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