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