Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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