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