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