projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New gdbarch memory tagging hooks
[deliverable/binutils-gdb.git] / libiberty / cp-demangle.c
CommitLineData
d00edca5 1/* Demangler for g++ V3 ABI.
250d07de 2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
d00edca5 3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
eb383413 4
9ad1aa29 5 This file is part of the libiberty library, which is part of GCC.
74bcd529 6
9ad1aa29 7 This file is free software; you can redistribute it and/or modify
eb383413
L		 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
35efcd67
DD		 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
eb383413
L		 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
979c05d3 28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
eb383413
L		 29*/
30
858b45cf
DD		 31/* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
e9301e76 33 https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
858b45cf
DD		 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)
208c1674
DD		 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)
858b45cf
DD		 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
59727473
DD		 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
208c1674 57 demangle_callbackref
59727473
DD		 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
208c1674 64 cplus_demangle_print_callback
59727473
DD		 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
858b45cf
DD		 70 Preprocessor macros you can define while compiling this file:
71
72 IN_LIBGCC2
208c1674 73 If defined, this file defines the following functions, q.v.:
858b45cf
DD		 74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
75 int *status)
208c1674
DD		 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]().
858b45cf
DD		 82
83 IN_GLIBCPP_V3
208c1674
DD		 84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
858b45cf
DD		 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.
d81bf7dd
MM		 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. */
858b45cf 100
208c1674
DD		 101#if defined (_AIX) && !defined (__GNUC__)
102 #pragma alloca
103#endif
104
eb383413
L		 105#ifdef HAVE_CONFIG_H
106#include "config.h"
107#endif
108
d00edca5 109#include <stdio.h>
b1233257 110
eb383413
L		 111#ifdef HAVE_STDLIB_H
112#include <stdlib.h>
113#endif
eb383413
L		 114#ifdef HAVE_STRING_H
115#include <string.h>
116#endif
117
208c1674
DD		 118#ifdef HAVE_ALLOCA_H
119# include <alloca.h>
120#else
121# ifndef alloca
122# ifdef __GNUC__
123# define alloca __builtin_alloca
124# else
125extern char *alloca ();
126# endif /* __GNUC__ */
127# endif /* alloca */
128#endif /* HAVE_ALLOCA_H */
129
fa3fcee7
NC		 130#ifdef HAVE_LIMITS_H
131#include <limits.h>
132#endif
133#ifndef INT_MAX
134# define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
135#endif
136
eb383413
L		 137#include "ansidecl.h"
138#include "libiberty.h"
eb383413 139#include "demangle.h"
59727473
DD		 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
9334f9c6 151static int d_fill_name (struct demangle_component *, const char *, int);
59727473
DD		 152
153#define cplus_demangle_fill_extended_operator d_fill_extended_operator
154static int
9334f9c6
DD		 155d_fill_extended_operator (struct demangle_component *, int,
156 struct demangle_component *);
59727473
DD		 157
158#define cplus_demangle_fill_ctor d_fill_ctor
159static int
9334f9c6
DD		 160d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
161 struct demangle_component *);
59727473
DD		 162
163#define cplus_demangle_fill_dtor d_fill_dtor
164static int
9334f9c6
DD		 165d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
166 struct demangle_component *);
59727473
DD		 167
168#define cplus_demangle_mangled_name d_mangled_name
9334f9c6 169static struct demangle_component *d_mangled_name (struct d_info *, int);
59727473
DD		 170
171#define cplus_demangle_type d_type
9334f9c6 172static struct demangle_component *d_type (struct d_info *);
59727473
DD		 173
174#define cplus_demangle_print d_print
c793cac1 175static char *d_print (int, struct demangle_component *, int, size_t *);
59727473 176
208c1674 177#define cplus_demangle_print_callback d_print_callback
c793cac1 178static int d_print_callback (int, struct demangle_component *,
208c1674
DD		 179 demangle_callbackref, void *);
180
59727473 181#define cplus_demangle_init_info d_init_info
9334f9c6 182static void d_init_info (const char *, int, size_t, struct d_info *);
59727473
DD		 183
184#else /* ! defined(IN_GLIBCPP_V3) */
185#define CP_STATIC_IF_GLIBCPP_V3
186#endif /* ! defined(IN_GLIBCPP_V3) */
eb383413 187
b6fb00c0
DD		 188/* See if the compiler supports dynamic arrays. */
189
190#ifdef __GNUC__
191#define CP_DYNAMIC_ARRAYS
192#else
193#ifdef __STDC__
194#ifdef __STDC_VERSION__
f211b8c0 195#if __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__
b6fb00c0 196#define CP_DYNAMIC_ARRAYS
f211b8c0 197#endif /* __STDC_VERSION__ >= 199901L && !__STDC_NO_VLA__ */
b6fb00c0
DD		 198#endif /* defined (__STDC_VERSION__) */
199#endif /* defined (__STDC__) */
200#endif /* ! defined (__GNUC__) */
201
858b45cf
DD		 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.
d00edca5 206
858b45cf 207 As of this writing this file has the following undefined references
208c1674
DD		 208 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
209 strcat, strlen. */
d00edca5 210
d00edca5 211#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
858b45cf
DD		 212#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
213#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
03d5f569 214
74bcd529
DD		 215/* The prefix prepended by GCC to an identifier represnting the
216 anonymous namespace. */
217#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
d00edca5
DD		 218#define ANONYMOUS_NAMESPACE_PREFIX_LEN \
219 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
74bcd529 220
97ceaf5b
DD		 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;
b6fb00c0
DD		 229 /* The length of the simple expansion. */
230 int simple_len;
97ceaf5b
DD		 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;
b6fb00c0
DD		 234 /* The length of the full expansion. */
235 int full_len;
97ceaf5b
DD		 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;
b6fb00c0
DD		 240 /* The length of set_last_name. */
241 int set_last_name_len;
97ceaf5b
DD		 242};
243
59727473 244/* Accessors for subtrees of struct demangle_component. */
eb383413 245
d00edca5
DD		 246#define d_left(dc) ((dc)->u.s_binary.left)
247#define d_right(dc) ((dc)->u.s_binary.right)
248
d00edca5 249/* A list of templates. This is used while printing. */
eb383413 250
d00edca5
DD		 251struct d_print_template
252{
253 /* Next template on the list. */
254 struct d_print_template *next;
255 /* This template. */
abf6a75b 256 const struct demangle_component *template_decl;
d00edca5 257};
eb383413 258
d00edca5 259/* A list of type modifiers. This is used while printing. */
eb383413 260
d00edca5
DD		 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. */
c793cac1 267 struct demangle_component *mod;
d00edca5
DD		 268 /* Whether this modifier was printed. */
269 int printed;
331c3da2
DD		 270 /* The list of templates which applies to this modifier. */
271 struct d_print_template *templates;
d00edca5 272};
eb383413 273
208c1674 274/* We use these structures to hold information during printing. */
d00edca5 275
208c1674 276struct d_growable_string
d00edca5 277{
d00edca5
DD		 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;
208c1674
DD		 284 /* Set to 1 if we had a memory allocation failure. */
285 int allocation_failure;
286};
287
91662bad 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
9548bbed 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
492e19d0 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;
492e19d0 319 int expansion;
320};
321
2d3392bd
IB		 322/* Maximum number of times d_print_comp may be called recursively. */
323#define MAX_RECURSION_COUNT 1024
324
208c1674
DD		 325enum { D_PRINT_BUFFER_LENGTH = 256 };
326struct d_print_info
327{
208c1674
DD		 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;
d00edca5
DD		 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;
208c1674
DD		 345 /* Set to 1 if we saw a demangling error. */
346 int demangle_failure;
2d3392bd
IB		 347 /* Number of times d_print_comp was recursively called. Should not
348 be bigger than MAX_RECURSION_COUNT. */
349 int recursion;
88acc2e1
NS		 350 /* Non-zero if we're printing a lambda argument. A template
351 parameter reference actually means 'auto'. */
352 int is_lambda_arg;
1c08f2c8 353 /* The current index into any template argument packs we are using
fa3fcee7 354 for printing, or -1 to print the whole pack. */
1c08f2c8 355 int pack_index;
3baae9d6
JJ		 356 /* Number of d_print_flush calls so far. */
357 unsigned long int flush_count;
91662bad 358 /* Stack of components, innermost first, used to avoid loops. */
359 const struct d_component_stack *component_stack;
9548bbed 360 /* Array of saved scopes for evaluating substitutions. */
361 struct d_saved_scope *saved_scopes;
fd259167
GB		 362 /* Index of the next unused saved scope in the above array. */
363 int next_saved_scope;
9548bbed 364 /* Number of saved scopes in the above array. */
365 int num_saved_scopes;
fd259167
GB		 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;
492e19d0 372 /* The nearest enclosing template, if any. */
373 const struct demangle_component *current_template;
d00edca5 374};
e61231f1 375
eb383413 376#ifdef CP_DEMANGLE_DEBUG
9334f9c6 377static void d_dump (struct demangle_component *, int);
eb383413 378#endif
59727473
DD		 379
380static struct demangle_component *
9334f9c6 381d_make_empty (struct d_info *);
59727473
DD		 382
383static struct demangle_component *
9334f9c6
DD		 384d_make_comp (struct d_info *, enum demangle_component_type,
385 struct demangle_component *,
386 struct demangle_component *);
59727473
DD		 387
388static struct demangle_component *
9334f9c6 389d_make_name (struct d_info *, const char *, int);
59727473 390
a0692e36
L		 391static struct demangle_component *
392d_make_demangle_mangled_name (struct d_info *, const char *);
393
59727473 394static struct demangle_component *
9334f9c6
DD		 395d_make_builtin_type (struct d_info *,
396 const struct demangle_builtin_type_info *);
59727473
DD		 397
398static struct demangle_component *
9334f9c6
DD		 399d_make_operator (struct d_info *,
400 const struct demangle_operator_info *);
59727473
DD		 401
402static struct demangle_component *
9334f9c6
DD		 403d_make_extended_operator (struct d_info *, int,
404 struct demangle_component *);
59727473
DD		 405
406static struct demangle_component *
9334f9c6
DD		 407d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
408 struct demangle_component *);
59727473
DD		 409
410static struct demangle_component *
9334f9c6
DD		 411d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
412 struct demangle_component *);
59727473
DD		 413
414static struct demangle_component *
fa3fcee7 415d_make_template_param (struct d_info *, int);
59727473
DD		 416
417static struct demangle_component *
9334f9c6 418d_make_sub (struct d_info *, const char *, int);
59727473
DD		 419
420static int
9334f9c6 421has_return_type (struct demangle_component *);
59727473
DD		 422
423static int
9334f9c6 424is_ctor_dtor_or_conversion (struct demangle_component *);
59727473 425
9334f9c6 426static struct demangle_component *d_encoding (struct d_info *, int);
59727473 427
2a8ae714 428static struct demangle_component *d_name (struct d_info *);
59727473 429
9334f9c6 430static struct demangle_component *d_nested_name (struct d_info *);
59727473 431
d750c713 432static struct demangle_component *d_prefix (struct d_info *, int);
59727473 433
9334f9c6 434static struct demangle_component *d_unqualified_name (struct d_info *);
59727473 435
9334f9c6 436static struct demangle_component *d_source_name (struct d_info *);
59727473 437
fa3fcee7 438static int d_number (struct d_info *);
59727473 439
fa3fcee7 440static struct demangle_component *d_identifier (struct d_info *, int);
59727473 441
9334f9c6 442static struct demangle_component *d_operator_name (struct d_info *);
59727473 443
9334f9c6 444static struct demangle_component *d_special_name (struct d_info *);
59727473 445
a4ddf8dc
JM		 446static struct demangle_component *d_parmlist (struct d_info *);
447
9334f9c6 448static int d_call_offset (struct d_info *, int);
59727473 449
9334f9c6 450static struct demangle_component *d_ctor_dtor_name (struct d_info *);
59727473
DD		 451
452static struct demangle_component **
9334f9c6 453d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
59727473 454
3a4d2339
DD		 455static struct demangle_component *
456d_ref_qualifier (struct d_info *, struct demangle_component *);
457
59727473 458static struct demangle_component *
9334f9c6 459d_function_type (struct d_info *);
59727473
DD		 460
461static struct demangle_component *
9334f9c6 462d_bare_function_type (struct d_info *, int);
59727473
DD		 463
464static struct demangle_component *
9334f9c6 465d_class_enum_type (struct d_info *);
59727473 466
9334f9c6 467static struct demangle_component *d_array_type (struct d_info *);
59727473 468
cbc43128
DD		 469static struct demangle_component *d_vector_type (struct d_info *);
470
59727473 471static struct demangle_component *
9334f9c6 472d_pointer_to_member_type (struct d_info *);
59727473
DD		 473
474static struct demangle_component *
9334f9c6 475d_template_param (struct d_info *);
59727473 476
9334f9c6 477static struct demangle_component *d_template_args (struct d_info *);
fa3fcee7 478static struct demangle_component *d_template_args_1 (struct d_info *);
59727473
DD		 479
480static struct demangle_component *
9334f9c6 481d_template_arg (struct d_info *);
59727473 482
9334f9c6 483static struct demangle_component *d_expression (struct d_info *);
59727473 484
9334f9c6 485static struct demangle_component *d_expr_primary (struct d_info *);
59727473 486
2a8ae714 487static struct demangle_component *d_local_name (struct d_info *);
59727473 488
9334f9c6 489static int d_discriminator (struct d_info *);
59727473 490
664aa91f
DD		 491static struct demangle_component *d_lambda (struct d_info *);
492
493static struct demangle_component *d_unnamed_type (struct d_info *);
494
7955ede5
DD		 495static struct demangle_component *
496d_clone_suffix (struct d_info *, struct demangle_component *);
497
59727473 498static int
9334f9c6 499d_add_substitution (struct d_info *, struct demangle_component *);
59727473 500
9334f9c6 501static struct demangle_component *d_substitution (struct d_info *, int);
59727473 502
492e19d0 503static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
504
505static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
506
208c1674 507static void d_growable_string_init (struct d_growable_string *, size_t);
59727473 508
208c1674
DD		 509static inline void
510d_growable_string_resize (struct d_growable_string *, size_t);
59727473 511
208c1674
DD		 512static inline void
513d_growable_string_append_buffer (struct d_growable_string *,
514 const char *, size_t);
59727473 515static void
208c1674
DD		 516d_growable_string_callback_adapter (const char *, size_t, void *);
517
518static void
fd259167 519d_print_init (struct d_print_info *, demangle_callbackref, void *,
533da483 520 struct demangle_component *);
208c1674
DD		 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);
59727473 529
208c1674
DD		 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 *);
59727473
DD		 536
537static void
c793cac1 538d_print_comp (struct d_print_info *, int, struct demangle_component *);
59727473
DD		 539
540static void
9334f9c6 541d_print_java_identifier (struct d_print_info *, const char *, int);
59727473
DD		 542
543static void
ddee5e46 544d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
59727473
DD		 545
546static void
c793cac1 547d_print_mod (struct d_print_info *, int, struct demangle_component *);
59727473
DD		 548
549static void
ddee5e46 550d_print_function_type (struct d_print_info *, int,
c793cac1 551 struct demangle_component *,
9334f9c6 552 struct d_print_mod *);
59727473
DD		 553
554static void
ddee5e46 555d_print_array_type (struct d_print_info *, int,
c793cac1 556 struct demangle_component *,
9334f9c6 557 struct d_print_mod *);
59727473
DD		 558
559static void
c793cac1 560d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
59727473 561
c4be2641 562static void d_print_cast (struct d_print_info *, int,
c793cac1 563 struct demangle_component *);
c4be2641 564static void d_print_conversion (struct d_print_info *, int,
c793cac1 565 struct demangle_component *);
59727473 566
208c1674
DD		 567static int d_demangle_callback (const char *, int,
568 demangle_callbackref, void *);
9334f9c6 569static char *d_demangle (const char *, int, size_t *);
d00edca5 570
a4ddf8dc
JM		 571#define FNQUAL_COMPONENT_CASE \
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
26a67918
PA		 581/* True iff TYPE is a demangling component representing a
582 function-type-qualifier. */
583
584static int
585is_fnqual_component_type (enum demangle_component_type type)
586{
587 switch (type)
588 {
589 FNQUAL_COMPONENT_CASE:
590 return 1;
591 default:
592 break;
593 }
594 return 0;
595}
596
597
eb383413 598#ifdef CP_DEMANGLE_DEBUG
d00edca5
DD		 599
600static void
9334f9c6 601d_dump (struct demangle_component *dc, int indent)
eb383413
L		 602{
603 int i;
eb383413 604
d00edca5 605 if (dc == NULL)
208c1674
DD		 606 {
607 if (indent == 0)
608 printf ("failed demangling\n");
609 return;
610 }
d00edca5
DD		 611
612 for (i = 0; i < indent; ++i)
613 putchar (' ');
614
615 switch (dc->type)
616 {
59727473 617 case DEMANGLE_COMPONENT_NAME:
d00edca5
DD		 618 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
619 return;
1f3de044
DD		 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;
59727473 625 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
d00edca5
DD		 626 printf ("template parameter %ld\n", dc->u.s_number.number);
627 return;
af03af8f
NC		 628 case DEMANGLE_COMPONENT_TPARM_OBJ:
629 printf ("template parameter object\n");
630 break;
6143b823
PA		 631 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
632 printf ("function parameter %ld\n", dc->u.s_number.number);
633 return;
59727473 634 case DEMANGLE_COMPONENT_CTOR:
d00edca5
DD		 635 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
636 d_dump (dc->u.s_ctor.name, indent + 2);
637 return;
59727473 638 case DEMANGLE_COMPONENT_DTOR:
d00edca5
DD		 639 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
640 d_dump (dc->u.s_dtor.name, indent + 2);
641 return;
59727473 642 case DEMANGLE_COMPONENT_SUB_STD:
d00edca5
DD		 643 printf ("standard substitution %s\n", dc->u.s_string.string);
644 return;
59727473 645 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
d00edca5
DD		 646 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
647 return;
59727473 648 case DEMANGLE_COMPONENT_OPERATOR:
d00edca5
DD		 649 printf ("operator %s\n", dc->u.s_operator.op->name);
650 return;
59727473 651 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d00edca5
DD		 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
59727473 657 case DEMANGLE_COMPONENT_QUAL_NAME:
d00edca5
DD		 658 printf ("qualified name\n");
659 break;
59727473 660 case DEMANGLE_COMPONENT_LOCAL_NAME:
d4edd112
DD		 661 printf ("local name\n");
662 break;
59727473 663 case DEMANGLE_COMPONENT_TYPED_NAME:
d00edca5
DD		 664 printf ("typed name\n");
665 break;
59727473 666 case DEMANGLE_COMPONENT_TEMPLATE:
d00edca5
DD		 667 printf ("template\n");
668 break;
59727473 669 case DEMANGLE_COMPONENT_VTABLE:
d00edca5
DD		 670 printf ("vtable\n");
671 break;
59727473 672 case DEMANGLE_COMPONENT_VTT:
d00edca5
DD		 673 printf ("VTT\n");
674 break;
59727473 675 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
d00edca5
DD		 676 printf ("construction vtable\n");
677 break;
59727473 678 case DEMANGLE_COMPONENT_TYPEINFO:
d00edca5
DD		 679 printf ("typeinfo\n");
680 break;
59727473 681 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
d00edca5
DD		 682 printf ("typeinfo name\n");
683 break;
59727473 684 case DEMANGLE_COMPONENT_TYPEINFO_FN:
d00edca5
DD		 685 printf ("typeinfo function\n");
686 break;
59727473 687 case DEMANGLE_COMPONENT_THUNK:
d00edca5
DD		 688 printf ("thunk\n");
689 break;
59727473 690 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
d00edca5
DD		 691 printf ("virtual thunk\n");
692 break;
59727473 693 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
d00edca5
DD		 694 printf ("covariant thunk\n");
695 break;
59727473 696 case DEMANGLE_COMPONENT_JAVA_CLASS:
d00edca5
DD		 697 printf ("java class\n");
698 break;
59727473 699 case DEMANGLE_COMPONENT_GUARD:
d00edca5
DD		 700 printf ("guard\n");
701 break;
59727473 702 case DEMANGLE_COMPONENT_REFTEMP:
d00edca5
DD		 703 printf ("reference temporary\n");
704 break;
839e4798
RH		 705 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
706 printf ("hidden alias\n");
707 break;
956a8f8b
DD		 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;
59727473 714 case DEMANGLE_COMPONENT_RESTRICT:
d00edca5
DD		 715 printf ("restrict\n");
716 break;
59727473 717 case DEMANGLE_COMPONENT_VOLATILE:
d00edca5
DD		 718 printf ("volatile\n");
719 break;
59727473 720 case DEMANGLE_COMPONENT_CONST:
d00edca5
DD		 721 printf ("const\n");
722 break;
59727473 723 case DEMANGLE_COMPONENT_RESTRICT_THIS:
858b45cf
DD		 724 printf ("restrict this\n");
725 break;
59727473 726 case DEMANGLE_COMPONENT_VOLATILE_THIS:
858b45cf
DD		 727 printf ("volatile this\n");
728 break;
59727473 729 case DEMANGLE_COMPONENT_CONST_THIS:
858b45cf
DD		 730 printf ("const this\n");
731 break;
3a4d2339
DD		 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;
e9a38816
JM		 738 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
739 printf ("transaction_safe this\n");
740 break;
59727473 741 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
d00edca5
DD		 742 printf ("vendor type qualifier\n");
743 break;
59727473 744 case DEMANGLE_COMPONENT_POINTER:
d00edca5
DD		 745 printf ("pointer\n");
746 break;
59727473 747 case DEMANGLE_COMPONENT_REFERENCE:
d00edca5
DD		 748 printf ("reference\n");
749 break;
8969a67f
DD		 750 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
751 printf ("rvalue reference\n");
752 break;
59727473 753 case DEMANGLE_COMPONENT_COMPLEX:
d00edca5
DD		 754 printf ("complex\n");
755 break;
59727473 756 case DEMANGLE_COMPONENT_IMAGINARY:
d00edca5
DD		 757 printf ("imaginary\n");
758 break;
59727473 759 case DEMANGLE_COMPONENT_VENDOR_TYPE:
d00edca5
DD		 760 printf ("vendor type\n");
761 break;
59727473 762 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
d00edca5
DD		 763 printf ("function type\n");
764 break;
59727473 765 case DEMANGLE_COMPONENT_ARRAY_TYPE:
d00edca5
DD		 766 printf ("array type\n");
767 break;
59727473 768 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
d00edca5
DD		 769 printf ("pointer to member type\n");
770 break;
d2825c1a 771 case DEMANGLE_COMPONENT_FIXED_TYPE:
b55f9678
IB		 772 printf ("fixed-point type, accum? %d, sat? %d\n",
773 dc->u.s_fixed.accum, dc->u.s_fixed.sat);
d81bf7dd 774 d_dump (dc->u.s_fixed.length, indent + 2);
d2825c1a 775 break;
59727473 776 case DEMANGLE_COMPONENT_ARGLIST:
d00edca5
DD		 777 printf ("argument list\n");
778 break;
59727473 779 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
d00edca5
DD		 780 printf ("template argument list\n");
781 break;
eb7b5ddb
DD		 782 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
783 printf ("initializer list\n");
784 break;
59727473 785 case DEMANGLE_COMPONENT_CAST:
d00edca5
DD		 786 printf ("cast\n");
787 break;
c4be2641
PA		 788 case DEMANGLE_COMPONENT_CONVERSION:
789 printf ("conversion operator\n");
790 break;
eb7b5ddb
DD		 791 case DEMANGLE_COMPONENT_NULLARY:
792 printf ("nullary operator\n");
793 break;
59727473 794 case DEMANGLE_COMPONENT_UNARY:
d00edca5
DD		 795 printf ("unary operator\n");
796 break;
59727473 797 case DEMANGLE_COMPONENT_BINARY:
d00edca5
DD		 798 printf ("binary operator\n");
799 break;
59727473 800 case DEMANGLE_COMPONENT_BINARY_ARGS:
d00edca5
DD		 801 printf ("binary operator arguments\n");
802 break;
59727473 803 case DEMANGLE_COMPONENT_TRINARY:
d00edca5
DD		 804 printf ("trinary operator\n");
805 break;
59727473 806 case DEMANGLE_COMPONENT_TRINARY_ARG1:
d00edca5
DD		 807 printf ("trinary operator arguments 1\n");
808 break;
59727473 809 case DEMANGLE_COMPONENT_TRINARY_ARG2:
d00edca5
DD		 810 printf ("trinary operator arguments 1\n");
811 break;
59727473 812 case DEMANGLE_COMPONENT_LITERAL:
d00edca5
DD		 813 printf ("literal\n");
814 break;
59727473 815 case DEMANGLE_COMPONENT_LITERAL_NEG:
97ceaf5b
DD		 816 printf ("negative literal\n");
817 break;
830ef634
DD		 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;
6143b823
PA		 827 case DEMANGLE_COMPONENT_NUMBER:
828 printf ("number %ld\n", dc->u.s_number.number);
829 return;
ba8cb4ba
DD		 830 case DEMANGLE_COMPONENT_DECLTYPE:
831 printf ("decltype\n");
832 break;
1c08f2c8
DD		 833 case DEMANGLE_COMPONENT_PACK_EXPANSION:
834 printf ("pack expansion\n");
835 break;
995b61fe
DD		 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;
a9c3ecea
DD		 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;
eb383413
L		 850 }
851
d00edca5
DD		 852 d_dump (d_left (dc), indent + 2);
853 d_dump (d_right (dc), indent + 2);
854}
855
856#endif /* CP_DEMANGLE_DEBUG */
857
59727473
DD		 858/* Fill in a DEMANGLE_COMPONENT_NAME. */
859
860CP_STATIC_IF_GLIBCPP_V3
861int
9334f9c6 862cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
59727473 863{
c1202057 864 if (p == NULL || s == NULL || len <= 0)
59727473 865 return 0;
b9da89d1 866 p->d_printing = 0;
533da483 867 p->d_counting = 0;
59727473
DD		 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
9334f9c6
DD		 878cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
879 struct demangle_component *name)
59727473
DD		 880{
881 if (p == NULL || args < 0 || name == NULL)
882 return 0;
b9da89d1 883 p->d_printing = 0;
533da483 884 p->d_counting = 0;
59727473
DD		 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
9334f9c6
DD		 895cplus_demangle_fill_ctor (struct demangle_component *p,
896 enum gnu_v3_ctor_kinds kind,
897 struct demangle_component *name)
59727473
DD		 898{
899 if (p == NULL
900 || name == NULL
4e55d6c3 901 || (int) kind < gnu_v3_complete_object_ctor
956a8f8b 902 || (int) kind > gnu_v3_object_ctor_group)
59727473 903 return 0;
b9da89d1 904 p->d_printing = 0;
533da483 905 p->d_counting = 0;
59727473
DD		 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
9334f9c6
DD		 916cplus_demangle_fill_dtor (struct demangle_component *p,
917 enum gnu_v3_dtor_kinds kind,
918 struct demangle_component *name)
59727473
DD		 919{
920 if (p == NULL
921 || name == NULL
4e55d6c3 922 || (int) kind < gnu_v3_deleting_dtor
956a8f8b 923 || (int) kind > gnu_v3_object_dtor_group)
59727473 924 return 0;
b9da89d1 925 p->d_printing = 0;
533da483 926 p->d_counting = 0;
59727473
DD		 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
d00edca5
DD		 933/* Add a new component. */
934
59727473 935static struct demangle_component *
9334f9c6 936d_make_empty (struct d_info *di)
d00edca5 937{
59727473 938 struct demangle_component *p;
d00edca5
DD		 939
940 if (di->next_comp >= di->num_comps)
941 return NULL;
942 p = &di->comps[di->next_comp];
c793cac1 943 p->d_printing = 0;
533da483 944 p->d_counting = 0;
d00edca5
DD		 945 ++di->next_comp;
946 return p;
947}
948
949/* Add a new generic component. */
950
59727473 951static struct demangle_component *
9334f9c6
DD		 952d_make_comp (struct d_info *di, enum demangle_component_type type,
953 struct demangle_component *left,
954 struct demangle_component *right)
d00edca5 955{
59727473 956 struct demangle_component *p;
d00edca5
DD		 957
958 /* We check for errors here. A typical error would be a NULL return
331c3da2
DD		 959 from a subroutine. We catch those here, and return NULL
960 upward. */
d00edca5
DD		 961 switch (type)
962 {
963 /* These types require two parameters. */
59727473
DD		 964 case DEMANGLE_COMPONENT_QUAL_NAME:
965 case DEMANGLE_COMPONENT_LOCAL_NAME:
966 case DEMANGLE_COMPONENT_TYPED_NAME:
1f3de044 967 case DEMANGLE_COMPONENT_TAGGED_NAME:
59727473 968 case DEMANGLE_COMPONENT_TEMPLATE:
2d6520ee 969 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
59727473
DD		 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:
59727473
DD		 977 case DEMANGLE_COMPONENT_LITERAL:
978 case DEMANGLE_COMPONENT_LITERAL_NEG:
830ef634 979 case DEMANGLE_COMPONENT_COMPOUND_NAME:
cbc43128 980 case DEMANGLE_COMPONENT_VECTOR_TYPE:
7955ede5 981 case DEMANGLE_COMPONENT_CLONE:
d00edca5
DD		 982 if (left == NULL || right == NULL)
983 return NULL;
984 break;
985
986 /* These types only require one parameter. */
59727473
DD		 987 case DEMANGLE_COMPONENT_VTABLE:
988 case DEMANGLE_COMPONENT_VTT:
59727473
DD		 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:
995b61fe
DD		 997 case DEMANGLE_COMPONENT_TLS_INIT:
998 case DEMANGLE_COMPONENT_TLS_WRAPPER:
59727473 999 case DEMANGLE_COMPONENT_REFTEMP:
839e4798 1000 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
956a8f8b
DD		 1001 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
1002 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
59727473
DD		 1003 case DEMANGLE_COMPONENT_POINTER:
1004 case DEMANGLE_COMPONENT_REFERENCE:
8969a67f 1005 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
59727473
DD		 1006 case DEMANGLE_COMPONENT_COMPLEX:
1007 case DEMANGLE_COMPONENT_IMAGINARY:
1008 case DEMANGLE_COMPONENT_VENDOR_TYPE:
59727473 1009 case DEMANGLE_COMPONENT_CAST:
c4be2641 1010 case DEMANGLE_COMPONENT_CONVERSION:
830ef634 1011 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
ba8cb4ba 1012 case DEMANGLE_COMPONENT_DECLTYPE:
1c08f2c8 1013 case DEMANGLE_COMPONENT_PACK_EXPANSION:
d5031754
DD		 1014 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
1015 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
eb7b5ddb
DD		 1016 case DEMANGLE_COMPONENT_NULLARY:
1017 case DEMANGLE_COMPONENT_TRINARY_ARG2:
af03af8f 1018 case DEMANGLE_COMPONENT_TPARM_OBJ:
d00edca5
DD		 1019 if (left == NULL)
1020 return NULL;
1021 break;
1022
1023 /* This needs a right parameter, but the left parameter can be
1024 empty. */
59727473 1025 case DEMANGLE_COMPONENT_ARRAY_TYPE:
eb7b5ddb 1026 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
d00edca5
DD		 1027 if (right == NULL)
1028 return NULL;
1029 break;
1030
1031 /* These are allowed to have no parameters--in some cases they
1032 will be filled in later. */
59727473
DD		 1033 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
1034 case DEMANGLE_COMPONENT_RESTRICT:
1035 case DEMANGLE_COMPONENT_VOLATILE:
1036 case DEMANGLE_COMPONENT_CONST:
1c08f2c8
DD		 1037 case DEMANGLE_COMPONENT_ARGLIST:
1038 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
a4ddf8dc 1039 FNQUAL_COMPONENT_CASE:
d00edca5
DD		 1040 break;
1041
1042 /* Other types should not be seen here. */
1043 default:
1044 return NULL;
eb383413 1045 }
d00edca5 1046
59727473 1047 p = d_make_empty (di);
d00edca5 1048 if (p != NULL)
eb383413 1049 {
59727473 1050 p->type = type;
d00edca5
DD		 1051 p->u.s_binary.left = left;
1052 p->u.s_binary.right = right;
eb383413 1053 }
d00edca5
DD		 1054 return p;
1055}
eb383413 1056
a0692e36
L		 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) != '_' || d_peek_next_char (di) != 'Z')
1063 return d_make_name (di, s, strlen (s));
1064 d_advance (di, 2);
1065 return d_encoding (di, 0);
1066}
1067
d00edca5 1068/* Add a new name component. */
03d5f569 1069
59727473 1070static struct demangle_component *
9334f9c6 1071d_make_name (struct d_info *di, const char *s, int len)
d00edca5 1072{
59727473 1073 struct demangle_component *p;
03d5f569 1074
59727473
DD		 1075 p = d_make_empty (di);
1076 if (! cplus_demangle_fill_name (p, s, len))
858b45cf 1077 return NULL;
d00edca5 1078 return p;
eb383413
L		 1079}
1080
d00edca5 1081/* Add a new builtin type component. */
eb383413 1082
59727473 1083static struct demangle_component *
9334f9c6
DD		 1084d_make_builtin_type (struct d_info *di,
1085 const struct demangle_builtin_type_info *type)
eb383413 1086{
59727473 1087 struct demangle_component *p;
d00edca5 1088
331c3da2
DD		 1089 if (type == NULL)
1090 return NULL;
59727473 1091 p = d_make_empty (di);
d00edca5 1092 if (p != NULL)
59727473
DD		 1093 {
1094 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
1095 p->u.s_builtin.type = type;
1096 }
d00edca5
DD		 1097 return p;
1098}
eb383413 1099
d00edca5 1100/* Add a new operator component. */
eb383413 1101
59727473 1102static struct demangle_component *
9334f9c6 1103d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
eb383413 1104{
59727473 1105 struct demangle_component *p;
d00edca5 1106
59727473 1107 p = d_make_empty (di);
d00edca5 1108 if (p != NULL)
59727473
DD		 1109 {
1110 p->type = DEMANGLE_COMPONENT_OPERATOR;
1111 p->u.s_operator.op = op;
1112 }
d00edca5 1113 return p;
eb383413
L		 1114}
1115
d00edca5 1116/* Add a new extended operator component. */
eb383413 1117
59727473 1118static struct demangle_component *
9334f9c6
DD		 1119d_make_extended_operator (struct d_info *di, int args,
1120 struct demangle_component *name)
eb383413 1121{
59727473 1122 struct demangle_component *p;
03d5f569 1123
59727473
DD		 1124 p = d_make_empty (di);
1125 if (! cplus_demangle_fill_extended_operator (p, args, name))
331c3da2 1126 return NULL;
d00edca5 1127 return p;
eb383413
L		 1128}
1129
664aa91f
DD		 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
d00edca5 1144/* Add a new constructor component. */
eb383413 1145
59727473 1146static struct demangle_component *
9334f9c6
DD		 1147d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
1148 struct demangle_component *name)
eb383413 1149{
59727473 1150 struct demangle_component *p;
d00edca5 1151
59727473
DD		 1152 p = d_make_empty (di);
1153 if (! cplus_demangle_fill_ctor (p, kind, name))
331c3da2 1154 return NULL;
d00edca5 1155 return p;
eb383413
L		 1156}
1157
d00edca5 1158/* Add a new destructor component. */
eb383413 1159
59727473 1160static struct demangle_component *
9334f9c6
DD		 1161d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
1162 struct demangle_component *name)
eb383413 1163{
59727473 1164 struct demangle_component *p;
d00edca5 1165
59727473
DD		 1166 p = d_make_empty (di);
1167 if (! cplus_demangle_fill_dtor (p, kind, name))
331c3da2 1168 return NULL;
d00edca5 1169 return p;
eb383413
L		 1170}
1171
d00edca5 1172/* Add a new template parameter. */
59666b35 1173
59727473 1174static struct demangle_component *
fa3fcee7 1175d_make_template_param (struct d_info *di, int i)
59666b35 1176{
59727473 1177 struct demangle_component *p;
d00edca5 1178
59727473 1179 p = d_make_empty (di);
d00edca5 1180 if (p != NULL)
59727473
DD		 1181 {
1182 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1183 p->u.s_number.number = i;
1184 }
d00edca5 1185 return p;
59666b35
DD		 1186}
1187
c743cf5d
DD		 1188/* Add a new function parameter. */
1189
1190static struct demangle_component *
fa3fcee7 1191d_make_function_param (struct d_info *di, int i)
c743cf5d
DD		 1192{
1193 struct demangle_component *p;
1194
1195 p = d_make_empty (di);
1196 if (p != NULL)
1197 {
1198 p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1199 p->u.s_number.number = i;
1200 }
1201 return p;
1202}
1203
d00edca5 1204/* Add a new standard substitution component. */
59666b35 1205
59727473 1206static struct demangle_component *
9334f9c6 1207d_make_sub (struct d_info *di, const char *name, int len)
59666b35 1208{
59727473 1209 struct demangle_component *p;
d00edca5 1210
59727473 1211 p = d_make_empty (di);
d00edca5 1212 if (p != NULL)
b6fb00c0 1213 {
59727473 1214 p->type = DEMANGLE_COMPONENT_SUB_STD;
b6fb00c0
DD		 1215 p->u.s_string.string = name;
1216 p->u.s_string.len = len;
1217 }
d00edca5 1218 return p;
59666b35
DD		 1219}
1220
7955ede5 1221/* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
331c3da2
DD		 1222
1223 TOP_LEVEL is non-zero when called at the top level. */
59666b35 1224
59727473
DD		 1225CP_STATIC_IF_GLIBCPP_V3
1226struct demangle_component *
9334f9c6 1227cplus_demangle_mangled_name (struct d_info *di, int top_level)
59666b35 1228{
7955ede5
DD		 1229 struct demangle_component *p;
1230
c743cf5d
DD		 1231 if (! d_check_char (di, '_')
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)
d00edca5 1236 return NULL;
6ef6358e 1237 if (! d_check_char (di, 'Z'))
d00edca5 1238 return NULL;
7955ede5
DD		 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) != 0)
1244 while (d_peek_char (di) == '.'
1245 && (IS_LOWER (d_peek_next_char (di))
1246 || d_peek_next_char (di) == '_'
1247 || IS_DIGIT (d_peek_next_char (di))))
1248 p = d_clone_suffix (di, p);
1249
1250 return p;
59666b35
DD		 1251}
1252
d00edca5
DD		 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. */
59666b35
DD		 1261
1262static int
9334f9c6 1263has_return_type (struct demangle_component *dc)
59666b35 1264{
d00edca5
DD		 1265 if (dc == NULL)
1266 return 0;
1267 switch (dc->type)
1268 {
1269 default:
1270 return 0;
2a8ae714
NC		 1271 case DEMANGLE_COMPONENT_LOCAL_NAME:
1272 return has_return_type (d_right (dc));
59727473 1273 case DEMANGLE_COMPONENT_TEMPLATE:
d00edca5 1274 return ! is_ctor_dtor_or_conversion (d_left (dc));
a4ddf8dc 1275 FNQUAL_COMPONENT_CASE:
54a962d9 1276 return has_return_type (d_left (dc));
d00edca5 1277 }
59666b35
DD		 1278}
1279
d00edca5
DD		 1280/* Return whether a name is a constructor, a destructor, or a
1281 conversion operator. */
eb383413
L		 1282
1283static int
9334f9c6 1284is_ctor_dtor_or_conversion (struct demangle_component *dc)
eb383413 1285{
d00edca5
DD		 1286 if (dc == NULL)
1287 return 0;
1288 switch (dc->type)
1289 {
1290 default:
1291 return 0;
59727473
DD		 1292 case DEMANGLE_COMPONENT_QUAL_NAME:
1293 case DEMANGLE_COMPONENT_LOCAL_NAME:
d00edca5 1294 return is_ctor_dtor_or_conversion (d_right (dc));
59727473
DD		 1295 case DEMANGLE_COMPONENT_CTOR:
1296 case DEMANGLE_COMPONENT_DTOR:
c4be2641 1297 case DEMANGLE_COMPONENT_CONVERSION:
d00edca5
DD		 1298 return 1;
1299 }
eb383413
L		 1300}
1301
d00edca5
DD		 1302/* <encoding> ::= <(function) name> <bare-function-type>
1303 ::= <(data) name>
6d95373e
DD		 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. */
eb383413 1310
59727473 1311static struct demangle_component *
9334f9c6 1312d_encoding (struct d_info *di, int top_level)
eb383413 1313{
d00edca5 1314 char peek = d_peek_char (di);
2a8ae714 1315 struct demangle_component *dc;
03d5f569 1316
d00edca5 1317 if (peek == 'G' || peek == 'T')
2a8ae714 1318 dc = d_special_name (di);
d00edca5 1319 else
03d5f569 1320 {
2a8ae714 1321 dc = d_name (di);
331c3da2 1322
2a8ae714
NC		 1323 if (!dc)
1324 /* Failed already. */;
1325 else if (top_level && (di->options & DMGL_PARAMS) == 0)
331c3da2
DD		 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. */
2a8ae714 1330 while (is_fnqual_component_type (dc->type))
331c3da2 1331 dc = d_left (dc);
820542c9 1332
59727473 1333 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
a4ddf8dc 1334 there may be function-qualifiers on its right argument which
59727473
DD		 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)
f211b8c0
NC		 1338 {
1339 while (d_right (dc) != NULL
1340 && is_fnqual_component_type (d_right (dc)->type))
1341 d_right (dc) = d_left (d_right (dc));
1342
1343 if (d_right (dc) == NULL)
1344 dc = NULL;
1345 }
2a8ae714
NC		 1346 }
1347 else
1348 {
1349 peek = d_peek_char (di);
1350 if (peek != '\0' && peek != 'E')
820542c9 1351 {
2a8ae714 1352 struct demangle_component *ftype;
820542c9 1353
2a8ae714
NC		 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) = NULL;
1364
1365 dc = d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME,
1366 dc, ftype);
1367 }
1368 else
1369 dc = NULL;
1370 }
331c3da2 1371 }
03d5f569 1372 }
2a8ae714
NC		 1373
1374 return dc;
d00edca5
DD		 1375}
1376
1f3de044
DD		 1377/* <tagged-name> ::= <name> B <source-name> */
1378
1379static struct demangle_component *
1380d_abi_tags (struct d_info *di, struct demangle_component *dc)
1381{
68996839 1382 struct demangle_component *hold_last_name;
1f3de044 1383 char peek;
68996839
NC		 1384
1385 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1386 hold_last_name = di->last_name;
1387
1f3de044
DD		 1388 while (peek = d_peek_char (di),
1389 peek == 'B')
1390 {
1391 struct demangle_component *tag;
1392 d_advance (di, 1);
1393 tag = d_source_name (di);
1394 dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
1395 }
68996839
NC		 1396
1397 di->last_name = hold_last_name;
1398
1f3de044
DD		 1399 return dc;
1400}
1401
d00edca5
DD		 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>
eb383413 1409
d00edca5
DD		 1410 <unscoped-template-name> ::= <unscoped-name>
1411 ::= <substitution>
1412*/
1413
59727473 1414static struct demangle_component *
2a8ae714 1415d_name (struct d_info *di)
d00edca5
DD		 1416{
1417 char peek = d_peek_char (di);
59727473 1418 struct demangle_component *dc;
d00edca5
DD		 1419
1420 switch (peek)
eb383413 1421 {
d00edca5
DD		 1422 case 'N':
1423 return d_nested_name (di);
1424
1425 case 'Z':
2a8ae714 1426 return d_local_name (di);
d00edca5 1427
664aa91f 1428 case 'U':
8bf955e1 1429 return d_unqualified_name (di);
664aa91f 1430
d00edca5
DD		 1431 case 'S':
1432 {
1433 int subst;
1434
1435 if (d_peek_next_char (di) != 't')
1436 {
97ceaf5b 1437 dc = d_substitution (di, 0);
d00edca5
DD		 1438 subst = 1;
1439 }
1440 else
1441 {
1442 d_advance (di, 2);
59727473
DD		 1443 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1444 d_make_name (di, "std", 3),
d00edca5 1445 d_unqualified_name (di));
b6fb00c0 1446 di->expansion += 3;
d00edca5
DD		 1447 subst = 0;
1448 }
1449
1450 if (d_peek_char (di) != '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;
1466 }
59727473
DD		 1467 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1468 d_template_args (di));
d00edca5
DD		 1469 }
1470
1471 return dc;
1472 }
1473
26505cc0 1474 case 'L':
d00edca5
DD		 1475 default:
1476 dc = d_unqualified_name (di);
1477 if (d_peek_char (di) == 'I')
03d5f569 1478 {
d00edca5
DD		 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;
59727473
DD		 1484 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1485 d_template_args (di));
03d5f569 1486 }
d00edca5 1487 return dc;
eb383413 1488 }
d00edca5 1489}
eb383413 1490
3a4d2339
DD		 1491/* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1492 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
d00edca5 1493*/
eb383413 1494
59727473 1495static struct demangle_component *
9334f9c6 1496d_nested_name (struct d_info *di)
d00edca5 1497{
59727473
DD		 1498 struct demangle_component *ret;
1499 struct demangle_component **pret;
3a4d2339 1500 struct demangle_component *rqual;
03d5f569 1501
6ef6358e 1502 if (! d_check_char (di, 'N'))
d00edca5 1503 return NULL;
eb383413 1504
858b45cf 1505 pret = d_cv_qualifiers (di, &ret, 1);
d00edca5
DD		 1506 if (pret == NULL)
1507 return NULL;
1508
3a4d2339
DD		 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);
1512
d750c713 1513 *pret = d_prefix (di, 1);
d00edca5
DD		 1514 if (*pret == NULL)
1515 return NULL;
eb383413 1516
3a4d2339
DD		 1517 if (rqual)
1518 {
1519 d_left (rqual) = ret;
1520 ret = rqual;
1521 }
1522
6ef6358e 1523 if (! d_check_char (di, 'E'))
eb383413
L		 1524 return NULL;
1525
d00edca5 1526 return ret;
eb383413
L		 1527}
1528
d00edca5
DD		 1529/* <prefix> ::= <prefix> <unqualified-name>
1530 ::= <template-prefix> <template-args>
1531 ::= <template-param>
6b6bd65a 1532 ::= <decltype>
d00edca5
DD		 1533 ::=
1534 ::= <substitution>
eb383413 1535
d00edca5
DD		 1536 <template-prefix> ::= <prefix> <(template) unqualified-name>
1537 ::= <template-param>
1538 ::= <substitution>
d750c713
NC		 1539
1540 SUBST is true if we should add substitutions (as normal), false
1541 if not (in an unresolved-name). */
d00edca5 1542
59727473 1543static struct demangle_component *
d750c713 1544d_prefix (struct d_info *di, int subst)
eb383413 1545{
59727473 1546 struct demangle_component *ret = NULL;
eb383413 1547
d00edca5 1548 while (1)
eb383413 1549 {
d00edca5 1550 char peek;
59727473
DD		 1551 enum demangle_component_type comb_type;
1552 struct demangle_component *dc;
d00edca5
DD		 1553
1554 peek = d_peek_char (di);
1555 if (peek == '\0')
1556 return NULL;
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. */
eb383413 1561
59727473 1562 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
6b6bd65a
DD		 1563 if (peek == 'D')
1564 {
1565 char peek2 = d_peek_next_char (di);
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)
858b45cf 1574 || IS_LOWER (peek)
d00edca5 1575 || peek == 'C'
664aa91f 1576 || peek == 'U'
8bf955e1 1577 || peek == 'L')
d00edca5
DD		 1578 dc = d_unqualified_name (di);
1579 else if (peek == 'S')
97ceaf5b 1580 dc = d_substitution (di, 1);
d00edca5
DD		 1581 else if (peek == 'I')
1582 {
1583 if (ret == NULL)
1584 return NULL;
59727473 1585 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
d00edca5
DD		 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;
664aa91f
DD		 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)
1598 return NULL;
1599 d_advance (di, 1);
1600 continue;
1601 }
d00edca5
DD		 1602 else
1603 return NULL;
1604
1605 if (ret == NULL)
1606 ret = dc;
eb383413 1607 else
d00edca5
DD		 1608 ret = d_make_comp (di, comb_type, ret, dc);
1609
d750c713 1610 if (peek != 'S' && d_peek_char (di) != 'E' && subst)
d00edca5
DD		 1611 {
1612 if (! d_add_substitution (di, ret))
1613 return NULL;
1614 }
eb383413
L		 1615 }
1616}
1617
d00edca5
DD		 1618/* <unqualified-name> ::= <operator-name>
1619 ::= <ctor-dtor-name>
1620 ::= <source-name>
8bf955e1
GK		 1621 ::= <local-source-name>
1622
1623 <local-source-name> ::= L <source-name> <discriminator>
d00edca5 1624*/
eb383413 1625
59727473 1626static struct demangle_component *
9334f9c6 1627d_unqualified_name (struct d_info *di)
eb383413 1628{
1f3de044 1629 struct demangle_component *ret;
d00edca5
DD		 1630 char peek;
1631
1632 peek = d_peek_char (di);
1633 if (IS_DIGIT (peek))
1f3de044 1634 ret = d_source_name (di);
858b45cf 1635 else if (IS_LOWER (peek))
b6fb00c0 1636 {
d750c713 1637 int was_expr = di->is_expression;
134e805d 1638 if (peek == 'o' && d_peek_next_char (di) == 'n')
d750c713
NC		 1639 {
1640 d_advance (di, 2);
1641 /* Treat cv as naming a conversion operator. */
1642 di->is_expression = 0;
1643 }
b6fb00c0 1644 ret = d_operator_name (di);
d750c713 1645 di->is_expression = was_expr;
59727473 1646 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
4e3aa408
DD		 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 }
b6fb00c0 1653 }
d00edca5 1654 else if (peek == 'C' || peek == 'D')
1f3de044 1655 ret = d_ctor_dtor_name (di);
8bf955e1
GK		 1656 else if (peek == 'L')
1657 {
8bf955e1
GK		 1658 d_advance (di, 1);
1659
1660 ret = d_source_name (di);
1661 if (ret == NULL)
1662 return NULL;
1663 if (! d_discriminator (di))
1664 return NULL;
8bf955e1 1665 }
664aa91f
DD		 1666 else if (peek == 'U')
1667 {
1668 switch (d_peek_next_char (di))
1669 {
1670 case 'l':
1f3de044
DD		 1671 ret = d_lambda (di);
1672 break;
664aa91f 1673 case 't':
1f3de044
DD		 1674 ret = d_unnamed_type (di);
1675 break;
664aa91f
DD		 1676 default:
1677 return NULL;
1678 }
1679 }
d00edca5 1680 else
03d5f569 1681 return NULL;
1f3de044
DD		 1682
1683 if (d_peek_char (di) == 'B')
1684 ret = d_abi_tags (di, ret);
1685 return ret;
eb383413
L		 1686}
1687
d00edca5 1688/* <source-name> ::= <(positive length) number> <identifier> */
eb383413 1689
59727473 1690static struct demangle_component *
9334f9c6 1691d_source_name (struct d_info *di)
eb383413 1692{
fa3fcee7 1693 int len;
59727473 1694 struct demangle_component *ret;
d00edca5
DD		 1695
1696 len = d_number (di);
1697 if (len <= 0)
1698 return NULL;
1699 ret = d_identifier (di, len);
1700 di->last_name = ret;
1701 return ret;
eb383413
L		 1702}
1703
d00edca5 1704/* number ::= [n] <(non-negative decimal integer)> */
eb383413 1705
fa3fcee7 1706static int
9334f9c6 1707d_number (struct d_info *di)
eb383413 1708{
b6fb00c0 1709 int negative;
d00edca5 1710 char peek;
fa3fcee7 1711 int ret;
eb383413 1712
b6fb00c0 1713 negative = 0;
d00edca5
DD		 1714 peek = d_peek_char (di);
1715 if (peek == 'n')
1716 {
b6fb00c0 1717 negative = 1;
d00edca5
DD		 1718 d_advance (di, 1);
1719 peek = d_peek_char (di);
1720 }
eb383413 1721
d00edca5
DD		 1722 ret = 0;
1723 while (1)
eb383413 1724 {
d00edca5 1725 if (! IS_DIGIT (peek))
b6fb00c0
DD		 1726 {
1727 if (negative)
1728 ret = - ret;
1729 return ret;
1730 }
2d3392bd
IB		 1731 if (ret > ((INT_MAX - (peek - '0')) / 10))
1732 return -1;
533da483 1733 ret = ret * 10 + (peek - '0');
d00edca5
DD		 1734 d_advance (di, 1);
1735 peek = d_peek_char (di);
eb383413 1736 }
eb383413
L		 1737}
1738
cbc43128
DD		 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
d00edca5 1753/* identifier ::= <(unqualified source code identifier)> */
eb383413 1754
59727473 1755static struct demangle_component *
fa3fcee7 1756d_identifier (struct d_info *di, int len)
eb383413 1757{
d00edca5 1758 const char *name;
eb383413 1759
d00edca5 1760 name = d_str (di);
b6fb00c0
DD		 1761
1762 if (di->send - name < len)
1763 return NULL;
1764
d00edca5 1765 d_advance (di, len);
eb383413 1766
2730f651
DD		 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) != 0
1771 && d_peek_char (di) == '$')
1772 d_advance (di, 1);
1773
d00edca5
DD		 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. */
fa3fcee7 1777 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
d00edca5
DD		 1778 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1779 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
eb383413 1780 {
d00edca5
DD		 1781 const char *s;
1782
1783 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1784 if ((*s == '.' || *s == '_' || *s == '$')
1785 && s[1] == 'N')
b6fb00c0
DD		 1786 {
1787 di->expansion -= len - sizeof "(anonymous namespace)";
1788 return d_make_name (di, "(anonymous namespace)",
1789 sizeof "(anonymous namespace)" - 1);
1790 }
eb383413 1791 }
d00edca5
DD		 1792
1793 return d_make_name (di, name, len);
eb383413
L		 1794}
1795
d00edca5
DD		 1796/* operator_name ::= many different two character encodings.
1797 ::= cv <type>
1798 ::= v <digit> <source-name>
eb7b5ddb
DD		 1799
1800 This list is sorted for binary search. */
eb383413 1801
b6fb00c0
DD		 1802#define NL(s) s, (sizeof s) - 1
1803
59727473
DD		 1804CP_STATIC_IF_GLIBCPP_V3
1805const struct demangle_operator_info cplus_demangle_operators[] =
d00edca5 1806{
b6fb00c0
DD		 1807 { "aN", NL ("&="), 2 },
1808 { "aS", NL ("="), 2 },
1809 { "aa", NL ("&&"), 2 },
1810 { "ad", NL ("&"), 1 },
1811 { "an", NL ("&"), 2 },
eb7b5ddb 1812 { "at", NL ("alignof "), 1 },
99e47410 1813 { "aw", NL ("co_await "), 1 },
eb7b5ddb 1814 { "az", NL ("alignof "), 1 },
7c328963 1815 { "cc", NL ("const_cast"), 2 },
ba8cb4ba 1816 { "cl", NL ("()"), 2 },
b6fb00c0
DD		 1817 { "cm", NL (","), 2 },
1818 { "co", NL ("~"), 1 },
1819 { "dV", NL ("/="), 2 },
7ade7fba 1820 { "dX", NL ("[...]="), 3 }, /* [expr...expr] = expr */
eb7b5ddb 1821 { "da", NL ("delete[] "), 1 },
7c328963 1822 { "dc", NL ("dynamic_cast"), 2 },
b6fb00c0 1823 { "de", NL ("*"), 1 },
7ade7fba 1824 { "di", NL ("="), 2 }, /* .name = expr */
eb7b5ddb
DD		 1825 { "dl", NL ("delete "), 1 },
1826 { "ds", NL (".*"), 2 },
1c08f2c8 1827 { "dt", NL ("."), 2 },
b6fb00c0 1828 { "dv", NL ("/"), 2 },
7ade7fba 1829 { "dx", NL ("]="), 2 }, /* [expr] = expr */
b6fb00c0
DD		 1830 { "eO", NL ("^="), 2 },
1831 { "eo", NL ("^"), 2 },
1832 { "eq", NL ("=="), 2 },
fa3fcee7
NC		 1833 { "fL", NL ("..."), 3 },
1834 { "fR", NL ("..."), 3 },
1835 { "fl", NL ("..."), 2 },
1836 { "fr", NL ("..."), 2 },
b6fb00c0 1837 { "ge", NL (">="), 2 },
eb7b5ddb 1838 { "gs", NL ("::"), 1 },
b6fb00c0
DD		 1839 { "gt", NL (">"), 2 },
1840 { "ix", NL ("[]"), 2 },
1841 { "lS", NL ("<<="), 2 },
1842 { "le", NL ("<="), 2 },
4e3aa408 1843 { "li", NL ("operator\"\" "), 1 },
b6fb00c0
DD		 1844 { "ls", NL ("<<"), 2 },
1845 { "lt", NL ("<"), 2 },
1846 { "mI", NL ("-="), 2 },
1847 { "mL", NL ("*="), 2 },
1848 { "mi", NL ("-"), 2 },
1849 { "ml", NL ("*"), 2 },
1850 { "mm", NL ("--"), 1 },
eb7b5ddb 1851 { "na", NL ("new[]"), 3 },
b6fb00c0
DD		 1852 { "ne", NL ("!="), 2 },
1853 { "ng", NL ("-"), 1 },
1854 { "nt", NL ("!"), 1 },
eb7b5ddb 1855 { "nw", NL ("new"), 3 },
b6fb00c0
DD		 1856 { "oR", NL ("|="), 2 },
1857 { "oo", NL ("||"), 2 },
1858 { "or", NL ("|"), 2 },
1859 { "pL", NL ("+="), 2 },
1860 { "pl", NL ("+"), 2 },
1861 { "pm", NL ("->*"), 2 },
1862 { "pp", NL ("++"), 1 },
1863 { "ps", NL ("+"), 1 },
1864 { "pt", NL ("->"), 2 },
1865 { "qu", NL ("?"), 3 },
1866 { "rM", NL ("%="), 2 },
1867 { "rS", NL (">>="), 2 },
7c328963 1868 { "rc", NL ("reinterpret_cast"), 2 },
b6fb00c0
DD		 1869 { "rm", NL ("%"), 2 },
1870 { "rs", NL (">>"), 2 },
fa3fcee7
NC		 1871 { "sP", NL ("sizeof..."), 1 },
1872 { "sZ", NL ("sizeof..."), 1 },
7c328963 1873 { "sc", NL ("static_cast"), 2 },
56b1e56d 1874 { "ss", NL ("<=>"), 2 },
b6fb00c0 1875 { "st", NL ("sizeof "), 1 },
59727473 1876 { "sz", NL ("sizeof "), 1 },
eb7b5ddb
DD		 1877 { "tr", NL ("throw"), 0 },
1878 { "tw", NL ("throw "), 1 },
59727473 1879 { NULL, NULL, 0, 0 }
d00edca5 1880};
eb383413 1881
59727473 1882static struct demangle_component *
9334f9c6 1883d_operator_name (struct d_info *di)
eb383413 1884{
d00edca5
DD		 1885 char c1;
1886 char c2;
eb383413 1887
d00edca5
DD		 1888 c1 = d_next_char (di);
1889 c2 = d_next_char (di);
1890 if (c1 == 'v' && IS_DIGIT (c2))
1891 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1892 else if (c1 == 'c' && c2 == 'v')
492e19d0 1893 {
1894 struct demangle_component *type;
1895 int was_conversion = di->is_conversion;
c4be2641 1896 struct demangle_component *res;
492e19d0 1897
1898 di->is_conversion = ! di->is_expression;
1899 type = cplus_demangle_type (di);
c4be2641
PA		 1900 if (di->is_conversion)
1901 res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
1902 else
1903 res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
492e19d0 1904 di->is_conversion = was_conversion;
c4be2641 1905 return res;
492e19d0 1906 }
d00edca5 1907 else
eb383413 1908 {
59727473 1909 /* LOW is the inclusive lower bound. */
d00edca5 1910 int low = 0;
59727473
DD		 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);
eb383413 1916
d00edca5
DD		 1917 while (1)
1918 {
1919 int i;
59727473 1920 const struct demangle_operator_info *p;
eb383413 1921
d00edca5 1922 i = low + (high - low) / 2;
59727473 1923 p = cplus_demangle_operators + i;
eb383413 1924
d00edca5
DD		 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;
1934 }
1935 }
eb383413
L		 1936}
1937
830ef634
DD		 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)
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;
1955 struct demangle_component *next = NULL;
fa3fcee7 1956 int len, i;
830ef634
DD		 1957 char c;
1958 const char *str;
1959
1960 len = d_number (di);
1961 if (len <= 1)
1962 return NULL;
1963
1964 /* Eat the leading '_'. */
1965 if (d_next_char (di) != '_')
1966 return NULL;
1967 len--;
1968
1969 str = d_str (di);
1970 i = 0;
1971
1972 while (len > 0)
1973 {
1974 c = str[i];
1975 if (!c)
1976 return NULL;
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;
1995 }
1996 next = d_make_character (di, c);
1997 d_advance (di, i);
1998 str = d_str (di);
1999 len -= i;
2000 i = 0;
2001 if (next == NULL)
2002 return NULL;
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);
2012 str = d_str (di);
2013 len -= i;
2014 i = 0;
2015 if (next == NULL)
2016 return NULL;
2017 }
2018
2019 if (p == NULL)
2020 p = next;
2021 else
2022 {
2023 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
2024 if (p == NULL)
2025 return NULL;
2026 }
2027 }
2028
2029 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
2030
2031 return p;
2032}
2033
d00edca5
DD		 2034/* <special-name> ::= TV <type>
2035 ::= TT <type>
2036 ::= TI <type>
2037 ::= TS <type>
af03af8f 2038 ::= TA <template-arg>
d00edca5
DD		 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>
839e4798 2047 ::= GA <encoding>
830ef634 2048 ::= Gr <resource name>
956a8f8b
DD		 2049 ::= GTt <encoding>
2050 ::= GTn <encoding>
d00edca5 2051*/
eb383413 2052
59727473 2053static struct demangle_component *
9334f9c6 2054d_special_name (struct d_info *di)
eb383413 2055{
b6fb00c0 2056 di->expansion += 20;
6ef6358e 2057 if (d_check_char (di, 'T'))
03d5f569 2058 {
d00edca5
DD		 2059 switch (d_next_char (di))
2060 {
2061 case 'V':
b6fb00c0 2062 di->expansion -= 5;
59727473
DD		 2063 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
2064 cplus_demangle_type (di), NULL);
d00edca5 2065 case 'T':
b6fb00c0 2066 di->expansion -= 10;
59727473
DD		 2067 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
2068 cplus_demangle_type (di), NULL);
d00edca5 2069 case 'I':
59727473
DD		 2070 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
2071 cplus_demangle_type (di), NULL);
d00edca5 2072 case 'S':
59727473
DD		 2073 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
2074 cplus_demangle_type (di), NULL);
eb383413 2075
d00edca5
DD		 2076 case 'h':
2077 if (! d_call_offset (di, 'h'))
2078 return NULL;
59727473
DD		 2079 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
2080 d_encoding (di, 0), NULL);
eb383413 2081
d00edca5
DD		 2082 case 'v':
2083 if (! d_call_offset (di, 'v'))
2084 return NULL;
59727473
DD		 2085 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
2086 d_encoding (di, 0), NULL);
eb383413 2087
d00edca5
DD		 2088 case 'c':
2089 if (! d_call_offset (di, '\0'))
2090 return NULL;
2091 if (! d_call_offset (di, '\0'))
2092 return NULL;
59727473
DD		 2093 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
2094 d_encoding (di, 0), NULL);
eb383413 2095
d00edca5
DD		 2096 case 'C':
2097 {
59727473 2098 struct demangle_component *derived_type;
fa3fcee7 2099 int offset;
59727473 2100 struct demangle_component *base_type;
d00edca5 2101
59727473 2102 derived_type = cplus_demangle_type (di);
d00edca5
DD		 2103 offset = d_number (di);
2104 if (offset < 0)
2105 return NULL;
6ef6358e 2106 if (! d_check_char (di, '_'))
d00edca5 2107 return NULL;
59727473 2108 base_type = cplus_demangle_type (di);
d00edca5
DD		 2109 /* We don't display the offset. FIXME: We should display
2110 it in verbose mode. */
b6fb00c0 2111 di->expansion += 5;
59727473
DD		 2112 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
2113 base_type, derived_type);
d00edca5 2114 }
eb383413 2115
d00edca5 2116 case 'F':
59727473
DD		 2117 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
2118 cplus_demangle_type (di), NULL);
d00edca5 2119 case 'J':
59727473
DD		 2120 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
2121 cplus_demangle_type (di), NULL);
eb383413 2122
995b61fe
DD		 2123 case 'H':
2124 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
2a8ae714 2125 d_name (di), NULL);
995b61fe
DD		 2126
2127 case 'W':
2128 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
2a8ae714 2129 d_name (di), NULL);
995b61fe 2130
af03af8f
NC		 2131 case 'A':
2132 return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
2133 d_template_arg (di), NULL);
2134
d00edca5
DD		 2135 default:
2136 return NULL;
2137 }
eb383413 2138 }
6ef6358e 2139 else if (d_check_char (di, 'G'))
eb383413 2140 {
d00edca5
DD		 2141 switch (d_next_char (di))
2142 {
2143 case 'V':
26a67918 2144 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
2a8ae714 2145 d_name (di), NULL);
d00edca5
DD		 2146
2147 case 'R':
abc6552b 2148 {
2a8ae714 2149 struct demangle_component *name = d_name (di);
abc6552b
DD		 2150 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
2151 d_number_component (di));
2152 }
d00edca5 2153
839e4798
RH		 2154 case 'A':
2155 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
2156 d_encoding (di, 0), NULL);
2157
956a8f8b
DD		 2158 case 'T':
2159 switch (d_next_char (di))
2160 {
2161 case 'n':
2162 return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
2163 d_encoding (di, 0), NULL);
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);
2173 }
2174
830ef634
DD		 2175 case 'r':
2176 return d_java_resource (di);
2177
d00edca5
DD		 2178 default:
2179 return NULL;
2180 }
eb383413 2181 }
d00edca5
DD		 2182 else
2183 return NULL;
eb383413
L		 2184}
2185
d00edca5
DD		 2186/* <call-offset> ::= h <nv-offset> _
2187 ::= v <v-offset> _
eb383413 2188
d00edca5 2189 <nv-offset> ::= <(offset) number>
eb383413 2190
d00edca5 2191 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
eb383413 2192
d00edca5
DD		 2193 The C parameter, if not '\0', is a character we just read which is
2194 the start of the <call-offset>.
eb383413 2195
d00edca5
DD		 2196 We don't display the offset information anywhere. FIXME: We should
2197 display it in verbose mode. */
eb383413 2198
d00edca5 2199static int
9334f9c6 2200d_call_offset (struct d_info *di, int c)
eb383413 2201{
d00edca5
DD		 2202 if (c == '\0')
2203 c = d_next_char (di);
eb383413 2204
d00edca5 2205 if (c == 'h')
eb129e35 2206 d_number (di);
d00edca5 2207 else if (c == 'v')
eb383413 2208 {
eb129e35 2209 d_number (di);
6ef6358e 2210 if (! d_check_char (di, '_'))
d00edca5 2211 return 0;
eb129e35 2212 d_number (di);
eb383413 2213 }
d00edca5
DD		 2214 else
2215 return 0;
eb383413 2216
6ef6358e 2217 if (! d_check_char (di, '_'))
d00edca5 2218 return 0;
eb383413 2219
d00edca5 2220 return 1;
eb383413
L		 2221}
2222
d00edca5
DD		 2223/* <ctor-dtor-name> ::= C1
2224 ::= C2
2225 ::= C3
2226 ::= D0
2227 ::= D1
2228 ::= D2
2229*/
2230
59727473 2231static struct demangle_component *
9334f9c6 2232d_ctor_dtor_name (struct d_info *di)
d00edca5 2233{
b6fb00c0
DD		 2234 if (di->last_name != NULL)
2235 {
59727473 2236 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
b6fb00c0 2237 di->expansion += di->last_name->u.s_name.len;
59727473 2238 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
b6fb00c0
DD		 2239 di->expansion += di->last_name->u.s_string.len;
2240 }
6ef6358e 2241 switch (d_peek_char (di))
d00edca5
DD		 2242 {
2243 case 'C':
2244 {
2245 enum gnu_v3_ctor_kinds kind;
ef0f5d7c
JM		 2246 int inheriting = 0;
2247
2248 if (d_peek_next_char (di) == 'I')
2249 {
2250 inheriting = 1;
2251 d_advance (di, 1);
2252 }
d00edca5 2253
6ef6358e 2254 switch (d_peek_next_char (di))
d00edca5
DD		 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;
eafbc3bf
BM		 2265 case '4':
2266 kind = gnu_v3_unified_ctor;
2267 break;
956a8f8b
DD		 2268 case '5':
2269 kind = gnu_v3_object_ctor_group;
2270 break;
d00edca5
DD		 2271 default:
2272 return NULL;
2273 }
ef0f5d7c 2274
6ef6358e 2275 d_advance (di, 2);
ef0f5d7c
JM		 2276
2277 if (inheriting)
2278 cplus_demangle_type (di);
2279
d00edca5
DD		 2280 return d_make_ctor (di, kind, di->last_name);
2281 }
2282
2283 case 'D':
2284 {
2285 enum gnu_v3_dtor_kinds kind;
2286
6ef6358e 2287 switch (d_peek_next_char (di))
d00edca5
DD		 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;
eafbc3bf
BM		 2298 /* digit '3' is not used */
2299 case '4':
2300 kind = gnu_v3_unified_dtor;
2301 break;
956a8f8b
DD		 2302 case '5':
2303 kind = gnu_v3_object_dtor_group;
2304 break;
d00edca5
DD		 2305 default:
2306 return NULL;
2307 }
6ef6358e 2308 d_advance (di, 2);
d00edca5
DD		 2309 return d_make_dtor (di, kind, di->last_name);
2310 }
eb383413 2311
d00edca5
DD		 2312 default:
2313 return NULL;
2314 }
2315}
eb383413 2316
a4ddf8dc
JM		 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);
2324 if (peek == 'r' || peek == 'V' || peek == 'K')
2325 return 1;
2326 if (peek == 'D')
2327 {
2328 peek = d_peek_next_char (di);
2329 if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
2330 return 1;
2331 }
2332 return 0;
2333}
2334
d00edca5
DD		 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>
8969a67f 2346 ::= O <type> (C++0x)
d00edca5
DD		 2347 ::= C <type>
2348 ::= G <type>
2349 ::= U <source-name> <type>
2350
2351 <builtin-type> ::= various one letter codes
2352 ::= u <source-name>
2353*/
eb383413 2354
59727473
DD		 2355CP_STATIC_IF_GLIBCPP_V3
2356const struct demangle_builtin_type_info
2357cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
d00edca5 2358{
2d733211 2359 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
b6fb00c0 2360 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
2d733211
DD		 2361 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
2362 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
2363 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
2364 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
2365 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
2366 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
b6fb00c0 2367 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2d733211 2368 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
b6fb00c0
DD		 2369 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2370 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2d733211 2371 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
b6fb00c0 2372 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2d733211
DD		 2373 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2374 D_PRINT_DEFAULT },
1c08f2c8
DD		 2375 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2376 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2377 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2d733211
DD		 2378 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
2379 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
1c08f2c8 2380 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
b6fb00c0 2381 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2d733211
DD		 2382 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
2383 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
2384 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2385 D_PRINT_UNSIGNED_LONG_LONG },
b6fb00c0 2386 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
1c08f2c8
DD		 2387 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
2388 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2389 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2390 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
07ffcfec
AM		 2391 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT },
2392 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2393 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2394 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
cf383746 2395 D_PRINT_DEFAULT },
d00edca5 2396};
eb383413 2397
59727473
DD		 2398CP_STATIC_IF_GLIBCPP_V3
2399struct demangle_component *
9334f9c6 2400cplus_demangle_type (struct d_info *di)
eb383413 2401{
d00edca5 2402 char peek;
59727473 2403 struct demangle_component *ret;
d00edca5
DD		 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
331c3da2
DD		 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. */
d00edca5 2420
a4ddf8dc 2421 if (next_is_type_qual (di))
d00edca5 2422 {
59727473 2423 struct demangle_component **pret;
74bcd529 2424
858b45cf 2425 pret = d_cv_qualifiers (di, &ret, 0);
331c3da2
DD		 2426 if (pret == NULL)
2427 return NULL;
dcd7e9d6
DD		 2428 if (d_peek_char (di) == '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)
3a4d2339
DD		 2438 return NULL;
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);
2445 d_left (*pret) = ret;
2446 ret = *pret;
2447 *pret = fn;
2448 }
2449 if (! d_add_substitution (di, ret))
d00edca5
DD		 2450 return NULL;
2451 return ret;
2452 }
eb383413 2453
d00edca5 2454 can_subst = 1;
eb383413 2455
a4ddf8dc 2456 peek = d_peek_char (di);
74bcd529 2457 switch (peek)
eb383413 2458 {
d00edca5
DD		 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':
59727473
DD		 2463 ret = d_make_builtin_type (di,
2464 &cplus_demangle_builtin_types[peek - 'a']);
b6fb00c0 2465 di->expansion += ret->u.s_builtin.type->len;
d00edca5
DD		 2466 can_subst = 0;
2467 d_advance (di, 1);
2468 break;
2469
2470 case 'u':
2471 d_advance (di, 1);
59727473
DD		 2472 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2473 d_source_name (di), NULL);
d00edca5
DD		 2474 break;
2475
2476 case 'F':
2477 ret = d_function_type (di);
eb383413
L		 2478 break;
2479
d00edca5
DD		 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':
eb383413 2483 case 'Z':
d00edca5 2484 ret = d_class_enum_type (di);
eb383413
L		 2485 break;
2486
d00edca5
DD		 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) == 'I')
03d5f569 2498 {
492e19d0 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
d00edca5 2529 candidate. */
492e19d0 2530 if (! di->is_conversion)
2531 {
2532 if (! d_add_substitution (di, ret))
2533 return NULL;
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) == 'I')
2545 {
2546 if (! d_add_substitution (di, ret))
2547 return NULL;
2548 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2549 args);
2550 }
2551 else
2552 d_backtrack (di, &checkpoint);
2553 }
03d5f569 2554 }
d00edca5
DD		 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;
74bcd529 2562
d00edca5
DD		 2563 peek_next = d_peek_next_char (di);
2564 if (IS_DIGIT (peek_next)
2565 || peek_next == '_'
858b45cf 2566 || IS_UPPER (peek_next))
d00edca5 2567 {
97ceaf5b 2568 ret = d_substitution (di, 0);
d00edca5
DD		 2569 /* The substituted name may have been a template name and
2570 may be followed by tepmlate args. */
2571 if (d_peek_char (di) == 'I')
59727473 2572 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
d00edca5
DD		 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. */
59727473 2584 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
d00edca5
DD		 2585 can_subst = 0;
2586 }
2587 }
eb383413
L		 2588 break;
2589
8969a67f
DD		 2590 case 'O':
2591 d_advance (di, 1);
2592 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2593 cplus_demangle_type (di), NULL);
2594 break;
2595
d00edca5
DD		 2596 case 'P':
2597 d_advance (di, 1);
59727473
DD		 2598 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2599 cplus_demangle_type (di), NULL);
d00edca5 2600 break;
eb383413 2601
d00edca5
DD		 2602 case 'R':
2603 d_advance (di, 1);
59727473 2604 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
8969a67f 2605 cplus_demangle_type (di), NULL);
d00edca5 2606 break;
eb383413 2607
d00edca5
DD		 2608 case 'C':
2609 d_advance (di, 1);
59727473
DD		 2610 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2611 cplus_demangle_type (di), NULL);
d00edca5
DD		 2612 break;
2613
2614 case 'G':
2615 d_advance (di, 1);
59727473
DD		 2616 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2617 cplus_demangle_type (di), NULL);
d00edca5 2618 break;
eb383413 2619
d00edca5
DD		 2620 case 'U':
2621 d_advance (di, 1);
2622 ret = d_source_name (di);
f91ca6bc
IB		 2623 if (d_peek_char (di) == 'I')
2624 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2625 d_template_args (di));
59727473
DD		 2626 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2627 cplus_demangle_type (di), ret);
eb383413 2628 break;
d00edca5 2629
ba8cb4ba
DD		 2630 case 'D':
2631 can_subst = 0;
2632 d_advance (di, 1);
2633 peek = d_next_char (di);
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);
2641 if (ret && d_next_char (di) != 'E')
2642 ret = NULL;
eb7b5ddb 2643 can_subst = 1;
ba8cb4ba
DD		 2644 break;
2645
2646 case 'p':
2647 /* Pack expansion. */
1c08f2c8
DD		 2648 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2649 cplus_demangle_type (di), NULL);
eb7b5ddb 2650 can_subst = 1;
1c08f2c8 2651 break;
24e829d0
DD		 2652
2653 case 'a':
2654 /* auto */
2655 ret = d_make_name (di, "auto", 4);
2656 break;
e495212d
AM		 2657 case 'c':
2658 /* decltype(auto) */
2659 ret = d_make_name (di, "decltype(auto)", 14);
2660 break;
2661
ba8cb4ba 2662 case 'f':
1c08f2c8
DD		 2663 /* 32-bit decimal floating point */
2664 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
ba8cb4ba
DD		 2665 di->expansion += ret->u.s_builtin.type->len;
2666 break;
2667 case 'd':
1c08f2c8
DD		 2668 /* 64-bit DFP */
2669 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
ba8cb4ba
DD		 2670 di->expansion += ret->u.s_builtin.type->len;
2671 break;
2672 case 'e':
2673 /* 128-bit DFP */
1c08f2c8 2674 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
ba8cb4ba
DD		 2675 di->expansion += ret->u.s_builtin.type->len;
2676 break;
2677 case 'h':
2678 /* 16-bit half-precision FP */
1c08f2c8
DD		 2679 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2680 di->expansion += ret->u.s_builtin.type->len;
2681 break;
07ffcfec
AM		 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;
1c08f2c8
DD		 2687 case 's':
2688 /* char16_t */
07ffcfec 2689 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
1c08f2c8
DD		 2690 di->expansion += ret->u.s_builtin.type->len;
2691 break;
2692 case 'i':
2693 /* char32_t */
07ffcfec 2694 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
ba8cb4ba
DD		 2695 di->expansion += ret->u.s_builtin.type->len;
2696 break;
d2825c1a
DD		 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))))
2703 /* For demangling we don't care about the bits. */
2704 d_number (di);
2705 ret->u.s_fixed.length = cplus_demangle_type (di);
cbc43128
DD		 2706 if (ret->u.s_fixed.length == NULL)
2707 return NULL;
d2825c1a
DD		 2708 d_number (di);
2709 peek = d_next_char (di);
2710 ret->u.s_fixed.sat = (peek == 's');
2711 break;
60cf58f5 2712
cbc43128
DD		 2713 case 'v':
2714 ret = d_vector_type (di);
eb7b5ddb 2715 can_subst = 1;
cbc43128
DD		 2716 break;
2717
cf383746
DD		 2718 case 'n':
2719 /* decltype(nullptr) */
07ffcfec 2720 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]);
cf383746
DD		 2721 di->expansion += ret->u.s_builtin.type->len;
2722 break;
2723
60cf58f5
DD		 2724 default:
2725 return NULL;
ba8cb4ba
DD		 2726 }
2727 break;
2728
d00edca5
DD		 2729 default:
2730 return NULL;
eb383413
L		 2731 }
2732
d00edca5
DD		 2733 if (can_subst)
2734 {
2735 if (! d_add_substitution (di, ret))
2736 return NULL;
2737 }
eb383413 2738
d00edca5
DD		 2739 return ret;
2740}
eb383413 2741
e9a38816 2742/* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
eb383413 2743
59727473 2744static struct demangle_component **
9334f9c6
DD		 2745d_cv_qualifiers (struct d_info *di,
2746 struct demangle_component **pret, int member_fn)
eb383413 2747{
f9fb0b2d 2748 struct demangle_component **pstart;
eb383413
L		 2749 char peek;
2750
f9fb0b2d 2751 pstart = pret;
d00edca5 2752 peek = d_peek_char (di);
a4ddf8dc 2753 while (next_is_type_qual (di))
eb383413 2754 {
59727473 2755 enum demangle_component_type t;
a4ddf8dc 2756 struct demangle_component *right = NULL;
59666b35 2757
d00edca5
DD		 2758 d_advance (di, 1);
2759 if (peek == 'r')
b6fb00c0 2760 {
59727473
DD		 2761 t = (member_fn
2762 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2763 : DEMANGLE_COMPONENT_RESTRICT);
b6fb00c0
DD		 2764 di->expansion += sizeof "restrict";
2765 }
d00edca5 2766 else if (peek == 'V')
b6fb00c0 2767 {
59727473
DD		 2768 t = (member_fn
2769 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2770 : DEMANGLE_COMPONENT_VOLATILE);
b6fb00c0
DD		 2771 di->expansion += sizeof "volatile";
2772 }
e9a38816 2773 else if (peek == 'K')
b6fb00c0 2774 {
59727473
DD		 2775 t = (member_fn
2776 ? DEMANGLE_COMPONENT_CONST_THIS
2777 : DEMANGLE_COMPONENT_CONST);
b6fb00c0
DD		 2778 di->expansion += sizeof "const";
2779 }
e9a38816
JM		 2780 else
2781 {
a4ddf8dc
JM		 2782 peek = d_next_char (di);
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)
2797 return NULL;
2798 if (! d_check_char (di, 'E'))
2799 return NULL;
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)
2808 return NULL;
2809 if (! d_check_char (di, 'E'))
2810 return NULL;
2811 }
2812 else
2813 return NULL;
e9a38816 2814 }
eb383413 2815
a4ddf8dc 2816 *pret = d_make_comp (di, t, NULL, right);
d00edca5
DD		 2817 if (*pret == NULL)
2818 return NULL;
2819 pret = &d_left (*pret);
eb383413 2820
d00edca5
DD		 2821 peek = d_peek_char (di);
2822 }
eb383413 2823
f9fb0b2d
DD		 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);
2843 }
2844 }
2845
d00edca5
DD		 2846 return pret;
2847}
eb383413 2848
3a4d2339
DD		 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);
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);
2873
2874 ret = d_make_comp (di, t, ret, NULL);
2875 }
2876
2877 return ret;
2878}
2879
e9a38816 2880/* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
eb383413 2881
59727473 2882static struct demangle_component *
9334f9c6 2883d_function_type (struct d_info *di)
eb383413 2884{
af03af8f 2885 struct demangle_component *ret = NULL;
eb383413 2886
af03af8f 2887 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
d00edca5 2888 {
af03af8f
NC		 2889 if (di->recursion_level > DEMANGLE_RECURSION_LIMIT)
2890 /* FIXME: There ought to be a way to report
2891 that the recursion limit has been reached. */
2892 return NULL;
2893
2894 di->recursion_level ++;
d00edca5 2895 }
3a4d2339 2896
af03af8f
NC		 2897 if (d_check_char (di, 'F'))
2898 {
2899 if (d_peek_char (di) == '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);
2904 }
2905 ret = d_bare_function_type (di, 1);
2906 ret = d_ref_qualifier (di, ret);
2907
2908 if (! d_check_char (di, 'E'))
2909 ret = NULL;
2910 }
2911
2912 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2913 di->recursion_level --;
d00edca5
DD		 2914 return ret;
2915}
74bcd529 2916
664aa91f 2917/* <type>+ */
eb383413 2918
59727473 2919static struct demangle_component *
664aa91f 2920d_parmlist (struct d_info *di)
d00edca5 2921{
59727473
DD		 2922 struct demangle_component *tl;
2923 struct demangle_component **ptl;
7887b2ce 2924
d00edca5
DD		 2925 tl = NULL;
2926 ptl = &tl;
eb383413
L		 2927 while (1)
2928 {
59727473 2929 struct demangle_component *type;
eb383413 2930
664aa91f 2931 char peek = d_peek_char (di);
7955ede5 2932 if (peek == '\0' || peek == 'E' || peek == '.')
d00edca5 2933 break;
3a4d2339
DD		 2934 if ((peek == 'R' || peek == 'O')
2935 && d_peek_next_char (di) == 'E')
2936 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2937 break;
59727473 2938 type = cplus_demangle_type (di);
d00edca5
DD		 2939 if (type == NULL)
2940 return NULL;
664aa91f
DD		 2941 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2942 if (*ptl == NULL)
2943 return NULL;
2944 ptl = &d_right (*ptl);
eb383413 2945 }
eb383413 2946
d00edca5
DD		 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)
2951 return NULL;
eb383413 2952
d00edca5
DD		 2953 /* If we have a single parameter type void, omit it. */
2954 if (d_right (tl) == NULL
59727473 2955 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
d00edca5 2956 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
b6fb00c0
DD		 2957 {
2958 di->expansion -= d_left (tl)->u.s_builtin.type->len;
664aa91f 2959 d_left (tl) = NULL;
b6fb00c0 2960 }
eb383413 2961
664aa91f
DD		 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);
2977 if (peek == 'J')
2978 {
2979 d_advance (di, 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)
2987 return NULL;
2988 }
2989 else
2990 return_type = NULL;
2991
2992 tl = d_parmlist (di);
2993 if (tl == NULL)
2994 return NULL;
2995
2996 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2997 return_type, tl);
d00edca5 2998}
eb383413 2999
d00edca5 3000/* <class-enum-type> ::= <name> */
eb383413 3001
59727473 3002static struct demangle_component *
9334f9c6 3003d_class_enum_type (struct d_info *di)
d00edca5 3004{
2a8ae714 3005 return d_name (di);
d00edca5 3006}
74bcd529 3007
d00edca5
DD		 3008/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
3009 ::= A [<(dimension) expression>] _ <(element) type>
3010*/
74bcd529 3011
59727473 3012static struct demangle_component *
9334f9c6 3013d_array_type (struct d_info *di)
d00edca5
DD		 3014{
3015 char peek;
59727473 3016 struct demangle_component *dim;
74bcd529 3017
6ef6358e 3018 if (! d_check_char (di, 'A'))
d00edca5
DD		 3019 return NULL;
3020
3021 peek = d_peek_char (di);
3022 if (peek == '_')
3023 dim = NULL;
3024 else if (IS_DIGIT (peek))
74bcd529 3025 {
d00edca5 3026 const char *s;
74bcd529 3027
d00edca5
DD		 3028 s = d_str (di);
3029 do
3030 {
3031 d_advance (di, 1);
3032 peek = d_peek_char (di);
3033 }
3034 while (IS_DIGIT (peek));
3035 dim = d_make_name (di, s, d_str (di) - s);
331c3da2
DD		 3036 if (dim == NULL)
3037 return NULL;
74bcd529 3038 }
eb383413 3039 else
d00edca5
DD		 3040 {
3041 dim = d_expression (di);
3042 if (dim == NULL)
3043 return NULL;
3044 }
eb383413 3045
6ef6358e 3046 if (! d_check_char (di, '_'))
d00edca5 3047 return NULL;
eb383413 3048
59727473
DD		 3049 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
3050 cplus_demangle_type (di));
d00edca5 3051}
eb383413 3052
cbc43128
DD		 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);
3063 if (peek == '_')
3064 {
3065 d_advance (di, 1);
3066 dim = d_expression (di);
3067 }
3068 else
3069 dim = d_number_component (di);
3070
3071 if (dim == NULL)
3072 return NULL;
3073
3074 if (! d_check_char (di, '_'))
3075 return NULL;
3076
3077 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
3078 cplus_demangle_type (di));
3079}
3080
d00edca5 3081/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
eb383413 3082
59727473 3083static struct demangle_component *
9334f9c6 3084d_pointer_to_member_type (struct d_info *di)
eb383413 3085{
59727473
DD		 3086 struct demangle_component *cl;
3087 struct demangle_component *mem;
eb383413 3088
6ef6358e 3089 if (! d_check_char (di, 'M'))
d00edca5 3090 return NULL;
eb383413 3091
59727473 3092 cl = cplus_demangle_type (di);
dcd7e9d6 3093 if (cl == NULL)
8d301070 3094 return NULL;
eb383413 3095
dcd7e9d6
DD		 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)
3113 return NULL;
cb6c09ac 3114
59727473 3115 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
eb383413
L		 3116}
3117
664aa91f
DD		 3118/* <non-negative number> _ */
3119
fa3fcee7 3120static int
664aa91f
DD		 3121d_compact_number (struct d_info *di)
3122{
fa3fcee7 3123 int num;
664aa91f
DD		 3124 if (d_peek_char (di) == '_')
3125 num = 0;
3126 else if (d_peek_char (di) == 'n')
3127 return -1;
3128 else
3129 num = d_number (di) + 1;
3130
fa3fcee7 3131 if (num < 0 || ! d_check_char (di, '_'))
664aa91f
DD		 3132 return -1;
3133 return num;
3134}
3135
d00edca5
DD		 3136/* <template-param> ::= T_
3137 ::= T <(parameter-2 non-negative) number> _
3138*/
eb383413 3139
59727473 3140static struct demangle_component *
9334f9c6 3141d_template_param (struct d_info *di)
eb383413 3142{
fa3fcee7 3143 int param;
eb383413 3144
6ef6358e 3145 if (! d_check_char (di, 'T'))
d00edca5 3146 return NULL;
eb383413 3147
664aa91f
DD		 3148 param = d_compact_number (di);
3149 if (param < 0)
d00edca5 3150 return NULL;
eb383413 3151
d00edca5 3152 return d_make_template_param (di, param);
eb383413
L		 3153}
3154
d00edca5
DD		 3155/* <template-args> ::= I <template-arg>+ E */
3156
59727473 3157static struct demangle_component *
9334f9c6 3158d_template_args (struct d_info *di)
fa3fcee7
NC		 3159{
3160 if (d_peek_char (di) != 'I'
3161 && d_peek_char (di) != 'J')
3162 return NULL;
3163 d_advance (di, 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)
eb383413 3172{
59727473
DD		 3173 struct demangle_component *hold_last_name;
3174 struct demangle_component *al;
3175 struct demangle_component **pal;
eb383413 3176
d00edca5
DD		 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;
eb383413 3181
1c08f2c8
DD		 3182 if (d_peek_char (di) == 'E')
3183 {
3184 /* An argument pack can be empty. */
3185 d_advance (di, 1);
3186 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
3187 }
3188
d00edca5
DD		 3189 al = NULL;
3190 pal = &al;
eb383413
L		 3191 while (1)
3192 {
59727473 3193 struct demangle_component *a;
d00edca5
DD		 3194
3195 a = d_template_arg (di);
3196 if (a == NULL)
3197 return NULL;
3198
59727473 3199 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
331c3da2
DD		 3200 if (*pal == NULL)
3201 return NULL;
d00edca5
DD		 3202 pal = &d_right (*pal);
3203
3204 if (d_peek_char (di) == 'E')
03d5f569 3205 {
d00edca5
DD		 3206 d_advance (di, 1);
3207 break;
03d5f569 3208 }
eb383413
L		 3209 }
3210
d00edca5
DD		 3211 di->last_name = hold_last_name;
3212
3213 return al;
eb383413
L		 3214}
3215
d00edca5
DD		 3216/* <template-arg> ::= <type>
3217 ::= X <expression> E
3218 ::= <expr-primary>
3219*/
eb383413 3220
59727473 3221static struct demangle_component *
9334f9c6 3222d_template_arg (struct d_info *di)
eb383413 3223{
59727473 3224 struct demangle_component *ret;
03d5f569 3225
d00edca5 3226 switch (d_peek_char (di))
eb383413 3227 {
d00edca5
DD		 3228 case 'X':
3229 d_advance (di, 1);
3230 ret = d_expression (di);
6ef6358e 3231 if (! d_check_char (di, 'E'))
d00edca5
DD		 3232 return NULL;
3233 return ret;
b851d07b 3234
d00edca5
DD		 3235 case 'L':
3236 return d_expr_primary (di);
eb383413 3237
1c08f2c8 3238 case 'I':
eb7b5ddb 3239 case 'J':
1c08f2c8
DD		 3240 /* An argument pack. */
3241 return d_template_args (di);
3242
d00edca5 3243 default:
59727473 3244 return cplus_demangle_type (di);
74bcd529 3245 }
eb383413
L		 3246}
3247
eb7b5ddb
DD		 3248/* Parse a sequence of expressions until we hit the terminator
3249 character. */
ba8cb4ba
DD		 3250
3251static struct demangle_component *
eb7b5ddb 3252d_exprlist (struct d_info *di, char terminator)
ba8cb4ba
DD		 3253{
3254 struct demangle_component *list = NULL;
3255 struct demangle_component **p = &list;
3256
eb7b5ddb 3257 if (d_peek_char (di) == terminator)
1c08f2c8
DD		 3258 {
3259 d_advance (di, 1);
3260 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
3261 }
3262
ba8cb4ba
DD		 3263 while (1)
3264 {
3265 struct demangle_component *arg = d_expression (di);
3266 if (arg == NULL)
3267 return NULL;
3268
3269 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
3270 if (*p == NULL)
3271 return NULL;
3272 p = &d_right (*p);
3273
eb7b5ddb 3274 if (d_peek_char (di) == terminator)
ba8cb4ba
DD		 3275 {
3276 d_advance (di, 1);
3277 break;
3278 }
3279 }
3280
3281 return list;
3282}
3283
7c328963
DD		 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
d750c713
NC		 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);
3314
3315 peek = d_peek_char (di);
3316 if (di->unresolved_name_state
3317 && (IS_DIGIT (peek)
3318 || IS_LOWER (peek)
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) == 'E')
3330 d_advance (di, 1);
3331 }
3332 else
3333 type = cplus_demangle_type (di);
3334 name = d_unqualified_name (di);
3335 if (d_peek_char (di) == '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
d00edca5
DD		 3341/* <expression> ::= <(unary) operator-name> <expression>
3342 ::= <(binary) operator-name> <expression> <expression>
3343 ::= <(trinary) operator-name> <expression> <expression> <expression>
ba8cb4ba 3344 ::= cl <expression>+ E
d00edca5
DD		 3345 ::= st <type>
3346 ::= <template-param>
d750c713 3347 ::= <unresolved-name>
d00edca5 3348 ::= <expr-primary>
7ade7fba
AM		 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
d00edca5
DD		 3355*/
3356
d750c713 3357static struct demangle_component *
492e19d0 3358d_expression_1 (struct d_info *di)
eb383413 3359{
d00edca5 3360 char peek;
eb383413 3361
d00edca5
DD		 3362 peek = d_peek_char (di);
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) == 'r')
d750c713 3368 return d_unresolved_name (di);
e2e1864d
DD		 3369 else if (peek == 's' && d_peek_next_char (di) == 'p')
3370 {
3371 d_advance (di, 2);
3372 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
492e19d0 3373 d_expression_1 (di), NULL);
e2e1864d 3374 }
c743cf5d 3375 else if (peek == 'f' && d_peek_next_char (di) == 'p')
ba8cb4ba 3376 {
c743cf5d
DD		 3377 /* Function parameter used in a late-specified return type. */
3378 int index;
ba8cb4ba 3379 d_advance (di, 2);
f2917a30
DD		 3380 if (d_peek_char (di) == 'T')
3381 {
3382 /* 'this' parameter. */
3383 d_advance (di, 1);
3384 index = 0;
3385 }
3386 else
3387 {
fa3fcee7
NC		 3388 index = d_compact_number (di);
3389 if (index == INT_MAX || index == -1)
f2917a30 3390 return NULL;
fa3fcee7 3391 index++;
f2917a30 3392 }
c743cf5d 3393 return d_make_function_param (di, index);
ba8cb4ba 3394 }
cbc43128
DD		 3395 else if (IS_DIGIT (peek)
3396 || (peek == 'o' && d_peek_next_char (di) == 'n'))
1c08f2c8
DD		 3397 {
3398 /* We can get an unqualified name as an expression in the case of
cbc43128
DD		 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);
3405
3406 name = d_unqualified_name (di);
1c08f2c8
DD		 3407 if (name == NULL)
3408 return NULL;
3409 if (d_peek_char (di) == 'I')
3410 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3411 d_template_args (di));
3412 else
3413 return name;
3414 }
eb7b5ddb
DD		 3415 else if ((peek == 'i' || peek == 't')
3416 && d_peek_next_char (di) == 'l')
3417 {
3418 /* Brace-enclosed initializer list, untyped or typed. */
3419 struct demangle_component *type = NULL;
af03af8f 3420 d_advance (di, 2);
eb7b5ddb
DD		 3421 if (peek == 't')
3422 type = cplus_demangle_type (di);
f211b8c0 3423 if (!d_peek_char (di) || !d_peek_next_char (di))
d81bf7dd 3424 return NULL;
eb7b5ddb
DD		 3425 return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3426 type, d_exprlist (di, 'E'));
3427 }
d00edca5 3428 else
eb383413 3429 {
59727473 3430 struct demangle_component *op;
eb7b5ddb 3431 const char *code = NULL;
d00edca5 3432 int args;
eb383413 3433
d00edca5
DD		 3434 op = d_operator_name (di);
3435 if (op == NULL)
3436 return NULL;
eb383413 3437
59727473 3438 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
eb7b5ddb
DD		 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 }
eb383413 3446
d00edca5
DD		 3447 switch (op->type)
3448 {
3449 default:
3450 return NULL;
59727473 3451 case DEMANGLE_COMPONENT_OPERATOR:
d00edca5
DD		 3452 args = op->u.s_operator.op->args;
3453 break;
59727473 3454 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d00edca5
DD		 3455 args = op->u.s_extended_operator.args;
3456 break;
59727473 3457 case DEMANGLE_COMPONENT_CAST:
60cf58f5 3458 args = 1;
d00edca5
DD		 3459 break;
3460 }
3461
3462 switch (args)
3463 {
eb7b5ddb
DD		 3464 case 0:
3465 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3466
d00edca5 3467 case 1:
c743cf5d
DD		 3468 {
3469 struct demangle_component *operand;
eb7b5ddb
DD		 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, '_');
3476
c743cf5d
DD		 3477 if (op->type == DEMANGLE_COMPONENT_CAST
3478 && d_check_char (di, '_'))
eb7b5ddb 3479 operand = d_exprlist (di, 'E');
fa3fcee7
NC		 3480 else if (code && !strcmp (code, "sP"))
3481 operand = d_template_args_1 (di);
c743cf5d 3482 else
492e19d0 3483 operand = d_expression_1 (di);
eb7b5ddb
DD		 3484
3485 if (suffix)
3486 /* Indicate the suffix variant for d_print_comp. */
2a8ae714
NC		 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);
c743cf5d 3491 }
d00edca5
DD		 3492 case 2:
3493 {
59727473 3494 struct demangle_component *left;
ba8cb4ba 3495 struct demangle_component *right;
d00edca5 3496
d81bf7dd
MM		 3497 if (code == NULL)
3498 return NULL;
7c328963
DD		 3499 if (op_is_new_cast (op))
3500 left = cplus_demangle_type (di);
fa3fcee7
NC		 3501 else if (code[0] == 'f')
3502 /* fold-expression. */
3503 left = d_operator_name (di);
7ade7fba
AM		 3504 else if (!strcmp (code, "di"))
3505 left = d_unqualified_name (di);
7c328963 3506 else
492e19d0 3507 left = d_expression_1 (di);
cbc43128 3508 if (!strcmp (code, "cl"))
eb7b5ddb 3509 right = d_exprlist (di, 'E');
cbc43128
DD		 3510 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3511 {
d750c713
NC		 3512 peek = d_peek_char (di);
3513 /* These codes start a qualified name. */
3514 if ((peek == 'g' && d_peek_next_char (di) == 's')
3515 || (peek == 's' && d_peek_next_char (di) == '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) == 'I')
3525 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3526 right, d_template_args (di));
3527 }
cbc43128 3528 }
ba8cb4ba 3529 else
492e19d0 3530 right = d_expression_1 (di);
ba8cb4ba 3531
59727473
DD		 3532 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3533 d_make_comp (di,
3534 DEMANGLE_COMPONENT_BINARY_ARGS,
ba8cb4ba 3535 left, right));
d00edca5
DD		 3536 }
3537 case 3:
3538 {
59727473
DD		 3539 struct demangle_component *first;
3540 struct demangle_component *second;
eb7b5ddb 3541 struct demangle_component *third;
d00edca5 3542
d81bf7dd
MM		 3543 if (code == NULL)
3544 return NULL;
7ade7fba
AM		 3545 else if (!strcmp (code, "qu")
3546 || !strcmp (code, "dX"))
eb7b5ddb
DD		 3547 {
3548 /* ?: expression. */
492e19d0 3549 first = d_expression_1 (di);
3550 second = d_expression_1 (di);
3551 third = d_expression_1 (di);
ddc5804e
MW		 3552 if (third == NULL)
3553 return NULL;
eb7b5ddb 3554 }
fa3fcee7
NC		 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);
ddc5804e
MW		 3561 if (third == NULL)
3562 return NULL;
fa3fcee7 3563 }
eb7b5ddb
DD		 3564 else if (code[0] == 'n')
3565 {
3566 /* new-expression. */
3567 if (code[1] != 'w' && code[1] != 'a')
3568 return NULL;
3569 first = d_exprlist (di, '_');
3570 second = cplus_demangle_type (di);
3571 if (d_peek_char (di) == 'E')
3572 {
3573 d_advance (di, 1);
3574 third = NULL;
3575 }
3576 else if (d_peek_char (di) == 'p'
3577 && d_peek_next_char (di) == 'i')
3578 {
3579 /* Parenthesized initializer. */
3580 d_advance (di, 2);
3581 third = d_exprlist (di, 'E');
3582 }
3583 else if (d_peek_char (di) == 'i'
3584 && d_peek_next_char (di) == 'l')
3585 /* initializer-list. */
492e19d0 3586 third = d_expression_1 (di);
eb7b5ddb
DD		 3587 else
3588 return NULL;
3589 }
3590 else
3591 return NULL;
59727473
DD		 3592 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3593 d_make_comp (di,
3594 DEMANGLE_COMPONENT_TRINARY_ARG1,
3595 first,
d00edca5 3596 d_make_comp (di,
59727473 3597 DEMANGLE_COMPONENT_TRINARY_ARG2,
eb7b5ddb 3598 second, third)));
d00edca5
DD		 3599 }
3600 default:
3601 return NULL;
3602 }
eb383413
L		 3603 }
3604}
3605
492e19d0 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
d00edca5
DD		 3618/* <expr-primary> ::= L <type> <(value) number> E
3619 ::= L <type> <(value) float> E
3620 ::= L <mangled-name> E
3621*/
74bcd529 3622
59727473 3623static struct demangle_component *
9334f9c6 3624d_expr_primary (struct d_info *di)
74bcd529 3625{
59727473 3626 struct demangle_component *ret;
74bcd529 3627
6ef6358e 3628 if (! d_check_char (di, 'L'))
d00edca5 3629 return NULL;
c743cf5d
DD		 3630 if (d_peek_char (di) == '_'
3631 /* Workaround for G++ bug; see comment in write_template_arg. */
3632 || d_peek_char (di) == 'Z')
59727473 3633 ret = cplus_demangle_mangled_name (di, 0);
d00edca5 3634 else
74bcd529 3635 {
59727473
DD		 3636 struct demangle_component *type;
3637 enum demangle_component_type t;
d00edca5
DD		 3638 const char *s;
3639
59727473 3640 type = cplus_demangle_type (di);
a21da8bf
DD		 3641 if (type == NULL)
3642 return NULL;
d00edca5 3643
b6fb00c0
DD		 3644 /* If we have a type we know how to print, we aren't going to
3645 print the type name itself. */
59727473 3646 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
b6fb00c0
DD		 3647 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3648 di->expansion -= type->u.s_builtin.type->len;
3649
533da483
NC		 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) == 'E')
3655 {
3656 d_advance (di, 1);
3657 return type;
3658 }
3659 }
3660
d00edca5
DD		 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
59727473 3672 t = DEMANGLE_COMPONENT_LITERAL;
97ceaf5b
DD		 3673 if (d_peek_char (di) == 'n')
3674 {
59727473 3675 t = DEMANGLE_COMPONENT_LITERAL_NEG;
97ceaf5b
DD		 3676 d_advance (di, 1);
3677 }
d00edca5
DD		 3678 s = d_str (di);
3679 while (d_peek_char (di) != 'E')
6ba85b8c
DD		 3680 {
3681 if (d_peek_char (di) == '\0')
3682 return NULL;
3683 d_advance (di, 1);
3684 }
97ceaf5b 3685 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
d00edca5 3686 }
6ef6358e 3687 if (! d_check_char (di, 'E'))
d00edca5
DD		 3688 return NULL;
3689 return ret;
74bcd529
DD		 3690}
3691
d00edca5
DD		 3692/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3693 ::= Z <(function) encoding> E s [<discriminator>]
a9c3ecea 3694 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
d00edca5 3695*/
74bcd529 3696
59727473 3697static struct demangle_component *
2a8ae714 3698d_local_name (struct d_info *di)
74bcd529 3699{
59727473 3700 struct demangle_component *function;
26a67918 3701 struct demangle_component *name;
74bcd529 3702
6ef6358e 3703 if (! d_check_char (di, 'Z'))
d00edca5 3704 return NULL;
74bcd529 3705
6d95373e 3706 function = d_encoding (di, 0);
2a8ae714
NC		 3707 if (!function)
3708 return NULL;
74bcd529 3709
6ef6358e 3710 if (! d_check_char (di, 'E'))
d00edca5 3711 return NULL;
74bcd529 3712
d00edca5 3713 if (d_peek_char (di) == 's')
74bcd529 3714 {
d00edca5
DD		 3715 d_advance (di, 1);
3716 if (! d_discriminator (di))
3717 return NULL;
26a67918 3718 name = d_make_name (di, "string literal", sizeof "string literal" - 1);
74bcd529 3719 }
d00edca5 3720 else
74bcd529 3721 {
664aa91f
DD		 3722 int num = -1;
3723
3724 if (d_peek_char (di) == 'd')
3725 {
3726 /* Default argument scope: d <number> _. */
3727 d_advance (di, 1);
3728 num = d_compact_number (di);
3729 if (num < 0)
3730 return NULL;
3731 }
74bcd529 3732
2a8ae714 3733 name = d_name (di);
26a67918
PA		 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 {
26a67918
PA		 3741 /* Read and ignore an optional discriminator. */
3742 if (! d_discriminator (di))
3743 return NULL;
3744 }
3745
664aa91f
DD		 3746 if (num >= 0)
3747 name = d_make_default_arg (di, num, name);
74bcd529 3748 }
26a67918 3749
2a8ae714
NC		 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)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3755 d_left (d_right (function)) = NULL;
3756
26a67918 3757 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
74bcd529
DD		 3758}
3759
134e805d
NC		 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.
eb383413 3765
d00edca5
DD		 3766 We demangle the discriminator, but we don't print it out. FIXME:
3767 We should print it out in verbose mode. */
74bcd529 3768
d00edca5 3769static int
9334f9c6 3770d_discriminator (struct d_info *di)
d00edca5 3771{
134e805d 3772 int discrim, num_underscores = 1;
74bcd529 3773
d00edca5
DD		 3774 if (d_peek_char (di) != '_')
3775 return 1;
3776 d_advance (di, 1);
134e805d
NC		 3777 if (d_peek_char (di) == '_')
3778 {
3779 ++num_underscores;
3780 d_advance (di, 1);
3781 }
3782
d00edca5
DD		 3783 discrim = d_number (di);
3784 if (discrim < 0)
3785 return 0;
134e805d
NC		 3786 if (num_underscores > 1 && discrim >= 10)
3787 {
3788 if (d_peek_char (di) == '_')
3789 d_advance (di, 1);
3790 else
3791 return 0;
3792 }
3793
d00edca5
DD		 3794 return 1;
3795}
eb383413 3796
664aa91f
DD		 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'))
3807 return NULL;
3808 if (! d_check_char (di, 'l'))
3809 return NULL;
3810
3811 tl = d_parmlist (di);
3812 if (tl == NULL)
3813 return NULL;
3814
3815 if (! d_check_char (di, 'E'))
3816 return NULL;
3817
3818 num = d_compact_number (di);
3819 if (num < 0)
3820 return NULL;
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
664aa91f
DD		 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;
fa3fcee7 3839 int num;
664aa91f
DD		 3840
3841 if (! d_check_char (di, 'U'))
3842 return NULL;
3843 if (! d_check_char (di, 't'))
3844 return NULL;
3845
3846 num = d_compact_number (di);
3847 if (num < 0)
3848 return NULL;
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;
3859
3860 return ret;
3861}
3862
7955ede5
DD		 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);
3870 const char *pend = suffix;
3871 struct demangle_component *n;
3872
3873 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3874 {
3875 pend += 2;
3876 while (IS_LOWER (*pend) || *pend == '_')
3877 ++pend;
3878 }
3879 while (*pend == '.' && IS_DIGIT (pend[1]))
3880 {
3881 pend += 2;
3882 while (IS_DIGIT (*pend))
3883 ++pend;
3884 }
3885 d_advance (di, pend - suffix);
3886 n = d_make_name (di, suffix, pend - suffix);
3887 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3888}
3889
d00edca5 3890/* Add a new substitution. */
eb383413 3891
d00edca5 3892static int
9334f9c6 3893d_add_substitution (struct d_info *di, struct demangle_component *dc)
eb383413 3894{
331c3da2
DD		 3895 if (dc == NULL)
3896 return 0;
d00edca5
DD		 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
97ceaf5b
DD		 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.
d00edca5 3921*/
eb383413 3922
97ceaf5b
DD		 3923static const struct d_standard_sub_info standard_subs[] =
3924{
b6fb00c0
DD		 3925 { 't', NL ("std"),
3926 NL ("std"),
3927 NULL, 0 },
3928 { 'a', NL ("std::allocator"),
3929 NL ("std::allocator"),
3930 NL ("allocator") },
3931 { 'b', NL ("std::basic_string"),
3932 NL ("std::basic_string"),
3933 NL ("basic_string") },
3934 { 's', NL ("std::string"),
3935 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3936 NL ("basic_string") },
3937 { 'i', NL ("std::istream"),
3938 NL ("std::basic_istream<char, std::char_traits<char> >"),
3939 NL ("basic_istream") },
3940 { 'o', NL ("std::ostream"),
3941 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3942 NL ("basic_ostream") },
3943 { 'd', NL ("std::iostream"),
3944 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3945 NL ("basic_iostream") }
97ceaf5b
DD		 3946};
3947
59727473 3948static struct demangle_component *
9334f9c6 3949d_substitution (struct d_info *di, int prefix)
d00edca5
DD		 3950{
3951 char c;
eb383413 3952
6ef6358e 3953 if (! d_check_char (di, 'S'))
d00edca5 3954 return NULL;
e7e9b069 3955
d00edca5 3956 c = d_next_char (di);
858b45cf 3957 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
eb383413 3958 {
dddc49b7 3959 unsigned int id;
eb383413 3960
d00edca5
DD		 3961 id = 0;
3962 if (c != '_')
eb383413 3963 {
d00edca5 3964 do
eb383413 3965 {
dddc49b7
DD		 3966 unsigned int new_id;
3967
d00edca5 3968 if (IS_DIGIT (c))
dddc49b7 3969 new_id = id * 36 + c - '0';
858b45cf 3970 else if (IS_UPPER (c))
dddc49b7 3971 new_id = id * 36 + c - 'A' + 10;
d00edca5
DD		 3972 else
3973 return NULL;
dddc49b7 3974 if (new_id < id)
e63f184e 3975 return NULL;
dddc49b7 3976 id = new_id;
d00edca5 3977 c = d_next_char (di);
eb383413 3978 }
d00edca5 3979 while (c != '_');
eb383413 3980
d00edca5 3981 ++id;
eb383413 3982 }
eb383413 3983
dddc49b7 3984 if (id >= (unsigned int) di->next_sub)
d00edca5 3985 return NULL;
eb383413 3986
d00edca5 3987 return di->subs[id];
eb383413 3988 }
d00edca5 3989 else
eb383413 3990 {
97ceaf5b
DD		 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) != 0;
3996 if (! verbose && prefix)
e61231f1 3997 {
97ceaf5b
DD		 3998 char peek;
3999
4000 peek = d_peek_char (di);
4001 if (peek == 'C' || peek == 'D')
4002 verbose = 1;
eb383413 4003 }
97ceaf5b
DD		 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 {
b6fb00c0
DD		 4011 const char *s;
4012 int len;
41f225de 4013 struct demangle_component *dc;
b6fb00c0 4014
97ceaf5b 4015 if (p->set_last_name != NULL)
b6fb00c0
DD		 4016 di->last_name = d_make_sub (di, p->set_last_name,
4017 p->set_last_name_len);
97ceaf5b 4018 if (verbose)
b6fb00c0
DD		 4019 {
4020 s = p->full_expansion;
4021 len = p->full_len;
4022 }
97ceaf5b 4023 else
b6fb00c0
DD		 4024 {
4025 s = p->simple_expansion;
4026 len = p->simple_len;
4027 }
4028 di->expansion += len;
41f225de 4029 dc = d_make_sub (di, s, len);
b55f9678
IB		 4030 if (d_peek_char (di) == 'B')
4031 {
4032 /* If there are ABI tags on the abbreviation, it becomes
4033 a substitution candidate. */
41f225de 4034 dc = d_abi_tags (di, dc);
2d3392bd
IB		 4035 if (! d_add_substitution (di, dc))
4036 return NULL;
b55f9678 4037 }
41f225de 4038 return dc;
97ceaf5b
DD		 4039 }
4040 }
4041
4042 return NULL;
eb383413 4043 }
eb383413
L		 4044}
4045
492e19d0 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;
492e19d0 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;
492e19d0 4061 di->expansion = checkpoint->expansion;
4062}
4063
208c1674 4064/* Initialize a growable string. */
eb383413 4065
d00edca5 4066static void
208c1674 4067d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
d00edca5 4068{
208c1674
DD		 4069 dgs->buf = NULL;
4070 dgs->len = 0;
4071 dgs->alc = 0;
4072 dgs->allocation_failure = 0;
eb383413 4073
208c1674
DD		 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)
331c3da2 4087 return;
59666b35 4088
208c1674
DD		 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)
4098 {
4099 free (dgs->buf);
4100 dgs->buf = NULL;
4101 dgs->len = 0;
4102 dgs->alc = 0;
4103 dgs->allocation_failure = 1;
4104 return;
eb383413 4105 }
208c1674
DD		 4106 dgs->buf = newbuf;
4107 dgs->alc = newalc;
d00edca5 4108}
0976f6a7 4109
208c1674 4110/* Append a buffer to a growable string. */
0976f6a7 4111
208c1674
DD		 4112static inline void
4113d_growable_string_append_buffer (struct d_growable_string *dgs,
4114 const char *s, size_t l)
d00edca5 4115{
208c1674 4116 size_t need;
0976f6a7 4117
208c1674
DD		 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;
eb383413
L		 4128}
4129
208c1674 4130/* Bridge growable strings to the callback mechanism. */
d00edca5
DD		 4131
4132static void
208c1674 4133d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
eb383413 4134{
208c1674 4135 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
eb383413 4136
208c1674 4137 d_growable_string_append_buffer (dgs, s, l);
eb383413
L		 4138}
4139
fd259167
GB		 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
c1202057 4148d_count_templates_scopes (struct d_print_info *dpi,
533da483 4149 struct demangle_component *dc)
fd259167 4150{
533da483 4151 if (dc == NULL || dc->d_counting > 1 || dpi->recursion > MAX_RECURSION_COUNT)
fd259167
GB		 4152 return;
4153
533da483
NC		 4154 ++ dc->d_counting;
4155
fd259167
GB		 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:
c1202057 4170 dpi->num_copy_templates++;
fd259167
GB		 4171 goto recurse_left_right;
4172
4173 case DEMANGLE_COMPONENT_REFERENCE:
4174 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4175 if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
c1202057 4176 dpi->num_saved_scopes++;
fd259167
GB		 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:
e9a38816 4205 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
a4ddf8dc
JM		 4206 case DEMANGLE_COMPONENT_NOEXCEPT:
4207 case DEMANGLE_COMPONENT_THROW_SPEC:
fd259167
GB		 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:
fd259167
GB		 4216 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4217 case DEMANGLE_COMPONENT_ARGLIST:
4218 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
af03af8f 4219 case DEMANGLE_COMPONENT_TPARM_OBJ:
fd259167
GB		 4220 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4221 case DEMANGLE_COMPONENT_CAST:
c4be2641 4222 case DEMANGLE_COMPONENT_CONVERSION:
fd259167
GB		 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:
c1202057
NC		 4241 /* PR 89394 - Check for too much recursion. */
4242 if (dpi->recursion > DEMANGLE_RECURSION_LIMIT)
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));
4249 d_count_templates_scopes (dpi, d_right (dc));
4250 -- dpi->recursion;
fd259167
GB		 4251 break;
4252
4253 case DEMANGLE_COMPONENT_CTOR:
c1202057 4254 d_count_templates_scopes (dpi, dc->u.s_ctor.name);
fd259167
GB		 4255 break;
4256
4257 case DEMANGLE_COMPONENT_DTOR:
c1202057 4258 d_count_templates_scopes (dpi, dc->u.s_dtor.name);
fd259167
GB		 4259 break;
4260
4261 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
c1202057 4262 d_count_templates_scopes (dpi, dc->u.s_extended_operator.name);
fd259167
GB		 4263 break;
4264
b55f9678 4265 case DEMANGLE_COMPONENT_FIXED_TYPE:
c1202057 4266 d_count_templates_scopes (dpi, dc->u.s_fixed.length);
b55f9678
IB		 4267 break;
4268
fd259167
GB		 4269 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4270 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
c1202057 4271 d_count_templates_scopes (dpi, d_left (dc));
fd259167
GB		 4272 break;
4273
4274 case DEMANGLE_COMPONENT_LAMBDA:
4275 case DEMANGLE_COMPONENT_DEFAULT_ARG:
c1202057 4276 d_count_templates_scopes (dpi, dc->u.s_unary_num.sub);
fd259167
GB		 4277 break;
4278 }
4279}
4280
208c1674 4281/* Initialize a print information structure. */
eb383413 4282
d00edca5 4283static void
ddee5e46 4284d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
533da483 4285 void *opaque, struct demangle_component *dc)
208c1674 4286{
208c1674
DD		 4287 dpi->len = 0;
4288 dpi->last_char = '\0';
4289 dpi->templates = NULL;
4290 dpi->modifiers = NULL;
04aed652 4291 dpi->pack_index = 0;
3baae9d6 4292 dpi->flush_count = 0;
208c1674
DD		 4293
4294 dpi->callback = callback;
4295 dpi->opaque = opaque;
4296
4297 dpi->demangle_failure = 0;
2d3392bd 4298 dpi->recursion = 0;
88acc2e1 4299 dpi->is_lambda_arg = 0;
9548bbed 4300
91662bad 4301 dpi->component_stack = NULL;
4302
9548bbed 4303 dpi->saved_scopes = NULL;
fd259167 4304 dpi->next_saved_scope = 0;
9548bbed 4305 dpi->num_saved_scopes = 0;
9548bbed 4306
fd259167
GB		 4307 dpi->copy_templates = NULL;
4308 dpi->next_copy_template = 0;
4309 dpi->num_copy_templates = 0;
9548bbed 4310
c1202057
NC		 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_LIMIT)
4316 dpi->recursion = 0;
fd259167 4317 dpi->num_copy_templates *= dpi->num_saved_scopes;
9548bbed 4318
fd259167 4319 dpi->current_template = NULL;
208c1674
DD		 4320}
4321
4322/* Indicate that an error occurred during printing, and test for error. */
4323
4324static inline void
9334f9c6 4325d_print_error (struct d_print_info *dpi)
bc9bf259 4326{
208c1674
DD		 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;
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;
3baae9d6 4344 dpi->flush_count++;
208c1674
DD		 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
664aa91f 4374static inline void
fa3fcee7 4375d_append_num (struct d_print_info *dpi, int l)
664aa91f
DD		 4376{
4377 char buf[25];
fa3fcee7 4378 sprintf (buf,"%d", l);
664aa91f
DD		 4379 d_append_string (dpi, buf);
4380}
4381
208c1674
DD		 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,
c793cac1 4400 struct demangle_component *dc,
208c1674
DD		 4401 demangle_callbackref callback, void *opaque)
4402{
4403 struct d_print_info dpi;
4404
fd259167 4405 d_print_init (&dpi, callback, opaque, dc);
208c1674 4406
fd259167
GB		 4407 {
4408#ifdef CP_DYNAMIC_ARRAYS
fa3fcee7
NC		 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];
fd259167
GB		 4415
4416 dpi.saved_scopes = scopes;
4417 dpi.copy_templates = temps;
4418#else
4419 dpi.saved_scopes = alloca (dpi.num_saved_scopes
4420 * sizeof (*dpi.saved_scopes));
4421 dpi.copy_templates = alloca (dpi.num_copy_templates
4422 * sizeof (*dpi.copy_templates));
4423#endif
4424
4425 d_print_comp (&dpi, options, dc);
4426 }
208c1674
DD		 4427
4428 d_print_flush (&dpi);
4429
fd259167 4430 return ! d_print_saw_error (&dpi);
d00edca5 4431}
bc9bf259 4432
b6fb00c0
DD		 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. */
eb383413 4440
59727473
DD		 4441CP_STATIC_IF_GLIBCPP_V3
4442char *
c793cac1 4443cplus_demangle_print (int options, struct demangle_component *dc,
9334f9c6 4444 int estimate, size_t *palc)
d00edca5 4445{
208c1674 4446 struct d_growable_string dgs;
eb383413 4447
208c1674 4448 d_growable_string_init (&dgs, estimate);
eb383413 4449
208c1674
DD		 4450 if (! cplus_demangle_print_callback (options, dc,
4451 d_growable_string_callback_adapter,
4452 &dgs))
eb383413 4453 {
208c1674
DD		 4454 free (dgs.buf);
4455 *palc = 0;
d00edca5 4456 return NULL;
eb383413 4457 }
eb383413 4458
208c1674
DD		 4459 *palc = dgs.allocation_failure ? 1 : dgs.alc;
4460 return dgs.buf;
eb383413
L		 4461}
4462
1c08f2c8 4463/* Returns the I'th element of the template arglist ARGS, or NULL on
fa3fcee7 4464 failure. If I is negative, return the entire arglist. */
1c08f2c8
DD		 4465
4466static struct demangle_component *
4467d_index_template_argument (struct demangle_component *args, int i)
4468{
4469 struct demangle_component *a;
4470
fa3fcee7
NC		 4471 if (i < 0)
4472 /* Print the whole argument pack. */
4473 return args;
4474
1c08f2c8
DD		 4475 for (a = args;
4476 a != NULL;
4477 a = d_right (a))
4478 {
4479 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4480 return NULL;
4481 if (i <= 0)
4482 break;
4483 --i;
4484 }
4485 if (i != 0 || a == NULL)
4486 return NULL;
4487
4488 return d_left (a);
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)
4499 {
4500 d_print_error (dpi);
4501 return NULL;
4502 }
4503
4504 return d_index_template_argument
4505 (d_right (dpi->templates->template_decl),
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)
4517 return NULL;
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;
4526
4527 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4528 return NULL;
4529
57cf60a5 4530 case DEMANGLE_COMPONENT_LAMBDA:
1c08f2c8 4531 case DEMANGLE_COMPONENT_NAME:
1f3de044 4532 case DEMANGLE_COMPONENT_TAGGED_NAME:
1c08f2c8
DD		 4533 case DEMANGLE_COMPONENT_OPERATOR:
4534 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4535 case DEMANGLE_COMPONENT_SUB_STD:
4536 case DEMANGLE_COMPONENT_CHARACTER:
e2e1864d 4537 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
67bf71fe 4538 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
d81bf7dd
MM		 4539 case DEMANGLE_COMPONENT_FIXED_TYPE:
4540 case DEMANGLE_COMPONENT_DEFAULT_ARG:
4541 case DEMANGLE_COMPONENT_NUMBER:
1c08f2c8
DD		 4542 return NULL;
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));
4553 if (a)
4554 return a;
4555 return d_find_pack (dpi, d_right (dc));
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) != NULL)
4567 {
4568 ++count;
4569 dc = d_right (dc);
4570 }
4571 return count;
4572}
4573
fa3fcee7
NC		 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))
4583 {
4584 struct demangle_component *elt = d_left (dc);
4585 if (elt == NULL)
4586 break;
4587 if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
4588 {
4589 struct demangle_component *a = d_find_pack (dpi, d_left (elt));
4590 count += d_pack_length (a);
4591 }
4592 else
4593 ++count;
4594 }
4595 return count;
4596}
4597
1c08f2c8
DD		 4598/* DC is a component of a mangled expression. Print it, wrapped in parens
4599 if needed. */
4600
4601static void
ddee5e46 4602d_print_subexpr (struct d_print_info *dpi, int options,
c793cac1 4603 struct demangle_component *dc)
1c08f2c8
DD		 4604{
4605 int simple = 0;
e2e1864d 4606 if (dc->type == DEMANGLE_COMPONENT_NAME
eb7b5ddb
DD		 4607 || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4608 || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
e2e1864d 4609 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
1c08f2c8
DD		 4610 simple = 1;
4611 if (!simple)
4612 d_append_char (dpi, '(');
ddee5e46 4613 d_print_comp (dpi, options, dc);
1c08f2c8
DD		 4614 if (!simple)
4615 d_append_char (dpi, ')');
4616}
4617
fd259167 4618/* Save the current scope. */
9548bbed 4619
fd259167
GB		 4620static void
4621d_save_scope (struct d_print_info *dpi,
4622 const struct demangle_component *container)
9548bbed 4623{
fd259167
GB		 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;
9548bbed 4637
4638 for (src = dpi->templates; src != NULL; src = src->next)
4639 {
fd259167 4640 struct d_print_template *dst;
9548bbed 4641
fd259167 4642 if (dpi->next_copy_template >= dpi->num_copy_templates)
9548bbed 4643 {
4644 d_print_error (dpi);
fd259167 4645 return;
9548bbed 4646 }
fd259167
GB		 4647 dst = &dpi->copy_templates[dpi->next_copy_template];
4648 dpi->next_copy_template++;
9548bbed 4649
4650 dst->template_decl = src->template_decl;
4651 *link = dst;
4652 link = &dst->next;
4653 }
4654
4655 *link = NULL;
fd259167
GB		 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];
9548bbed 4670
fd259167 4671 return NULL;
9548bbed 4672}
4673
fa3fcee7
NC		 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,
c793cac1 4679 struct demangle_component *dc)
fa3fcee7 4680{
c793cac1 4681 struct demangle_component *ops, *operator_, *op1, *op2;
fa3fcee7
NC		 4682 int save_idx;
4683
4684 const char *fold_code = d_left (dc)->u.s_operator.op->code;
4685 if (fold_code[0] != 'f')
4686 return 0;
4687
4688 ops = d_right (dc);
4689 operator_ = d_left (ops);
4690 op1 = d_right (ops);
4691 op2 = 0;
4692 if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
4693 {
4694 op2 = d_right (op1);
4695 op1 = d_left (op1);
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
7ade7fba
AM		 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);
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)->u.s_operator.op->code;
4764
4765 struct demangle_component *operands = d_right (dc);
4766 struct demangle_component *op1 = d_left (operands);
4767 struct demangle_component *op2 = d_right (operands);
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));
4779 op2 = d_right (op2);
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
d00edca5 4796/* Subroutine to handle components. */
eb383413 4797
d00edca5 4798static void
91662bad 4799d_print_comp_inner (struct d_print_info *dpi, int options,
c793cac1 4800 struct demangle_component *dc)
eb383413 4801{
b24539b3
DD		 4802 /* Magic variable to let reference smashing skip over the next modifier
4803 without needing to modify *dc. */
c793cac1 4804 struct demangle_component *mod_inner = NULL;
b24539b3 4805
9548bbed 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
d00edca5 4813 if (dc == NULL)
eb383413 4814 {
d00edca5
DD		 4815 d_print_error (dpi);
4816 return;
eb383413 4817 }
d00edca5
DD		 4818 if (d_print_saw_error (dpi))
4819 return;
eb383413 4820
d00edca5 4821 switch (dc->type)
eb383413 4822 {
59727473 4823 case DEMANGLE_COMPONENT_NAME:
ddee5e46 4824 if ((options & DMGL_JAVA) == 0)
b6fb00c0
DD		 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);
d00edca5 4828 return;
eb383413 4829
1f3de044
DD		 4830 case DEMANGLE_COMPONENT_TAGGED_NAME:
4831 d_print_comp (dpi, options, d_left (dc));
4832 d_append_string (dpi, "[abi:");
4833 d_print_comp (dpi, options, d_right (dc));
4834 d_append_char (dpi, ']');
4835 return;
4836
59727473
DD		 4837 case DEMANGLE_COMPONENT_QUAL_NAME:
4838 case DEMANGLE_COMPONENT_LOCAL_NAME:
ddee5e46
DD		 4839 d_print_comp (dpi, options, d_left (dc));
4840 if ((options & DMGL_JAVA) == 0)
208c1674 4841 d_append_string (dpi, "::");
b6fb00c0
DD		 4842 else
4843 d_append_char (dpi, '.');
a9c3ecea
DD		 4844 {
4845 struct demangle_component *local_name = d_right (dc);
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 }
d00edca5 4855 return;
eb383413 4856
59727473 4857 case DEMANGLE_COMPONENT_TYPED_NAME:
d00edca5 4858 {
858b45cf 4859 struct d_print_mod *hold_modifiers;
59727473 4860 struct demangle_component *typed_name;
858b45cf
DD		 4861 struct d_print_mod adpm[4];
4862 unsigned int i;
d00edca5
DD		 4863 struct d_print_template dpt;
4864
4865 /* Pass the name down to the type so that it can be printed in
858b45cf
DD		 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;
c743cf5d 4869 dpi->modifiers = 0;
858b45cf 4870 i = 0;
d00edca5 4871 typed_name = d_left (dc);
858b45cf
DD		 4872 while (typed_name != NULL)
4873 {
4874 if (i >= sizeof adpm / sizeof adpm[0])
4875 {
4876 d_print_error (dpi);
4877 return;
4878 }
d00edca5 4879
858b45cf
DD		 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
a4ddf8dc 4887 if (!is_fnqual_component_type (typed_name->type))
858b45cf
DD		 4888 break;
4889
4890 typed_name = d_left (typed_name);
4891 }
d00edca5 4892
168b8298
MS		 4893 if (typed_name == NULL)
4894 {
4895 d_print_error (dpi);
4896 return;
4897 }
4898
59727473
DD		 4899 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4900 there may be CV-qualifiers on its right argument which
2a8ae714 4901 really apply here; this happens when parsing a class that
59727473
DD		 4902 is local to a function. */
4903 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
d4edd112 4904 {
2a8ae714
NC		 4905 typed_name = d_right (typed_name);
4906 if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4907 typed_name = typed_name->u.s_unary_num.sub;
f211b8c0
NC		 4908 while (typed_name != NULL
4909 && is_fnqual_component_type (typed_name->type))
d4edd112
DD		 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
2a8ae714 4921 adpm[i - 1].mod = typed_name;
d4edd112
DD		 4922 adpm[i - 1].printed = 0;
4923 adpm[i - 1].templates = dpi->templates;
4924 ++i;
4925
2a8ae714 4926 typed_name = d_left (typed_name);
d4edd112 4927 }
f211b8c0
NC		 4928 if (typed_name == NULL)
4929 {
4930 d_print_error (dpi);
4931 return;
4932 }
d4edd112
DD		 4933 }
4934
2a8ae714
NC		 4935 /* If typed_name is a template, then it applies to the
4936 function type as well. */
4937 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4938 {
4939 dpt.next = dpi->templates;
4940 dpi->templates = &dpt;
4941 dpt.template_decl = typed_name;
4942 }
4943
ddee5e46 4944 d_print_comp (dpi, options, d_right (dc));
74bcd529 4945
59727473 4946 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
d00edca5 4947 dpi->templates = dpt.next;
eb383413 4948
858b45cf 4949 /* If the modifiers didn't get printed by the type, print them
d00edca5 4950 now. */
858b45cf 4951 while (i > 0)
d00edca5 4952 {
858b45cf
DD		 4953 --i;
4954 if (! adpm[i].printed)
4955 {
4956 d_append_char (dpi, ' ');
ddee5e46 4957 d_print_mod (dpi, options, adpm[i].mod);
858b45cf 4958 }
d00edca5 4959 }
eb383413 4960
858b45cf 4961 dpi->modifiers = hold_modifiers;
eb383413 4962
d00edca5
DD		 4963 return;
4964 }
eb383413 4965
59727473 4966 case DEMANGLE_COMPONENT_TEMPLATE:
331c3da2
DD		 4967 {
4968 struct d_print_mod *hold_dpm;
208c1674 4969 struct demangle_component *dcl;
492e19d0 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;
331c3da2
DD		 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;
4983
208c1674
DD		 4984 dcl = d_left (dc);
4985
ddee5e46 4986 if ((options & DMGL_JAVA) != 0
208c1674
DD		 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
ddee5e46 4994 d_print_comp (dpi, options, d_right (dc));
208c1674
DD		 4995 d_append_string (dpi, "[]");
4996 }
4997 else
4998 {
ddee5e46 4999 d_print_comp (dpi, options, dcl);
208c1674
DD		 5000 if (d_last_char (dpi) == '<')
5001 d_append_char (dpi, ' ');
5002 d_append_char (dpi, '<');
ddee5e46 5003 d_print_comp (dpi, options, d_right (dc));
208c1674
DD		 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 }
331c3da2
DD		 5010
5011 dpi->modifiers = hold_dpm;
492e19d0 5012 dpi->current_template = hold_current;
331c3da2
DD		 5013
5014 return;
5015 }
d00edca5 5016
59727473 5017 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
88acc2e1
NS		 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);
1c08f2c8 5030
88acc2e1
NS		 5031 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5032 a = d_index_template_argument (a, dpi->pack_index);
59666b35 5033
88acc2e1
NS		 5034 if (a == NULL)
5035 {
5036 d_print_error (dpi);
5037 return;
5038 }
59666b35 5039
88acc2e1
NS		 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. */
eb383413 5044
88acc2e1
NS		 5045 hold_dpt = dpi->templates;
5046 dpi->templates = hold_dpt->next;
03d5f569 5047
88acc2e1 5048 d_print_comp (dpi, options, a);
59666b35 5049
88acc2e1
NS		 5050 dpi->templates = hold_dpt;
5051 }
5052 return;
eb383413 5053
af03af8f
NC		 5054 case DEMANGLE_COMPONENT_TPARM_OBJ:
5055 d_append_string (dpi, "template parameter object for ");
5056 d_print_comp (dpi, options, d_left (dc));
5057 return;
5058
59727473 5059 case DEMANGLE_COMPONENT_CTOR:
ddee5e46 5060 d_print_comp (dpi, options, dc->u.s_ctor.name);
d00edca5
DD		 5061 return;
5062
59727473 5063 case DEMANGLE_COMPONENT_DTOR:
d00edca5 5064 d_append_char (dpi, '~');
ddee5e46 5065 d_print_comp (dpi, options, dc->u.s_dtor.name);
d00edca5
DD		 5066 return;
5067
59727473 5068 case DEMANGLE_COMPONENT_VTABLE:
208c1674 5069 d_append_string (dpi, "vtable for ");
ddee5e46 5070 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5071 return;
5072
59727473 5073 case DEMANGLE_COMPONENT_VTT:
208c1674 5074 d_append_string (dpi, "VTT for ");
ddee5e46 5075 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5076 return;
5077
59727473 5078 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
208c1674 5079 d_append_string (dpi, "construction vtable for ");
ddee5e46 5080 d_print_comp (dpi, options, d_left (dc));
208c1674 5081 d_append_string (dpi, "-in-");
ddee5e46 5082 d_print_comp (dpi, options, d_right (dc));
d00edca5
DD		 5083 return;
5084
59727473 5085 case DEMANGLE_COMPONENT_TYPEINFO:
208c1674 5086 d_append_string (dpi, "typeinfo for ");
ddee5e46 5087 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5088 return;
5089
59727473 5090 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
208c1674 5091 d_append_string (dpi, "typeinfo name for ");
ddee5e46 5092 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5093 return;
5094
59727473 5095 case DEMANGLE_COMPONENT_TYPEINFO_FN:
208c1674 5096 d_append_string (dpi, "typeinfo fn for ");
ddee5e46 5097 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5098 return;
5099
59727473 5100 case DEMANGLE_COMPONENT_THUNK:
208c1674 5101 d_append_string (dpi, "non-virtual thunk to ");
ddee5e46 5102 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5103 return;
5104
59727473 5105 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
208c1674 5106 d_append_string (dpi, "virtual thunk to ");
ddee5e46 5107 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5108 return;
5109
59727473 5110 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
208c1674 5111 d_append_string (dpi, "covariant return thunk to ");
ddee5e46 5112 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5113 return;
5114
59727473 5115 case DEMANGLE_COMPONENT_JAVA_CLASS:
208c1674 5116 d_append_string (dpi, "java Class for ");
ddee5e46 5117 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5118 return;
5119
59727473 5120 case DEMANGLE_COMPONENT_GUARD:
208c1674 5121 d_append_string (dpi, "guard variable for ");
ddee5e46 5122 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5123 return;
5124
995b61fe
DD		 5125 case DEMANGLE_COMPONENT_TLS_INIT:
5126 d_append_string (dpi, "TLS init function for ");
5127 d_print_comp (dpi, options, d_left (dc));
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));
5133 return;
5134
59727473 5135 case DEMANGLE_COMPONENT_REFTEMP:
abc6552b
DD		 5136 d_append_string (dpi, "reference temporary #");
5137 d_print_comp (dpi, options, d_right (dc));
5138 d_append_string (dpi, " for ");
ddee5e46 5139 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5140 return;
5141
839e4798 5142 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
208c1674 5143 d_append_string (dpi, "hidden alias for ");
ddee5e46 5144 d_print_comp (dpi, options, d_left (dc));
839e4798
RH		 5145 return;
5146
956a8f8b
DD		 5147 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
5148 d_append_string (dpi, "transaction clone for ");
5149 d_print_comp (dpi, options, d_left (dc));
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));
5155 return;
5156
59727473 5157 case DEMANGLE_COMPONENT_SUB_STD:
b6fb00c0 5158 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
d00edca5
DD		 5159 return;
5160
59727473
DD		 5161 case DEMANGLE_COMPONENT_RESTRICT:
5162 case DEMANGLE_COMPONENT_VOLATILE:
5163 case DEMANGLE_COMPONENT_CONST:
74aee4eb
DD		 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; 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 {
ddee5e46 5181 d_print_comp (dpi, options, d_left (dc));
74aee4eb
DD		 5182 return;
5183 }
5184 }
5185 }
5186 }
b24539b3
DD		 5187 goto modifier;
5188
5189 case DEMANGLE_COMPONENT_REFERENCE:
5190 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5191 {
5192 /* Handle reference smashing: & + && = &. */
c793cac1 5193 struct demangle_component *sub = d_left (dc);
88acc2e1
NS		 5194 if (!dpi->is_lambda_arg
5195 && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
b24539b3 5196 {
fd259167 5197 struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
9548bbed 5198 struct demangle_component *a;
9548bbed 5199
5200 if (scope == NULL)
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. */
fd259167 5206 d_save_scope (dpi, sub);
9548bbed 5207 if (d_print_saw_error (dpi))
5208 return;
5209 }
5210 else
5211 {
91662bad 5212 const struct d_component_stack *dcse;
5213 int found_self_or_parent = 0;
5214
9548bbed 5215 /* This traversal is reentering SUB as a substition.
91662bad 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;
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 }
9548bbed 5236 }
5237
5238 a = d_lookup_template_argument (dpi, sub);
b24539b3
DD		 5239 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5240 a = d_index_template_argument (a, dpi->pack_index);
04aed652
DD		 5241
5242 if (a == NULL)
5243 {
9548bbed 5244 if (need_template_restore)
5245 dpi->templates = saved_templates;
5246
04aed652
DD		 5247 d_print_error (dpi);
5248 return;
5249 }
5250
b24539b3
DD		 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);
5259 }
74aee4eb 5260 /* Fall through. */
b24539b3 5261
59727473
DD		 5262 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5263 case DEMANGLE_COMPONENT_POINTER:
59727473
DD		 5264 case DEMANGLE_COMPONENT_COMPLEX:
5265 case DEMANGLE_COMPONENT_IMAGINARY:
a4ddf8dc 5266 FNQUAL_COMPONENT_CASE:
b24539b3 5267 modifier:
d00edca5
DD		 5268 {
5269 /* We keep a list of modifiers on the stack. */
5270 struct d_print_mod dpm;
eb383413 5271
d00edca5
DD		 5272 dpm.next = dpi->modifiers;
5273 dpi->modifiers = &dpm;
5274 dpm.mod = dc;
5275 dpm.printed = 0;
331c3da2 5276 dpm.templates = dpi->templates;
eb383413 5277
b24539b3
DD		 5278 if (!mod_inner)
5279 mod_inner = d_left (dc);
5280
5281 d_print_comp (dpi, options, mod_inner);
59666b35 5282
d00edca5
DD		 5283 /* If the modifier didn't get printed by the type, print it
5284 now. */
5285 if (! dpm.printed)
ddee5e46 5286 d_print_mod (dpi, options, dc);
eb383413 5287
d00edca5 5288 dpi->modifiers = dpm.next;
eb383413 5289
9548bbed 5290 if (need_template_restore)
5291 dpi->templates = saved_templates;
5292
d00edca5
DD		 5293 return;
5294 }
eb383413 5295
59727473 5296 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
ddee5e46 5297 if ((options & DMGL_JAVA) == 0)
b6fb00c0
DD		 5298 d_append_buffer (dpi, dc->u.s_builtin.type->name,
5299 dc->u.s_builtin.type->len);
d00edca5 5300 else
b6fb00c0
DD		 5301 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
5302 dc->u.s_builtin.type->java_len);
d00edca5 5303 return;
eb383413 5304
59727473 5305 case DEMANGLE_COMPONENT_VENDOR_TYPE:
ddee5e46 5306 d_print_comp (dpi, options, d_left (dc));
d00edca5 5307 return;
eb383413 5308
59727473 5309 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
d00edca5 5310 {
ddee5e46
DD		 5311 if ((options & DMGL_RET_POSTFIX) != 0)
5312 d_print_function_type (dpi,
5313 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5314 dc, dpi->modifiers);
7887b2ce
DD		 5315
5316 /* Print return type if present */
ddee5e46
DD		 5317 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
5318 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5319 d_left (dc));
5320 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
d00edca5
DD		 5321 {
5322 struct d_print_mod dpm;
eb383413 5323
d00edca5
DD		 5324 /* We must pass this type down as a modifier in order to
5325 print it in the right location. */
d00edca5
DD		 5326 dpm.next = dpi->modifiers;
5327 dpi->modifiers = &dpm;
5328 dpm.mod = dc;
5329 dpm.printed = 0;
331c3da2 5330 dpm.templates = dpi->templates;
eb383413 5331
ddee5e46
DD		 5332 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5333 d_left (dc));
eb383413 5334
d00edca5 5335 dpi->modifiers = dpm.next;
eb383413 5336
d00edca5
DD		 5337 if (dpm.printed)
5338 return;
eb383413 5339
7887b2ce
DD		 5340 /* In standard prefix notation, there is a space between the
5341 return type and the function signature. */
ddee5e46 5342 if ((options & DMGL_RET_POSTFIX) == 0)
7887b2ce 5343 d_append_char (dpi, ' ');
d00edca5 5344 }
eb383413 5345
ddee5e46
DD		 5346 if ((options & DMGL_RET_POSTFIX) == 0)
5347 d_print_function_type (dpi,
5348 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5349 dc, dpi->modifiers);
03d5f569 5350
d00edca5
DD		 5351 return;
5352 }
eb383413 5353
59727473 5354 case DEMANGLE_COMPONENT_ARRAY_TYPE:
d00edca5 5355 {
74aee4eb
DD		 5356 struct d_print_mod *hold_modifiers;
5357 struct d_print_mod adpm[4];
5358 unsigned int i;
5359 struct d_print_mod *pdpm;
eb383413 5360
d00edca5 5361 /* We must pass this type down as a modifier in order to print
74aee4eb
DD		 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. */
03d5f569 5368
74aee4eb
DD		 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
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 }
eb383413 5401
ddee5e46 5402 d_print_comp (dpi, options, d_right (dc));
eb383413 5403
74aee4eb 5404 dpi->modifiers = hold_modifiers;
eb383413 5405
74aee4eb 5406 if (adpm[0].printed)
d00edca5 5407 return;
eb383413 5408
74aee4eb
DD		 5409 while (i > 1)
5410 {
5411 --i;
ddee5e46 5412 d_print_mod (dpi, options, adpm[i].mod);
74aee4eb
DD		 5413 }
5414
ddee5e46 5415 d_print_array_type (dpi, options, dc, dpi->modifiers);
eb383413 5416
d00edca5
DD		 5417 return;
5418 }
eb383413 5419
59727473 5420 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
cbc43128 5421 case DEMANGLE_COMPONENT_VECTOR_TYPE:
d00edca5 5422 {
d00edca5
DD		 5423 struct d_print_mod dpm;
5424
d00edca5
DD		 5425 dpm.next = dpi->modifiers;
5426 dpi->modifiers = &dpm;
5427 dpm.mod = dc;
5428 dpm.printed = 0;
331c3da2 5429 dpm.templates = dpi->templates;
d00edca5 5430
ddee5e46 5431 d_print_comp (dpi, options, d_right (dc));
d00edca5
DD		 5432
5433 /* If the modifier didn't get printed by the type, print it
5434 now. */
5435 if (! dpm.printed)
ddee5e46 5436 d_print_mod (dpi, options, dc);
eb383413 5437
d00edca5 5438 dpi->modifiers = dpm.next;
eb383413 5439
d00edca5
DD		 5440 return;
5441 }
eb383413 5442
d2825c1a
DD		 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 {
ddee5e46 5450 d_print_comp (dpi, options, dc->u.s_fixed.length);
d2825c1a
DD		 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
59727473
DD		 5459 case DEMANGLE_COMPONENT_ARGLIST:
5460 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
1c08f2c8 5461 if (d_left (dc) != NULL)
ddee5e46 5462 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5463 if (d_right (dc) != NULL)
5464 {
4e59450e 5465 size_t len;
3baae9d6
JJ		 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);
208c1674 5471 d_append_string (dpi, ", ");
4e59450e 5472 len = dpi->len;
3baae9d6 5473 flush_count = dpi->flush_count;
ddee5e46 5474 d_print_comp (dpi, options, d_right (dc));
4e59450e
DD		 5475 /* If that didn't print anything (which can happen with empty
5476 template argument packs), remove the comma and space. */
3baae9d6 5477 if (dpi->flush_count == flush_count && dpi->len == len)
4e59450e 5478 dpi->len -= 2;
d00edca5
DD		 5479 }
5480 return;
eb383413 5481
eb7b5ddb
DD		 5482 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
5483 {
5484 struct demangle_component *type = d_left (dc);
5485 struct demangle_component *list = d_right (dc);
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
59727473 5495 case DEMANGLE_COMPONENT_OPERATOR:
d00edca5 5496 {
fbfd63c0
DD		 5497 const struct demangle_operator_info *op = dc->u.s_operator.op;
5498 int len = op->len;
d00edca5 5499
208c1674 5500 d_append_string (dpi, "operator");
fbfd63c0
DD		 5501 /* Add a space before new/delete. */
5502 if (IS_LOWER (op->name[0]))
d00edca5 5503 d_append_char (dpi, ' ');
fbfd63c0
DD		 5504 /* Omit a trailing space. */
5505 if (op->name[len-1] == ' ')
5506 --len;
5507 d_append_buffer (dpi, op->name, len);
d00edca5
DD		 5508 return;
5509 }
eb383413 5510
59727473 5511 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d750c713
NC		 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 }
eb383413 5524
c4be2641 5525 case DEMANGLE_COMPONENT_CONVERSION:
208c1674 5526 d_append_string (dpi, "operator ");
c4be2641 5527 d_print_conversion (dpi, options, dc);
d00edca5 5528 return;
eb383413 5529
eb7b5ddb
DD		 5530 case DEMANGLE_COMPONENT_NULLARY:
5531 d_print_expr_op (dpi, options, d_left (dc));
5532 return;
5533
59727473 5534 case DEMANGLE_COMPONENT_UNARY:
eb7b5ddb
DD		 5535 {
5536 struct demangle_component *op = d_left (dc);
5537 struct demangle_component *operand = d_right (dc);
5538 const char *code = NULL;
02e7efbf 5539
eb7b5ddb
DD		 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)->type == DEMANGLE_COMPONENT_QUAL_NAME
5549 && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5550 operand = d_left (operand);
5551 }
5552 if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5553 {
5554 /* This indicates a suffix operator. */
5555 operand = d_left (operand);
5556 d_print_subexpr (dpi, options, operand);
5557 d_print_expr_op (dpi, options, op);
5558 return;
5559 }
5560 }
02e7efbf 5561
fa3fcee7
NC		 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
eb7b5ddb
DD		 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);
d750c713
NC		 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__. */
eb7b5ddb
DD		 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 }
d00edca5
DD		 5604 return;
5605
59727473
DD		 5606 case DEMANGLE_COMPONENT_BINARY:
5607 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
eb383413 5608 {
d00edca5
DD		 5609 d_print_error (dpi);
5610 return;
eb383413 5611 }
858b45cf 5612
7c328963
DD		 5613 if (op_is_new_cast (d_left (dc)))
5614 {
5615 d_print_expr_op (dpi, options, d_left (dc));
5616 d_append_char (dpi, '<');
5617 d_print_comp (dpi, options, d_left (d_right (dc)));
5618 d_append_string (dpi, ">(");
5619 d_print_comp (dpi, options, d_right (d_right (dc)));
5620 d_append_char (dpi, ')');
5621 return;
5622 }
5623
fa3fcee7
NC		 5624 if (d_maybe_print_fold_expression (dpi, options, dc))
5625 return;
5626
7ade7fba
AM		 5627 if (d_maybe_print_designated_init (dpi, options, dc))
5628 return;
5629
858b45cf
DD		 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. */
59727473 5633 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
b6fb00c0
DD		 5634 && d_left (dc)->u.s_operator.op->len == 1
5635 && d_left (dc)->u.s_operator.op->name[0] == '>')
858b45cf
DD		 5636 d_append_char (dpi, '(');
5637
02e7efbf
JK		 5638 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5639 && d_left (d_right (dc))->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));
5646
5647 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5648 d_print_error (dpi);
5649 d_print_subexpr (dpi, options, d_left (func));
5650 }
5651 else
5652 d_print_subexpr (dpi, options, d_left (d_right (dc)));
9ac9c2b6
DD		 5653 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5654 {
5655 d_append_char (dpi, '[');
ddee5e46 5656 d_print_comp (dpi, options, d_right (d_right (dc)));
9ac9c2b6
DD		 5657 d_append_char (dpi, ']');
5658 }
5659 else
5660 {
5661 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
ddee5e46
DD		 5662 d_print_expr_op (dpi, options, d_left (dc));
5663 d_print_subexpr (dpi, options, d_right (d_right (dc)));
9ac9c2b6 5664 }
858b45cf 5665
59727473 5666 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
b6fb00c0
DD		 5667 && d_left (dc)->u.s_operator.op->len == 1
5668 && d_left (dc)->u.s_operator.op->name[0] == '>')
858b45cf
DD		 5669 d_append_char (dpi, ')');
5670
d00edca5
DD		 5671 return;
5672
59727473
DD		 5673 case DEMANGLE_COMPONENT_BINARY_ARGS:
5674 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
d00edca5
DD		 5675 d_print_error (dpi);
5676 return;
5677
59727473
DD		 5678 case DEMANGLE_COMPONENT_TRINARY:
5679 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5680 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
d00edca5
DD		 5681 {
5682 d_print_error (dpi);
5683 return;
5684 }
fa3fcee7
NC		 5685 if (d_maybe_print_fold_expression (dpi, options, dc))
5686 return;
7ade7fba
AM		 5687 if (d_maybe_print_designated_init (dpi, options, dc))
5688 return;
eb7b5ddb
DD		 5689 {
5690 struct demangle_component *op = d_left (dc);
5691 struct demangle_component *first = d_left (d_right (dc));
5692 struct demangle_component *second = d_left (d_right (d_right (dc)));
5693 struct demangle_component *third = d_right (d_right (d_right (dc)));
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) != NULL)
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 }
d00edca5
DD		 5716 return;
5717
59727473
DD		 5718 case DEMANGLE_COMPONENT_TRINARY_ARG1:
5719 case DEMANGLE_COMPONENT_TRINARY_ARG2:
5720 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
d00edca5
DD		 5721 d_print_error (dpi);
5722 return;
5723
59727473
DD		 5724 case DEMANGLE_COMPONENT_LITERAL:
5725 case DEMANGLE_COMPONENT_LITERAL_NEG:
2d733211
DD		 5726 {
5727 enum d_builtin_type_print tp;
d00edca5 5728
2d733211
DD		 5729 /* For some builtin types, produce simpler output. */
5730 tp = D_PRINT_DEFAULT;
5731 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5732 {
5733 tp = d_left (dc)->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)->type == DEMANGLE_COMPONENT_NAME)
5743 {
5744 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5745 d_append_char (dpi, '-');
ddee5e46 5746 d_print_comp (dpi, options, d_right (dc));
2d733211
DD		 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:
208c1674 5758 d_append_string (dpi, "ul");
2d733211
DD		 5759 break;
5760 case D_PRINT_LONG_LONG:
208c1674 5761 d_append_string (dpi, "ll");
2d733211
DD		 5762 break;
5763 case D_PRINT_UNSIGNED_LONG_LONG:
208c1674 5764 d_append_string (dpi, "ull");
2d733211
DD		 5765 break;
5766 }
5767 return;
5768 }
5769 break;
eb383413 5770
2d733211
DD		 5771 case D_PRINT_BOOL:
5772 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5773 && d_right (dc)->u.s_name.len == 1
5774 && dc->type == DEMANGLE_COMPONENT_LITERAL)
5775 {
5776 switch (d_right (dc)->u.s_name.s[0])
5777 {
5778 case '0':
208c1674 5779 d_append_string (dpi, "false");
2d733211
DD		 5780 return;
5781 case '1':
208c1674 5782 d_append_string (dpi, "true");
2d733211
DD		 5783 return;
5784 default:
5785 break;
5786 }
5787 }
5788 break;
03d5f569 5789
2d733211
DD		 5790 default:
5791 break;
5792 }
5793 }
eb383413 5794
2d733211 5795 d_append_char (dpi, '(');
ddee5e46 5796 d_print_comp (dpi, options, d_left (dc));
2d733211
DD		 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, '[');
ddee5e46 5802 d_print_comp (dpi, options, d_right (dc));
2d733211
DD		 5803 if (tp == D_PRINT_FLOAT)
5804 d_append_char (dpi, ']');
5805 }
d00edca5 5806 return;
eb383413 5807
cbc43128
DD		 5808 case DEMANGLE_COMPONENT_NUMBER:
5809 d_append_num (dpi, dc->u.s_number.number);
5810 return;
5811
830ef634
DD		 5812 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5813 d_append_string (dpi, "java resource ");
ddee5e46 5814 d_print_comp (dpi, options, d_left (dc));
830ef634
DD		 5815 return;
5816
5817 case DEMANGLE_COMPONENT_COMPOUND_NAME:
ddee5e46
DD		 5818 d_print_comp (dpi, options, d_left (dc));
5819 d_print_comp (dpi, options, d_right (dc));
830ef634
DD		 5820 return;
5821
5822 case DEMANGLE_COMPONENT_CHARACTER:
5823 d_append_char (dpi, dc->u.s_character.character);
5824 return;
5825
ba8cb4ba
DD		 5826 case DEMANGLE_COMPONENT_DECLTYPE:
5827 d_append_string (dpi, "decltype (");
ddee5e46 5828 d_print_comp (dpi, options, d_left (dc));
ba8cb4ba
DD		 5829 d_append_char (dpi, ')');
5830 return;
5831
1c08f2c8
DD		 5832 case DEMANGLE_COMPONENT_PACK_EXPANSION:
5833 {
e2e1864d 5834 int len;
1c08f2c8 5835 int i;
e2e1864d
DD		 5836 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5837 if (a == NULL)
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 "...". */
ddee5e46 5842 d_print_subexpr (dpi, options, d_left (dc));
e2e1864d
DD		 5843 d_append_string (dpi, "...");
5844 return;
5845 }
1c08f2c8 5846
e2e1864d 5847 len = d_pack_length (a);
1c08f2c8
DD		 5848 dc = d_left (dc);
5849 for (i = 0; i < len; ++i)
5850 {
5851 dpi->pack_index = i;
ddee5e46 5852 d_print_comp (dpi, options, dc);
1c08f2c8
DD		 5853 if (i < len-1)
5854 d_append_string (dpi, ", ");
5855 }
5856 }
5857 return;
5858
c743cf5d 5859 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
f2917a30
DD		 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 }
664aa91f 5871 return;
c743cf5d 5872
d5031754
DD		 5873 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5874 d_append_string (dpi, "global constructors keyed to ");
ddee5e46 5875 d_print_comp (dpi, options, dc->u.s_binary.left);
d5031754
DD		 5876 return;
5877
5878 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5879 d_append_string (dpi, "global destructors keyed to ");
ddee5e46 5880 d_print_comp (dpi, options, dc->u.s_binary.left);
d5031754
DD		 5881 return;
5882
664aa91f
DD		 5883 case DEMANGLE_COMPONENT_LAMBDA:
5884 d_append_string (dpi, "{lambda(");
88acc2e1
NS		 5885 /* Generic lambda auto parms are mangled as the template type
5886 parm they are. */
5887 dpi->is_lambda_arg++;
ddee5e46 5888 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
88acc2e1 5889 dpi->is_lambda_arg--;
664aa91f
DD		 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
7955ede5
DD		 5901 case DEMANGLE_COMPONENT_CLONE:
5902 d_print_comp (dpi, options, d_left (dc));
5903 d_append_string (dpi, " [clone ");
5904 d_print_comp (dpi, options, d_right (dc));
5905 d_append_char (dpi, ']');
5906 return;
5907
d00edca5
DD		 5908 default:
5909 d_print_error (dpi);
5910 return;
5911 }
eb383413
L		 5912}
5913
91662bad 5914static void
5915d_print_comp (struct d_print_info *dpi, int options,
c793cac1 5916 struct demangle_component *dc)
91662bad 5917{
5918 struct d_component_stack self;
2d3392bd 5919 if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
c793cac1
NC		 5920 {
5921 d_print_error (dpi);
5922 return;
5923 }
2d3392bd
IB		 5924
5925 dc->d_printing++;
5926 dpi->recursion++;
91662bad 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;
c793cac1 5935 dc->d_printing--;
2d3392bd 5936 dpi->recursion--;
91662bad 5937}
5938
b6fb00c0
DD		 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>+_. */
eb383413 5943
d00edca5 5944static void
9334f9c6 5945d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
eb383413 5946{
b6fb00c0
DD		 5947 const char *p;
5948 const char *end;
eb383413 5949
b6fb00c0
DD		 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')
eb383413 5957 {
b6fb00c0
DD		 5958 unsigned long c;
5959 const char *q;
5960
5961 c = 0;
5962 for (q = p + 3; q < end; ++q)
d00edca5 5963 {
b6fb00c0
DD		 5964 int dig;
5965
5966 if (IS_DIGIT (*q))
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;
eb383413 5974
b6fb00c0
DD		 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;
d00edca5 5984 }
d00edca5 5985 }
b6fb00c0
DD		 5986
5987 d_append_char (dpi, *p);
eb383413 5988 }
eb383413
L		 5989}
5990
858b45cf
DD		 5991/* Print a list of modifiers. SUFFIX is 1 if we are printing
5992 qualifiers on this after printing a function. */
eb383413 5993
d00edca5 5994static void
ddee5e46 5995d_print_mod_list (struct d_print_info *dpi, int options,
9334f9c6 5996 struct d_print_mod *mods, int suffix)
eb383413 5997{
331c3da2
DD		 5998 struct d_print_template *hold_dpt;
5999
858b45cf 6000 if (mods == NULL || d_print_saw_error (dpi))
d00edca5 6001 return;
eb383413 6002
858b45cf
DD		 6003 if (mods->printed
6004 || (! suffix
a4ddf8dc 6005 && (is_fnqual_component_type (mods->mod->type))))
858b45cf 6006 {
ddee5e46 6007 d_print_mod_list (dpi, options, mods->next, suffix);
858b45cf
DD		 6008 return;
6009 }
6010
331c3da2
DD		 6011 mods->printed = 1;
6012
6013 hold_dpt = dpi->templates;
6014 dpi->templates = mods->templates;
6015
59727473 6016 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
eb383413 6017 {
ddee5e46 6018 d_print_function_type (dpi, options, mods->mod, mods->next);
331c3da2 6019 dpi->templates = hold_dpt;
d00edca5
DD		 6020 return;
6021 }
59727473 6022 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
d00edca5 6023 {
ddee5e46 6024 d_print_array_type (dpi, options, mods->mod, mods->next);
331c3da2 6025 dpi->templates = hold_dpt;
d00edca5
DD		 6026 return;
6027 }
59727473 6028 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
d4edd112
DD		 6029 {
6030 struct d_print_mod *hold_modifiers;
59727473 6031 struct demangle_component *dc;
d4edd112
DD		 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;
ddee5e46 6040 d_print_comp (dpi, options, d_left (mods->mod));
d4edd112
DD		 6041 dpi->modifiers = hold_modifiers;
6042
ddee5e46 6043 if ((options & DMGL_JAVA) == 0)
208c1674 6044 d_append_string (dpi, "::");
b6fb00c0
DD		 6045 else
6046 d_append_char (dpi, '.');
d4edd112
DD		 6047
6048 dc = d_right (mods->mod);
664aa91f
DD		 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
a4ddf8dc 6058 while (is_fnqual_component_type (dc->type))
d4edd112
DD		 6059 dc = d_left (dc);
6060
ddee5e46 6061 d_print_comp (dpi, options, dc);
d4edd112
DD		 6062
6063 dpi->templates = hold_dpt;
6064 return;
6065 }
eb383413 6066
ddee5e46 6067 d_print_mod (dpi, options, mods->mod);
eb383413 6068
331c3da2
DD		 6069 dpi->templates = hold_dpt;
6070
ddee5e46 6071 d_print_mod_list (dpi, options, mods->next, suffix);
eb383413 6072}
331c3da2 6073
d00edca5 6074/* Print a modifier. */
eb383413 6075
d00edca5 6076static void
ddee5e46 6077d_print_mod (struct d_print_info *dpi, int options,
c793cac1 6078 struct demangle_component *mod)
d00edca5
DD		 6079{
6080 switch (mod->type)
6081 {
59727473
DD		 6082 case DEMANGLE_COMPONENT_RESTRICT:
6083 case DEMANGLE_COMPONENT_RESTRICT_THIS:
208c1674 6084 d_append_string (dpi, " restrict");
d00edca5 6085 return;
59727473
DD		 6086 case DEMANGLE_COMPONENT_VOLATILE:
6087 case DEMANGLE_COMPONENT_VOLATILE_THIS:
208c1674 6088 d_append_string (dpi, " volatile");
d00edca5 6089 return;
59727473
DD		 6090 case DEMANGLE_COMPONENT_CONST:
6091 case DEMANGLE_COMPONENT_CONST_THIS:
208c1674 6092 d_append_string (dpi, " const");
d00edca5 6093 return;
e9a38816
JM		 6094 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
6095 d_append_string (dpi, " transaction_safe");
6096 return;
a4ddf8dc
JM		 6097 case DEMANGLE_COMPONENT_NOEXCEPT:
6098 d_append_string (dpi, " noexcept");
6099 if (d_right (mod))
6100 {
6101 d_append_char (dpi, '(');
6102 d_print_comp (dpi, options, d_right (mod));
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))
6109 {
6110 d_append_char (dpi, '(');
6111 d_print_comp (dpi, options, d_right (mod));
6112 d_append_char (dpi, ')');
6113 }
6114 return;
59727473 6115 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
d00edca5 6116 d_append_char (dpi, ' ');
ddee5e46 6117 d_print_comp (dpi, options, d_right (mod));
d00edca5 6118 return;
59727473 6119 case DEMANGLE_COMPONENT_POINTER:
d00edca5 6120 /* There is no pointer symbol in Java. */
ddee5e46 6121 if ((options & DMGL_JAVA) == 0)
d00edca5
DD		 6122 d_append_char (dpi, '*');
6123 return;
3a4d2339
DD		 6124 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6125 /* For the ref-qualifier, put a space before the &. */
6126 d_append_char (dpi, ' ');
41f225de 6127 /* FALLTHRU */
59727473 6128 case DEMANGLE_COMPONENT_REFERENCE:
d00edca5
DD		 6129 d_append_char (dpi, '&');
6130 return;
3a4d2339
DD		 6131 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6132 d_append_char (dpi, ' ');
41f225de 6133 /* FALLTHRU */
8969a67f
DD		 6134 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
6135 d_append_string (dpi, "&&");
6136 return;
59727473 6137 case DEMANGLE_COMPONENT_COMPLEX:
533da483 6138 d_append_string (dpi, " _Complex");
d00edca5 6139 return;
59727473 6140 case DEMANGLE_COMPONENT_IMAGINARY:
533da483 6141 d_append_string (dpi, " _Imaginary");
d00edca5 6142 return;
59727473 6143 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
858b45cf 6144 if (d_last_char (dpi) != '(')
d00edca5 6145 d_append_char (dpi, ' ');
ddee5e46 6146 d_print_comp (dpi, options, d_left (mod));
208c1674 6147 d_append_string (dpi, "::*");
d00edca5 6148 return;
59727473 6149 case DEMANGLE_COMPONENT_TYPED_NAME:
ddee5e46 6150 d_print_comp (dpi, options, d_left (mod));
d00edca5 6151 return;
cbc43128 6152 case DEMANGLE_COMPONENT_VECTOR_TYPE:
f9b58c5b 6153 d_append_string (dpi, " __vector(");
ddee5e46 6154 d_print_comp (dpi, options, d_left (mod));
f9b58c5b 6155 d_append_char (dpi, ')');
cbc43128
DD		 6156 return;
6157
d00edca5
DD		 6158 default:
6159 /* Otherwise, we have something that won't go back on the
6160 modifier stack, so we can just print it. */
ddee5e46 6161 d_print_comp (dpi, options, mod);
d00edca5
DD		 6162 return;
6163 }
6164}
eb383413 6165
d00edca5 6166/* Print a function type, except for the return type. */
eb383413 6167
d00edca5 6168static void
ddee5e46 6169d_print_function_type (struct d_print_info *dpi, int options,
c793cac1 6170 struct demangle_component *dc,
9334f9c6 6171 struct d_print_mod *mods)
eb383413 6172{
331c3da2 6173 int need_paren;
2d733211 6174 int need_space;
331c3da2 6175 struct d_print_mod *p;
d4edd112 6176 struct d_print_mod *hold_modifiers;
331c3da2
DD		 6177
6178 need_paren = 0;
2d733211 6179 need_space = 0;
331c3da2 6180 for (p = mods; p != NULL; p = p->next)
d00edca5 6181 {
331c3da2
DD		 6182 if (p->printed)
6183 break;
eb383413 6184
331c3da2 6185 switch (p->mod->type)
d00edca5 6186 {
2d733211
DD		 6187 case DEMANGLE_COMPONENT_POINTER:
6188 case DEMANGLE_COMPONENT_REFERENCE:
8969a67f 6189 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
2d733211
DD		 6190 need_paren = 1;
6191 break;
59727473
DD		 6192 case DEMANGLE_COMPONENT_RESTRICT:
6193 case DEMANGLE_COMPONENT_VOLATILE:
6194 case DEMANGLE_COMPONENT_CONST:
6195 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
59727473
DD		 6196 case DEMANGLE_COMPONENT_COMPLEX:
6197 case DEMANGLE_COMPONENT_IMAGINARY:
6198 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
2d733211 6199 need_space = 1;
331c3da2
DD		 6200 need_paren = 1;
6201 break;
a4ddf8dc 6202 FNQUAL_COMPONENT_CASE:
858b45cf 6203 break;
331c3da2
DD		 6204 default:
6205 break;
d00edca5 6206 }
331c3da2
DD		 6207 if (need_paren)
6208 break;
6209 }
eb383413 6210
331c3da2 6211 if (need_paren)
858b45cf 6212 {
2d733211 6213 if (! need_space)
858b45cf 6214 {
2d733211
DD		 6215 if (d_last_char (dpi) != '('
6216 && d_last_char (dpi) != '*')
6217 need_space = 1;
858b45cf 6218 }
2d733211
DD		 6219 if (need_space && d_last_char (dpi) != ' ')
6220 d_append_char (dpi, ' ');
858b45cf
DD		 6221 d_append_char (dpi, '(');
6222 }
eb383413 6223
d4edd112
DD		 6224 hold_modifiers = dpi->modifiers;
6225 dpi->modifiers = NULL;
6226
ddee5e46 6227 d_print_mod_list (dpi, options, mods, 0);
eb383413 6228
331c3da2
DD		 6229 if (need_paren)
6230 d_append_char (dpi, ')');
eb383413 6231
d00edca5 6232 d_append_char (dpi, '(');
eb383413 6233
d00edca5 6234 if (d_right (dc) != NULL)
ddee5e46 6235 d_print_comp (dpi, options, d_right (dc));
eb383413 6236
d00edca5 6237 d_append_char (dpi, ')');
858b45cf 6238
ddee5e46 6239 d_print_mod_list (dpi, options, mods, 1);
d4edd112
DD		 6240
6241 dpi->modifiers = hold_modifiers;
d00edca5 6242}
eb383413 6243
d00edca5 6244/* Print an array type, except for the element type. */
eb383413 6245
d00edca5 6246static void
ddee5e46 6247d_print_array_type (struct d_print_info *dpi, int options,
c793cac1 6248 struct demangle_component *dc,
9334f9c6 6249 struct d_print_mod *mods)
d00edca5
DD		 6250{
6251 int need_space;
eb383413 6252
d00edca5
DD		 6253 need_space = 1;
6254 if (mods != NULL)
eb383413 6255 {
d00edca5
DD		 6256 int need_paren;
6257 struct d_print_mod *p;
03d5f569 6258
d00edca5
DD		 6259 need_paren = 0;
6260 for (p = mods; p != NULL; p = p->next)
eb383413 6261 {
74aee4eb 6262 if (! p->printed)
eb383413 6263 {
74aee4eb
DD		 6264 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6265 {
6266 need_space = 0;
6267 break;
6268 }
6269 else
6270 {
6271 need_paren = 1;
6272 need_space = 1;
6273 break;
6274 }
eb383413 6275 }
d00edca5 6276 }
eb383413 6277
d00edca5 6278 if (need_paren)
208c1674 6279 d_append_string (dpi, " (");
eb383413 6280
ddee5e46 6281 d_print_mod_list (dpi, options, mods, 0);
eb383413 6282
d00edca5
DD		 6283 if (need_paren)
6284 d_append_char (dpi, ')');
6285 }
eb383413 6286
d00edca5
DD		 6287 if (need_space)
6288 d_append_char (dpi, ' ');
03d5f569 6289
d00edca5 6290 d_append_char (dpi, '[');
03d5f569 6291
d00edca5 6292 if (d_left (dc) != NULL)
ddee5e46 6293 d_print_comp (dpi, options, d_left (dc));
eb383413 6294
d00edca5
DD		 6295 d_append_char (dpi, ']');
6296}
eb383413 6297
d00edca5 6298/* Print an operator in an expression. */
eb383413 6299
d00edca5 6300static void
ddee5e46 6301d_print_expr_op (struct d_print_info *dpi, int options,
c793cac1 6302 struct demangle_component *dc)
d00edca5 6303{
59727473 6304 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
b6fb00c0
DD		 6305 d_append_buffer (dpi, dc->u.s_operator.op->name,
6306 dc->u.s_operator.op->len);
d00edca5 6307 else
ddee5e46 6308 d_print_comp (dpi, options, dc);
eb383413
L		 6309}
6310
d00edca5 6311/* Print a cast. */
eb383413 6312
d00edca5 6313static void
ddee5e46 6314d_print_cast (struct d_print_info *dpi, int options,
c793cac1 6315 struct demangle_component *dc)
c4be2641
PA		 6316{
6317 d_print_comp (dpi, options, d_left (dc));
6318}
6319
6320/* Print a conversion operator. */
6321
6322static void
6323d_print_conversion (struct d_print_info *dpi, int options,
c793cac1 6324 struct demangle_component *dc)
eb383413 6325{
492e19d0 6326 struct d_print_template dpt;
331c3da2 6327
c4be2641 6328 /* For a conversion operator, we need the template parameters from
492e19d0 6329 the enclosing template in scope for processing the type. */
6330 if (dpi->current_template != NULL)
6331 {
d00edca5
DD		 6332 dpt.next = dpi->templates;
6333 dpi->templates = &dpt;
492e19d0 6334 dpt.template_decl = dpi->current_template;
6335 }
0976f6a7 6336
492e19d0 6337 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
6338 {
6339 d_print_comp (dpi, options, d_left (dc));
6340 if (dpi->current_template != NULL)
6341 dpi->templates = dpt.next;
6342 }
6343 else
6344 {
ddee5e46 6345 d_print_comp (dpi, options, d_left (d_left (dc)));
0976f6a7 6346
492e19d0 6347 /* For a templated cast operator, we need to remove the template
6348 parameters from scope after printing the operator name,
6349 so we need to handle the template printing here. */
6350 if (dpi->current_template != NULL)
6351 dpi->templates = dpt.next;
eb383413 6352
858b45cf
DD		 6353 if (d_last_char (dpi) == '<')
6354 d_append_char (dpi, ' ');
d00edca5 6355 d_append_char (dpi, '<');
ddee5e46 6356 d_print_comp (dpi, options, d_right (d_left (dc)));
d00edca5
DD		 6357 /* Avoid generating two consecutive '>' characters, to avoid
6358 the C++ syntactic ambiguity. */
858b45cf 6359 if (d_last_char (dpi) == '>')
d00edca5
DD		 6360 d_append_char (dpi, ' ');
6361 d_append_char (dpi, '>');
eb383413 6362 }
d00edca5
DD		 6363}
6364
6365/* Initialize the information structure we use to pass around
6366 information. */
6367
59727473
DD		 6368CP_STATIC_IF_GLIBCPP_V3
6369void
9334f9c6
DD		 6370cplus_demangle_init_info (const char *mangled, int options, size_t len,
6371 struct d_info *di)
eb383413 6372{
d00edca5 6373 di->s = mangled;
b6fb00c0 6374 di->send = mangled + len;
d00edca5 6375 di->options = options;
eb383413 6376
d00edca5
DD		 6377 di->n = mangled;
6378
07ffcfec 6379 /* We cannot need more components than twice the number of chars in
d00edca5
DD		 6380 the mangled string. Most components correspond directly to
6381 chars, but the ARGLIST types are exceptions. */
6382 di->num_comps = 2 * len;
d00edca5
DD		 6383 di->next_comp = 0;
6384
07ffcfec 6385 /* Similarly, we cannot need more substitutions than there are
331c3da2
DD		 6386 chars in the mangled string. */
6387 di->num_subs = len;
d00edca5
DD		 6388 di->next_sub = 0;
6389
6390 di->last_name = NULL;
6391
b6fb00c0 6392 di->expansion = 0;
492e19d0 6393 di->is_expression = 0;
6394 di->is_conversion = 0;
af03af8f 6395 di->recursion_level = 0;
eb383413
L		 6396}
6397
208c1674
DD		 6398/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6399 mangled name, return strings in repeated callback giving the demangled
6400 name. OPTIONS is the usual libiberty demangler options. On success,
6401 this returns 1. On failure, returns 0. */
eb383413 6402
208c1674
DD		 6403static int
6404d_demangle_callback (const char *mangled, int options,
6405 demangle_callbackref callback, void *opaque)
eb383413 6406{
d5031754
DD		 6407 enum
6408 {
6409 DCT_TYPE,
6410 DCT_MANGLED,
6411 DCT_GLOBAL_CTORS,
6412 DCT_GLOBAL_DTORS
6413 }
6414 type;
d00edca5 6415 struct d_info di;
59727473 6416 struct demangle_component *dc;
208c1674 6417 int status;
d00edca5
DD		 6418
6419 if (mangled[0] == '_' && mangled[1] == 'Z')
d5031754 6420 type = DCT_MANGLED;
d00edca5
DD		 6421 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
6422 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
6423 && (mangled[9] == 'D' || mangled[9] == 'I')
6424 && mangled[10] == '_')
d5031754 6425 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
eb383413
L		 6426 else
6427 {
d00edca5 6428 if ((options & DMGL_TYPES) == 0)
208c1674 6429 return 0;
d5031754 6430 type = DCT_TYPE;
eb383413
L		 6431 }
6432
d750c713
NC		 6433 di.unresolved_name_state = 1;
6434
6435 again:
208c1674 6436 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
03d5f569 6437
af03af8f
NC		 6438 /* PR 87675 - Check for a mangled string that is so long
6439 that we do not have enough stack space to demangle it. */
6440 if (((options & DMGL_NO_RECURSE_LIMIT) == 0)
6441 /* This check is a bit arbitrary, since what we really want to do is to
6442 compare the sizes of the di.comps and di.subs arrays against the
6443 amount of stack space remaining. But there is no portable way to do
6444 this, so instead we use the recursion limit as a guide to the maximum
6445 size of the arrays. */
6446 && (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT)
6447 {
6448 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6449 return 0;
6450 }
6451
b6fb00c0
DD		 6452 {
6453#ifdef CP_DYNAMIC_ARRAYS
59727473
DD		 6454 __extension__ struct demangle_component comps[di.num_comps];
6455 __extension__ struct demangle_component *subs[di.num_subs];
b6fb00c0 6456
208c1674
DD		 6457 di.comps = comps;
6458 di.subs = subs;
b6fb00c0 6459#else
208c1674
DD		 6460 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6461 di.subs = alloca (di.num_subs * sizeof (*di.subs));
b6fb00c0
DD		 6462#endif
6463
d5031754
DD		 6464 switch (type)
6465 {
6466 case DCT_TYPE:
6467 dc = cplus_demangle_type (&di);
6468 break;
6469 case DCT_MANGLED:
6470 dc = cplus_demangle_mangled_name (&di, 1);
6471 break;
6472 case DCT_GLOBAL_CTORS:
6473 case DCT_GLOBAL_DTORS:
6474 d_advance (&di, 11);
6475 dc = d_make_comp (&di,
6476 (type == DCT_GLOBAL_CTORS
6477 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6478 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
a0692e36 6479 d_make_demangle_mangled_name (&di, d_str (&di)),
d5031754
DD		 6480 NULL);
6481 d_advance (&di, strlen (d_str (&di)));
6482 break;
8458514f 6483 default:
6484 abort (); /* We have listed all the cases. */
d5031754 6485 }
d00edca5 6486
b6fb00c0
DD		 6487 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6488 mangled string, then we didn't successfully demangle it. If
6489 DMGL_PARAMS is not set, we didn't look at the trailing
6490 parameters. */
6491 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
6492 dc = NULL;
24afc00d 6493
d750c713
NC		 6494 /* See discussion in d_unresolved_name. */
6495 if (dc == NULL && di.unresolved_name_state == -1)
6496 {
6497 di.unresolved_name_state = 0;
6498 goto again;
6499 }
6500
d00edca5 6501#ifdef CP_DEMANGLE_DEBUG
208c1674 6502 d_dump (dc, 0);
d00edca5
DD		 6503#endif
6504
208c1674
DD		 6505 status = (dc != NULL)
6506 ? cplus_demangle_print_callback (options, dc, callback, opaque)
6507 : 0;
6508 }
03d5f569 6509
208c1674
DD		 6510 return status;
6511}
03d5f569 6512
208c1674
DD		 6513/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6514 name, return a buffer allocated with malloc holding the demangled
6515 name. OPTIONS is the usual libiberty demangler options. On
6516 success, this sets *PALC to the allocated size of the returned
6517 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6518 a memory allocation failure, and returns NULL. */
b6fb00c0 6519
208c1674
DD		 6520static char *
6521d_demangle (const char *mangled, int options, size_t *palc)
6522{
6523 struct d_growable_string dgs;
6524 int status;
03d5f569 6525
208c1674
DD		 6526 d_growable_string_init (&dgs, 0);
6527
6528 status = d_demangle_callback (mangled, options,
6529 d_growable_string_callback_adapter, &dgs);
6530 if (status == 0)
6531 {
6532 free (dgs.buf);
6533 *palc = 0;
6534 return NULL;
6535 }
6536
ffe7cfdf 6537 *palc = dgs.allocation_failure ? 1 : dgs.alc;
208c1674 6538 return dgs.buf;
eb383413
L		 6539}
6540
0c4460bb 6541#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
d00edca5 6542
9334f9c6 6543extern char *__cxa_demangle (const char *, char *, size_t *, int *);
03d5f569 6544
d00edca5
DD		 6545/* ia64 ABI-mandated entry point in the C++ runtime library for
6546 performing demangling. MANGLED_NAME is a NUL-terminated character
6547 string containing the name to be demangled.
03d5f569
JM		 6548
6549 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6550 *LENGTH bytes, into which the demangled name is stored. If
6551 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6552 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
d00edca5 6553 is placed in a region of memory allocated with malloc.
03d5f569 6554
208c1674 6555 If LENGTH is non-NULL, the length of the buffer containing the
d00edca5 6556 demangled name, is placed in *LENGTH.
03d5f569
JM		 6557
6558 The return value is a pointer to the start of the NUL-terminated
6559 demangled name, or NULL if the demangling fails. The caller is
d00edca5 6560 responsible for deallocating this memory using free.
03d5f569
JM		 6561
6562 *STATUS is set to one of the following values:
6563 0: The demangling operation succeeded.
d00edca5 6564 -1: A memory allocation failure occurred.
03d5f569
JM		 6565 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6566 -3: One of the arguments is invalid.
6567
d00edca5 6568 The demangling is performed using the C++ ABI mangling rules, with
03d5f569
JM		 6569 GNU extensions. */
6570
6571char *
9334f9c6
DD		 6572__cxa_demangle (const char *mangled_name, char *output_buffer,
6573 size_t *length, int *status)
03d5f569 6574{
d00edca5
DD		 6575 char *demangled;
6576 size_t alc;
03d5f569 6577
d00edca5
DD		 6578 if (mangled_name == NULL)
6579 {
74aee4eb
DD		 6580 if (status != NULL)
6581 *status = -3;
03d5f569
JM		 6582 return NULL;
6583 }
03d5f569 6584
d00edca5 6585 if (output_buffer != NULL && length == NULL)
03d5f569 6586 {
74aee4eb
DD		 6587 if (status != NULL)
6588 *status = -3;
d00edca5 6589 return NULL;
03d5f569 6590 }
d00edca5 6591
74aee4eb 6592 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
d00edca5
DD		 6593
6594 if (demangled == NULL)
03d5f569 6595 {
74aee4eb
DD		 6596 if (status != NULL)
6597 {
6598 if (alc == 1)
6599 *status = -1;
6600 else
6601 *status = -2;
6602 }
03d5f569
JM		 6603 return NULL;
6604 }
d00edca5
DD		 6605
6606 if (output_buffer == NULL)
6607 {
6608 if (length != NULL)
6609 *length = alc;
6610 }
03d5f569 6611 else
03d5f569 6612 {
d00edca5
DD		 6613 if (strlen (demangled) < *length)
6614 {
6615 strcpy (output_buffer, demangled);
6616 free (demangled);
6617 demangled = output_buffer;
6618 }
6619 else
6620 {
6621 free (output_buffer);
6622 *length = alc;
6623 }
03d5f569 6624 }
d00edca5 6625
74aee4eb
DD		 6626 if (status != NULL)
6627 *status = 0;
d00edca5
DD		 6628
6629 return demangled;
03d5f569
JM		 6630}
6631
208c1674
DD		 6632extern int __gcclibcxx_demangle_callback (const char *,
6633 void (*)
6634 (const char *, size_t, void *),
6635 void *);
6636
6637/* Alternative, allocationless entry point in the C++ runtime library
6638 for performing demangling. MANGLED_NAME is a NUL-terminated character
6639 string containing the name to be demangled.
6640
6641 CALLBACK is a callback function, called with demangled string
6642 segments as demangling progresses; it is called at least once,
6643 but may be called more than once. OPAQUE is a generalized pointer
6644 used as a callback argument.
6645
6646 The return code is one of the following values, equivalent to
6647 the STATUS values of __cxa_demangle() (excluding -1, since this
6648 function performs no memory allocations):
6649 0: The demangling operation succeeded.
6650 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6651 -3: One of the arguments is invalid.
6652
6653 The demangling is performed using the C++ ABI mangling rules, with
6654 GNU extensions. */
6655
6656int
6657__gcclibcxx_demangle_callback (const char *mangled_name,
6658 void (*callback) (const char *, size_t, void *),
6659 void *opaque)
6660{
6661 int status;
6662
6663 if (mangled_name == NULL || callback == NULL)
6664 return -3;
6665
6666 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6667 callback, opaque);
6668 if (status == 0)
6669 return -2;
6670
6671 return 0;
6672}
6673
0c4460bb 6674#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
03d5f569 6675
d00edca5
DD		 6676/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6677 mangled name, return a buffer allocated with malloc holding the
6678 demangled name. Otherwise, return NULL. */
eb383413
L		 6679
6680char *
208c1674 6681cplus_demangle_v3 (const char *mangled, int options)
eb383413 6682{
d00edca5 6683 size_t alc;
849ee224 6684
d00edca5 6685 return d_demangle (mangled, options, &alc);
eb383413
L		 6686}
6687
208c1674
DD		 6688int
6689cplus_demangle_v3_callback (const char *mangled, int options,
6690 demangle_callbackref callback, void *opaque)
6691{
6692 return d_demangle_callback (mangled, options, callback, opaque);
6693}
6694
bc9bf259
DD		 6695/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6696 conventions, but the output formatting is a little different.
208c1674
DD		 6697 This instructs the C++ demangler not to emit pointer characters ("*"), to
6698 use Java's namespace separator symbol ("." instead of "::"), and to output
6699 JArray<TYPE> as TYPE[]. */
bc9bf259
DD		 6700
6701char *
208c1674 6702java_demangle_v3 (const char *mangled)
bc9bf259 6703{
d00edca5 6704 size_t alc;
bc9bf259 6705
208c1674
DD		 6706 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6707}
f2160d2b 6708
208c1674
DD		 6709int
6710java_demangle_v3_callback (const char *mangled,
6711 demangle_callbackref callback, void *opaque)
6712{
6713 return d_demangle_callback (mangled,
6714 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6715 callback, opaque);
bc9bf259
DD		 6716}
6717
0c4460bb 6718#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
03d5f569 6719
2a9dffbf 6720#ifndef IN_GLIBCPP_V3
d00edca5
DD		 6721
6722/* Demangle a string in order to find out whether it is a constructor
6723 or destructor. Return non-zero on success. Set *CTOR_KIND and
6724 *DTOR_KIND appropriately. */
6725
6726static int
9334f9c6
DD		 6727is_ctor_or_dtor (const char *mangled,
6728 enum gnu_v3_ctor_kinds *ctor_kind,
6729 enum gnu_v3_dtor_kinds *dtor_kind)
e61231f1 6730{
d00edca5 6731 struct d_info di;
59727473 6732 struct demangle_component *dc;
858b45cf 6733 int ret;
e61231f1 6734
d00edca5
DD		 6735 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6736 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6737
59727473 6738 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
e61231f1 6739
b6fb00c0
DD		 6740 {
6741#ifdef CP_DYNAMIC_ARRAYS
59727473
DD		 6742 __extension__ struct demangle_component comps[di.num_comps];
6743 __extension__ struct demangle_component *subs[di.num_subs];
b6fb00c0 6744
208c1674
DD		 6745 di.comps = comps;
6746 di.subs = subs;
b6fb00c0 6747#else
208c1674
DD		 6748 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6749 di.subs = alloca (di.num_subs * sizeof (*di.subs));
b6fb00c0 6750#endif
d00edca5 6751
59727473 6752 dc = cplus_demangle_mangled_name (&di, 1);
d35d0cd4 6753
b6fb00c0
DD		 6754 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6755 to demangle the entire string. */
e61231f1 6756
b6fb00c0
DD		 6757 ret = 0;
6758 while (dc != NULL)
6759 {
6760 switch (dc->type)
6761 {
3a4d2339
DD		 6762 /* These cannot appear on a constructor or destructor. */
6763 case DEMANGLE_COMPONENT_RESTRICT_THIS:
6764 case DEMANGLE_COMPONENT_VOLATILE_THIS:
6765 case DEMANGLE_COMPONENT_CONST_THIS:
6766 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6767 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
b6fb00c0
DD		 6768 default:
6769 dc = NULL;
6770 break;
59727473
DD		 6771 case DEMANGLE_COMPONENT_TYPED_NAME:
6772 case DEMANGLE_COMPONENT_TEMPLATE:
b6fb00c0
DD		 6773 dc = d_left (dc);
6774 break;
59727473
DD		 6775 case DEMANGLE_COMPONENT_QUAL_NAME:
6776 case DEMANGLE_COMPONENT_LOCAL_NAME:
b6fb00c0
DD		 6777 dc = d_right (dc);
6778 break;
59727473 6779 case DEMANGLE_COMPONENT_CTOR:
b6fb00c0
DD		 6780 *ctor_kind = dc->u.s_ctor.kind;
6781 ret = 1;
6782 dc = NULL;
6783 break;
59727473 6784 case DEMANGLE_COMPONENT_DTOR:
b6fb00c0
DD		 6785 *dtor_kind = dc->u.s_dtor.kind;
6786 ret = 1;
6787 dc = NULL;
6788 break;
6789 }
6790 }
b6fb00c0 6791 }
858b45cf
DD		 6792
6793 return ret;
e61231f1
JB		 6794}
6795
d00edca5
DD		 6796/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6797 name. A non-zero return indicates the type of constructor. */
e61231f1 6798
e61231f1 6799enum gnu_v3_ctor_kinds
9334f9c6 6800is_gnu_v3_mangled_ctor (const char *name)
e61231f1 6801{
d00edca5
DD		 6802 enum gnu_v3_ctor_kinds ctor_kind;
6803 enum gnu_v3_dtor_kinds dtor_kind;
e61231f1 6804
d00edca5 6805 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
585cc78f 6806 return (enum gnu_v3_ctor_kinds) 0;
d00edca5 6807 return ctor_kind;
e61231f1
JB		 6808}
6809
6810
d00edca5
DD		 6811/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6812 name. A non-zero return indicates the type of destructor. */
6813
e61231f1 6814enum gnu_v3_dtor_kinds
9334f9c6 6815is_gnu_v3_mangled_dtor (const char *name)
e61231f1 6816{
d00edca5
DD		 6817 enum gnu_v3_ctor_kinds ctor_kind;
6818 enum gnu_v3_dtor_kinds dtor_kind;
e61231f1 6819
d00edca5 6820 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
585cc78f 6821 return (enum gnu_v3_dtor_kinds) 0;
d00edca5 6822 return dtor_kind;
e61231f1
JB		 6823}
6824
d00edca5 6825#endif /* IN_GLIBCPP_V3 */
e61231f1 6826
eb383413
L		 6827#ifdef STANDALONE_DEMANGLER
6828
6829#include "getopt.h"
d00edca5
DD		 6830#include "dyn-string.h"
6831
e064c173 6832static void print_usage (FILE* fp, int exit_value);
eb383413 6833
d00edca5
DD		 6834#define IS_ALPHA(CHAR) \
6835 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6836 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
eb383413
L		 6837
6838/* Non-zero if CHAR is a character than can occur in a mangled name. */
6839#define is_mangled_char(CHAR) \
74bcd529
DD		 6840 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6841 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
eb383413
L		 6842
6843/* The name of this program, as invoked. */
6844const char* program_name;
6845
6846/* Prints usage summary to FP and then exits with EXIT_VALUE. */
6847
6848static void
9334f9c6 6849print_usage (FILE* fp, int exit_value)
eb383413
L		 6850{
6851 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
74bcd529 6852 fprintf (fp, "Options:\n");
eb383413 6853 fprintf (fp, " -h,--help Display this message.\n");
6d95373e 6854 fprintf (fp, " -p,--no-params Don't display function parameters\n");
eb383413
L		 6855 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
6856 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6857
6858 exit (exit_value);
6859}
6860
6861/* Option specification for getopt_long. */
c23795e2 6862static const struct option long_options[] =
eb383413 6863{
6d95373e
DD		 6864 { "help", no_argument, NULL, 'h' },
6865 { "no-params", no_argument, NULL, 'p' },
6866 { "verbose", no_argument, NULL, 'v' },
6867 { NULL, no_argument, NULL, 0 },
eb383413
L		 6868};
6869
6870/* Main entry for a demangling filter executable. It will demangle
6871 its command line arguments, if any. If none are provided, it will
6872 filter stdin to stdout, replacing any recognized mangled C++ names
6873 with their demangled equivalents. */
6874
6875int
9334f9c6 6876main (int argc, char *argv[])
eb383413 6877{
eb383413
L		 6878 int i;
6879 int opt_char;
d00edca5 6880 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
eb383413
L		 6881
6882 /* Use the program name of this program, as invoked. */
6883 program_name = argv[0];
6884
6885 /* Parse options. */
6886 do
6887 {
6d95373e 6888 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
eb383413
L		 6889 switch (opt_char)
6890 {
6891 case '?': /* Unrecognized option. */
6892 print_usage (stderr, 1);
6893 break;
6894
6895 case 'h':
6896 print_usage (stdout, 0);
6897 break;
6898
6d95373e
DD		 6899 case 'p':
6900 options &= ~ DMGL_PARAMS;
6901 break;
6902
eb383413 6903 case 'v':
d00edca5 6904 options |= DMGL_VERBOSE;
eb383413
L		 6905 break;
6906 }
6907 }
6908 while (opt_char != -1);
6909
6910 if (optind == argc)
6911 /* No command line arguments were provided. Filter stdin. */
6912 {
6913 dyn_string_t mangled = dyn_string_new (3);
d00edca5 6914 char *s;
eb383413
L		 6915
6916 /* Read all of input. */
6917 while (!feof (stdin))
6918 {
d00edca5 6919 char c;
eb383413
L		 6920
6921 /* Pile characters into mangled until we hit one that can't
6922 occur in a mangled name. */
6923 c = getchar ();
6924 while (!feof (stdin) && is_mangled_char (c))
6925 {
6926 dyn_string_append_char (mangled, c);
6927 if (feof (stdin))
6928 break;
6929 c = getchar ();
6930 }
6931
d00edca5 6932 if (dyn_string_length (mangled) > 0)
03d5f569 6933 {
74aee4eb
DD		 6934#ifdef IN_GLIBCPP_V3
6935 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6936#else
d00edca5 6937 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
74aee4eb 6938#endif
d00edca5
DD		 6939
6940 if (s != NULL)
6941 {
6942 fputs (s, stdout);
6943 free (s);
6944 }
6945 else
6946 {
6947 /* It might not have been a mangled name. Print the
6948 original text. */
6949 fputs (dyn_string_buf (mangled), stdout);
6950 }
6951
6952 dyn_string_clear (mangled);
03d5f569 6953 }
eb383413
L		 6954
6955 /* If we haven't hit EOF yet, we've read one character that
6956 can't occur in a mangled name, so print it out. */
6957 if (!feof (stdin))
6958 putchar (c);
eb383413
L		 6959 }
6960
6961 dyn_string_delete (mangled);
eb383413
L		 6962 }
6963 else
6964 /* Demangle command line arguments. */
6965 {
eb383413
L		 6966 /* Loop over command line arguments. */
6967 for (i = optind; i < argc; ++i)
6968 {
d00edca5 6969 char *s;
74aee4eb
DD		 6970#ifdef IN_GLIBCPP_V3
6971 int status;
6972#endif
d00edca5 6973
eb383413 6974 /* Attempt to demangle. */
74aee4eb
DD		 6975#ifdef IN_GLIBCPP_V3
6976 s = __cxa_demangle (argv[i], NULL, NULL, &status);
6977#else
d00edca5 6978 s = cplus_demangle_v3 (argv[i], options);
74aee4eb 6979#endif
eb383413
L		 6980
6981 /* If it worked, print the demangled name. */
d00edca5 6982 if (s != NULL)
03d5f569 6983 {
d00edca5
DD		 6984 printf ("%s\n", s);
6985 free (s);
03d5f569 6986 }
d00edca5 6987 else
74aee4eb
DD		 6988 {
6989#ifdef IN_GLIBCPP_V3
6990 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6991#else
6992 fprintf (stderr, "Failed: %s\n", argv[i]);
6993#endif
6994 }
eb383413 6995 }
eb383413
L		 6996 }
6997
6998 return 0;
6999}
7000
7001#endif /* STANDALONE_DEMANGLER */
GDB Binutils - Deliverables
This page took 1.372915 seconds and 4 git commands to generate.