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