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