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