Bug Summary

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