]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - libiberty/cp-demangle.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sync libiberty and include with GCC for get_DW_UT_name.
[thirdparty/binutils-gdb.git] / libiberty / cp-demangle.c
CommitLineData
d00edca5 1/* Demangler for g++ V3 ABI.
533da483 2 Copyright (C) 2003-2020 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
9334f9c6 432static struct demangle_component *d_prefix (struct d_info *);
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
d00edca5
DD		 1513 *pret = d_prefix (di);
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>
1539*/
1540
59727473 1541static struct demangle_component *
9334f9c6 1542d_prefix (struct d_info *di)
eb383413 1543{
59727473 1544 struct demangle_component *ret = NULL;
eb383413 1545
d00edca5 1546 while (1)
eb383413 1547 {
d00edca5 1548 char peek;
59727473
DD		 1549 enum demangle_component_type comb_type;
1550 struct demangle_component *dc;
d00edca5
DD		 1551
1552 peek = d_peek_char (di);
1553 if (peek == '\0')
1554 return NULL;
1555
1556 /* The older code accepts a <local-name> here, but I don't see
1557 that in the grammar. The older code does not accept a
1558 <template-param> here. */
eb383413 1559
59727473 1560 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
6b6bd65a
DD		 1561 if (peek == 'D')
1562 {
1563 char peek2 = d_peek_next_char (di);
1564 if (peek2 == 'T' || peek2 == 't')
1565 /* Decltype. */
1566 dc = cplus_demangle_type (di);
1567 else
1568 /* Destructor name. */
1569 dc = d_unqualified_name (di);
1570 }
1571 else if (IS_DIGIT (peek)
858b45cf 1572 || IS_LOWER (peek)
d00edca5 1573 || peek == 'C'
664aa91f 1574 || peek == 'U'
8bf955e1 1575 || peek == 'L')
d00edca5
DD		 1576 dc = d_unqualified_name (di);
1577 else if (peek == 'S')
97ceaf5b 1578 dc = d_substitution (di, 1);
d00edca5
DD		 1579 else if (peek == 'I')
1580 {
1581 if (ret == NULL)
1582 return NULL;
59727473 1583 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
d00edca5
DD		 1584 dc = d_template_args (di);
1585 }
1586 else if (peek == 'T')
1587 dc = d_template_param (di);
1588 else if (peek == 'E')
1589 return ret;
664aa91f
DD		 1590 else if (peek == 'M')
1591 {
1592 /* Initializer scope for a lambda. We don't need to represent
1593 this; the normal code will just treat the variable as a type
1594 scope, which gives appropriate output. */
1595 if (ret == NULL)
1596 return NULL;
1597 d_advance (di, 1);
1598 continue;
1599 }
d00edca5
DD		 1600 else
1601 return NULL;
1602
1603 if (ret == NULL)
1604 ret = dc;
eb383413 1605 else
d00edca5
DD		 1606 ret = d_make_comp (di, comb_type, ret, dc);
1607
1608 if (peek != 'S' && d_peek_char (di) != 'E')
1609 {
1610 if (! d_add_substitution (di, ret))
1611 return NULL;
1612 }
eb383413
L		 1613 }
1614}
1615
d00edca5
DD		 1616/* <unqualified-name> ::= <operator-name>
1617 ::= <ctor-dtor-name>
1618 ::= <source-name>
8bf955e1
GK		 1619 ::= <local-source-name>
1620
1621 <local-source-name> ::= L <source-name> <discriminator>
d00edca5 1622*/
eb383413 1623
59727473 1624static struct demangle_component *
9334f9c6 1625d_unqualified_name (struct d_info *di)
eb383413 1626{
1f3de044 1627 struct demangle_component *ret;
d00edca5
DD		 1628 char peek;
1629
1630 peek = d_peek_char (di);
1631 if (IS_DIGIT (peek))
1f3de044 1632 ret = d_source_name (di);
858b45cf 1633 else if (IS_LOWER (peek))
b6fb00c0 1634 {
134e805d
NC		 1635 if (peek == 'o' && d_peek_next_char (di) == 'n')
1636 d_advance (di, 2);
b6fb00c0 1637 ret = d_operator_name (di);
59727473 1638 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
4e3aa408
DD		 1639 {
1640 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1641 if (!strcmp (ret->u.s_operator.op->code, "li"))
1642 ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
1643 d_source_name (di));
1644 }
b6fb00c0 1645 }
d00edca5 1646 else if (peek == 'C' || peek == 'D')
1f3de044 1647 ret = d_ctor_dtor_name (di);
8bf955e1
GK		 1648 else if (peek == 'L')
1649 {
8bf955e1
GK		 1650 d_advance (di, 1);
1651
1652 ret = d_source_name (di);
1653 if (ret == NULL)
1654 return NULL;
1655 if (! d_discriminator (di))
1656 return NULL;
8bf955e1 1657 }
664aa91f
DD		 1658 else if (peek == 'U')
1659 {
1660 switch (d_peek_next_char (di))
1661 {
1662 case 'l':
1f3de044
DD		 1663 ret = d_lambda (di);
1664 break;
664aa91f 1665 case 't':
1f3de044
DD		 1666 ret = d_unnamed_type (di);
1667 break;
664aa91f
DD		 1668 default:
1669 return NULL;
1670 }
1671 }
d00edca5 1672 else
03d5f569 1673 return NULL;
1f3de044
DD		 1674
1675 if (d_peek_char (di) == 'B')
1676 ret = d_abi_tags (di, ret);
1677 return ret;
eb383413
L		 1678}
1679
d00edca5 1680/* <source-name> ::= <(positive length) number> <identifier> */
eb383413 1681
59727473 1682static struct demangle_component *
9334f9c6 1683d_source_name (struct d_info *di)
eb383413 1684{
fa3fcee7 1685 int len;
59727473 1686 struct demangle_component *ret;
d00edca5
DD		 1687
1688 len = d_number (di);
1689 if (len <= 0)
1690 return NULL;
1691 ret = d_identifier (di, len);
1692 di->last_name = ret;
1693 return ret;
eb383413
L		 1694}
1695
d00edca5 1696/* number ::= [n] <(non-negative decimal integer)> */
eb383413 1697
fa3fcee7 1698static int
9334f9c6 1699d_number (struct d_info *di)
eb383413 1700{
b6fb00c0 1701 int negative;
d00edca5 1702 char peek;
fa3fcee7 1703 int ret;
eb383413 1704
b6fb00c0 1705 negative = 0;
d00edca5
DD		 1706 peek = d_peek_char (di);
1707 if (peek == 'n')
1708 {
b6fb00c0 1709 negative = 1;
d00edca5
DD		 1710 d_advance (di, 1);
1711 peek = d_peek_char (di);
1712 }
eb383413 1713
d00edca5
DD		 1714 ret = 0;
1715 while (1)
eb383413 1716 {
d00edca5 1717 if (! IS_DIGIT (peek))
b6fb00c0
DD		 1718 {
1719 if (negative)
1720 ret = - ret;
1721 return ret;
1722 }
2d3392bd
IB		 1723 if (ret > ((INT_MAX - (peek - '0')) / 10))
1724 return -1;
533da483 1725 ret = ret * 10 + (peek - '0');
d00edca5
DD		 1726 d_advance (di, 1);
1727 peek = d_peek_char (di);
eb383413 1728 }
eb383413
L		 1729}
1730
cbc43128
DD		 1731/* Like d_number, but returns a demangle_component. */
1732
1733static struct demangle_component *
1734d_number_component (struct d_info *di)
1735{
1736 struct demangle_component *ret = d_make_empty (di);
1737 if (ret)
1738 {
1739 ret->type = DEMANGLE_COMPONENT_NUMBER;
1740 ret->u.s_number.number = d_number (di);
1741 }
1742 return ret;
1743}
1744
d00edca5 1745/* identifier ::= <(unqualified source code identifier)> */
eb383413 1746
59727473 1747static struct demangle_component *
fa3fcee7 1748d_identifier (struct d_info *di, int len)
eb383413 1749{
d00edca5 1750 const char *name;
eb383413 1751
d00edca5 1752 name = d_str (di);
b6fb00c0
DD		 1753
1754 if (di->send - name < len)
1755 return NULL;
1756
d00edca5 1757 d_advance (di, len);
eb383413 1758
2730f651
DD		 1759 /* A Java mangled name may have a trailing '$' if it is a C++
1760 keyword. This '$' is not included in the length count. We just
1761 ignore the '$'. */
1762 if ((di->options & DMGL_JAVA) != 0
1763 && d_peek_char (di) == '$')
1764 d_advance (di, 1);
1765
d00edca5
DD		 1766 /* Look for something which looks like a gcc encoding of an
1767 anonymous namespace, and replace it with a more user friendly
1768 name. */
fa3fcee7 1769 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
d00edca5
DD		 1770 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1771 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
eb383413 1772 {
d00edca5
DD		 1773 const char *s;
1774
1775 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1776 if ((*s == '.' || *s == '_' || *s == '$')
1777 && s[1] == 'N')
b6fb00c0
DD		 1778 {
1779 di->expansion -= len - sizeof "(anonymous namespace)";
1780 return d_make_name (di, "(anonymous namespace)",
1781 sizeof "(anonymous namespace)" - 1);
1782 }
eb383413 1783 }
d00edca5
DD		 1784
1785 return d_make_name (di, name, len);
eb383413
L		 1786}
1787
d00edca5
DD		 1788/* operator_name ::= many different two character encodings.
1789 ::= cv <type>
1790 ::= v <digit> <source-name>
eb7b5ddb
DD		 1791
1792 This list is sorted for binary search. */
eb383413 1793
b6fb00c0
DD		 1794#define NL(s) s, (sizeof s) - 1
1795
59727473
DD		 1796CP_STATIC_IF_GLIBCPP_V3
1797const struct demangle_operator_info cplus_demangle_operators[] =
d00edca5 1798{
b6fb00c0
DD		 1799 { "aN", NL ("&="), 2 },
1800 { "aS", NL ("="), 2 },
1801 { "aa", NL ("&&"), 2 },
1802 { "ad", NL ("&"), 1 },
1803 { "an", NL ("&"), 2 },
eb7b5ddb 1804 { "at", NL ("alignof "), 1 },
99e47410 1805 { "aw", NL ("co_await "), 1 },
eb7b5ddb 1806 { "az", NL ("alignof "), 1 },
7c328963 1807 { "cc", NL ("const_cast"), 2 },
ba8cb4ba 1808 { "cl", NL ("()"), 2 },
b6fb00c0
DD		 1809 { "cm", NL (","), 2 },
1810 { "co", NL ("~"), 1 },
1811 { "dV", NL ("/="), 2 },
7ade7fba 1812 { "dX", NL ("[...]="), 3 }, /* [expr...expr] = expr */
eb7b5ddb 1813 { "da", NL ("delete[] "), 1 },
7c328963 1814 { "dc", NL ("dynamic_cast"), 2 },
b6fb00c0 1815 { "de", NL ("*"), 1 },
7ade7fba 1816 { "di", NL ("="), 2 }, /* .name = expr */
eb7b5ddb
DD		 1817 { "dl", NL ("delete "), 1 },
1818 { "ds", NL (".*"), 2 },
1c08f2c8 1819 { "dt", NL ("."), 2 },
b6fb00c0 1820 { "dv", NL ("/"), 2 },
7ade7fba 1821 { "dx", NL ("]="), 2 }, /* [expr] = expr */
b6fb00c0
DD		 1822 { "eO", NL ("^="), 2 },
1823 { "eo", NL ("^"), 2 },
1824 { "eq", NL ("=="), 2 },
fa3fcee7
NC		 1825 { "fL", NL ("..."), 3 },
1826 { "fR", NL ("..."), 3 },
1827 { "fl", NL ("..."), 2 },
1828 { "fr", NL ("..."), 2 },
b6fb00c0 1829 { "ge", NL (">="), 2 },
eb7b5ddb 1830 { "gs", NL ("::"), 1 },
b6fb00c0
DD		 1831 { "gt", NL (">"), 2 },
1832 { "ix", NL ("[]"), 2 },
1833 { "lS", NL ("<<="), 2 },
1834 { "le", NL ("<="), 2 },
4e3aa408 1835 { "li", NL ("operator\"\" "), 1 },
b6fb00c0
DD		 1836 { "ls", NL ("<<"), 2 },
1837 { "lt", NL ("<"), 2 },
1838 { "mI", NL ("-="), 2 },
1839 { "mL", NL ("*="), 2 },
1840 { "mi", NL ("-"), 2 },
1841 { "ml", NL ("*"), 2 },
1842 { "mm", NL ("--"), 1 },
eb7b5ddb 1843 { "na", NL ("new[]"), 3 },
b6fb00c0
DD		 1844 { "ne", NL ("!="), 2 },
1845 { "ng", NL ("-"), 1 },
1846 { "nt", NL ("!"), 1 },
eb7b5ddb 1847 { "nw", NL ("new"), 3 },
b6fb00c0
DD		 1848 { "oR", NL ("|="), 2 },
1849 { "oo", NL ("||"), 2 },
1850 { "or", NL ("|"), 2 },
1851 { "pL", NL ("+="), 2 },
1852 { "pl", NL ("+"), 2 },
1853 { "pm", NL ("->*"), 2 },
1854 { "pp", NL ("++"), 1 },
1855 { "ps", NL ("+"), 1 },
1856 { "pt", NL ("->"), 2 },
1857 { "qu", NL ("?"), 3 },
1858 { "rM", NL ("%="), 2 },
1859 { "rS", NL (">>="), 2 },
7c328963 1860 { "rc", NL ("reinterpret_cast"), 2 },
b6fb00c0
DD		 1861 { "rm", NL ("%"), 2 },
1862 { "rs", NL (">>"), 2 },
fa3fcee7
NC		 1863 { "sP", NL ("sizeof..."), 1 },
1864 { "sZ", NL ("sizeof..."), 1 },
7c328963 1865 { "sc", NL ("static_cast"), 2 },
56b1e56d 1866 { "ss", NL ("<=>"), 2 },
b6fb00c0 1867 { "st", NL ("sizeof "), 1 },
59727473 1868 { "sz", NL ("sizeof "), 1 },
eb7b5ddb
DD		 1869 { "tr", NL ("throw"), 0 },
1870 { "tw", NL ("throw "), 1 },
59727473 1871 { NULL, NULL, 0, 0 }
d00edca5 1872};
eb383413 1873
59727473 1874static struct demangle_component *
9334f9c6 1875d_operator_name (struct d_info *di)
eb383413 1876{
d00edca5
DD		 1877 char c1;
1878 char c2;
eb383413 1879
d00edca5
DD		 1880 c1 = d_next_char (di);
1881 c2 = d_next_char (di);
1882 if (c1 == 'v' && IS_DIGIT (c2))
1883 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1884 else if (c1 == 'c' && c2 == 'v')
492e19d0 1885 {
1886 struct demangle_component *type;
1887 int was_conversion = di->is_conversion;
c4be2641 1888 struct demangle_component *res;
492e19d0 1889
1890 di->is_conversion = ! di->is_expression;
1891 type = cplus_demangle_type (di);
c4be2641
PA		 1892 if (di->is_conversion)
1893 res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
1894 else
1895 res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
492e19d0 1896 di->is_conversion = was_conversion;
c4be2641 1897 return res;
492e19d0 1898 }
d00edca5 1899 else
eb383413 1900 {
59727473 1901 /* LOW is the inclusive lower bound. */
d00edca5 1902 int low = 0;
59727473
DD		 1903 /* HIGH is the exclusive upper bound. We subtract one to ignore
1904 the sentinel at the end of the array. */
1905 int high = ((sizeof (cplus_demangle_operators)
1906 / sizeof (cplus_demangle_operators[0]))
1907 - 1);
eb383413 1908
d00edca5
DD		 1909 while (1)
1910 {
1911 int i;
59727473 1912 const struct demangle_operator_info *p;
eb383413 1913
d00edca5 1914 i = low + (high - low) / 2;
59727473 1915 p = cplus_demangle_operators + i;
eb383413 1916
d00edca5
DD		 1917 if (c1 == p->code[0] && c2 == p->code[1])
1918 return d_make_operator (di, p);
1919
1920 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1921 high = i;
1922 else
1923 low = i + 1;
1924 if (low == high)
1925 return NULL;
1926 }
1927 }
eb383413
L		 1928}
1929
830ef634
DD		 1930static struct demangle_component *
1931d_make_character (struct d_info *di, int c)
1932{
1933 struct demangle_component *p;
1934 p = d_make_empty (di);
1935 if (p != NULL)
1936 {
1937 p->type = DEMANGLE_COMPONENT_CHARACTER;
1938 p->u.s_character.character = c;
1939 }
1940 return p;
1941}
1942
1943static struct demangle_component *
1944d_java_resource (struct d_info *di)
1945{
1946 struct demangle_component *p = NULL;
1947 struct demangle_component *next = NULL;
fa3fcee7 1948 int len, i;
830ef634
DD		 1949 char c;
1950 const char *str;
1951
1952 len = d_number (di);
1953 if (len <= 1)
1954 return NULL;
1955
1956 /* Eat the leading '_'. */
1957 if (d_next_char (di) != '_')
1958 return NULL;
1959 len--;
1960
1961 str = d_str (di);
1962 i = 0;
1963
1964 while (len > 0)
1965 {
1966 c = str[i];
1967 if (!c)
1968 return NULL;
1969
1970 /* Each chunk is either a '$' escape... */
1971 if (c == '$')
1972 {
1973 i++;
1974 switch (str[i++])
1975 {
1976 case 'S':
1977 c = '/';
1978 break;
1979 case '_':
1980 c = '.';
1981 break;
1982 case '$':
1983 c = '$';
1984 break;
1985 default:
1986 return NULL;
1987 }
1988 next = d_make_character (di, c);
1989 d_advance (di, i);
1990 str = d_str (di);
1991 len -= i;
1992 i = 0;
1993 if (next == NULL)
1994 return NULL;
1995 }
1996 /* ... or a sequence of characters. */
1997 else
1998 {
1999 while (i < len && str[i] && str[i] != '$')
2000 i++;
2001
2002 next = d_make_name (di, str, i);
2003 d_advance (di, i);
2004 str = d_str (di);
2005 len -= i;
2006 i = 0;
2007 if (next == NULL)
2008 return NULL;
2009 }
2010
2011 if (p == NULL)
2012 p = next;
2013 else
2014 {
2015 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
2016 if (p == NULL)
2017 return NULL;
2018 }
2019 }
2020
2021 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
2022
2023 return p;
2024}
2025
d00edca5
DD		 2026/* <special-name> ::= TV <type>
2027 ::= TT <type>
2028 ::= TI <type>
2029 ::= TS <type>
af03af8f 2030 ::= TA <template-arg>
d00edca5
DD		 2031 ::= GV <(object) name>
2032 ::= T <call-offset> <(base) encoding>
2033 ::= Tc <call-offset> <call-offset> <(base) encoding>
2034 Also g++ extensions:
2035 ::= TC <type> <(offset) number> _ <(base) type>
2036 ::= TF <type>
2037 ::= TJ <type>
2038 ::= GR <name>
839e4798 2039 ::= GA <encoding>
830ef634 2040 ::= Gr <resource name>
956a8f8b
DD		 2041 ::= GTt <encoding>
2042 ::= GTn <encoding>
d00edca5 2043*/
eb383413 2044
59727473 2045static struct demangle_component *
9334f9c6 2046d_special_name (struct d_info *di)
eb383413 2047{
b6fb00c0 2048 di->expansion += 20;
6ef6358e 2049 if (d_check_char (di, 'T'))
03d5f569 2050 {
d00edca5
DD		 2051 switch (d_next_char (di))
2052 {
2053 case 'V':
b6fb00c0 2054 di->expansion -= 5;
59727473
DD		 2055 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
2056 cplus_demangle_type (di), NULL);
d00edca5 2057 case 'T':
b6fb00c0 2058 di->expansion -= 10;
59727473
DD		 2059 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
2060 cplus_demangle_type (di), NULL);
d00edca5 2061 case 'I':
59727473
DD		 2062 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
2063 cplus_demangle_type (di), NULL);
d00edca5 2064 case 'S':
59727473
DD		 2065 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
2066 cplus_demangle_type (di), NULL);
eb383413 2067
d00edca5
DD		 2068 case 'h':
2069 if (! d_call_offset (di, 'h'))
2070 return NULL;
59727473
DD		 2071 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
2072 d_encoding (di, 0), NULL);
eb383413 2073
d00edca5
DD		 2074 case 'v':
2075 if (! d_call_offset (di, 'v'))
2076 return NULL;
59727473
DD		 2077 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
2078 d_encoding (di, 0), NULL);
eb383413 2079
d00edca5
DD		 2080 case 'c':
2081 if (! d_call_offset (di, '\0'))
2082 return NULL;
2083 if (! d_call_offset (di, '\0'))
2084 return NULL;
59727473
DD		 2085 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
2086 d_encoding (di, 0), NULL);
eb383413 2087
d00edca5
DD		 2088 case 'C':
2089 {
59727473 2090 struct demangle_component *derived_type;
fa3fcee7 2091 int offset;
59727473 2092 struct demangle_component *base_type;
d00edca5 2093
59727473 2094 derived_type = cplus_demangle_type (di);
d00edca5
DD		 2095 offset = d_number (di);
2096 if (offset < 0)
2097 return NULL;
6ef6358e 2098 if (! d_check_char (di, '_'))
d00edca5 2099 return NULL;
59727473 2100 base_type = cplus_demangle_type (di);
d00edca5
DD		 2101 /* We don't display the offset. FIXME: We should display
2102 it in verbose mode. */
b6fb00c0 2103 di->expansion += 5;
59727473
DD		 2104 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
2105 base_type, derived_type);
d00edca5 2106 }
eb383413 2107
d00edca5 2108 case 'F':
59727473
DD		 2109 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
2110 cplus_demangle_type (di), NULL);
d00edca5 2111 case 'J':
59727473
DD		 2112 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
2113 cplus_demangle_type (di), NULL);
eb383413 2114
995b61fe
DD		 2115 case 'H':
2116 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
2a8ae714 2117 d_name (di), NULL);
995b61fe
DD		 2118
2119 case 'W':
2120 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
2a8ae714 2121 d_name (di), NULL);
995b61fe 2122
af03af8f
NC		 2123 case 'A':
2124 return d_make_comp (di, DEMANGLE_COMPONENT_TPARM_OBJ,
2125 d_template_arg (di), NULL);
2126
d00edca5
DD		 2127 default:
2128 return NULL;
2129 }
eb383413 2130 }
6ef6358e 2131 else if (d_check_char (di, 'G'))
eb383413 2132 {
d00edca5
DD		 2133 switch (d_next_char (di))
2134 {
2135 case 'V':
26a67918 2136 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD,
2a8ae714 2137 d_name (di), NULL);
d00edca5
DD		 2138
2139 case 'R':
abc6552b 2140 {
2a8ae714 2141 struct demangle_component *name = d_name (di);
abc6552b
DD		 2142 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
2143 d_number_component (di));
2144 }
d00edca5 2145
839e4798
RH		 2146 case 'A':
2147 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
2148 d_encoding (di, 0), NULL);
2149
956a8f8b
DD		 2150 case 'T':
2151 switch (d_next_char (di))
2152 {
2153 case 'n':
2154 return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
2155 d_encoding (di, 0), NULL);
2156 default:
2157 /* ??? The proposal is that other letters (such as 'h') stand
2158 for different variants of transaction cloning, such as
2159 compiling directly for hardware transaction support. But
2160 they still should all be transactional clones of some sort
2161 so go ahead and call them that. */
2162 case 't':
2163 return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
2164 d_encoding (di, 0), NULL);
2165 }
2166
830ef634
DD		 2167 case 'r':
2168 return d_java_resource (di);
2169
d00edca5
DD		 2170 default:
2171 return NULL;
2172 }
eb383413 2173 }
d00edca5
DD		 2174 else
2175 return NULL;
eb383413
L		 2176}
2177
d00edca5
DD		 2178/* <call-offset> ::= h <nv-offset> _
2179 ::= v <v-offset> _
eb383413 2180
d00edca5 2181 <nv-offset> ::= <(offset) number>
eb383413 2182
d00edca5 2183 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
eb383413 2184
d00edca5
DD		 2185 The C parameter, if not '\0', is a character we just read which is
2186 the start of the <call-offset>.
eb383413 2187
d00edca5
DD		 2188 We don't display the offset information anywhere. FIXME: We should
2189 display it in verbose mode. */
eb383413 2190
d00edca5 2191static int
9334f9c6 2192d_call_offset (struct d_info *di, int c)
eb383413 2193{
d00edca5
DD		 2194 if (c == '\0')
2195 c = d_next_char (di);
eb383413 2196
d00edca5 2197 if (c == 'h')
eb129e35 2198 d_number (di);
d00edca5 2199 else if (c == 'v')
eb383413 2200 {
eb129e35 2201 d_number (di);
6ef6358e 2202 if (! d_check_char (di, '_'))
d00edca5 2203 return 0;
eb129e35 2204 d_number (di);
eb383413 2205 }
d00edca5
DD		 2206 else
2207 return 0;
eb383413 2208
6ef6358e 2209 if (! d_check_char (di, '_'))
d00edca5 2210 return 0;
eb383413 2211
d00edca5 2212 return 1;
eb383413
L		 2213}
2214
d00edca5
DD		 2215/* <ctor-dtor-name> ::= C1
2216 ::= C2
2217 ::= C3
2218 ::= D0
2219 ::= D1
2220 ::= D2
2221*/
2222
59727473 2223static struct demangle_component *
9334f9c6 2224d_ctor_dtor_name (struct d_info *di)
d00edca5 2225{
b6fb00c0
DD		 2226 if (di->last_name != NULL)
2227 {
59727473 2228 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
b6fb00c0 2229 di->expansion += di->last_name->u.s_name.len;
59727473 2230 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
b6fb00c0
DD		 2231 di->expansion += di->last_name->u.s_string.len;
2232 }
6ef6358e 2233 switch (d_peek_char (di))
d00edca5
DD		 2234 {
2235 case 'C':
2236 {
2237 enum gnu_v3_ctor_kinds kind;
ef0f5d7c
JM		 2238 int inheriting = 0;
2239
2240 if (d_peek_next_char (di) == 'I')
2241 {
2242 inheriting = 1;
2243 d_advance (di, 1);
2244 }
d00edca5 2245
6ef6358e 2246 switch (d_peek_next_char (di))
d00edca5
DD		 2247 {
2248 case '1':
2249 kind = gnu_v3_complete_object_ctor;
2250 break;
2251 case '2':
2252 kind = gnu_v3_base_object_ctor;
2253 break;
2254 case '3':
2255 kind = gnu_v3_complete_object_allocating_ctor;
2256 break;
eafbc3bf
BM		 2257 case '4':
2258 kind = gnu_v3_unified_ctor;
2259 break;
956a8f8b
DD		 2260 case '5':
2261 kind = gnu_v3_object_ctor_group;
2262 break;
d00edca5
DD		 2263 default:
2264 return NULL;
2265 }
ef0f5d7c 2266
6ef6358e 2267 d_advance (di, 2);
ef0f5d7c
JM		 2268
2269 if (inheriting)
2270 cplus_demangle_type (di);
2271
d00edca5
DD		 2272 return d_make_ctor (di, kind, di->last_name);
2273 }
2274
2275 case 'D':
2276 {
2277 enum gnu_v3_dtor_kinds kind;
2278
6ef6358e 2279 switch (d_peek_next_char (di))
d00edca5
DD		 2280 {
2281 case '0':
2282 kind = gnu_v3_deleting_dtor;
2283 break;
2284 case '1':
2285 kind = gnu_v3_complete_object_dtor;
2286 break;
2287 case '2':
2288 kind = gnu_v3_base_object_dtor;
2289 break;
eafbc3bf
BM		 2290 /* digit '3' is not used */
2291 case '4':
2292 kind = gnu_v3_unified_dtor;
2293 break;
956a8f8b
DD		 2294 case '5':
2295 kind = gnu_v3_object_dtor_group;
2296 break;
d00edca5
DD		 2297 default:
2298 return NULL;
2299 }
6ef6358e 2300 d_advance (di, 2);
d00edca5
DD		 2301 return d_make_dtor (di, kind, di->last_name);
2302 }
eb383413 2303
d00edca5
DD		 2304 default:
2305 return NULL;
2306 }
2307}
eb383413 2308
a4ddf8dc
JM		 2309/* True iff we're looking at an order-insensitive type-qualifier, including
2310 function-type-qualifiers. */
2311
2312static int
2313next_is_type_qual (struct d_info *di)
2314{
2315 char peek = d_peek_char (di);
2316 if (peek == 'r' || peek == 'V' || peek == 'K')
2317 return 1;
2318 if (peek == 'D')
2319 {
2320 peek = d_peek_next_char (di);
2321 if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
2322 return 1;
2323 }
2324 return 0;
2325}
2326
d00edca5
DD		 2327/* <type> ::= <builtin-type>
2328 ::= <function-type>
2329 ::= <class-enum-type>
2330 ::= <array-type>
2331 ::= <pointer-to-member-type>
2332 ::= <template-param>
2333 ::= <template-template-param> <template-args>
2334 ::= <substitution>
2335 ::= <CV-qualifiers> <type>
2336 ::= P <type>
2337 ::= R <type>
8969a67f 2338 ::= O <type> (C++0x)
d00edca5
DD		 2339 ::= C <type>
2340 ::= G <type>
2341 ::= U <source-name> <type>
2342
2343 <builtin-type> ::= various one letter codes
2344 ::= u <source-name>
2345*/
eb383413 2346
59727473
DD		 2347CP_STATIC_IF_GLIBCPP_V3
2348const struct demangle_builtin_type_info
2349cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
d00edca5 2350{
2d733211 2351 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
b6fb00c0 2352 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
2d733211
DD		 2353 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
2354 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
2355 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
2356 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
2357 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
2358 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
b6fb00c0 2359 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2d733211 2360 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
b6fb00c0
DD		 2361 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2362 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2d733211 2363 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
b6fb00c0 2364 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2d733211
DD		 2365 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2366 D_PRINT_DEFAULT },
1c08f2c8
DD		 2367 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2368 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2369 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2d733211
DD		 2370 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
2371 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
1c08f2c8 2372 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
b6fb00c0 2373 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2d733211
DD		 2374 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
2375 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
2376 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2377 D_PRINT_UNSIGNED_LONG_LONG },
b6fb00c0 2378 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
1c08f2c8
DD		 2379 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
2380 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2381 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2382 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
07ffcfec
AM		 2383 /* 30 */ { NL ("char8_t"), NL ("char8_t"), D_PRINT_DEFAULT },
2384 /* 31 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2385 /* 32 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2386 /* 33 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
cf383746 2387 D_PRINT_DEFAULT },
d00edca5 2388};
eb383413 2389
59727473
DD		 2390CP_STATIC_IF_GLIBCPP_V3
2391struct demangle_component *
9334f9c6 2392cplus_demangle_type (struct d_info *di)
eb383413 2393{
d00edca5 2394 char peek;
59727473 2395 struct demangle_component *ret;
d00edca5
DD		 2396 int can_subst;
2397
2398 /* The ABI specifies that when CV-qualifiers are used, the base type
2399 is substitutable, and the fully qualified type is substitutable,
2400 but the base type with a strict subset of the CV-qualifiers is
2401 not substitutable. The natural recursive implementation of the
2402 CV-qualifiers would cause subsets to be substitutable, so instead
2403 we pull them all off now.
2404
331c3da2
DD		 2405 FIXME: The ABI says that order-insensitive vendor qualifiers
2406 should be handled in the same way, but we have no way to tell
2407 which vendor qualifiers are order-insensitive and which are
2408 order-sensitive. So we just assume that they are all
2409 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2410 __vector, and it treats it as order-sensitive when mangling
2411 names. */
d00edca5 2412
a4ddf8dc 2413 if (next_is_type_qual (di))
d00edca5 2414 {
59727473 2415 struct demangle_component **pret;
74bcd529 2416
858b45cf 2417 pret = d_cv_qualifiers (di, &ret, 0);
331c3da2
DD		 2418 if (pret == NULL)
2419 return NULL;
dcd7e9d6
DD		 2420 if (d_peek_char (di) == 'F')
2421 {
2422 /* cv-qualifiers before a function type apply to 'this',
2423 so avoid adding the unqualified function type to
2424 the substitution list. */
2425 *pret = d_function_type (di);
2426 }
2427 else
2428 *pret = cplus_demangle_type (di);
2429 if (!*pret)
3a4d2339
DD		 2430 return NULL;
2431 if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2432 || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
2433 {
2434 /* Move the ref-qualifier outside the cv-qualifiers so that
2435 they are printed in the right order. */
2436 struct demangle_component *fn = d_left (*pret);
2437 d_left (*pret) = ret;
2438 ret = *pret;
2439 *pret = fn;
2440 }
2441 if (! d_add_substitution (di, ret))
d00edca5
DD		 2442 return NULL;
2443 return ret;
2444 }
eb383413 2445
d00edca5 2446 can_subst = 1;
eb383413 2447
a4ddf8dc 2448 peek = d_peek_char (di);
74bcd529 2449 switch (peek)
eb383413 2450 {
d00edca5
DD		 2451 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2452 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2453 case 'o': case 's': case 't':
2454 case 'v': case 'w': case 'x': case 'y': case 'z':
59727473
DD		 2455 ret = d_make_builtin_type (di,
2456 &cplus_demangle_builtin_types[peek - 'a']);
b6fb00c0 2457 di->expansion += ret->u.s_builtin.type->len;
d00edca5
DD		 2458 can_subst = 0;
2459 d_advance (di, 1);
2460 break;
2461
2462 case 'u':
2463 d_advance (di, 1);
59727473
DD		 2464 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2465 d_source_name (di), NULL);
d00edca5
DD		 2466 break;
2467
2468 case 'F':
2469 ret = d_function_type (di);
eb383413
L		 2470 break;
2471
d00edca5
DD		 2472 case '0': case '1': case '2': case '3': case '4':
2473 case '5': case '6': case '7': case '8': case '9':
2474 case 'N':
eb383413 2475 case 'Z':
d00edca5 2476 ret = d_class_enum_type (di);
eb383413
L		 2477 break;
2478
d00edca5
DD		 2479 case 'A':
2480 ret = d_array_type (di);
2481 break;
2482
2483 case 'M':
2484 ret = d_pointer_to_member_type (di);
2485 break;
2486
2487 case 'T':
2488 ret = d_template_param (di);
2489 if (d_peek_char (di) == 'I')
03d5f569 2490 {
492e19d0 2491 /* This may be <template-template-param> <template-args>.
2492 If this is the type for a conversion operator, we can
2493 have a <template-template-param> here only by following
2494 a derivation like this:
2495
2496 <nested-name>
2497 -> <template-prefix> <template-args>
2498 -> <prefix> <template-unqualified-name> <template-args>
2499 -> <unqualified-name> <template-unqualified-name> <template-args>
2500 -> <source-name> <template-unqualified-name> <template-args>
2501 -> <source-name> <operator-name> <template-args>
2502 -> <source-name> cv <type> <template-args>
2503 -> <source-name> cv <template-template-param> <template-args> <template-args>
2504
2505 where the <template-args> is followed by another.
2506 Otherwise, we must have a derivation like this:
2507
2508 <nested-name>
2509 -> <template-prefix> <template-args>
2510 -> <prefix> <template-unqualified-name> <template-args>
2511 -> <unqualified-name> <template-unqualified-name> <template-args>
2512 -> <source-name> <template-unqualified-name> <template-args>
2513 -> <source-name> <operator-name> <template-args>
2514 -> <source-name> cv <type> <template-args>
2515 -> <source-name> cv <template-param> <template-args>
2516
2517 where we need to leave the <template-args> to be processed
2518 by d_prefix (following the <template-prefix>).
2519
2520 The <template-template-param> part is a substitution
d00edca5 2521 candidate. */
492e19d0 2522 if (! di->is_conversion)
2523 {
2524 if (! d_add_substitution (di, ret))
2525 return NULL;
2526 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2527 d_template_args (di));
2528 }
2529 else
2530 {
2531 struct demangle_component *args;
2532 struct d_info_checkpoint checkpoint;
2533
2534 d_checkpoint (di, &checkpoint);
2535 args = d_template_args (di);
2536 if (d_peek_char (di) == 'I')
2537 {
2538 if (! d_add_substitution (di, ret))
2539 return NULL;
2540 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2541 args);
2542 }
2543 else
2544 d_backtrack (di, &checkpoint);
2545 }
03d5f569 2546 }
d00edca5
DD		 2547 break;
2548
2549 case 'S':
2550 /* If this is a special substitution, then it is the start of
2551 <class-enum-type>. */
2552 {
2553 char peek_next;
74bcd529 2554
d00edca5
DD		 2555 peek_next = d_peek_next_char (di);
2556 if (IS_DIGIT (peek_next)
2557 || peek_next == '_'
858b45cf 2558 || IS_UPPER (peek_next))
d00edca5 2559 {
97ceaf5b 2560 ret = d_substitution (di, 0);
d00edca5
DD		 2561 /* The substituted name may have been a template name and
2562 may be followed by tepmlate args. */
2563 if (d_peek_char (di) == 'I')
59727473 2564 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
d00edca5
DD		 2565 d_template_args (di));
2566 else
2567 can_subst = 0;
2568 }
2569 else
2570 {
2571 ret = d_class_enum_type (di);
2572 /* If the substitution was a complete type, then it is not
2573 a new substitution candidate. However, if the
2574 substitution was followed by template arguments, then
2575 the whole thing is a substitution candidate. */
59727473 2576 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
d00edca5
DD		 2577 can_subst = 0;
2578 }
2579 }
eb383413
L		 2580 break;
2581
8969a67f
DD		 2582 case 'O':
2583 d_advance (di, 1);
2584 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2585 cplus_demangle_type (di), NULL);
2586 break;
2587
d00edca5
DD		 2588 case 'P':
2589 d_advance (di, 1);
59727473
DD		 2590 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2591 cplus_demangle_type (di), NULL);
d00edca5 2592 break;
eb383413 2593
d00edca5
DD		 2594 case 'R':
2595 d_advance (di, 1);
59727473 2596 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
8969a67f 2597 cplus_demangle_type (di), NULL);
d00edca5 2598 break;
eb383413 2599
d00edca5
DD		 2600 case 'C':
2601 d_advance (di, 1);
59727473
DD		 2602 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2603 cplus_demangle_type (di), NULL);
d00edca5
DD		 2604 break;
2605
2606 case 'G':
2607 d_advance (di, 1);
59727473
DD		 2608 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2609 cplus_demangle_type (di), NULL);
d00edca5 2610 break;
eb383413 2611
d00edca5
DD		 2612 case 'U':
2613 d_advance (di, 1);
2614 ret = d_source_name (di);
f91ca6bc
IB		 2615 if (d_peek_char (di) == 'I')
2616 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2617 d_template_args (di));
59727473
DD		 2618 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2619 cplus_demangle_type (di), ret);
eb383413 2620 break;
d00edca5 2621
ba8cb4ba
DD		 2622 case 'D':
2623 can_subst = 0;
2624 d_advance (di, 1);
2625 peek = d_next_char (di);
2626 switch (peek)
2627 {
2628 case 'T':
2629 case 't':
2630 /* decltype (expression) */
2631 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2632 d_expression (di), NULL);
2633 if (ret && d_next_char (di) != 'E')
2634 ret = NULL;
eb7b5ddb 2635 can_subst = 1;
ba8cb4ba
DD		 2636 break;
2637
2638 case 'p':
2639 /* Pack expansion. */
1c08f2c8
DD		 2640 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2641 cplus_demangle_type (di), NULL);
eb7b5ddb 2642 can_subst = 1;
1c08f2c8 2643 break;
24e829d0
DD		 2644
2645 case 'a':
2646 /* auto */
2647 ret = d_make_name (di, "auto", 4);
2648 break;
e495212d
AM		 2649 case 'c':
2650 /* decltype(auto) */
2651 ret = d_make_name (di, "decltype(auto)", 14);
2652 break;
2653
ba8cb4ba 2654 case 'f':
1c08f2c8
DD		 2655 /* 32-bit decimal floating point */
2656 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
ba8cb4ba
DD		 2657 di->expansion += ret->u.s_builtin.type->len;
2658 break;
2659 case 'd':
1c08f2c8
DD		 2660 /* 64-bit DFP */
2661 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
ba8cb4ba
DD		 2662 di->expansion += ret->u.s_builtin.type->len;
2663 break;
2664 case 'e':
2665 /* 128-bit DFP */
1c08f2c8 2666 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
ba8cb4ba
DD		 2667 di->expansion += ret->u.s_builtin.type->len;
2668 break;
2669 case 'h':
2670 /* 16-bit half-precision FP */
1c08f2c8
DD		 2671 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2672 di->expansion += ret->u.s_builtin.type->len;
2673 break;
07ffcfec
AM		 2674 case 'u':
2675 /* char8_t */
2676 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2677 di->expansion += ret->u.s_builtin.type->len;
2678 break;
1c08f2c8
DD		 2679 case 's':
2680 /* char16_t */
07ffcfec 2681 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
1c08f2c8
DD		 2682 di->expansion += ret->u.s_builtin.type->len;
2683 break;
2684 case 'i':
2685 /* char32_t */
07ffcfec 2686 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
ba8cb4ba
DD		 2687 di->expansion += ret->u.s_builtin.type->len;
2688 break;
d2825c1a
DD		 2689
2690 case 'F':
2691 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2692 ret = d_make_empty (di);
2693 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2694 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2695 /* For demangling we don't care about the bits. */
2696 d_number (di);
2697 ret->u.s_fixed.length = cplus_demangle_type (di);
cbc43128
DD		 2698 if (ret->u.s_fixed.length == NULL)
2699 return NULL;
d2825c1a
DD		 2700 d_number (di);
2701 peek = d_next_char (di);
2702 ret->u.s_fixed.sat = (peek == 's');
2703 break;
60cf58f5 2704
cbc43128
DD		 2705 case 'v':
2706 ret = d_vector_type (di);
eb7b5ddb 2707 can_subst = 1;
cbc43128
DD		 2708 break;
2709
cf383746
DD		 2710 case 'n':
2711 /* decltype(nullptr) */
07ffcfec 2712 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[33]);
cf383746
DD		 2713 di->expansion += ret->u.s_builtin.type->len;
2714 break;
2715
60cf58f5
DD		 2716 default:
2717 return NULL;
ba8cb4ba
DD		 2718 }
2719 break;
2720
d00edca5
DD		 2721 default:
2722 return NULL;
eb383413
L		 2723 }
2724
d00edca5
DD		 2725 if (can_subst)
2726 {
2727 if (! d_add_substitution (di, ret))
2728 return NULL;
2729 }
eb383413 2730
d00edca5
DD		 2731 return ret;
2732}
eb383413 2733
e9a38816 2734/* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
eb383413 2735
59727473 2736static struct demangle_component **
9334f9c6
DD		 2737d_cv_qualifiers (struct d_info *di,
2738 struct demangle_component **pret, int member_fn)
eb383413 2739{
f9fb0b2d 2740 struct demangle_component **pstart;
eb383413
L		 2741 char peek;
2742
f9fb0b2d 2743 pstart = pret;
d00edca5 2744 peek = d_peek_char (di);
a4ddf8dc 2745 while (next_is_type_qual (di))
eb383413 2746 {
59727473 2747 enum demangle_component_type t;
a4ddf8dc 2748 struct demangle_component *right = NULL;
59666b35 2749
d00edca5
DD		 2750 d_advance (di, 1);
2751 if (peek == 'r')
b6fb00c0 2752 {
59727473
DD		 2753 t = (member_fn
2754 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2755 : DEMANGLE_COMPONENT_RESTRICT);
b6fb00c0
DD		 2756 di->expansion += sizeof "restrict";
2757 }
d00edca5 2758 else if (peek == 'V')
b6fb00c0 2759 {
59727473
DD		 2760 t = (member_fn
2761 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2762 : DEMANGLE_COMPONENT_VOLATILE);
b6fb00c0
DD		 2763 di->expansion += sizeof "volatile";
2764 }
e9a38816 2765 else if (peek == 'K')
b6fb00c0 2766 {
59727473
DD		 2767 t = (member_fn
2768 ? DEMANGLE_COMPONENT_CONST_THIS
2769 : DEMANGLE_COMPONENT_CONST);
b6fb00c0
DD		 2770 di->expansion += sizeof "const";
2771 }
e9a38816
JM		 2772 else
2773 {
a4ddf8dc
JM		 2774 peek = d_next_char (di);
2775 if (peek == 'x')
2776 {
2777 t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
2778 di->expansion += sizeof "transaction_safe";
2779 }
2780 else if (peek == 'o'
2781 || peek == 'O')
2782 {
2783 t = DEMANGLE_COMPONENT_NOEXCEPT;
2784 di->expansion += sizeof "noexcept";
2785 if (peek == 'O')
2786 {
2787 right = d_expression (di);
2788 if (right == NULL)
2789 return NULL;
2790 if (! d_check_char (di, 'E'))
2791 return NULL;
2792 }
2793 }
2794 else if (peek == 'w')
2795 {
2796 t = DEMANGLE_COMPONENT_THROW_SPEC;
2797 di->expansion += sizeof "throw";
2798 right = d_parmlist (di);
2799 if (right == NULL)
2800 return NULL;
2801 if (! d_check_char (di, 'E'))
2802 return NULL;
2803 }
2804 else
2805 return NULL;
e9a38816 2806 }
eb383413 2807
a4ddf8dc 2808 *pret = d_make_comp (di, t, NULL, right);
d00edca5
DD		 2809 if (*pret == NULL)
2810 return NULL;
2811 pret = &d_left (*pret);
eb383413 2812
d00edca5
DD		 2813 peek = d_peek_char (di);
2814 }
eb383413 2815
f9fb0b2d
DD		 2816 if (!member_fn && peek == 'F')
2817 {
2818 while (pstart != pret)
2819 {
2820 switch ((*pstart)->type)
2821 {
2822 case DEMANGLE_COMPONENT_RESTRICT:
2823 (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2824 break;
2825 case DEMANGLE_COMPONENT_VOLATILE:
2826 (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2827 break;
2828 case DEMANGLE_COMPONENT_CONST:
2829 (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2830 break;
2831 default:
2832 break;
2833 }
2834 pstart = &d_left (*pstart);
2835 }
2836 }
2837
d00edca5
DD		 2838 return pret;
2839}
eb383413 2840
3a4d2339
DD		 2841/* <ref-qualifier> ::= R
2842 ::= O */
2843
2844static struct demangle_component *
2845d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2846{
2847 struct demangle_component *ret = sub;
2848 char peek;
2849
2850 peek = d_peek_char (di);
2851 if (peek == 'R' || peek == 'O')
2852 {
2853 enum demangle_component_type t;
2854 if (peek == 'R')
2855 {
2856 t = DEMANGLE_COMPONENT_REFERENCE_THIS;
2857 di->expansion += sizeof "&";
2858 }
2859 else
2860 {
2861 t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
2862 di->expansion += sizeof "&&";
2863 }
2864 d_advance (di, 1);
2865
2866 ret = d_make_comp (di, t, ret, NULL);
2867 }
2868
2869 return ret;
2870}
2871
e9a38816 2872/* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
eb383413 2873
59727473 2874static struct demangle_component *
9334f9c6 2875d_function_type (struct d_info *di)
eb383413 2876{
af03af8f 2877 struct demangle_component *ret = NULL;
eb383413 2878
af03af8f 2879 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
d00edca5 2880 {
af03af8f
NC		 2881 if (di->recursion_level > DEMANGLE_RECURSION_LIMIT)
2882 /* FIXME: There ought to be a way to report
2883 that the recursion limit has been reached. */
2884 return NULL;
2885
2886 di->recursion_level ++;
d00edca5 2887 }
3a4d2339 2888
af03af8f
NC		 2889 if (d_check_char (di, 'F'))
2890 {
2891 if (d_peek_char (di) == 'Y')
2892 {
2893 /* Function has C linkage. We don't print this information.
2894 FIXME: We should print it in verbose mode. */
2895 d_advance (di, 1);
2896 }
2897 ret = d_bare_function_type (di, 1);
2898 ret = d_ref_qualifier (di, ret);
2899
2900 if (! d_check_char (di, 'E'))
2901 ret = NULL;
2902 }
2903
2904 if ((di->options & DMGL_NO_RECURSE_LIMIT) == 0)
2905 di->recursion_level --;
d00edca5
DD		 2906 return ret;
2907}
74bcd529 2908
664aa91f 2909/* <type>+ */
eb383413 2910
59727473 2911static struct demangle_component *
664aa91f 2912d_parmlist (struct d_info *di)
d00edca5 2913{
59727473
DD		 2914 struct demangle_component *tl;
2915 struct demangle_component **ptl;
7887b2ce 2916
d00edca5
DD		 2917 tl = NULL;
2918 ptl = &tl;
eb383413
L		 2919 while (1)
2920 {
59727473 2921 struct demangle_component *type;
eb383413 2922
664aa91f 2923 char peek = d_peek_char (di);
7955ede5 2924 if (peek == '\0' || peek == 'E' || peek == '.')
d00edca5 2925 break;
3a4d2339
DD		 2926 if ((peek == 'R' || peek == 'O')
2927 && d_peek_next_char (di) == 'E')
2928 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2929 break;
59727473 2930 type = cplus_demangle_type (di);
d00edca5
DD		 2931 if (type == NULL)
2932 return NULL;
664aa91f
DD		 2933 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2934 if (*ptl == NULL)
2935 return NULL;
2936 ptl = &d_right (*ptl);
eb383413 2937 }
eb383413 2938
d00edca5
DD		 2939 /* There should be at least one parameter type besides the optional
2940 return type. A function which takes no arguments will have a
2941 single parameter type void. */
2942 if (tl == NULL)
2943 return NULL;
eb383413 2944
d00edca5
DD		 2945 /* If we have a single parameter type void, omit it. */
2946 if (d_right (tl) == NULL
59727473 2947 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
d00edca5 2948 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
b6fb00c0
DD		 2949 {
2950 di->expansion -= d_left (tl)->u.s_builtin.type->len;
664aa91f 2951 d_left (tl) = NULL;
b6fb00c0 2952 }
eb383413 2953
664aa91f
DD		 2954 return tl;
2955}
2956
2957/* <bare-function-type> ::= [J]<type>+ */
2958
2959static struct demangle_component *
2960d_bare_function_type (struct d_info *di, int has_return_type)
2961{
2962 struct demangle_component *return_type;
2963 struct demangle_component *tl;
2964 char peek;
2965
2966 /* Detect special qualifier indicating that the first argument
2967 is the return type. */
2968 peek = d_peek_char (di);
2969 if (peek == 'J')
2970 {
2971 d_advance (di, 1);
2972 has_return_type = 1;
2973 }
2974
2975 if (has_return_type)
2976 {
2977 return_type = cplus_demangle_type (di);
2978 if (return_type == NULL)
2979 return NULL;
2980 }
2981 else
2982 return_type = NULL;
2983
2984 tl = d_parmlist (di);
2985 if (tl == NULL)
2986 return NULL;
2987
2988 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2989 return_type, tl);
d00edca5 2990}
eb383413 2991
d00edca5 2992/* <class-enum-type> ::= <name> */
eb383413 2993
59727473 2994static struct demangle_component *
9334f9c6 2995d_class_enum_type (struct d_info *di)
d00edca5 2996{
2a8ae714 2997 return d_name (di);
d00edca5 2998}
74bcd529 2999
d00edca5
DD		 3000/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
3001 ::= A [<(dimension) expression>] _ <(element) type>
3002*/
74bcd529 3003
59727473 3004static struct demangle_component *
9334f9c6 3005d_array_type (struct d_info *di)
d00edca5
DD		 3006{
3007 char peek;
59727473 3008 struct demangle_component *dim;
74bcd529 3009
6ef6358e 3010 if (! d_check_char (di, 'A'))
d00edca5
DD		 3011 return NULL;
3012
3013 peek = d_peek_char (di);
3014 if (peek == '_')
3015 dim = NULL;
3016 else if (IS_DIGIT (peek))
74bcd529 3017 {
d00edca5 3018 const char *s;
74bcd529 3019
d00edca5
DD		 3020 s = d_str (di);
3021 do
3022 {
3023 d_advance (di, 1);
3024 peek = d_peek_char (di);
3025 }
3026 while (IS_DIGIT (peek));
3027 dim = d_make_name (di, s, d_str (di) - s);
331c3da2
DD		 3028 if (dim == NULL)
3029 return NULL;
74bcd529 3030 }
eb383413 3031 else
d00edca5
DD		 3032 {
3033 dim = d_expression (di);
3034 if (dim == NULL)
3035 return NULL;
3036 }
eb383413 3037
6ef6358e 3038 if (! d_check_char (di, '_'))
d00edca5 3039 return NULL;
eb383413 3040
59727473
DD		 3041 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
3042 cplus_demangle_type (di));
d00edca5 3043}
eb383413 3044
cbc43128
DD		 3045/* <vector-type> ::= Dv <number> _ <type>
3046 ::= Dv _ <expression> _ <type> */
3047
3048static struct demangle_component *
3049d_vector_type (struct d_info *di)
3050{
3051 char peek;
3052 struct demangle_component *dim;
3053
3054 peek = d_peek_char (di);
3055 if (peek == '_')
3056 {
3057 d_advance (di, 1);
3058 dim = d_expression (di);
3059 }
3060 else
3061 dim = d_number_component (di);
3062
3063 if (dim == NULL)
3064 return NULL;
3065
3066 if (! d_check_char (di, '_'))
3067 return NULL;
3068
3069 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
3070 cplus_demangle_type (di));
3071}
3072
d00edca5 3073/* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
eb383413 3074
59727473 3075static struct demangle_component *
9334f9c6 3076d_pointer_to_member_type (struct d_info *di)
eb383413 3077{
59727473
DD		 3078 struct demangle_component *cl;
3079 struct demangle_component *mem;
eb383413 3080
6ef6358e 3081 if (! d_check_char (di, 'M'))
d00edca5 3082 return NULL;
eb383413 3083
59727473 3084 cl = cplus_demangle_type (di);
dcd7e9d6 3085 if (cl == NULL)
8d301070 3086 return NULL;
eb383413 3087
dcd7e9d6
DD		 3088 /* The ABI says, "The type of a non-static member function is considered
3089 to be different, for the purposes of substitution, from the type of a
3090 namespace-scope or static member function whose type appears
3091 similar. The types of two non-static member functions are considered
3092 to be different, for the purposes of substitution, if the functions
3093 are members of different classes. In other words, for the purposes of
3094 substitution, the class of which the function is a member is
3095 considered part of the type of function."
3096
3097 For a pointer to member function, this call to cplus_demangle_type
3098 will end up adding a (possibly qualified) non-member function type to
3099 the substitution table, which is not correct; however, the member
3100 function type will never be used in a substitution, so putting the
3101 wrong type in the substitution table is harmless. */
3102
3103 mem = cplus_demangle_type (di);
3104 if (mem == NULL)
3105 return NULL;
cb6c09ac 3106
59727473 3107 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
eb383413
L		 3108}
3109
664aa91f
DD		 3110/* <non-negative number> _ */
3111
fa3fcee7 3112static int
664aa91f
DD		 3113d_compact_number (struct d_info *di)
3114{
fa3fcee7 3115 int num;
664aa91f
DD		 3116 if (d_peek_char (di) == '_')
3117 num = 0;
3118 else if (d_peek_char (di) == 'n')
3119 return -1;
3120 else
3121 num = d_number (di) + 1;
3122
fa3fcee7 3123 if (num < 0 || ! d_check_char (di, '_'))
664aa91f
DD		 3124 return -1;
3125 return num;
3126}
3127
d00edca5
DD		 3128/* <template-param> ::= T_
3129 ::= T <(parameter-2 non-negative) number> _
3130*/
eb383413 3131
59727473 3132static struct demangle_component *
9334f9c6 3133d_template_param (struct d_info *di)
eb383413 3134{
fa3fcee7 3135 int param;
eb383413 3136
6ef6358e 3137 if (! d_check_char (di, 'T'))
d00edca5 3138 return NULL;
eb383413 3139
664aa91f
DD		 3140 param = d_compact_number (di);
3141 if (param < 0)
d00edca5 3142 return NULL;
eb383413 3143
d00edca5 3144 return d_make_template_param (di, param);
eb383413
L		 3145}
3146
d00edca5
DD		 3147/* <template-args> ::= I <template-arg>+ E */
3148
59727473 3149static struct demangle_component *
9334f9c6 3150d_template_args (struct d_info *di)
fa3fcee7
NC		 3151{
3152 if (d_peek_char (di) != 'I'
3153 && d_peek_char (di) != 'J')
3154 return NULL;
3155 d_advance (di, 1);
3156
3157 return d_template_args_1 (di);
3158}
3159
3160/* <template-arg>* E */
3161
3162static struct demangle_component *
3163d_template_args_1 (struct d_info *di)
eb383413 3164{
59727473
DD		 3165 struct demangle_component *hold_last_name;
3166 struct demangle_component *al;
3167 struct demangle_component **pal;
eb383413 3168
d00edca5
DD		 3169 /* Preserve the last name we saw--don't let the template arguments
3170 clobber it, as that would give us the wrong name for a subsequent
3171 constructor or destructor. */
3172 hold_last_name = di->last_name;
eb383413 3173
1c08f2c8
DD		 3174 if (d_peek_char (di) == 'E')
3175 {
3176 /* An argument pack can be empty. */
3177 d_advance (di, 1);
3178 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
3179 }
3180
d00edca5
DD		 3181 al = NULL;
3182 pal = &al;
eb383413
L		 3183 while (1)
3184 {
59727473 3185 struct demangle_component *a;
d00edca5
DD		 3186
3187 a = d_template_arg (di);
3188 if (a == NULL)
3189 return NULL;
3190
59727473 3191 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
331c3da2
DD		 3192 if (*pal == NULL)
3193 return NULL;
d00edca5
DD		 3194 pal = &d_right (*pal);
3195
3196 if (d_peek_char (di) == 'E')
03d5f569 3197 {
d00edca5
DD		 3198 d_advance (di, 1);
3199 break;
03d5f569 3200 }
eb383413
L		 3201 }
3202
d00edca5
DD		 3203 di->last_name = hold_last_name;
3204
3205 return al;
eb383413
L		 3206}
3207
d00edca5
DD		 3208/* <template-arg> ::= <type>
3209 ::= X <expression> E
3210 ::= <expr-primary>
3211*/
eb383413 3212
59727473 3213static struct demangle_component *
9334f9c6 3214d_template_arg (struct d_info *di)
eb383413 3215{
59727473 3216 struct demangle_component *ret;
03d5f569 3217
d00edca5 3218 switch (d_peek_char (di))
eb383413 3219 {
d00edca5
DD		 3220 case 'X':
3221 d_advance (di, 1);
3222 ret = d_expression (di);
6ef6358e 3223 if (! d_check_char (di, 'E'))
d00edca5
DD		 3224 return NULL;
3225 return ret;
b851d07b 3226
d00edca5
DD		 3227 case 'L':
3228 return d_expr_primary (di);
eb383413 3229
1c08f2c8 3230 case 'I':
eb7b5ddb 3231 case 'J':
1c08f2c8
DD		 3232 /* An argument pack. */
3233 return d_template_args (di);
3234
d00edca5 3235 default:
59727473 3236 return cplus_demangle_type (di);
74bcd529 3237 }
eb383413
L		 3238}
3239
eb7b5ddb
DD		 3240/* Parse a sequence of expressions until we hit the terminator
3241 character. */
ba8cb4ba
DD		 3242
3243static struct demangle_component *
eb7b5ddb 3244d_exprlist (struct d_info *di, char terminator)
ba8cb4ba
DD		 3245{
3246 struct demangle_component *list = NULL;
3247 struct demangle_component **p = &list;
3248
eb7b5ddb 3249 if (d_peek_char (di) == terminator)
1c08f2c8
DD		 3250 {
3251 d_advance (di, 1);
3252 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
3253 }
3254
ba8cb4ba
DD		 3255 while (1)
3256 {
3257 struct demangle_component *arg = d_expression (di);
3258 if (arg == NULL)
3259 return NULL;
3260
3261 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
3262 if (*p == NULL)
3263 return NULL;
3264 p = &d_right (*p);
3265
eb7b5ddb 3266 if (d_peek_char (di) == terminator)
ba8cb4ba
DD		 3267 {
3268 d_advance (di, 1);
3269 break;
3270 }
3271 }
3272
3273 return list;
3274}
3275
7c328963
DD		 3276/* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3277 dynamic_cast, static_cast or reinterpret_cast. */
3278
3279static int
3280op_is_new_cast (struct demangle_component *op)
3281{
3282 const char *code = op->u.s_operator.op->code;
3283 return (code[1] == 'c'
3284 && (code[0] == 's' || code[0] == 'd'
3285 || code[0] == 'c' || code[0] == 'r'));
3286}
3287
d00edca5
DD		 3288/* <expression> ::= <(unary) operator-name> <expression>
3289 ::= <(binary) operator-name> <expression> <expression>
3290 ::= <(trinary) operator-name> <expression> <expression> <expression>
ba8cb4ba 3291 ::= cl <expression>+ E
d00edca5
DD		 3292 ::= st <type>
3293 ::= <template-param>
3294 ::= sr <type> <unqualified-name>
3295 ::= sr <type> <unqualified-name> <template-args>
3296 ::= <expr-primary>
7ade7fba
AM		 3297
3298 <braced-expression> ::= <expression>
3299 ::= di <field source-name> <braced-expression> # .name = expr
3300 ::= dx <index expression> <braced-expression> # [expr] = expr
3301 ::= dX <range begin expression> <range end expression> <braced-expression>
3302 # [expr ... expr] = expr
d00edca5
DD		 3303*/
3304
492e19d0 3305static inline struct demangle_component *
3306d_expression_1 (struct d_info *di)
eb383413 3307{
d00edca5 3308 char peek;
eb383413 3309
d00edca5
DD		 3310 peek = d_peek_char (di);
3311 if (peek == 'L')
3312 return d_expr_primary (di);
3313 else if (peek == 'T')
3314 return d_template_param (di);
3315 else if (peek == 's' && d_peek_next_char (di) == 'r')
eb383413 3316 {
59727473
DD		 3317 struct demangle_component *type;
3318 struct demangle_component *name;
eb383413 3319
d00edca5 3320 d_advance (di, 2);
59727473 3321 type = cplus_demangle_type (di);
d00edca5
DD		 3322 name = d_unqualified_name (di);
3323 if (d_peek_char (di) != 'I')
59727473 3324 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
d00edca5 3325 else
59727473
DD		 3326 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
3327 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
d00edca5 3328 d_template_args (di)));
793011ca 3329 }
e2e1864d
DD		 3330 else if (peek == 's' && d_peek_next_char (di) == 'p')
3331 {
3332 d_advance (di, 2);
3333 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
492e19d0 3334 d_expression_1 (di), NULL);
e2e1864d 3335 }
c743cf5d 3336 else if (peek == 'f' && d_peek_next_char (di) == 'p')
ba8cb4ba 3337 {
c743cf5d
DD		 3338 /* Function parameter used in a late-specified return type. */
3339 int index;
ba8cb4ba 3340 d_advance (di, 2);
f2917a30
DD		 3341 if (d_peek_char (di) == 'T')
3342 {
3343 /* 'this' parameter. */
3344 d_advance (di, 1);
3345 index = 0;
3346 }
3347 else
3348 {
fa3fcee7
NC		 3349 index = d_compact_number (di);
3350 if (index == INT_MAX || index == -1)
f2917a30 3351 return NULL;
fa3fcee7 3352 index++;
f2917a30 3353 }
c743cf5d 3354 return d_make_function_param (di, index);
ba8cb4ba 3355 }
cbc43128
DD		 3356 else if (IS_DIGIT (peek)
3357 || (peek == 'o' && d_peek_next_char (di) == 'n'))
1c08f2c8
DD		 3358 {
3359 /* We can get an unqualified name as an expression in the case of
cbc43128
DD		 3360 a dependent function call, i.e. decltype(f(t)). */
3361 struct demangle_component *name;
3362
3363 if (peek == 'o')
3364 /* operator-function-id, i.e. operator+(t). */
3365 d_advance (di, 2);
3366
3367 name = d_unqualified_name (di);
1c08f2c8
DD		 3368 if (name == NULL)
3369 return NULL;
3370 if (d_peek_char (di) == 'I')
3371 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3372 d_template_args (di));
3373 else
3374 return name;
3375 }
eb7b5ddb
DD		 3376 else if ((peek == 'i' || peek == 't')
3377 && d_peek_next_char (di) == 'l')
3378 {
3379 /* Brace-enclosed initializer list, untyped or typed. */
3380 struct demangle_component *type = NULL;
af03af8f 3381 d_advance (di, 2);
eb7b5ddb
DD		 3382 if (peek == 't')
3383 type = cplus_demangle_type (di);
f211b8c0 3384 if (!d_peek_char (di) || !d_peek_next_char (di))
d81bf7dd 3385 return NULL;
eb7b5ddb
DD		 3386 return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3387 type, d_exprlist (di, 'E'));
3388 }
d00edca5 3389 else
eb383413 3390 {
59727473 3391 struct demangle_component *op;
eb7b5ddb 3392 const char *code = NULL;
d00edca5 3393 int args;
eb383413 3394
d00edca5
DD		 3395 op = d_operator_name (di);
3396 if (op == NULL)
3397 return NULL;
eb383413 3398
59727473 3399 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
eb7b5ddb
DD		 3400 {
3401 code = op->u.s_operator.op->code;
3402 di->expansion += op->u.s_operator.op->len - 2;
3403 if (strcmp (code, "st") == 0)
3404 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3405 cplus_demangle_type (di));
3406 }
eb383413 3407
d00edca5
DD		 3408 switch (op->type)
3409 {
3410 default:
3411 return NULL;
59727473 3412 case DEMANGLE_COMPONENT_OPERATOR:
d00edca5
DD		 3413 args = op->u.s_operator.op->args;
3414 break;
59727473 3415 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
d00edca5
DD		 3416 args = op->u.s_extended_operator.args;
3417 break;
59727473 3418 case DEMANGLE_COMPONENT_CAST:
60cf58f5 3419 args = 1;
d00edca5
DD		 3420 break;
3421 }
3422
3423 switch (args)
3424 {
eb7b5ddb
DD		 3425 case 0:
3426 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3427
d00edca5 3428 case 1:
c743cf5d
DD		 3429 {
3430 struct demangle_component *operand;
eb7b5ddb
DD		 3431 int suffix = 0;
3432
3433 if (code && (code[0] == 'p' || code[0] == 'm')
3434 && code[1] == code[0])
3435 /* pp_ and mm_ are the prefix variants. */
3436 suffix = !d_check_char (di, '_');
3437
c743cf5d
DD		 3438 if (op->type == DEMANGLE_COMPONENT_CAST
3439 && d_check_char (di, '_'))
eb7b5ddb 3440 operand = d_exprlist (di, 'E');
fa3fcee7
NC		 3441 else if (code && !strcmp (code, "sP"))
3442 operand = d_template_args_1 (di);
c743cf5d 3443 else
492e19d0 3444 operand = d_expression_1 (di);
eb7b5ddb
DD		 3445
3446 if (suffix)
3447 /* Indicate the suffix variant for d_print_comp. */
2a8ae714
NC		 3448 operand = d_make_comp (di, DEMANGLE_COMPONENT_BINARY_ARGS,
3449 operand, operand);
3450
3451 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op, operand);
c743cf5d 3452 }
d00edca5
DD		 3453 case 2:
3454 {
59727473 3455 struct demangle_component *left;
ba8cb4ba 3456 struct demangle_component *right;
d00edca5 3457
d81bf7dd
MM		 3458 if (code == NULL)
3459 return NULL;
7c328963
DD		 3460 if (op_is_new_cast (op))
3461 left = cplus_demangle_type (di);
fa3fcee7
NC		 3462 else if (code[0] == 'f')
3463 /* fold-expression. */
3464 left = d_operator_name (di);
7ade7fba
AM		 3465 else if (!strcmp (code, "di"))
3466 left = d_unqualified_name (di);
7c328963 3467 else
492e19d0 3468 left = d_expression_1 (di);
cbc43128 3469 if (!strcmp (code, "cl"))
eb7b5ddb 3470 right = d_exprlist (di, 'E');
cbc43128
DD		 3471 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3472 {
3473 right = d_unqualified_name (di);
3474 if (d_peek_char (di) == 'I')
3475 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3476 right, d_template_args (di));
3477 }
ba8cb4ba 3478 else
492e19d0 3479 right = d_expression_1 (di);
ba8cb4ba 3480
59727473
DD		 3481 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3482 d_make_comp (di,
3483 DEMANGLE_COMPONENT_BINARY_ARGS,
ba8cb4ba 3484 left, right));
d00edca5
DD		 3485 }
3486 case 3:
3487 {
59727473
DD		 3488 struct demangle_component *first;
3489 struct demangle_component *second;
eb7b5ddb 3490 struct demangle_component *third;
d00edca5 3491
d81bf7dd
MM		 3492 if (code == NULL)
3493 return NULL;
7ade7fba
AM		 3494 else if (!strcmp (code, "qu")
3495 || !strcmp (code, "dX"))
eb7b5ddb
DD		 3496 {
3497 /* ?: expression. */
492e19d0 3498 first = d_expression_1 (di);
3499 second = d_expression_1 (di);
3500 third = d_expression_1 (di);
ddc5804e
MW		 3501 if (third == NULL)
3502 return NULL;
eb7b5ddb 3503 }
fa3fcee7
NC		 3504 else if (code[0] == 'f')
3505 {
3506 /* fold-expression. */
3507 first = d_operator_name (di);
3508 second = d_expression_1 (di);
3509 third = d_expression_1 (di);
ddc5804e
MW		 3510 if (third == NULL)
3511 return NULL;
fa3fcee7 3512 }
eb7b5ddb
DD		 3513 else if (code[0] == 'n')
3514 {
3515 /* new-expression. */
3516 if (code[1] != 'w' && code[1] != 'a')
3517 return NULL;
3518 first = d_exprlist (di, '_');
3519 second = cplus_demangle_type (di);
3520 if (d_peek_char (di) == 'E')
3521 {
3522 d_advance (di, 1);
3523 third = NULL;
3524 }
3525 else if (d_peek_char (di) == 'p'
3526 && d_peek_next_char (di) == 'i')
3527 {
3528 /* Parenthesized initializer. */
3529 d_advance (di, 2);
3530 third = d_exprlist (di, 'E');
3531 }
3532 else if (d_peek_char (di) == 'i'
3533 && d_peek_next_char (di) == 'l')
3534 /* initializer-list. */
492e19d0 3535 third = d_expression_1 (di);
eb7b5ddb
DD		 3536 else
3537 return NULL;
3538 }
3539 else
3540 return NULL;
59727473
DD		 3541 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3542 d_make_comp (di,
3543 DEMANGLE_COMPONENT_TRINARY_ARG1,
3544 first,
d00edca5 3545 d_make_comp (di,
59727473 3546 DEMANGLE_COMPONENT_TRINARY_ARG2,
eb7b5ddb 3547 second, third)));
d00edca5
DD		 3548 }
3549 default:
3550 return NULL;
3551 }
eb383413
L		 3552 }
3553}
3554
492e19d0 3555static struct demangle_component *
3556d_expression (struct d_info *di)
3557{
3558 struct demangle_component *ret;
3559 int was_expression = di->is_expression;
3560
3561 di->is_expression = 1;
3562 ret = d_expression_1 (di);
3563 di->is_expression = was_expression;
3564 return ret;
3565}
3566
d00edca5
DD		 3567/* <expr-primary> ::= L <type> <(value) number> E
3568 ::= L <type> <(value) float> E
3569 ::= L <mangled-name> E
3570*/
74bcd529 3571
59727473 3572static struct demangle_component *
9334f9c6 3573d_expr_primary (struct d_info *di)
74bcd529 3574{
59727473 3575 struct demangle_component *ret;
74bcd529 3576
6ef6358e 3577 if (! d_check_char (di, 'L'))
d00edca5 3578 return NULL;
c743cf5d
DD		 3579 if (d_peek_char (di) == '_'
3580 /* Workaround for G++ bug; see comment in write_template_arg. */
3581 || d_peek_char (di) == 'Z')
59727473 3582 ret = cplus_demangle_mangled_name (di, 0);
d00edca5 3583 else
74bcd529 3584 {
59727473
DD		 3585 struct demangle_component *type;
3586 enum demangle_component_type t;
d00edca5
DD		 3587 const char *s;
3588
59727473 3589 type = cplus_demangle_type (di);
a21da8bf
DD		 3590 if (type == NULL)
3591 return NULL;
d00edca5 3592
b6fb00c0
DD		 3593 /* If we have a type we know how to print, we aren't going to
3594 print the type name itself. */
59727473 3595 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
b6fb00c0
DD		 3596 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3597 di->expansion -= type->u.s_builtin.type->len;
3598
533da483
NC		 3599 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3600 && strcmp (type->u.s_builtin.type->name,
3601 cplus_demangle_builtin_types[33].name) == 0)
3602 {
3603 if (d_peek_char (di) == 'E')
3604 {
3605 d_advance (di, 1);
3606 return type;
3607 }
3608 }
3609
d00edca5
DD		 3610 /* Rather than try to interpret the literal value, we just
3611 collect it as a string. Note that it's possible to have a
3612 floating point literal here. The ABI specifies that the
3613 format of such literals is machine independent. That's fine,
3614 but what's not fine is that versions of g++ up to 3.2 with
3615 -fabi-version=1 used upper case letters in the hex constant,
3616 and dumped out gcc's internal representation. That makes it
3617 hard to tell where the constant ends, and hard to dump the
3618 constant in any readable form anyhow. We don't attempt to
3619 handle these cases. */
3620
59727473 3621 t = DEMANGLE_COMPONENT_LITERAL;
97ceaf5b
DD		 3622 if (d_peek_char (di) == 'n')
3623 {
59727473 3624 t = DEMANGLE_COMPONENT_LITERAL_NEG;
97ceaf5b
DD		 3625 d_advance (di, 1);
3626 }
d00edca5
DD		 3627 s = d_str (di);
3628 while (d_peek_char (di) != 'E')
6ba85b8c
DD		 3629 {
3630 if (d_peek_char (di) == '\0')
3631 return NULL;
3632 d_advance (di, 1);
3633 }
97ceaf5b 3634 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
d00edca5 3635 }
6ef6358e 3636 if (! d_check_char (di, 'E'))
d00edca5
DD		 3637 return NULL;
3638 return ret;
74bcd529
DD		 3639}
3640
d00edca5
DD		 3641/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3642 ::= Z <(function) encoding> E s [<discriminator>]
a9c3ecea 3643 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
d00edca5 3644*/
74bcd529 3645
59727473 3646static struct demangle_component *
2a8ae714 3647d_local_name (struct d_info *di)
74bcd529 3648{
59727473 3649 struct demangle_component *function;
26a67918 3650 struct demangle_component *name;
74bcd529 3651
6ef6358e 3652 if (! d_check_char (di, 'Z'))
d00edca5 3653 return NULL;
74bcd529 3654
6d95373e 3655 function = d_encoding (di, 0);
2a8ae714
NC		 3656 if (!function)
3657 return NULL;
74bcd529 3658
6ef6358e 3659 if (! d_check_char (di, 'E'))
d00edca5 3660 return NULL;
74bcd529 3661
d00edca5 3662 if (d_peek_char (di) == 's')
74bcd529 3663 {
d00edca5
DD		 3664 d_advance (di, 1);
3665 if (! d_discriminator (di))
3666 return NULL;
26a67918 3667 name = d_make_name (di, "string literal", sizeof "string literal" - 1);
74bcd529 3668 }
d00edca5 3669 else
74bcd529 3670 {
664aa91f
DD		 3671 int num = -1;
3672
3673 if (d_peek_char (di) == 'd')
3674 {
3675 /* Default argument scope: d <number> _. */
3676 d_advance (di, 1);
3677 num = d_compact_number (di);
3678 if (num < 0)
3679 return NULL;
3680 }
74bcd529 3681
2a8ae714 3682 name = d_name (di);
26a67918
PA		 3683
3684 if (name
3685 /* Lambdas and unnamed types have internal discriminators
3686 and are not functions. */
3687 && name->type != DEMANGLE_COMPONENT_LAMBDA
3688 && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE)
3689 {
26a67918
PA		 3690 /* Read and ignore an optional discriminator. */
3691 if (! d_discriminator (di))
3692 return NULL;
3693 }
3694
664aa91f
DD		 3695 if (num >= 0)
3696 name = d_make_default_arg (di, num, name);
74bcd529 3697 }
26a67918 3698
2a8ae714
NC		 3699 /* Elide the return type of the containing function so as to not
3700 confuse the user thinking it is the return type of whatever local
3701 function we might be containing. */
3702 if (function->type == DEMANGLE_COMPONENT_TYPED_NAME
3703 && d_right (function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3704 d_left (d_right (function)) = NULL;
3705
26a67918 3706 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
74bcd529
DD		 3707}
3708
134e805d
NC		 3709/* <discriminator> ::= _ <number> # when number < 10
3710 ::= __ <number> _ # when number >= 10
3711
3712 <discriminator> ::= _ <number> # when number >=10
3713 is also accepted to support gcc versions that wrongly mangled that way.
eb383413 3714
d00edca5
DD		 3715 We demangle the discriminator, but we don't print it out. FIXME:
3716 We should print it out in verbose mode. */
74bcd529 3717
d00edca5 3718static int
9334f9c6 3719d_discriminator (struct d_info *di)
d00edca5 3720{
134e805d 3721 int discrim, num_underscores = 1;
74bcd529 3722
d00edca5
DD		 3723 if (d_peek_char (di) != '_')
3724 return 1;
3725 d_advance (di, 1);
134e805d
NC		 3726 if (d_peek_char (di) == '_')
3727 {
3728 ++num_underscores;
3729 d_advance (di, 1);
3730 }
3731
d00edca5
DD		 3732 discrim = d_number (di);
3733 if (discrim < 0)
3734 return 0;
134e805d
NC		 3735 if (num_underscores > 1 && discrim >= 10)
3736 {
3737 if (d_peek_char (di) == '_')
3738 d_advance (di, 1);
3739 else
3740 return 0;
3741 }
3742
d00edca5
DD		 3743 return 1;
3744}
eb383413 3745
664aa91f
DD		 3746/* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3747
3748static struct demangle_component *
3749d_lambda (struct d_info *di)
3750{
3751 struct demangle_component *tl;
3752 struct demangle_component *ret;
3753 int num;
3754
3755 if (! d_check_char (di, 'U'))
3756 return NULL;
3757 if (! d_check_char (di, 'l'))
3758 return NULL;
3759
3760 tl = d_parmlist (di);
3761 if (tl == NULL)
3762 return NULL;
3763
3764 if (! d_check_char (di, 'E'))
3765 return NULL;
3766
3767 num = d_compact_number (di);
3768 if (num < 0)
3769 return NULL;
3770
3771 ret = d_make_empty (di);
3772 if (ret)
3773 {
3774 ret->type = DEMANGLE_COMPONENT_LAMBDA;
3775 ret->u.s_unary_num.sub = tl;
3776 ret->u.s_unary_num.num = num;
3777 }
3778
664aa91f
DD		 3779 return ret;
3780}
3781
3782/* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3783
3784static struct demangle_component *
3785d_unnamed_type (struct d_info *di)
3786{
3787 struct demangle_component *ret;
fa3fcee7 3788 int num;
664aa91f
DD		 3789
3790 if (! d_check_char (di, 'U'))
3791 return NULL;
3792 if (! d_check_char (di, 't'))
3793 return NULL;
3794
3795 num = d_compact_number (di);
3796 if (num < 0)
3797 return NULL;
3798
3799 ret = d_make_empty (di);
3800 if (ret)
3801 {
3802 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3803 ret->u.s_number.number = num;
3804 }
3805
3806 if (! d_add_substitution (di, ret))
3807 return NULL;
3808
3809 return ret;
3810}
3811
7955ede5
DD		 3812/* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3813*/
3814
3815static struct demangle_component *
3816d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3817{
3818 const char *suffix = d_str (di);
3819 const char *pend = suffix;
3820 struct demangle_component *n;
3821
3822 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3823 {
3824 pend += 2;
3825 while (IS_LOWER (*pend) || *pend == '_')
3826 ++pend;
3827 }
3828 while (*pend == '.' && IS_DIGIT (pend[1]))
3829 {
3830 pend += 2;
3831 while (IS_DIGIT (*pend))
3832 ++pend;
3833 }
3834 d_advance (di, pend - suffix);
3835 n = d_make_name (di, suffix, pend - suffix);
3836 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3837}
3838
d00edca5 3839/* Add a new substitution. */
eb383413 3840
d00edca5 3841static int
9334f9c6 3842d_add_substitution (struct d_info *di, struct demangle_component *dc)
eb383413 3843{
331c3da2
DD		 3844 if (dc == NULL)
3845 return 0;
d00edca5
DD		 3846 if (di->next_sub >= di->num_subs)
3847 return 0;
3848 di->subs[di->next_sub] = dc;
3849 ++di->next_sub;
3850 return 1;
3851}
3852
3853/* <substitution> ::= S <seq-id> _
3854 ::= S_
3855 ::= St
3856 ::= Sa
3857 ::= Sb
3858 ::= Ss
3859 ::= Si
3860 ::= So
3861 ::= Sd
97ceaf5b
DD		 3862
3863 If PREFIX is non-zero, then this type is being used as a prefix in
3864 a qualified name. In this case, for the standard substitutions, we
3865 need to check whether we are being used as a prefix for a
3866 constructor or destructor, and return a full template name.
3867 Otherwise we will get something like std::iostream::~iostream()
3868 which does not correspond particularly well to any function which
3869 actually appears in the source.
d00edca5 3870*/
eb383413 3871
97ceaf5b
DD		 3872static const struct d_standard_sub_info standard_subs[] =
3873{
b6fb00c0
DD		 3874 { 't', NL ("std"),
3875 NL ("std"),
3876 NULL, 0 },
3877 { 'a', NL ("std::allocator"),
3878 NL ("std::allocator"),
3879 NL ("allocator") },
3880 { 'b', NL ("std::basic_string"),
3881 NL ("std::basic_string"),
3882 NL ("basic_string") },
3883 { 's', NL ("std::string"),
3884 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3885 NL ("basic_string") },
3886 { 'i', NL ("std::istream"),
3887 NL ("std::basic_istream<char, std::char_traits<char> >"),
3888 NL ("basic_istream") },
3889 { 'o', NL ("std::ostream"),
3890 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3891 NL ("basic_ostream") },
3892 { 'd', NL ("std::iostream"),
3893 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3894 NL ("basic_iostream") }
97ceaf5b
DD		 3895};
3896
59727473 3897static struct demangle_component *
9334f9c6 3898d_substitution (struct d_info *di, int prefix)
d00edca5
DD		 3899{
3900 char c;
eb383413 3901
6ef6358e 3902 if (! d_check_char (di, 'S'))
d00edca5 3903 return NULL;
e7e9b069 3904
d00edca5 3905 c = d_next_char (di);
858b45cf 3906 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
eb383413 3907 {
dddc49b7 3908 unsigned int id;
eb383413 3909
d00edca5
DD		 3910 id = 0;
3911 if (c != '_')
eb383413 3912 {
d00edca5 3913 do
eb383413 3914 {
dddc49b7
DD		 3915 unsigned int new_id;
3916
d00edca5 3917 if (IS_DIGIT (c))
dddc49b7 3918 new_id = id * 36 + c - '0';
858b45cf 3919 else if (IS_UPPER (c))
dddc49b7 3920 new_id = id * 36 + c - 'A' + 10;
d00edca5
DD		 3921 else
3922 return NULL;
dddc49b7 3923 if (new_id < id)
e63f184e 3924 return NULL;
dddc49b7 3925 id = new_id;
d00edca5 3926 c = d_next_char (di);
eb383413 3927 }
d00edca5 3928 while (c != '_');
eb383413 3929
d00edca5 3930 ++id;
eb383413 3931 }
eb383413 3932
dddc49b7 3933 if (id >= (unsigned int) di->next_sub)
d00edca5 3934 return NULL;
eb383413 3935
d00edca5 3936 return di->subs[id];
eb383413 3937 }
d00edca5 3938 else
eb383413 3939 {
97ceaf5b
DD		 3940 int verbose;
3941 const struct d_standard_sub_info *p;
3942 const struct d_standard_sub_info *pend;
3943
3944 verbose = (di->options & DMGL_VERBOSE) != 0;
3945 if (! verbose && prefix)
e61231f1 3946 {
97ceaf5b
DD		 3947 char peek;
3948
3949 peek = d_peek_char (di);
3950 if (peek == 'C' || peek == 'D')
3951 verbose = 1;
eb383413 3952 }
97ceaf5b
DD		 3953
3954 pend = (&standard_subs[0]
3955 + sizeof standard_subs / sizeof standard_subs[0]);
3956 for (p = &standard_subs[0]; p < pend; ++p)
3957 {
3958 if (c == p->code)
3959 {
b6fb00c0
DD		 3960 const char *s;
3961 int len;
41f225de 3962 struct demangle_component *dc;
b6fb00c0 3963
97ceaf5b 3964 if (p->set_last_name != NULL)
b6fb00c0
DD		 3965 di->last_name = d_make_sub (di, p->set_last_name,
3966 p->set_last_name_len);
97ceaf5b 3967 if (verbose)
b6fb00c0
DD		 3968 {
3969 s = p->full_expansion;
3970 len = p->full_len;
3971 }
97ceaf5b 3972 else
b6fb00c0
DD		 3973 {
3974 s = p->simple_expansion;
3975 len = p->simple_len;
3976 }
3977 di->expansion += len;
41f225de 3978 dc = d_make_sub (di, s, len);
b55f9678
IB		 3979 if (d_peek_char (di) == 'B')
3980 {
3981 /* If there are ABI tags on the abbreviation, it becomes
3982 a substitution candidate. */
41f225de 3983 dc = d_abi_tags (di, dc);
2d3392bd
IB		 3984 if (! d_add_substitution (di, dc))
3985 return NULL;
b55f9678 3986 }
41f225de 3987 return dc;
97ceaf5b
DD		 3988 }
3989 }
3990
3991 return NULL;
eb383413 3992 }
eb383413
L		 3993}
3994
492e19d0 3995static void
3996d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
3997{
3998 checkpoint->n = di->n;
3999 checkpoint->next_comp = di->next_comp;
4000 checkpoint->next_sub = di->next_sub;
492e19d0 4001 checkpoint->expansion = di->expansion;
4002}
4003
4004static void
4005d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
4006{
4007 di->n = checkpoint->n;
4008 di->next_comp = checkpoint->next_comp;
4009 di->next_sub = checkpoint->next_sub;
492e19d0 4010 di->expansion = checkpoint->expansion;
4011}
4012
208c1674 4013/* Initialize a growable string. */
eb383413 4014
d00edca5 4015static void
208c1674 4016d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
d00edca5 4017{
208c1674
DD		 4018 dgs->buf = NULL;
4019 dgs->len = 0;
4020 dgs->alc = 0;
4021 dgs->allocation_failure = 0;
eb383413 4022
208c1674
DD		 4023 if (estimate > 0)
4024 d_growable_string_resize (dgs, estimate);
4025}
4026
4027/* Grow a growable string to a given size. */
4028
4029static inline void
4030d_growable_string_resize (struct d_growable_string *dgs, size_t need)
4031{
4032 size_t newalc;
4033 char *newbuf;
4034
4035 if (dgs->allocation_failure)
331c3da2 4036 return;
59666b35 4037
208c1674
DD		 4038 /* Start allocation at two bytes to avoid any possibility of confusion
4039 with the special value of 1 used as a return in *palc to indicate
4040 allocation failures. */
4041 newalc = dgs->alc > 0 ? dgs->alc : 2;
4042 while (newalc < need)
4043 newalc <<= 1;
4044
4045 newbuf = (char *) realloc (dgs->buf, newalc);
4046 if (newbuf == NULL)
4047 {
4048 free (dgs->buf);
4049 dgs->buf = NULL;
4050 dgs->len = 0;
4051 dgs->alc = 0;
4052 dgs->allocation_failure = 1;
4053 return;
eb383413 4054 }
208c1674
DD		 4055 dgs->buf = newbuf;
4056 dgs->alc = newalc;
d00edca5 4057}
0976f6a7 4058
208c1674 4059/* Append a buffer to a growable string. */
0976f6a7 4060
208c1674
DD		 4061static inline void
4062d_growable_string_append_buffer (struct d_growable_string *dgs,
4063 const char *s, size_t l)
d00edca5 4064{
208c1674 4065 size_t need;
0976f6a7 4066
208c1674
DD		 4067 need = dgs->len + l + 1;
4068 if (need > dgs->alc)
4069 d_growable_string_resize (dgs, need);
4070
4071 if (dgs->allocation_failure)
4072 return;
4073
4074 memcpy (dgs->buf + dgs->len, s, l);
4075 dgs->buf[dgs->len + l] = '\0';
4076 dgs->len += l;
eb383413
L		 4077}
4078
208c1674 4079/* Bridge growable strings to the callback mechanism. */
d00edca5
DD		 4080
4081static void
208c1674 4082d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
eb383413 4083{
208c1674 4084 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
eb383413 4085
208c1674 4086 d_growable_string_append_buffer (dgs, s, l);
eb383413
L		 4087}
4088
fd259167
GB		 4089/* Walk the tree, counting the number of templates encountered, and
4090 the number of times a scope might be saved. These counts will be
4091 used to allocate data structures for d_print_comp, so the logic
4092 here must mirror the logic d_print_comp will use. It is not
4093 important that the resulting numbers are exact, so long as they
4094 are larger than the actual numbers encountered. */
4095
4096static void
c1202057 4097d_count_templates_scopes (struct d_print_info *dpi,
533da483 4098 struct demangle_component *dc)
fd259167 4099{
533da483 4100 if (dc == NULL || dc->d_counting > 1 || dpi->recursion > MAX_RECURSION_COUNT)
fd259167
GB		 4101 return;
4102
533da483
NC		 4103 ++ dc->d_counting;
4104
fd259167
GB		 4105 switch (dc->type)
4106 {
4107 case DEMANGLE_COMPONENT_NAME:
4108 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4109 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4110 case DEMANGLE_COMPONENT_SUB_STD:
4111 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4112 case DEMANGLE_COMPONENT_OPERATOR:
4113 case DEMANGLE_COMPONENT_CHARACTER:
4114 case DEMANGLE_COMPONENT_NUMBER:
4115 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4116 break;
4117
4118 case DEMANGLE_COMPONENT_TEMPLATE:
c1202057 4119 dpi->num_copy_templates++;
fd259167
GB		 4120 goto recurse_left_right;
4121
4122 case DEMANGLE_COMPONENT_REFERENCE:
4123 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4124 if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
c1202057 4125 dpi->num_saved_scopes++;
fd259167
GB		 4126 goto recurse_left_right;
4127
4128 case DEMANGLE_COMPONENT_QUAL_NAME:
4129 case DEMANGLE_COMPONENT_LOCAL_NAME:
4130 case DEMANGLE_COMPONENT_TYPED_NAME:
4131 case DEMANGLE_COMPONENT_VTABLE:
4132 case DEMANGLE_COMPONENT_VTT:
4133 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4134 case DEMANGLE_COMPONENT_TYPEINFO:
4135 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4136 case DEMANGLE_COMPONENT_TYPEINFO_FN:
4137 case DEMANGLE_COMPONENT_THUNK:
4138 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4139 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4140 case DEMANGLE_COMPONENT_JAVA_CLASS:
4141 case DEMANGLE_COMPONENT_GUARD:
4142 case DEMANGLE_COMPONENT_TLS_INIT:
4143 case DEMANGLE_COMPONENT_TLS_WRAPPER:
4144 case DEMANGLE_COMPONENT_REFTEMP:
4145 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4146 case DEMANGLE_COMPONENT_RESTRICT:
4147 case DEMANGLE_COMPONENT_VOLATILE:
4148 case DEMANGLE_COMPONENT_CONST:
4149 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4150 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4151 case DEMANGLE_COMPONENT_CONST_THIS:
4152 case DEMANGLE_COMPONENT_REFERENCE_THIS:
4153 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
e9a38816 4154 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
a4ddf8dc
JM		 4155 case DEMANGLE_COMPONENT_NOEXCEPT:
4156 case DEMANGLE_COMPONENT_THROW_SPEC:
fd259167
GB		 4157 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4158 case DEMANGLE_COMPONENT_POINTER:
4159 case DEMANGLE_COMPONENT_COMPLEX:
4160 case DEMANGLE_COMPONENT_IMAGINARY:
4161 case DEMANGLE_COMPONENT_VENDOR_TYPE:
4162 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4163 case DEMANGLE_COMPONENT_ARRAY_TYPE:
4164 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
fd259167
GB		 4165 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4166 case DEMANGLE_COMPONENT_ARGLIST:
4167 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
af03af8f 4168 case DEMANGLE_COMPONENT_TPARM_OBJ:
fd259167
GB		 4169 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4170 case DEMANGLE_COMPONENT_CAST:
c4be2641 4171 case DEMANGLE_COMPONENT_CONVERSION:
fd259167
GB		 4172 case DEMANGLE_COMPONENT_NULLARY:
4173 case DEMANGLE_COMPONENT_UNARY:
4174 case DEMANGLE_COMPONENT_BINARY:
4175 case DEMANGLE_COMPONENT_BINARY_ARGS:
4176 case DEMANGLE_COMPONENT_TRINARY:
4177 case DEMANGLE_COMPONENT_TRINARY_ARG1:
4178 case DEMANGLE_COMPONENT_TRINARY_ARG2:
4179 case DEMANGLE_COMPONENT_LITERAL:
4180 case DEMANGLE_COMPONENT_LITERAL_NEG:
4181 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4182 case DEMANGLE_COMPONENT_COMPOUND_NAME:
4183 case DEMANGLE_COMPONENT_DECLTYPE:
4184 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4185 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4186 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4187 case DEMANGLE_COMPONENT_TAGGED_NAME:
4188 case DEMANGLE_COMPONENT_CLONE:
4189 recurse_left_right:
c1202057
NC		 4190 /* PR 89394 - Check for too much recursion. */
4191 if (dpi->recursion > DEMANGLE_RECURSION_LIMIT)
4192 /* FIXME: There ought to be a way to report to the
4193 user that the recursion limit has been reached. */
4194 return;
4195
4196 ++ dpi->recursion;
4197 d_count_templates_scopes (dpi, d_left (dc));
4198 d_count_templates_scopes (dpi, d_right (dc));
4199 -- dpi->recursion;
fd259167
GB		 4200 break;
4201
4202 case DEMANGLE_COMPONENT_CTOR:
c1202057 4203 d_count_templates_scopes (dpi, dc->u.s_ctor.name);
fd259167
GB		 4204 break;
4205
4206 case DEMANGLE_COMPONENT_DTOR:
c1202057 4207 d_count_templates_scopes (dpi, dc->u.s_dtor.name);
fd259167
GB		 4208 break;
4209
4210 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
c1202057 4211 d_count_templates_scopes (dpi, dc->u.s_extended_operator.name);
fd259167
GB		 4212 break;
4213
b55f9678 4214 case DEMANGLE_COMPONENT_FIXED_TYPE:
c1202057 4215 d_count_templates_scopes (dpi, dc->u.s_fixed.length);
b55f9678
IB		 4216 break;
4217
fd259167
GB		 4218 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4219 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
c1202057 4220 d_count_templates_scopes (dpi, d_left (dc));
fd259167
GB		 4221 break;
4222
4223 case DEMANGLE_COMPONENT_LAMBDA:
4224 case DEMANGLE_COMPONENT_DEFAULT_ARG:
c1202057 4225 d_count_templates_scopes (dpi, dc->u.s_unary_num.sub);
fd259167
GB		 4226 break;
4227 }
4228}
4229
208c1674 4230/* Initialize a print information structure. */
eb383413 4231
d00edca5 4232static void
ddee5e46 4233d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
533da483 4234 void *opaque, struct demangle_component *dc)
208c1674 4235{
208c1674
DD		 4236 dpi->len = 0;
4237 dpi->last_char = '\0';
4238 dpi->templates = NULL;
4239 dpi->modifiers = NULL;
04aed652 4240 dpi->pack_index = 0;
3baae9d6 4241 dpi->flush_count = 0;
208c1674
DD		 4242
4243 dpi->callback = callback;
4244 dpi->opaque = opaque;
4245
4246 dpi->demangle_failure = 0;
2d3392bd 4247 dpi->recursion = 0;
88acc2e1 4248 dpi->is_lambda_arg = 0;
9548bbed 4249
91662bad 4250 dpi->component_stack = NULL;
4251
9548bbed 4252 dpi->saved_scopes = NULL;
fd259167 4253 dpi->next_saved_scope = 0;
9548bbed 4254 dpi->num_saved_scopes = 0;
9548bbed 4255
fd259167
GB		 4256 dpi->copy_templates = NULL;
4257 dpi->next_copy_template = 0;
4258 dpi->num_copy_templates = 0;
9548bbed 4259
c1202057
NC		 4260 d_count_templates_scopes (dpi, dc);
4261 /* If we did not reach the recursion limit, then reset the
4262 current recursion value back to 0, so that we can print
4263 the templates. */
4264 if (dpi->recursion < DEMANGLE_RECURSION_LIMIT)
4265 dpi->recursion = 0;
fd259167 4266 dpi->num_copy_templates *= dpi->num_saved_scopes;
9548bbed 4267
fd259167 4268 dpi->current_template = NULL;
208c1674
DD		 4269}
4270
4271/* Indicate that an error occurred during printing, and test for error. */
4272
4273static inline void
9334f9c6 4274d_print_error (struct d_print_info *dpi)
bc9bf259 4275{
208c1674
DD		 4276 dpi->demangle_failure = 1;
4277}
4278
4279static inline int
4280d_print_saw_error (struct d_print_info *dpi)
4281{
4282 return dpi->demangle_failure != 0;
4283}
4284
4285/* Flush buffered characters to the callback. */
4286
4287static inline void
4288d_print_flush (struct d_print_info *dpi)
4289{
4290 dpi->buf[dpi->len] = '\0';
4291 dpi->callback (dpi->buf, dpi->len, dpi->opaque);
4292 dpi->len = 0;
3baae9d6 4293 dpi->flush_count++;
208c1674
DD		 4294}
4295
4296/* Append characters and buffers for printing. */
4297
4298static inline void
4299d_append_char (struct d_print_info *dpi, char c)
4300{
4301 if (dpi->len == sizeof (dpi->buf) - 1)
4302 d_print_flush (dpi);
4303
4304 dpi->buf[dpi->len++] = c;
4305 dpi->last_char = c;
4306}
4307
4308static inline void
4309d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4310{
4311 size_t i;
4312
4313 for (i = 0; i < l; i++)
4314 d_append_char (dpi, s[i]);
4315}
4316
4317static inline void
4318d_append_string (struct d_print_info *dpi, const char *s)
4319{
4320 d_append_buffer (dpi, s, strlen (s));
4321}
4322
664aa91f 4323static inline void
fa3fcee7 4324d_append_num (struct d_print_info *dpi, int l)
664aa91f
DD		 4325{
4326 char buf[25];
fa3fcee7 4327 sprintf (buf,"%d", l);
664aa91f
DD		 4328 d_append_string (dpi, buf);
4329}
4330
208c1674
DD		 4331static inline char
4332d_last_char (struct d_print_info *dpi)
4333{
4334 return dpi->last_char;
4335}
4336
4337/* Turn components into a human readable string. OPTIONS is the
4338 options bits passed to the demangler. DC is the tree to print.
4339 CALLBACK is a function to call to flush demangled string segments
4340 as they fill the intermediate buffer, and OPAQUE is a generalized
4341 callback argument. On success, this returns 1. On failure,
4342 it returns 0, indicating a bad parse. It does not use heap
4343 memory to build an output string, so cannot encounter memory
4344 allocation failure. */
4345
4346CP_STATIC_IF_GLIBCPP_V3
4347int
4348cplus_demangle_print_callback (int options,
c793cac1 4349 struct demangle_component *dc,
208c1674
DD		 4350 demangle_callbackref callback, void *opaque)
4351{
4352 struct d_print_info dpi;
4353
fd259167 4354 d_print_init (&dpi, callback, opaque, dc);
208c1674 4355
fd259167
GB		 4356 {
4357#ifdef CP_DYNAMIC_ARRAYS
fa3fcee7
NC		 4358 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4359 and flagged as errors by Address Sanitizer. */
4360 __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
4361 ? dpi.num_saved_scopes : 1];
4362 __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
4363 ? dpi.num_copy_templates : 1];
fd259167
GB		 4364
4365 dpi.saved_scopes = scopes;
4366 dpi.copy_templates = temps;
4367#else
4368 dpi.saved_scopes = alloca (dpi.num_saved_scopes
4369 * sizeof (*dpi.saved_scopes));
4370 dpi.copy_templates = alloca (dpi.num_copy_templates
4371 * sizeof (*dpi.copy_templates));
4372#endif
4373
4374 d_print_comp (&dpi, options, dc);
4375 }
208c1674
DD		 4376
4377 d_print_flush (&dpi);
4378
fd259167 4379 return ! d_print_saw_error (&dpi);
d00edca5 4380}
bc9bf259 4381
b6fb00c0
DD		 4382/* Turn components into a human readable string. OPTIONS is the
4383 options bits passed to the demangler. DC is the tree to print.
4384 ESTIMATE is a guess at the length of the result. This returns a
4385 string allocated by malloc, or NULL on error. On success, this
4386 sets *PALC to the size of the allocated buffer. On failure, this
4387 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4388 failure. */
eb383413 4389
59727473
DD		 4390CP_STATIC_IF_GLIBCPP_V3
4391char *
c793cac1 4392cplus_demangle_print (int options, struct demangle_component *dc,
9334f9c6 4393 int estimate, size_t *palc)
d00edca5 4394{
208c1674 4395 struct d_growable_string dgs;
eb383413 4396
208c1674 4397 d_growable_string_init (&dgs, estimate);
eb383413 4398
208c1674
DD		 4399 if (! cplus_demangle_print_callback (options, dc,
4400 d_growable_string_callback_adapter,
4401 &dgs))
eb383413 4402 {
208c1674
DD		 4403 free (dgs.buf);
4404 *palc = 0;
d00edca5 4405 return NULL;
eb383413 4406 }
eb383413 4407
208c1674
DD		 4408 *palc = dgs.allocation_failure ? 1 : dgs.alc;
4409 return dgs.buf;
eb383413
L		 4410}
4411
1c08f2c8 4412/* Returns the I'th element of the template arglist ARGS, or NULL on
fa3fcee7 4413 failure. If I is negative, return the entire arglist. */
1c08f2c8
DD		 4414
4415static struct demangle_component *
4416d_index_template_argument (struct demangle_component *args, int i)
4417{
4418 struct demangle_component *a;
4419
fa3fcee7
NC		 4420 if (i < 0)
4421 /* Print the whole argument pack. */
4422 return args;
4423
1c08f2c8
DD		 4424 for (a = args;
4425 a != NULL;
4426 a = d_right (a))
4427 {
4428 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4429 return NULL;
4430 if (i <= 0)
4431 break;
4432 --i;
4433 }
4434 if (i != 0 || a == NULL)
4435 return NULL;
4436
4437 return d_left (a);
4438}
4439
4440/* Returns the template argument from the current context indicated by DC,
4441 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4442
4443static struct demangle_component *
4444d_lookup_template_argument (struct d_print_info *dpi,
4445 const struct demangle_component *dc)
4446{
4447 if (dpi->templates == NULL)
4448 {
4449 d_print_error (dpi);
4450 return NULL;
4451 }
4452
4453 return d_index_template_argument
4454 (d_right (dpi->templates->template_decl),
4455 dc->u.s_number.number);
4456}
4457
4458/* Returns a template argument pack used in DC (any will do), or NULL. */
4459
4460static struct demangle_component *
4461d_find_pack (struct d_print_info *dpi,
4462 const struct demangle_component *dc)
4463{
4464 struct demangle_component *a;
4465 if (dc == NULL)
4466 return NULL;
4467
4468 switch (dc->type)
4469 {
4470 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4471 a = d_lookup_template_argument (dpi, dc);
4472 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4473 return a;
4474 return NULL;
4475
4476 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4477 return NULL;
4478
57cf60a5 4479 case DEMANGLE_COMPONENT_LAMBDA:
1c08f2c8 4480 case DEMANGLE_COMPONENT_NAME:
1f3de044 4481 case DEMANGLE_COMPONENT_TAGGED_NAME:
1c08f2c8
DD		 4482 case DEMANGLE_COMPONENT_OPERATOR:
4483 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4484 case DEMANGLE_COMPONENT_SUB_STD:
4485 case DEMANGLE_COMPONENT_CHARACTER:
e2e1864d 4486 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
67bf71fe 4487 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
d81bf7dd
MM		 4488 case DEMANGLE_COMPONENT_FIXED_TYPE:
4489 case DEMANGLE_COMPONENT_DEFAULT_ARG:
4490 case DEMANGLE_COMPONENT_NUMBER:
1c08f2c8
DD		 4491 return NULL;
4492
4493 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4494 return d_find_pack (dpi, dc->u.s_extended_operator.name);
4495 case DEMANGLE_COMPONENT_CTOR:
4496 return d_find_pack (dpi, dc->u.s_ctor.name);
4497 case DEMANGLE_COMPONENT_DTOR:
4498 return d_find_pack (dpi, dc->u.s_dtor.name);
4499
4500 default:
4501 a = d_find_pack (dpi, d_left (dc));
4502 if (a)
4503 return a;
4504 return d_find_pack (dpi, d_right (dc));
4505 }
4506}
4507
4508/* Returns the length of the template argument pack DC. */
4509
4510static int
4511d_pack_length (const struct demangle_component *dc)
4512{
4513 int count = 0;
4514 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4515 && d_left (dc) != NULL)
4516 {
4517 ++count;
4518 dc = d_right (dc);
4519 }
4520 return count;
4521}
4522
fa3fcee7
NC		 4523/* Returns the number of template args in DC, expanding any pack expansions
4524 found there. */
4525
4526static int
4527d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4528{
4529 int count = 0;
4530 for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
4531 dc = d_right (dc))
4532 {
4533 struct demangle_component *elt = d_left (dc);
4534 if (elt == NULL)
4535 break;
4536 if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
4537 {
4538 struct demangle_component *a = d_find_pack (dpi, d_left (elt));
4539 count += d_pack_length (a);
4540 }
4541 else
4542 ++count;
4543 }
4544 return count;
4545}
4546
1c08f2c8
DD		 4547/* DC is a component of a mangled expression. Print it, wrapped in parens
4548 if needed. */
4549
4550static void
ddee5e46 4551d_print_subexpr (struct d_print_info *dpi, int options,
c793cac1 4552 struct demangle_component *dc)
1c08f2c8
DD		 4553{
4554 int simple = 0;
e2e1864d 4555 if (dc->type == DEMANGLE_COMPONENT_NAME
eb7b5ddb
DD		 4556 || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4557 || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
e2e1864d 4558 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
1c08f2c8
DD		 4559 simple = 1;
4560 if (!simple)
4561 d_append_char (dpi, '(');
ddee5e46 4562 d_print_comp (dpi, options, dc);
1c08f2c8
DD		 4563 if (!simple)
4564 d_append_char (dpi, ')');
4565}
4566
fd259167 4567/* Save the current scope. */
9548bbed 4568
fd259167
GB		 4569static void
4570d_save_scope (struct d_print_info *dpi,
4571 const struct demangle_component *container)
9548bbed 4572{
fd259167
GB		 4573 struct d_saved_scope *scope;
4574 struct d_print_template *src, **link;
4575
4576 if (dpi->next_saved_scope >= dpi->num_saved_scopes)
4577 {
4578 d_print_error (dpi);
4579 return;
4580 }
4581 scope = &dpi->saved_scopes[dpi->next_saved_scope];
4582 dpi->next_saved_scope++;
4583
4584 scope->container = container;
4585 link = &scope->templates;
9548bbed 4586
4587 for (src = dpi->templates; src != NULL; src = src->next)
4588 {
fd259167 4589 struct d_print_template *dst;
9548bbed 4590
fd259167 4591 if (dpi->next_copy_template >= dpi->num_copy_templates)
9548bbed 4592 {
4593 d_print_error (dpi);
fd259167 4594 return;
9548bbed 4595 }
fd259167
GB		 4596 dst = &dpi->copy_templates[dpi->next_copy_template];
4597 dpi->next_copy_template++;
9548bbed 4598
4599 dst->template_decl = src->template_decl;
4600 *link = dst;
4601 link = &dst->next;
4602 }
4603
4604 *link = NULL;
fd259167
GB		 4605}
4606
4607/* Attempt to locate a previously saved scope. Returns NULL if no
4608 corresponding saved scope was found. */
4609
4610static struct d_saved_scope *
4611d_get_saved_scope (struct d_print_info *dpi,
4612 const struct demangle_component *container)
4613{
4614 int i;
4615
4616 for (i = 0; i < dpi->next_saved_scope; i++)
4617 if (dpi->saved_scopes[i].container == container)
4618 return &dpi->saved_scopes[i];
9548bbed 4619
fd259167 4620 return NULL;
9548bbed 4621}
4622
fa3fcee7
NC		 4623/* If DC is a C++17 fold-expression, print it and return true; otherwise
4624 return false. */
4625
4626static int
4627d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
c793cac1 4628 struct demangle_component *dc)
fa3fcee7 4629{
c793cac1 4630 struct demangle_component *ops, *operator_, *op1, *op2;
fa3fcee7
NC		 4631 int save_idx;
4632
4633 const char *fold_code = d_left (dc)->u.s_operator.op->code;
4634 if (fold_code[0] != 'f')
4635 return 0;
4636
4637 ops = d_right (dc);
4638 operator_ = d_left (ops);
4639 op1 = d_right (ops);
4640 op2 = 0;
4641 if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
4642 {
4643 op2 = d_right (op1);
4644 op1 = d_left (op1);
4645 }
4646
4647 /* Print the whole pack. */
4648 save_idx = dpi->pack_index;
4649 dpi->pack_index = -1;
4650
4651 switch (fold_code[1])
4652 {
4653 /* Unary left fold, (... + X). */
4654 case 'l':
4655 d_append_string (dpi, "(...");
4656 d_print_expr_op (dpi, options, operator_);
4657 d_print_subexpr (dpi, options, op1);
4658 d_append_char (dpi, ')');
4659 break;
4660
4661 /* Unary right fold, (X + ...). */
4662 case 'r':
4663 d_append_char (dpi, '(');
4664 d_print_subexpr (dpi, options, op1);
4665 d_print_expr_op (dpi, options, operator_);
4666 d_append_string (dpi, "...)");
4667 break;
4668
4669 /* Binary left fold, (42 + ... + X). */
4670 case 'L':
4671 /* Binary right fold, (X + ... + 42). */
4672 case 'R':
4673 d_append_char (dpi, '(');
4674 d_print_subexpr (dpi, options, op1);
4675 d_print_expr_op (dpi, options, operator_);
4676 d_append_string (dpi, "...");
4677 d_print_expr_op (dpi, options, operator_);
4678 d_print_subexpr (dpi, options, op2);
4679 d_append_char (dpi, ')');
4680 break;
4681 }
4682
4683 dpi->pack_index = save_idx;
4684 return 1;
4685}
4686
7ade7fba
AM		 4687/* True iff DC represents a C99-style designated initializer. */
4688
4689static int
4690is_designated_init (struct demangle_component *dc)
4691{
4692 if (dc->type != DEMANGLE_COMPONENT_BINARY
4693 && dc->type != DEMANGLE_COMPONENT_TRINARY)
4694 return 0;
4695
4696 struct demangle_component *op = d_left (dc);
4697 const char *code = op->u.s_operator.op->code;
4698 return (code[0] == 'd'
4699 && (code[1] == 'i' || code[1] == 'x' || code[1] == 'X'));
4700}
4701
4702/* If DC represents a C99-style designated initializer, print it and return
4703 true; otherwise, return false. */
4704
4705static int
4706d_maybe_print_designated_init (struct d_print_info *dpi, int options,
4707 struct demangle_component *dc)
4708{
4709 if (!is_designated_init (dc))
4710 return 0;
4711
4712 const char *code = d_left (dc)->u.s_operator.op->code;
4713
4714 struct demangle_component *operands = d_right (dc);
4715 struct demangle_component *op1 = d_left (operands);
4716 struct demangle_component *op2 = d_right (operands);
4717
4718 if (code[1] == 'i')
4719 d_append_char (dpi, '.');
4720 else
4721 d_append_char (dpi, '[');
4722
4723 d_print_comp (dpi, options, op1);
4724 if (code[1] == 'X')
4725 {
4726 d_append_string (dpi, " ... ");
4727 d_print_comp (dpi, options, d_left (op2));
4728 op2 = d_right (op2);
4729 }
4730 if (code[1] != 'i')
4731 d_append_char (dpi, ']');
4732 if (is_designated_init (op2))
4733 {
4734 /* Don't put '=' or '(' between chained designators. */
4735 d_print_comp (dpi, options, op2);
4736 }
4737 else
4738 {
4739 d_append_char (dpi, '=');
4740 d_print_subexpr (dpi, options, op2);
4741 }
4742 return 1;
4743}
4744
d00edca5 4745/* Subroutine to handle components. */
eb383413 4746
d00edca5 4747static void
91662bad 4748d_print_comp_inner (struct d_print_info *dpi, int options,
c793cac1 4749 struct demangle_component *dc)
eb383413 4750{
b24539b3
DD		 4751 /* Magic variable to let reference smashing skip over the next modifier
4752 without needing to modify *dc. */
c793cac1 4753 struct demangle_component *mod_inner = NULL;
b24539b3 4754
9548bbed 4755 /* Variable used to store the current templates while a previously
4756 captured scope is used. */
4757 struct d_print_template *saved_templates;
4758
4759 /* Nonzero if templates have been stored in the above variable. */
4760 int need_template_restore = 0;
4761
d00edca5 4762 if (dc == NULL)
eb383413 4763 {
d00edca5
DD		 4764 d_print_error (dpi);
4765 return;
eb383413 4766 }
d00edca5
DD		 4767 if (d_print_saw_error (dpi))
4768 return;
eb383413 4769
d00edca5 4770 switch (dc->type)
eb383413 4771 {
59727473 4772 case DEMANGLE_COMPONENT_NAME:
ddee5e46 4773 if ((options & DMGL_JAVA) == 0)
b6fb00c0
DD		 4774 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
4775 else
4776 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
d00edca5 4777 return;
eb383413 4778
1f3de044
DD		 4779 case DEMANGLE_COMPONENT_TAGGED_NAME:
4780 d_print_comp (dpi, options, d_left (dc));
4781 d_append_string (dpi, "[abi:");
4782 d_print_comp (dpi, options, d_right (dc));
4783 d_append_char (dpi, ']');
4784 return;
4785
59727473
DD		 4786 case DEMANGLE_COMPONENT_QUAL_NAME:
4787 case DEMANGLE_COMPONENT_LOCAL_NAME:
ddee5e46
DD		 4788 d_print_comp (dpi, options, d_left (dc));
4789 if ((options & DMGL_JAVA) == 0)
208c1674 4790 d_append_string (dpi, "::");
b6fb00c0
DD		 4791 else
4792 d_append_char (dpi, '.');
a9c3ecea
DD		 4793 {
4794 struct demangle_component *local_name = d_right (dc);
4795 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4796 {
4797 d_append_string (dpi, "{default arg#");
4798 d_append_num (dpi, local_name->u.s_unary_num.num + 1);
4799 d_append_string (dpi, "}::");
4800 local_name = local_name->u.s_unary_num.sub;
4801 }
4802 d_print_comp (dpi, options, local_name);
4803 }
d00edca5 4804 return;
eb383413 4805
59727473 4806 case DEMANGLE_COMPONENT_TYPED_NAME:
d00edca5 4807 {
858b45cf 4808 struct d_print_mod *hold_modifiers;
59727473 4809 struct demangle_component *typed_name;
858b45cf
DD		 4810 struct d_print_mod adpm[4];
4811 unsigned int i;
d00edca5
DD		 4812 struct d_print_template dpt;
4813
4814 /* Pass the name down to the type so that it can be printed in
858b45cf
DD		 4815 the right place for the type. We also have to pass down
4816 any CV-qualifiers, which apply to the this parameter. */
4817 hold_modifiers = dpi->modifiers;
c743cf5d 4818 dpi->modifiers = 0;
858b45cf 4819 i = 0;
d00edca5 4820 typed_name = d_left (dc);
858b45cf
DD		 4821 while (typed_name != NULL)
4822 {
4823 if (i >= sizeof adpm / sizeof adpm[0])
4824 {
4825 d_print_error (dpi);
4826 return;
4827 }
d00edca5 4828
858b45cf
DD		 4829 adpm[i].next = dpi->modifiers;
4830 dpi->modifiers = &adpm[i];
4831 adpm[i].mod = typed_name;
4832 adpm[i].printed = 0;
4833 adpm[i].templates = dpi->templates;
4834 ++i;
4835
a4ddf8dc 4836 if (!is_fnqual_component_type (typed_name->type))
858b45cf
DD		 4837 break;
4838
4839 typed_name = d_left (typed_name);
4840 }
d00edca5 4841
168b8298
MS		 4842 if (typed_name == NULL)
4843 {
4844 d_print_error (dpi);
4845 return;
4846 }
4847
59727473
DD		 4848 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4849 there may be CV-qualifiers on its right argument which
2a8ae714 4850 really apply here; this happens when parsing a class that
59727473
DD		 4851 is local to a function. */
4852 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
d4edd112 4853 {
2a8ae714
NC		 4854 typed_name = d_right (typed_name);
4855 if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4856 typed_name = typed_name->u.s_unary_num.sub;
f211b8c0
NC		 4857 while (typed_name != NULL
4858 && is_fnqual_component_type (typed_name->type))
d4edd112
DD		 4859 {
4860 if (i >= sizeof adpm / sizeof adpm[0])
4861 {
4862 d_print_error (dpi);
4863 return;
4864 }
4865
4866 adpm[i] = adpm[i - 1];
4867 adpm[i].next = &adpm[i - 1];
4868 dpi->modifiers = &adpm[i];
4869
2a8ae714 4870 adpm[i - 1].mod = typed_name;
d4edd112
DD		 4871 adpm[i - 1].printed = 0;
4872 adpm[i - 1].templates = dpi->templates;
4873 ++i;
4874
2a8ae714 4875 typed_name = d_left (typed_name);
d4edd112 4876 }
f211b8c0
NC		 4877 if (typed_name == NULL)
4878 {
4879 d_print_error (dpi);
4880 return;
4881 }
d4edd112
DD		 4882 }
4883
2a8ae714
NC		 4884 /* If typed_name is a template, then it applies to the
4885 function type as well. */
4886 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4887 {
4888 dpt.next = dpi->templates;
4889 dpi->templates = &dpt;
4890 dpt.template_decl = typed_name;
4891 }
4892
ddee5e46 4893 d_print_comp (dpi, options, d_right (dc));
74bcd529 4894
59727473 4895 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
d00edca5 4896 dpi->templates = dpt.next;
eb383413 4897
858b45cf 4898 /* If the modifiers didn't get printed by the type, print them
d00edca5 4899 now. */
858b45cf 4900 while (i > 0)
d00edca5 4901 {
858b45cf
DD		 4902 --i;
4903 if (! adpm[i].printed)
4904 {
4905 d_append_char (dpi, ' ');
ddee5e46 4906 d_print_mod (dpi, options, adpm[i].mod);
858b45cf 4907 }
d00edca5 4908 }
eb383413 4909
858b45cf 4910 dpi->modifiers = hold_modifiers;
eb383413 4911
d00edca5
DD		 4912 return;
4913 }
eb383413 4914
59727473 4915 case DEMANGLE_COMPONENT_TEMPLATE:
331c3da2
DD		 4916 {
4917 struct d_print_mod *hold_dpm;
208c1674 4918 struct demangle_component *dcl;
492e19d0 4919 const struct demangle_component *hold_current;
4920
4921 /* This template may need to be referenced by a cast operator
4922 contained in its subtree. */
4923 hold_current = dpi->current_template;
4924 dpi->current_template = dc;
331c3da2
DD		 4925
4926 /* Don't push modifiers into a template definition. Doing so
4927 could give the wrong definition for a template argument.
4928 Instead, treat the template essentially as a name. */
4929
4930 hold_dpm = dpi->modifiers;
4931 dpi->modifiers = NULL;
4932
208c1674
DD		 4933 dcl = d_left (dc);
4934
ddee5e46 4935 if ((options & DMGL_JAVA) != 0
208c1674
DD		 4936 && dcl->type == DEMANGLE_COMPONENT_NAME
4937 && dcl->u.s_name.len == 6
4938 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4939 {
4940 /* Special-case Java arrays, so that JArray<TYPE> appears
4941 instead as TYPE[]. */
4942
ddee5e46 4943 d_print_comp (dpi, options, d_right (dc));
208c1674
DD		 4944 d_append_string (dpi, "[]");
4945 }
4946 else
4947 {
ddee5e46 4948 d_print_comp (dpi, options, dcl);
208c1674
DD		 4949 if (d_last_char (dpi) == '<')
4950 d_append_char (dpi, ' ');
4951 d_append_char (dpi, '<');
ddee5e46 4952 d_print_comp (dpi, options, d_right (dc));
208c1674
DD		 4953 /* Avoid generating two consecutive '>' characters, to avoid
4954 the C++ syntactic ambiguity. */
4955 if (d_last_char (dpi) == '>')
4956 d_append_char (dpi, ' ');
4957 d_append_char (dpi, '>');
4958 }
331c3da2
DD		 4959
4960 dpi->modifiers = hold_dpm;
492e19d0 4961 dpi->current_template = hold_current;
331c3da2
DD		 4962
4963 return;
4964 }
d00edca5 4965
59727473 4966 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
88acc2e1
NS		 4967 if (dpi->is_lambda_arg)
4968 {
4969 /* Show the template parm index, as that's how g++ displays
4970 these, and future proofs us against potential
4971 '[]<typename T> (T *a, T *b) {...}'. */
4972 d_append_buffer (dpi, "auto:", 5);
4973 d_append_num (dpi, dc->u.s_number.number + 1);
4974 }
4975 else
4976 {
4977 struct d_print_template *hold_dpt;
4978 struct demangle_component *a = d_lookup_template_argument (dpi, dc);
1c08f2c8 4979
88acc2e1
NS		 4980 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4981 a = d_index_template_argument (a, dpi->pack_index);
59666b35 4982
88acc2e1
NS		 4983 if (a == NULL)
4984 {
4985 d_print_error (dpi);
4986 return;
4987 }
59666b35 4988
88acc2e1
NS		 4989 /* While processing this parameter, we need to pop the list
4990 of templates. This is because the template parameter may
4991 itself be a reference to a parameter of an outer
4992 template. */
eb383413 4993
88acc2e1
NS		 4994 hold_dpt = dpi->templates;
4995 dpi->templates = hold_dpt->next;
03d5f569 4996
88acc2e1 4997 d_print_comp (dpi, options, a);
59666b35 4998
88acc2e1
NS		 4999 dpi->templates = hold_dpt;
5000 }
5001 return;
eb383413 5002
af03af8f
NC		 5003 case DEMANGLE_COMPONENT_TPARM_OBJ:
5004 d_append_string (dpi, "template parameter object for ");
5005 d_print_comp (dpi, options, d_left (dc));
5006 return;
5007
59727473 5008 case DEMANGLE_COMPONENT_CTOR:
ddee5e46 5009 d_print_comp (dpi, options, dc->u.s_ctor.name);
d00edca5
DD		 5010 return;
5011
59727473 5012 case DEMANGLE_COMPONENT_DTOR:
d00edca5 5013 d_append_char (dpi, '~');
ddee5e46 5014 d_print_comp (dpi, options, dc->u.s_dtor.name);
d00edca5
DD		 5015 return;
5016
59727473 5017 case DEMANGLE_COMPONENT_VTABLE:
208c1674 5018 d_append_string (dpi, "vtable for ");
ddee5e46 5019 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5020 return;
5021
59727473 5022 case DEMANGLE_COMPONENT_VTT:
208c1674 5023 d_append_string (dpi, "VTT for ");
ddee5e46 5024 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5025 return;
5026
59727473 5027 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
208c1674 5028 d_append_string (dpi, "construction vtable for ");
ddee5e46 5029 d_print_comp (dpi, options, d_left (dc));
208c1674 5030 d_append_string (dpi, "-in-");
ddee5e46 5031 d_print_comp (dpi, options, d_right (dc));
d00edca5
DD		 5032 return;
5033
59727473 5034 case DEMANGLE_COMPONENT_TYPEINFO:
208c1674 5035 d_append_string (dpi, "typeinfo for ");
ddee5e46 5036 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5037 return;
5038
59727473 5039 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
208c1674 5040 d_append_string (dpi, "typeinfo name for ");
ddee5e46 5041 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5042 return;
5043
59727473 5044 case DEMANGLE_COMPONENT_TYPEINFO_FN:
208c1674 5045 d_append_string (dpi, "typeinfo fn for ");
ddee5e46 5046 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5047 return;
5048
59727473 5049 case DEMANGLE_COMPONENT_THUNK:
208c1674 5050 d_append_string (dpi, "non-virtual thunk to ");
ddee5e46 5051 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5052 return;
5053
59727473 5054 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
208c1674 5055 d_append_string (dpi, "virtual thunk to ");
ddee5e46 5056 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5057 return;
5058
59727473 5059 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
208c1674 5060 d_append_string (dpi, "covariant return thunk to ");
ddee5e46 5061 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5062 return;
5063
59727473 5064 case DEMANGLE_COMPONENT_JAVA_CLASS:
208c1674 5065 d_append_string (dpi, "java Class for ");
ddee5e46 5066 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5067 return;
5068
59727473 5069 case DEMANGLE_COMPONENT_GUARD:
208c1674 5070 d_append_string (dpi, "guard variable for ");
ddee5e46 5071 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5072 return;
5073
995b61fe
DD		 5074 case DEMANGLE_COMPONENT_TLS_INIT:
5075 d_append_string (dpi, "TLS init function for ");
5076 d_print_comp (dpi, options, d_left (dc));
5077 return;
5078
5079 case DEMANGLE_COMPONENT_TLS_WRAPPER:
5080 d_append_string (dpi, "TLS wrapper function for ");
5081 d_print_comp (dpi, options, d_left (dc));
5082 return;
5083
59727473 5084 case DEMANGLE_COMPONENT_REFTEMP:
abc6552b
DD		 5085 d_append_string (dpi, "reference temporary #");
5086 d_print_comp (dpi, options, d_right (dc));
5087 d_append_string (dpi, " for ");
ddee5e46 5088 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5089 return;
5090
839e4798 5091 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
208c1674 5092 d_append_string (dpi, "hidden alias for ");
ddee5e46 5093 d_print_comp (dpi, options, d_left (dc));
839e4798
RH		 5094 return;
5095
956a8f8b
DD		 5096 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
5097 d_append_string (dpi, "transaction clone for ");
5098 d_print_comp (dpi, options, d_left (dc));
5099 return;
5100
5101 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
5102 d_append_string (dpi, "non-transaction clone for ");
5103 d_print_comp (dpi, options, d_left (dc));
5104 return;
5105
59727473 5106 case DEMANGLE_COMPONENT_SUB_STD:
b6fb00c0 5107 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
d00edca5
DD		 5108 return;
5109
59727473
DD		 5110 case DEMANGLE_COMPONENT_RESTRICT:
5111 case DEMANGLE_COMPONENT_VOLATILE:
5112 case DEMANGLE_COMPONENT_CONST:
74aee4eb
DD		 5113 {
5114 struct d_print_mod *pdpm;
5115
5116 /* When printing arrays, it's possible to have cases where the
5117 same CV-qualifier gets pushed on the stack multiple times.
5118 We only need to print it once. */
5119
5120 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
5121 {
5122 if (! pdpm->printed)
5123 {
5124 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
5125 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
5126 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
5127 break;
5128 if (pdpm->mod->type == dc->type)
5129 {
ddee5e46 5130 d_print_comp (dpi, options, d_left (dc));
74aee4eb
DD		 5131 return;
5132 }
5133 }
5134 }
5135 }
b24539b3
DD		 5136 goto modifier;
5137
5138 case DEMANGLE_COMPONENT_REFERENCE:
5139 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5140 {
5141 /* Handle reference smashing: & + && = &. */
c793cac1 5142 struct demangle_component *sub = d_left (dc);
88acc2e1
NS		 5143 if (!dpi->is_lambda_arg
5144 && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
b24539b3 5145 {
fd259167 5146 struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
9548bbed 5147 struct demangle_component *a;
9548bbed 5148
5149 if (scope == NULL)
5150 {
5151 /* This is the first time SUB has been traversed.
5152 We need to capture the current templates so
5153 they can be restored if SUB is reentered as a
5154 substitution. */
fd259167 5155 d_save_scope (dpi, sub);
9548bbed 5156 if (d_print_saw_error (dpi))
5157 return;
5158 }
5159 else
5160 {
91662bad 5161 const struct d_component_stack *dcse;
5162 int found_self_or_parent = 0;
5163
9548bbed 5164 /* This traversal is reentering SUB as a substition.
91662bad 5165 If we are not beneath SUB or DC in the tree then we
5166 need to restore SUB's template stack temporarily. */
5167 for (dcse = dpi->component_stack; dcse != NULL;
5168 dcse = dcse->parent)
5169 {
5170 if (dcse->dc == sub
5171 || (dcse->dc == dc
5172 && dcse != dpi->component_stack))
5173 {
5174 found_self_or_parent = 1;
5175 break;
5176 }
5177 }
5178
5179 if (!found_self_or_parent)
5180 {
5181 saved_templates = dpi->templates;
5182 dpi->templates = scope->templates;
5183 need_template_restore = 1;
5184 }
9548bbed 5185 }
5186
5187 a = d_lookup_template_argument (dpi, sub);
b24539b3
DD		 5188 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5189 a = d_index_template_argument (a, dpi->pack_index);
04aed652
DD		 5190
5191 if (a == NULL)
5192 {
9548bbed 5193 if (need_template_restore)
5194 dpi->templates = saved_templates;
5195
04aed652
DD		 5196 d_print_error (dpi);
5197 return;
5198 }
5199
b24539b3
DD		 5200 sub = a;
5201 }
5202
5203 if (sub->type == DEMANGLE_COMPONENT_REFERENCE
5204 || sub->type == dc->type)
5205 dc = sub;
5206 else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
5207 mod_inner = d_left (sub);
5208 }
74aee4eb 5209 /* Fall through. */
b24539b3 5210
59727473
DD		 5211 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5212 case DEMANGLE_COMPONENT_POINTER:
59727473
DD		 5213 case DEMANGLE_COMPONENT_COMPLEX:
5214 case DEMANGLE_COMPONENT_IMAGINARY:
a4ddf8dc 5215 FNQUAL_COMPONENT_CASE:
b24539b3 5216 modifier:
d00edca5
DD		 5217 {
5218 /* We keep a list of modifiers on the stack. */
5219 struct d_print_mod dpm;
eb383413 5220
d00edca5
DD		 5221 dpm.next = dpi->modifiers;
5222 dpi->modifiers = &dpm;
5223 dpm.mod = dc;
5224 dpm.printed = 0;
331c3da2 5225 dpm.templates = dpi->templates;
eb383413 5226
b24539b3
DD		 5227 if (!mod_inner)
5228 mod_inner = d_left (dc);
5229
5230 d_print_comp (dpi, options, mod_inner);
59666b35 5231
d00edca5
DD		 5232 /* If the modifier didn't get printed by the type, print it
5233 now. */
5234 if (! dpm.printed)
ddee5e46 5235 d_print_mod (dpi, options, dc);
eb383413 5236
d00edca5 5237 dpi->modifiers = dpm.next;
eb383413 5238
9548bbed 5239 if (need_template_restore)
5240 dpi->templates = saved_templates;
5241
d00edca5
DD		 5242 return;
5243 }
eb383413 5244
59727473 5245 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
ddee5e46 5246 if ((options & DMGL_JAVA) == 0)
b6fb00c0
DD		 5247 d_append_buffer (dpi, dc->u.s_builtin.type->name,
5248 dc->u.s_builtin.type->len);
d00edca5 5249 else
b6fb00c0
DD		 5250 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
5251 dc->u.s_builtin.type->java_len);
d00edca5 5252 return;
eb383413 5253
59727473 5254 case DEMANGLE_COMPONENT_VENDOR_TYPE:
ddee5e46 5255 d_print_comp (dpi, options, d_left (dc));
d00edca5 5256 return;
eb383413 5257
59727473 5258 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
d00edca5 5259 {
ddee5e46
DD		 5260 if ((options & DMGL_RET_POSTFIX) != 0)
5261 d_print_function_type (dpi,
5262 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5263 dc, dpi->modifiers);
7887b2ce
DD		 5264
5265 /* Print return type if present */
ddee5e46
DD		 5266 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
5267 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5268 d_left (dc));
5269 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
d00edca5
DD		 5270 {
5271 struct d_print_mod dpm;
eb383413 5272
d00edca5
DD		 5273 /* We must pass this type down as a modifier in order to
5274 print it in the right location. */
d00edca5
DD		 5275 dpm.next = dpi->modifiers;
5276 dpi->modifiers = &dpm;
5277 dpm.mod = dc;
5278 dpm.printed = 0;
331c3da2 5279 dpm.templates = dpi->templates;
eb383413 5280
ddee5e46
DD		 5281 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5282 d_left (dc));
eb383413 5283
d00edca5 5284 dpi->modifiers = dpm.next;
eb383413 5285
d00edca5
DD		 5286 if (dpm.printed)
5287 return;
eb383413 5288
7887b2ce
DD		 5289 /* In standard prefix notation, there is a space between the
5290 return type and the function signature. */
ddee5e46 5291 if ((options & DMGL_RET_POSTFIX) == 0)
7887b2ce 5292 d_append_char (dpi, ' ');
d00edca5 5293 }
eb383413 5294
ddee5e46
DD		 5295 if ((options & DMGL_RET_POSTFIX) == 0)
5296 d_print_function_type (dpi,
5297 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5298 dc, dpi->modifiers);
03d5f569 5299
d00edca5
DD		 5300 return;
5301 }
eb383413 5302
59727473 5303 case DEMANGLE_COMPONENT_ARRAY_TYPE:
d00edca5 5304 {
74aee4eb
DD		 5305 struct d_print_mod *hold_modifiers;
5306 struct d_print_mod adpm[4];
5307 unsigned int i;
5308 struct d_print_mod *pdpm;
eb383413 5309
d00edca5 5310 /* We must pass this type down as a modifier in order to print
74aee4eb
DD		 5311 multi-dimensional arrays correctly. If the array itself is
5312 CV-qualified, we act as though the element type were
5313 CV-qualified. We do this by copying the modifiers down
5314 rather than fiddling pointers, so that we don't wind up
5315 with a d_print_mod higher on the stack pointing into our
5316 stack frame after we return. */
03d5f569 5317
74aee4eb
DD		 5318 hold_modifiers = dpi->modifiers;
5319
5320 adpm[0].next = hold_modifiers;
5321 dpi->modifiers = &adpm[0];
5322 adpm[0].mod = dc;
5323 adpm[0].printed = 0;
5324 adpm[0].templates = dpi->templates;
5325
5326 i = 1;
5327 pdpm = hold_modifiers;
5328 while (pdpm != NULL
5329 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
5330 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
5331 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
5332 {
5333 if (! pdpm->printed)
5334 {
5335 if (i >= sizeof adpm / sizeof adpm[0])
5336 {
5337 d_print_error (dpi);
5338 return;
5339 }
5340
5341 adpm[i] = *pdpm;
5342 adpm[i].next = dpi->modifiers;
5343 dpi->modifiers = &adpm[i];
5344 pdpm->printed = 1;
5345 ++i;
5346 }
5347
5348 pdpm = pdpm->next;
5349 }
eb383413 5350
ddee5e46 5351 d_print_comp (dpi, options, d_right (dc));
eb383413 5352
74aee4eb 5353 dpi->modifiers = hold_modifiers;
eb383413 5354
74aee4eb 5355 if (adpm[0].printed)
d00edca5 5356 return;
eb383413 5357
74aee4eb
DD		 5358 while (i > 1)
5359 {
5360 --i;
ddee5e46 5361 d_print_mod (dpi, options, adpm[i].mod);
74aee4eb
DD		 5362 }
5363
ddee5e46 5364 d_print_array_type (dpi, options, dc, dpi->modifiers);
eb383413 5365
d00edca5
DD		 5366 return;
5367 }
eb383413 5368
59727473 5369 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
cbc43128 5370 case DEMANGLE_COMPONENT_VECTOR_TYPE:
d00edca5 5371 {
d00edca5
DD		 5372 struct d_print_mod dpm;
5373
d00edca5
DD		 5374 dpm.next = dpi->modifiers;
5375 dpi->modifiers = &dpm;
5376 dpm.mod = dc;
5377 dpm.printed = 0;
331c3da2 5378 dpm.templates = dpi->templates;
d00edca5 5379
ddee5e46 5380 d_print_comp (dpi, options, d_right (dc));
d00edca5
DD		 5381
5382 /* If the modifier didn't get printed by the type, print it
5383 now. */
5384 if (! dpm.printed)
ddee5e46 5385 d_print_mod (dpi, options, dc);
eb383413 5386
d00edca5 5387 dpi->modifiers = dpm.next;
eb383413 5388
d00edca5
DD		 5389 return;
5390 }
eb383413 5391
d2825c1a
DD		 5392 case DEMANGLE_COMPONENT_FIXED_TYPE:
5393 if (dc->u.s_fixed.sat)
5394 d_append_string (dpi, "_Sat ");
5395 /* Don't print "int _Accum". */
5396 if (dc->u.s_fixed.length->u.s_builtin.type
5397 != &cplus_demangle_builtin_types['i'-'a'])
5398 {
ddee5e46 5399 d_print_comp (dpi, options, dc->u.s_fixed.length);
d2825c1a
DD		 5400 d_append_char (dpi, ' ');
5401 }
5402 if (dc->u.s_fixed.accum)
5403 d_append_string (dpi, "_Accum");
5404 else
5405 d_append_string (dpi, "_Fract");
5406 return;
5407
59727473
DD		 5408 case DEMANGLE_COMPONENT_ARGLIST:
5409 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
1c08f2c8 5410 if (d_left (dc) != NULL)
ddee5e46 5411 d_print_comp (dpi, options, d_left (dc));
d00edca5
DD		 5412 if (d_right (dc) != NULL)
5413 {
4e59450e 5414 size_t len;
3baae9d6
JJ		 5415 unsigned long int flush_count;
5416 /* Make sure ", " isn't flushed by d_append_string, otherwise
5417 dpi->len -= 2 wouldn't work. */
5418 if (dpi->len >= sizeof (dpi->buf) - 2)
5419 d_print_flush (dpi);
208c1674 5420 d_append_string (dpi, ", ");
4e59450e 5421 len = dpi->len;
3baae9d6 5422 flush_count = dpi->flush_count;
ddee5e46 5423 d_print_comp (dpi, options, d_right (dc));
4e59450e
DD		 5424 /* If that didn't print anything (which can happen with empty
5425 template argument packs), remove the comma and space. */
3baae9d6 5426 if (dpi->flush_count == flush_count && dpi->len == len)
4e59450e 5427 dpi->len -= 2;
d00edca5
DD		 5428 }
5429 return;
eb383413 5430
eb7b5ddb
DD		 5431 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
5432 {
5433 struct demangle_component *type = d_left (dc);
5434 struct demangle_component *list = d_right (dc);
5435
5436 if (type)
5437 d_print_comp (dpi, options, type);
5438 d_append_char (dpi, '{');
5439 d_print_comp (dpi, options, list);
5440 d_append_char (dpi, '}');
5441 }
5442 return;
5443
59727473 5444 case DEMANGLE_COMPONENT_OPERATOR:
d00edca5 5445 {
fbfd63c0
DD		 5446 const struct demangle_operator_info *op = dc->u.s_operator.op;
5447 int len = op->len;
d00edca5 5448
208c1674 5449 d_append_string (dpi, "operator");
fbfd63c0
DD		 5450 /* Add a space before new/delete. */
5451 if (IS_LOWER (op->name[0]))
d00edca5 5452 d_append_char (dpi, ' ');
fbfd63c0
DD		 5453 /* Omit a trailing space. */
5454 if (op->name[len-1] == ' ')
5455 --len;
5456 d_append_buffer (dpi, op->name, len);
d00edca5
DD		 5457 return;
5458 }
eb383413 5459
59727473 5460 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
208c1674 5461 d_append_string (dpi, "operator ");
ddee5e46 5462 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
d00edca5 5463 return;
eb383413 5464
c4be2641 5465 case DEMANGLE_COMPONENT_CONVERSION:
208c1674 5466 d_append_string (dpi, "operator ");
c4be2641 5467 d_print_conversion (dpi, options, dc);
d00edca5 5468 return;
eb383413 5469
eb7b5ddb
DD		 5470 case DEMANGLE_COMPONENT_NULLARY:
5471 d_print_expr_op (dpi, options, d_left (dc));
5472 return;
5473
59727473 5474 case DEMANGLE_COMPONENT_UNARY:
eb7b5ddb
DD		 5475 {
5476 struct demangle_component *op = d_left (dc);
5477 struct demangle_component *operand = d_right (dc);
5478 const char *code = NULL;
02e7efbf 5479
eb7b5ddb
DD		 5480 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
5481 {
5482 code = op->u.s_operator.op->code;
5483 if (!strcmp (code, "ad"))
5484 {
5485 /* Don't print the argument list for the address of a
5486 function. */
5487 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
5488 && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
5489 && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5490 operand = d_left (operand);
5491 }
5492 if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5493 {
5494 /* This indicates a suffix operator. */
5495 operand = d_left (operand);
5496 d_print_subexpr (dpi, options, operand);
5497 d_print_expr_op (dpi, options, op);
5498 return;
5499 }
5500 }
02e7efbf 5501
fa3fcee7
NC		 5502 /* For sizeof..., just print the pack length. */
5503 if (code && !strcmp (code, "sZ"))
5504 {
5505 struct demangle_component *a = d_find_pack (dpi, operand);
5506 int len = d_pack_length (a);
5507 d_append_num (dpi, len);
5508 return;
5509 }
5510 else if (code && !strcmp (code, "sP"))
5511 {
5512 int len = d_args_length (dpi, operand);
5513 d_append_num (dpi, len);
5514 return;
5515 }
5516
eb7b5ddb
DD		 5517 if (op->type != DEMANGLE_COMPONENT_CAST)
5518 d_print_expr_op (dpi, options, op);
5519 else
5520 {
5521 d_append_char (dpi, '(');
5522 d_print_cast (dpi, options, op);
5523 d_append_char (dpi, ')');
5524 }
5525 if (code && !strcmp (code, "gs"))
5526 /* Avoid parens after '::'. */
5527 d_print_comp (dpi, options, operand);
5528 else if (code && !strcmp (code, "st"))
5529 /* Always print parens for sizeof (type). */
5530 {
5531 d_append_char (dpi, '(');
5532 d_print_comp (dpi, options, operand);
5533 d_append_char (dpi, ')');
5534 }
5535 else
5536 d_print_subexpr (dpi, options, operand);
5537 }
d00edca5
DD		 5538 return;
5539
59727473
DD		 5540 case DEMANGLE_COMPONENT_BINARY:
5541 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
eb383413 5542 {
d00edca5
DD		 5543 d_print_error (dpi);
5544 return;
eb383413 5545 }
858b45cf 5546
7c328963
DD		 5547 if (op_is_new_cast (d_left (dc)))
5548 {
5549 d_print_expr_op (dpi, options, d_left (dc));
5550 d_append_char (dpi, '<');
5551 d_print_comp (dpi, options, d_left (d_right (dc)));
5552 d_append_string (dpi, ">(");
5553 d_print_comp (dpi, options, d_right (d_right (dc)));
5554 d_append_char (dpi, ')');
5555 return;
5556 }
5557
fa3fcee7
NC		 5558 if (d_maybe_print_fold_expression (dpi, options, dc))
5559 return;
5560
7ade7fba
AM		 5561 if (d_maybe_print_designated_init (dpi, options, dc))
5562 return;
5563
858b45cf
DD		 5564 /* We wrap an expression which uses the greater-than operator in
5565 an extra layer of parens so that it does not get confused
5566 with the '>' which ends the template parameters. */
59727473 5567 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
b6fb00c0
DD		 5568 && d_left (dc)->u.s_operator.op->len == 1
5569 && d_left (dc)->u.s_operator.op->name[0] == '>')
858b45cf
DD		 5570 d_append_char (dpi, '(');
5571
02e7efbf
JK		 5572 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5573 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
5574 {
5575 /* Function call used in an expression should not have printed types
5576 of the function arguments. Values of the function arguments still
5577 get printed below. */
5578
5579 const struct demangle_component *func = d_left (d_right (dc));
5580
5581 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5582 d_print_error (dpi);
5583 d_print_subexpr (dpi, options, d_left (func));
5584 }
5585 else
5586 d_print_subexpr (dpi, options, d_left (d_right (dc)));
9ac9c2b6
DD		 5587 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5588 {
5589 d_append_char (dpi, '[');
ddee5e46 5590 d_print_comp (dpi, options, d_right (d_right (dc)));
9ac9c2b6
DD		 5591 d_append_char (dpi, ']');
5592 }
5593 else
5594 {
5595 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
ddee5e46
DD		 5596 d_print_expr_op (dpi, options, d_left (dc));
5597 d_print_subexpr (dpi, options, d_right (d_right (dc)));
9ac9c2b6 5598 }
858b45cf 5599
59727473 5600 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
b6fb00c0
DD		 5601 && d_left (dc)->u.s_operator.op->len == 1
5602 && d_left (dc)->u.s_operator.op->name[0] == '>')
858b45cf
DD		 5603 d_append_char (dpi, ')');
5604
d00edca5
DD		 5605 return;
5606
59727473
DD		 5607 case DEMANGLE_COMPONENT_BINARY_ARGS:
5608 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
d00edca5
DD		 5609 d_print_error (dpi);
5610 return;
5611
59727473
DD		 5612 case DEMANGLE_COMPONENT_TRINARY:
5613 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5614 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
d00edca5
DD		 5615 {
5616 d_print_error (dpi);
5617 return;
5618 }
fa3fcee7
NC		 5619 if (d_maybe_print_fold_expression (dpi, options, dc))
5620 return;
7ade7fba
AM		 5621 if (d_maybe_print_designated_init (dpi, options, dc))
5622 return;
eb7b5ddb
DD		 5623 {
5624 struct demangle_component *op = d_left (dc);
5625 struct demangle_component *first = d_left (d_right (dc));
5626 struct demangle_component *second = d_left (d_right (d_right (dc)));
5627 struct demangle_component *third = d_right (d_right (d_right (dc)));
5628
5629 if (!strcmp (op->u.s_operator.op->code, "qu"))
5630 {
5631 d_print_subexpr (dpi, options, first);
5632 d_print_expr_op (dpi, options, op);
5633 d_print_subexpr (dpi, options, second);
5634 d_append_string (dpi, " : ");
5635 d_print_subexpr (dpi, options, third);
5636 }
5637 else
5638 {
5639 d_append_string (dpi, "new ");
5640 if (d_left (first) != NULL)
5641 {
5642 d_print_subexpr (dpi, options, first);
5643 d_append_char (dpi, ' ');
5644 }
5645 d_print_comp (dpi, options, second);
5646 if (third)
5647 d_print_subexpr (dpi, options, third);
5648 }
5649 }
d00edca5
DD		 5650 return;
5651
59727473
DD		 5652 case DEMANGLE_COMPONENT_TRINARY_ARG1:
5653 case DEMANGLE_COMPONENT_TRINARY_ARG2:
5654 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
d00edca5
DD		 5655 d_print_error (dpi);
5656 return;
5657
59727473
DD		 5658 case DEMANGLE_COMPONENT_LITERAL:
5659 case DEMANGLE_COMPONENT_LITERAL_NEG:
2d733211
DD		 5660 {
5661 enum d_builtin_type_print tp;
d00edca5 5662
2d733211
DD		 5663 /* For some builtin types, produce simpler output. */
5664 tp = D_PRINT_DEFAULT;
5665 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5666 {
5667 tp = d_left (dc)->u.s_builtin.type->print;
5668 switch (tp)
5669 {
5670 case D_PRINT_INT:
5671 case D_PRINT_UNSIGNED:
5672 case D_PRINT_LONG:
5673 case D_PRINT_UNSIGNED_LONG:
5674 case D_PRINT_LONG_LONG:
5675 case D_PRINT_UNSIGNED_LONG_LONG:
5676 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
5677 {
5678 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5679 d_append_char (dpi, '-');
ddee5e46 5680 d_print_comp (dpi, options, d_right (dc));
2d733211
DD		 5681 switch (tp)
5682 {
5683 default:
5684 break;
5685 case D_PRINT_UNSIGNED:
5686 d_append_char (dpi, 'u');
5687 break;
5688 case D_PRINT_LONG:
5689 d_append_char (dpi, 'l');
5690 break;
5691 case D_PRINT_UNSIGNED_LONG:
208c1674 5692 d_append_string (dpi, "ul");
2d733211
DD		 5693 break;
5694 case D_PRINT_LONG_LONG:
208c1674 5695 d_append_string (dpi, "ll");
2d733211
DD		 5696 break;
5697 case D_PRINT_UNSIGNED_LONG_LONG:
208c1674 5698 d_append_string (dpi, "ull");
2d733211
DD		 5699 break;
5700 }
5701 return;
5702 }
5703 break;
eb383413 5704
2d733211
DD		 5705 case D_PRINT_BOOL:
5706 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5707 && d_right (dc)->u.s_name.len == 1
5708 && dc->type == DEMANGLE_COMPONENT_LITERAL)
5709 {
5710 switch (d_right (dc)->u.s_name.s[0])
5711 {
5712 case '0':
208c1674 5713 d_append_string (dpi, "false");
2d733211
DD		 5714 return;
5715 case '1':
208c1674 5716 d_append_string (dpi, "true");
2d733211
DD		 5717 return;
5718 default:
5719 break;
5720 }
5721 }
5722 break;
03d5f569 5723
2d733211
DD		 5724 default:
5725 break;
5726 }
5727 }
eb383413 5728
2d733211 5729 d_append_char (dpi, '(');
ddee5e46 5730 d_print_comp (dpi, options, d_left (dc));
2d733211
DD		 5731 d_append_char (dpi, ')');
5732 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5733 d_append_char (dpi, '-');
5734 if (tp == D_PRINT_FLOAT)
5735 d_append_char (dpi, '[');
ddee5e46 5736 d_print_comp (dpi, options, d_right (dc));
2d733211
DD		 5737 if (tp == D_PRINT_FLOAT)
5738 d_append_char (dpi, ']');
5739 }
d00edca5 5740 return;
eb383413 5741
cbc43128
DD		 5742 case DEMANGLE_COMPONENT_NUMBER:
5743 d_append_num (dpi, dc->u.s_number.number);
5744 return;
5745
830ef634
DD		 5746 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5747 d_append_string (dpi, "java resource ");
ddee5e46 5748 d_print_comp (dpi, options, d_left (dc));
830ef634
DD		 5749 return;
5750
5751 case DEMANGLE_COMPONENT_COMPOUND_NAME:
ddee5e46
DD		 5752 d_print_comp (dpi, options, d_left (dc));
5753 d_print_comp (dpi, options, d_right (dc));
830ef634
DD		 5754 return;
5755
5756 case DEMANGLE_COMPONENT_CHARACTER:
5757 d_append_char (dpi, dc->u.s_character.character);
5758 return;
5759
ba8cb4ba
DD		 5760 case DEMANGLE_COMPONENT_DECLTYPE:
5761 d_append_string (dpi, "decltype (");
ddee5e46 5762 d_print_comp (dpi, options, d_left (dc));
ba8cb4ba
DD		 5763 d_append_char (dpi, ')');
5764 return;
5765
1c08f2c8
DD		 5766 case DEMANGLE_COMPONENT_PACK_EXPANSION:
5767 {
e2e1864d 5768 int len;
1c08f2c8 5769 int i;
e2e1864d
DD		 5770 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5771 if (a == NULL)
5772 {
5773 /* d_find_pack won't find anything if the only packs involved
5774 in this expansion are function parameter packs; in that
5775 case, just print the pattern and "...". */
ddee5e46 5776 d_print_subexpr (dpi, options, d_left (dc));
e2e1864d
DD		 5777 d_append_string (dpi, "...");
5778 return;
5779 }
1c08f2c8 5780
e2e1864d 5781 len = d_pack_length (a);
1c08f2c8
DD		 5782 dc = d_left (dc);
5783 for (i = 0; i < len; ++i)
5784 {
5785 dpi->pack_index = i;
ddee5e46 5786 d_print_comp (dpi, options, dc);
1c08f2c8
DD		 5787 if (i < len-1)
5788 d_append_string (dpi, ", ");
5789 }
5790 }
5791 return;
5792
c743cf5d 5793 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
f2917a30
DD		 5794 {
5795 long num = dc->u.s_number.number;
5796 if (num == 0)
5797 d_append_string (dpi, "this");
5798 else
5799 {
5800 d_append_string (dpi, "{parm#");
5801 d_append_num (dpi, num);
5802 d_append_char (dpi, '}');
5803 }
5804 }
664aa91f 5805 return;
c743cf5d 5806
d5031754
DD		 5807 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5808 d_append_string (dpi, "global constructors keyed to ");
ddee5e46 5809 d_print_comp (dpi, options, dc->u.s_binary.left);
d5031754
DD		 5810 return;
5811
5812 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5813 d_append_string (dpi, "global destructors keyed to ");
ddee5e46 5814 d_print_comp (dpi, options, dc->u.s_binary.left);
d5031754
DD		 5815 return;
5816
664aa91f
DD		 5817 case DEMANGLE_COMPONENT_LAMBDA:
5818 d_append_string (dpi, "{lambda(");
88acc2e1
NS		 5819 /* Generic lambda auto parms are mangled as the template type
5820 parm they are. */
5821 dpi->is_lambda_arg++;
ddee5e46 5822 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
88acc2e1 5823 dpi->is_lambda_arg--;
664aa91f
DD		 5824 d_append_string (dpi, ")#");
5825 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5826 d_append_char (dpi, '}');
5827 return;
5828
5829 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
5830 d_append_string (dpi, "{unnamed type#");
5831 d_append_num (dpi, dc->u.s_number.number + 1);
5832 d_append_char (dpi, '}');
5833 return;
5834
7955ede5
DD		 5835 case DEMANGLE_COMPONENT_CLONE:
5836 d_print_comp (dpi, options, d_left (dc));
5837 d_append_string (dpi, " [clone ");
5838 d_print_comp (dpi, options, d_right (dc));
5839 d_append_char (dpi, ']');
5840 return;
5841
d00edca5
DD		 5842 default:
5843 d_print_error (dpi);
5844 return;
5845 }
eb383413
L		 5846}
5847
91662bad 5848static void
5849d_print_comp (struct d_print_info *dpi, int options,
c793cac1 5850 struct demangle_component *dc)
91662bad 5851{
5852 struct d_component_stack self;
2d3392bd 5853 if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
c793cac1
NC		 5854 {
5855 d_print_error (dpi);
5856 return;
5857 }
2d3392bd
IB		 5858
5859 dc->d_printing++;
5860 dpi->recursion++;
91662bad 5861
5862 self.dc = dc;
5863 self.parent = dpi->component_stack;
5864 dpi->component_stack = &self;
5865
5866 d_print_comp_inner (dpi, options, dc);
5867
5868 dpi->component_stack = self.parent;
c793cac1 5869 dc->d_printing--;
2d3392bd 5870 dpi->recursion--;
91662bad 5871}
5872
b6fb00c0
DD		 5873/* Print a Java dentifier. For Java we try to handle encoded extended
5874 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5875 so we don't it for C++. Characters are encoded as
5876 __U<hex-char>+_. */
eb383413 5877
d00edca5 5878static void
9334f9c6 5879d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
eb383413 5880{
b6fb00c0
DD		 5881 const char *p;
5882 const char *end;
eb383413 5883
b6fb00c0
DD		 5884 end = name + len;
5885 for (p = name; p < end; ++p)
5886 {
5887 if (end - p > 3
5888 && p[0] == '_'
5889 && p[1] == '_'
5890 && p[2] == 'U')
eb383413 5891 {
b6fb00c0
DD		 5892 unsigned long c;
5893 const char *q;
5894
5895 c = 0;
5896 for (q = p + 3; q < end; ++q)
d00edca5 5897 {
b6fb00c0
DD		 5898 int dig;
5899
5900 if (IS_DIGIT (*q))
5901 dig = *q - '0';
5902 else if (*q >= 'A' && *q <= 'F')
5903 dig = *q - 'A' + 10;
5904 else if (*q >= 'a' && *q <= 'f')
5905 dig = *q - 'a' + 10;
5906 else
5907 break;
eb383413 5908
b6fb00c0
DD		 5909 c = c * 16 + dig;
5910 }
5911 /* If the Unicode character is larger than 256, we don't try
5912 to deal with it here. FIXME. */
5913 if (q < end && *q == '_' && c < 256)
5914 {
5915 d_append_char (dpi, c);
5916 p = q;
5917 continue;
d00edca5 5918 }
d00edca5 5919 }
b6fb00c0
DD		 5920
5921 d_append_char (dpi, *p);
eb383413 5922 }
eb383413
L		 5923}
5924
858b45cf
DD		 5925/* Print a list of modifiers. SUFFIX is 1 if we are printing
5926 qualifiers on this after printing a function. */
eb383413 5927
d00edca5 5928static void
ddee5e46 5929d_print_mod_list (struct d_print_info *dpi, int options,
9334f9c6 5930 struct d_print_mod *mods, int suffix)
eb383413 5931{
331c3da2
DD		 5932 struct d_print_template *hold_dpt;
5933
858b45cf 5934 if (mods == NULL || d_print_saw_error (dpi))
d00edca5 5935 return;
eb383413 5936
858b45cf
DD		 5937 if (mods->printed
5938 || (! suffix
a4ddf8dc 5939 && (is_fnqual_component_type (mods->mod->type))))
858b45cf 5940 {
ddee5e46 5941 d_print_mod_list (dpi, options, mods->next, suffix);
858b45cf
DD		 5942 return;
5943 }
5944
331c3da2
DD		 5945 mods->printed = 1;
5946
5947 hold_dpt = dpi->templates;
5948 dpi->templates = mods->templates;
5949
59727473 5950 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
eb383413 5951 {
ddee5e46 5952 d_print_function_type (dpi, options, mods->mod, mods->next);
331c3da2 5953 dpi->templates = hold_dpt;
d00edca5
DD		 5954 return;
5955 }
59727473 5956 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
d00edca5 5957 {
ddee5e46 5958 d_print_array_type (dpi, options, mods->mod, mods->next);
331c3da2 5959 dpi->templates = hold_dpt;
d00edca5
DD		 5960 return;
5961 }
59727473 5962 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
d4edd112
DD		 5963 {
5964 struct d_print_mod *hold_modifiers;
59727473 5965 struct demangle_component *dc;
d4edd112
DD		 5966
5967 /* When this is on the modifier stack, we have pulled any
5968 qualifiers off the right argument already. Otherwise, we
5969 print it as usual, but don't let the left argument see any
5970 modifiers. */
5971
5972 hold_modifiers = dpi->modifiers;
5973 dpi->modifiers = NULL;
ddee5e46 5974 d_print_comp (dpi, options, d_left (mods->mod));
d4edd112
DD		 5975 dpi->modifiers = hold_modifiers;
5976
ddee5e46 5977 if ((options & DMGL_JAVA) == 0)
208c1674 5978 d_append_string (dpi, "::");
b6fb00c0
DD		 5979 else
5980 d_append_char (dpi, '.');
d4edd112
DD		 5981
5982 dc = d_right (mods->mod);
664aa91f
DD		 5983
5984 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
5985 {
5986 d_append_string (dpi, "{default arg#");
5987 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5988 d_append_string (dpi, "}::");
5989 dc = dc->u.s_unary_num.sub;
5990 }
5991
a4ddf8dc 5992 while (is_fnqual_component_type (dc->type))
d4edd112
DD		 5993 dc = d_left (dc);
5994
ddee5e46 5995 d_print_comp (dpi, options, dc);
d4edd112
DD		 5996
5997 dpi->templates = hold_dpt;
5998 return;
5999 }
eb383413 6000
ddee5e46 6001 d_print_mod (dpi, options, mods->mod);
eb383413 6002
331c3da2
DD		 6003 dpi->templates = hold_dpt;
6004
ddee5e46 6005 d_print_mod_list (dpi, options, mods->next, suffix);
eb383413 6006}
331c3da2 6007
d00edca5 6008/* Print a modifier. */
eb383413 6009
d00edca5 6010static void
ddee5e46 6011d_print_mod (struct d_print_info *dpi, int options,
c793cac1 6012 struct demangle_component *mod)
d00edca5
DD		 6013{
6014 switch (mod->type)
6015 {
59727473
DD		 6016 case DEMANGLE_COMPONENT_RESTRICT:
6017 case DEMANGLE_COMPONENT_RESTRICT_THIS:
208c1674 6018 d_append_string (dpi, " restrict");
d00edca5 6019 return;
59727473
DD		 6020 case DEMANGLE_COMPONENT_VOLATILE:
6021 case DEMANGLE_COMPONENT_VOLATILE_THIS:
208c1674 6022 d_append_string (dpi, " volatile");
d00edca5 6023 return;
59727473
DD		 6024 case DEMANGLE_COMPONENT_CONST:
6025 case DEMANGLE_COMPONENT_CONST_THIS:
208c1674 6026 d_append_string (dpi, " const");
d00edca5 6027 return;
e9a38816
JM		 6028 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
6029 d_append_string (dpi, " transaction_safe");
6030 return;
a4ddf8dc
JM		 6031 case DEMANGLE_COMPONENT_NOEXCEPT:
6032 d_append_string (dpi, " noexcept");
6033 if (d_right (mod))
6034 {
6035 d_append_char (dpi, '(');
6036 d_print_comp (dpi, options, d_right (mod));
6037 d_append_char (dpi, ')');
6038 }
6039 return;
6040 case DEMANGLE_COMPONENT_THROW_SPEC:
6041 d_append_string (dpi, " throw");
6042 if (d_right (mod))
6043 {
6044 d_append_char (dpi, '(');
6045 d_print_comp (dpi, options, d_right (mod));
6046 d_append_char (dpi, ')');
6047 }
6048 return;
59727473 6049 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
d00edca5 6050 d_append_char (dpi, ' ');
ddee5e46 6051 d_print_comp (dpi, options, d_right (mod));
d00edca5 6052 return;
59727473 6053 case DEMANGLE_COMPONENT_POINTER:
d00edca5 6054 /* There is no pointer symbol in Java. */
ddee5e46 6055 if ((options & DMGL_JAVA) == 0)
d00edca5
DD		 6056 d_append_char (dpi, '*');
6057 return;
3a4d2339
DD		 6058 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6059 /* For the ref-qualifier, put a space before the &. */
6060 d_append_char (dpi, ' ');
41f225de 6061 /* FALLTHRU */
59727473 6062 case DEMANGLE_COMPONENT_REFERENCE:
d00edca5
DD		 6063 d_append_char (dpi, '&');
6064 return;
3a4d2339
DD		 6065 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6066 d_append_char (dpi, ' ');
41f225de 6067 /* FALLTHRU */
8969a67f
DD		 6068 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
6069 d_append_string (dpi, "&&");
6070 return;
59727473 6071 case DEMANGLE_COMPONENT_COMPLEX:
533da483 6072 d_append_string (dpi, " _Complex");
d00edca5 6073 return;
59727473 6074 case DEMANGLE_COMPONENT_IMAGINARY:
533da483 6075 d_append_string (dpi, " _Imaginary");
d00edca5 6076 return;
59727473 6077 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
858b45cf 6078 if (d_last_char (dpi) != '(')
d00edca5 6079 d_append_char (dpi, ' ');
ddee5e46 6080 d_print_comp (dpi, options, d_left (mod));
208c1674 6081 d_append_string (dpi, "::*");
d00edca5 6082 return;
59727473 6083 case DEMANGLE_COMPONENT_TYPED_NAME:
ddee5e46 6084 d_print_comp (dpi, options, d_left (mod));
d00edca5 6085 return;
cbc43128 6086 case DEMANGLE_COMPONENT_VECTOR_TYPE:
f9b58c5b 6087 d_append_string (dpi, " __vector(");
ddee5e46 6088 d_print_comp (dpi, options, d_left (mod));
f9b58c5b 6089 d_append_char (dpi, ')');
cbc43128
DD		 6090 return;
6091
d00edca5
DD		 6092 default:
6093 /* Otherwise, we have something that won't go back on the
6094 modifier stack, so we can just print it. */
ddee5e46 6095 d_print_comp (dpi, options, mod);
d00edca5
DD		 6096 return;
6097 }
6098}
eb383413 6099
d00edca5 6100/* Print a function type, except for the return type. */
eb383413 6101
d00edca5 6102static void
ddee5e46 6103d_print_function_type (struct d_print_info *dpi, int options,
c793cac1 6104 struct demangle_component *dc,
9334f9c6 6105 struct d_print_mod *mods)
eb383413 6106{
331c3da2 6107 int need_paren;
2d733211 6108 int need_space;
331c3da2 6109 struct d_print_mod *p;
d4edd112 6110 struct d_print_mod *hold_modifiers;
331c3da2
DD		 6111
6112 need_paren = 0;
2d733211 6113 need_space = 0;
331c3da2 6114 for (p = mods; p != NULL; p = p->next)
d00edca5 6115 {
331c3da2
DD		 6116 if (p->printed)
6117 break;
eb383413 6118
331c3da2 6119 switch (p->mod->type)
d00edca5 6120 {
2d733211
DD		 6121 case DEMANGLE_COMPONENT_POINTER:
6122 case DEMANGLE_COMPONENT_REFERENCE:
8969a67f 6123 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
2d733211
DD		 6124 need_paren = 1;
6125 break;
59727473
DD		 6126 case DEMANGLE_COMPONENT_RESTRICT:
6127 case DEMANGLE_COMPONENT_VOLATILE:
6128 case DEMANGLE_COMPONENT_CONST:
6129 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
59727473
DD		 6130 case DEMANGLE_COMPONENT_COMPLEX:
6131 case DEMANGLE_COMPONENT_IMAGINARY:
6132 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
2d733211 6133 need_space = 1;
331c3da2
DD		 6134 need_paren = 1;
6135 break;
a4ddf8dc 6136 FNQUAL_COMPONENT_CASE:
858b45cf 6137 break;
331c3da2
DD		 6138 default:
6139 break;
d00edca5 6140 }
331c3da2
DD		 6141 if (need_paren)
6142 break;
6143 }
eb383413 6144
331c3da2 6145 if (need_paren)
858b45cf 6146 {
2d733211 6147 if (! need_space)
858b45cf 6148 {
2d733211
DD		 6149 if (d_last_char (dpi) != '('
6150 && d_last_char (dpi) != '*')
6151 need_space = 1;
858b45cf 6152 }
2d733211
DD		 6153 if (need_space && d_last_char (dpi) != ' ')
6154 d_append_char (dpi, ' ');
858b45cf
DD		 6155 d_append_char (dpi, '(');
6156 }
eb383413 6157
d4edd112
DD		 6158 hold_modifiers = dpi->modifiers;
6159 dpi->modifiers = NULL;
6160
ddee5e46 6161 d_print_mod_list (dpi, options, mods, 0);
eb383413 6162
331c3da2
DD		 6163 if (need_paren)
6164 d_append_char (dpi, ')');
eb383413 6165
d00edca5 6166 d_append_char (dpi, '(');
eb383413 6167
d00edca5 6168 if (d_right (dc) != NULL)
ddee5e46 6169 d_print_comp (dpi, options, d_right (dc));
eb383413 6170
d00edca5 6171 d_append_char (dpi, ')');
858b45cf 6172
ddee5e46 6173 d_print_mod_list (dpi, options, mods, 1);
d4edd112
DD		 6174
6175 dpi->modifiers = hold_modifiers;
d00edca5 6176}
eb383413 6177
d00edca5 6178/* Print an array type, except for the element type. */
eb383413 6179
d00edca5 6180static void
ddee5e46 6181d_print_array_type (struct d_print_info *dpi, int options,
c793cac1 6182 struct demangle_component *dc,
9334f9c6 6183 struct d_print_mod *mods)
d00edca5
DD		 6184{
6185 int need_space;
eb383413 6186
d00edca5
DD		 6187 need_space = 1;
6188 if (mods != NULL)
eb383413 6189 {
d00edca5
DD		 6190 int need_paren;
6191 struct d_print_mod *p;
03d5f569 6192
d00edca5
DD		 6193 need_paren = 0;
6194 for (p = mods; p != NULL; p = p->next)
eb383413 6195 {
74aee4eb 6196 if (! p->printed)
eb383413 6197 {
74aee4eb
DD		 6198 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6199 {
6200 need_space = 0;
6201 break;
6202 }
6203 else
6204 {
6205 need_paren = 1;
6206 need_space = 1;
6207 break;
6208 }
eb383413 6209 }
d00edca5 6210 }
eb383413 6211
d00edca5 6212 if (need_paren)
208c1674 6213 d_append_string (dpi, " (");
eb383413 6214
ddee5e46 6215 d_print_mod_list (dpi, options, mods, 0);
eb383413 6216
d00edca5
DD		 6217 if (need_paren)
6218 d_append_char (dpi, ')');
6219 }
eb383413 6220
d00edca5
DD		 6221 if (need_space)
6222 d_append_char (dpi, ' ');
03d5f569 6223
d00edca5 6224 d_append_char (dpi, '[');
03d5f569 6225
d00edca5 6226 if (d_left (dc) != NULL)
ddee5e46 6227 d_print_comp (dpi, options, d_left (dc));
eb383413 6228
d00edca5
DD		 6229 d_append_char (dpi, ']');
6230}
eb383413 6231
d00edca5 6232/* Print an operator in an expression. */
eb383413 6233
d00edca5 6234static void
ddee5e46 6235d_print_expr_op (struct d_print_info *dpi, int options,
c793cac1 6236 struct demangle_component *dc)
d00edca5 6237{
59727473 6238 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
b6fb00c0
DD		 6239 d_append_buffer (dpi, dc->u.s_operator.op->name,
6240 dc->u.s_operator.op->len);
d00edca5 6241 else
ddee5e46 6242 d_print_comp (dpi, options, dc);
eb383413
L		 6243}
6244
d00edca5 6245/* Print a cast. */
eb383413 6246
d00edca5 6247static void
ddee5e46 6248d_print_cast (struct d_print_info *dpi, int options,
c793cac1 6249 struct demangle_component *dc)
c4be2641
PA		 6250{
6251 d_print_comp (dpi, options, d_left (dc));
6252}
6253
6254/* Print a conversion operator. */
6255
6256static void
6257d_print_conversion (struct d_print_info *dpi, int options,
c793cac1 6258 struct demangle_component *dc)
eb383413 6259{
492e19d0 6260 struct d_print_template dpt;
331c3da2 6261
c4be2641 6262 /* For a conversion operator, we need the template parameters from
492e19d0 6263 the enclosing template in scope for processing the type. */
6264 if (dpi->current_template != NULL)
6265 {
d00edca5
DD		 6266 dpt.next = dpi->templates;
6267 dpi->templates = &dpt;
492e19d0 6268 dpt.template_decl = dpi->current_template;
6269 }
0976f6a7 6270
492e19d0 6271 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
6272 {
6273 d_print_comp (dpi, options, d_left (dc));
6274 if (dpi->current_template != NULL)
6275 dpi->templates = dpt.next;
6276 }
6277 else
6278 {
ddee5e46 6279 d_print_comp (dpi, options, d_left (d_left (dc)));
0976f6a7 6280
492e19d0 6281 /* For a templated cast operator, we need to remove the template
6282 parameters from scope after printing the operator name,
6283 so we need to handle the template printing here. */
6284 if (dpi->current_template != NULL)
6285 dpi->templates = dpt.next;
eb383413 6286
858b45cf
DD		 6287 if (d_last_char (dpi) == '<')
6288 d_append_char (dpi, ' ');
d00edca5 6289 d_append_char (dpi, '<');
ddee5e46 6290 d_print_comp (dpi, options, d_right (d_left (dc)));
d00edca5
DD		 6291 /* Avoid generating two consecutive '>' characters, to avoid
6292 the C++ syntactic ambiguity. */
858b45cf 6293 if (d_last_char (dpi) == '>')
d00edca5
DD		 6294 d_append_char (dpi, ' ');
6295 d_append_char (dpi, '>');
eb383413 6296 }
d00edca5
DD		 6297}
6298
6299/* Initialize the information structure we use to pass around
6300 information. */
6301
59727473
DD		 6302CP_STATIC_IF_GLIBCPP_V3
6303void
9334f9c6
DD		 6304cplus_demangle_init_info (const char *mangled, int options, size_t len,
6305 struct d_info *di)
eb383413 6306{
d00edca5 6307 di->s = mangled;
b6fb00c0 6308 di->send = mangled + len;
d00edca5 6309 di->options = options;
eb383413 6310
d00edca5
DD		 6311 di->n = mangled;
6312
07ffcfec 6313 /* We cannot need more components than twice the number of chars in
d00edca5
DD		 6314 the mangled string. Most components correspond directly to
6315 chars, but the ARGLIST types are exceptions. */
6316 di->num_comps = 2 * len;
d00edca5
DD		 6317 di->next_comp = 0;
6318
07ffcfec 6319 /* Similarly, we cannot need more substitutions than there are
331c3da2
DD		 6320 chars in the mangled string. */
6321 di->num_subs = len;
d00edca5
DD		 6322 di->next_sub = 0;
6323
6324 di->last_name = NULL;
6325
b6fb00c0 6326 di->expansion = 0;
492e19d0 6327 di->is_expression = 0;
6328 di->is_conversion = 0;
af03af8f 6329 di->recursion_level = 0;
eb383413
L		 6330}
6331
208c1674
DD		 6332/* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6333 mangled name, return strings in repeated callback giving the demangled
6334 name. OPTIONS is the usual libiberty demangler options. On success,
6335 this returns 1. On failure, returns 0. */
eb383413 6336
208c1674
DD		 6337static int
6338d_demangle_callback (const char *mangled, int options,
6339 demangle_callbackref callback, void *opaque)
eb383413 6340{
d5031754
DD		 6341 enum
6342 {
6343 DCT_TYPE,
6344 DCT_MANGLED,
6345 DCT_GLOBAL_CTORS,
6346 DCT_GLOBAL_DTORS
6347 }
6348 type;
d00edca5 6349 struct d_info di;
59727473 6350 struct demangle_component *dc;
208c1674 6351 int status;
d00edca5
DD		 6352
6353 if (mangled[0] == '_' && mangled[1] == 'Z')
d5031754 6354 type = DCT_MANGLED;
d00edca5
DD		 6355 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
6356 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
6357 && (mangled[9] == 'D' || mangled[9] == 'I')
6358 && mangled[10] == '_')
d5031754 6359 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
eb383413
L		 6360 else
6361 {
d00edca5 6362 if ((options & DMGL_TYPES) == 0)
208c1674 6363 return 0;
d5031754 6364 type = DCT_TYPE;
eb383413
L		 6365 }
6366
208c1674 6367 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
03d5f569 6368
af03af8f
NC		 6369 /* PR 87675 - Check for a mangled string that is so long
6370 that we do not have enough stack space to demangle it. */
6371 if (((options & DMGL_NO_RECURSE_LIMIT) == 0)
6372 /* This check is a bit arbitrary, since what we really want to do is to
6373 compare the sizes of the di.comps and di.subs arrays against the
6374 amount of stack space remaining. But there is no portable way to do
6375 this, so instead we use the recursion limit as a guide to the maximum
6376 size of the arrays. */
6377 && (unsigned long) di.num_comps > DEMANGLE_RECURSION_LIMIT)
6378 {
6379 /* FIXME: We need a way to indicate that a stack limit has been reached. */
6380 return 0;
6381 }
6382
b6fb00c0
DD		 6383 {
6384#ifdef CP_DYNAMIC_ARRAYS
59727473
DD		 6385 __extension__ struct demangle_component comps[di.num_comps];
6386 __extension__ struct demangle_component *subs[di.num_subs];
b6fb00c0 6387
208c1674
DD		 6388 di.comps = comps;
6389 di.subs = subs;
b6fb00c0 6390#else
208c1674
DD		 6391 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6392 di.subs = alloca (di.num_subs * sizeof (*di.subs));
b6fb00c0
DD		 6393#endif
6394
d5031754
DD		 6395 switch (type)
6396 {
6397 case DCT_TYPE:
6398 dc = cplus_demangle_type (&di);
6399 break;
6400 case DCT_MANGLED:
6401 dc = cplus_demangle_mangled_name (&di, 1);
6402 break;
6403 case DCT_GLOBAL_CTORS:
6404 case DCT_GLOBAL_DTORS:
6405 d_advance (&di, 11);
6406 dc = d_make_comp (&di,
6407 (type == DCT_GLOBAL_CTORS
6408 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6409 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
a0692e36 6410 d_make_demangle_mangled_name (&di, d_str (&di)),
d5031754
DD		 6411 NULL);
6412 d_advance (&di, strlen (d_str (&di)));
6413 break;
8458514f 6414 default:
6415 abort (); /* We have listed all the cases. */
d5031754 6416 }
d00edca5 6417
b6fb00c0
DD		 6418 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6419 mangled string, then we didn't successfully demangle it. If
6420 DMGL_PARAMS is not set, we didn't look at the trailing
6421 parameters. */
6422 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
6423 dc = NULL;
24afc00d 6424
d00edca5 6425#ifdef CP_DEMANGLE_DEBUG
208c1674 6426 d_dump (dc, 0);
d00edca5
DD		 6427#endif
6428
208c1674
DD		 6429 status = (dc != NULL)
6430 ? cplus_demangle_print_callback (options, dc, callback, opaque)
6431 : 0;
6432 }
03d5f569 6433
208c1674
DD		 6434 return status;
6435}
03d5f569 6436
208c1674
DD		 6437/* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6438 name, return a buffer allocated with malloc holding the demangled
6439 name. OPTIONS is the usual libiberty demangler options. On
6440 success, this sets *PALC to the allocated size of the returned
6441 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6442 a memory allocation failure, and returns NULL. */
b6fb00c0 6443
208c1674
DD		 6444static char *
6445d_demangle (const char *mangled, int options, size_t *palc)
6446{
6447 struct d_growable_string dgs;
6448 int status;
03d5f569 6449
208c1674
DD		 6450 d_growable_string_init (&dgs, 0);
6451
6452 status = d_demangle_callback (mangled, options,
6453 d_growable_string_callback_adapter, &dgs);
6454 if (status == 0)
6455 {
6456 free (dgs.buf);
6457 *palc = 0;
6458 return NULL;
6459 }
6460
ffe7cfdf 6461 *palc = dgs.allocation_failure ? 1 : dgs.alc;
208c1674 6462 return dgs.buf;
eb383413
L		 6463}
6464
0c4460bb 6465#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
d00edca5 6466
9334f9c6 6467extern char *__cxa_demangle (const char *, char *, size_t *, int *);
03d5f569 6468
d00edca5
DD		 6469/* ia64 ABI-mandated entry point in the C++ runtime library for
6470 performing demangling. MANGLED_NAME is a NUL-terminated character
6471 string containing the name to be demangled.
03d5f569
JM		 6472
6473 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6474 *LENGTH bytes, into which the demangled name is stored. If
6475 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6476 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
d00edca5 6477 is placed in a region of memory allocated with malloc.
03d5f569 6478
208c1674 6479 If LENGTH is non-NULL, the length of the buffer containing the
d00edca5 6480 demangled name, is placed in *LENGTH.
03d5f569
JM		 6481
6482 The return value is a pointer to the start of the NUL-terminated
6483 demangled name, or NULL if the demangling fails. The caller is
d00edca5 6484 responsible for deallocating this memory using free.
03d5f569
JM		 6485
6486 *STATUS is set to one of the following values:
6487 0: The demangling operation succeeded.
d00edca5 6488 -1: A memory allocation failure occurred.
03d5f569
JM		 6489 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6490 -3: One of the arguments is invalid.
6491
d00edca5 6492 The demangling is performed using the C++ ABI mangling rules, with
03d5f569
JM		 6493 GNU extensions. */
6494
6495char *
9334f9c6
DD		 6496__cxa_demangle (const char *mangled_name, char *output_buffer,
6497 size_t *length, int *status)
03d5f569 6498{
d00edca5
DD		 6499 char *demangled;
6500 size_t alc;
03d5f569 6501
d00edca5
DD		 6502 if (mangled_name == NULL)
6503 {
74aee4eb
DD		 6504 if (status != NULL)
6505 *status = -3;
03d5f569
JM		 6506 return NULL;
6507 }
03d5f569 6508
d00edca5 6509 if (output_buffer != NULL && length == NULL)
03d5f569 6510 {
74aee4eb
DD		 6511 if (status != NULL)
6512 *status = -3;
d00edca5 6513 return NULL;
03d5f569 6514 }
d00edca5 6515
74aee4eb 6516 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
d00edca5
DD		 6517
6518 if (demangled == NULL)
03d5f569 6519 {
74aee4eb
DD		 6520 if (status != NULL)
6521 {
6522 if (alc == 1)
6523 *status = -1;
6524 else
6525 *status = -2;
6526 }
03d5f569
JM		 6527 return NULL;
6528 }
d00edca5
DD		 6529
6530 if (output_buffer == NULL)
6531 {
6532 if (length != NULL)
6533 *length = alc;
6534 }
03d5f569 6535 else
03d5f569 6536 {
d00edca5
DD		 6537 if (strlen (demangled) < *length)
6538 {
6539 strcpy (output_buffer, demangled);
6540 free (demangled);
6541 demangled = output_buffer;
6542 }
6543 else
6544 {
6545 free (output_buffer);
6546 *length = alc;
6547 }
03d5f569 6548 }
d00edca5 6549
74aee4eb
DD		 6550 if (status != NULL)
6551 *status = 0;
d00edca5
DD		 6552
6553 return demangled;
03d5f569
JM		 6554}
6555
208c1674
DD		 6556extern int __gcclibcxx_demangle_callback (const char *,
6557 void (*)
6558 (const char *, size_t, void *),
6559 void *);
6560
6561/* Alternative, allocationless entry point in the C++ runtime library
6562 for performing demangling. MANGLED_NAME is a NUL-terminated character
6563 string containing the name to be demangled.
6564
6565 CALLBACK is a callback function, called with demangled string
6566 segments as demangling progresses; it is called at least once,
6567 but may be called more than once. OPAQUE is a generalized pointer
6568 used as a callback argument.
6569
6570 The return code is one of the following values, equivalent to
6571 the STATUS values of __cxa_demangle() (excluding -1, since this
6572 function performs no memory allocations):
6573 0: The demangling operation succeeded.
6574 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6575 -3: One of the arguments is invalid.
6576
6577 The demangling is performed using the C++ ABI mangling rules, with
6578 GNU extensions. */
6579
6580int
6581__gcclibcxx_demangle_callback (const char *mangled_name,
6582 void (*callback) (const char *, size_t, void *),
6583 void *opaque)
6584{
6585 int status;
6586
6587 if (mangled_name == NULL || callback == NULL)
6588 return -3;
6589
6590 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6591 callback, opaque);
6592 if (status == 0)
6593 return -2;
6594
6595 return 0;
6596}
6597
0c4460bb 6598#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
03d5f569 6599
d00edca5
DD		 6600/* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6601 mangled name, return a buffer allocated with malloc holding the
6602 demangled name. Otherwise, return NULL. */
eb383413
L		 6603
6604char *
208c1674 6605cplus_demangle_v3 (const char *mangled, int options)
eb383413 6606{
d00edca5 6607 size_t alc;
849ee224 6608
d00edca5 6609 return d_demangle (mangled, options, &alc);
eb383413
L		 6610}
6611
208c1674
DD		 6612int
6613cplus_demangle_v3_callback (const char *mangled, int options,
6614 demangle_callbackref callback, void *opaque)
6615{
6616 return d_demangle_callback (mangled, options, callback, opaque);
6617}
6618
bc9bf259
DD		 6619/* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6620 conventions, but the output formatting is a little different.
208c1674
DD		 6621 This instructs the C++ demangler not to emit pointer characters ("*"), to
6622 use Java's namespace separator symbol ("." instead of "::"), and to output
6623 JArray<TYPE> as TYPE[]. */
bc9bf259
DD		 6624
6625char *
208c1674 6626java_demangle_v3 (const char *mangled)
bc9bf259 6627{
d00edca5 6628 size_t alc;
bc9bf259 6629
208c1674
DD		 6630 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6631}
f2160d2b 6632
208c1674
DD		 6633int
6634java_demangle_v3_callback (const char *mangled,
6635 demangle_callbackref callback, void *opaque)
6636{
6637 return d_demangle_callback (mangled,
6638 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6639 callback, opaque);
bc9bf259
DD		 6640}
6641
0c4460bb 6642#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
03d5f569 6643
2a9dffbf 6644#ifndef IN_GLIBCPP_V3
d00edca5
DD		 6645
6646/* Demangle a string in order to find out whether it is a constructor
6647 or destructor. Return non-zero on success. Set *CTOR_KIND and
6648 *DTOR_KIND appropriately. */
6649
6650static int
9334f9c6
DD		 6651is_ctor_or_dtor (const char *mangled,
6652 enum gnu_v3_ctor_kinds *ctor_kind,
6653 enum gnu_v3_dtor_kinds *dtor_kind)
e61231f1 6654{
d00edca5 6655 struct d_info di;
59727473 6656 struct demangle_component *dc;
858b45cf 6657 int ret;
e61231f1 6658
d00edca5
DD		 6659 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6660 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6661
59727473 6662 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
e61231f1 6663
b6fb00c0
DD		 6664 {
6665#ifdef CP_DYNAMIC_ARRAYS
59727473
DD		 6666 __extension__ struct demangle_component comps[di.num_comps];
6667 __extension__ struct demangle_component *subs[di.num_subs];
b6fb00c0 6668
208c1674
DD		 6669 di.comps = comps;
6670 di.subs = subs;
b6fb00c0 6671#else
208c1674
DD		 6672 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6673 di.subs = alloca (di.num_subs * sizeof (*di.subs));
b6fb00c0 6674#endif
d00edca5 6675
59727473 6676 dc = cplus_demangle_mangled_name (&di, 1);
d35d0cd4 6677
b6fb00c0
DD		 6678 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6679 to demangle the entire string. */
e61231f1 6680
b6fb00c0
DD		 6681 ret = 0;
6682 while (dc != NULL)
6683 {
6684 switch (dc->type)
6685 {
3a4d2339
DD		 6686 /* These cannot appear on a constructor or destructor. */
6687 case DEMANGLE_COMPONENT_RESTRICT_THIS:
6688 case DEMANGLE_COMPONENT_VOLATILE_THIS:
6689 case DEMANGLE_COMPONENT_CONST_THIS:
6690 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6691 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
b6fb00c0
DD		 6692 default:
6693 dc = NULL;
6694 break;
59727473
DD		 6695 case DEMANGLE_COMPONENT_TYPED_NAME:
6696 case DEMANGLE_COMPONENT_TEMPLATE:
b6fb00c0
DD		 6697 dc = d_left (dc);
6698 break;
59727473
DD		 6699 case DEMANGLE_COMPONENT_QUAL_NAME:
6700 case DEMANGLE_COMPONENT_LOCAL_NAME:
b6fb00c0
DD		 6701 dc = d_right (dc);
6702 break;
59727473 6703 case DEMANGLE_COMPONENT_CTOR:
b6fb00c0
DD		 6704 *ctor_kind = dc->u.s_ctor.kind;
6705 ret = 1;
6706 dc = NULL;
6707 break;
59727473 6708 case DEMANGLE_COMPONENT_DTOR:
b6fb00c0
DD		 6709 *dtor_kind = dc->u.s_dtor.kind;
6710 ret = 1;
6711 dc = NULL;
6712 break;
6713 }
6714 }
b6fb00c0 6715 }
858b45cf
DD		 6716
6717 return ret;
e61231f1
JB		 6718}
6719
d00edca5
DD		 6720/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6721 name. A non-zero return indicates the type of constructor. */
e61231f1 6722
e61231f1 6723enum gnu_v3_ctor_kinds
9334f9c6 6724is_gnu_v3_mangled_ctor (const char *name)
e61231f1 6725{
d00edca5
DD		 6726 enum gnu_v3_ctor_kinds ctor_kind;
6727 enum gnu_v3_dtor_kinds dtor_kind;
e61231f1 6728
d00edca5 6729 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
585cc78f 6730 return (enum gnu_v3_ctor_kinds) 0;
d00edca5 6731 return ctor_kind;
e61231f1
JB		 6732}
6733
6734
d00edca5
DD		 6735/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6736 name. A non-zero return indicates the type of destructor. */
6737
e61231f1 6738enum gnu_v3_dtor_kinds
9334f9c6 6739is_gnu_v3_mangled_dtor (const char *name)
e61231f1 6740{
d00edca5
DD		 6741 enum gnu_v3_ctor_kinds ctor_kind;
6742 enum gnu_v3_dtor_kinds dtor_kind;
e61231f1 6743
d00edca5 6744 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
585cc78f 6745 return (enum gnu_v3_dtor_kinds) 0;
d00edca5 6746 return dtor_kind;
e61231f1
JB		 6747}
6748
d00edca5 6749#endif /* IN_GLIBCPP_V3 */
e61231f1 6750
eb383413
L		 6751#ifdef STANDALONE_DEMANGLER
6752
6753#include "getopt.h"
d00edca5
DD		 6754#include "dyn-string.h"
6755
e064c173 6756static void print_usage (FILE* fp, int exit_value);
eb383413 6757
d00edca5
DD		 6758#define IS_ALPHA(CHAR) \
6759 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6760 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
eb383413
L		 6761
6762/* Non-zero if CHAR is a character than can occur in a mangled name. */
6763#define is_mangled_char(CHAR) \
74bcd529
DD		 6764 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6765 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
eb383413
L		 6766
6767/* The name of this program, as invoked. */
6768const char* program_name;
6769
6770/* Prints usage summary to FP and then exits with EXIT_VALUE. */
6771
6772static void
9334f9c6 6773print_usage (FILE* fp, int exit_value)
eb383413
L		 6774{
6775 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
74bcd529 6776 fprintf (fp, "Options:\n");
eb383413 6777 fprintf (fp, " -h,--help Display this message.\n");
6d95373e 6778 fprintf (fp, " -p,--no-params Don't display function parameters\n");
eb383413
L		 6779 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
6780 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6781
6782 exit (exit_value);
6783}
6784
6785/* Option specification for getopt_long. */
c23795e2 6786static const struct option long_options[] =
eb383413 6787{
6d95373e
DD		 6788 { "help", no_argument, NULL, 'h' },
6789 { "no-params", no_argument, NULL, 'p' },
6790 { "verbose", no_argument, NULL, 'v' },
6791 { NULL, no_argument, NULL, 0 },
eb383413
L		 6792};
6793
6794/* Main entry for a demangling filter executable. It will demangle
6795 its command line arguments, if any. If none are provided, it will
6796 filter stdin to stdout, replacing any recognized mangled C++ names
6797 with their demangled equivalents. */
6798
6799int
9334f9c6 6800main (int argc, char *argv[])
eb383413 6801{
eb383413
L		 6802 int i;
6803 int opt_char;
d00edca5 6804 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
eb383413
L		 6805
6806 /* Use the program name of this program, as invoked. */
6807 program_name = argv[0];
6808
6809 /* Parse options. */
6810 do
6811 {
6d95373e 6812 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
eb383413
L		 6813 switch (opt_char)
6814 {
6815 case '?': /* Unrecognized option. */
6816 print_usage (stderr, 1);
6817 break;
6818
6819 case 'h':
6820 print_usage (stdout, 0);
6821 break;
6822
6d95373e
DD		 6823 case 'p':
6824 options &= ~ DMGL_PARAMS;
6825 break;
6826
eb383413 6827 case 'v':
d00edca5 6828 options |= DMGL_VERBOSE;
eb383413
L		 6829 break;
6830 }
6831 }
6832 while (opt_char != -1);
6833
6834 if (optind == argc)
6835 /* No command line arguments were provided. Filter stdin. */
6836 {
6837 dyn_string_t mangled = dyn_string_new (3);
d00edca5 6838 char *s;
eb383413
L		 6839
6840 /* Read all of input. */
6841 while (!feof (stdin))
6842 {
d00edca5 6843 char c;
eb383413
L		 6844
6845 /* Pile characters into mangled until we hit one that can't
6846 occur in a mangled name. */
6847 c = getchar ();
6848 while (!feof (stdin) && is_mangled_char (c))
6849 {
6850 dyn_string_append_char (mangled, c);
6851 if (feof (stdin))
6852 break;
6853 c = getchar ();
6854 }
6855
d00edca5 6856 if (dyn_string_length (mangled) > 0)
03d5f569 6857 {
74aee4eb
DD		 6858#ifdef IN_GLIBCPP_V3
6859 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6860#else
d00edca5 6861 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
74aee4eb 6862#endif
d00edca5
DD		 6863
6864 if (s != NULL)
6865 {
6866 fputs (s, stdout);
6867 free (s);
6868 }
6869 else
6870 {
6871 /* It might not have been a mangled name. Print the
6872 original text. */
6873 fputs (dyn_string_buf (mangled), stdout);
6874 }
6875
6876 dyn_string_clear (mangled);
03d5f569 6877 }
eb383413
L		 6878
6879 /* If we haven't hit EOF yet, we've read one character that
6880 can't occur in a mangled name, so print it out. */
6881 if (!feof (stdin))
6882 putchar (c);
eb383413
L		 6883 }
6884
6885 dyn_string_delete (mangled);
eb383413
L		 6886 }
6887 else
6888 /* Demangle command line arguments. */
6889 {
eb383413
L		 6890 /* Loop over command line arguments. */
6891 for (i = optind; i < argc; ++i)
6892 {
d00edca5 6893 char *s;
74aee4eb
DD		 6894#ifdef IN_GLIBCPP_V3
6895 int status;
6896#endif
d00edca5 6897
eb383413 6898 /* Attempt to demangle. */
74aee4eb
DD		 6899#ifdef IN_GLIBCPP_V3
6900 s = __cxa_demangle (argv[i], NULL, NULL, &status);
6901#else
d00edca5 6902 s = cplus_demangle_v3 (argv[i], options);
74aee4eb 6903#endif
eb383413
L		 6904
6905 /* If it worked, print the demangled name. */
d00edca5 6906 if (s != NULL)
03d5f569 6907 {
d00edca5
DD		 6908 printf ("%s\n", s);
6909 free (s);
03d5f569 6910 }
d00edca5 6911 else
74aee4eb
DD		 6912 {
6913#ifdef IN_GLIBCPP_V3
6914 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6915#else
6916 fprintf (stderr, "Failed: %s\n", argv[i]);
6917#endif
6918 }
eb383413 6919 }
eb383413
L		 6920 }
6921
6922 return 0;
6923}
6924
6925#endif /* STANDALONE_DEMANGLER */
A mirror of the official binutils-gdb repository