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