/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/cp-demangle.c

Bug Summary

File:	build/libiberty/cp-demangle.c
Warning:	line 6341, column 17 Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name cp-demangle.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D HAVE_CONFIG_H -I . -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/../include -D _GNU_SOURCE -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wwrite-strings -fconst-strings -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/build-x86_64-pc-linux-gnu/libiberty -ferror-limit 19 -fcf-protection=full -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-LIpk7h.plist -x c /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/libiberty/cp-demangle.c

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