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