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