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