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