WebSVN – Kolibri OS – Blame – /contrib/toolchain/gcc/5x/libstdc++-v3/libsupc++/cp-demangle.c

Rev	Author	Line No.	Line
6554	serge	1	/* Demangler for g++ V3 ABI.
		2	Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2014
		3	Free Software Foundation, Inc.
		4	Written by Ian Lance Taylor .
		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 .
		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
		107
		108	#ifdef HAVE_STDLIB_H
		109	#include
		110	#endif
		111	#ifdef HAVE_STRING_H
		112	#include
		113	#endif
		114
		115	#ifdef HAVE_ALLOCA_H
		116	# include
		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	#ifdef HAVE_LIMITS_H
		128	#include
		129	#endif
		130	#ifndef INT_MAX
		131	# define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
		132	#endif
		133
		134	#include "ansidecl.h"
		135	#include "libiberty.h"
		136	#include "demangle.h"
		137	#include "cp-demangle.h"
		138
		139	/* If IN_GLIBCPP_V3 is defined, some functions are made static. We
		140	also rename them via #define to avoid compiler errors when the
		141	static definition conflicts with the extern declaration in a header
		142	file. */
		143	#ifdef IN_GLIBCPP_V3
		144
		145	#define CP_STATIC_IF_GLIBCPP_V3 static
		146
		147	#define cplus_demangle_fill_name d_fill_name
		148	static int d_fill_name (struct demangle_component , const char , int);
		149
		150	#define cplus_demangle_fill_extended_operator d_fill_extended_operator
		151	static int
		152	d_fill_extended_operator (struct demangle_component *, int,
		153	struct demangle_component *);
		154
		155	#define cplus_demangle_fill_ctor d_fill_ctor
		156	static int
		157	d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
		158	struct demangle_component *);
		159
		160	#define cplus_demangle_fill_dtor d_fill_dtor
		161	static int
		162	d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
		163	struct demangle_component *);
		164
		165	#define cplus_demangle_mangled_name d_mangled_name
		166	static struct demangle_component d_mangled_name (struct d_info , int);
		167
		168	#define cplus_demangle_type d_type
		169	static struct demangle_component d_type (struct d_info );
		170
		171	#define cplus_demangle_print d_print
		172	static char d_print (int, const struct demangle_component , int, size_t *);
		173
		174	#define cplus_demangle_print_callback d_print_callback
		175	static int d_print_callback (int, const struct demangle_component *,
		176	demangle_callbackref, void *);
		177
		178	#define cplus_demangle_init_info d_init_info
		179	static void d_init_info (const char , int, size_t, struct d_info );
		180
		181	#else /* ! defined(IN_GLIBCPP_V3) */
		182	#define CP_STATIC_IF_GLIBCPP_V3
		183	#endif /* ! defined(IN_GLIBCPP_V3) */
		184
		185	/* See if the compiler supports dynamic arrays. */
		186
		187	#ifdef __GNUC__
		188	#define CP_DYNAMIC_ARRAYS
		189	#else
		190	#ifdef __STDC__
		191	#ifdef __STDC_VERSION__
		192	#if __STDC_VERSION__ >= 199901L
		193	#define CP_DYNAMIC_ARRAYS
		194	#endif /* __STDC__VERSION >= 199901L */
		195	#endif /* defined (__STDC_VERSION__) */
		196	#endif /* defined (__STDC__) */
		197	#endif /* ! defined (__GNUC__) */
		198
		199	/* We avoid pulling in the ctype tables, to prevent pulling in
		200	additional unresolved symbols when this code is used in a library.
		201	FIXME: Is this really a valid reason? This comes from the original
		202	V3 demangler code.
		203
		204	As of this writing this file has the following undefined references
		205	when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
		206	strcat, strlen. */
		207
		208	#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
		209	#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
		210	#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
		211
		212	/* The prefix prepended by GCC to an identifier represnting the
		213	anonymous namespace. */
		214	#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
		215	#define ANONYMOUS_NAMESPACE_PREFIX_LEN \
		216	(sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
		217
		218	/* Information we keep for the standard substitutions. */
		219
		220	struct d_standard_sub_info
		221	{
		222	/* The code for this substitution. */
		223	char code;
		224	/* The simple string it expands to. */
		225	const char *simple_expansion;
		226	/* The length of the simple expansion. */
		227	int simple_len;
		228	/* The results of a full, verbose, expansion. This is used when
		229	qualifying a constructor/destructor, or when in verbose mode. */
		230	const char *full_expansion;
		231	/* The length of the full expansion. */
		232	int full_len;
		233	/* What to set the last_name field of d_info to; NULL if we should
		234	not set it. This is only relevant when qualifying a
		235	constructor/destructor. */
		236	const char *set_last_name;
		237	/* The length of set_last_name. */
		238	int set_last_name_len;
		239	};
		240
		241	/* Accessors for subtrees of struct demangle_component. */
		242
		243	#define d_left(dc) ((dc)->u.s_binary.left)
		244	#define d_right(dc) ((dc)->u.s_binary.right)
		245
		246	/* A list of templates. This is used while printing. */
		247
		248	struct d_print_template
		249	{
		250	/* Next template on the list. */
		251	struct d_print_template *next;
		252	/* This template. */
		253	const struct demangle_component *template_decl;
		254	};
		255
		256	/* A list of type modifiers. This is used while printing. */
		257
		258	struct d_print_mod
		259	{
		260	/* Next modifier on the list. These are in the reverse of the order
		261	in which they appeared in the mangled string. */
		262	struct d_print_mod *next;
		263	/* The modifier. */
		264	const struct demangle_component *mod;
		265	/* Whether this modifier was printed. */
		266	int printed;
		267	/* The list of templates which applies to this modifier. */
		268	struct d_print_template *templates;
		269	};
		270
		271	/* We use these structures to hold information during printing. */
		272
		273	struct d_growable_string
		274	{
		275	/* Buffer holding the result. */
		276	char *buf;
		277	/* Current length of data in buffer. */
		278	size_t len;
		279	/* Allocated size of buffer. */
		280	size_t alc;
		281	/* Set to 1 if we had a memory allocation failure. */
		282	int allocation_failure;
		283	};
		284
		285	/* Stack of components, innermost first, used to avoid loops. */
		286
		287	struct d_component_stack
		288	{
		289	/* This component. */
		290	const struct demangle_component *dc;
		291	/* This component's parent. */
		292	const struct d_component_stack *parent;
		293	};
		294
		295	/* A demangle component and some scope captured when it was first
		296	traversed. */
		297
		298	struct d_saved_scope
		299	{
		300	/* The component whose scope this is. */
		301	const struct demangle_component *container;
		302	/* The list of templates, if any, that was current when this
		303	scope was captured. */
		304	struct d_print_template *templates;
		305	};
		306
		307	/* Checkpoint structure to allow backtracking. This holds copies
		308	of the fields of struct d_info that need to be restored
		309	if a trial parse needs to be backtracked over. */
		310
		311	struct d_info_checkpoint
		312	{
		313	const char *n;
		314	int next_comp;
		315	int next_sub;
		316	int did_subs;
		317	int expansion;
		318	};
		319
		320	enum { D_PRINT_BUFFER_LENGTH = 256 };
		321	struct d_print_info
		322	{
		323	/* Fixed-length allocated buffer for demangled data, flushed to the
		324	callback with a NUL termination once full. */
		325	char buf[D_PRINT_BUFFER_LENGTH];
		326	/* Current length of data in buffer. */
		327	size_t len;
		328	/* The last character printed, saved individually so that it survives
		329	any buffer flush. */
		330	char last_char;
		331	/* Callback function to handle demangled buffer flush. */
		332	demangle_callbackref callback;
		333	/* Opaque callback argument. */
		334	void *opaque;
		335	/* The current list of templates, if any. */
		336	struct d_print_template *templates;
		337	/* The current list of modifiers (e.g., pointer, reference, etc.),
		338	if any. */
		339	struct d_print_mod *modifiers;
		340	/* Set to 1 if we saw a demangling error. */
		341	int demangle_failure;
		342	/* The current index into any template argument packs we are using
		343	for printing. */
		344	int pack_index;
		345	/* Number of d_print_flush calls so far. */
		346	unsigned long int flush_count;
		347	/* Stack of components, innermost first, used to avoid loops. */
		348	const struct d_component_stack *component_stack;
		349	/* Array of saved scopes for evaluating substitutions. */
		350	struct d_saved_scope *saved_scopes;
		351	/* Index of the next unused saved scope in the above array. */
		352	int next_saved_scope;
		353	/* Number of saved scopes in the above array. */
		354	int num_saved_scopes;
		355	/* Array of templates for saving into scopes. */
		356	struct d_print_template *copy_templates;
		357	/* Index of the next unused copy template in the above array. */
		358	int next_copy_template;
		359	/* Number of copy templates in the above array. */
		360	int num_copy_templates;
		361	/* The nearest enclosing template, if any. */
		362	const struct demangle_component *current_template;
		363	};
		364
		365	#ifdef CP_DEMANGLE_DEBUG
		366	static void d_dump (struct demangle_component *, int);
		367	#endif
		368
		369	static struct demangle_component *
		370	d_make_empty (struct d_info *);
		371
		372	static struct demangle_component *
		373	d_make_comp (struct d_info *, enum demangle_component_type,
		374	struct demangle_component *,
		375	struct demangle_component *);
		376
		377	static struct demangle_component *
		378	d_make_name (struct d_info , const char , int);
		379
		380	static struct demangle_component *
		381	d_make_demangle_mangled_name (struct d_info , const char );
		382
		383	static struct demangle_component *
		384	d_make_builtin_type (struct d_info *,
		385	const struct demangle_builtin_type_info *);
		386
		387	static struct demangle_component *
		388	d_make_operator (struct d_info *,
		389	const struct demangle_operator_info *);
		390
		391	static struct demangle_component *
		392	d_make_extended_operator (struct d_info *, int,
		393	struct demangle_component *);
		394
		395	static struct demangle_component *
		396	d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
		397	struct demangle_component *);
		398
		399	static struct demangle_component *
		400	d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
		401	struct demangle_component *);
		402
		403	static struct demangle_component *
		404	d_make_template_param (struct d_info *, int);
		405
		406	static struct demangle_component *
		407	d_make_sub (struct d_info , const char , int);
		408
		409	static int
		410	has_return_type (struct demangle_component *);
		411
		412	static int
		413	is_ctor_dtor_or_conversion (struct demangle_component *);
		414
		415	static struct demangle_component d_encoding (struct d_info , int);
		416
		417	static struct demangle_component d_name (struct d_info );
		418
		419	static struct demangle_component d_nested_name (struct d_info );
		420
		421	static struct demangle_component d_prefix (struct d_info );
		422
		423	static struct demangle_component d_unqualified_name (struct d_info );
		424
		425	static struct demangle_component d_source_name (struct d_info );
		426
		427	static int d_number (struct d_info *);
		428
		429	static struct demangle_component d_identifier (struct d_info , int);
		430
		431	static struct demangle_component d_operator_name (struct d_info );
		432
		433	static struct demangle_component d_special_name (struct d_info );
		434
		435	static int d_call_offset (struct d_info *, int);
		436
		437	static struct demangle_component d_ctor_dtor_name (struct d_info );
		438
		439	static struct demangle_component **
		440	d_cv_qualifiers (struct d_info , struct demangle_component *, int);
		441
		442	static struct demangle_component *
		443	d_ref_qualifier (struct d_info , struct demangle_component );
		444
		445	static struct demangle_component *
		446	d_function_type (struct d_info *);
		447
		448	static struct demangle_component *
		449	d_bare_function_type (struct d_info *, int);
		450
		451	static struct demangle_component *
		452	d_class_enum_type (struct d_info *);
		453
		454	static struct demangle_component d_array_type (struct d_info );
		455
		456	static struct demangle_component d_vector_type (struct d_info );
		457
		458	static struct demangle_component *
		459	d_pointer_to_member_type (struct d_info *);
		460
		461	static struct demangle_component *
		462	d_template_param (struct d_info *);
		463
		464	static struct demangle_component d_template_args (struct d_info );
		465
		466	static struct demangle_component *
		467	d_template_arg (struct d_info *);
		468
		469	static struct demangle_component d_expression (struct d_info );
		470
		471	static struct demangle_component d_expr_primary (struct d_info );
		472
		473	static struct demangle_component d_local_name (struct d_info );
		474
		475	static int d_discriminator (struct d_info *);
		476
		477	static struct demangle_component d_lambda (struct d_info );
		478
		479	static struct demangle_component d_unnamed_type (struct d_info );
		480
		481	static struct demangle_component *
		482	d_clone_suffix (struct d_info , struct demangle_component );
		483
		484	static int
		485	d_add_substitution (struct d_info , struct demangle_component );
		486
		487	static struct demangle_component d_substitution (struct d_info , int);
		488
		489	static void d_checkpoint (struct d_info , struct d_info_checkpoint );
		490
		491	static void d_backtrack (struct d_info , struct d_info_checkpoint );
		492
		493	static void d_growable_string_init (struct d_growable_string *, size_t);
		494
		495	static inline void
		496	d_growable_string_resize (struct d_growable_string *, size_t);
		497
		498	static inline void
		499	d_growable_string_append_buffer (struct d_growable_string *,
		500	const char *, size_t);
		501	static void
		502	d_growable_string_callback_adapter (const char , size_t, void );
		503
		504	static void
		505	d_print_init (struct d_print_info , demangle_callbackref, void ,
		506	const struct demangle_component *);
		507
		508	static inline void d_print_error (struct d_print_info *);
		509
		510	static inline int d_print_saw_error (struct d_print_info *);
		511
		512	static inline void d_print_flush (struct d_print_info *);
		513
		514	static inline void d_append_char (struct d_print_info *, char);
		515
		516	static inline void d_append_buffer (struct d_print_info *,
		517	const char *, size_t);
		518
		519	static inline void d_append_string (struct d_print_info , const char );
		520
		521	static inline char d_last_char (struct d_print_info *);
		522
		523	static void
		524	d_print_comp (struct d_print_info , int, const struct demangle_component );
		525
		526	static void
		527	d_print_java_identifier (struct d_print_info , const char , int);
		528
		529	static void
		530	d_print_mod_list (struct d_print_info , int, struct d_print_mod , int);
		531
		532	static void
		533	d_print_mod (struct d_print_info , int, const struct demangle_component );
		534
		535	static void
		536	d_print_function_type (struct d_print_info *, int,
		537	const struct demangle_component *,
		538	struct d_print_mod *);
		539
		540	static void
		541	d_print_array_type (struct d_print_info *, int,
		542	const struct demangle_component *,
		543	struct d_print_mod *);
		544
		545	static void
		546	d_print_expr_op (struct d_print_info , int, const struct demangle_component );
		547
		548	static void d_print_cast (struct d_print_info *, int,
		549	const struct demangle_component *);
		550	static void d_print_conversion (struct d_print_info *, int,
		551	const struct demangle_component *);
		552
		553	static int d_demangle_callback (const char *, int,
		554	demangle_callbackref, void *);
		555	static char d_demangle (const char , int, size_t *);
		556
		557	#ifdef CP_DEMANGLE_DEBUG
		558
		559	static void
		560	d_dump (struct demangle_component *dc, int indent)
		561	{
		562	int i;
		563
		564	if (dc == NULL)
		565	{
		566	if (indent == 0)
		567	printf ("failed demangling\n");
		568	return;
		569	}
		570
		571	for (i = 0; i < indent; ++i)
		572	putchar (' ');
		573
		574	switch (dc->type)
		575	{
		576	case DEMANGLE_COMPONENT_NAME:
		577	printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
		578	return;
		579	case DEMANGLE_COMPONENT_TAGGED_NAME:
		580	printf ("tagged name\n");
		581	d_dump (dc->u.s_binary.left, indent + 2);
		582	d_dump (dc->u.s_binary.right, indent + 2);
		583	return;
		584	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
		585	printf ("template parameter %ld\n", dc->u.s_number.number);
		586	return;
		587	case DEMANGLE_COMPONENT_FUNCTION_PARAM:
		588	printf ("function parameter %ld\n", dc->u.s_number.number);
		589	return;
		590	case DEMANGLE_COMPONENT_CTOR:
		591	printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
		592	d_dump (dc->u.s_ctor.name, indent + 2);
		593	return;
		594	case DEMANGLE_COMPONENT_DTOR:
		595	printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
		596	d_dump (dc->u.s_dtor.name, indent + 2);
		597	return;
		598	case DEMANGLE_COMPONENT_SUB_STD:
		599	printf ("standard substitution %s\n", dc->u.s_string.string);
		600	return;
		601	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
		602	printf ("builtin type %s\n", dc->u.s_builtin.type->name);
		603	return;
		604	case DEMANGLE_COMPONENT_OPERATOR:
		605	printf ("operator %s\n", dc->u.s_operator.op->name);
		606	return;
		607	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
		608	printf ("extended operator with %d args\n",
		609	dc->u.s_extended_operator.args);
		610	d_dump (dc->u.s_extended_operator.name, indent + 2);
		611	return;
		612
		613	case DEMANGLE_COMPONENT_QUAL_NAME:
		614	printf ("qualified name\n");
		615	break;
		616	case DEMANGLE_COMPONENT_LOCAL_NAME:
		617	printf ("local name\n");
		618	break;
		619	case DEMANGLE_COMPONENT_TYPED_NAME:
		620	printf ("typed name\n");
		621	break;
		622	case DEMANGLE_COMPONENT_TEMPLATE:
		623	printf ("template\n");
		624	break;
		625	case DEMANGLE_COMPONENT_VTABLE:
		626	printf ("vtable\n");
		627	break;
		628	case DEMANGLE_COMPONENT_VTT:
		629	printf ("VTT\n");
		630	break;
		631	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
		632	printf ("construction vtable\n");
		633	break;
		634	case DEMANGLE_COMPONENT_TYPEINFO:
		635	printf ("typeinfo\n");
		636	break;
		637	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
		638	printf ("typeinfo name\n");
		639	break;
		640	case DEMANGLE_COMPONENT_TYPEINFO_FN:
		641	printf ("typeinfo function\n");
		642	break;
		643	case DEMANGLE_COMPONENT_THUNK:
		644	printf ("thunk\n");
		645	break;
		646	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
		647	printf ("virtual thunk\n");
		648	break;
		649	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
		650	printf ("covariant thunk\n");
		651	break;
		652	case DEMANGLE_COMPONENT_JAVA_CLASS:
		653	printf ("java class\n");
		654	break;
		655	case DEMANGLE_COMPONENT_GUARD:
		656	printf ("guard\n");
		657	break;
		658	case DEMANGLE_COMPONENT_REFTEMP:
		659	printf ("reference temporary\n");
		660	break;
		661	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
		662	printf ("hidden alias\n");
		663	break;
		664	case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
		665	printf ("transaction clone\n");
		666	break;
		667	case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
		668	printf ("non-transaction clone\n");
		669	break;
		670	case DEMANGLE_COMPONENT_RESTRICT:
		671	printf ("restrict\n");
		672	break;
		673	case DEMANGLE_COMPONENT_VOLATILE:
		674	printf ("volatile\n");
		675	break;
		676	case DEMANGLE_COMPONENT_CONST:
		677	printf ("const\n");
		678	break;
		679	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		680	printf ("restrict this\n");
		681	break;
		682	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		683	printf ("volatile this\n");
		684	break;
		685	case DEMANGLE_COMPONENT_CONST_THIS:
		686	printf ("const this\n");
		687	break;
		688	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		689	printf ("reference this\n");
		690	break;
		691	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		692	printf ("rvalue reference this\n");
		693	break;
		694	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		695	printf ("vendor type qualifier\n");
		696	break;
		697	case DEMANGLE_COMPONENT_POINTER:
		698	printf ("pointer\n");
		699	break;
		700	case DEMANGLE_COMPONENT_REFERENCE:
		701	printf ("reference\n");
		702	break;
		703	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
		704	printf ("rvalue reference\n");
		705	break;
		706	case DEMANGLE_COMPONENT_COMPLEX:
		707	printf ("complex\n");
		708	break;
		709	case DEMANGLE_COMPONENT_IMAGINARY:
		710	printf ("imaginary\n");
		711	break;
		712	case DEMANGLE_COMPONENT_VENDOR_TYPE:
		713	printf ("vendor type\n");
		714	break;
		715	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
		716	printf ("function type\n");
		717	break;
		718	case DEMANGLE_COMPONENT_ARRAY_TYPE:
		719	printf ("array type\n");
		720	break;
		721	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		722	printf ("pointer to member type\n");
		723	break;
		724	case DEMANGLE_COMPONENT_FIXED_TYPE:
		725	printf ("fixed-point type, accum? %d, sat? %d\n",
		726	dc->u.s_fixed.accum, dc->u.s_fixed.sat);
		727	d_dump (dc->u.s_fixed.length, indent + 2);
		728	break;
		729	case DEMANGLE_COMPONENT_ARGLIST:
		730	printf ("argument list\n");
		731	break;
		732	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
		733	printf ("template argument list\n");
		734	break;
		735	case DEMANGLE_COMPONENT_INITIALIZER_LIST:
		736	printf ("initializer list\n");
		737	break;
		738	case DEMANGLE_COMPONENT_CAST:
		739	printf ("cast\n");
		740	break;
		741	case DEMANGLE_COMPONENT_CONVERSION:
		742	printf ("conversion operator\n");
		743	break;
		744	case DEMANGLE_COMPONENT_NULLARY:
		745	printf ("nullary operator\n");
		746	break;
		747	case DEMANGLE_COMPONENT_UNARY:
		748	printf ("unary operator\n");
		749	break;
		750	case DEMANGLE_COMPONENT_BINARY:
		751	printf ("binary operator\n");
		752	break;
		753	case DEMANGLE_COMPONENT_BINARY_ARGS:
		754	printf ("binary operator arguments\n");
		755	break;
		756	case DEMANGLE_COMPONENT_TRINARY:
		757	printf ("trinary operator\n");
		758	break;
		759	case DEMANGLE_COMPONENT_TRINARY_ARG1:
		760	printf ("trinary operator arguments 1\n");
		761	break;
		762	case DEMANGLE_COMPONENT_TRINARY_ARG2:
		763	printf ("trinary operator arguments 1\n");
		764	break;
		765	case DEMANGLE_COMPONENT_LITERAL:
		766	printf ("literal\n");
		767	break;
		768	case DEMANGLE_COMPONENT_LITERAL_NEG:
		769	printf ("negative literal\n");
		770	break;
		771	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
		772	printf ("java resource\n");
		773	break;
		774	case DEMANGLE_COMPONENT_COMPOUND_NAME:
		775	printf ("compound name\n");
		776	break;
		777	case DEMANGLE_COMPONENT_CHARACTER:
		778	printf ("character '%c'\n", dc->u.s_character.character);
		779	return;
		780	case DEMANGLE_COMPONENT_NUMBER:
		781	printf ("number %ld\n", dc->u.s_number.number);
		782	return;
		783	case DEMANGLE_COMPONENT_DECLTYPE:
		784	printf ("decltype\n");
		785	break;
		786	case DEMANGLE_COMPONENT_PACK_EXPANSION:
		787	printf ("pack expansion\n");
		788	break;
		789	case DEMANGLE_COMPONENT_TLS_INIT:
		790	printf ("tls init function\n");
		791	break;
		792	case DEMANGLE_COMPONENT_TLS_WRAPPER:
		793	printf ("tls wrapper function\n");
		794	break;
		795	case DEMANGLE_COMPONENT_DEFAULT_ARG:
		796	printf ("default argument %d\n", dc->u.s_unary_num.num);
		797	d_dump (dc->u.s_unary_num.sub, indent+2);
		798	return;
		799	case DEMANGLE_COMPONENT_LAMBDA:
		800	printf ("lambda %d\n", dc->u.s_unary_num.num);
		801	d_dump (dc->u.s_unary_num.sub, indent+2);
		802	return;
		803	}
		804
		805	d_dump (d_left (dc), indent + 2);
		806	d_dump (d_right (dc), indent + 2);
		807	}
		808
		809	#endif /* CP_DEMANGLE_DEBUG */
		810
		811	/* Fill in a DEMANGLE_COMPONENT_NAME. */
		812
		813	CP_STATIC_IF_GLIBCPP_V3
		814	int
		815	cplus_demangle_fill_name (struct demangle_component p, const char s, int len)
		816	{
		817	if (p == NULL \|\| s == NULL \|\| len == 0)
		818	return 0;
		819	p->type = DEMANGLE_COMPONENT_NAME;
		820	p->u.s_name.s = s;
		821	p->u.s_name.len = len;
		822	return 1;
		823	}
		824
		825	/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
		826
		827	CP_STATIC_IF_GLIBCPP_V3
		828	int
		829	cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
		830	struct demangle_component *name)
		831	{
		832	if (p == NULL \|\| args < 0 \|\| name == NULL)
		833	return 0;
		834	p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
		835	p->u.s_extended_operator.args = args;
		836	p->u.s_extended_operator.name = name;
		837	return 1;
		838	}
		839
		840	/* Fill in a DEMANGLE_COMPONENT_CTOR. */
		841
		842	CP_STATIC_IF_GLIBCPP_V3
		843	int
		844	cplus_demangle_fill_ctor (struct demangle_component *p,
		845	enum gnu_v3_ctor_kinds kind,
		846	struct demangle_component *name)
		847	{
		848	if (p == NULL
		849	\|\| name == NULL
		850	\|\| (int) kind < gnu_v3_complete_object_ctor
		851	\|\| (int) kind > gnu_v3_object_ctor_group)
		852	return 0;
		853	p->type = DEMANGLE_COMPONENT_CTOR;
		854	p->u.s_ctor.kind = kind;
		855	p->u.s_ctor.name = name;
		856	return 1;
		857	}
		858
		859	/* Fill in a DEMANGLE_COMPONENT_DTOR. */
		860
		861	CP_STATIC_IF_GLIBCPP_V3
		862	int
		863	cplus_demangle_fill_dtor (struct demangle_component *p,
		864	enum gnu_v3_dtor_kinds kind,
		865	struct demangle_component *name)
		866	{
		867	if (p == NULL
		868	\|\| name == NULL
		869	\|\| (int) kind < gnu_v3_deleting_dtor
		870	\|\| (int) kind > gnu_v3_object_dtor_group)
		871	return 0;
		872	p->type = DEMANGLE_COMPONENT_DTOR;
		873	p->u.s_dtor.kind = kind;
		874	p->u.s_dtor.name = name;
		875	return 1;
		876	}
		877
		878	/* Add a new component. */
		879
		880	static struct demangle_component *
		881	d_make_empty (struct d_info *di)
		882	{
		883	struct demangle_component *p;
		884
		885	if (di->next_comp >= di->num_comps)
		886	return NULL;
		887	p = &di->comps[di->next_comp];
		888	++di->next_comp;
		889	return p;
		890	}
		891
		892	/* Add a new generic component. */
		893
		894	static struct demangle_component *
		895	d_make_comp (struct d_info *di, enum demangle_component_type type,
		896	struct demangle_component *left,
		897	struct demangle_component *right)
		898	{
		899	struct demangle_component *p;
		900
		901	/* We check for errors here. A typical error would be a NULL return
		902	from a subroutine. We catch those here, and return NULL
		903	upward. */
		904	switch (type)
		905	{
		906	/* These types require two parameters. */
		907	case DEMANGLE_COMPONENT_QUAL_NAME:
		908	case DEMANGLE_COMPONENT_LOCAL_NAME:
		909	case DEMANGLE_COMPONENT_TYPED_NAME:
		910	case DEMANGLE_COMPONENT_TAGGED_NAME:
		911	case DEMANGLE_COMPONENT_TEMPLATE:
		912	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
		913	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		914	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		915	case DEMANGLE_COMPONENT_UNARY:
		916	case DEMANGLE_COMPONENT_BINARY:
		917	case DEMANGLE_COMPONENT_BINARY_ARGS:
		918	case DEMANGLE_COMPONENT_TRINARY:
		919	case DEMANGLE_COMPONENT_TRINARY_ARG1:
		920	case DEMANGLE_COMPONENT_LITERAL:
		921	case DEMANGLE_COMPONENT_LITERAL_NEG:
		922	case DEMANGLE_COMPONENT_COMPOUND_NAME:
		923	case DEMANGLE_COMPONENT_VECTOR_TYPE:
		924	case DEMANGLE_COMPONENT_CLONE:
		925	if (left == NULL \|\| right == NULL)
		926	return NULL;
		927	break;
		928
		929	/* These types only require one parameter. */
		930	case DEMANGLE_COMPONENT_VTABLE:
		931	case DEMANGLE_COMPONENT_VTT:
		932	case DEMANGLE_COMPONENT_TYPEINFO:
		933	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
		934	case DEMANGLE_COMPONENT_TYPEINFO_FN:
		935	case DEMANGLE_COMPONENT_THUNK:
		936	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
		937	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
		938	case DEMANGLE_COMPONENT_JAVA_CLASS:
		939	case DEMANGLE_COMPONENT_GUARD:
		940	case DEMANGLE_COMPONENT_TLS_INIT:
		941	case DEMANGLE_COMPONENT_TLS_WRAPPER:
		942	case DEMANGLE_COMPONENT_REFTEMP:
		943	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
		944	case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
		945	case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
		946	case DEMANGLE_COMPONENT_POINTER:
		947	case DEMANGLE_COMPONENT_REFERENCE:
		948	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
		949	case DEMANGLE_COMPONENT_COMPLEX:
		950	case DEMANGLE_COMPONENT_IMAGINARY:
		951	case DEMANGLE_COMPONENT_VENDOR_TYPE:
		952	case DEMANGLE_COMPONENT_CAST:
		953	case DEMANGLE_COMPONENT_CONVERSION:
		954	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
		955	case DEMANGLE_COMPONENT_DECLTYPE:
		956	case DEMANGLE_COMPONENT_PACK_EXPANSION:
		957	case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
		958	case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
		959	case DEMANGLE_COMPONENT_NULLARY:
		960	case DEMANGLE_COMPONENT_TRINARY_ARG2:
		961	if (left == NULL)
		962	return NULL;
		963	break;
		964
		965	/* This needs a right parameter, but the left parameter can be
		966	empty. */
		967	case DEMANGLE_COMPONENT_ARRAY_TYPE:
		968	case DEMANGLE_COMPONENT_INITIALIZER_LIST:
		969	if (right == NULL)
		970	return NULL;
		971	break;
		972
		973	/* These are allowed to have no parameters--in some cases they
		974	will be filled in later. */
		975	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
		976	case DEMANGLE_COMPONENT_RESTRICT:
		977	case DEMANGLE_COMPONENT_VOLATILE:
		978	case DEMANGLE_COMPONENT_CONST:
		979	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		980	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		981	case DEMANGLE_COMPONENT_CONST_THIS:
		982	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		983	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		984	case DEMANGLE_COMPONENT_ARGLIST:
		985	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
		986	break;
		987
		988	/* Other types should not be seen here. */
		989	default:
		990	return NULL;
		991	}
		992
		993	p = d_make_empty (di);
		994	if (p != NULL)
		995	{
		996	p->type = type;
		997	p->u.s_binary.left = left;
		998	p->u.s_binary.right = right;
		999	}
		1000	return p;
		1001	}
		1002
		1003	/* Add a new demangle mangled name component. */
		1004
		1005	static struct demangle_component *
		1006	d_make_demangle_mangled_name (struct d_info di, const char s)
		1007	{
		1008	if (d_peek_char (di) != '_' \|\| d_peek_next_char (di) != 'Z')
		1009	return d_make_name (di, s, strlen (s));
		1010	d_advance (di, 2);
		1011	return d_encoding (di, 0);
		1012	}
		1013
		1014	/* Add a new name component. */
		1015
		1016	static struct demangle_component *
		1017	d_make_name (struct d_info di, const char s, int len)
		1018	{
		1019	struct demangle_component *p;
		1020
		1021	p = d_make_empty (di);
		1022	if (! cplus_demangle_fill_name (p, s, len))
		1023	return NULL;
		1024	return p;
		1025	}
		1026
		1027	/* Add a new builtin type component. */
		1028
		1029	static struct demangle_component *
		1030	d_make_builtin_type (struct d_info *di,
		1031	const struct demangle_builtin_type_info *type)
		1032	{
		1033	struct demangle_component *p;
		1034
		1035	if (type == NULL)
		1036	return NULL;
		1037	p = d_make_empty (di);
		1038	if (p != NULL)
		1039	{
		1040	p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
		1041	p->u.s_builtin.type = type;
		1042	}
		1043	return p;
		1044	}
		1045
		1046	/* Add a new operator component. */
		1047
		1048	static struct demangle_component *
		1049	d_make_operator (struct d_info di, const struct demangle_operator_info op)
		1050	{
		1051	struct demangle_component *p;
		1052
		1053	p = d_make_empty (di);
		1054	if (p != NULL)
		1055	{
		1056	p->type = DEMANGLE_COMPONENT_OPERATOR;
		1057	p->u.s_operator.op = op;
		1058	}
		1059	return p;
		1060	}
		1061
		1062	/* Add a new extended operator component. */
		1063
		1064	static struct demangle_component *
		1065	d_make_extended_operator (struct d_info *di, int args,
		1066	struct demangle_component *name)
		1067	{
		1068	struct demangle_component *p;
		1069
		1070	p = d_make_empty (di);
		1071	if (! cplus_demangle_fill_extended_operator (p, args, name))
		1072	return NULL;
		1073	return p;
		1074	}
		1075
		1076	static struct demangle_component *
		1077	d_make_default_arg (struct d_info *di, int num,
		1078	struct demangle_component *sub)
		1079	{
		1080	struct demangle_component *p = d_make_empty (di);
		1081	if (p)
		1082	{
		1083	p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
		1084	p->u.s_unary_num.num = num;
		1085	p->u.s_unary_num.sub = sub;
		1086	}
		1087	return p;
		1088	}
		1089
		1090	/* Add a new constructor component. */
		1091
		1092	static struct demangle_component *
		1093	d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
		1094	struct demangle_component *name)
		1095	{
		1096	struct demangle_component *p;
		1097
		1098	p = d_make_empty (di);
		1099	if (! cplus_demangle_fill_ctor (p, kind, name))
		1100	return NULL;
		1101	return p;
		1102	}
		1103
		1104	/* Add a new destructor component. */
		1105
		1106	static struct demangle_component *
		1107	d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
		1108	struct demangle_component *name)
		1109	{
		1110	struct demangle_component *p;
		1111
		1112	p = d_make_empty (di);
		1113	if (! cplus_demangle_fill_dtor (p, kind, name))
		1114	return NULL;
		1115	return p;
		1116	}
		1117
		1118	/* Add a new template parameter. */
		1119
		1120	static struct demangle_component *
		1121	d_make_template_param (struct d_info *di, int i)
		1122	{
		1123	struct demangle_component *p;
		1124
		1125	p = d_make_empty (di);
		1126	if (p != NULL)
		1127	{
		1128	p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
		1129	p->u.s_number.number = i;
		1130	}
		1131	return p;
		1132	}
		1133
		1134	/* Add a new function parameter. */
		1135
		1136	static struct demangle_component *
		1137	d_make_function_param (struct d_info *di, int i)
		1138	{
		1139	struct demangle_component *p;
		1140
		1141	p = d_make_empty (di);
		1142	if (p != NULL)
		1143	{
		1144	p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
		1145	p->u.s_number.number = i;
		1146	}
		1147	return p;
		1148	}
		1149
		1150	/* Add a new standard substitution component. */
		1151
		1152	static struct demangle_component *
		1153	d_make_sub (struct d_info di, const char name, int len)
		1154	{
		1155	struct demangle_component *p;
		1156
		1157	p = d_make_empty (di);
		1158	if (p != NULL)
		1159	{
		1160	p->type = DEMANGLE_COMPONENT_SUB_STD;
		1161	p->u.s_string.string = name;
		1162	p->u.s_string.len = len;
		1163	}
		1164	return p;
		1165	}
		1166
		1167	/* ::= _Z []*
		1168
		1169	TOP_LEVEL is non-zero when called at the top level. */
		1170
		1171	CP_STATIC_IF_GLIBCPP_V3
		1172	struct demangle_component *
		1173	cplus_demangle_mangled_name (struct d_info *di, int top_level)
		1174	{
		1175	struct demangle_component *p;
		1176
		1177	if (! d_check_char (di, '_')
		1178	/* Allow missing _ if not at toplevel to work around a
		1179	bug in G++ abi-version=2 mangling; see the comment in
		1180	write_template_arg. */
		1181	&& top_level)
		1182	return NULL;
		1183	if (! d_check_char (di, 'Z'))
		1184	return NULL;
		1185	p = d_encoding (di, top_level);
		1186
		1187	/* If at top level and parsing parameters, check for a clone
		1188	suffix. */
		1189	if (top_level && (di->options & DMGL_PARAMS) != 0)
		1190	while (d_peek_char (di) == '.'
		1191	&& (IS_LOWER (d_peek_next_char (di))
		1192	\|\| d_peek_next_char (di) == '_'
		1193	\|\| IS_DIGIT (d_peek_next_char (di))))
		1194	p = d_clone_suffix (di, p);
		1195
		1196	return p;
		1197	}
		1198
		1199	/* Return whether a function should have a return type. The argument
		1200	is the function name, which may be qualified in various ways. The
		1201	rules are that template functions have return types with some
		1202	exceptions, function types which are not part of a function name
		1203	mangling have return types with some exceptions, and non-template
		1204	function names do not have return types. The exceptions are that
		1205	constructors, destructors, and conversion operators do not have
		1206	return types. */
		1207
		1208	static int
		1209	has_return_type (struct demangle_component *dc)
		1210	{
		1211	if (dc == NULL)
		1212	return 0;
		1213	switch (dc->type)
		1214	{
		1215	default:
		1216	return 0;
		1217	case DEMANGLE_COMPONENT_TEMPLATE:
		1218	return ! is_ctor_dtor_or_conversion (d_left (dc));
		1219	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		1220	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		1221	case DEMANGLE_COMPONENT_CONST_THIS:
		1222	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		1223	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		1224	return has_return_type (d_left (dc));
		1225	}
		1226	}
		1227
		1228	/* Return whether a name is a constructor, a destructor, or a
		1229	conversion operator. */
		1230
		1231	static int
		1232	is_ctor_dtor_or_conversion (struct demangle_component *dc)
		1233	{
		1234	if (dc == NULL)
		1235	return 0;
		1236	switch (dc->type)
		1237	{
		1238	default:
		1239	return 0;
		1240	case DEMANGLE_COMPONENT_QUAL_NAME:
		1241	case DEMANGLE_COMPONENT_LOCAL_NAME:
		1242	return is_ctor_dtor_or_conversion (d_right (dc));
		1243	case DEMANGLE_COMPONENT_CTOR:
		1244	case DEMANGLE_COMPONENT_DTOR:
		1245	case DEMANGLE_COMPONENT_CONVERSION:
		1246	return 1;
		1247	}
		1248	}
		1249
		1250	/* ::= <(function) name>
		1251	::= <(data) name>
		1252	::=
		1253
		1254	TOP_LEVEL is non-zero when called at the top level, in which case
		1255	if DMGL_PARAMS is not set we do not demangle the function
		1256	parameters. We only set this at the top level, because otherwise
		1257	we would not correctly demangle names in local scopes. */
		1258
		1259	static struct demangle_component *
		1260	d_encoding (struct d_info *di, int top_level)
		1261	{
		1262	char peek = d_peek_char (di);
		1263
		1264	if (peek == 'G' \|\| peek == 'T')
		1265	return d_special_name (di);
		1266	else
		1267	{
		1268	struct demangle_component *dc;
		1269
		1270	dc = d_name (di);
		1271
		1272	if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
		1273	{
		1274	/* Strip off any initial CV-qualifiers, as they really apply
		1275	to the `this' parameter, and they were not output by the
		1276	v2 demangler without DMGL_PARAMS. */
		1277	while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
		1278	\|\| dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
		1279	\|\| dc->type == DEMANGLE_COMPONENT_CONST_THIS
		1280	\|\| dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
		1281	\|\| dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
		1282	dc = d_left (dc);
		1283
		1284	/* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
		1285	there may be CV-qualifiers on its right argument which
		1286	really apply here; this happens when parsing a class
		1287	which is local to a function. */
		1288	if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
		1289	{
		1290	struct demangle_component *dcr;
		1291
		1292	dcr = d_right (dc);
		1293	while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
		1294	\|\| dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
		1295	\|\| dcr->type == DEMANGLE_COMPONENT_CONST_THIS
		1296	\|\| dcr->type == DEMANGLE_COMPONENT_REFERENCE_THIS
		1297	\|\| dcr->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
		1298	dcr = d_left (dcr);
		1299	dc->u.s_binary.right = dcr;
		1300	}
		1301
		1302	return dc;
		1303	}
		1304
		1305	peek = d_peek_char (di);
		1306	if (dc == NULL \|\| peek == '\0' \|\| peek == 'E')
		1307	return dc;
		1308	return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
		1309	d_bare_function_type (di, has_return_type (dc)));
		1310	}
		1311	}
		1312
		1313	/* ::= B */
		1314
		1315	static struct demangle_component *
		1316	d_abi_tags (struct d_info di, struct demangle_component dc)
		1317	{
		1318	char peek;
		1319	while (peek = d_peek_char (di),
		1320	peek == 'B')
		1321	{
		1322	struct demangle_component *tag;
		1323	d_advance (di, 1);
		1324	tag = d_source_name (di);
		1325	dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
		1326	}
		1327	return dc;
		1328	}
		1329
		1330	/* ::=
		1331	::=
		1332	::=
		1333	::=
		1334
		1335	::=
		1336	::= St
		1337
		1338	::=
		1339	::=
		1340	*/
		1341
		1342	static struct demangle_component *
		1343	d_name (struct d_info *di)
		1344	{
		1345	char peek = d_peek_char (di);
		1346	struct demangle_component *dc;
		1347
		1348	switch (peek)
		1349	{
		1350	case 'N':
		1351	return d_nested_name (di);
		1352
		1353	case 'Z':
		1354	return d_local_name (di);
		1355
		1356	case 'U':
		1357	return d_unqualified_name (di);
		1358
		1359	case 'S':
		1360	{
		1361	int subst;
		1362
		1363	if (d_peek_next_char (di) != 't')
		1364	{
		1365	dc = d_substitution (di, 0);
		1366	subst = 1;
		1367	}
		1368	else
		1369	{
		1370	d_advance (di, 2);
		1371	dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
		1372	d_make_name (di, "std", 3),
		1373	d_unqualified_name (di));
		1374	di->expansion += 3;
		1375	subst = 0;
		1376	}
		1377
		1378	if (d_peek_char (di) != 'I')
		1379	{
		1380	/* The grammar does not permit this case to occur if we
		1381	called d_substitution() above (i.e., subst == 1). We
		1382	don't bother to check. */
		1383	}
		1384	else
		1385	{
		1386	/* This is , which means that we just saw
		1387	, which is a substitution
		1388	candidate if we didn't just get it from a
		1389	substitution. */
		1390	if (! subst)
		1391	{
		1392	if (! d_add_substitution (di, dc))
		1393	return NULL;
		1394	}
		1395	dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
		1396	d_template_args (di));
		1397	}
		1398
		1399	return dc;
		1400	}
		1401
		1402	case 'L':
		1403	default:
		1404	dc = d_unqualified_name (di);
		1405	if (d_peek_char (di) == 'I')
		1406	{
		1407	/* This is , which means that we just saw
		1408	, which is a substitution
		1409	candidate. */
		1410	if (! d_add_substitution (di, dc))
		1411	return NULL;
		1412	dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
		1413	d_template_args (di));
		1414	}
		1415	return dc;
		1416	}
		1417	}
		1418
		1419	/* ::= N [] [] E
		1420	::= N [] [] E
		1421	*/
		1422
		1423	static struct demangle_component *
		1424	d_nested_name (struct d_info *di)
		1425	{
		1426	struct demangle_component *ret;
		1427	struct demangle_component **pret;
		1428	struct demangle_component *rqual;
		1429
		1430	if (! d_check_char (di, 'N'))
		1431	return NULL;
		1432
		1433	pret = d_cv_qualifiers (di, &ret, 1);
		1434	if (pret == NULL)
		1435	return NULL;
		1436
		1437	/* Parse the ref-qualifier now and then attach it
		1438	once we have something to attach it to. */
		1439	rqual = d_ref_qualifier (di, NULL);
		1440
		1441	*pret = d_prefix (di);
		1442	if (*pret == NULL)
		1443	return NULL;
		1444
		1445	if (rqual)
		1446	{
		1447	d_left (rqual) = ret;
		1448	ret = rqual;
		1449	}
		1450
		1451	if (! d_check_char (di, 'E'))
		1452	return NULL;
		1453
		1454	return ret;
		1455	}
		1456
		1457	/* ::=
		1458	::=
		1459	::=
		1460	::=
		1461	::=
		1462	::=
		1463
		1464	::= <(template) unqualified-name>
		1465	::=
		1466	::=
		1467	*/
		1468
		1469	static struct demangle_component *
		1470	d_prefix (struct d_info *di)
		1471	{
		1472	struct demangle_component *ret = NULL;
		1473
		1474	while (1)
		1475	{
		1476	char peek;
		1477	enum demangle_component_type comb_type;
		1478	struct demangle_component *dc;
		1479
		1480	peek = d_peek_char (di);
		1481	if (peek == '\0')
		1482	return NULL;
		1483
		1484	/* The older code accepts a here, but I don't see
		1485	that in the grammar. The older code does not accept a
		1486	here. */
		1487
		1488	comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
		1489	if (peek == 'D')
		1490	{
		1491	char peek2 = d_peek_next_char (di);
		1492	if (peek2 == 'T' \|\| peek2 == 't')
		1493	/* Decltype. */
		1494	dc = cplus_demangle_type (di);
		1495	else
		1496	/* Destructor name. */
		1497	dc = d_unqualified_name (di);
		1498	}
		1499	else if (IS_DIGIT (peek)
		1500	\|\| IS_LOWER (peek)
		1501	\|\| peek == 'C'
		1502	\|\| peek == 'U'
		1503	\|\| peek == 'L')
		1504	dc = d_unqualified_name (di);
		1505	else if (peek == 'S')
		1506	dc = d_substitution (di, 1);
		1507	else if (peek == 'I')
		1508	{
		1509	if (ret == NULL)
		1510	return NULL;
		1511	comb_type = DEMANGLE_COMPONENT_TEMPLATE;
		1512	dc = d_template_args (di);
		1513	}
		1514	else if (peek == 'T')
		1515	dc = d_template_param (di);
		1516	else if (peek == 'E')
		1517	return ret;
		1518	else if (peek == 'M')
		1519	{
		1520	/* Initializer scope for a lambda. We don't need to represent
		1521	this; the normal code will just treat the variable as a type
		1522	scope, which gives appropriate output. */
		1523	if (ret == NULL)
		1524	return NULL;
		1525	d_advance (di, 1);
		1526	continue;
		1527	}
		1528	else
		1529	return NULL;
		1530
		1531	if (ret == NULL)
		1532	ret = dc;
		1533	else
		1534	ret = d_make_comp (di, comb_type, ret, dc);
		1535
		1536	if (peek != 'S' && d_peek_char (di) != 'E')
		1537	{
		1538	if (! d_add_substitution (di, ret))
		1539	return NULL;
		1540	}
		1541	}
		1542	}
		1543
		1544	/* ::=
		1545	::=
		1546	::=
		1547	::=
		1548
		1549	::= L
		1550	*/
		1551
		1552	static struct demangle_component *
		1553	d_unqualified_name (struct d_info *di)
		1554	{
		1555	struct demangle_component *ret;
		1556	char peek;
		1557
		1558	peek = d_peek_char (di);
		1559	if (IS_DIGIT (peek))
		1560	ret = d_source_name (di);
		1561	else if (IS_LOWER (peek))
		1562	{
		1563	ret = d_operator_name (di);
		1564	if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
		1565	{
		1566	di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
		1567	if (!strcmp (ret->u.s_operator.op->code, "li"))
		1568	ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
		1569	d_source_name (di));
		1570	}
		1571	}
		1572	else if (peek == 'C' \|\| peek == 'D')
		1573	ret = d_ctor_dtor_name (di);
		1574	else if (peek == 'L')
		1575	{
		1576	d_advance (di, 1);
		1577
		1578	ret = d_source_name (di);
		1579	if (ret == NULL)
		1580	return NULL;
		1581	if (! d_discriminator (di))
		1582	return NULL;
		1583	}
		1584	else if (peek == 'U')
		1585	{
		1586	switch (d_peek_next_char (di))
		1587	{
		1588	case 'l':
		1589	ret = d_lambda (di);
		1590	break;
		1591	case 't':
		1592	ret = d_unnamed_type (di);
		1593	break;
		1594	default:
		1595	return NULL;
		1596	}
		1597	}
		1598	else
		1599	return NULL;
		1600
		1601	if (d_peek_char (di) == 'B')
		1602	ret = d_abi_tags (di, ret);
		1603	return ret;
		1604	}
		1605
		1606	/* ::= <(positive length) number> */
		1607
		1608	static struct demangle_component *
		1609	d_source_name (struct d_info *di)
		1610	{
		1611	int len;
		1612	struct demangle_component *ret;
		1613
		1614	len = d_number (di);
		1615	if (len <= 0)
		1616	return NULL;
		1617	ret = d_identifier (di, len);
		1618	di->last_name = ret;
		1619	return ret;
		1620	}
		1621
		1622	/* number ::= [n] <(non-negative decimal integer)> */
		1623
		1624	static int
		1625	d_number (struct d_info *di)
		1626	{
		1627	int negative;
		1628	char peek;
		1629	int ret;
		1630
		1631	negative = 0;
		1632	peek = d_peek_char (di);
		1633	if (peek == 'n')
		1634	{
		1635	negative = 1;
		1636	d_advance (di, 1);
		1637	peek = d_peek_char (di);
		1638	}
		1639
		1640	ret = 0;
		1641	while (1)
		1642	{
		1643	if (! IS_DIGIT (peek))
		1644	{
		1645	if (negative)
		1646	ret = - ret;
		1647	return ret;
		1648	}
		1649	ret = ret * 10 + peek - '0';
		1650	d_advance (di, 1);
		1651	peek = d_peek_char (di);
		1652	}
		1653	}
		1654
		1655	/* Like d_number, but returns a demangle_component. */
		1656
		1657	static struct demangle_component *
		1658	d_number_component (struct d_info *di)
		1659	{
		1660	struct demangle_component *ret = d_make_empty (di);
		1661	if (ret)
		1662	{
		1663	ret->type = DEMANGLE_COMPONENT_NUMBER;
		1664	ret->u.s_number.number = d_number (di);
		1665	}
		1666	return ret;
		1667	}
		1668
		1669	/* identifier ::= <(unqualified source code identifier)> */
		1670
		1671	static struct demangle_component *
		1672	d_identifier (struct d_info *di, int len)
		1673	{
		1674	const char *name;
		1675
		1676	name = d_str (di);
		1677
		1678	if (di->send - name < len)
		1679	return NULL;
		1680
		1681	d_advance (di, len);
		1682
		1683	/* A Java mangled name may have a trailing '$' if it is a C++
		1684	keyword. This '$' is not included in the length count. We just
		1685	ignore the '$'. */
		1686	if ((di->options & DMGL_JAVA) != 0
		1687	&& d_peek_char (di) == '$')
		1688	d_advance (di, 1);
		1689
		1690	/* Look for something which looks like a gcc encoding of an
		1691	anonymous namespace, and replace it with a more user friendly
		1692	name. */
		1693	if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
		1694	&& memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
		1695	ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
		1696	{
		1697	const char *s;
		1698
		1699	s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
		1700	if ((s == '.' \|\| s == '_' \|\| *s == '$')
		1701	&& s[1] == 'N')
		1702	{
		1703	di->expansion -= len - sizeof "(anonymous namespace)";
		1704	return d_make_name (di, "(anonymous namespace)",
		1705	sizeof "(anonymous namespace)" - 1);
		1706	}
		1707	}
		1708
		1709	return d_make_name (di, name, len);
		1710	}
		1711
		1712	/* operator_name ::= many different two character encodings.
		1713	::= cv
		1714	::= v
		1715
		1716	This list is sorted for binary search. */
		1717
		1718	#define NL(s) s, (sizeof s) - 1
		1719
		1720	CP_STATIC_IF_GLIBCPP_V3
		1721	const struct demangle_operator_info cplus_demangle_operators[] =
		1722	{
		1723	{ "aN", NL ("&="), 2 },
		1724	{ "aS", NL ("="), 2 },
		1725	{ "aa", NL ("&&"), 2 },
		1726	{ "ad", NL ("&"), 1 },
		1727	{ "an", NL ("&"), 2 },
		1728	{ "at", NL ("alignof "), 1 },
		1729	{ "az", NL ("alignof "), 1 },
		1730	{ "cc", NL ("const_cast"), 2 },
		1731	{ "cl", NL ("()"), 2 },
		1732	{ "cm", NL (","), 2 },
		1733	{ "co", NL ("~"), 1 },
		1734	{ "dV", NL ("/="), 2 },
		1735	{ "da", NL ("delete[] "), 1 },
		1736	{ "dc", NL ("dynamic_cast"), 2 },
		1737	{ "de", NL ("*"), 1 },
		1738	{ "dl", NL ("delete "), 1 },
		1739	{ "ds", NL (".*"), 2 },
		1740	{ "dt", NL ("."), 2 },
		1741	{ "dv", NL ("/"), 2 },
		1742	{ "eO", NL ("^="), 2 },
		1743	{ "eo", NL ("^"), 2 },
		1744	{ "eq", NL ("=="), 2 },
		1745	{ "ge", NL (">="), 2 },
		1746	{ "gs", NL ("::"), 1 },
		1747	{ "gt", NL (">"), 2 },
		1748	{ "ix", NL ("[]"), 2 },
		1749	{ "lS", NL ("<<="), 2 },
		1750	{ "le", NL ("<="), 2 },
		1751	{ "li", NL ("operator\"\" "), 1 },
		1752	{ "ls", NL ("<<"), 2 },
		1753	{ "lt", NL ("<"), 2 },
		1754	{ "mI", NL ("-="), 2 },
		1755	{ "mL", NL ("*="), 2 },
		1756	{ "mi", NL ("-"), 2 },
		1757	{ "ml", NL ("*"), 2 },
		1758	{ "mm", NL ("--"), 1 },
		1759	{ "na", NL ("new[]"), 3 },
		1760	{ "ne", NL ("!="), 2 },
		1761	{ "ng", NL ("-"), 1 },
		1762	{ "nt", NL ("!"), 1 },
		1763	{ "nw", NL ("new"), 3 },
		1764	{ "oR", NL ("\|="), 2 },
		1765	{ "oo", NL ("\|\|"), 2 },
		1766	{ "or", NL ("\|"), 2 },
		1767	{ "pL", NL ("+="), 2 },
		1768	{ "pl", NL ("+"), 2 },
		1769	{ "pm", NL ("->*"), 2 },
		1770	{ "pp", NL ("++"), 1 },
		1771	{ "ps", NL ("+"), 1 },
		1772	{ "pt", NL ("->"), 2 },
		1773	{ "qu", NL ("?"), 3 },
		1774	{ "rM", NL ("%="), 2 },
		1775	{ "rS", NL (">>="), 2 },
		1776	{ "rc", NL ("reinterpret_cast"), 2 },
		1777	{ "rm", NL ("%"), 2 },
		1778	{ "rs", NL (">>"), 2 },
		1779	{ "sc", NL ("static_cast"), 2 },
		1780	{ "st", NL ("sizeof "), 1 },
		1781	{ "sz", NL ("sizeof "), 1 },
		1782	{ "tr", NL ("throw"), 0 },
		1783	{ "tw", NL ("throw "), 1 },
		1784	{ NULL, NULL, 0, 0 }
		1785	};
		1786
		1787	static struct demangle_component *
		1788	d_operator_name (struct d_info *di)
		1789	{
		1790	char c1;
		1791	char c2;
		1792
		1793	c1 = d_next_char (di);
		1794	c2 = d_next_char (di);
		1795	if (c1 == 'v' && IS_DIGIT (c2))
		1796	return d_make_extended_operator (di, c2 - '0', d_source_name (di));
		1797	else if (c1 == 'c' && c2 == 'v')
		1798	{
		1799	struct demangle_component *type;
		1800	int was_conversion = di->is_conversion;
		1801	struct demangle_component *res;
		1802
		1803	di->is_conversion = ! di->is_expression;
		1804	type = cplus_demangle_type (di);
		1805	if (di->is_conversion)
		1806	res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
		1807	else
		1808	res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
		1809	di->is_conversion = was_conversion;
		1810	return res;
		1811	}
		1812	else
		1813	{
		1814	/* LOW is the inclusive lower bound. */
		1815	int low = 0;
		1816	/* HIGH is the exclusive upper bound. We subtract one to ignore
		1817	the sentinel at the end of the array. */
		1818	int high = ((sizeof (cplus_demangle_operators)
		1819	/ sizeof (cplus_demangle_operators[0]))
		1820	- 1);
		1821
		1822	while (1)
		1823	{
		1824	int i;
		1825	const struct demangle_operator_info *p;
		1826
		1827	i = low + (high - low) / 2;
		1828	p = cplus_demangle_operators + i;
		1829
		1830	if (c1 == p->code[0] && c2 == p->code[1])
		1831	return d_make_operator (di, p);
		1832
		1833	if (c1 < p->code[0] \|\| (c1 == p->code[0] && c2 < p->code[1]))
		1834	high = i;
		1835	else
		1836	low = i + 1;
		1837	if (low == high)
		1838	return NULL;
		1839	}
		1840	}
		1841	}
		1842
		1843	static struct demangle_component *
		1844	d_make_character (struct d_info *di, int c)
		1845	{
		1846	struct demangle_component *p;
		1847	p = d_make_empty (di);
		1848	if (p != NULL)
		1849	{
		1850	p->type = DEMANGLE_COMPONENT_CHARACTER;
		1851	p->u.s_character.character = c;
		1852	}
		1853	return p;
		1854	}
		1855
		1856	static struct demangle_component *
		1857	d_java_resource (struct d_info *di)
		1858	{
		1859	struct demangle_component *p = NULL;
		1860	struct demangle_component *next = NULL;
		1861	int len, i;
		1862	char c;
		1863	const char *str;
		1864
		1865	len = d_number (di);
		1866	if (len <= 1)
		1867	return NULL;
		1868
		1869	/* Eat the leading '_'. */
		1870	if (d_next_char (di) != '_')
		1871	return NULL;
		1872	len--;
		1873
		1874	str = d_str (di);
		1875	i = 0;
		1876
		1877	while (len > 0)
		1878	{
		1879	c = str[i];
		1880	if (!c)
		1881	return NULL;
		1882
		1883	/* Each chunk is either a '$' escape... */
		1884	if (c == '$')
		1885	{
		1886	i++;
		1887	switch (str[i++])
		1888	{
		1889	case 'S':
		1890	c = '/';
		1891	break;
		1892	case '_':
		1893	c = '.';
		1894	break;
		1895	case '$':
		1896	c = '$';
		1897	break;
		1898	default:
		1899	return NULL;
		1900	}
		1901	next = d_make_character (di, c);
		1902	d_advance (di, i);
		1903	str = d_str (di);
		1904	len -= i;
		1905	i = 0;
		1906	if (next == NULL)
		1907	return NULL;
		1908	}
		1909	/* ... or a sequence of characters. */
		1910	else
		1911	{
		1912	while (i < len && str[i] && str[i] != '$')
		1913	i++;
		1914
		1915	next = d_make_name (di, str, i);
		1916	d_advance (di, i);
		1917	str = d_str (di);
		1918	len -= i;
		1919	i = 0;
		1920	if (next == NULL)
		1921	return NULL;
		1922	}
		1923
		1924	if (p == NULL)
		1925	p = next;
		1926	else
		1927	{
		1928	p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
		1929	if (p == NULL)
		1930	return NULL;
		1931	}
		1932	}
		1933
		1934	p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
		1935
		1936	return p;
		1937	}
		1938
		1939	/* ::= TV
		1940	::= TT
		1941	::= TI
		1942	::= TS
		1943	::= GV <(object) name>
		1944	::= T <(base) encoding>
		1945	::= Tc <(base) encoding>
		1946	Also g++ extensions:
		1947	::= TC <(offset) number> _ <(base) type>
		1948	::= TF
		1949	::= TJ
		1950	::= GR
		1951	::= GA
		1952	::= Gr
		1953	::= GTt
		1954	::= GTn
		1955	*/
		1956
		1957	static struct demangle_component *
		1958	d_special_name (struct d_info *di)
		1959	{
		1960	di->expansion += 20;
		1961	if (d_check_char (di, 'T'))
		1962	{
		1963	switch (d_next_char (di))
		1964	{
		1965	case 'V':
		1966	di->expansion -= 5;
		1967	return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
		1968	cplus_demangle_type (di), NULL);
		1969	case 'T':
		1970	di->expansion -= 10;
		1971	return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
		1972	cplus_demangle_type (di), NULL);
		1973	case 'I':
		1974	return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
		1975	cplus_demangle_type (di), NULL);
		1976	case 'S':
		1977	return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
		1978	cplus_demangle_type (di), NULL);
		1979
		1980	case 'h':
		1981	if (! d_call_offset (di, 'h'))
		1982	return NULL;
		1983	return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
		1984	d_encoding (di, 0), NULL);
		1985
		1986	case 'v':
		1987	if (! d_call_offset (di, 'v'))
		1988	return NULL;
		1989	return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
		1990	d_encoding (di, 0), NULL);
		1991
		1992	case 'c':
		1993	if (! d_call_offset (di, '\0'))
		1994	return NULL;
		1995	if (! d_call_offset (di, '\0'))
		1996	return NULL;
		1997	return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
		1998	d_encoding (di, 0), NULL);
		1999
		2000	case 'C':
		2001	{
		2002	struct demangle_component *derived_type;
		2003	int offset;
		2004	struct demangle_component *base_type;
		2005
		2006	derived_type = cplus_demangle_type (di);
		2007	offset = d_number (di);
		2008	if (offset < 0)
		2009	return NULL;
		2010	if (! d_check_char (di, '_'))
		2011	return NULL;
		2012	base_type = cplus_demangle_type (di);
		2013	/* We don't display the offset. FIXME: We should display
		2014	it in verbose mode. */
		2015	di->expansion += 5;
		2016	return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
		2017	base_type, derived_type);
		2018	}
		2019
		2020	case 'F':
		2021	return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
		2022	cplus_demangle_type (di), NULL);
		2023	case 'J':
		2024	return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
		2025	cplus_demangle_type (di), NULL);
		2026
		2027	case 'H':
		2028	return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
		2029	d_name (di), NULL);
		2030
		2031	case 'W':
		2032	return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
		2033	d_name (di), NULL);
		2034
		2035	default:
		2036	return NULL;
		2037	}
		2038	}
		2039	else if (d_check_char (di, 'G'))
		2040	{
		2041	switch (d_next_char (di))
		2042	{
		2043	case 'V':
		2044	return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
		2045
		2046	case 'R':
		2047	{
		2048	struct demangle_component *name = d_name (di);
		2049	return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
		2050	d_number_component (di));
		2051	}
		2052
		2053	case 'A':
		2054	return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
		2055	d_encoding (di, 0), NULL);
		2056
		2057	case 'T':
		2058	switch (d_next_char (di))
		2059	{
		2060	case 'n':
		2061	return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
		2062	d_encoding (di, 0), NULL);
		2063	default:
		2064	/* ??? The proposal is that other letters (such as 'h') stand
		2065	for different variants of transaction cloning, such as
		2066	compiling directly for hardware transaction support. But
		2067	they still should all be transactional clones of some sort
		2068	so go ahead and call them that. */
		2069	case 't':
		2070	return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
		2071	d_encoding (di, 0), NULL);
		2072	}
		2073
		2074	case 'r':
		2075	return d_java_resource (di);
		2076
		2077	default:
		2078	return NULL;
		2079	}
		2080	}
		2081	else
		2082	return NULL;
		2083	}
		2084
		2085	/* ::= h _
		2086	::= v _
		2087
		2088	::= <(offset) number>
		2089
		2090	::= <(offset) number> _ <(virtual offset) number>
		2091
		2092	The C parameter, if not '\0', is a character we just read which is
		2093	the start of the .
		2094
		2095	We don't display the offset information anywhere. FIXME: We should
		2096	display it in verbose mode. */
		2097
		2098	static int
		2099	d_call_offset (struct d_info *di, int c)
		2100	{
		2101	if (c == '\0')
		2102	c = d_next_char (di);
		2103
		2104	if (c == 'h')
		2105	d_number (di);
		2106	else if (c == 'v')
		2107	{
		2108	d_number (di);
		2109	if (! d_check_char (di, '_'))
		2110	return 0;
		2111	d_number (di);
		2112	}
		2113	else
		2114	return 0;
		2115
		2116	if (! d_check_char (di, '_'))
		2117	return 0;
		2118
		2119	return 1;
		2120	}
		2121
		2122	/* ::= C1
		2123	::= C2
		2124	::= C3
		2125	::= D0
		2126	::= D1
		2127	::= D2
		2128	*/
		2129
		2130	static struct demangle_component *
		2131	d_ctor_dtor_name (struct d_info *di)
		2132	{
		2133	if (di->last_name != NULL)
		2134	{
		2135	if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
		2136	di->expansion += di->last_name->u.s_name.len;
		2137	else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
		2138	di->expansion += di->last_name->u.s_string.len;
		2139	}
		2140	switch (d_peek_char (di))
		2141	{
		2142	case 'C':
		2143	{
		2144	enum gnu_v3_ctor_kinds kind;
		2145
		2146	switch (d_peek_next_char (di))
		2147	{
		2148	case '1':
		2149	kind = gnu_v3_complete_object_ctor;
		2150	break;
		2151	case '2':
		2152	kind = gnu_v3_base_object_ctor;
		2153	break;
		2154	case '3':
		2155	kind = gnu_v3_complete_object_allocating_ctor;
		2156	break;
		2157	case '4':
		2158	kind = gnu_v3_unified_ctor;
		2159	break;
		2160	case '5':
		2161	kind = gnu_v3_object_ctor_group;
		2162	break;
		2163	default:
		2164	return NULL;
		2165	}
		2166	d_advance (di, 2);
		2167	return d_make_ctor (di, kind, di->last_name);
		2168	}
		2169
		2170	case 'D':
		2171	{
		2172	enum gnu_v3_dtor_kinds kind;
		2173
		2174	switch (d_peek_next_char (di))
		2175	{
		2176	case '0':
		2177	kind = gnu_v3_deleting_dtor;
		2178	break;
		2179	case '1':
		2180	kind = gnu_v3_complete_object_dtor;
		2181	break;
		2182	case '2':
		2183	kind = gnu_v3_base_object_dtor;
		2184	break;
		2185	/* digit '3' is not used */
		2186	case '4':
		2187	kind = gnu_v3_unified_dtor;
		2188	break;
		2189	case '5':
		2190	kind = gnu_v3_object_dtor_group;
		2191	break;
		2192	default:
		2193	return NULL;
		2194	}
		2195	d_advance (di, 2);
		2196	return d_make_dtor (di, kind, di->last_name);
		2197	}
		2198
		2199	default:
		2200	return NULL;
		2201	}
		2202	}
		2203
		2204	/* ::=
		2205	::=
		2206	::=
		2207	::=
		2208	::=
		2209	::=
		2210	::=
		2211	::=
		2212	::=
		2213	::= P
		2214	::= R
		2215	::= O (C++0x)
		2216	::= C
		2217	::= G
		2218	::= U
		2219
		2220	::= various one letter codes
		2221	::= u
		2222	*/
		2223
		2224	CP_STATIC_IF_GLIBCPP_V3
		2225	const struct demangle_builtin_type_info
		2226	cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
		2227	{
		2228	/* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
		2229	/* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
		2230	/* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
		2231	/* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
		2232	/* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
		2233	/* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
		2234	/* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
		2235	/* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
		2236	/* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
		2237	/* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
		2238	/* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
		2239	/* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
		2240	/* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
		2241	/* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
		2242	/* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
		2243	D_PRINT_DEFAULT },
		2244	/* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
		2245	/* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
		2246	/* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
		2247	/* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
		2248	/* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
		2249	/* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
		2250	/* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
		2251	/* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
		2252	/* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
		2253	/* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
		2254	D_PRINT_UNSIGNED_LONG_LONG },
		2255	/* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
		2256	/* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
		2257	/* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
		2258	/* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
		2259	/* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
		2260	/* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
		2261	/* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
		2262	/* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
		2263	D_PRINT_DEFAULT },
		2264	};
		2265
		2266	CP_STATIC_IF_GLIBCPP_V3
		2267	struct demangle_component *
		2268	cplus_demangle_type (struct d_info *di)
		2269	{
		2270	char peek;
		2271	struct demangle_component *ret;
		2272	int can_subst;
		2273
		2274	/* The ABI specifies that when CV-qualifiers are used, the base type
		2275	is substitutable, and the fully qualified type is substitutable,
		2276	but the base type with a strict subset of the CV-qualifiers is
		2277	not substitutable. The natural recursive implementation of the
		2278	CV-qualifiers would cause subsets to be substitutable, so instead
		2279	we pull them all off now.
		2280
		2281	FIXME: The ABI says that order-insensitive vendor qualifiers
		2282	should be handled in the same way, but we have no way to tell
		2283	which vendor qualifiers are order-insensitive and which are
		2284	order-sensitive. So we just assume that they are all
		2285	order-sensitive. g++ 3.4 supports only one vendor qualifier,
		2286	__vector, and it treats it as order-sensitive when mangling
		2287	names. */
		2288
		2289	peek = d_peek_char (di);
		2290	if (peek == 'r' \|\| peek == 'V' \|\| peek == 'K')
		2291	{
		2292	struct demangle_component **pret;
		2293
		2294	pret = d_cv_qualifiers (di, &ret, 0);
		2295	if (pret == NULL)
		2296	return NULL;
		2297	if (d_peek_char (di) == 'F')
		2298	{
		2299	/* cv-qualifiers before a function type apply to 'this',
		2300	so avoid adding the unqualified function type to
		2301	the substitution list. */
		2302	*pret = d_function_type (di);
		2303	}
		2304	else
6556	serge	2305	*pret = cplus_demangle_type (di);
6554	serge	2306	if (!*pret)
		2307	return NULL;
		2308	if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
		2309	\|\| (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
		2310	{
		2311	/* Move the ref-qualifier outside the cv-qualifiers so that
		2312	they are printed in the right order. */
		2313	struct demangle_component fn = d_left (pret);
		2314	d_left (*pret) = ret;
		2315	ret = *pret;
		2316	*pret = fn;
		2317	}
		2318	if (! d_add_substitution (di, ret))
		2319	return NULL;
		2320	return ret;
		2321	}
		2322
		2323	can_subst = 1;
		2324
		2325	switch (peek)
		2326	{
		2327	case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
		2328	case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
		2329	case 'o': case 's': case 't':
		2330	case 'v': case 'w': case 'x': case 'y': case 'z':
		2331	ret = d_make_builtin_type (di,
		2332	&cplus_demangle_builtin_types[peek - 'a']);
		2333	di->expansion += ret->u.s_builtin.type->len;
		2334	can_subst = 0;
		2335	d_advance (di, 1);
		2336	break;
		2337
		2338	case 'u':
		2339	d_advance (di, 1);
		2340	ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
		2341	d_source_name (di), NULL);
		2342	break;
		2343
		2344	case 'F':
		2345	ret = d_function_type (di);
		2346	break;
		2347
		2348	case '0': case '1': case '2': case '3': case '4':
		2349	case '5': case '6': case '7': case '8': case '9':
		2350	case 'N':
		2351	case 'Z':
		2352	ret = d_class_enum_type (di);
		2353	break;
		2354
		2355	case 'A':
		2356	ret = d_array_type (di);
		2357	break;
		2358
		2359	case 'M':
		2360	ret = d_pointer_to_member_type (di);
		2361	break;
		2362
		2363	case 'T':
		2364	ret = d_template_param (di);
		2365	if (d_peek_char (di) == 'I')
		2366	{
		2367	/* This may be .
		2368	If this is the type for a conversion operator, we can
		2369	have a here only by following
		2370	a derivation like this:
		2371
		2372
		2373	->
		2374	->
		2375	->
		2376	->
		2377	->
		2378	-> cv
		2379	-> cv
		2380
		2381	where the is followed by another.
		2382	Otherwise, we must have a derivation like this:
		2383
		2384
		2385	->
		2386	->
		2387	->
		2388	->
		2389	->
		2390	-> cv
		2391	-> cv
		2392
		2393	where we need to leave the to be processed
		2394	by d_prefix (following the ).
		2395
		2396	The part is a substitution
		2397	candidate. */
		2398	if (! di->is_conversion)
		2399	{
6556	serge	2400	if (! d_add_substitution (di, ret))
		2401	return NULL;
		2402	ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
		2403	d_template_args (di));
		2404	}
6554	serge	2405	else
		2406	{
		2407	struct demangle_component *args;
		2408	struct d_info_checkpoint checkpoint;
		2409
		2410	d_checkpoint (di, &checkpoint);
		2411	args = d_template_args (di);
		2412	if (d_peek_char (di) == 'I')
		2413	{
		2414	if (! d_add_substitution (di, ret))
		2415	return NULL;
		2416	ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
		2417	args);
		2418	}
		2419	else
		2420	d_backtrack (di, &checkpoint);
		2421	}
		2422	}
		2423	break;
		2424
		2425	case 'S':
		2426	/* If this is a special substitution, then it is the start of
		2427	. */
		2428	{
		2429	char peek_next;
		2430
		2431	peek_next = d_peek_next_char (di);
		2432	if (IS_DIGIT (peek_next)
		2433	\|\| peek_next == '_'
		2434	\|\| IS_UPPER (peek_next))
		2435	{
		2436	ret = d_substitution (di, 0);
		2437	/* The substituted name may have been a template name and
		2438	may be followed by tepmlate args. */
		2439	if (d_peek_char (di) == 'I')
		2440	ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
		2441	d_template_args (di));
		2442	else
		2443	can_subst = 0;
		2444	}
		2445	else
		2446	{
		2447	ret = d_class_enum_type (di);
		2448	/* If the substitution was a complete type, then it is not
		2449	a new substitution candidate. However, if the
		2450	substitution was followed by template arguments, then
		2451	the whole thing is a substitution candidate. */
		2452	if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
		2453	can_subst = 0;
		2454	}
		2455	}
		2456	break;
		2457
		2458	case 'O':
		2459	d_advance (di, 1);
		2460	ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
		2461	cplus_demangle_type (di), NULL);
		2462	break;
		2463
		2464	case 'P':
		2465	d_advance (di, 1);
		2466	ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
		2467	cplus_demangle_type (di), NULL);
		2468	break;
		2469
		2470	case 'R':
		2471	d_advance (di, 1);
		2472	ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
		2473	cplus_demangle_type (di), NULL);
		2474	break;
		2475
		2476	case 'C':
		2477	d_advance (di, 1);
		2478	ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
		2479	cplus_demangle_type (di), NULL);
		2480	break;
		2481
		2482	case 'G':
		2483	d_advance (di, 1);
		2484	ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
		2485	cplus_demangle_type (di), NULL);
		2486	break;
		2487
		2488	case 'U':
		2489	d_advance (di, 1);
		2490	ret = d_source_name (di);
		2491	ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
		2492	cplus_demangle_type (di), ret);
		2493	break;
		2494
		2495	case 'D':
		2496	can_subst = 0;
		2497	d_advance (di, 1);
		2498	peek = d_next_char (di);
		2499	switch (peek)
		2500	{
		2501	case 'T':
		2502	case 't':
		2503	/* decltype (expression) */
		2504	ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
		2505	d_expression (di), NULL);
		2506	if (ret && d_next_char (di) != 'E')
		2507	ret = NULL;
		2508	can_subst = 1;
		2509	break;
		2510
		2511	case 'p':
		2512	/* Pack expansion. */
		2513	ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
		2514	cplus_demangle_type (di), NULL);
		2515	can_subst = 1;
		2516	break;
		2517
		2518	case 'a':
		2519	/* auto */
		2520	ret = d_make_name (di, "auto", 4);
		2521	break;
		2522
		2523	case 'f':
		2524	/* 32-bit decimal floating point */
		2525	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
		2526	di->expansion += ret->u.s_builtin.type->len;
		2527	break;
		2528	case 'd':
		2529	/* 64-bit DFP */
		2530	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
		2531	di->expansion += ret->u.s_builtin.type->len;
		2532	break;
		2533	case 'e':
		2534	/* 128-bit DFP */
		2535	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
		2536	di->expansion += ret->u.s_builtin.type->len;
		2537	break;
		2538	case 'h':
		2539	/* 16-bit half-precision FP */
		2540	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
		2541	di->expansion += ret->u.s_builtin.type->len;
		2542	break;
		2543	case 's':
		2544	/* char16_t */
		2545	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
		2546	di->expansion += ret->u.s_builtin.type->len;
		2547	break;
		2548	case 'i':
		2549	/* char32_t */
		2550	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
		2551	di->expansion += ret->u.s_builtin.type->len;
		2552	break;
		2553
		2554	case 'F':
		2555	/* Fixed point types. DF */
		2556	ret = d_make_empty (di);
		2557	ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
		2558	if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
		2559	/* For demangling we don't care about the bits. */
		2560	d_number (di);
		2561	ret->u.s_fixed.length = cplus_demangle_type (di);
		2562	if (ret->u.s_fixed.length == NULL)
		2563	return NULL;
		2564	d_number (di);
		2565	peek = d_next_char (di);
		2566	ret->u.s_fixed.sat = (peek == 's');
		2567	break;
		2568
		2569	case 'v':
		2570	ret = d_vector_type (di);
		2571	can_subst = 1;
		2572	break;
		2573
		2574	case 'n':
		2575	/* decltype(nullptr) */
		2576	ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
		2577	di->expansion += ret->u.s_builtin.type->len;
		2578	break;
		2579
		2580	default:
		2581	return NULL;
		2582	}
		2583	break;
		2584
		2585	default:
		2586	return NULL;
		2587	}
		2588
		2589	if (can_subst)
		2590	{
		2591	if (! d_add_substitution (di, ret))
		2592	return NULL;
		2593	}
		2594
		2595	return ret;
		2596	}
		2597
		2598	/* ::= [r] [V] [K] */
		2599
		2600	static struct demangle_component **
		2601	d_cv_qualifiers (struct d_info *di,
		2602	struct demangle_component **pret, int member_fn)
		2603	{
		2604	struct demangle_component **pstart;
		2605	char peek;
		2606
		2607	pstart = pret;
		2608	peek = d_peek_char (di);
		2609	while (peek == 'r' \|\| peek == 'V' \|\| peek == 'K')
		2610	{
		2611	enum demangle_component_type t;
		2612
		2613	d_advance (di, 1);
		2614	if (peek == 'r')
		2615	{
		2616	t = (member_fn
		2617	? DEMANGLE_COMPONENT_RESTRICT_THIS
		2618	: DEMANGLE_COMPONENT_RESTRICT);
		2619	di->expansion += sizeof "restrict";
		2620	}
		2621	else if (peek == 'V')
		2622	{
		2623	t = (member_fn
		2624	? DEMANGLE_COMPONENT_VOLATILE_THIS
		2625	: DEMANGLE_COMPONENT_VOLATILE);
		2626	di->expansion += sizeof "volatile";
		2627	}
		2628	else
		2629	{
		2630	t = (member_fn
		2631	? DEMANGLE_COMPONENT_CONST_THIS
		2632	: DEMANGLE_COMPONENT_CONST);
		2633	di->expansion += sizeof "const";
		2634	}
		2635
		2636	*pret = d_make_comp (di, t, NULL, NULL);
		2637	if (*pret == NULL)
		2638	return NULL;
		2639	pret = &d_left (*pret);
		2640
		2641	peek = d_peek_char (di);
		2642	}
		2643
		2644	if (!member_fn && peek == 'F')
		2645	{
		2646	while (pstart != pret)
		2647	{
		2648	switch ((*pstart)->type)
		2649	{
		2650	case DEMANGLE_COMPONENT_RESTRICT:
		2651	(*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
		2652	break;
		2653	case DEMANGLE_COMPONENT_VOLATILE:
		2654	(*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
		2655	break;
		2656	case DEMANGLE_COMPONENT_CONST:
		2657	(*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
		2658	break;
		2659	default:
		2660	break;
		2661	}
		2662	pstart = &d_left (*pstart);
		2663	}
		2664	}
		2665
		2666	return pret;
		2667	}
		2668
		2669	/* ::= R
		2670	::= O */
		2671
		2672	static struct demangle_component *
		2673	d_ref_qualifier (struct d_info di, struct demangle_component sub)
		2674	{
		2675	struct demangle_component *ret = sub;
		2676	char peek;
		2677
		2678	peek = d_peek_char (di);
		2679	if (peek == 'R' \|\| peek == 'O')
		2680	{
		2681	enum demangle_component_type t;
		2682	if (peek == 'R')
		2683	{
		2684	t = DEMANGLE_COMPONENT_REFERENCE_THIS;
		2685	di->expansion += sizeof "&";
		2686	}
		2687	else
		2688	{
		2689	t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
		2690	di->expansion += sizeof "&&";
		2691	}
		2692	d_advance (di, 1);
		2693
		2694	ret = d_make_comp (di, t, ret, NULL);
		2695	}
		2696
		2697	return ret;
		2698	}
		2699
		2700	/* ::= F [Y] [] E */
		2701
		2702	static struct demangle_component *
		2703	d_function_type (struct d_info *di)
		2704	{
		2705	struct demangle_component *ret;
		2706
		2707	if (! d_check_char (di, 'F'))
		2708	return NULL;
		2709	if (d_peek_char (di) == 'Y')
		2710	{
		2711	/* Function has C linkage. We don't print this information.
		2712	FIXME: We should print it in verbose mode. */
		2713	d_advance (di, 1);
		2714	}
		2715	ret = d_bare_function_type (di, 1);
		2716	ret = d_ref_qualifier (di, ret);
		2717
		2718	if (! d_check_char (di, 'E'))
		2719	return NULL;
		2720	return ret;
		2721	}
		2722
		2723	/* + */
		2724
		2725	static struct demangle_component *
		2726	d_parmlist (struct d_info *di)
		2727	{
		2728	struct demangle_component *tl;
		2729	struct demangle_component **ptl;
		2730
		2731	tl = NULL;
		2732	ptl = &tl;
		2733	while (1)
		2734	{
		2735	struct demangle_component *type;
		2736
		2737	char peek = d_peek_char (di);
		2738	if (peek == '\0' \|\| peek == 'E' \|\| peek == '.')
		2739	break;
		2740	if ((peek == 'R' \|\| peek == 'O')
		2741	&& d_peek_next_char (di) == 'E')
		2742	/* Function ref-qualifier, not a ref prefix for a parameter type. */
		2743	break;
		2744	type = cplus_demangle_type (di);
		2745	if (type == NULL)
		2746	return NULL;
		2747	*ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
		2748	if (*ptl == NULL)
		2749	return NULL;
		2750	ptl = &d_right (*ptl);
		2751	}
		2752
		2753	/* There should be at least one parameter type besides the optional
		2754	return type. A function which takes no arguments will have a
		2755	single parameter type void. */
		2756	if (tl == NULL)
		2757	return NULL;
		2758
		2759	/* If we have a single parameter type void, omit it. */
		2760	if (d_right (tl) == NULL
		2761	&& d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
		2762	&& d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
		2763	{
		2764	di->expansion -= d_left (tl)->u.s_builtin.type->len;
		2765	d_left (tl) = NULL;
		2766	}
		2767
		2768	return tl;
		2769	}
		2770
		2771	/* ::= [J]+ */
		2772
		2773	static struct demangle_component *
		2774	d_bare_function_type (struct d_info *di, int has_return_type)
		2775	{
		2776	struct demangle_component *return_type;
		2777	struct demangle_component *tl;
		2778	char peek;
		2779
		2780	/* Detect special qualifier indicating that the first argument
		2781	is the return type. */
		2782	peek = d_peek_char (di);
		2783	if (peek == 'J')
		2784	{
		2785	d_advance (di, 1);
		2786	has_return_type = 1;
		2787	}
		2788
		2789	if (has_return_type)
		2790	{
		2791	return_type = cplus_demangle_type (di);
		2792	if (return_type == NULL)
		2793	return NULL;
		2794	}
		2795	else
		2796	return_type = NULL;
		2797
		2798	tl = d_parmlist (di);
		2799	if (tl == NULL)
		2800	return NULL;
		2801
		2802	return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
		2803	return_type, tl);
		2804	}
		2805
		2806	/* ::= */
		2807
		2808	static struct demangle_component *
		2809	d_class_enum_type (struct d_info *di)
		2810	{
		2811	return d_name (di);
		2812	}
		2813
		2814	/* ::= A <(positive dimension) number> _ <(element) type>
		2815	::= A [<(dimension) expression>] _ <(element) type>
		2816	*/
		2817
		2818	static struct demangle_component *
		2819	d_array_type (struct d_info *di)
		2820	{
		2821	char peek;
		2822	struct demangle_component *dim;
		2823
		2824	if (! d_check_char (di, 'A'))
		2825	return NULL;
		2826
		2827	peek = d_peek_char (di);
		2828	if (peek == '_')
		2829	dim = NULL;
		2830	else if (IS_DIGIT (peek))
		2831	{
		2832	const char *s;
		2833
		2834	s = d_str (di);
		2835	do
		2836	{
		2837	d_advance (di, 1);
		2838	peek = d_peek_char (di);
		2839	}
		2840	while (IS_DIGIT (peek));
		2841	dim = d_make_name (di, s, d_str (di) - s);
		2842	if (dim == NULL)
		2843	return NULL;
		2844	}
		2845	else
		2846	{
		2847	dim = d_expression (di);
		2848	if (dim == NULL)
		2849	return NULL;
		2850	}
		2851
		2852	if (! d_check_char (di, '_'))
		2853	return NULL;
		2854
		2855	return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
		2856	cplus_demangle_type (di));
		2857	}
		2858
		2859	/* ::= Dv _
		2860	::= Dv _ _ */
		2861
		2862	static struct demangle_component *
		2863	d_vector_type (struct d_info *di)
		2864	{
		2865	char peek;
		2866	struct demangle_component *dim;
		2867
		2868	peek = d_peek_char (di);
		2869	if (peek == '_')
		2870	{
		2871	d_advance (di, 1);
		2872	dim = d_expression (di);
		2873	}
		2874	else
		2875	dim = d_number_component (di);
		2876
		2877	if (dim == NULL)
		2878	return NULL;
		2879
		2880	if (! d_check_char (di, '_'))
		2881	return NULL;
		2882
		2883	return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
		2884	cplus_demangle_type (di));
		2885	}
		2886
		2887	/* ::= M <(class) type> <(member) type> */
		2888
		2889	static struct demangle_component *
		2890	d_pointer_to_member_type (struct d_info *di)
		2891	{
		2892	struct demangle_component *cl;
		2893	struct demangle_component *mem;
		2894
		2895	if (! d_check_char (di, 'M'))
		2896	return NULL;
		2897
		2898	cl = cplus_demangle_type (di);
		2899	if (cl == NULL)
		2900	return NULL;
		2901
		2902	/* The ABI says, "The type of a non-static member function is considered
		2903	to be different, for the purposes of substitution, from the type of a
		2904	namespace-scope or static member function whose type appears
		2905	similar. The types of two non-static member functions are considered
		2906	to be different, for the purposes of substitution, if the functions
		2907	are members of different classes. In other words, for the purposes of
		2908	substitution, the class of which the function is a member is
		2909	considered part of the type of function."
		2910
		2911	For a pointer to member function, this call to cplus_demangle_type
		2912	will end up adding a (possibly qualified) non-member function type to
		2913	the substitution table, which is not correct; however, the member
		2914	function type will never be used in a substitution, so putting the
		2915	wrong type in the substitution table is harmless. */
		2916
		2917	mem = cplus_demangle_type (di);
		2918	if (mem == NULL)
		2919	return NULL;
		2920
		2921	return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
		2922	}
		2923
		2924	/* _ */
		2925
		2926	static int
		2927	d_compact_number (struct d_info *di)
		2928	{
		2929	int num;
		2930	if (d_peek_char (di) == '_')
		2931	num = 0;
		2932	else if (d_peek_char (di) == 'n')
		2933	return -1;
		2934	else
		2935	num = d_number (di) + 1;
		2936
		2937	if (num < 0 \|\| ! d_check_char (di, '_'))
		2938	return -1;
		2939	return num;
		2940	}
		2941
		2942	/* ::= T_
		2943	::= T <(parameter-2 non-negative) number> _
		2944	*/
		2945
		2946	static struct demangle_component *
		2947	d_template_param (struct d_info *di)
		2948	{
		2949	int param;
		2950
		2951	if (! d_check_char (di, 'T'))
		2952	return NULL;
		2953
		2954	param = d_compact_number (di);
		2955	if (param < 0)
		2956	return NULL;
		2957
		2958	++di->did_subs;
		2959
		2960	return d_make_template_param (di, param);
		2961	}
		2962
		2963	/* ::= I + E */
		2964
		2965	static struct demangle_component *
		2966	d_template_args (struct d_info *di)
		2967	{
		2968	struct demangle_component *hold_last_name;
		2969	struct demangle_component *al;
		2970	struct demangle_component **pal;
		2971
		2972	/* Preserve the last name we saw--don't let the template arguments
		2973	clobber it, as that would give us the wrong name for a subsequent
		2974	constructor or destructor. */
		2975	hold_last_name = di->last_name;
		2976
		2977	if (d_peek_char (di) != 'I'
		2978	&& d_peek_char (di) != 'J')
		2979	return NULL;
		2980	d_advance (di, 1);
		2981
		2982	if (d_peek_char (di) == 'E')
		2983	{
		2984	/* An argument pack can be empty. */
		2985	d_advance (di, 1);
		2986	return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
		2987	}
		2988
		2989	al = NULL;
		2990	pal = &al;
		2991	while (1)
		2992	{
		2993	struct demangle_component *a;
		2994
		2995	a = d_template_arg (di);
		2996	if (a == NULL)
		2997	return NULL;
		2998
		2999	*pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
		3000	if (*pal == NULL)
		3001	return NULL;
		3002	pal = &d_right (*pal);
		3003
		3004	if (d_peek_char (di) == 'E')
		3005	{
		3006	d_advance (di, 1);
		3007	break;
		3008	}
		3009	}
		3010
		3011	di->last_name = hold_last_name;
		3012
		3013	return al;
		3014	}
		3015
		3016	/* ::=
		3017	::= X E
		3018	::=
		3019	*/
		3020
		3021	static struct demangle_component *
		3022	d_template_arg (struct d_info *di)
		3023	{
		3024	struct demangle_component *ret;
		3025
		3026	switch (d_peek_char (di))
		3027	{
		3028	case 'X':
		3029	d_advance (di, 1);
		3030	ret = d_expression (di);
		3031	if (! d_check_char (di, 'E'))
		3032	return NULL;
		3033	return ret;
		3034
		3035	case 'L':
		3036	return d_expr_primary (di);
		3037
		3038	case 'I':
		3039	case 'J':
		3040	/* An argument pack. */
		3041	return d_template_args (di);
		3042
		3043	default:
		3044	return cplus_demangle_type (di);
		3045	}
		3046	}
		3047
		3048	/* Parse a sequence of expressions until we hit the terminator
		3049	character. */
		3050
		3051	static struct demangle_component *
		3052	d_exprlist (struct d_info *di, char terminator)
		3053	{
		3054	struct demangle_component *list = NULL;
		3055	struct demangle_component **p = &list;
		3056
		3057	if (d_peek_char (di) == terminator)
		3058	{
		3059	d_advance (di, 1);
		3060	return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
		3061	}
		3062
		3063	while (1)
		3064	{
		3065	struct demangle_component *arg = d_expression (di);
		3066	if (arg == NULL)
		3067	return NULL;
		3068
		3069	*p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
		3070	if (*p == NULL)
		3071	return NULL;
		3072	p = &d_right (*p);
		3073
		3074	if (d_peek_char (di) == terminator)
		3075	{
		3076	d_advance (di, 1);
		3077	break;
		3078	}
		3079	}
		3080
		3081	return list;
		3082	}
		3083
		3084	/* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
		3085	dynamic_cast, static_cast or reinterpret_cast. */
		3086
		3087	static int
		3088	op_is_new_cast (struct demangle_component *op)
		3089	{
		3090	const char *code = op->u.s_operator.op->code;
		3091	return (code[1] == 'c'
		3092	&& (code[0] == 's' \|\| code[0] == 'd'
		3093	\|\| code[0] == 'c' \|\| code[0] == 'r'));
		3094	}
		3095
		3096	/* ::= <(unary) operator-name>
		3097	::= <(binary) operator-name>
		3098	::= <(trinary) operator-name>
		3099	::= cl + E
		3100	::= st
		3101	::=
		3102	::= sr
		3103	::= sr
		3104	::=
		3105	*/
		3106
		3107	static inline struct demangle_component *
		3108	d_expression_1 (struct d_info *di)
		3109	{
		3110	char peek;
		3111
		3112	peek = d_peek_char (di);
		3113	if (peek == 'L')
		3114	return d_expr_primary (di);
		3115	else if (peek == 'T')
		3116	return d_template_param (di);
		3117	else if (peek == 's' && d_peek_next_char (di) == 'r')
		3118	{
		3119	struct demangle_component *type;
		3120	struct demangle_component *name;
		3121
		3122	d_advance (di, 2);
		3123	type = cplus_demangle_type (di);
		3124	name = d_unqualified_name (di);
		3125	if (d_peek_char (di) != 'I')
		3126	return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
		3127	else
		3128	return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
		3129	d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
		3130	d_template_args (di)));
		3131	}
		3132	else if (peek == 's' && d_peek_next_char (di) == 'p')
		3133	{
		3134	d_advance (di, 2);
		3135	return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
		3136	d_expression_1 (di), NULL);
		3137	}
		3138	else if (peek == 'f' && d_peek_next_char (di) == 'p')
		3139	{
		3140	/* Function parameter used in a late-specified return type. */
		3141	int index;
		3142	d_advance (di, 2);
		3143	if (d_peek_char (di) == 'T')
		3144	{
		3145	/* 'this' parameter. */
		3146	d_advance (di, 1);
		3147	index = 0;
		3148	}
		3149	else
		3150	{
		3151	index = d_compact_number (di);
		3152	if (index == INT_MAX \|\| index == -1)
		3153	return NULL;
		3154	index++;
		3155	}
		3156	return d_make_function_param (di, index);
		3157	}
		3158	else if (IS_DIGIT (peek)
		3159	\|\| (peek == 'o' && d_peek_next_char (di) == 'n'))
		3160	{
		3161	/* We can get an unqualified name as an expression in the case of
		3162	a dependent function call, i.e. decltype(f(t)). */
		3163	struct demangle_component *name;
		3164
		3165	if (peek == 'o')
		3166	/* operator-function-id, i.e. operator+(t). */
		3167	d_advance (di, 2);
		3168
		3169	name = d_unqualified_name (di);
		3170	if (name == NULL)
		3171	return NULL;
		3172	if (d_peek_char (di) == 'I')
		3173	return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
		3174	d_template_args (di));
		3175	else
		3176	return name;
		3177	}
		3178	else if ((peek == 'i' \|\| peek == 't')
		3179	&& d_peek_next_char (di) == 'l')
		3180	{
		3181	/* Brace-enclosed initializer list, untyped or typed. */
		3182	struct demangle_component *type = NULL;
		3183	if (peek == 't')
		3184	type = cplus_demangle_type (di);
		3185	if (!d_peek_next_char (di))
		3186	return NULL;
		3187	d_advance (di, 2);
		3188	return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
		3189	type, d_exprlist (di, 'E'));
		3190	}
		3191	else
		3192	{
		3193	struct demangle_component *op;
		3194	const char *code = NULL;
		3195	int args;
		3196
		3197	op = d_operator_name (di);
		3198	if (op == NULL)
		3199	return NULL;
		3200
		3201	if (op->type == DEMANGLE_COMPONENT_OPERATOR)
		3202	{
		3203	code = op->u.s_operator.op->code;
		3204	di->expansion += op->u.s_operator.op->len - 2;
		3205	if (strcmp (code, "st") == 0)
		3206	return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
		3207	cplus_demangle_type (di));
		3208	}
		3209
		3210	switch (op->type)
		3211	{
		3212	default:
		3213	return NULL;
		3214	case DEMANGLE_COMPONENT_OPERATOR:
		3215	args = op->u.s_operator.op->args;
		3216	break;
		3217	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
		3218	args = op->u.s_extended_operator.args;
		3219	break;
		3220	case DEMANGLE_COMPONENT_CAST:
		3221	args = 1;
		3222	break;
		3223	}
		3224
		3225	switch (args)
		3226	{
		3227	case 0:
		3228	return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
		3229
		3230	case 1:
		3231	{
		3232	struct demangle_component *operand;
		3233	int suffix = 0;
		3234
		3235	if (code && (code[0] == 'p' \|\| code[0] == 'm')
		3236	&& code[1] == code[0])
		3237	/* pp_ and mm_ are the prefix variants. */
		3238	suffix = !d_check_char (di, '_');
		3239
		3240	if (op->type == DEMANGLE_COMPONENT_CAST
		3241	&& d_check_char (di, '_'))
		3242	operand = d_exprlist (di, 'E');
		3243	else
		3244	operand = d_expression_1 (di);
		3245
		3246	if (suffix)
		3247	/* Indicate the suffix variant for d_print_comp. */
		3248	return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
		3249	d_make_comp (di,
		3250	DEMANGLE_COMPONENT_BINARY_ARGS,
		3251	operand, operand));
		3252	else
		3253	return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
		3254	operand);
		3255	}
		3256	case 2:
		3257	{
		3258	struct demangle_component *left;
		3259	struct demangle_component *right;
		3260
		3261	if (code == NULL)
		3262	return NULL;
		3263	if (op_is_new_cast (op))
		3264	left = cplus_demangle_type (di);
		3265	else
		3266	left = d_expression_1 (di);
		3267	if (!strcmp (code, "cl"))
		3268	right = d_exprlist (di, 'E');
		3269	else if (!strcmp (code, "dt") \|\| !strcmp (code, "pt"))
		3270	{
		3271	right = d_unqualified_name (di);
		3272	if (d_peek_char (di) == 'I')
		3273	right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
		3274	right, d_template_args (di));
		3275	}
		3276	else
		3277	right = d_expression_1 (di);
		3278
		3279	return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
		3280	d_make_comp (di,
		3281	DEMANGLE_COMPONENT_BINARY_ARGS,
		3282	left, right));
		3283	}
		3284	case 3:
		3285	{
		3286	struct demangle_component *first;
		3287	struct demangle_component *second;
		3288	struct demangle_component *third;
		3289
		3290	if (code == NULL)
		3291	return NULL;
		3292	else if (!strcmp (code, "qu"))
		3293	{
		3294	/* ?: expression. */
		3295	first = d_expression_1 (di);
		3296	second = d_expression_1 (di);
		3297	third = d_expression_1 (di);
		3298	}
		3299	else if (code[0] == 'n')
		3300	{
		3301	/* new-expression. */
		3302	if (code[1] != 'w' && code[1] != 'a')
		3303	return NULL;
		3304	first = d_exprlist (di, '_');
		3305	second = cplus_demangle_type (di);
		3306	if (d_peek_char (di) == 'E')
		3307	{
		3308	d_advance (di, 1);
		3309	third = NULL;
		3310	}
		3311	else if (d_peek_char (di) == 'p'
		3312	&& d_peek_next_char (di) == 'i')
		3313	{
		3314	/* Parenthesized initializer. */
		3315	d_advance (di, 2);
		3316	third = d_exprlist (di, 'E');
		3317	}
		3318	else if (d_peek_char (di) == 'i'
		3319	&& d_peek_next_char (di) == 'l')
		3320	/* initializer-list. */
		3321	third = d_expression_1 (di);
		3322	else
		3323	return NULL;
		3324	}
		3325	else
		3326	return NULL;
		3327	return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
		3328	d_make_comp (di,
		3329	DEMANGLE_COMPONENT_TRINARY_ARG1,
		3330	first,
		3331	d_make_comp (di,
		3332	DEMANGLE_COMPONENT_TRINARY_ARG2,
		3333	second, third)));
		3334	}
		3335	default:
		3336	return NULL;
		3337	}
		3338	}
		3339	}
		3340
		3341	static struct demangle_component *
		3342	d_expression (struct d_info *di)
		3343	{
		3344	struct demangle_component *ret;
		3345	int was_expression = di->is_expression;
		3346
		3347	di->is_expression = 1;
		3348	ret = d_expression_1 (di);
		3349	di->is_expression = was_expression;
		3350	return ret;
		3351	}
		3352
		3353	/* ::= L <(value) number> E
		3354	::= L <(value) float> E
		3355	::= L E
		3356	*/
		3357
		3358	static struct demangle_component *
		3359	d_expr_primary (struct d_info *di)
		3360	{
		3361	struct demangle_component *ret;
		3362
		3363	if (! d_check_char (di, 'L'))
		3364	return NULL;
		3365	if (d_peek_char (di) == '_'
		3366	/* Workaround for G++ bug; see comment in write_template_arg. */
		3367	\|\| d_peek_char (di) == 'Z')
		3368	ret = cplus_demangle_mangled_name (di, 0);
		3369	else
		3370	{
		3371	struct demangle_component *type;
		3372	enum demangle_component_type t;
		3373	const char *s;
		3374
		3375	type = cplus_demangle_type (di);
		3376	if (type == NULL)
		3377	return NULL;
		3378
		3379	/* If we have a type we know how to print, we aren't going to
		3380	print the type name itself. */
		3381	if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
		3382	&& type->u.s_builtin.type->print != D_PRINT_DEFAULT)
		3383	di->expansion -= type->u.s_builtin.type->len;
		3384
		3385	/* Rather than try to interpret the literal value, we just
		3386	collect it as a string. Note that it's possible to have a
		3387	floating point literal here. The ABI specifies that the
		3388	format of such literals is machine independent. That's fine,
		3389	but what's not fine is that versions of g++ up to 3.2 with
		3390	-fabi-version=1 used upper case letters in the hex constant,
		3391	and dumped out gcc's internal representation. That makes it
		3392	hard to tell where the constant ends, and hard to dump the
		3393	constant in any readable form anyhow. We don't attempt to
		3394	handle these cases. */
		3395
		3396	t = DEMANGLE_COMPONENT_LITERAL;
		3397	if (d_peek_char (di) == 'n')
		3398	{
		3399	t = DEMANGLE_COMPONENT_LITERAL_NEG;
		3400	d_advance (di, 1);
		3401	}
		3402	s = d_str (di);
		3403	while (d_peek_char (di) != 'E')
		3404	{
		3405	if (d_peek_char (di) == '\0')
		3406	return NULL;
		3407	d_advance (di, 1);
		3408	}
		3409	ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
		3410	}
		3411	if (! d_check_char (di, 'E'))
		3412	return NULL;
		3413	return ret;
		3414	}
		3415
		3416	/* ::= Z <(function) encoding> E <(entity) name> []
		3417	::= Z <(function) encoding> E s []
		3418	::= Z <(function) encoding> E d [ number>] _
		3419	*/
		3420
		3421	static struct demangle_component *
		3422	d_local_name (struct d_info *di)
		3423	{
		3424	struct demangle_component *function;
		3425
		3426	if (! d_check_char (di, 'Z'))
		3427	return NULL;
		3428
		3429	function = d_encoding (di, 0);
		3430
		3431	if (! d_check_char (di, 'E'))
		3432	return NULL;
		3433
		3434	if (d_peek_char (di) == 's')
		3435	{
		3436	d_advance (di, 1);
		3437	if (! d_discriminator (di))
		3438	return NULL;
		3439	return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
		3440	d_make_name (di, "string literal",
		3441	sizeof "string literal" - 1));
		3442	}
		3443	else
		3444	{
		3445	struct demangle_component *name;
		3446	int num = -1;
		3447
		3448	if (d_peek_char (di) == 'd')
		3449	{
		3450	/* Default argument scope: d _. */
		3451	d_advance (di, 1);
		3452	num = d_compact_number (di);
		3453	if (num < 0)
		3454	return NULL;
		3455	}
		3456
		3457	name = d_name (di);
		3458	if (name)
		3459	switch (name->type)
		3460	{
		3461	/* Lambdas and unnamed types have internal discriminators. */
		3462	case DEMANGLE_COMPONENT_LAMBDA:
		3463	case DEMANGLE_COMPONENT_UNNAMED_TYPE:
		3464	break;
		3465	default:
		3466	if (! d_discriminator (di))
		3467	return NULL;
		3468	}
		3469	if (num >= 0)
		3470	name = d_make_default_arg (di, num, name);
		3471	return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
		3472	}
		3473	}
		3474
		3475	/* ::= _ <(non-negative) number>
		3476
		3477	We demangle the discriminator, but we don't print it out. FIXME:
		3478	We should print it out in verbose mode. */
		3479
		3480	static int
		3481	d_discriminator (struct d_info *di)
		3482	{
		3483	int discrim;
		3484
		3485	if (d_peek_char (di) != '_')
		3486	return 1;
		3487	d_advance (di, 1);
		3488	discrim = d_number (di);
		3489	if (discrim < 0)
		3490	return 0;
		3491	return 1;
		3492	}
		3493
		3494	/* ::= Ul E [ ] _ */
		3495
		3496	static struct demangle_component *
		3497	d_lambda (struct d_info *di)
		3498	{
		3499	struct demangle_component *tl;
		3500	struct demangle_component *ret;
		3501	int num;
		3502
		3503	if (! d_check_char (di, 'U'))
		3504	return NULL;
		3505	if (! d_check_char (di, 'l'))
		3506	return NULL;
		3507
		3508	tl = d_parmlist (di);
		3509	if (tl == NULL)
		3510	return NULL;
		3511
		3512	if (! d_check_char (di, 'E'))
		3513	return NULL;
		3514
		3515	num = d_compact_number (di);
		3516	if (num < 0)
		3517	return NULL;
		3518
		3519	ret = d_make_empty (di);
		3520	if (ret)
		3521	{
		3522	ret->type = DEMANGLE_COMPONENT_LAMBDA;
		3523	ret->u.s_unary_num.sub = tl;
		3524	ret->u.s_unary_num.num = num;
		3525	}
		3526
		3527	if (! d_add_substitution (di, ret))
		3528	return NULL;
		3529
		3530	return ret;
		3531	}
		3532
		3533	/* ::= Ut [ ] _ */
		3534
		3535	static struct demangle_component *
		3536	d_unnamed_type (struct d_info *di)
		3537	{
		3538	struct demangle_component *ret;
		3539	int num;
		3540
		3541	if (! d_check_char (di, 'U'))
		3542	return NULL;
		3543	if (! d_check_char (di, 't'))
		3544	return NULL;
		3545
		3546	num = d_compact_number (di);
		3547	if (num < 0)
		3548	return NULL;
		3549
		3550	ret = d_make_empty (di);
		3551	if (ret)
		3552	{
		3553	ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
		3554	ret->u.s_number.number = num;
		3555	}
		3556
		3557	if (! d_add_substitution (di, ret))
		3558	return NULL;
		3559
		3560	return ret;
		3561	}
		3562
		3563	/* ::= [ . ] [ . ]*
		3564	*/
		3565
		3566	static struct demangle_component *
		3567	d_clone_suffix (struct d_info di, struct demangle_component encoding)
		3568	{
		3569	const char *suffix = d_str (di);
		3570	const char *pend = suffix;
		3571	struct demangle_component *n;
		3572
		3573	if (*pend == '.' && (IS_LOWER (pend[1]) \|\| pend[1] == '_'))
		3574	{
		3575	pend += 2;
		3576	while (IS_LOWER (pend) \|\| pend == '_')
		3577	++pend;
		3578	}
		3579	while (*pend == '.' && IS_DIGIT (pend[1]))
		3580	{
		3581	pend += 2;
		3582	while (IS_DIGIT (*pend))
		3583	++pend;
		3584	}
		3585	d_advance (di, pend - suffix);
		3586	n = d_make_name (di, suffix, pend - suffix);
		3587	return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
		3588	}
		3589
		3590	/* Add a new substitution. */
		3591
		3592	static int
		3593	d_add_substitution (struct d_info di, struct demangle_component dc)
		3594	{
		3595	if (dc == NULL)
		3596	return 0;
		3597	if (di->next_sub >= di->num_subs)
		3598	return 0;
		3599	di->subs[di->next_sub] = dc;
		3600	++di->next_sub;
		3601	return 1;
		3602	}
		3603
		3604	/* ::= S _
		3605	::= S_
		3606	::= St
		3607	::= Sa
		3608	::= Sb
		3609	::= Ss
		3610	::= Si
		3611	::= So
		3612	::= Sd
		3613
		3614	If PREFIX is non-zero, then this type is being used as a prefix in
		3615	a qualified name. In this case, for the standard substitutions, we
		3616	need to check whether we are being used as a prefix for a
		3617	constructor or destructor, and return a full template name.
		3618	Otherwise we will get something like std::iostream::~iostream()
		3619	which does not correspond particularly well to any function which
		3620	actually appears in the source.
		3621	*/
		3622
		3623	static const struct d_standard_sub_info standard_subs[] =
		3624	{
		3625	{ 't', NL ("std"),
		3626	NL ("std"),
		3627	NULL, 0 },
		3628	{ 'a', NL ("std::allocator"),
		3629	NL ("std::allocator"),
		3630	NL ("allocator") },
		3631	{ 'b', NL ("std::basic_string"),
		3632	NL ("std::basic_string"),
		3633	NL ("basic_string") },
		3634	{ 's', NL ("std::string"),
		3635	NL ("std::basic_string, std::allocator >"),
		3636	NL ("basic_string") },
		3637	{ 'i', NL ("std::istream"),
		3638	NL ("std::basic_istream >"),
		3639	NL ("basic_istream") },
		3640	{ 'o', NL ("std::ostream"),
		3641	NL ("std::basic_ostream >"),
		3642	NL ("basic_ostream") },
		3643	{ 'd', NL ("std::iostream"),
		3644	NL ("std::basic_iostream >"),
		3645	NL ("basic_iostream") }
		3646	};
		3647
		3648	static struct demangle_component *
		3649	d_substitution (struct d_info *di, int prefix)
		3650	{
		3651	char c;
		3652
		3653	if (! d_check_char (di, 'S'))
		3654	return NULL;
		3655
		3656	c = d_next_char (di);
		3657	if (c == '_' \|\| IS_DIGIT (c) \|\| IS_UPPER (c))
		3658	{
		3659	unsigned int id;
		3660
		3661	id = 0;
		3662	if (c != '_')
		3663	{
		3664	do
		3665	{
		3666	unsigned int new_id;
		3667
		3668	if (IS_DIGIT (c))
		3669	new_id = id * 36 + c - '0';
		3670	else if (IS_UPPER (c))
		3671	new_id = id * 36 + c - 'A' + 10;
		3672	else
		3673	return NULL;
		3674	if (new_id < id)
		3675	return NULL;
		3676	id = new_id;
		3677	c = d_next_char (di);
		3678	}
		3679	while (c != '_');
		3680
		3681	++id;
		3682	}
		3683
		3684	if (id >= (unsigned int) di->next_sub)
		3685	return NULL;
		3686
		3687	++di->did_subs;
		3688
		3689	return di->subs[id];
		3690	}
		3691	else
		3692	{
		3693	int verbose;
		3694	const struct d_standard_sub_info *p;
		3695	const struct d_standard_sub_info *pend;
		3696
		3697	verbose = (di->options & DMGL_VERBOSE) != 0;
		3698	if (! verbose && prefix)
		3699	{
		3700	char peek;
		3701
		3702	peek = d_peek_char (di);
		3703	if (peek == 'C' \|\| peek == 'D')
		3704	verbose = 1;
		3705	}
		3706
		3707	pend = (&standard_subs[0]
		3708	+ sizeof standard_subs / sizeof standard_subs[0]);
		3709	for (p = &standard_subs[0]; p < pend; ++p)
		3710	{
		3711	if (c == p->code)
		3712	{
		3713	const char *s;
		3714	int len;
		3715	struct demangle_component *c;
		3716
		3717	if (p->set_last_name != NULL)
		3718	di->last_name = d_make_sub (di, p->set_last_name,
		3719	p->set_last_name_len);
		3720	if (verbose)
		3721	{
		3722	s = p->full_expansion;
		3723	len = p->full_len;
		3724	}
		3725	else
		3726	{
		3727	s = p->simple_expansion;
		3728	len = p->simple_len;
		3729	}
		3730	di->expansion += len;
		3731	c = d_make_sub (di, s, len);
		3732	if (d_peek_char (di) == 'B')
		3733	{
		3734	/* If there are ABI tags on the abbreviation, it becomes
		3735	a substitution candidate. */
		3736	c = d_abi_tags (di, c);
		3737	d_add_substitution (di, c);
		3738	}
		3739	return c;
		3740	}
		3741	}
		3742
		3743	return NULL;
		3744	}
		3745	}
		3746
		3747	static void
		3748	d_checkpoint (struct d_info di, struct d_info_checkpoint checkpoint)
		3749	{
		3750	checkpoint->n = di->n;
		3751	checkpoint->next_comp = di->next_comp;
		3752	checkpoint->next_sub = di->next_sub;
		3753	checkpoint->did_subs = di->did_subs;
		3754	checkpoint->expansion = di->expansion;
		3755	}
		3756
		3757	static void
		3758	d_backtrack (struct d_info di, struct d_info_checkpoint checkpoint)
		3759	{
		3760	di->n = checkpoint->n;
		3761	di->next_comp = checkpoint->next_comp;
		3762	di->next_sub = checkpoint->next_sub;
		3763	di->did_subs = checkpoint->did_subs;
		3764	di->expansion = checkpoint->expansion;
		3765	}
		3766
		3767	/* Initialize a growable string. */
		3768
		3769	static void
		3770	d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
		3771	{
		3772	dgs->buf = NULL;
		3773	dgs->len = 0;
		3774	dgs->alc = 0;
		3775	dgs->allocation_failure = 0;
		3776
		3777	if (estimate > 0)
		3778	d_growable_string_resize (dgs, estimate);
		3779	}
		3780
		3781	/* Grow a growable string to a given size. */
		3782
		3783	static inline void
		3784	d_growable_string_resize (struct d_growable_string *dgs, size_t need)
		3785	{
		3786	size_t newalc;
		3787	char *newbuf;
		3788
		3789	if (dgs->allocation_failure)
		3790	return;
		3791
		3792	/* Start allocation at two bytes to avoid any possibility of confusion
		3793	with the special value of 1 used as a return in *palc to indicate
		3794	allocation failures. */
		3795	newalc = dgs->alc > 0 ? dgs->alc : 2;
		3796	while (newalc < need)
		3797	newalc <<= 1;
		3798
		3799	newbuf = (char *) realloc (dgs->buf, newalc);
		3800	if (newbuf == NULL)
		3801	{
		3802	free (dgs->buf);
		3803	dgs->buf = NULL;
		3804	dgs->len = 0;
		3805	dgs->alc = 0;
		3806	dgs->allocation_failure = 1;
		3807	return;
		3808	}
		3809	dgs->buf = newbuf;
		3810	dgs->alc = newalc;
		3811	}
		3812
		3813	/* Append a buffer to a growable string. */
		3814
		3815	static inline void
		3816	d_growable_string_append_buffer (struct d_growable_string *dgs,
		3817	const char *s, size_t l)
		3818	{
		3819	size_t need;
		3820
		3821	need = dgs->len + l + 1;
		3822	if (need > dgs->alc)
		3823	d_growable_string_resize (dgs, need);
		3824
		3825	if (dgs->allocation_failure)
		3826	return;
		3827
		3828	memcpy (dgs->buf + dgs->len, s, l);
		3829	dgs->buf[dgs->len + l] = '\0';
		3830	dgs->len += l;
		3831	}
		3832
		3833	/* Bridge growable strings to the callback mechanism. */
		3834
		3835	static void
		3836	d_growable_string_callback_adapter (const char s, size_t l, void opaque)
		3837	{
		3838	struct d_growable_string dgs = (struct d_growable_string) opaque;
		3839
		3840	d_growable_string_append_buffer (dgs, s, l);
		3841	}
		3842
		3843	/* Walk the tree, counting the number of templates encountered, and
		3844	the number of times a scope might be saved. These counts will be
		3845	used to allocate data structures for d_print_comp, so the logic
		3846	here must mirror the logic d_print_comp will use. It is not
		3847	important that the resulting numbers are exact, so long as they
		3848	are larger than the actual numbers encountered. */
		3849
		3850	static void
		3851	d_count_templates_scopes (int num_templates, int num_scopes,
		3852	const struct demangle_component *dc)
		3853	{
		3854	if (dc == NULL)
		3855	return;
		3856
		3857	switch (dc->type)
		3858	{
		3859	case DEMANGLE_COMPONENT_NAME:
		3860	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
		3861	case DEMANGLE_COMPONENT_FUNCTION_PARAM:
		3862	case DEMANGLE_COMPONENT_SUB_STD:
		3863	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
		3864	case DEMANGLE_COMPONENT_OPERATOR:
		3865	case DEMANGLE_COMPONENT_CHARACTER:
		3866	case DEMANGLE_COMPONENT_NUMBER:
		3867	case DEMANGLE_COMPONENT_UNNAMED_TYPE:
		3868	break;
		3869
		3870	case DEMANGLE_COMPONENT_TEMPLATE:
		3871	(*num_templates)++;
		3872	goto recurse_left_right;
		3873
		3874	case DEMANGLE_COMPONENT_REFERENCE:
		3875	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
		3876	if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
		3877	(*num_scopes)++;
		3878	goto recurse_left_right;
		3879
		3880	case DEMANGLE_COMPONENT_QUAL_NAME:
		3881	case DEMANGLE_COMPONENT_LOCAL_NAME:
		3882	case DEMANGLE_COMPONENT_TYPED_NAME:
		3883	case DEMANGLE_COMPONENT_VTABLE:
		3884	case DEMANGLE_COMPONENT_VTT:
		3885	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
		3886	case DEMANGLE_COMPONENT_TYPEINFO:
		3887	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
		3888	case DEMANGLE_COMPONENT_TYPEINFO_FN:
		3889	case DEMANGLE_COMPONENT_THUNK:
		3890	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
		3891	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
		3892	case DEMANGLE_COMPONENT_JAVA_CLASS:
		3893	case DEMANGLE_COMPONENT_GUARD:
		3894	case DEMANGLE_COMPONENT_TLS_INIT:
		3895	case DEMANGLE_COMPONENT_TLS_WRAPPER:
		3896	case DEMANGLE_COMPONENT_REFTEMP:
		3897	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
		3898	case DEMANGLE_COMPONENT_RESTRICT:
		3899	case DEMANGLE_COMPONENT_VOLATILE:
		3900	case DEMANGLE_COMPONENT_CONST:
		3901	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		3902	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		3903	case DEMANGLE_COMPONENT_CONST_THIS:
		3904	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		3905	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		3906	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		3907	case DEMANGLE_COMPONENT_POINTER:
		3908	case DEMANGLE_COMPONENT_COMPLEX:
		3909	case DEMANGLE_COMPONENT_IMAGINARY:
		3910	case DEMANGLE_COMPONENT_VENDOR_TYPE:
		3911	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
		3912	case DEMANGLE_COMPONENT_ARRAY_TYPE:
		3913	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		3914	case DEMANGLE_COMPONENT_VECTOR_TYPE:
		3915	case DEMANGLE_COMPONENT_ARGLIST:
		3916	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
		3917	case DEMANGLE_COMPONENT_INITIALIZER_LIST:
		3918	case DEMANGLE_COMPONENT_CAST:
		3919	case DEMANGLE_COMPONENT_CONVERSION:
		3920	case DEMANGLE_COMPONENT_NULLARY:
		3921	case DEMANGLE_COMPONENT_UNARY:
		3922	case DEMANGLE_COMPONENT_BINARY:
		3923	case DEMANGLE_COMPONENT_BINARY_ARGS:
		3924	case DEMANGLE_COMPONENT_TRINARY:
		3925	case DEMANGLE_COMPONENT_TRINARY_ARG1:
		3926	case DEMANGLE_COMPONENT_TRINARY_ARG2:
		3927	case DEMANGLE_COMPONENT_LITERAL:
		3928	case DEMANGLE_COMPONENT_LITERAL_NEG:
		3929	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
		3930	case DEMANGLE_COMPONENT_COMPOUND_NAME:
		3931	case DEMANGLE_COMPONENT_DECLTYPE:
		3932	case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
		3933	case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
		3934	case DEMANGLE_COMPONENT_PACK_EXPANSION:
		3935	case DEMANGLE_COMPONENT_TAGGED_NAME:
		3936	case DEMANGLE_COMPONENT_CLONE:
		3937	recurse_left_right:
		3938	d_count_templates_scopes (num_templates, num_scopes,
		3939	d_left (dc));
		3940	d_count_templates_scopes (num_templates, num_scopes,
		3941	d_right (dc));
		3942	break;
		3943
		3944	case DEMANGLE_COMPONENT_CTOR:
		3945	d_count_templates_scopes (num_templates, num_scopes,
		3946	dc->u.s_ctor.name);
		3947	break;
		3948
		3949	case DEMANGLE_COMPONENT_DTOR:
		3950	d_count_templates_scopes (num_templates, num_scopes,
		3951	dc->u.s_dtor.name);
		3952	break;
		3953
		3954	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
		3955	d_count_templates_scopes (num_templates, num_scopes,
		3956	dc->u.s_extended_operator.name);
		3957	break;
		3958
		3959	case DEMANGLE_COMPONENT_FIXED_TYPE:
		3960	d_count_templates_scopes (num_templates, num_scopes,
		3961	dc->u.s_fixed.length);
		3962	break;
		3963
		3964	case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
		3965	case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
		3966	d_count_templates_scopes (num_templates, num_scopes,
		3967	d_left (dc));
		3968	break;
		3969
		3970	case DEMANGLE_COMPONENT_LAMBDA:
		3971	case DEMANGLE_COMPONENT_DEFAULT_ARG:
		3972	d_count_templates_scopes (num_templates, num_scopes,
		3973	dc->u.s_unary_num.sub);
		3974	break;
		3975	}
		3976	}
		3977
		3978	/* Initialize a print information structure. */
		3979
		3980	static void
		3981	d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
		3982	void opaque, const struct demangle_component dc)
		3983	{
		3984	dpi->len = 0;
		3985	dpi->last_char = '\0';
		3986	dpi->templates = NULL;
		3987	dpi->modifiers = NULL;
		3988	dpi->pack_index = 0;
		3989	dpi->flush_count = 0;
		3990
		3991	dpi->callback = callback;
		3992	dpi->opaque = opaque;
		3993
		3994	dpi->demangle_failure = 0;
		3995
		3996	dpi->component_stack = NULL;
		3997
		3998	dpi->saved_scopes = NULL;
		3999	dpi->next_saved_scope = 0;
		4000	dpi->num_saved_scopes = 0;
		4001
		4002	dpi->copy_templates = NULL;
		4003	dpi->next_copy_template = 0;
		4004	dpi->num_copy_templates = 0;
		4005
		4006	d_count_templates_scopes (&dpi->num_copy_templates,
		4007	&dpi->num_saved_scopes, dc);
		4008	dpi->num_copy_templates *= dpi->num_saved_scopes;
		4009
		4010	dpi->current_template = NULL;
		4011	}
		4012
		4013	/* Indicate that an error occurred during printing, and test for error. */
		4014
		4015	static inline void
		4016	d_print_error (struct d_print_info *dpi)
		4017	{
		4018	dpi->demangle_failure = 1;
		4019	}
		4020
		4021	static inline int
		4022	d_print_saw_error (struct d_print_info *dpi)
		4023	{
		4024	return dpi->demangle_failure != 0;
		4025	}
		4026
		4027	/* Flush buffered characters to the callback. */
		4028
		4029	static inline void
		4030	d_print_flush (struct d_print_info *dpi)
		4031	{
		4032	dpi->buf[dpi->len] = '\0';
		4033	dpi->callback (dpi->buf, dpi->len, dpi->opaque);
		4034	dpi->len = 0;
		4035	dpi->flush_count++;
		4036	}
		4037
		4038	/* Append characters and buffers for printing. */
		4039
		4040	static inline void
		4041	d_append_char (struct d_print_info *dpi, char c)
		4042	{
		4043	if (dpi->len == sizeof (dpi->buf) - 1)
		4044	d_print_flush (dpi);
		4045
		4046	dpi->buf[dpi->len++] = c;
		4047	dpi->last_char = c;
		4048	}
		4049
		4050	static inline void
		4051	d_append_buffer (struct d_print_info dpi, const char s, size_t l)
		4052	{
		4053	size_t i;
		4054
		4055	for (i = 0; i < l; i++)
		4056	d_append_char (dpi, s[i]);
		4057	}
		4058
		4059	static inline void
		4060	d_append_string (struct d_print_info dpi, const char s)
		4061	{
		4062	d_append_buffer (dpi, s, strlen (s));
		4063	}
		4064
		4065	static inline void
		4066	d_append_num (struct d_print_info *dpi, int l)
		4067	{
		4068	char buf[25];
		4069	sprintf (buf,"%d", l);
		4070	d_append_string (dpi, buf);
		4071	}
		4072
		4073	static inline char
		4074	d_last_char (struct d_print_info *dpi)
		4075	{
		4076	return dpi->last_char;
		4077	}
		4078
		4079	/* Turn components into a human readable string. OPTIONS is the
		4080	options bits passed to the demangler. DC is the tree to print.
		4081	CALLBACK is a function to call to flush demangled string segments
		4082	as they fill the intermediate buffer, and OPAQUE is a generalized
		4083	callback argument. On success, this returns 1. On failure,
		4084	it returns 0, indicating a bad parse. It does not use heap
		4085	memory to build an output string, so cannot encounter memory
		4086	allocation failure. */
		4087
		4088	CP_STATIC_IF_GLIBCPP_V3
		4089	int
		4090	cplus_demangle_print_callback (int options,
		4091	const struct demangle_component *dc,
		4092	demangle_callbackref callback, void *opaque)
		4093	{
		4094	struct d_print_info dpi;
		4095
		4096	d_print_init (&dpi, callback, opaque, dc);
		4097
		4098	{
		4099	#ifdef CP_DYNAMIC_ARRAYS
		4100	__extension__ struct d_saved_scope scopes[dpi.num_saved_scopes];
		4101	__extension__ struct d_print_template temps[dpi.num_copy_templates];
		4102
		4103	dpi.saved_scopes = scopes;
		4104	dpi.copy_templates = temps;
		4105	#else
		4106	dpi.saved_scopes = alloca (dpi.num_saved_scopes
		4107	* sizeof (*dpi.saved_scopes));
		4108	dpi.copy_templates = alloca (dpi.num_copy_templates
		4109	* sizeof (*dpi.copy_templates));
		4110	#endif
		4111
6556	serge	4112	d_print_comp (&dpi, options, dc);
6554	serge	4113	}
		4114
		4115	d_print_flush (&dpi);
		4116
		4117	return ! d_print_saw_error (&dpi);
		4118	}
		4119
		4120	/* Turn components into a human readable string. OPTIONS is the
		4121	options bits passed to the demangler. DC is the tree to print.
		4122	ESTIMATE is a guess at the length of the result. This returns a
		4123	string allocated by malloc, or NULL on error. On success, this
		4124	sets *PALC to the size of the allocated buffer. On failure, this
		4125	sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
		4126	failure. */
		4127
		4128	CP_STATIC_IF_GLIBCPP_V3
		4129	char *
		4130	cplus_demangle_print (int options, const struct demangle_component *dc,
		4131	int estimate, size_t *palc)
		4132	{
		4133	struct d_growable_string dgs;
		4134
		4135	d_growable_string_init (&dgs, estimate);
		4136
		4137	if (! cplus_demangle_print_callback (options, dc,
		4138	d_growable_string_callback_adapter,
		4139	&dgs))
		4140	{
		4141	free (dgs.buf);
		4142	*palc = 0;
		4143	return NULL;
		4144	}
		4145
		4146	*palc = dgs.allocation_failure ? 1 : dgs.alc;
		4147	return dgs.buf;
		4148	}
		4149
		4150	/* Returns the I'th element of the template arglist ARGS, or NULL on
		4151	failure. */
		4152
		4153	static struct demangle_component *
		4154	d_index_template_argument (struct demangle_component *args, int i)
		4155	{
		4156	struct demangle_component *a;
		4157
		4158	for (a = args;
		4159	a != NULL;
		4160	a = d_right (a))
		4161	{
		4162	if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
		4163	return NULL;
		4164	if (i <= 0)
		4165	break;
		4166	--i;
		4167	}
		4168	if (i != 0 \|\| a == NULL)
		4169	return NULL;
		4170
		4171	return d_left (a);
		4172	}
		4173
		4174	/* Returns the template argument from the current context indicated by DC,
		4175	which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
		4176
		4177	static struct demangle_component *
		4178	d_lookup_template_argument (struct d_print_info *dpi,
		4179	const struct demangle_component *dc)
		4180	{
		4181	if (dpi->templates == NULL)
		4182	{
		4183	d_print_error (dpi);
		4184	return NULL;
		4185	}
		4186
		4187	return d_index_template_argument
		4188	(d_right (dpi->templates->template_decl),
		4189	dc->u.s_number.number);
		4190	}
		4191
		4192	/* Returns a template argument pack used in DC (any will do), or NULL. */
		4193
		4194	static struct demangle_component *
		4195	d_find_pack (struct d_print_info *dpi,
		4196	const struct demangle_component *dc)
		4197	{
		4198	struct demangle_component *a;
		4199	if (dc == NULL)
		4200	return NULL;
		4201
		4202	switch (dc->type)
		4203	{
		4204	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
		4205	a = d_lookup_template_argument (dpi, dc);
		4206	if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
		4207	return a;
		4208	return NULL;
		4209
		4210	case DEMANGLE_COMPONENT_PACK_EXPANSION:
		4211	return NULL;
		4212
		4213	case DEMANGLE_COMPONENT_LAMBDA:
		4214	case DEMANGLE_COMPONENT_NAME:
		4215	case DEMANGLE_COMPONENT_TAGGED_NAME:
		4216	case DEMANGLE_COMPONENT_OPERATOR:
		4217	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
		4218	case DEMANGLE_COMPONENT_SUB_STD:
		4219	case DEMANGLE_COMPONENT_CHARACTER:
		4220	case DEMANGLE_COMPONENT_FUNCTION_PARAM:
		4221	case DEMANGLE_COMPONENT_UNNAMED_TYPE:
		4222	case DEMANGLE_COMPONENT_FIXED_TYPE:
		4223	case DEMANGLE_COMPONENT_DEFAULT_ARG:
		4224	case DEMANGLE_COMPONENT_NUMBER:
		4225	return NULL;
		4226
		4227	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
		4228	return d_find_pack (dpi, dc->u.s_extended_operator.name);
		4229	case DEMANGLE_COMPONENT_CTOR:
		4230	return d_find_pack (dpi, dc->u.s_ctor.name);
		4231	case DEMANGLE_COMPONENT_DTOR:
		4232	return d_find_pack (dpi, dc->u.s_dtor.name);
		4233
		4234	default:
		4235	a = d_find_pack (dpi, d_left (dc));
		4236	if (a)
		4237	return a;
		4238	return d_find_pack (dpi, d_right (dc));
		4239	}
		4240	}
		4241
		4242	/* Returns the length of the template argument pack DC. */
		4243
		4244	static int
		4245	d_pack_length (const struct demangle_component *dc)
		4246	{
		4247	int count = 0;
		4248	while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
		4249	&& d_left (dc) != NULL)
		4250	{
		4251	++count;
		4252	dc = d_right (dc);
		4253	}
		4254	return count;
		4255	}
		4256
		4257	/* DC is a component of a mangled expression. Print it, wrapped in parens
		4258	if needed. */
		4259
		4260	static void
		4261	d_print_subexpr (struct d_print_info *dpi, int options,
		4262	const struct demangle_component *dc)
		4263	{
		4264	int simple = 0;
		4265	if (dc->type == DEMANGLE_COMPONENT_NAME
		4266	\|\| dc->type == DEMANGLE_COMPONENT_QUAL_NAME
		4267	\|\| dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
		4268	\|\| dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
		4269	simple = 1;
		4270	if (!simple)
		4271	d_append_char (dpi, '(');
		4272	d_print_comp (dpi, options, dc);
		4273	if (!simple)
		4274	d_append_char (dpi, ')');
		4275	}
		4276
		4277	/* Save the current scope. */
		4278
		4279	static void
		4280	d_save_scope (struct d_print_info *dpi,
		4281	const struct demangle_component *container)
		4282	{
		4283	struct d_saved_scope *scope;
		4284	struct d_print_template src, *link;
		4285
		4286	if (dpi->next_saved_scope >= dpi->num_saved_scopes)
		4287	{
		4288	d_print_error (dpi);
		4289	return;
		4290	}
		4291	scope = &dpi->saved_scopes[dpi->next_saved_scope];
		4292	dpi->next_saved_scope++;
		4293
		4294	scope->container = container;
		4295	link = &scope->templates;
		4296
		4297	for (src = dpi->templates; src != NULL; src = src->next)
		4298	{
		4299	struct d_print_template *dst;
		4300
		4301	if (dpi->next_copy_template >= dpi->num_copy_templates)
		4302	{
		4303	d_print_error (dpi);
		4304	return;
		4305	}
		4306	dst = &dpi->copy_templates[dpi->next_copy_template];
		4307	dpi->next_copy_template++;
		4308
		4309	dst->template_decl = src->template_decl;
		4310	*link = dst;
		4311	link = &dst->next;
		4312	}
		4313
		4314	*link = NULL;
		4315	}
		4316
		4317	/* Attempt to locate a previously saved scope. Returns NULL if no
		4318	corresponding saved scope was found. */
		4319
		4320	static struct d_saved_scope *
		4321	d_get_saved_scope (struct d_print_info *dpi,
		4322	const struct demangle_component *container)
		4323	{
		4324	int i;
		4325
		4326	for (i = 0; i < dpi->next_saved_scope; i++)
		4327	if (dpi->saved_scopes[i].container == container)
		4328	return &dpi->saved_scopes[i];
		4329
		4330	return NULL;
		4331	}
		4332
		4333	/* Subroutine to handle components. */
		4334
		4335	static void
		4336	d_print_comp_inner (struct d_print_info *dpi, int options,
6556	serge	4337	const struct demangle_component *dc)
6554	serge	4338	{
		4339	/* Magic variable to let reference smashing skip over the next modifier
		4340	without needing to modify dc. /
		4341	const struct demangle_component *mod_inner = NULL;
		4342
		4343	/* Variable used to store the current templates while a previously
		4344	captured scope is used. */
		4345	struct d_print_template *saved_templates;
		4346
		4347	/* Nonzero if templates have been stored in the above variable. */
		4348	int need_template_restore = 0;
		4349
		4350	if (dc == NULL)
		4351	{
		4352	d_print_error (dpi);
		4353	return;
		4354	}
		4355	if (d_print_saw_error (dpi))
		4356	return;
		4357
		4358	switch (dc->type)
		4359	{
		4360	case DEMANGLE_COMPONENT_NAME:
		4361	if ((options & DMGL_JAVA) == 0)
		4362	d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
		4363	else
		4364	d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
		4365	return;
		4366
		4367	case DEMANGLE_COMPONENT_TAGGED_NAME:
		4368	d_print_comp (dpi, options, d_left (dc));
		4369	d_append_string (dpi, "[abi:");
		4370	d_print_comp (dpi, options, d_right (dc));
		4371	d_append_char (dpi, ']');
		4372	return;
		4373
		4374	case DEMANGLE_COMPONENT_QUAL_NAME:
		4375	case DEMANGLE_COMPONENT_LOCAL_NAME:
		4376	d_print_comp (dpi, options, d_left (dc));
		4377	if ((options & DMGL_JAVA) == 0)
		4378	d_append_string (dpi, "::");
		4379	else
		4380	d_append_char (dpi, '.');
		4381	{
		4382	struct demangle_component *local_name = d_right (dc);
		4383	if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
		4384	{
		4385	d_append_string (dpi, "{default arg#");
		4386	d_append_num (dpi, local_name->u.s_unary_num.num + 1);
		4387	d_append_string (dpi, "}::");
		4388	local_name = local_name->u.s_unary_num.sub;
		4389	}
		4390	d_print_comp (dpi, options, local_name);
		4391	}
		4392	return;
		4393
		4394	case DEMANGLE_COMPONENT_TYPED_NAME:
		4395	{
		4396	struct d_print_mod *hold_modifiers;
		4397	struct demangle_component *typed_name;
		4398	struct d_print_mod adpm[4];
		4399	unsigned int i;
		4400	struct d_print_template dpt;
		4401
		4402	/* Pass the name down to the type so that it can be printed in
		4403	the right place for the type. We also have to pass down
		4404	any CV-qualifiers, which apply to the this parameter. */
		4405	hold_modifiers = dpi->modifiers;
		4406	dpi->modifiers = 0;
		4407	i = 0;
		4408	typed_name = d_left (dc);
		4409	while (typed_name != NULL)
		4410	{
		4411	if (i >= sizeof adpm / sizeof adpm[0])
		4412	{
		4413	d_print_error (dpi);
		4414	return;
		4415	}
		4416
		4417	adpm[i].next = dpi->modifiers;
		4418	dpi->modifiers = &adpm[i];
		4419	adpm[i].mod = typed_name;
		4420	adpm[i].printed = 0;
		4421	adpm[i].templates = dpi->templates;
		4422	++i;
		4423
		4424	if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
		4425	&& typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
		4426	&& typed_name->type != DEMANGLE_COMPONENT_CONST_THIS
		4427	&& typed_name->type != DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
		4428	&& typed_name->type != DEMANGLE_COMPONENT_REFERENCE_THIS)
		4429	break;
		4430
		4431	typed_name = d_left (typed_name);
		4432	}
		4433
		4434	if (typed_name == NULL)
		4435	{
		4436	d_print_error (dpi);
		4437	return;
		4438	}
		4439
		4440	/* If typed_name is a template, then it applies to the
		4441	function type as well. */
		4442	if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
		4443	{
		4444	dpt.next = dpi->templates;
		4445	dpi->templates = &dpt;
		4446	dpt.template_decl = typed_name;
		4447	}
		4448
		4449	/* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
		4450	there may be CV-qualifiers on its right argument which
		4451	really apply here; this happens when parsing a class which
		4452	is local to a function. */
		4453	if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
		4454	{
		4455	struct demangle_component *local_name;
		4456
		4457	local_name = d_right (typed_name);
		4458	if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
		4459	local_name = local_name->u.s_unary_num.sub;
		4460	if (local_name == NULL)
		4461	{
		4462	d_print_error (dpi);
		4463	return;
		4464	}
		4465	while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
		4466	\|\| local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
		4467	\|\| local_name->type == DEMANGLE_COMPONENT_CONST_THIS
		4468	\|\| local_name->type == DEMANGLE_COMPONENT_REFERENCE_THIS
		4469	\|\| (local_name->type
		4470	== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))
		4471	{
		4472	if (i >= sizeof adpm / sizeof adpm[0])
		4473	{
		4474	d_print_error (dpi);
		4475	return;
		4476	}
		4477
		4478	adpm[i] = adpm[i - 1];
		4479	adpm[i].next = &adpm[i - 1];
		4480	dpi->modifiers = &adpm[i];
		4481
		4482	adpm[i - 1].mod = local_name;
		4483	adpm[i - 1].printed = 0;
		4484	adpm[i - 1].templates = dpi->templates;
		4485	++i;
		4486
		4487	local_name = d_left (local_name);
		4488	}
		4489	}
		4490
		4491	d_print_comp (dpi, options, d_right (dc));
		4492
		4493	if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
		4494	dpi->templates = dpt.next;
		4495
		4496	/* If the modifiers didn't get printed by the type, print them
		4497	now. */
		4498	while (i > 0)
		4499	{
		4500	--i;
		4501	if (! adpm[i].printed)
		4502	{
		4503	d_append_char (dpi, ' ');
		4504	d_print_mod (dpi, options, adpm[i].mod);
		4505	}
		4506	}
		4507
		4508	dpi->modifiers = hold_modifiers;
		4509
		4510	return;
		4511	}
		4512
		4513	case DEMANGLE_COMPONENT_TEMPLATE:
		4514	{
		4515	struct d_print_mod *hold_dpm;
		4516	struct demangle_component *dcl;
		4517	const struct demangle_component *hold_current;
		4518
		4519	/* This template may need to be referenced by a cast operator
		4520	contained in its subtree. */
		4521	hold_current = dpi->current_template;
		4522	dpi->current_template = dc;
		4523
		4524	/* Don't push modifiers into a template definition. Doing so
		4525	could give the wrong definition for a template argument.
		4526	Instead, treat the template essentially as a name. */
		4527
		4528	hold_dpm = dpi->modifiers;
		4529	dpi->modifiers = NULL;
		4530
		4531	dcl = d_left (dc);
		4532
		4533	if ((options & DMGL_JAVA) != 0
		4534	&& dcl->type == DEMANGLE_COMPONENT_NAME
		4535	&& dcl->u.s_name.len == 6
		4536	&& strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
		4537	{
		4538	/* Special-case Java arrays, so that JArray appears
		4539	instead as TYPE[]. */
		4540
		4541	d_print_comp (dpi, options, d_right (dc));
		4542	d_append_string (dpi, "[]");
		4543	}
		4544	else
		4545	{
		4546	d_print_comp (dpi, options, dcl);
		4547	if (d_last_char (dpi) == '<')
		4548	d_append_char (dpi, ' ');
		4549	d_append_char (dpi, '<');
		4550	d_print_comp (dpi, options, d_right (dc));
		4551	/* Avoid generating two consecutive '>' characters, to avoid
		4552	the C++ syntactic ambiguity. */
		4553	if (d_last_char (dpi) == '>')
		4554	d_append_char (dpi, ' ');
		4555	d_append_char (dpi, '>');
		4556	}
		4557
		4558	dpi->modifiers = hold_dpm;
		4559	dpi->current_template = hold_current;
		4560
		4561	return;
		4562	}
		4563
		4564	case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
		4565	{
		4566	struct d_print_template *hold_dpt;
		4567	struct demangle_component *a = d_lookup_template_argument (dpi, dc);
		4568
		4569	if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
		4570	a = d_index_template_argument (a, dpi->pack_index);
		4571
		4572	if (a == NULL)
		4573	{
		4574	d_print_error (dpi);
		4575	return;
		4576	}
		4577
		4578	/* While processing this parameter, we need to pop the list of
		4579	templates. This is because the template parameter may
		4580	itself be a reference to a parameter of an outer
		4581	template. */
		4582
		4583	hold_dpt = dpi->templates;
		4584	dpi->templates = hold_dpt->next;
		4585
		4586	d_print_comp (dpi, options, a);
		4587
		4588	dpi->templates = hold_dpt;
		4589
		4590	return;
		4591	}
		4592
		4593	case DEMANGLE_COMPONENT_CTOR:
		4594	d_print_comp (dpi, options, dc->u.s_ctor.name);
		4595	return;
		4596
		4597	case DEMANGLE_COMPONENT_DTOR:
		4598	d_append_char (dpi, '~');
		4599	d_print_comp (dpi, options, dc->u.s_dtor.name);
		4600	return;
		4601
		4602	case DEMANGLE_COMPONENT_VTABLE:
		4603	d_append_string (dpi, "vtable for ");
		4604	d_print_comp (dpi, options, d_left (dc));
		4605	return;
		4606
		4607	case DEMANGLE_COMPONENT_VTT:
		4608	d_append_string (dpi, "VTT for ");
		4609	d_print_comp (dpi, options, d_left (dc));
		4610	return;
		4611
		4612	case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
		4613	d_append_string (dpi, "construction vtable for ");
		4614	d_print_comp (dpi, options, d_left (dc));
		4615	d_append_string (dpi, "-in-");
		4616	d_print_comp (dpi, options, d_right (dc));
		4617	return;
		4618
		4619	case DEMANGLE_COMPONENT_TYPEINFO:
		4620	d_append_string (dpi, "typeinfo for ");
		4621	d_print_comp (dpi, options, d_left (dc));
		4622	return;
		4623
		4624	case DEMANGLE_COMPONENT_TYPEINFO_NAME:
		4625	d_append_string (dpi, "typeinfo name for ");
		4626	d_print_comp (dpi, options, d_left (dc));
		4627	return;
		4628
		4629	case DEMANGLE_COMPONENT_TYPEINFO_FN:
		4630	d_append_string (dpi, "typeinfo fn for ");
		4631	d_print_comp (dpi, options, d_left (dc));
		4632	return;
		4633
		4634	case DEMANGLE_COMPONENT_THUNK:
		4635	d_append_string (dpi, "non-virtual thunk to ");
		4636	d_print_comp (dpi, options, d_left (dc));
		4637	return;
		4638
		4639	case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
		4640	d_append_string (dpi, "virtual thunk to ");
		4641	d_print_comp (dpi, options, d_left (dc));
		4642	return;
		4643
		4644	case DEMANGLE_COMPONENT_COVARIANT_THUNK:
		4645	d_append_string (dpi, "covariant return thunk to ");
		4646	d_print_comp (dpi, options, d_left (dc));
		4647	return;
		4648
		4649	case DEMANGLE_COMPONENT_JAVA_CLASS:
		4650	d_append_string (dpi, "java Class for ");
		4651	d_print_comp (dpi, options, d_left (dc));
		4652	return;
		4653
		4654	case DEMANGLE_COMPONENT_GUARD:
		4655	d_append_string (dpi, "guard variable for ");
		4656	d_print_comp (dpi, options, d_left (dc));
		4657	return;
		4658
		4659	case DEMANGLE_COMPONENT_TLS_INIT:
		4660	d_append_string (dpi, "TLS init function for ");
		4661	d_print_comp (dpi, options, d_left (dc));
		4662	return;
		4663
		4664	case DEMANGLE_COMPONENT_TLS_WRAPPER:
		4665	d_append_string (dpi, "TLS wrapper function for ");
		4666	d_print_comp (dpi, options, d_left (dc));
		4667	return;
		4668
		4669	case DEMANGLE_COMPONENT_REFTEMP:
		4670	d_append_string (dpi, "reference temporary #");
		4671	d_print_comp (dpi, options, d_right (dc));
		4672	d_append_string (dpi, " for ");
		4673	d_print_comp (dpi, options, d_left (dc));
		4674	return;
		4675
		4676	case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
		4677	d_append_string (dpi, "hidden alias for ");
		4678	d_print_comp (dpi, options, d_left (dc));
		4679	return;
		4680
		4681	case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
		4682	d_append_string (dpi, "transaction clone for ");
		4683	d_print_comp (dpi, options, d_left (dc));
		4684	return;
		4685
		4686	case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
		4687	d_append_string (dpi, "non-transaction clone for ");
		4688	d_print_comp (dpi, options, d_left (dc));
		4689	return;
		4690
		4691	case DEMANGLE_COMPONENT_SUB_STD:
		4692	d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
		4693	return;
		4694
		4695	case DEMANGLE_COMPONENT_RESTRICT:
		4696	case DEMANGLE_COMPONENT_VOLATILE:
		4697	case DEMANGLE_COMPONENT_CONST:
		4698	{
		4699	struct d_print_mod *pdpm;
		4700
		4701	/* When printing arrays, it's possible to have cases where the
		4702	same CV-qualifier gets pushed on the stack multiple times.
		4703	We only need to print it once. */
		4704
		4705	for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
		4706	{
		4707	if (! pdpm->printed)
		4708	{
		4709	if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
		4710	&& pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
		4711	&& pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
		4712	break;
		4713	if (pdpm->mod->type == dc->type)
		4714	{
		4715	d_print_comp (dpi, options, d_left (dc));
		4716	return;
		4717	}
		4718	}
		4719	}
		4720	}
		4721	goto modifier;
		4722
		4723	case DEMANGLE_COMPONENT_REFERENCE:
		4724	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
		4725	{
		4726	/* Handle reference smashing: & + && = &. */
		4727	const struct demangle_component *sub = d_left (dc);
		4728	if (sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
		4729	{
		4730	struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
		4731	struct demangle_component *a;
		4732
		4733	if (scope == NULL)
		4734	{
		4735	/* This is the first time SUB has been traversed.
		4736	We need to capture the current templates so
		4737	they can be restored if SUB is reentered as a
		4738	substitution. */
		4739	d_save_scope (dpi, sub);
		4740	if (d_print_saw_error (dpi))
		4741	return;
		4742	}
		4743	else
		4744	{
		4745	const struct d_component_stack *dcse;
		4746	int found_self_or_parent = 0;
		4747
		4748	/* This traversal is reentering SUB as a substition.
		4749	If we are not beneath SUB or DC in the tree then we
		4750	need to restore SUB's template stack temporarily. */
		4751	for (dcse = dpi->component_stack; dcse != NULL;
		4752	dcse = dcse->parent)
		4753	{
		4754	if (dcse->dc == sub
		4755	\|\| (dcse->dc == dc
		4756	&& dcse != dpi->component_stack))
		4757	{
		4758	found_self_or_parent = 1;
		4759	break;
		4760	}
		4761	}
		4762
		4763	if (!found_self_or_parent)
		4764	{
		4765	saved_templates = dpi->templates;
		4766	dpi->templates = scope->templates;
		4767	need_template_restore = 1;
		4768	}
		4769	}
		4770
		4771	a = d_lookup_template_argument (dpi, sub);
		4772	if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
		4773	a = d_index_template_argument (a, dpi->pack_index);
		4774
		4775	if (a == NULL)
		4776	{
		4777	if (need_template_restore)
		4778	dpi->templates = saved_templates;
		4779
		4780	d_print_error (dpi);
		4781	return;
		4782	}
		4783
		4784	sub = a;
		4785	}
		4786
		4787	if (sub->type == DEMANGLE_COMPONENT_REFERENCE
		4788	\|\| sub->type == dc->type)
		4789	dc = sub;
		4790	else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
		4791	mod_inner = d_left (sub);
		4792	}
		4793	/* Fall through. */
		4794
		4795	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		4796	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		4797	case DEMANGLE_COMPONENT_CONST_THIS:
		4798	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		4799	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		4800	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		4801	case DEMANGLE_COMPONENT_POINTER:
		4802	case DEMANGLE_COMPONENT_COMPLEX:
		4803	case DEMANGLE_COMPONENT_IMAGINARY:
		4804	modifier:
		4805	{
		4806	/* We keep a list of modifiers on the stack. */
		4807	struct d_print_mod dpm;
		4808
		4809	dpm.next = dpi->modifiers;
		4810	dpi->modifiers = &dpm;
		4811	dpm.mod = dc;
		4812	dpm.printed = 0;
		4813	dpm.templates = dpi->templates;
		4814
		4815	if (!mod_inner)
		4816	mod_inner = d_left (dc);
		4817
		4818	d_print_comp (dpi, options, mod_inner);
		4819
		4820	/* If the modifier didn't get printed by the type, print it
		4821	now. */
		4822	if (! dpm.printed)
		4823	d_print_mod (dpi, options, dc);
		4824
		4825	dpi->modifiers = dpm.next;
		4826
		4827	if (need_template_restore)
		4828	dpi->templates = saved_templates;
		4829
		4830	return;
		4831	}
		4832
		4833	case DEMANGLE_COMPONENT_BUILTIN_TYPE:
		4834	if ((options & DMGL_JAVA) == 0)
		4835	d_append_buffer (dpi, dc->u.s_builtin.type->name,
		4836	dc->u.s_builtin.type->len);
		4837	else
		4838	d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
		4839	dc->u.s_builtin.type->java_len);
		4840	return;
		4841
		4842	case DEMANGLE_COMPONENT_VENDOR_TYPE:
		4843	d_print_comp (dpi, options, d_left (dc));
		4844	return;
		4845
		4846	case DEMANGLE_COMPONENT_FUNCTION_TYPE:
		4847	{
		4848	if ((options & DMGL_RET_POSTFIX) != 0)
		4849	d_print_function_type (dpi,
		4850	options & ~(DMGL_RET_POSTFIX \| DMGL_RET_DROP),
		4851	dc, dpi->modifiers);
		4852
		4853	/* Print return type if present */
		4854	if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
		4855	d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX \| DMGL_RET_DROP),
		4856	d_left (dc));
		4857	else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
		4858	{
		4859	struct d_print_mod dpm;
		4860
		4861	/* We must pass this type down as a modifier in order to
		4862	print it in the right location. */
		4863	dpm.next = dpi->modifiers;
		4864	dpi->modifiers = &dpm;
		4865	dpm.mod = dc;
		4866	dpm.printed = 0;
		4867	dpm.templates = dpi->templates;
		4868
		4869	d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX \| DMGL_RET_DROP),
		4870	d_left (dc));
		4871
		4872	dpi->modifiers = dpm.next;
		4873
		4874	if (dpm.printed)
		4875	return;
		4876
		4877	/* In standard prefix notation, there is a space between the
		4878	return type and the function signature. */
		4879	if ((options & DMGL_RET_POSTFIX) == 0)
		4880	d_append_char (dpi, ' ');
		4881	}
		4882
		4883	if ((options & DMGL_RET_POSTFIX) == 0)
		4884	d_print_function_type (dpi,
		4885	options & ~(DMGL_RET_POSTFIX \| DMGL_RET_DROP),
		4886	dc, dpi->modifiers);
		4887
		4888	return;
		4889	}
		4890
		4891	case DEMANGLE_COMPONENT_ARRAY_TYPE:
		4892	{
		4893	struct d_print_mod *hold_modifiers;
		4894	struct d_print_mod adpm[4];
		4895	unsigned int i;
		4896	struct d_print_mod *pdpm;
		4897
		4898	/* We must pass this type down as a modifier in order to print
		4899	multi-dimensional arrays correctly. If the array itself is
		4900	CV-qualified, we act as though the element type were
		4901	CV-qualified. We do this by copying the modifiers down
		4902	rather than fiddling pointers, so that we don't wind up
		4903	with a d_print_mod higher on the stack pointing into our
		4904	stack frame after we return. */
		4905
		4906	hold_modifiers = dpi->modifiers;
		4907
		4908	adpm[0].next = hold_modifiers;
		4909	dpi->modifiers = &adpm[0];
		4910	adpm[0].mod = dc;
		4911	adpm[0].printed = 0;
		4912	adpm[0].templates = dpi->templates;
		4913
		4914	i = 1;
		4915	pdpm = hold_modifiers;
		4916	while (pdpm != NULL
		4917	&& (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
		4918	\|\| pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
		4919	\|\| pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
		4920	{
		4921	if (! pdpm->printed)
		4922	{
		4923	if (i >= sizeof adpm / sizeof adpm[0])
		4924	{
		4925	d_print_error (dpi);
		4926	return;
		4927	}
		4928
		4929	adpm[i] = *pdpm;
		4930	adpm[i].next = dpi->modifiers;
		4931	dpi->modifiers = &adpm[i];
		4932	pdpm->printed = 1;
		4933	++i;
		4934	}
		4935
		4936	pdpm = pdpm->next;
		4937	}
		4938
		4939	d_print_comp (dpi, options, d_right (dc));
		4940
		4941	dpi->modifiers = hold_modifiers;
		4942
		4943	if (adpm[0].printed)
		4944	return;
		4945
		4946	while (i > 1)
		4947	{
		4948	--i;
		4949	d_print_mod (dpi, options, adpm[i].mod);
		4950	}
		4951
		4952	d_print_array_type (dpi, options, dc, dpi->modifiers);
		4953
		4954	return;
		4955	}
		4956
		4957	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		4958	case DEMANGLE_COMPONENT_VECTOR_TYPE:
		4959	{
		4960	struct d_print_mod dpm;
		4961
		4962	dpm.next = dpi->modifiers;
		4963	dpi->modifiers = &dpm;
		4964	dpm.mod = dc;
		4965	dpm.printed = 0;
		4966	dpm.templates = dpi->templates;
		4967
		4968	d_print_comp (dpi, options, d_right (dc));
		4969
		4970	/* If the modifier didn't get printed by the type, print it
		4971	now. */
		4972	if (! dpm.printed)
		4973	d_print_mod (dpi, options, dc);
		4974
		4975	dpi->modifiers = dpm.next;
		4976
		4977	return;
		4978	}
		4979
		4980	case DEMANGLE_COMPONENT_FIXED_TYPE:
		4981	if (dc->u.s_fixed.sat)
		4982	d_append_string (dpi, "_Sat ");
		4983	/* Don't print "int _Accum". */
		4984	if (dc->u.s_fixed.length->u.s_builtin.type
		4985	!= &cplus_demangle_builtin_types['i'-'a'])
		4986	{
		4987	d_print_comp (dpi, options, dc->u.s_fixed.length);
		4988	d_append_char (dpi, ' ');
		4989	}
		4990	if (dc->u.s_fixed.accum)
		4991	d_append_string (dpi, "_Accum");
		4992	else
		4993	d_append_string (dpi, "_Fract");
		4994	return;
		4995
		4996	case DEMANGLE_COMPONENT_ARGLIST:
		4997	case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
		4998	if (d_left (dc) != NULL)
		4999	d_print_comp (dpi, options, d_left (dc));
		5000	if (d_right (dc) != NULL)
		5001	{
		5002	size_t len;
		5003	unsigned long int flush_count;
		5004	/* Make sure ", " isn't flushed by d_append_string, otherwise
		5005	dpi->len -= 2 wouldn't work. */
		5006	if (dpi->len >= sizeof (dpi->buf) - 2)
		5007	d_print_flush (dpi);
		5008	d_append_string (dpi, ", ");
		5009	len = dpi->len;
		5010	flush_count = dpi->flush_count;
		5011	d_print_comp (dpi, options, d_right (dc));
		5012	/* If that didn't print anything (which can happen with empty
		5013	template argument packs), remove the comma and space. */
		5014	if (dpi->flush_count == flush_count && dpi->len == len)
		5015	dpi->len -= 2;
		5016	}
		5017	return;
		5018
		5019	case DEMANGLE_COMPONENT_INITIALIZER_LIST:
		5020	{
		5021	struct demangle_component *type = d_left (dc);
		5022	struct demangle_component *list = d_right (dc);
		5023
		5024	if (type)
		5025	d_print_comp (dpi, options, type);
		5026	d_append_char (dpi, '{');
		5027	d_print_comp (dpi, options, list);
		5028	d_append_char (dpi, '}');
		5029	}
		5030	return;
		5031
		5032	case DEMANGLE_COMPONENT_OPERATOR:
		5033	{
		5034	const struct demangle_operator_info *op = dc->u.s_operator.op;
		5035	int len = op->len;
		5036
		5037	d_append_string (dpi, "operator");
		5038	/* Add a space before new/delete. */
		5039	if (IS_LOWER (op->name[0]))
		5040	d_append_char (dpi, ' ');
		5041	/* Omit a trailing space. */
		5042	if (op->name[len-1] == ' ')
		5043	--len;
		5044	d_append_buffer (dpi, op->name, len);
		5045	return;
		5046	}
		5047
		5048	case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
		5049	d_append_string (dpi, "operator ");
		5050	d_print_comp (dpi, options, dc->u.s_extended_operator.name);
		5051	return;
		5052
		5053	case DEMANGLE_COMPONENT_CONVERSION:
		5054	d_append_string (dpi, "operator ");
		5055	d_print_conversion (dpi, options, dc);
		5056	return;
		5057
		5058	case DEMANGLE_COMPONENT_NULLARY:
		5059	d_print_expr_op (dpi, options, d_left (dc));
		5060	return;
		5061
		5062	case DEMANGLE_COMPONENT_UNARY:
		5063	{
		5064	struct demangle_component *op = d_left (dc);
		5065	struct demangle_component *operand = d_right (dc);
		5066	const char *code = NULL;
		5067
		5068	if (op->type == DEMANGLE_COMPONENT_OPERATOR)
		5069	{
		5070	code = op->u.s_operator.op->code;
		5071	if (!strcmp (code, "ad"))
		5072	{
		5073	/* Don't print the argument list for the address of a
		5074	function. */
		5075	if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
		5076	&& d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
		5077	&& d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
		5078	operand = d_left (operand);
		5079	}
		5080	if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
		5081	{
		5082	/* This indicates a suffix operator. */
		5083	operand = d_left (operand);
		5084	d_print_subexpr (dpi, options, operand);
		5085	d_print_expr_op (dpi, options, op);
		5086	return;
		5087	}
		5088	}
		5089
		5090	if (op->type != DEMANGLE_COMPONENT_CAST)
		5091	d_print_expr_op (dpi, options, op);
		5092	else
		5093	{
		5094	d_append_char (dpi, '(');
		5095	d_print_cast (dpi, options, op);
		5096	d_append_char (dpi, ')');
		5097	}
		5098	if (code && !strcmp (code, "gs"))
		5099	/* Avoid parens after '::'. */
		5100	d_print_comp (dpi, options, operand);
		5101	else if (code && !strcmp (code, "st"))
		5102	/* Always print parens for sizeof (type). */
		5103	{
		5104	d_append_char (dpi, '(');
		5105	d_print_comp (dpi, options, operand);
		5106	d_append_char (dpi, ')');
		5107	}
		5108	else
		5109	d_print_subexpr (dpi, options, operand);
		5110	}
		5111	return;
		5112
		5113	case DEMANGLE_COMPONENT_BINARY:
		5114	if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
		5115	{
		5116	d_print_error (dpi);
		5117	return;
		5118	}
		5119
		5120	if (op_is_new_cast (d_left (dc)))
		5121	{
		5122	d_print_expr_op (dpi, options, d_left (dc));
		5123	d_append_char (dpi, '<');
		5124	d_print_comp (dpi, options, d_left (d_right (dc)));
		5125	d_append_string (dpi, ">(");
		5126	d_print_comp (dpi, options, d_right (d_right (dc)));
		5127	d_append_char (dpi, ')');
		5128	return;
		5129	}
		5130
		5131	/* We wrap an expression which uses the greater-than operator in
		5132	an extra layer of parens so that it does not get confused
		5133	with the '>' which ends the template parameters. */
		5134	if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
		5135	&& d_left (dc)->u.s_operator.op->len == 1
		5136	&& d_left (dc)->u.s_operator.op->name[0] == '>')
		5137	d_append_char (dpi, '(');
		5138
		5139	if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
		5140	&& d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
		5141	{
		5142	/* Function call used in an expression should not have printed types
		5143	of the function arguments. Values of the function arguments still
		5144	get printed below. */
		5145
		5146	const struct demangle_component *func = d_left (d_right (dc));
		5147
		5148	if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
		5149	d_print_error (dpi);
		5150	d_print_subexpr (dpi, options, d_left (func));
		5151	}
		5152	else
		5153	d_print_subexpr (dpi, options, d_left (d_right (dc)));
		5154	if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
		5155	{
		5156	d_append_char (dpi, '[');
		5157	d_print_comp (dpi, options, d_right (d_right (dc)));
		5158	d_append_char (dpi, ']');
		5159	}
		5160	else
		5161	{
		5162	if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
		5163	d_print_expr_op (dpi, options, d_left (dc));
		5164	d_print_subexpr (dpi, options, d_right (d_right (dc)));
		5165	}
		5166
		5167	if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
		5168	&& d_left (dc)->u.s_operator.op->len == 1
		5169	&& d_left (dc)->u.s_operator.op->name[0] == '>')
		5170	d_append_char (dpi, ')');
		5171
		5172	return;
		5173
		5174	case DEMANGLE_COMPONENT_BINARY_ARGS:
		5175	/* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
		5176	d_print_error (dpi);
		5177	return;
		5178
		5179	case DEMANGLE_COMPONENT_TRINARY:
		5180	if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
		5181	\|\| d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
		5182	{
		5183	d_print_error (dpi);
		5184	return;
		5185	}
		5186	{
		5187	struct demangle_component *op = d_left (dc);
		5188	struct demangle_component *first = d_left (d_right (dc));
		5189	struct demangle_component *second = d_left (d_right (d_right (dc)));
		5190	struct demangle_component *third = d_right (d_right (d_right (dc)));
		5191
		5192	if (!strcmp (op->u.s_operator.op->code, "qu"))
		5193	{
		5194	d_print_subexpr (dpi, options, first);
		5195	d_print_expr_op (dpi, options, op);
		5196	d_print_subexpr (dpi, options, second);
		5197	d_append_string (dpi, " : ");
		5198	d_print_subexpr (dpi, options, third);
		5199	}
		5200	else
		5201	{
		5202	d_append_string (dpi, "new ");
		5203	if (d_left (first) != NULL)
		5204	{
		5205	d_print_subexpr (dpi, options, first);
		5206	d_append_char (dpi, ' ');
		5207	}
		5208	d_print_comp (dpi, options, second);
		5209	if (third)
		5210	d_print_subexpr (dpi, options, third);
		5211	}
		5212	}
		5213	return;
		5214
		5215	case DEMANGLE_COMPONENT_TRINARY_ARG1:
		5216	case DEMANGLE_COMPONENT_TRINARY_ARG2:
		5217	/* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
		5218	d_print_error (dpi);
		5219	return;
		5220
		5221	case DEMANGLE_COMPONENT_LITERAL:
		5222	case DEMANGLE_COMPONENT_LITERAL_NEG:
		5223	{
		5224	enum d_builtin_type_print tp;
		5225
		5226	/* For some builtin types, produce simpler output. */
		5227	tp = D_PRINT_DEFAULT;
		5228	if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
		5229	{
		5230	tp = d_left (dc)->u.s_builtin.type->print;
		5231	switch (tp)
		5232	{
		5233	case D_PRINT_INT:
		5234	case D_PRINT_UNSIGNED:
		5235	case D_PRINT_LONG:
		5236	case D_PRINT_UNSIGNED_LONG:
		5237	case D_PRINT_LONG_LONG:
		5238	case D_PRINT_UNSIGNED_LONG_LONG:
		5239	if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
		5240	{
		5241	if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
		5242	d_append_char (dpi, '-');
		5243	d_print_comp (dpi, options, d_right (dc));
		5244	switch (tp)
		5245	{
		5246	default:
		5247	break;
		5248	case D_PRINT_UNSIGNED:
		5249	d_append_char (dpi, 'u');
		5250	break;
		5251	case D_PRINT_LONG:
		5252	d_append_char (dpi, 'l');
		5253	break;
		5254	case D_PRINT_UNSIGNED_LONG:
		5255	d_append_string (dpi, "ul");
		5256	break;
		5257	case D_PRINT_LONG_LONG:
		5258	d_append_string (dpi, "ll");
		5259	break;
		5260	case D_PRINT_UNSIGNED_LONG_LONG:
		5261	d_append_string (dpi, "ull");
		5262	break;
		5263	}
		5264	return;
		5265	}
		5266	break;
		5267
		5268	case D_PRINT_BOOL:
		5269	if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
		5270	&& d_right (dc)->u.s_name.len == 1
		5271	&& dc->type == DEMANGLE_COMPONENT_LITERAL)
		5272	{
		5273	switch (d_right (dc)->u.s_name.s[0])
		5274	{
		5275	case '0':
		5276	d_append_string (dpi, "false");
		5277	return;
		5278	case '1':
		5279	d_append_string (dpi, "true");
		5280	return;
		5281	default:
		5282	break;
		5283	}
		5284	}
		5285	break;
		5286
		5287	default:
		5288	break;
		5289	}
		5290	}
		5291
		5292	d_append_char (dpi, '(');
		5293	d_print_comp (dpi, options, d_left (dc));
		5294	d_append_char (dpi, ')');
		5295	if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
		5296	d_append_char (dpi, '-');
		5297	if (tp == D_PRINT_FLOAT)
		5298	d_append_char (dpi, '[');
		5299	d_print_comp (dpi, options, d_right (dc));
		5300	if (tp == D_PRINT_FLOAT)
		5301	d_append_char (dpi, ']');
		5302	}
		5303	return;
		5304
		5305	case DEMANGLE_COMPONENT_NUMBER:
		5306	d_append_num (dpi, dc->u.s_number.number);
		5307	return;
		5308
		5309	case DEMANGLE_COMPONENT_JAVA_RESOURCE:
		5310	d_append_string (dpi, "java resource ");
		5311	d_print_comp (dpi, options, d_left (dc));
		5312	return;
		5313
		5314	case DEMANGLE_COMPONENT_COMPOUND_NAME:
		5315	d_print_comp (dpi, options, d_left (dc));
		5316	d_print_comp (dpi, options, d_right (dc));
		5317	return;
		5318
		5319	case DEMANGLE_COMPONENT_CHARACTER:
		5320	d_append_char (dpi, dc->u.s_character.character);
		5321	return;
		5322
		5323	case DEMANGLE_COMPONENT_DECLTYPE:
		5324	d_append_string (dpi, "decltype (");
		5325	d_print_comp (dpi, options, d_left (dc));
		5326	d_append_char (dpi, ')');
		5327	return;
		5328
		5329	case DEMANGLE_COMPONENT_PACK_EXPANSION:
		5330	{
		5331	int len;
		5332	int i;
		5333	struct demangle_component *a = d_find_pack (dpi, d_left (dc));
		5334	if (a == NULL)
		5335	{
		5336	/* d_find_pack won't find anything if the only packs involved
		5337	in this expansion are function parameter packs; in that
		5338	case, just print the pattern and "...". */
		5339	d_print_subexpr (dpi, options, d_left (dc));
		5340	d_append_string (dpi, "...");
		5341	return;
		5342	}
		5343
		5344	len = d_pack_length (a);
		5345	dc = d_left (dc);
		5346	for (i = 0; i < len; ++i)
		5347	{
		5348	dpi->pack_index = i;
		5349	d_print_comp (dpi, options, dc);
		5350	if (i < len-1)
		5351	d_append_string (dpi, ", ");
		5352	}
		5353	}
		5354	return;
		5355
		5356	case DEMANGLE_COMPONENT_FUNCTION_PARAM:
		5357	{
		5358	long num = dc->u.s_number.number;
		5359	if (num == 0)
		5360	d_append_string (dpi, "this");
		5361	else
		5362	{
		5363	d_append_string (dpi, "{parm#");
		5364	d_append_num (dpi, num);
		5365	d_append_char (dpi, '}');
		5366	}
		5367	}
		5368	return;
		5369
		5370	case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
		5371	d_append_string (dpi, "global constructors keyed to ");
		5372	d_print_comp (dpi, options, dc->u.s_binary.left);
		5373	return;
		5374
		5375	case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
		5376	d_append_string (dpi, "global destructors keyed to ");
		5377	d_print_comp (dpi, options, dc->u.s_binary.left);
		5378	return;
		5379
		5380	case DEMANGLE_COMPONENT_LAMBDA:
		5381	d_append_string (dpi, "{lambda(");
		5382	d_print_comp (dpi, options, dc->u.s_unary_num.sub);
		5383	d_append_string (dpi, ")#");
		5384	d_append_num (dpi, dc->u.s_unary_num.num + 1);
		5385	d_append_char (dpi, '}');
		5386	return;
		5387
		5388	case DEMANGLE_COMPONENT_UNNAMED_TYPE:
		5389	d_append_string (dpi, "{unnamed type#");
		5390	d_append_num (dpi, dc->u.s_number.number + 1);
		5391	d_append_char (dpi, '}');
		5392	return;
		5393
		5394	case DEMANGLE_COMPONENT_CLONE:
		5395	d_print_comp (dpi, options, d_left (dc));
		5396	d_append_string (dpi, " [clone ");
		5397	d_print_comp (dpi, options, d_right (dc));
		5398	d_append_char (dpi, ']');
		5399	return;
		5400
		5401	default:
		5402	d_print_error (dpi);
		5403	return;
		5404	}
		5405	}
		5406
		5407	static void
		5408	d_print_comp (struct d_print_info *dpi, int options,
		5409	const struct demangle_component *dc)
		5410	{
		5411	struct d_component_stack self;
		5412
		5413	self.dc = dc;
		5414	self.parent = dpi->component_stack;
		5415	dpi->component_stack = &self;
		5416
		5417	d_print_comp_inner (dpi, options, dc);
		5418
		5419	dpi->component_stack = self.parent;
		5420	}
		5421
		5422	/* Print a Java dentifier. For Java we try to handle encoded extended
		5423	Unicode characters. The C++ ABI doesn't mention Unicode encoding,
		5424	so we don't it for C++. Characters are encoded as
		5425	__U+_. */
		5426
		5427	static void
		5428	d_print_java_identifier (struct d_print_info dpi, const char name, int len)
		5429	{
		5430	const char *p;
		5431	const char *end;
		5432
		5433	end = name + len;
		5434	for (p = name; p < end; ++p)
		5435	{
		5436	if (end - p > 3
		5437	&& p[0] == '_'
		5438	&& p[1] == '_'
		5439	&& p[2] == 'U')
		5440	{
		5441	unsigned long c;
		5442	const char *q;
		5443
		5444	c = 0;
		5445	for (q = p + 3; q < end; ++q)
		5446	{
		5447	int dig;
		5448
		5449	if (IS_DIGIT (*q))
		5450	dig = *q - '0';
		5451	else if (q >= 'A' && q <= 'F')
		5452	dig = *q - 'A' + 10;
		5453	else if (q >= 'a' && q <= 'f')
		5454	dig = *q - 'a' + 10;
		5455	else
		5456	break;
		5457
		5458	c = c * 16 + dig;
		5459	}
		5460	/* If the Unicode character is larger than 256, we don't try
		5461	to deal with it here. FIXME. */
		5462	if (q < end && *q == '_' && c < 256)
		5463	{
		5464	d_append_char (dpi, c);
		5465	p = q;
		5466	continue;
		5467	}
		5468	}
		5469
		5470	d_append_char (dpi, *p);
		5471	}
		5472	}
		5473
		5474	/* Print a list of modifiers. SUFFIX is 1 if we are printing
		5475	qualifiers on this after printing a function. */
		5476
		5477	static void
		5478	d_print_mod_list (struct d_print_info *dpi, int options,
		5479	struct d_print_mod *mods, int suffix)
		5480	{
		5481	struct d_print_template *hold_dpt;
		5482
		5483	if (mods == NULL \|\| d_print_saw_error (dpi))
		5484	return;
		5485
		5486	if (mods->printed
		5487	\|\| (! suffix
		5488	&& (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
		5489	\|\| mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
		5490	\|\| mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS
		5491	\|\| mods->mod->type == DEMANGLE_COMPONENT_REFERENCE_THIS
		5492	\|\| (mods->mod->type
		5493	== DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS))))
		5494	{
		5495	d_print_mod_list (dpi, options, mods->next, suffix);
		5496	return;
		5497	}
		5498
		5499	mods->printed = 1;
		5500
		5501	hold_dpt = dpi->templates;
		5502	dpi->templates = mods->templates;
		5503
		5504	if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
		5505	{
		5506	d_print_function_type (dpi, options, mods->mod, mods->next);
		5507	dpi->templates = hold_dpt;
		5508	return;
		5509	}
		5510	else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
		5511	{
		5512	d_print_array_type (dpi, options, mods->mod, mods->next);
		5513	dpi->templates = hold_dpt;
		5514	return;
		5515	}
		5516	else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
		5517	{
		5518	struct d_print_mod *hold_modifiers;
		5519	struct demangle_component *dc;
		5520
		5521	/* When this is on the modifier stack, we have pulled any
		5522	qualifiers off the right argument already. Otherwise, we
		5523	print it as usual, but don't let the left argument see any
		5524	modifiers. */
		5525
		5526	hold_modifiers = dpi->modifiers;
		5527	dpi->modifiers = NULL;
		5528	d_print_comp (dpi, options, d_left (mods->mod));
		5529	dpi->modifiers = hold_modifiers;
		5530
		5531	if ((options & DMGL_JAVA) == 0)
		5532	d_append_string (dpi, "::");
		5533	else
		5534	d_append_char (dpi, '.');
		5535
		5536	dc = d_right (mods->mod);
		5537
		5538	if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
		5539	{
		5540	d_append_string (dpi, "{default arg#");
		5541	d_append_num (dpi, dc->u.s_unary_num.num + 1);
		5542	d_append_string (dpi, "}::");
		5543	dc = dc->u.s_unary_num.sub;
		5544	}
		5545
		5546	while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
		5547	\|\| dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
		5548	\|\| dc->type == DEMANGLE_COMPONENT_CONST_THIS
		5549	\|\| dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
		5550	\|\| dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
		5551	dc = d_left (dc);
		5552
		5553	d_print_comp (dpi, options, dc);
		5554
		5555	dpi->templates = hold_dpt;
		5556	return;
		5557	}
		5558
		5559	d_print_mod (dpi, options, mods->mod);
		5560
		5561	dpi->templates = hold_dpt;
		5562
		5563	d_print_mod_list (dpi, options, mods->next, suffix);
		5564	}
		5565
		5566	/* Print a modifier. */
		5567
		5568	static void
		5569	d_print_mod (struct d_print_info *dpi, int options,
		5570	const struct demangle_component *mod)
		5571	{
		5572	switch (mod->type)
		5573	{
		5574	case DEMANGLE_COMPONENT_RESTRICT:
		5575	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		5576	d_append_string (dpi, " restrict");
		5577	return;
		5578	case DEMANGLE_COMPONENT_VOLATILE:
		5579	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		5580	d_append_string (dpi, " volatile");
		5581	return;
		5582	case DEMANGLE_COMPONENT_CONST:
		5583	case DEMANGLE_COMPONENT_CONST_THIS:
		5584	d_append_string (dpi, " const");
		5585	return;
		5586	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		5587	d_append_char (dpi, ' ');
		5588	d_print_comp (dpi, options, d_right (mod));
		5589	return;
		5590	case DEMANGLE_COMPONENT_POINTER:
		5591	/* There is no pointer symbol in Java. */
		5592	if ((options & DMGL_JAVA) == 0)
		5593	d_append_char (dpi, '*');
		5594	return;
		5595	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		5596	/* For the ref-qualifier, put a space before the &. */
		5597	d_append_char (dpi, ' ');
		5598	case DEMANGLE_COMPONENT_REFERENCE:
		5599	d_append_char (dpi, '&');
		5600	return;
		5601	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		5602	d_append_char (dpi, ' ');
		5603	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
		5604	d_append_string (dpi, "&&");
		5605	return;
		5606	case DEMANGLE_COMPONENT_COMPLEX:
		5607	d_append_string (dpi, "complex ");
		5608	return;
		5609	case DEMANGLE_COMPONENT_IMAGINARY:
		5610	d_append_string (dpi, "imaginary ");
		5611	return;
		5612	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		5613	if (d_last_char (dpi) != '(')
		5614	d_append_char (dpi, ' ');
		5615	d_print_comp (dpi, options, d_left (mod));
		5616	d_append_string (dpi, "::*");
		5617	return;
		5618	case DEMANGLE_COMPONENT_TYPED_NAME:
		5619	d_print_comp (dpi, options, d_left (mod));
		5620	return;
		5621	case DEMANGLE_COMPONENT_VECTOR_TYPE:
		5622	d_append_string (dpi, " __vector(");
		5623	d_print_comp (dpi, options, d_left (mod));
		5624	d_append_char (dpi, ')');
		5625	return;
		5626
		5627	default:
		5628	/* Otherwise, we have something that won't go back on the
		5629	modifier stack, so we can just print it. */
		5630	d_print_comp (dpi, options, mod);
		5631	return;
		5632	}
		5633	}
		5634
		5635	/* Print a function type, except for the return type. */
		5636
		5637	static void
		5638	d_print_function_type (struct d_print_info *dpi, int options,
		5639	const struct demangle_component *dc,
		5640	struct d_print_mod *mods)
		5641	{
		5642	int need_paren;
		5643	int need_space;
		5644	struct d_print_mod *p;
		5645	struct d_print_mod *hold_modifiers;
		5646
		5647	need_paren = 0;
		5648	need_space = 0;
		5649	for (p = mods; p != NULL; p = p->next)
		5650	{
		5651	if (p->printed)
		5652	break;
		5653
		5654	switch (p->mod->type)
		5655	{
		5656	case DEMANGLE_COMPONENT_POINTER:
		5657	case DEMANGLE_COMPONENT_REFERENCE:
		5658	case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
		5659	need_paren = 1;
		5660	break;
		5661	case DEMANGLE_COMPONENT_RESTRICT:
		5662	case DEMANGLE_COMPONENT_VOLATILE:
		5663	case DEMANGLE_COMPONENT_CONST:
		5664	case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
		5665	case DEMANGLE_COMPONENT_COMPLEX:
		5666	case DEMANGLE_COMPONENT_IMAGINARY:
		5667	case DEMANGLE_COMPONENT_PTRMEM_TYPE:
		5668	need_space = 1;
		5669	need_paren = 1;
		5670	break;
		5671	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		5672	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		5673	case DEMANGLE_COMPONENT_CONST_THIS:
		5674	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		5675	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		5676	break;
		5677	default:
		5678	break;
		5679	}
		5680	if (need_paren)
		5681	break;
		5682	}
		5683
		5684	if (need_paren)
		5685	{
		5686	if (! need_space)
		5687	{
		5688	if (d_last_char (dpi) != '('
		5689	&& d_last_char (dpi) != '*')
		5690	need_space = 1;
		5691	}
		5692	if (need_space && d_last_char (dpi) != ' ')
		5693	d_append_char (dpi, ' ');
		5694	d_append_char (dpi, '(');
		5695	}
		5696
		5697	hold_modifiers = dpi->modifiers;
		5698	dpi->modifiers = NULL;
		5699
		5700	d_print_mod_list (dpi, options, mods, 0);
		5701
		5702	if (need_paren)
		5703	d_append_char (dpi, ')');
		5704
		5705	d_append_char (dpi, '(');
		5706
		5707	if (d_right (dc) != NULL)
		5708	d_print_comp (dpi, options, d_right (dc));
		5709
		5710	d_append_char (dpi, ')');
		5711
		5712	d_print_mod_list (dpi, options, mods, 1);
		5713
		5714	dpi->modifiers = hold_modifiers;
		5715	}
		5716
		5717	/* Print an array type, except for the element type. */
		5718
		5719	static void
		5720	d_print_array_type (struct d_print_info *dpi, int options,
		5721	const struct demangle_component *dc,
		5722	struct d_print_mod *mods)
		5723	{
		5724	int need_space;
		5725
		5726	need_space = 1;
		5727	if (mods != NULL)
		5728	{
		5729	int need_paren;
		5730	struct d_print_mod *p;
		5731
		5732	need_paren = 0;
		5733	for (p = mods; p != NULL; p = p->next)
		5734	{
		5735	if (! p->printed)
		5736	{
		5737	if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
		5738	{
		5739	need_space = 0;
		5740	break;
		5741	}
		5742	else
		5743	{
		5744	need_paren = 1;
		5745	need_space = 1;
		5746	break;
		5747	}
		5748	}
		5749	}
		5750
		5751	if (need_paren)
		5752	d_append_string (dpi, " (");
		5753
		5754	d_print_mod_list (dpi, options, mods, 0);
		5755
		5756	if (need_paren)
		5757	d_append_char (dpi, ')');
		5758	}
		5759
		5760	if (need_space)
		5761	d_append_char (dpi, ' ');
		5762
		5763	d_append_char (dpi, '[');
		5764
		5765	if (d_left (dc) != NULL)
		5766	d_print_comp (dpi, options, d_left (dc));
		5767
		5768	d_append_char (dpi, ']');
		5769	}
		5770
		5771	/* Print an operator in an expression. */
		5772
		5773	static void
		5774	d_print_expr_op (struct d_print_info *dpi, int options,
		5775	const struct demangle_component *dc)
		5776	{
		5777	if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
		5778	d_append_buffer (dpi, dc->u.s_operator.op->name,
		5779	dc->u.s_operator.op->len);
		5780	else
		5781	d_print_comp (dpi, options, dc);
		5782	}
		5783
		5784	/* Print a cast. */
		5785
		5786	static void
		5787	d_print_cast (struct d_print_info *dpi, int options,
6556	serge	5788	const struct demangle_component *dc)
6554	serge	5789	{
6556	serge	5790	d_print_comp (dpi, options, d_left (dc));
6554	serge	5791	}
		5792
		5793	/* Print a conversion operator. */
		5794
		5795	static void
		5796	d_print_conversion (struct d_print_info *dpi, int options,
		5797	const struct demangle_component *dc)
		5798	{
		5799	struct d_print_template dpt;
		5800
		5801	/* For a conversion operator, we need the template parameters from
		5802	the enclosing template in scope for processing the type. */
		5803	if (dpi->current_template != NULL)
		5804	{
		5805	dpt.next = dpi->templates;
		5806	dpi->templates = &dpt;
		5807	dpt.template_decl = dpi->current_template;
		5808	}
		5809
		5810	if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
		5811	{
		5812	d_print_comp (dpi, options, d_left (dc));
		5813	if (dpi->current_template != NULL)
		5814	dpi->templates = dpt.next;
		5815	}
		5816	else
		5817	{
		5818	d_print_comp (dpi, options, d_left (d_left (dc)));
		5819
		5820	/* For a templated cast operator, we need to remove the template
		5821	parameters from scope after printing the operator name,
		5822	so we need to handle the template printing here. */
		5823	if (dpi->current_template != NULL)
6556	serge	5824	dpi->templates = dpt.next;
6554	serge	5825
		5826	if (d_last_char (dpi) == '<')
		5827	d_append_char (dpi, ' ');
		5828	d_append_char (dpi, '<');
		5829	d_print_comp (dpi, options, d_right (d_left (dc)));
		5830	/* Avoid generating two consecutive '>' characters, to avoid
		5831	the C++ syntactic ambiguity. */
		5832	if (d_last_char (dpi) == '>')
		5833	d_append_char (dpi, ' ');
		5834	d_append_char (dpi, '>');
		5835	}
		5836	}
		5837
		5838	/* Initialize the information structure we use to pass around
		5839	information. */
		5840
		5841	CP_STATIC_IF_GLIBCPP_V3
		5842	void
		5843	cplus_demangle_init_info (const char *mangled, int options, size_t len,
		5844	struct d_info *di)
		5845	{
		5846	di->s = mangled;
		5847	di->send = mangled + len;
		5848	di->options = options;
		5849
		5850	di->n = mangled;
		5851
		5852	/* We can not need more components than twice the number of chars in
		5853	the mangled string. Most components correspond directly to
		5854	chars, but the ARGLIST types are exceptions. */
		5855	di->num_comps = 2 * len;
		5856	di->next_comp = 0;
		5857
		5858	/* Similarly, we can not need more substitutions than there are
		5859	chars in the mangled string. */
		5860	di->num_subs = len;
		5861	di->next_sub = 0;
		5862	di->did_subs = 0;
		5863
		5864	di->last_name = NULL;
		5865
		5866	di->expansion = 0;
		5867	di->is_expression = 0;
		5868	di->is_conversion = 0;
		5869	}
		5870
		5871	/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
		5872	mangled name, return strings in repeated callback giving the demangled
		5873	name. OPTIONS is the usual libiberty demangler options. On success,
		5874	this returns 1. On failure, returns 0. */
		5875
		5876	static int
		5877	d_demangle_callback (const char *mangled, int options,
		5878	demangle_callbackref callback, void *opaque)
		5879	{
		5880	enum
		5881	{
		5882	DCT_TYPE,
		5883	DCT_MANGLED,
		5884	DCT_GLOBAL_CTORS,
		5885	DCT_GLOBAL_DTORS
		5886	}
		5887	type;
		5888	struct d_info di;
		5889	struct demangle_component *dc;
		5890	int status;
		5891
		5892	if (mangled[0] == '_' && mangled[1] == 'Z')
		5893	type = DCT_MANGLED;
		5894	else if (strncmp (mangled, "_GLOBAL_", 8) == 0
		5895	&& (mangled[8] == '.' \|\| mangled[8] == '_' \|\| mangled[8] == '$')
		5896	&& (mangled[9] == 'D' \|\| mangled[9] == 'I')
		5897	&& mangled[10] == '_')
		5898	type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
		5899	else
		5900	{
		5901	if ((options & DMGL_TYPES) == 0)
		5902	return 0;
		5903	type = DCT_TYPE;
		5904	}
		5905
		5906	cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
		5907
		5908	{
		5909	#ifdef CP_DYNAMIC_ARRAYS
		5910	__extension__ struct demangle_component comps[di.num_comps];
		5911	__extension__ struct demangle_component *subs[di.num_subs];
		5912
		5913	di.comps = comps;
		5914	di.subs = subs;
		5915	#else
		5916	di.comps = alloca (di.num_comps * sizeof (*di.comps));
		5917	di.subs = alloca (di.num_subs * sizeof (*di.subs));
		5918	#endif
		5919
		5920	switch (type)
		5921	{
		5922	case DCT_TYPE:
		5923	dc = cplus_demangle_type (&di);
		5924	break;
		5925	case DCT_MANGLED:
		5926	dc = cplus_demangle_mangled_name (&di, 1);
		5927	break;
		5928	case DCT_GLOBAL_CTORS:
		5929	case DCT_GLOBAL_DTORS:
		5930	d_advance (&di, 11);
		5931	dc = d_make_comp (&di,
		5932	(type == DCT_GLOBAL_CTORS
		5933	? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
		5934	: DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
		5935	d_make_demangle_mangled_name (&di, d_str (&di)),
		5936	NULL);
		5937	d_advance (&di, strlen (d_str (&di)));
		5938	break;
		5939	default:
		5940	abort (); /* We have listed all the cases. */
		5941	}
		5942
		5943	/* If DMGL_PARAMS is set, then if we didn't consume the entire
		5944	mangled string, then we didn't successfully demangle it. If
		5945	DMGL_PARAMS is not set, we didn't look at the trailing
		5946	parameters. */
		5947	if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
		5948	dc = NULL;
		5949
		5950	#ifdef CP_DEMANGLE_DEBUG
		5951	d_dump (dc, 0);
		5952	#endif
		5953
		5954	status = (dc != NULL)
		5955	? cplus_demangle_print_callback (options, dc, callback, opaque)
		5956	: 0;
		5957	}
		5958
		5959	return status;
		5960	}
		5961
		5962	/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
		5963	name, return a buffer allocated with malloc holding the demangled
		5964	name. OPTIONS is the usual libiberty demangler options. On
		5965	success, this sets *PALC to the allocated size of the returned
		5966	buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
		5967	a memory allocation failure, and returns NULL. */
		5968
		5969	static char *
		5970	d_demangle (const char mangled, int options, size_t palc)
		5971	{
		5972	struct d_growable_string dgs;
		5973	int status;
		5974
		5975	d_growable_string_init (&dgs, 0);
		5976
		5977	status = d_demangle_callback (mangled, options,
		5978	d_growable_string_callback_adapter, &dgs);
		5979	if (status == 0)
		5980	{
		5981	free (dgs.buf);
		5982	*palc = 0;
		5983	return NULL;
		5984	}
		5985
		5986	*palc = dgs.allocation_failure ? 1 : dgs.alc;
		5987	return dgs.buf;
		5988	}
		5989
		5990	#if defined(IN_LIBGCC2) \|\| defined(IN_GLIBCPP_V3)
		5991
		5992	extern char __cxa_demangle (const char , char , size_t , int *);
		5993
		5994	/* ia64 ABI-mandated entry point in the C++ runtime library for
		5995	performing demangling. MANGLED_NAME is a NUL-terminated character
		5996	string containing the name to be demangled.
		5997
		5998	OUTPUT_BUFFER is a region of memory, allocated with malloc, of
		5999	*LENGTH bytes, into which the demangled name is stored. If
		6000	OUTPUT_BUFFER is not long enough, it is expanded using realloc.
		6001	OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
		6002	is placed in a region of memory allocated with malloc.
		6003
		6004	If LENGTH is non-NULL, the length of the buffer containing the
		6005	demangled name, is placed in *LENGTH.
		6006
		6007	The return value is a pointer to the start of the NUL-terminated
		6008	demangled name, or NULL if the demangling fails. The caller is
		6009	responsible for deallocating this memory using free.
		6010
		6011	*STATUS is set to one of the following values:
		6012	0: The demangling operation succeeded.
		6013	-1: A memory allocation failure occurred.
		6014	-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
		6015	-3: One of the arguments is invalid.
		6016
		6017	The demangling is performed using the C++ ABI mangling rules, with
		6018	GNU extensions. */
		6019
		6020	char *
		6021	__cxa_demangle (const char mangled_name, char output_buffer,
		6022	size_t length, int status)
		6023	{
		6024	char *demangled;
		6025	size_t alc;
		6026
		6027	if (mangled_name == NULL)
		6028	{
		6029	if (status != NULL)
		6030	*status = -3;
		6031	return NULL;
		6032	}
		6033
		6034	if (output_buffer != NULL && length == NULL)
		6035	{
		6036	if (status != NULL)
		6037	*status = -3;
		6038	return NULL;
		6039	}
		6040
		6041	demangled = d_demangle (mangled_name, DMGL_PARAMS \| DMGL_TYPES, &alc);
		6042
		6043	if (demangled == NULL)
		6044	{
		6045	if (status != NULL)
		6046	{
		6047	if (alc == 1)
		6048	*status = -1;
		6049	else
		6050	*status = -2;
		6051	}
		6052	return NULL;
		6053	}
		6054
		6055	if (output_buffer == NULL)
		6056	{
		6057	if (length != NULL)
		6058	*length = alc;
		6059	}
		6060	else
		6061	{
		6062	if (strlen (demangled) < *length)
		6063	{
		6064	strcpy (output_buffer, demangled);
		6065	free (demangled);
		6066	demangled = output_buffer;
		6067	}
		6068	else
		6069	{
		6070	free (output_buffer);
		6071	*length = alc;
		6072	}
		6073	}
		6074
		6075	if (status != NULL)
		6076	*status = 0;
		6077
		6078	return demangled;
		6079	}
		6080
		6081	extern int __gcclibcxx_demangle_callback (const char *,
		6082	void (*)
		6083	(const char , size_t, void ),
		6084	void *);
		6085
		6086	/* Alternative, allocationless entry point in the C++ runtime library
		6087	for performing demangling. MANGLED_NAME is a NUL-terminated character
		6088	string containing the name to be demangled.
		6089
		6090	CALLBACK is a callback function, called with demangled string
		6091	segments as demangling progresses; it is called at least once,
		6092	but may be called more than once. OPAQUE is a generalized pointer
		6093	used as a callback argument.
		6094
		6095	The return code is one of the following values, equivalent to
		6096	the STATUS values of __cxa_demangle() (excluding -1, since this
		6097	function performs no memory allocations):
		6098	0: The demangling operation succeeded.
		6099	-2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
		6100	-3: One of the arguments is invalid.
		6101
		6102	The demangling is performed using the C++ ABI mangling rules, with
		6103	GNU extensions. */
		6104
		6105	int
		6106	__gcclibcxx_demangle_callback (const char *mangled_name,
		6107	void (callback) (const char , size_t, void *),
		6108	void *opaque)
		6109	{
		6110	int status;
		6111
		6112	if (mangled_name == NULL \|\| callback == NULL)
		6113	return -3;
		6114
		6115	status = d_demangle_callback (mangled_name, DMGL_PARAMS \| DMGL_TYPES,
		6116	callback, opaque);
		6117	if (status == 0)
		6118	return -2;
		6119
		6120	return 0;
		6121	}
		6122
		6123	#else /* ! (IN_LIBGCC2 \|\| IN_GLIBCPP_V3) */
		6124
		6125	/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
		6126	mangled name, return a buffer allocated with malloc holding the
		6127	demangled name. Otherwise, return NULL. */
		6128
		6129	char *
		6130	cplus_demangle_v3 (const char *mangled, int options)
		6131	{
		6132	size_t alc;
		6133
		6134	return d_demangle (mangled, options, &alc);
		6135	}
		6136
		6137	int
		6138	cplus_demangle_v3_callback (const char *mangled, int options,
		6139	demangle_callbackref callback, void *opaque)
		6140	{
		6141	return d_demangle_callback (mangled, options, callback, opaque);
		6142	}
		6143
		6144	/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
		6145	conventions, but the output formatting is a little different.
		6146	This instructs the C++ demangler not to emit pointer characters ("*"), to
		6147	use Java's namespace separator symbol ("." instead of "::"), and to output
		6148	JArray as TYPE[]. */
		6149
		6150	char *
		6151	java_demangle_v3 (const char *mangled)
		6152	{
		6153	size_t alc;
		6154
		6155	return d_demangle (mangled, DMGL_JAVA \| DMGL_PARAMS \| DMGL_RET_POSTFIX, &alc);
		6156	}
		6157
		6158	int
		6159	java_demangle_v3_callback (const char *mangled,
		6160	demangle_callbackref callback, void *opaque)
		6161	{
		6162	return d_demangle_callback (mangled,
		6163	DMGL_JAVA \| DMGL_PARAMS \| DMGL_RET_POSTFIX,
		6164	callback, opaque);
		6165	}
		6166
		6167	#endif /* IN_LIBGCC2 \|\| IN_GLIBCPP_V3 */
		6168
		6169	#ifndef IN_GLIBCPP_V3
		6170
		6171	/* Demangle a string in order to find out whether it is a constructor
		6172	or destructor. Return non-zero on success. Set *CTOR_KIND and
		6173	DTOR_KIND appropriately. /
		6174
		6175	static int
		6176	is_ctor_or_dtor (const char *mangled,
		6177	enum gnu_v3_ctor_kinds *ctor_kind,
		6178	enum gnu_v3_dtor_kinds *dtor_kind)
		6179	{
		6180	struct d_info di;
		6181	struct demangle_component *dc;
		6182	int ret;
		6183
		6184	*ctor_kind = (enum gnu_v3_ctor_kinds) 0;
		6185	*dtor_kind = (enum gnu_v3_dtor_kinds) 0;
		6186
		6187	cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
		6188
		6189	{
		6190	#ifdef CP_DYNAMIC_ARRAYS
		6191	__extension__ struct demangle_component comps[di.num_comps];
		6192	__extension__ struct demangle_component *subs[di.num_subs];
		6193
		6194	di.comps = comps;
		6195	di.subs = subs;
		6196	#else
		6197	di.comps = alloca (di.num_comps * sizeof (*di.comps));
		6198	di.subs = alloca (di.num_subs * sizeof (*di.subs));
		6199	#endif
		6200
		6201	dc = cplus_demangle_mangled_name (&di, 1);
		6202
		6203	/* Note that because we did not pass DMGL_PARAMS, we don't expect
		6204	to demangle the entire string. */
		6205
		6206	ret = 0;
		6207	while (dc != NULL)
		6208	{
		6209	switch (dc->type)
		6210	{
		6211	/* These cannot appear on a constructor or destructor. */
		6212	case DEMANGLE_COMPONENT_RESTRICT_THIS:
		6213	case DEMANGLE_COMPONENT_VOLATILE_THIS:
		6214	case DEMANGLE_COMPONENT_CONST_THIS:
		6215	case DEMANGLE_COMPONENT_REFERENCE_THIS:
		6216	case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
		6217	default:
		6218	dc = NULL;
		6219	break;
		6220	case DEMANGLE_COMPONENT_TYPED_NAME:
		6221	case DEMANGLE_COMPONENT_TEMPLATE:
		6222	dc = d_left (dc);
		6223	break;
		6224	case DEMANGLE_COMPONENT_QUAL_NAME:
		6225	case DEMANGLE_COMPONENT_LOCAL_NAME:
		6226	dc = d_right (dc);
		6227	break;
		6228	case DEMANGLE_COMPONENT_CTOR:
		6229	*ctor_kind = dc->u.s_ctor.kind;
		6230	ret = 1;
		6231	dc = NULL;
		6232	break;
		6233	case DEMANGLE_COMPONENT_DTOR:
		6234	*dtor_kind = dc->u.s_dtor.kind;
		6235	ret = 1;
		6236	dc = NULL;
		6237	break;
		6238	}
		6239	}
		6240	}
		6241
		6242	return ret;
		6243	}
		6244
		6245	/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
		6246	name. A non-zero return indicates the type of constructor. */
		6247
		6248	enum gnu_v3_ctor_kinds
		6249	is_gnu_v3_mangled_ctor (const char *name)
		6250	{
		6251	enum gnu_v3_ctor_kinds ctor_kind;
		6252	enum gnu_v3_dtor_kinds dtor_kind;
		6253
		6254	if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
		6255	return (enum gnu_v3_ctor_kinds) 0;
		6256	return ctor_kind;
		6257	}
		6258
		6259
		6260	/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
		6261	name. A non-zero return indicates the type of destructor. */
		6262
		6263	enum gnu_v3_dtor_kinds
		6264	is_gnu_v3_mangled_dtor (const char *name)
		6265	{
		6266	enum gnu_v3_ctor_kinds ctor_kind;
		6267	enum gnu_v3_dtor_kinds dtor_kind;
		6268
		6269	if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
		6270	return (enum gnu_v3_dtor_kinds) 0;
		6271	return dtor_kind;
		6272	}
		6273
		6274	#endif /* IN_GLIBCPP_V3 */
		6275
		6276	#ifdef STANDALONE_DEMANGLER
		6277
		6278	#include "getopt.h"
		6279	#include "dyn-string.h"
		6280
		6281	static void print_usage (FILE* fp, int exit_value);
		6282
		6283	#define IS_ALPHA(CHAR) \
		6284	(((CHAR) >= 'a' && (CHAR) <= 'z') \
		6285	\|\| ((CHAR) >= 'A' && (CHAR) <= 'Z'))
		6286
		6287	/* Non-zero if CHAR is a character than can occur in a mangled name. */
		6288	#define is_mangled_char(CHAR) \
		6289	(IS_ALPHA (CHAR) \|\| IS_DIGIT (CHAR) \
		6290	\|\| (CHAR) == '_' \|\| (CHAR) == '.' \|\| (CHAR) == '$')
		6291
		6292	/* The name of this program, as invoked. */
		6293	const char* program_name;
		6294
		6295	/* Prints usage summary to FP and then exits with EXIT_VALUE. */
		6296
		6297	static void
		6298	print_usage (FILE* fp, int exit_value)
		6299	{
		6300	fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
		6301	fprintf (fp, "Options:\n");
		6302	fprintf (fp, " -h,--help Display this message.\n");
		6303	fprintf (fp, " -p,--no-params Don't display function parameters\n");
		6304	fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
		6305	fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
		6306
		6307	exit (exit_value);
		6308	}
		6309
		6310	/* Option specification for getopt_long. */
		6311	static const struct option long_options[] =
		6312	{
		6313	{ "help", no_argument, NULL, 'h' },
		6314	{ "no-params", no_argument, NULL, 'p' },
		6315	{ "verbose", no_argument, NULL, 'v' },
		6316	{ NULL, no_argument, NULL, 0 },
		6317	};
		6318
		6319	/* Main entry for a demangling filter executable. It will demangle
		6320	its command line arguments, if any. If none are provided, it will
		6321	filter stdin to stdout, replacing any recognized mangled C++ names
		6322	with their demangled equivalents. */
		6323
		6324	int
		6325	main (int argc, char *argv[])
		6326	{
		6327	int i;
		6328	int opt_char;
		6329	int options = DMGL_PARAMS \| DMGL_ANSI \| DMGL_TYPES;
		6330
		6331	/* Use the program name of this program, as invoked. */
		6332	program_name = argv[0];
		6333
		6334	/* Parse options. */
		6335	do
		6336	{
		6337	opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
		6338	switch (opt_char)
		6339	{
		6340	case '?': /* Unrecognized option. */
		6341	print_usage (stderr, 1);
		6342	break;
		6343
		6344	case 'h':
		6345	print_usage (stdout, 0);
		6346	break;
		6347
		6348	case 'p':
		6349	options &= ~ DMGL_PARAMS;
		6350	break;
		6351
		6352	case 'v':
		6353	options \|= DMGL_VERBOSE;
		6354	break;
		6355	}
		6356	}
		6357	while (opt_char != -1);
		6358
		6359	if (optind == argc)
		6360	/* No command line arguments were provided. Filter stdin. */
		6361	{
		6362	dyn_string_t mangled = dyn_string_new (3);
		6363	char *s;
		6364
		6365	/* Read all of input. */
		6366	while (!feof (stdin))
		6367	{
		6368	char c;
		6369
		6370	/* Pile characters into mangled until we hit one that can't
		6371	occur in a mangled name. */
		6372	c = getchar ();
		6373	while (!feof (stdin) && is_mangled_char (c))
		6374	{
		6375	dyn_string_append_char (mangled, c);
		6376	if (feof (stdin))
		6377	break;
		6378	c = getchar ();
		6379	}
		6380
		6381	if (dyn_string_length (mangled) > 0)
		6382	{
		6383	#ifdef IN_GLIBCPP_V3
		6384	s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
		6385	#else
		6386	s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
		6387	#endif
		6388
		6389	if (s != NULL)
		6390	{
		6391	fputs (s, stdout);
		6392	free (s);
		6393	}
		6394	else
		6395	{
		6396	/* It might not have been a mangled name. Print the
		6397	original text. */
		6398	fputs (dyn_string_buf (mangled), stdout);
		6399	}
		6400
		6401	dyn_string_clear (mangled);
		6402	}
		6403
		6404	/* If we haven't hit EOF yet, we've read one character that
		6405	can't occur in a mangled name, so print it out. */
		6406	if (!feof (stdin))
		6407	putchar (c);
		6408	}
		6409
		6410	dyn_string_delete (mangled);
		6411	}
		6412	else
		6413	/* Demangle command line arguments. */
		6414	{
		6415	/* Loop over command line arguments. */
		6416	for (i = optind; i < argc; ++i)
		6417	{
		6418	char *s;
		6419	#ifdef IN_GLIBCPP_V3
		6420	int status;
		6421	#endif
		6422
		6423	/* Attempt to demangle. */
		6424	#ifdef IN_GLIBCPP_V3
		6425	s = __cxa_demangle (argv[i], NULL, NULL, &status);
		6426	#else
		6427	s = cplus_demangle_v3 (argv[i], options);
		6428	#endif
		6429
		6430	/* If it worked, print the demangled name. */
		6431	if (s != NULL)
		6432	{
		6433	printf ("%s\n", s);
		6434	free (s);
		6435	}
		6436	else
		6437	{
		6438	#ifdef IN_GLIBCPP_V3
		6439	fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
		6440	#else
		6441	fprintf (stderr, "Failed: %s\n", argv[i]);
		6442	#endif
		6443	}
		6444	}
		6445	}
		6446
		6447	return 0;
		6448	}
		6449
		6450	#endif /* STANDALONE_DEMANGLER */

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/gcc/5x/libstdc++-v3/libsupc++/cp-demangle.c – Rev 6556