Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

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