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