Introduce IntegerRange for options (PR driver/79659).
[official-gcc.git] / libiberty / cp-demangle.c
blob7b8d0b4cbaa699544f11e5cc78f081053e4c9dc8
1 /* Demangler for g++ V3 ABI.
2 Copyright (C) 2003-2017 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@wasabisystems.com>.
5 This file is part of the libiberty library, which is part of GCC.
7 This file is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 In addition to the permissions in the GNU General Public License, the
13 Free Software Foundation gives you unlimited permission to link the
14 compiled version of this file into combinations with other programs,
15 and to distribute those combinations without any restriction coming
16 from the use of this file. (The General Public License restrictions
17 do apply in other respects; for example, they cover modification of
18 the file, and distribution when not linked into a combined
19 executable.)
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
31 /* This code implements a demangler for the g++ V3 ABI. The ABI is
32 described on this web page:
33 http://www.codesourcery.com/cxx-abi/abi.html#mangling
35 This code was written while looking at the demangler written by
36 Alex Samuel <samuel@codesourcery.com>.
38 This code first pulls the mangled name apart into a list of
39 components, and then walks the list generating the demangled
40 name.
42 This file will normally define the following functions, q.v.:
43 char *cplus_demangle_v3(const char *mangled, int options)
44 char *java_demangle_v3(const char *mangled)
45 int cplus_demangle_v3_callback(const char *mangled, int options,
46 demangle_callbackref callback)
47 int java_demangle_v3_callback(const char *mangled,
48 demangle_callbackref callback)
49 enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
50 enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
52 Also, the interface to the component list is public, and defined in
53 demangle.h. The interface consists of these types, which are
54 defined in demangle.h:
55 enum demangle_component_type
56 struct demangle_component
57 demangle_callbackref
58 and these functions defined in this file:
59 cplus_demangle_fill_name
60 cplus_demangle_fill_extended_operator
61 cplus_demangle_fill_ctor
62 cplus_demangle_fill_dtor
63 cplus_demangle_print
64 cplus_demangle_print_callback
65 and other functions defined in the file cp-demint.c.
67 This file also defines some other functions and variables which are
68 only to be used by the file cp-demint.c.
70 Preprocessor macros you can define while compiling this file:
72 IN_LIBGCC2
73 If defined, this file defines the following functions, q.v.:
74 char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
75 int *status)
76 int __gcclibcxx_demangle_callback (const char *,
77 void (*)
78 (const char *, size_t, void *),
79 void *)
80 instead of cplus_demangle_v3[_callback]() and
81 java_demangle_v3[_callback]().
83 IN_GLIBCPP_V3
84 If defined, this file defines only __cxa_demangle() and
85 __gcclibcxx_demangle_callback(), and no other publically visible
86 functions or variables.
88 STANDALONE_DEMANGLER
89 If defined, this file defines a main() function which demangles
90 any arguments, or, if none, demangles stdin.
92 CP_DEMANGLE_DEBUG
93 If defined, turns on debugging mode, which prints information on
94 stdout about the mangled string. This is not generally useful.
96 CHECK_DEMANGLER
97 If defined, additional sanity checks will be performed. It will
98 cause some slowdown, but will allow to catch out-of-bound access
99 errors earlier. This macro is intended for testing and debugging. */
101 #if defined (_AIX) && !defined (__GNUC__)
102 #pragma alloca
103 #endif
105 #ifdef HAVE_CONFIG_H
106 #include "config.h"
107 #endif
109 #include <stdio.h>
111 #ifdef HAVE_STDLIB_H
112 #include <stdlib.h>
113 #endif
114 #ifdef HAVE_STRING_H
115 #include <string.h>
116 #endif
118 #ifdef HAVE_ALLOCA_H
119 # include <alloca.h>
120 #else
121 # ifndef alloca
122 # ifdef __GNUC__
123 # define alloca __builtin_alloca
124 # else
125 extern char *alloca ();
126 # endif /* __GNUC__ */
127 # endif /* alloca */
128 #endif /* HAVE_ALLOCA_H */
130 #ifdef HAVE_LIMITS_H
131 #include <limits.h>
132 #endif
133 #ifndef INT_MAX
134 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
135 #endif
137 #include "ansidecl.h"
138 #include "libiberty.h"
139 #include "demangle.h"
140 #include "cp-demangle.h"
142 /* If IN_GLIBCPP_V3 is defined, some functions are made static. We
143 also rename them via #define to avoid compiler errors when the
144 static definition conflicts with the extern declaration in a header
145 file. */
146 #ifdef IN_GLIBCPP_V3
148 #define CP_STATIC_IF_GLIBCPP_V3 static
150 #define cplus_demangle_fill_name d_fill_name
151 static int d_fill_name (struct demangle_component *, const char *, int);
153 #define cplus_demangle_fill_extended_operator d_fill_extended_operator
154 static int
155 d_fill_extended_operator (struct demangle_component *, int,
156 struct demangle_component *);
158 #define cplus_demangle_fill_ctor d_fill_ctor
159 static int
160 d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
161 struct demangle_component *);
163 #define cplus_demangle_fill_dtor d_fill_dtor
164 static int
165 d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
166 struct demangle_component *);
168 #define cplus_demangle_mangled_name d_mangled_name
169 static struct demangle_component *d_mangled_name (struct d_info *, int);
171 #define cplus_demangle_type d_type
172 static struct demangle_component *d_type (struct d_info *);
174 #define cplus_demangle_print d_print
175 static char *d_print (int, struct demangle_component *, int, size_t *);
177 #define cplus_demangle_print_callback d_print_callback
178 static int d_print_callback (int, struct demangle_component *,
179 demangle_callbackref, void *);
181 #define cplus_demangle_init_info d_init_info
182 static void d_init_info (const char *, int, size_t, struct d_info *);
184 #else /* ! defined(IN_GLIBCPP_V3) */
185 #define CP_STATIC_IF_GLIBCPP_V3
186 #endif /* ! defined(IN_GLIBCPP_V3) */
188 /* See if the compiler supports dynamic arrays. */
190 #ifdef __GNUC__
191 #define CP_DYNAMIC_ARRAYS
192 #else
193 #ifdef __STDC__
194 #ifdef __STDC_VERSION__
195 #if __STDC_VERSION__ >= 199901L
196 #define CP_DYNAMIC_ARRAYS
197 #endif /* __STDC__VERSION >= 199901L */
198 #endif /* defined (__STDC_VERSION__) */
199 #endif /* defined (__STDC__) */
200 #endif /* ! defined (__GNUC__) */
202 /* We avoid pulling in the ctype tables, to prevent pulling in
203 additional unresolved symbols when this code is used in a library.
204 FIXME: Is this really a valid reason? This comes from the original
205 V3 demangler code.
207 As of this writing this file has the following undefined references
208 when compiled with -DIN_GLIBCPP_V3: realloc, free, memcpy, strcpy,
209 strcat, strlen. */
211 #define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
212 #define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
213 #define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
215 /* The prefix prepended by GCC to an identifier represnting the
216 anonymous namespace. */
217 #define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
218 #define ANONYMOUS_NAMESPACE_PREFIX_LEN \
219 (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
221 /* Information we keep for the standard substitutions. */
223 struct d_standard_sub_info
225 /* The code for this substitution. */
226 char code;
227 /* The simple string it expands to. */
228 const char *simple_expansion;
229 /* The length of the simple expansion. */
230 int simple_len;
231 /* The results of a full, verbose, expansion. This is used when
232 qualifying a constructor/destructor, or when in verbose mode. */
233 const char *full_expansion;
234 /* The length of the full expansion. */
235 int full_len;
236 /* What to set the last_name field of d_info to; NULL if we should
237 not set it. This is only relevant when qualifying a
238 constructor/destructor. */
239 const char *set_last_name;
240 /* The length of set_last_name. */
241 int set_last_name_len;
244 /* Accessors for subtrees of struct demangle_component. */
246 #define d_left(dc) ((dc)->u.s_binary.left)
247 #define d_right(dc) ((dc)->u.s_binary.right)
249 /* A list of templates. This is used while printing. */
251 struct d_print_template
253 /* Next template on the list. */
254 struct d_print_template *next;
255 /* This template. */
256 const struct demangle_component *template_decl;
259 /* A list of type modifiers. This is used while printing. */
261 struct d_print_mod
263 /* Next modifier on the list. These are in the reverse of the order
264 in which they appeared in the mangled string. */
265 struct d_print_mod *next;
266 /* The modifier. */
267 struct demangle_component *mod;
268 /* Whether this modifier was printed. */
269 int printed;
270 /* The list of templates which applies to this modifier. */
271 struct d_print_template *templates;
274 /* We use these structures to hold information during printing. */
276 struct d_growable_string
278 /* Buffer holding the result. */
279 char *buf;
280 /* Current length of data in buffer. */
281 size_t len;
282 /* Allocated size of buffer. */
283 size_t alc;
284 /* Set to 1 if we had a memory allocation failure. */
285 int allocation_failure;
288 /* Stack of components, innermost first, used to avoid loops. */
290 struct d_component_stack
292 /* This component. */
293 const struct demangle_component *dc;
294 /* This component's parent. */
295 const struct d_component_stack *parent;
298 /* A demangle component and some scope captured when it was first
299 traversed. */
301 struct d_saved_scope
303 /* The component whose scope this is. */
304 const struct demangle_component *container;
305 /* The list of templates, if any, that was current when this
306 scope was captured. */
307 struct d_print_template *templates;
310 /* Checkpoint structure to allow backtracking. This holds copies
311 of the fields of struct d_info that need to be restored
312 if a trial parse needs to be backtracked over. */
314 struct d_info_checkpoint
316 const char *n;
317 int next_comp;
318 int next_sub;
319 int expansion;
322 /* Maximum number of times d_print_comp may be called recursively. */
323 #define MAX_RECURSION_COUNT 1024
325 enum { D_PRINT_BUFFER_LENGTH = 256 };
326 struct d_print_info
328 /* Fixed-length allocated buffer for demangled data, flushed to the
329 callback with a NUL termination once full. */
330 char buf[D_PRINT_BUFFER_LENGTH];
331 /* Current length of data in buffer. */
332 size_t len;
333 /* The last character printed, saved individually so that it survives
334 any buffer flush. */
335 char last_char;
336 /* Callback function to handle demangled buffer flush. */
337 demangle_callbackref callback;
338 /* Opaque callback argument. */
339 void *opaque;
340 /* The current list of templates, if any. */
341 struct d_print_template *templates;
342 /* The current list of modifiers (e.g., pointer, reference, etc.),
343 if any. */
344 struct d_print_mod *modifiers;
345 /* Set to 1 if we saw a demangling error. */
346 int demangle_failure;
347 /* Number of times d_print_comp was recursively called. Should not
348 be bigger than MAX_RECURSION_COUNT. */
349 int recursion;
350 /* Non-zero if we're printing a lambda argument. A template
351 parameter reference actually means 'auto'. */
352 int is_lambda_arg;
353 /* The current index into any template argument packs we are using
354 for printing, or -1 to print the whole pack. */
355 int pack_index;
356 /* Number of d_print_flush calls so far. */
357 unsigned long int flush_count;
358 /* Stack of components, innermost first, used to avoid loops. */
359 const struct d_component_stack *component_stack;
360 /* Array of saved scopes for evaluating substitutions. */
361 struct d_saved_scope *saved_scopes;
362 /* Index of the next unused saved scope in the above array. */
363 int next_saved_scope;
364 /* Number of saved scopes in the above array. */
365 int num_saved_scopes;
366 /* Array of templates for saving into scopes. */
367 struct d_print_template *copy_templates;
368 /* Index of the next unused copy template in the above array. */
369 int next_copy_template;
370 /* Number of copy templates in the above array. */
371 int num_copy_templates;
372 /* The nearest enclosing template, if any. */
373 const struct demangle_component *current_template;
376 #ifdef CP_DEMANGLE_DEBUG
377 static void d_dump (struct demangle_component *, int);
378 #endif
380 static struct demangle_component *
381 d_make_empty (struct d_info *);
383 static struct demangle_component *
384 d_make_comp (struct d_info *, enum demangle_component_type,
385 struct demangle_component *,
386 struct demangle_component *);
388 static struct demangle_component *
389 d_make_name (struct d_info *, const char *, int);
391 static struct demangle_component *
392 d_make_demangle_mangled_name (struct d_info *, const char *);
394 static struct demangle_component *
395 d_make_builtin_type (struct d_info *,
396 const struct demangle_builtin_type_info *);
398 static struct demangle_component *
399 d_make_operator (struct d_info *,
400 const struct demangle_operator_info *);
402 static struct demangle_component *
403 d_make_extended_operator (struct d_info *, int,
404 struct demangle_component *);
406 static struct demangle_component *
407 d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
408 struct demangle_component *);
410 static struct demangle_component *
411 d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
412 struct demangle_component *);
414 static struct demangle_component *
415 d_make_template_param (struct d_info *, int);
417 static struct demangle_component *
418 d_make_sub (struct d_info *, const char *, int);
420 static int
421 has_return_type (struct demangle_component *);
423 static int
424 is_ctor_dtor_or_conversion (struct demangle_component *);
426 static struct demangle_component *d_encoding (struct d_info *, int);
428 static struct demangle_component *d_name (struct d_info *);
430 static struct demangle_component *d_nested_name (struct d_info *);
432 static struct demangle_component *d_prefix (struct d_info *);
434 static struct demangle_component *d_unqualified_name (struct d_info *);
436 static struct demangle_component *d_source_name (struct d_info *);
438 static int d_number (struct d_info *);
440 static struct demangle_component *d_identifier (struct d_info *, int);
442 static struct demangle_component *d_operator_name (struct d_info *);
444 static struct demangle_component *d_special_name (struct d_info *);
446 static struct demangle_component *d_parmlist (struct d_info *);
448 static int d_call_offset (struct d_info *, int);
450 static struct demangle_component *d_ctor_dtor_name (struct d_info *);
452 static struct demangle_component **
453 d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
455 static struct demangle_component *
456 d_ref_qualifier (struct d_info *, struct demangle_component *);
458 static struct demangle_component *
459 d_function_type (struct d_info *);
461 static struct demangle_component *
462 d_bare_function_type (struct d_info *, int);
464 static struct demangle_component *
465 d_class_enum_type (struct d_info *);
467 static struct demangle_component *d_array_type (struct d_info *);
469 static struct demangle_component *d_vector_type (struct d_info *);
471 static struct demangle_component *
472 d_pointer_to_member_type (struct d_info *);
474 static struct demangle_component *
475 d_template_param (struct d_info *);
477 static struct demangle_component *d_template_args (struct d_info *);
478 static struct demangle_component *d_template_args_1 (struct d_info *);
480 static struct demangle_component *
481 d_template_arg (struct d_info *);
483 static struct demangle_component *d_expression (struct d_info *);
485 static struct demangle_component *d_expr_primary (struct d_info *);
487 static struct demangle_component *d_local_name (struct d_info *);
489 static int d_discriminator (struct d_info *);
491 static struct demangle_component *d_lambda (struct d_info *);
493 static struct demangle_component *d_unnamed_type (struct d_info *);
495 static struct demangle_component *
496 d_clone_suffix (struct d_info *, struct demangle_component *);
498 static int
499 d_add_substitution (struct d_info *, struct demangle_component *);
501 static struct demangle_component *d_substitution (struct d_info *, int);
503 static void d_checkpoint (struct d_info *, struct d_info_checkpoint *);
505 static void d_backtrack (struct d_info *, struct d_info_checkpoint *);
507 static void d_growable_string_init (struct d_growable_string *, size_t);
509 static inline void
510 d_growable_string_resize (struct d_growable_string *, size_t);
512 static inline void
513 d_growable_string_append_buffer (struct d_growable_string *,
514 const char *, size_t);
515 static void
516 d_growable_string_callback_adapter (const char *, size_t, void *);
518 static void
519 d_print_init (struct d_print_info *, demangle_callbackref, void *,
520 const struct demangle_component *);
522 static inline void d_print_error (struct d_print_info *);
524 static inline int d_print_saw_error (struct d_print_info *);
526 static inline void d_print_flush (struct d_print_info *);
528 static inline void d_append_char (struct d_print_info *, char);
530 static inline void d_append_buffer (struct d_print_info *,
531 const char *, size_t);
533 static inline void d_append_string (struct d_print_info *, const char *);
535 static inline char d_last_char (struct d_print_info *);
537 static void
538 d_print_comp (struct d_print_info *, int, struct demangle_component *);
540 static void
541 d_print_java_identifier (struct d_print_info *, const char *, int);
543 static void
544 d_print_mod_list (struct d_print_info *, int, struct d_print_mod *, int);
546 static void
547 d_print_mod (struct d_print_info *, int, struct demangle_component *);
549 static void
550 d_print_function_type (struct d_print_info *, int,
551 struct demangle_component *,
552 struct d_print_mod *);
554 static void
555 d_print_array_type (struct d_print_info *, int,
556 struct demangle_component *,
557 struct d_print_mod *);
559 static void
560 d_print_expr_op (struct d_print_info *, int, struct demangle_component *);
562 static void d_print_cast (struct d_print_info *, int,
563 struct demangle_component *);
564 static void d_print_conversion (struct d_print_info *, int,
565 struct demangle_component *);
567 static int d_demangle_callback (const char *, int,
568 demangle_callbackref, void *);
569 static char *d_demangle (const char *, int, size_t *);
571 /* True iff TYPE is a demangling component representing a
572 function-type-qualifier. */
574 static int
575 is_fnqual_component_type (enum demangle_component_type type)
577 return (type == DEMANGLE_COMPONENT_RESTRICT_THIS
578 || type == DEMANGLE_COMPONENT_VOLATILE_THIS
579 || type == DEMANGLE_COMPONENT_CONST_THIS
580 || type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
581 || type == DEMANGLE_COMPONENT_TRANSACTION_SAFE
582 || type == DEMANGLE_COMPONENT_NOEXCEPT
583 || type == DEMANGLE_COMPONENT_THROW_SPEC
584 || type == DEMANGLE_COMPONENT_REFERENCE_THIS);
587 #define FNQUAL_COMPONENT_CASE \
588 case DEMANGLE_COMPONENT_RESTRICT_THIS: \
589 case DEMANGLE_COMPONENT_VOLATILE_THIS: \
590 case DEMANGLE_COMPONENT_CONST_THIS: \
591 case DEMANGLE_COMPONENT_REFERENCE_THIS: \
592 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
593 case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
594 case DEMANGLE_COMPONENT_NOEXCEPT: \
595 case DEMANGLE_COMPONENT_THROW_SPEC
597 #ifdef CP_DEMANGLE_DEBUG
599 static void
600 d_dump (struct demangle_component *dc, int indent)
602 int i;
604 if (dc == NULL)
606 if (indent == 0)
607 printf ("failed demangling\n");
608 return;
611 for (i = 0; i < indent; ++i)
612 putchar (' ');
614 switch (dc->type)
616 case DEMANGLE_COMPONENT_NAME:
617 printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
618 return;
619 case DEMANGLE_COMPONENT_TAGGED_NAME:
620 printf ("tagged name\n");
621 d_dump (dc->u.s_binary.left, indent + 2);
622 d_dump (dc->u.s_binary.right, indent + 2);
623 return;
624 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
625 printf ("template parameter %ld\n", dc->u.s_number.number);
626 return;
627 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
628 printf ("function parameter %ld\n", dc->u.s_number.number);
629 return;
630 case DEMANGLE_COMPONENT_CTOR:
631 printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
632 d_dump (dc->u.s_ctor.name, indent + 2);
633 return;
634 case DEMANGLE_COMPONENT_DTOR:
635 printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
636 d_dump (dc->u.s_dtor.name, indent + 2);
637 return;
638 case DEMANGLE_COMPONENT_SUB_STD:
639 printf ("standard substitution %s\n", dc->u.s_string.string);
640 return;
641 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
642 printf ("builtin type %s\n", dc->u.s_builtin.type->name);
643 return;
644 case DEMANGLE_COMPONENT_OPERATOR:
645 printf ("operator %s\n", dc->u.s_operator.op->name);
646 return;
647 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
648 printf ("extended operator with %d args\n",
649 dc->u.s_extended_operator.args);
650 d_dump (dc->u.s_extended_operator.name, indent + 2);
651 return;
653 case DEMANGLE_COMPONENT_QUAL_NAME:
654 printf ("qualified name\n");
655 break;
656 case DEMANGLE_COMPONENT_LOCAL_NAME:
657 printf ("local name\n");
658 break;
659 case DEMANGLE_COMPONENT_TYPED_NAME:
660 printf ("typed name\n");
661 break;
662 case DEMANGLE_COMPONENT_TEMPLATE:
663 printf ("template\n");
664 break;
665 case DEMANGLE_COMPONENT_VTABLE:
666 printf ("vtable\n");
667 break;
668 case DEMANGLE_COMPONENT_VTT:
669 printf ("VTT\n");
670 break;
671 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
672 printf ("construction vtable\n");
673 break;
674 case DEMANGLE_COMPONENT_TYPEINFO:
675 printf ("typeinfo\n");
676 break;
677 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
678 printf ("typeinfo name\n");
679 break;
680 case DEMANGLE_COMPONENT_TYPEINFO_FN:
681 printf ("typeinfo function\n");
682 break;
683 case DEMANGLE_COMPONENT_THUNK:
684 printf ("thunk\n");
685 break;
686 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
687 printf ("virtual thunk\n");
688 break;
689 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
690 printf ("covariant thunk\n");
691 break;
692 case DEMANGLE_COMPONENT_JAVA_CLASS:
693 printf ("java class\n");
694 break;
695 case DEMANGLE_COMPONENT_GUARD:
696 printf ("guard\n");
697 break;
698 case DEMANGLE_COMPONENT_REFTEMP:
699 printf ("reference temporary\n");
700 break;
701 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
702 printf ("hidden alias\n");
703 break;
704 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
705 printf ("transaction clone\n");
706 break;
707 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
708 printf ("non-transaction clone\n");
709 break;
710 case DEMANGLE_COMPONENT_RESTRICT:
711 printf ("restrict\n");
712 break;
713 case DEMANGLE_COMPONENT_VOLATILE:
714 printf ("volatile\n");
715 break;
716 case DEMANGLE_COMPONENT_CONST:
717 printf ("const\n");
718 break;
719 case DEMANGLE_COMPONENT_RESTRICT_THIS:
720 printf ("restrict this\n");
721 break;
722 case DEMANGLE_COMPONENT_VOLATILE_THIS:
723 printf ("volatile this\n");
724 break;
725 case DEMANGLE_COMPONENT_CONST_THIS:
726 printf ("const this\n");
727 break;
728 case DEMANGLE_COMPONENT_REFERENCE_THIS:
729 printf ("reference this\n");
730 break;
731 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
732 printf ("rvalue reference this\n");
733 break;
734 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
735 printf ("transaction_safe this\n");
736 break;
737 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
738 printf ("vendor type qualifier\n");
739 break;
740 case DEMANGLE_COMPONENT_POINTER:
741 printf ("pointer\n");
742 break;
743 case DEMANGLE_COMPONENT_REFERENCE:
744 printf ("reference\n");
745 break;
746 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
747 printf ("rvalue reference\n");
748 break;
749 case DEMANGLE_COMPONENT_COMPLEX:
750 printf ("complex\n");
751 break;
752 case DEMANGLE_COMPONENT_IMAGINARY:
753 printf ("imaginary\n");
754 break;
755 case DEMANGLE_COMPONENT_VENDOR_TYPE:
756 printf ("vendor type\n");
757 break;
758 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
759 printf ("function type\n");
760 break;
761 case DEMANGLE_COMPONENT_ARRAY_TYPE:
762 printf ("array type\n");
763 break;
764 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
765 printf ("pointer to member type\n");
766 break;
767 case DEMANGLE_COMPONENT_FIXED_TYPE:
768 printf ("fixed-point type, accum? %d, sat? %d\n",
769 dc->u.s_fixed.accum, dc->u.s_fixed.sat);
770 d_dump (dc->u.s_fixed.length, indent + 2);
771 break;
772 case DEMANGLE_COMPONENT_ARGLIST:
773 printf ("argument list\n");
774 break;
775 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
776 printf ("template argument list\n");
777 break;
778 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
779 printf ("initializer list\n");
780 break;
781 case DEMANGLE_COMPONENT_CAST:
782 printf ("cast\n");
783 break;
784 case DEMANGLE_COMPONENT_CONVERSION:
785 printf ("conversion operator\n");
786 break;
787 case DEMANGLE_COMPONENT_NULLARY:
788 printf ("nullary operator\n");
789 break;
790 case DEMANGLE_COMPONENT_UNARY:
791 printf ("unary operator\n");
792 break;
793 case DEMANGLE_COMPONENT_BINARY:
794 printf ("binary operator\n");
795 break;
796 case DEMANGLE_COMPONENT_BINARY_ARGS:
797 printf ("binary operator arguments\n");
798 break;
799 case DEMANGLE_COMPONENT_TRINARY:
800 printf ("trinary operator\n");
801 break;
802 case DEMANGLE_COMPONENT_TRINARY_ARG1:
803 printf ("trinary operator arguments 1\n");
804 break;
805 case DEMANGLE_COMPONENT_TRINARY_ARG2:
806 printf ("trinary operator arguments 1\n");
807 break;
808 case DEMANGLE_COMPONENT_LITERAL:
809 printf ("literal\n");
810 break;
811 case DEMANGLE_COMPONENT_LITERAL_NEG:
812 printf ("negative literal\n");
813 break;
814 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
815 printf ("java resource\n");
816 break;
817 case DEMANGLE_COMPONENT_COMPOUND_NAME:
818 printf ("compound name\n");
819 break;
820 case DEMANGLE_COMPONENT_CHARACTER:
821 printf ("character '%c'\n", dc->u.s_character.character);
822 return;
823 case DEMANGLE_COMPONENT_NUMBER:
824 printf ("number %ld\n", dc->u.s_number.number);
825 return;
826 case DEMANGLE_COMPONENT_DECLTYPE:
827 printf ("decltype\n");
828 break;
829 case DEMANGLE_COMPONENT_PACK_EXPANSION:
830 printf ("pack expansion\n");
831 break;
832 case DEMANGLE_COMPONENT_TLS_INIT:
833 printf ("tls init function\n");
834 break;
835 case DEMANGLE_COMPONENT_TLS_WRAPPER:
836 printf ("tls wrapper function\n");
837 break;
838 case DEMANGLE_COMPONENT_DEFAULT_ARG:
839 printf ("default argument %d\n", dc->u.s_unary_num.num);
840 d_dump (dc->u.s_unary_num.sub, indent+2);
841 return;
842 case DEMANGLE_COMPONENT_LAMBDA:
843 printf ("lambda %d\n", dc->u.s_unary_num.num);
844 d_dump (dc->u.s_unary_num.sub, indent+2);
845 return;
848 d_dump (d_left (dc), indent + 2);
849 d_dump (d_right (dc), indent + 2);
852 #endif /* CP_DEMANGLE_DEBUG */
854 /* Fill in a DEMANGLE_COMPONENT_NAME. */
856 CP_STATIC_IF_GLIBCPP_V3
858 cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
860 if (p == NULL || s == NULL || len == 0)
861 return 0;
862 p->d_printing = 0;
863 p->type = DEMANGLE_COMPONENT_NAME;
864 p->u.s_name.s = s;
865 p->u.s_name.len = len;
866 return 1;
869 /* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR. */
871 CP_STATIC_IF_GLIBCPP_V3
873 cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
874 struct demangle_component *name)
876 if (p == NULL || args < 0 || name == NULL)
877 return 0;
878 p->d_printing = 0;
879 p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
880 p->u.s_extended_operator.args = args;
881 p->u.s_extended_operator.name = name;
882 return 1;
885 /* Fill in a DEMANGLE_COMPONENT_CTOR. */
887 CP_STATIC_IF_GLIBCPP_V3
889 cplus_demangle_fill_ctor (struct demangle_component *p,
890 enum gnu_v3_ctor_kinds kind,
891 struct demangle_component *name)
893 if (p == NULL
894 || name == NULL
895 || (int) kind < gnu_v3_complete_object_ctor
896 || (int) kind > gnu_v3_object_ctor_group)
897 return 0;
898 p->d_printing = 0;
899 p->type = DEMANGLE_COMPONENT_CTOR;
900 p->u.s_ctor.kind = kind;
901 p->u.s_ctor.name = name;
902 return 1;
905 /* Fill in a DEMANGLE_COMPONENT_DTOR. */
907 CP_STATIC_IF_GLIBCPP_V3
909 cplus_demangle_fill_dtor (struct demangle_component *p,
910 enum gnu_v3_dtor_kinds kind,
911 struct demangle_component *name)
913 if (p == NULL
914 || name == NULL
915 || (int) kind < gnu_v3_deleting_dtor
916 || (int) kind > gnu_v3_object_dtor_group)
917 return 0;
918 p->d_printing = 0;
919 p->type = DEMANGLE_COMPONENT_DTOR;
920 p->u.s_dtor.kind = kind;
921 p->u.s_dtor.name = name;
922 return 1;
925 /* Add a new component. */
927 static struct demangle_component *
928 d_make_empty (struct d_info *di)
930 struct demangle_component *p;
932 if (di->next_comp >= di->num_comps)
933 return NULL;
934 p = &di->comps[di->next_comp];
935 p->d_printing = 0;
936 ++di->next_comp;
937 return p;
940 /* Add a new generic component. */
942 static struct demangle_component *
943 d_make_comp (struct d_info *di, enum demangle_component_type type,
944 struct demangle_component *left,
945 struct demangle_component *right)
947 struct demangle_component *p;
949 /* We check for errors here. A typical error would be a NULL return
950 from a subroutine. We catch those here, and return NULL
951 upward. */
952 switch (type)
954 /* These types require two parameters. */
955 case DEMANGLE_COMPONENT_QUAL_NAME:
956 case DEMANGLE_COMPONENT_LOCAL_NAME:
957 case DEMANGLE_COMPONENT_TYPED_NAME:
958 case DEMANGLE_COMPONENT_TAGGED_NAME:
959 case DEMANGLE_COMPONENT_TEMPLATE:
960 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
961 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
962 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
963 case DEMANGLE_COMPONENT_UNARY:
964 case DEMANGLE_COMPONENT_BINARY:
965 case DEMANGLE_COMPONENT_BINARY_ARGS:
966 case DEMANGLE_COMPONENT_TRINARY:
967 case DEMANGLE_COMPONENT_TRINARY_ARG1:
968 case DEMANGLE_COMPONENT_LITERAL:
969 case DEMANGLE_COMPONENT_LITERAL_NEG:
970 case DEMANGLE_COMPONENT_COMPOUND_NAME:
971 case DEMANGLE_COMPONENT_VECTOR_TYPE:
972 case DEMANGLE_COMPONENT_CLONE:
973 if (left == NULL || right == NULL)
974 return NULL;
975 break;
977 /* These types only require one parameter. */
978 case DEMANGLE_COMPONENT_VTABLE:
979 case DEMANGLE_COMPONENT_VTT:
980 case DEMANGLE_COMPONENT_TYPEINFO:
981 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
982 case DEMANGLE_COMPONENT_TYPEINFO_FN:
983 case DEMANGLE_COMPONENT_THUNK:
984 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
985 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
986 case DEMANGLE_COMPONENT_JAVA_CLASS:
987 case DEMANGLE_COMPONENT_GUARD:
988 case DEMANGLE_COMPONENT_TLS_INIT:
989 case DEMANGLE_COMPONENT_TLS_WRAPPER:
990 case DEMANGLE_COMPONENT_REFTEMP:
991 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
992 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
993 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
994 case DEMANGLE_COMPONENT_POINTER:
995 case DEMANGLE_COMPONENT_REFERENCE:
996 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
997 case DEMANGLE_COMPONENT_COMPLEX:
998 case DEMANGLE_COMPONENT_IMAGINARY:
999 case DEMANGLE_COMPONENT_VENDOR_TYPE:
1000 case DEMANGLE_COMPONENT_CAST:
1001 case DEMANGLE_COMPONENT_CONVERSION:
1002 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
1003 case DEMANGLE_COMPONENT_DECLTYPE:
1004 case DEMANGLE_COMPONENT_PACK_EXPANSION:
1005 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
1006 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
1007 case DEMANGLE_COMPONENT_NULLARY:
1008 case DEMANGLE_COMPONENT_TRINARY_ARG2:
1009 if (left == NULL)
1010 return NULL;
1011 break;
1013 /* This needs a right parameter, but the left parameter can be
1014 empty. */
1015 case DEMANGLE_COMPONENT_ARRAY_TYPE:
1016 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
1017 if (right == NULL)
1018 return NULL;
1019 break;
1021 /* These are allowed to have no parameters--in some cases they
1022 will be filled in later. */
1023 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
1024 case DEMANGLE_COMPONENT_RESTRICT:
1025 case DEMANGLE_COMPONENT_VOLATILE:
1026 case DEMANGLE_COMPONENT_CONST:
1027 case DEMANGLE_COMPONENT_ARGLIST:
1028 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
1029 FNQUAL_COMPONENT_CASE:
1030 break;
1032 /* Other types should not be seen here. */
1033 default:
1034 return NULL;
1037 p = d_make_empty (di);
1038 if (p != NULL)
1040 p->type = type;
1041 p->u.s_binary.left = left;
1042 p->u.s_binary.right = right;
1044 return p;
1047 /* Add a new demangle mangled name component. */
1049 static struct demangle_component *
1050 d_make_demangle_mangled_name (struct d_info *di, const char *s)
1052 if (d_peek_char (di) != '_' || d_peek_next_char (di) != 'Z')
1053 return d_make_name (di, s, strlen (s));
1054 d_advance (di, 2);
1055 return d_encoding (di, 0);
1058 /* Add a new name component. */
1060 static struct demangle_component *
1061 d_make_name (struct d_info *di, const char *s, int len)
1063 struct demangle_component *p;
1065 p = d_make_empty (di);
1066 if (! cplus_demangle_fill_name (p, s, len))
1067 return NULL;
1068 return p;
1071 /* Add a new builtin type component. */
1073 static struct demangle_component *
1074 d_make_builtin_type (struct d_info *di,
1075 const struct demangle_builtin_type_info *type)
1077 struct demangle_component *p;
1079 if (type == NULL)
1080 return NULL;
1081 p = d_make_empty (di);
1082 if (p != NULL)
1084 p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
1085 p->u.s_builtin.type = type;
1087 return p;
1090 /* Add a new operator component. */
1092 static struct demangle_component *
1093 d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
1095 struct demangle_component *p;
1097 p = d_make_empty (di);
1098 if (p != NULL)
1100 p->type = DEMANGLE_COMPONENT_OPERATOR;
1101 p->u.s_operator.op = op;
1103 return p;
1106 /* Add a new extended operator component. */
1108 static struct demangle_component *
1109 d_make_extended_operator (struct d_info *di, int args,
1110 struct demangle_component *name)
1112 struct demangle_component *p;
1114 p = d_make_empty (di);
1115 if (! cplus_demangle_fill_extended_operator (p, args, name))
1116 return NULL;
1117 return p;
1120 static struct demangle_component *
1121 d_make_default_arg (struct d_info *di, int num,
1122 struct demangle_component *sub)
1124 struct demangle_component *p = d_make_empty (di);
1125 if (p)
1127 p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
1128 p->u.s_unary_num.num = num;
1129 p->u.s_unary_num.sub = sub;
1131 return p;
1134 /* Add a new constructor component. */
1136 static struct demangle_component *
1137 d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
1138 struct demangle_component *name)
1140 struct demangle_component *p;
1142 p = d_make_empty (di);
1143 if (! cplus_demangle_fill_ctor (p, kind, name))
1144 return NULL;
1145 return p;
1148 /* Add a new destructor component. */
1150 static struct demangle_component *
1151 d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
1152 struct demangle_component *name)
1154 struct demangle_component *p;
1156 p = d_make_empty (di);
1157 if (! cplus_demangle_fill_dtor (p, kind, name))
1158 return NULL;
1159 return p;
1162 /* Add a new template parameter. */
1164 static struct demangle_component *
1165 d_make_template_param (struct d_info *di, int i)
1167 struct demangle_component *p;
1169 p = d_make_empty (di);
1170 if (p != NULL)
1172 p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
1173 p->u.s_number.number = i;
1175 return p;
1178 /* Add a new function parameter. */
1180 static struct demangle_component *
1181 d_make_function_param (struct d_info *di, int i)
1183 struct demangle_component *p;
1185 p = d_make_empty (di);
1186 if (p != NULL)
1188 p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
1189 p->u.s_number.number = i;
1191 return p;
1194 /* Add a new standard substitution component. */
1196 static struct demangle_component *
1197 d_make_sub (struct d_info *di, const char *name, int len)
1199 struct demangle_component *p;
1201 p = d_make_empty (di);
1202 if (p != NULL)
1204 p->type = DEMANGLE_COMPONENT_SUB_STD;
1205 p->u.s_string.string = name;
1206 p->u.s_string.len = len;
1208 return p;
1211 /* <mangled-name> ::= _Z <encoding> [<clone-suffix>]*
1213 TOP_LEVEL is non-zero when called at the top level. */
1215 CP_STATIC_IF_GLIBCPP_V3
1216 struct demangle_component *
1217 cplus_demangle_mangled_name (struct d_info *di, int top_level)
1219 struct demangle_component *p;
1221 if (! d_check_char (di, '_')
1222 /* Allow missing _ if not at toplevel to work around a
1223 bug in G++ abi-version=2 mangling; see the comment in
1224 write_template_arg. */
1225 && top_level)
1226 return NULL;
1227 if (! d_check_char (di, 'Z'))
1228 return NULL;
1229 p = d_encoding (di, top_level);
1231 /* If at top level and parsing parameters, check for a clone
1232 suffix. */
1233 if (top_level && (di->options & DMGL_PARAMS) != 0)
1234 while (d_peek_char (di) == '.'
1235 && (IS_LOWER (d_peek_next_char (di))
1236 || d_peek_next_char (di) == '_'
1237 || IS_DIGIT (d_peek_next_char (di))))
1238 p = d_clone_suffix (di, p);
1240 return p;
1243 /* Return whether a function should have a return type. The argument
1244 is the function name, which may be qualified in various ways. The
1245 rules are that template functions have return types with some
1246 exceptions, function types which are not part of a function name
1247 mangling have return types with some exceptions, and non-template
1248 function names do not have return types. The exceptions are that
1249 constructors, destructors, and conversion operators do not have
1250 return types. */
1252 static int
1253 has_return_type (struct demangle_component *dc)
1255 if (dc == NULL)
1256 return 0;
1257 switch (dc->type)
1259 default:
1260 return 0;
1261 case DEMANGLE_COMPONENT_TEMPLATE:
1262 return ! is_ctor_dtor_or_conversion (d_left (dc));
1263 FNQUAL_COMPONENT_CASE:
1264 return has_return_type (d_left (dc));
1268 /* Return whether a name is a constructor, a destructor, or a
1269 conversion operator. */
1271 static int
1272 is_ctor_dtor_or_conversion (struct demangle_component *dc)
1274 if (dc == NULL)
1275 return 0;
1276 switch (dc->type)
1278 default:
1279 return 0;
1280 case DEMANGLE_COMPONENT_QUAL_NAME:
1281 case DEMANGLE_COMPONENT_LOCAL_NAME:
1282 return is_ctor_dtor_or_conversion (d_right (dc));
1283 case DEMANGLE_COMPONENT_CTOR:
1284 case DEMANGLE_COMPONENT_DTOR:
1285 case DEMANGLE_COMPONENT_CONVERSION:
1286 return 1;
1290 /* <encoding> ::= <(function) name> <bare-function-type>
1291 ::= <(data) name>
1292 ::= <special-name>
1294 TOP_LEVEL is non-zero when called at the top level, in which case
1295 if DMGL_PARAMS is not set we do not demangle the function
1296 parameters. We only set this at the top level, because otherwise
1297 we would not correctly demangle names in local scopes. */
1299 static struct demangle_component *
1300 d_encoding (struct d_info *di, int top_level)
1302 char peek = d_peek_char (di);
1304 if (peek == 'G' || peek == 'T')
1305 return d_special_name (di);
1306 else
1308 struct demangle_component *dc;
1310 dc = d_name (di);
1312 if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
1314 /* Strip off any initial CV-qualifiers, as they really apply
1315 to the `this' parameter, and they were not output by the
1316 v2 demangler without DMGL_PARAMS. */
1317 while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1318 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1319 || dc->type == DEMANGLE_COMPONENT_CONST_THIS
1320 || dc->type == DEMANGLE_COMPONENT_REFERENCE_THIS
1321 || dc->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS)
1322 dc = d_left (dc);
1324 /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1325 there may be function-qualifiers on its right argument which
1326 really apply here; this happens when parsing a class
1327 which is local to a function. */
1328 if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1330 struct demangle_component *dcr;
1332 dcr = d_right (dc);
1333 while (is_fnqual_component_type (dcr->type))
1334 dcr = d_left (dcr);
1335 dc->u.s_binary.right = dcr;
1338 return dc;
1341 peek = d_peek_char (di);
1342 if (dc == NULL || peek == '\0' || peek == 'E')
1343 return dc;
1344 return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1345 d_bare_function_type (di, has_return_type (dc)));
1349 /* <tagged-name> ::= <name> B <source-name> */
1351 static struct demangle_component *
1352 d_abi_tags (struct d_info *di, struct demangle_component *dc)
1354 struct demangle_component *hold_last_name;
1355 char peek;
1357 /* Preserve the last name, so the ABI tag doesn't clobber it. */
1358 hold_last_name = di->last_name;
1360 while (peek = d_peek_char (di),
1361 peek == 'B')
1363 struct demangle_component *tag;
1364 d_advance (di, 1);
1365 tag = d_source_name (di);
1366 dc = d_make_comp (di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
1369 di->last_name = hold_last_name;
1371 return dc;
1374 /* <name> ::= <nested-name>
1375 ::= <unscoped-name>
1376 ::= <unscoped-template-name> <template-args>
1377 ::= <local-name>
1379 <unscoped-name> ::= <unqualified-name>
1380 ::= St <unqualified-name>
1382 <unscoped-template-name> ::= <unscoped-name>
1383 ::= <substitution>
1386 static struct demangle_component *
1387 d_name (struct d_info *di)
1389 char peek = d_peek_char (di);
1390 struct demangle_component *dc;
1392 switch (peek)
1394 case 'N':
1395 return d_nested_name (di);
1397 case 'Z':
1398 return d_local_name (di);
1400 case 'U':
1401 return d_unqualified_name (di);
1403 case 'S':
1405 int subst;
1407 if (d_peek_next_char (di) != 't')
1409 dc = d_substitution (di, 0);
1410 subst = 1;
1412 else
1414 d_advance (di, 2);
1415 dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1416 d_make_name (di, "std", 3),
1417 d_unqualified_name (di));
1418 di->expansion += 3;
1419 subst = 0;
1422 if (d_peek_char (di) != 'I')
1424 /* The grammar does not permit this case to occur if we
1425 called d_substitution() above (i.e., subst == 1). We
1426 don't bother to check. */
1428 else
1430 /* This is <template-args>, which means that we just saw
1431 <unscoped-template-name>, which is a substitution
1432 candidate if we didn't just get it from a
1433 substitution. */
1434 if (! subst)
1436 if (! d_add_substitution (di, dc))
1437 return NULL;
1439 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1440 d_template_args (di));
1443 return dc;
1446 case 'L':
1447 default:
1448 dc = d_unqualified_name (di);
1449 if (d_peek_char (di) == 'I')
1451 /* This is <template-args>, which means that we just saw
1452 <unscoped-template-name>, which is a substitution
1453 candidate. */
1454 if (! d_add_substitution (di, dc))
1455 return NULL;
1456 dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1457 d_template_args (di));
1459 return dc;
1463 /* <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix> <unqualified-name> E
1464 ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix> <template-args> E
1467 static struct demangle_component *
1468 d_nested_name (struct d_info *di)
1470 struct demangle_component *ret;
1471 struct demangle_component **pret;
1472 struct demangle_component *rqual;
1474 if (! d_check_char (di, 'N'))
1475 return NULL;
1477 pret = d_cv_qualifiers (di, &ret, 1);
1478 if (pret == NULL)
1479 return NULL;
1481 /* Parse the ref-qualifier now and then attach it
1482 once we have something to attach it to. */
1483 rqual = d_ref_qualifier (di, NULL);
1485 *pret = d_prefix (di);
1486 if (*pret == NULL)
1487 return NULL;
1489 if (rqual)
1491 d_left (rqual) = ret;
1492 ret = rqual;
1495 if (! d_check_char (di, 'E'))
1496 return NULL;
1498 return ret;
1501 /* <prefix> ::= <prefix> <unqualified-name>
1502 ::= <template-prefix> <template-args>
1503 ::= <template-param>
1504 ::= <decltype>
1506 ::= <substitution>
1508 <template-prefix> ::= <prefix> <(template) unqualified-name>
1509 ::= <template-param>
1510 ::= <substitution>
1513 static struct demangle_component *
1514 d_prefix (struct d_info *di)
1516 struct demangle_component *ret = NULL;
1518 while (1)
1520 char peek;
1521 enum demangle_component_type comb_type;
1522 struct demangle_component *dc;
1524 peek = d_peek_char (di);
1525 if (peek == '\0')
1526 return NULL;
1528 /* The older code accepts a <local-name> here, but I don't see
1529 that in the grammar. The older code does not accept a
1530 <template-param> here. */
1532 comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1533 if (peek == 'D')
1535 char peek2 = d_peek_next_char (di);
1536 if (peek2 == 'T' || peek2 == 't')
1537 /* Decltype. */
1538 dc = cplus_demangle_type (di);
1539 else
1540 /* Destructor name. */
1541 dc = d_unqualified_name (di);
1543 else if (IS_DIGIT (peek)
1544 || IS_LOWER (peek)
1545 || peek == 'C'
1546 || peek == 'U'
1547 || peek == 'L')
1548 dc = d_unqualified_name (di);
1549 else if (peek == 'S')
1550 dc = d_substitution (di, 1);
1551 else if (peek == 'I')
1553 if (ret == NULL)
1554 return NULL;
1555 comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1556 dc = d_template_args (di);
1558 else if (peek == 'T')
1559 dc = d_template_param (di);
1560 else if (peek == 'E')
1561 return ret;
1562 else if (peek == 'M')
1564 /* Initializer scope for a lambda. We don't need to represent
1565 this; the normal code will just treat the variable as a type
1566 scope, which gives appropriate output. */
1567 if (ret == NULL)
1568 return NULL;
1569 d_advance (di, 1);
1570 continue;
1572 else
1573 return NULL;
1575 if (ret == NULL)
1576 ret = dc;
1577 else
1578 ret = d_make_comp (di, comb_type, ret, dc);
1580 if (peek != 'S' && d_peek_char (di) != 'E')
1582 if (! d_add_substitution (di, ret))
1583 return NULL;
1588 /* <unqualified-name> ::= <operator-name>
1589 ::= <ctor-dtor-name>
1590 ::= <source-name>
1591 ::= <local-source-name>
1593 <local-source-name> ::= L <source-name> <discriminator>
1596 static struct demangle_component *
1597 d_unqualified_name (struct d_info *di)
1599 struct demangle_component *ret;
1600 char peek;
1602 peek = d_peek_char (di);
1603 if (IS_DIGIT (peek))
1604 ret = d_source_name (di);
1605 else if (IS_LOWER (peek))
1607 if (peek == 'o' && d_peek_next_char (di) == 'n')
1608 d_advance (di, 2);
1609 ret = d_operator_name (di);
1610 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1612 di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1613 if (!strcmp (ret->u.s_operator.op->code, "li"))
1614 ret = d_make_comp (di, DEMANGLE_COMPONENT_UNARY, ret,
1615 d_source_name (di));
1618 else if (peek == 'C' || peek == 'D')
1619 ret = d_ctor_dtor_name (di);
1620 else if (peek == 'L')
1622 d_advance (di, 1);
1624 ret = d_source_name (di);
1625 if (ret == NULL)
1626 return NULL;
1627 if (! d_discriminator (di))
1628 return NULL;
1630 else if (peek == 'U')
1632 switch (d_peek_next_char (di))
1634 case 'l':
1635 ret = d_lambda (di);
1636 break;
1637 case 't':
1638 ret = d_unnamed_type (di);
1639 break;
1640 default:
1641 return NULL;
1644 else
1645 return NULL;
1647 if (d_peek_char (di) == 'B')
1648 ret = d_abi_tags (di, ret);
1649 return ret;
1652 /* <source-name> ::= <(positive length) number> <identifier> */
1654 static struct demangle_component *
1655 d_source_name (struct d_info *di)
1657 int len;
1658 struct demangle_component *ret;
1660 len = d_number (di);
1661 if (len <= 0)
1662 return NULL;
1663 ret = d_identifier (di, len);
1664 di->last_name = ret;
1665 return ret;
1668 /* number ::= [n] <(non-negative decimal integer)> */
1670 static int
1671 d_number (struct d_info *di)
1673 int negative;
1674 char peek;
1675 int ret;
1677 negative = 0;
1678 peek = d_peek_char (di);
1679 if (peek == 'n')
1681 negative = 1;
1682 d_advance (di, 1);
1683 peek = d_peek_char (di);
1686 ret = 0;
1687 while (1)
1689 if (! IS_DIGIT (peek))
1691 if (negative)
1692 ret = - ret;
1693 return ret;
1695 if (ret > ((INT_MAX - (peek - '0')) / 10))
1696 return -1;
1697 ret = ret * 10 + peek - '0';
1698 d_advance (di, 1);
1699 peek = d_peek_char (di);
1703 /* Like d_number, but returns a demangle_component. */
1705 static struct demangle_component *
1706 d_number_component (struct d_info *di)
1708 struct demangle_component *ret = d_make_empty (di);
1709 if (ret)
1711 ret->type = DEMANGLE_COMPONENT_NUMBER;
1712 ret->u.s_number.number = d_number (di);
1714 return ret;
1717 /* identifier ::= <(unqualified source code identifier)> */
1719 static struct demangle_component *
1720 d_identifier (struct d_info *di, int len)
1722 const char *name;
1724 name = d_str (di);
1726 if (di->send - name < len)
1727 return NULL;
1729 d_advance (di, len);
1731 /* A Java mangled name may have a trailing '$' if it is a C++
1732 keyword. This '$' is not included in the length count. We just
1733 ignore the '$'. */
1734 if ((di->options & DMGL_JAVA) != 0
1735 && d_peek_char (di) == '$')
1736 d_advance (di, 1);
1738 /* Look for something which looks like a gcc encoding of an
1739 anonymous namespace, and replace it with a more user friendly
1740 name. */
1741 if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1742 && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1743 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1745 const char *s;
1747 s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1748 if ((*s == '.' || *s == '_' || *s == '$')
1749 && s[1] == 'N')
1751 di->expansion -= len - sizeof "(anonymous namespace)";
1752 return d_make_name (di, "(anonymous namespace)",
1753 sizeof "(anonymous namespace)" - 1);
1757 return d_make_name (di, name, len);
1760 /* operator_name ::= many different two character encodings.
1761 ::= cv <type>
1762 ::= v <digit> <source-name>
1764 This list is sorted for binary search. */
1766 #define NL(s) s, (sizeof s) - 1
1768 CP_STATIC_IF_GLIBCPP_V3
1769 const struct demangle_operator_info cplus_demangle_operators[] =
1771 { "aN", NL ("&="), 2 },
1772 { "aS", NL ("="), 2 },
1773 { "aa", NL ("&&"), 2 },
1774 { "ad", NL ("&"), 1 },
1775 { "an", NL ("&"), 2 },
1776 { "at", NL ("alignof "), 1 },
1777 { "az", NL ("alignof "), 1 },
1778 { "cc", NL ("const_cast"), 2 },
1779 { "cl", NL ("()"), 2 },
1780 { "cm", NL (","), 2 },
1781 { "co", NL ("~"), 1 },
1782 { "dV", NL ("/="), 2 },
1783 { "da", NL ("delete[] "), 1 },
1784 { "dc", NL ("dynamic_cast"), 2 },
1785 { "de", NL ("*"), 1 },
1786 { "dl", NL ("delete "), 1 },
1787 { "ds", NL (".*"), 2 },
1788 { "dt", NL ("."), 2 },
1789 { "dv", NL ("/"), 2 },
1790 { "eO", NL ("^="), 2 },
1791 { "eo", NL ("^"), 2 },
1792 { "eq", NL ("=="), 2 },
1793 { "fL", NL ("..."), 3 },
1794 { "fR", NL ("..."), 3 },
1795 { "fl", NL ("..."), 2 },
1796 { "fr", NL ("..."), 2 },
1797 { "ge", NL (">="), 2 },
1798 { "gs", NL ("::"), 1 },
1799 { "gt", NL (">"), 2 },
1800 { "ix", NL ("[]"), 2 },
1801 { "lS", NL ("<<="), 2 },
1802 { "le", NL ("<="), 2 },
1803 { "li", NL ("operator\"\" "), 1 },
1804 { "ls", NL ("<<"), 2 },
1805 { "lt", NL ("<"), 2 },
1806 { "mI", NL ("-="), 2 },
1807 { "mL", NL ("*="), 2 },
1808 { "mi", NL ("-"), 2 },
1809 { "ml", NL ("*"), 2 },
1810 { "mm", NL ("--"), 1 },
1811 { "na", NL ("new[]"), 3 },
1812 { "ne", NL ("!="), 2 },
1813 { "ng", NL ("-"), 1 },
1814 { "nt", NL ("!"), 1 },
1815 { "nw", NL ("new"), 3 },
1816 { "oR", NL ("|="), 2 },
1817 { "oo", NL ("||"), 2 },
1818 { "or", NL ("|"), 2 },
1819 { "pL", NL ("+="), 2 },
1820 { "pl", NL ("+"), 2 },
1821 { "pm", NL ("->*"), 2 },
1822 { "pp", NL ("++"), 1 },
1823 { "ps", NL ("+"), 1 },
1824 { "pt", NL ("->"), 2 },
1825 { "qu", NL ("?"), 3 },
1826 { "rM", NL ("%="), 2 },
1827 { "rS", NL (">>="), 2 },
1828 { "rc", NL ("reinterpret_cast"), 2 },
1829 { "rm", NL ("%"), 2 },
1830 { "rs", NL (">>"), 2 },
1831 { "sP", NL ("sizeof..."), 1 },
1832 { "sZ", NL ("sizeof..."), 1 },
1833 { "sc", NL ("static_cast"), 2 },
1834 { "st", NL ("sizeof "), 1 },
1835 { "sz", NL ("sizeof "), 1 },
1836 { "tr", NL ("throw"), 0 },
1837 { "tw", NL ("throw "), 1 },
1838 { NULL, NULL, 0, 0 }
1841 static struct demangle_component *
1842 d_operator_name (struct d_info *di)
1844 char c1;
1845 char c2;
1847 c1 = d_next_char (di);
1848 c2 = d_next_char (di);
1849 if (c1 == 'v' && IS_DIGIT (c2))
1850 return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1851 else if (c1 == 'c' && c2 == 'v')
1853 struct demangle_component *type;
1854 int was_conversion = di->is_conversion;
1855 struct demangle_component *res;
1857 di->is_conversion = ! di->is_expression;
1858 type = cplus_demangle_type (di);
1859 if (di->is_conversion)
1860 res = d_make_comp (di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
1861 else
1862 res = d_make_comp (di, DEMANGLE_COMPONENT_CAST, type, NULL);
1863 di->is_conversion = was_conversion;
1864 return res;
1866 else
1868 /* LOW is the inclusive lower bound. */
1869 int low = 0;
1870 /* HIGH is the exclusive upper bound. We subtract one to ignore
1871 the sentinel at the end of the array. */
1872 int high = ((sizeof (cplus_demangle_operators)
1873 / sizeof (cplus_demangle_operators[0]))
1874 - 1);
1876 while (1)
1878 int i;
1879 const struct demangle_operator_info *p;
1881 i = low + (high - low) / 2;
1882 p = cplus_demangle_operators + i;
1884 if (c1 == p->code[0] && c2 == p->code[1])
1885 return d_make_operator (di, p);
1887 if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1888 high = i;
1889 else
1890 low = i + 1;
1891 if (low == high)
1892 return NULL;
1897 static struct demangle_component *
1898 d_make_character (struct d_info *di, int c)
1900 struct demangle_component *p;
1901 p = d_make_empty (di);
1902 if (p != NULL)
1904 p->type = DEMANGLE_COMPONENT_CHARACTER;
1905 p->u.s_character.character = c;
1907 return p;
1910 static struct demangle_component *
1911 d_java_resource (struct d_info *di)
1913 struct demangle_component *p = NULL;
1914 struct demangle_component *next = NULL;
1915 int len, i;
1916 char c;
1917 const char *str;
1919 len = d_number (di);
1920 if (len <= 1)
1921 return NULL;
1923 /* Eat the leading '_'. */
1924 if (d_next_char (di) != '_')
1925 return NULL;
1926 len--;
1928 str = d_str (di);
1929 i = 0;
1931 while (len > 0)
1933 c = str[i];
1934 if (!c)
1935 return NULL;
1937 /* Each chunk is either a '$' escape... */
1938 if (c == '$')
1940 i++;
1941 switch (str[i++])
1943 case 'S':
1944 c = '/';
1945 break;
1946 case '_':
1947 c = '.';
1948 break;
1949 case '$':
1950 c = '$';
1951 break;
1952 default:
1953 return NULL;
1955 next = d_make_character (di, c);
1956 d_advance (di, i);
1957 str = d_str (di);
1958 len -= i;
1959 i = 0;
1960 if (next == NULL)
1961 return NULL;
1963 /* ... or a sequence of characters. */
1964 else
1966 while (i < len && str[i] && str[i] != '$')
1967 i++;
1969 next = d_make_name (di, str, i);
1970 d_advance (di, i);
1971 str = d_str (di);
1972 len -= i;
1973 i = 0;
1974 if (next == NULL)
1975 return NULL;
1978 if (p == NULL)
1979 p = next;
1980 else
1982 p = d_make_comp (di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
1983 if (p == NULL)
1984 return NULL;
1988 p = d_make_comp (di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
1990 return p;
1993 /* <special-name> ::= TV <type>
1994 ::= TT <type>
1995 ::= TI <type>
1996 ::= TS <type>
1997 ::= GV <(object) name>
1998 ::= T <call-offset> <(base) encoding>
1999 ::= Tc <call-offset> <call-offset> <(base) encoding>
2000 Also g++ extensions:
2001 ::= TC <type> <(offset) number> _ <(base) type>
2002 ::= TF <type>
2003 ::= TJ <type>
2004 ::= GR <name>
2005 ::= GA <encoding>
2006 ::= Gr <resource name>
2007 ::= GTt <encoding>
2008 ::= GTn <encoding>
2011 static struct demangle_component *
2012 d_special_name (struct d_info *di)
2014 di->expansion += 20;
2015 if (d_check_char (di, 'T'))
2017 switch (d_next_char (di))
2019 case 'V':
2020 di->expansion -= 5;
2021 return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
2022 cplus_demangle_type (di), NULL);
2023 case 'T':
2024 di->expansion -= 10;
2025 return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
2026 cplus_demangle_type (di), NULL);
2027 case 'I':
2028 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
2029 cplus_demangle_type (di), NULL);
2030 case 'S':
2031 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
2032 cplus_demangle_type (di), NULL);
2034 case 'h':
2035 if (! d_call_offset (di, 'h'))
2036 return NULL;
2037 return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
2038 d_encoding (di, 0), NULL);
2040 case 'v':
2041 if (! d_call_offset (di, 'v'))
2042 return NULL;
2043 return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
2044 d_encoding (di, 0), NULL);
2046 case 'c':
2047 if (! d_call_offset (di, '\0'))
2048 return NULL;
2049 if (! d_call_offset (di, '\0'))
2050 return NULL;
2051 return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
2052 d_encoding (di, 0), NULL);
2054 case 'C':
2056 struct demangle_component *derived_type;
2057 int offset;
2058 struct demangle_component *base_type;
2060 derived_type = cplus_demangle_type (di);
2061 offset = d_number (di);
2062 if (offset < 0)
2063 return NULL;
2064 if (! d_check_char (di, '_'))
2065 return NULL;
2066 base_type = cplus_demangle_type (di);
2067 /* We don't display the offset. FIXME: We should display
2068 it in verbose mode. */
2069 di->expansion += 5;
2070 return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
2071 base_type, derived_type);
2074 case 'F':
2075 return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
2076 cplus_demangle_type (di), NULL);
2077 case 'J':
2078 return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
2079 cplus_demangle_type (di), NULL);
2081 case 'H':
2082 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_INIT,
2083 d_name (di), NULL);
2085 case 'W':
2086 return d_make_comp (di, DEMANGLE_COMPONENT_TLS_WRAPPER,
2087 d_name (di), NULL);
2089 default:
2090 return NULL;
2093 else if (d_check_char (di, 'G'))
2095 switch (d_next_char (di))
2097 case 'V':
2098 return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
2100 case 'R':
2102 struct demangle_component *name = d_name (di);
2103 return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, name,
2104 d_number_component (di));
2107 case 'A':
2108 return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
2109 d_encoding (di, 0), NULL);
2111 case 'T':
2112 switch (d_next_char (di))
2114 case 'n':
2115 return d_make_comp (di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
2116 d_encoding (di, 0), NULL);
2117 default:
2118 /* ??? The proposal is that other letters (such as 'h') stand
2119 for different variants of transaction cloning, such as
2120 compiling directly for hardware transaction support. But
2121 they still should all be transactional clones of some sort
2122 so go ahead and call them that. */
2123 case 't':
2124 return d_make_comp (di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
2125 d_encoding (di, 0), NULL);
2128 case 'r':
2129 return d_java_resource (di);
2131 default:
2132 return NULL;
2135 else
2136 return NULL;
2139 /* <call-offset> ::= h <nv-offset> _
2140 ::= v <v-offset> _
2142 <nv-offset> ::= <(offset) number>
2144 <v-offset> ::= <(offset) number> _ <(virtual offset) number>
2146 The C parameter, if not '\0', is a character we just read which is
2147 the start of the <call-offset>.
2149 We don't display the offset information anywhere. FIXME: We should
2150 display it in verbose mode. */
2152 static int
2153 d_call_offset (struct d_info *di, int c)
2155 if (c == '\0')
2156 c = d_next_char (di);
2158 if (c == 'h')
2159 d_number (di);
2160 else if (c == 'v')
2162 d_number (di);
2163 if (! d_check_char (di, '_'))
2164 return 0;
2165 d_number (di);
2167 else
2168 return 0;
2170 if (! d_check_char (di, '_'))
2171 return 0;
2173 return 1;
2176 /* <ctor-dtor-name> ::= C1
2177 ::= C2
2178 ::= C3
2179 ::= D0
2180 ::= D1
2181 ::= D2
2184 static struct demangle_component *
2185 d_ctor_dtor_name (struct d_info *di)
2187 if (di->last_name != NULL)
2189 if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
2190 di->expansion += di->last_name->u.s_name.len;
2191 else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
2192 di->expansion += di->last_name->u.s_string.len;
2194 switch (d_peek_char (di))
2196 case 'C':
2198 enum gnu_v3_ctor_kinds kind;
2199 int inheriting = 0;
2201 if (d_peek_next_char (di) == 'I')
2203 inheriting = 1;
2204 d_advance (di, 1);
2207 switch (d_peek_next_char (di))
2209 case '1':
2210 kind = gnu_v3_complete_object_ctor;
2211 break;
2212 case '2':
2213 kind = gnu_v3_base_object_ctor;
2214 break;
2215 case '3':
2216 kind = gnu_v3_complete_object_allocating_ctor;
2217 break;
2218 case '4':
2219 kind = gnu_v3_unified_ctor;
2220 break;
2221 case '5':
2222 kind = gnu_v3_object_ctor_group;
2223 break;
2224 default:
2225 return NULL;
2228 d_advance (di, 2);
2230 if (inheriting)
2231 cplus_demangle_type (di);
2233 return d_make_ctor (di, kind, di->last_name);
2236 case 'D':
2238 enum gnu_v3_dtor_kinds kind;
2240 switch (d_peek_next_char (di))
2242 case '0':
2243 kind = gnu_v3_deleting_dtor;
2244 break;
2245 case '1':
2246 kind = gnu_v3_complete_object_dtor;
2247 break;
2248 case '2':
2249 kind = gnu_v3_base_object_dtor;
2250 break;
2251 /* digit '3' is not used */
2252 case '4':
2253 kind = gnu_v3_unified_dtor;
2254 break;
2255 case '5':
2256 kind = gnu_v3_object_dtor_group;
2257 break;
2258 default:
2259 return NULL;
2261 d_advance (di, 2);
2262 return d_make_dtor (di, kind, di->last_name);
2265 default:
2266 return NULL;
2270 /* True iff we're looking at an order-insensitive type-qualifier, including
2271 function-type-qualifiers. */
2273 static int
2274 next_is_type_qual (struct d_info *di)
2276 char peek = d_peek_char (di);
2277 if (peek == 'r' || peek == 'V' || peek == 'K')
2278 return 1;
2279 if (peek == 'D')
2281 peek = d_peek_next_char (di);
2282 if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
2283 return 1;
2285 return 0;
2288 /* <type> ::= <builtin-type>
2289 ::= <function-type>
2290 ::= <class-enum-type>
2291 ::= <array-type>
2292 ::= <pointer-to-member-type>
2293 ::= <template-param>
2294 ::= <template-template-param> <template-args>
2295 ::= <substitution>
2296 ::= <CV-qualifiers> <type>
2297 ::= P <type>
2298 ::= R <type>
2299 ::= O <type> (C++0x)
2300 ::= C <type>
2301 ::= G <type>
2302 ::= U <source-name> <type>
2304 <builtin-type> ::= various one letter codes
2305 ::= u <source-name>
2308 CP_STATIC_IF_GLIBCPP_V3
2309 const struct demangle_builtin_type_info
2310 cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
2312 /* a */ { NL ("signed char"), NL ("signed char"), D_PRINT_DEFAULT },
2313 /* b */ { NL ("bool"), NL ("boolean"), D_PRINT_BOOL },
2314 /* c */ { NL ("char"), NL ("byte"), D_PRINT_DEFAULT },
2315 /* d */ { NL ("double"), NL ("double"), D_PRINT_FLOAT },
2316 /* e */ { NL ("long double"), NL ("long double"), D_PRINT_FLOAT },
2317 /* f */ { NL ("float"), NL ("float"), D_PRINT_FLOAT },
2318 /* g */ { NL ("__float128"), NL ("__float128"), D_PRINT_FLOAT },
2319 /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
2320 /* i */ { NL ("int"), NL ("int"), D_PRINT_INT },
2321 /* j */ { NL ("unsigned int"), NL ("unsigned"), D_PRINT_UNSIGNED },
2322 /* k */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2323 /* l */ { NL ("long"), NL ("long"), D_PRINT_LONG },
2324 /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
2325 /* n */ { NL ("__int128"), NL ("__int128"), D_PRINT_DEFAULT },
2326 /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
2327 D_PRINT_DEFAULT },
2328 /* p */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2329 /* q */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2330 /* r */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2331 /* s */ { NL ("short"), NL ("short"), D_PRINT_DEFAULT },
2332 /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
2333 /* u */ { NULL, 0, NULL, 0, D_PRINT_DEFAULT },
2334 /* v */ { NL ("void"), NL ("void"), D_PRINT_VOID },
2335 /* w */ { NL ("wchar_t"), NL ("char"), D_PRINT_DEFAULT },
2336 /* x */ { NL ("long long"), NL ("long"), D_PRINT_LONG_LONG },
2337 /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
2338 D_PRINT_UNSIGNED_LONG_LONG },
2339 /* z */ { NL ("..."), NL ("..."), D_PRINT_DEFAULT },
2340 /* 26 */ { NL ("decimal32"), NL ("decimal32"), D_PRINT_DEFAULT },
2341 /* 27 */ { NL ("decimal64"), NL ("decimal64"), D_PRINT_DEFAULT },
2342 /* 28 */ { NL ("decimal128"), NL ("decimal128"), D_PRINT_DEFAULT },
2343 /* 29 */ { NL ("half"), NL ("half"), D_PRINT_FLOAT },
2344 /* 30 */ { NL ("char16_t"), NL ("char16_t"), D_PRINT_DEFAULT },
2345 /* 31 */ { NL ("char32_t"), NL ("char32_t"), D_PRINT_DEFAULT },
2346 /* 32 */ { NL ("decltype(nullptr)"), NL ("decltype(nullptr)"),
2347 D_PRINT_DEFAULT },
2350 CP_STATIC_IF_GLIBCPP_V3
2351 struct demangle_component *
2352 cplus_demangle_type (struct d_info *di)
2354 char peek;
2355 struct demangle_component *ret;
2356 int can_subst;
2358 /* The ABI specifies that when CV-qualifiers are used, the base type
2359 is substitutable, and the fully qualified type is substitutable,
2360 but the base type with a strict subset of the CV-qualifiers is
2361 not substitutable. The natural recursive implementation of the
2362 CV-qualifiers would cause subsets to be substitutable, so instead
2363 we pull them all off now.
2365 FIXME: The ABI says that order-insensitive vendor qualifiers
2366 should be handled in the same way, but we have no way to tell
2367 which vendor qualifiers are order-insensitive and which are
2368 order-sensitive. So we just assume that they are all
2369 order-sensitive. g++ 3.4 supports only one vendor qualifier,
2370 __vector, and it treats it as order-sensitive when mangling
2371 names. */
2373 if (next_is_type_qual (di))
2375 struct demangle_component **pret;
2377 pret = d_cv_qualifiers (di, &ret, 0);
2378 if (pret == NULL)
2379 return NULL;
2380 if (d_peek_char (di) == 'F')
2382 /* cv-qualifiers before a function type apply to 'this',
2383 so avoid adding the unqualified function type to
2384 the substitution list. */
2385 *pret = d_function_type (di);
2387 else
2388 *pret = cplus_demangle_type (di);
2389 if (!*pret)
2390 return NULL;
2391 if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS
2392 || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS)
2394 /* Move the ref-qualifier outside the cv-qualifiers so that
2395 they are printed in the right order. */
2396 struct demangle_component *fn = d_left (*pret);
2397 d_left (*pret) = ret;
2398 ret = *pret;
2399 *pret = fn;
2401 if (! d_add_substitution (di, ret))
2402 return NULL;
2403 return ret;
2406 can_subst = 1;
2408 peek = d_peek_char (di);
2409 switch (peek)
2411 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
2412 case 'h': case 'i': case 'j': case 'l': case 'm': case 'n':
2413 case 'o': case 's': case 't':
2414 case 'v': case 'w': case 'x': case 'y': case 'z':
2415 ret = d_make_builtin_type (di,
2416 &cplus_demangle_builtin_types[peek - 'a']);
2417 di->expansion += ret->u.s_builtin.type->len;
2418 can_subst = 0;
2419 d_advance (di, 1);
2420 break;
2422 case 'u':
2423 d_advance (di, 1);
2424 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
2425 d_source_name (di), NULL);
2426 break;
2428 case 'F':
2429 ret = d_function_type (di);
2430 break;
2432 case '0': case '1': case '2': case '3': case '4':
2433 case '5': case '6': case '7': case '8': case '9':
2434 case 'N':
2435 case 'Z':
2436 ret = d_class_enum_type (di);
2437 break;
2439 case 'A':
2440 ret = d_array_type (di);
2441 break;
2443 case 'M':
2444 ret = d_pointer_to_member_type (di);
2445 break;
2447 case 'T':
2448 ret = d_template_param (di);
2449 if (d_peek_char (di) == 'I')
2451 /* This may be <template-template-param> <template-args>.
2452 If this is the type for a conversion operator, we can
2453 have a <template-template-param> here only by following
2454 a derivation like this:
2456 <nested-name>
2457 -> <template-prefix> <template-args>
2458 -> <prefix> <template-unqualified-name> <template-args>
2459 -> <unqualified-name> <template-unqualified-name> <template-args>
2460 -> <source-name> <template-unqualified-name> <template-args>
2461 -> <source-name> <operator-name> <template-args>
2462 -> <source-name> cv <type> <template-args>
2463 -> <source-name> cv <template-template-param> <template-args> <template-args>
2465 where the <template-args> is followed by another.
2466 Otherwise, we must have a derivation like this:
2468 <nested-name>
2469 -> <template-prefix> <template-args>
2470 -> <prefix> <template-unqualified-name> <template-args>
2471 -> <unqualified-name> <template-unqualified-name> <template-args>
2472 -> <source-name> <template-unqualified-name> <template-args>
2473 -> <source-name> <operator-name> <template-args>
2474 -> <source-name> cv <type> <template-args>
2475 -> <source-name> cv <template-param> <template-args>
2477 where we need to leave the <template-args> to be processed
2478 by d_prefix (following the <template-prefix>).
2480 The <template-template-param> part is a substitution
2481 candidate. */
2482 if (! di->is_conversion)
2484 if (! d_add_substitution (di, ret))
2485 return NULL;
2486 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2487 d_template_args (di));
2489 else
2491 struct demangle_component *args;
2492 struct d_info_checkpoint checkpoint;
2494 d_checkpoint (di, &checkpoint);
2495 args = d_template_args (di);
2496 if (d_peek_char (di) == 'I')
2498 if (! d_add_substitution (di, ret))
2499 return NULL;
2500 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2501 args);
2503 else
2504 d_backtrack (di, &checkpoint);
2507 break;
2509 case 'S':
2510 /* If this is a special substitution, then it is the start of
2511 <class-enum-type>. */
2513 char peek_next;
2515 peek_next = d_peek_next_char (di);
2516 if (IS_DIGIT (peek_next)
2517 || peek_next == '_'
2518 || IS_UPPER (peek_next))
2520 ret = d_substitution (di, 0);
2521 /* The substituted name may have been a template name and
2522 may be followed by tepmlate args. */
2523 if (d_peek_char (di) == 'I')
2524 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2525 d_template_args (di));
2526 else
2527 can_subst = 0;
2529 else
2531 ret = d_class_enum_type (di);
2532 /* If the substitution was a complete type, then it is not
2533 a new substitution candidate. However, if the
2534 substitution was followed by template arguments, then
2535 the whole thing is a substitution candidate. */
2536 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
2537 can_subst = 0;
2540 break;
2542 case 'O':
2543 d_advance (di, 1);
2544 ret = d_make_comp (di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
2545 cplus_demangle_type (di), NULL);
2546 break;
2548 case 'P':
2549 d_advance (di, 1);
2550 ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
2551 cplus_demangle_type (di), NULL);
2552 break;
2554 case 'R':
2555 d_advance (di, 1);
2556 ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
2557 cplus_demangle_type (di), NULL);
2558 break;
2560 case 'C':
2561 d_advance (di, 1);
2562 ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
2563 cplus_demangle_type (di), NULL);
2564 break;
2566 case 'G':
2567 d_advance (di, 1);
2568 ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
2569 cplus_demangle_type (di), NULL);
2570 break;
2572 case 'U':
2573 d_advance (di, 1);
2574 ret = d_source_name (di);
2575 if (d_peek_char (di) == 'I')
2576 ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
2577 d_template_args (di));
2578 ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
2579 cplus_demangle_type (di), ret);
2580 break;
2582 case 'D':
2583 can_subst = 0;
2584 d_advance (di, 1);
2585 peek = d_next_char (di);
2586 switch (peek)
2588 case 'T':
2589 case 't':
2590 /* decltype (expression) */
2591 ret = d_make_comp (di, DEMANGLE_COMPONENT_DECLTYPE,
2592 d_expression (di), NULL);
2593 if (ret && d_next_char (di) != 'E')
2594 ret = NULL;
2595 can_subst = 1;
2596 break;
2598 case 'p':
2599 /* Pack expansion. */
2600 ret = d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
2601 cplus_demangle_type (di), NULL);
2602 can_subst = 1;
2603 break;
2605 case 'a':
2606 /* auto */
2607 ret = d_make_name (di, "auto", 4);
2608 break;
2609 case 'c':
2610 /* decltype(auto) */
2611 ret = d_make_name (di, "decltype(auto)", 14);
2612 break;
2614 case 'f':
2615 /* 32-bit decimal floating point */
2616 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[26]);
2617 di->expansion += ret->u.s_builtin.type->len;
2618 break;
2619 case 'd':
2620 /* 64-bit DFP */
2621 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[27]);
2622 di->expansion += ret->u.s_builtin.type->len;
2623 break;
2624 case 'e':
2625 /* 128-bit DFP */
2626 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[28]);
2627 di->expansion += ret->u.s_builtin.type->len;
2628 break;
2629 case 'h':
2630 /* 16-bit half-precision FP */
2631 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[29]);
2632 di->expansion += ret->u.s_builtin.type->len;
2633 break;
2634 case 's':
2635 /* char16_t */
2636 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[30]);
2637 di->expansion += ret->u.s_builtin.type->len;
2638 break;
2639 case 'i':
2640 /* char32_t */
2641 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[31]);
2642 di->expansion += ret->u.s_builtin.type->len;
2643 break;
2645 case 'F':
2646 /* Fixed point types. DF<int bits><length><fract bits><sat> */
2647 ret = d_make_empty (di);
2648 ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
2649 if ((ret->u.s_fixed.accum = IS_DIGIT (d_peek_char (di))))
2650 /* For demangling we don't care about the bits. */
2651 d_number (di);
2652 ret->u.s_fixed.length = cplus_demangle_type (di);
2653 if (ret->u.s_fixed.length == NULL)
2654 return NULL;
2655 d_number (di);
2656 peek = d_next_char (di);
2657 ret->u.s_fixed.sat = (peek == 's');
2658 break;
2660 case 'v':
2661 ret = d_vector_type (di);
2662 can_subst = 1;
2663 break;
2665 case 'n':
2666 /* decltype(nullptr) */
2667 ret = d_make_builtin_type (di, &cplus_demangle_builtin_types[32]);
2668 di->expansion += ret->u.s_builtin.type->len;
2669 break;
2671 default:
2672 return NULL;
2674 break;
2676 default:
2677 return NULL;
2680 if (can_subst)
2682 if (! d_add_substitution (di, ret))
2683 return NULL;
2686 return ret;
2689 /* <CV-qualifiers> ::= [r] [V] [K] [Dx] */
2691 static struct demangle_component **
2692 d_cv_qualifiers (struct d_info *di,
2693 struct demangle_component **pret, int member_fn)
2695 struct demangle_component **pstart;
2696 char peek;
2698 pstart = pret;
2699 peek = d_peek_char (di);
2700 while (next_is_type_qual (di))
2702 enum demangle_component_type t;
2703 struct demangle_component *right = NULL;
2705 d_advance (di, 1);
2706 if (peek == 'r')
2708 t = (member_fn
2709 ? DEMANGLE_COMPONENT_RESTRICT_THIS
2710 : DEMANGLE_COMPONENT_RESTRICT);
2711 di->expansion += sizeof "restrict";
2713 else if (peek == 'V')
2715 t = (member_fn
2716 ? DEMANGLE_COMPONENT_VOLATILE_THIS
2717 : DEMANGLE_COMPONENT_VOLATILE);
2718 di->expansion += sizeof "volatile";
2720 else if (peek == 'K')
2722 t = (member_fn
2723 ? DEMANGLE_COMPONENT_CONST_THIS
2724 : DEMANGLE_COMPONENT_CONST);
2725 di->expansion += sizeof "const";
2727 else
2729 peek = d_next_char (di);
2730 if (peek == 'x')
2732 t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
2733 di->expansion += sizeof "transaction_safe";
2735 else if (peek == 'o'
2736 || peek == 'O')
2738 t = DEMANGLE_COMPONENT_NOEXCEPT;
2739 di->expansion += sizeof "noexcept";
2740 if (peek == 'O')
2742 right = d_expression (di);
2743 if (right == NULL)
2744 return NULL;
2745 if (! d_check_char (di, 'E'))
2746 return NULL;
2749 else if (peek == 'w')
2751 t = DEMANGLE_COMPONENT_THROW_SPEC;
2752 di->expansion += sizeof "throw";
2753 right = d_parmlist (di);
2754 if (right == NULL)
2755 return NULL;
2756 if (! d_check_char (di, 'E'))
2757 return NULL;
2759 else
2760 return NULL;
2763 *pret = d_make_comp (di, t, NULL, right);
2764 if (*pret == NULL)
2765 return NULL;
2766 pret = &d_left (*pret);
2768 peek = d_peek_char (di);
2771 if (!member_fn && peek == 'F')
2773 while (pstart != pret)
2775 switch ((*pstart)->type)
2777 case DEMANGLE_COMPONENT_RESTRICT:
2778 (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
2779 break;
2780 case DEMANGLE_COMPONENT_VOLATILE:
2781 (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
2782 break;
2783 case DEMANGLE_COMPONENT_CONST:
2784 (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
2785 break;
2786 default:
2787 break;
2789 pstart = &d_left (*pstart);
2793 return pret;
2796 /* <ref-qualifier> ::= R
2797 ::= O */
2799 static struct demangle_component *
2800 d_ref_qualifier (struct d_info *di, struct demangle_component *sub)
2802 struct demangle_component *ret = sub;
2803 char peek;
2805 peek = d_peek_char (di);
2806 if (peek == 'R' || peek == 'O')
2808 enum demangle_component_type t;
2809 if (peek == 'R')
2811 t = DEMANGLE_COMPONENT_REFERENCE_THIS;
2812 di->expansion += sizeof "&";
2814 else
2816 t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
2817 di->expansion += sizeof "&&";
2819 d_advance (di, 1);
2821 ret = d_make_comp (di, t, ret, NULL);
2824 return ret;
2827 /* <function-type> ::= F [Y] <bare-function-type> [<ref-qualifier>] [T] E */
2829 static struct demangle_component *
2830 d_function_type (struct d_info *di)
2832 struct demangle_component *ret;
2834 if (! d_check_char (di, 'F'))
2835 return NULL;
2836 if (d_peek_char (di) == 'Y')
2838 /* Function has C linkage. We don't print this information.
2839 FIXME: We should print it in verbose mode. */
2840 d_advance (di, 1);
2842 ret = d_bare_function_type (di, 1);
2843 ret = d_ref_qualifier (di, ret);
2845 if (! d_check_char (di, 'E'))
2846 return NULL;
2847 return ret;
2850 /* <type>+ */
2852 static struct demangle_component *
2853 d_parmlist (struct d_info *di)
2855 struct demangle_component *tl;
2856 struct demangle_component **ptl;
2858 tl = NULL;
2859 ptl = &tl;
2860 while (1)
2862 struct demangle_component *type;
2864 char peek = d_peek_char (di);
2865 if (peek == '\0' || peek == 'E' || peek == '.')
2866 break;
2867 if ((peek == 'R' || peek == 'O')
2868 && d_peek_next_char (di) == 'E')
2869 /* Function ref-qualifier, not a ref prefix for a parameter type. */
2870 break;
2871 type = cplus_demangle_type (di);
2872 if (type == NULL)
2873 return NULL;
2874 *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
2875 if (*ptl == NULL)
2876 return NULL;
2877 ptl = &d_right (*ptl);
2880 /* There should be at least one parameter type besides the optional
2881 return type. A function which takes no arguments will have a
2882 single parameter type void. */
2883 if (tl == NULL)
2884 return NULL;
2886 /* If we have a single parameter type void, omit it. */
2887 if (d_right (tl) == NULL
2888 && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2889 && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
2891 di->expansion -= d_left (tl)->u.s_builtin.type->len;
2892 d_left (tl) = NULL;
2895 return tl;
2898 /* <bare-function-type> ::= [J]<type>+ */
2900 static struct demangle_component *
2901 d_bare_function_type (struct d_info *di, int has_return_type)
2903 struct demangle_component *return_type;
2904 struct demangle_component *tl;
2905 char peek;
2907 /* Detect special qualifier indicating that the first argument
2908 is the return type. */
2909 peek = d_peek_char (di);
2910 if (peek == 'J')
2912 d_advance (di, 1);
2913 has_return_type = 1;
2916 if (has_return_type)
2918 return_type = cplus_demangle_type (di);
2919 if (return_type == NULL)
2920 return NULL;
2922 else
2923 return_type = NULL;
2925 tl = d_parmlist (di);
2926 if (tl == NULL)
2927 return NULL;
2929 return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
2930 return_type, tl);
2933 /* <class-enum-type> ::= <name> */
2935 static struct demangle_component *
2936 d_class_enum_type (struct d_info *di)
2938 return d_name (di);
2941 /* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2942 ::= A [<(dimension) expression>] _ <(element) type>
2945 static struct demangle_component *
2946 d_array_type (struct d_info *di)
2948 char peek;
2949 struct demangle_component *dim;
2951 if (! d_check_char (di, 'A'))
2952 return NULL;
2954 peek = d_peek_char (di);
2955 if (peek == '_')
2956 dim = NULL;
2957 else if (IS_DIGIT (peek))
2959 const char *s;
2961 s = d_str (di);
2964 d_advance (di, 1);
2965 peek = d_peek_char (di);
2967 while (IS_DIGIT (peek));
2968 dim = d_make_name (di, s, d_str (di) - s);
2969 if (dim == NULL)
2970 return NULL;
2972 else
2974 dim = d_expression (di);
2975 if (dim == NULL)
2976 return NULL;
2979 if (! d_check_char (di, '_'))
2980 return NULL;
2982 return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2983 cplus_demangle_type (di));
2986 /* <vector-type> ::= Dv <number> _ <type>
2987 ::= Dv _ <expression> _ <type> */
2989 static struct demangle_component *
2990 d_vector_type (struct d_info *di)
2992 char peek;
2993 struct demangle_component *dim;
2995 peek = d_peek_char (di);
2996 if (peek == '_')
2998 d_advance (di, 1);
2999 dim = d_expression (di);
3001 else
3002 dim = d_number_component (di);
3004 if (dim == NULL)
3005 return NULL;
3007 if (! d_check_char (di, '_'))
3008 return NULL;
3010 return d_make_comp (di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
3011 cplus_demangle_type (di));
3014 /* <pointer-to-member-type> ::= M <(class) type> <(member) type> */
3016 static struct demangle_component *
3017 d_pointer_to_member_type (struct d_info *di)
3019 struct demangle_component *cl;
3020 struct demangle_component *mem;
3022 if (! d_check_char (di, 'M'))
3023 return NULL;
3025 cl = cplus_demangle_type (di);
3026 if (cl == NULL)
3027 return NULL;
3029 /* The ABI says, "The type of a non-static member function is considered
3030 to be different, for the purposes of substitution, from the type of a
3031 namespace-scope or static member function whose type appears
3032 similar. The types of two non-static member functions are considered
3033 to be different, for the purposes of substitution, if the functions
3034 are members of different classes. In other words, for the purposes of
3035 substitution, the class of which the function is a member is
3036 considered part of the type of function."
3038 For a pointer to member function, this call to cplus_demangle_type
3039 will end up adding a (possibly qualified) non-member function type to
3040 the substitution table, which is not correct; however, the member
3041 function type will never be used in a substitution, so putting the
3042 wrong type in the substitution table is harmless. */
3044 mem = cplus_demangle_type (di);
3045 if (mem == NULL)
3046 return NULL;
3048 return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
3051 /* <non-negative number> _ */
3053 static int
3054 d_compact_number (struct d_info *di)
3056 int num;
3057 if (d_peek_char (di) == '_')
3058 num = 0;
3059 else if (d_peek_char (di) == 'n')
3060 return -1;
3061 else
3062 num = d_number (di) + 1;
3064 if (num < 0 || ! d_check_char (di, '_'))
3065 return -1;
3066 return num;
3069 /* <template-param> ::= T_
3070 ::= T <(parameter-2 non-negative) number> _
3073 static struct demangle_component *
3074 d_template_param (struct d_info *di)
3076 int param;
3078 if (! d_check_char (di, 'T'))
3079 return NULL;
3081 param = d_compact_number (di);
3082 if (param < 0)
3083 return NULL;
3085 return d_make_template_param (di, param);
3088 /* <template-args> ::= I <template-arg>+ E */
3090 static struct demangle_component *
3091 d_template_args (struct d_info *di)
3093 if (d_peek_char (di) != 'I'
3094 && d_peek_char (di) != 'J')
3095 return NULL;
3096 d_advance (di, 1);
3098 return d_template_args_1 (di);
3101 /* <template-arg>* E */
3103 static struct demangle_component *
3104 d_template_args_1 (struct d_info *di)
3106 struct demangle_component *hold_last_name;
3107 struct demangle_component *al;
3108 struct demangle_component **pal;
3110 /* Preserve the last name we saw--don't let the template arguments
3111 clobber it, as that would give us the wrong name for a subsequent
3112 constructor or destructor. */
3113 hold_last_name = di->last_name;
3115 if (d_peek_char (di) == 'E')
3117 /* An argument pack can be empty. */
3118 d_advance (di, 1);
3119 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
3122 al = NULL;
3123 pal = &al;
3124 while (1)
3126 struct demangle_component *a;
3128 a = d_template_arg (di);
3129 if (a == NULL)
3130 return NULL;
3132 *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
3133 if (*pal == NULL)
3134 return NULL;
3135 pal = &d_right (*pal);
3137 if (d_peek_char (di) == 'E')
3139 d_advance (di, 1);
3140 break;
3144 di->last_name = hold_last_name;
3146 return al;
3149 /* <template-arg> ::= <type>
3150 ::= X <expression> E
3151 ::= <expr-primary>
3154 static struct demangle_component *
3155 d_template_arg (struct d_info *di)
3157 struct demangle_component *ret;
3159 switch (d_peek_char (di))
3161 case 'X':
3162 d_advance (di, 1);
3163 ret = d_expression (di);
3164 if (! d_check_char (di, 'E'))
3165 return NULL;
3166 return ret;
3168 case 'L':
3169 return d_expr_primary (di);
3171 case 'I':
3172 case 'J':
3173 /* An argument pack. */
3174 return d_template_args (di);
3176 default:
3177 return cplus_demangle_type (di);
3181 /* Parse a sequence of expressions until we hit the terminator
3182 character. */
3184 static struct demangle_component *
3185 d_exprlist (struct d_info *di, char terminator)
3187 struct demangle_component *list = NULL;
3188 struct demangle_component **p = &list;
3190 if (d_peek_char (di) == terminator)
3192 d_advance (di, 1);
3193 return d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
3196 while (1)
3198 struct demangle_component *arg = d_expression (di);
3199 if (arg == NULL)
3200 return NULL;
3202 *p = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
3203 if (*p == NULL)
3204 return NULL;
3205 p = &d_right (*p);
3207 if (d_peek_char (di) == terminator)
3209 d_advance (di, 1);
3210 break;
3214 return list;
3217 /* Returns nonzero iff OP is an operator for a C++ cast: const_cast,
3218 dynamic_cast, static_cast or reinterpret_cast. */
3220 static int
3221 op_is_new_cast (struct demangle_component *op)
3223 const char *code = op->u.s_operator.op->code;
3224 return (code[1] == 'c'
3225 && (code[0] == 's' || code[0] == 'd'
3226 || code[0] == 'c' || code[0] == 'r'));
3229 /* <expression> ::= <(unary) operator-name> <expression>
3230 ::= <(binary) operator-name> <expression> <expression>
3231 ::= <(trinary) operator-name> <expression> <expression> <expression>
3232 ::= cl <expression>+ E
3233 ::= st <type>
3234 ::= <template-param>
3235 ::= sr <type> <unqualified-name>
3236 ::= sr <type> <unqualified-name> <template-args>
3237 ::= <expr-primary>
3240 static inline struct demangle_component *
3241 d_expression_1 (struct d_info *di)
3243 char peek;
3245 peek = d_peek_char (di);
3246 if (peek == 'L')
3247 return d_expr_primary (di);
3248 else if (peek == 'T')
3249 return d_template_param (di);
3250 else if (peek == 's' && d_peek_next_char (di) == 'r')
3252 struct demangle_component *type;
3253 struct demangle_component *name;
3255 d_advance (di, 2);
3256 type = cplus_demangle_type (di);
3257 name = d_unqualified_name (di);
3258 if (d_peek_char (di) != 'I')
3259 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
3260 else
3261 return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
3262 d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3263 d_template_args (di)));
3265 else if (peek == 's' && d_peek_next_char (di) == 'p')
3267 d_advance (di, 2);
3268 return d_make_comp (di, DEMANGLE_COMPONENT_PACK_EXPANSION,
3269 d_expression_1 (di), NULL);
3271 else if (peek == 'f' && d_peek_next_char (di) == 'p')
3273 /* Function parameter used in a late-specified return type. */
3274 int index;
3275 d_advance (di, 2);
3276 if (d_peek_char (di) == 'T')
3278 /* 'this' parameter. */
3279 d_advance (di, 1);
3280 index = 0;
3282 else
3284 index = d_compact_number (di);
3285 if (index == INT_MAX || index == -1)
3286 return NULL;
3287 index++;
3289 return d_make_function_param (di, index);
3291 else if (IS_DIGIT (peek)
3292 || (peek == 'o' && d_peek_next_char (di) == 'n'))
3294 /* We can get an unqualified name as an expression in the case of
3295 a dependent function call, i.e. decltype(f(t)). */
3296 struct demangle_component *name;
3298 if (peek == 'o')
3299 /* operator-function-id, i.e. operator+(t). */
3300 d_advance (di, 2);
3302 name = d_unqualified_name (di);
3303 if (name == NULL)
3304 return NULL;
3305 if (d_peek_char (di) == 'I')
3306 return d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
3307 d_template_args (di));
3308 else
3309 return name;
3311 else if ((peek == 'i' || peek == 't')
3312 && d_peek_next_char (di) == 'l')
3314 /* Brace-enclosed initializer list, untyped or typed. */
3315 struct demangle_component *type = NULL;
3316 if (peek == 't')
3317 type = cplus_demangle_type (di);
3318 if (!d_peek_next_char (di))
3319 return NULL;
3320 d_advance (di, 2);
3321 return d_make_comp (di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
3322 type, d_exprlist (di, 'E'));
3324 else
3326 struct demangle_component *op;
3327 const char *code = NULL;
3328 int args;
3330 op = d_operator_name (di);
3331 if (op == NULL)
3332 return NULL;
3334 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
3336 code = op->u.s_operator.op->code;
3337 di->expansion += op->u.s_operator.op->len - 2;
3338 if (strcmp (code, "st") == 0)
3339 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3340 cplus_demangle_type (di));
3343 switch (op->type)
3345 default:
3346 return NULL;
3347 case DEMANGLE_COMPONENT_OPERATOR:
3348 args = op->u.s_operator.op->args;
3349 break;
3350 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3351 args = op->u.s_extended_operator.args;
3352 break;
3353 case DEMANGLE_COMPONENT_CAST:
3354 args = 1;
3355 break;
3358 switch (args)
3360 case 0:
3361 return d_make_comp (di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
3363 case 1:
3365 struct demangle_component *operand;
3366 int suffix = 0;
3368 if (code && (code[0] == 'p' || code[0] == 'm')
3369 && code[1] == code[0])
3370 /* pp_ and mm_ are the prefix variants. */
3371 suffix = !d_check_char (di, '_');
3373 if (op->type == DEMANGLE_COMPONENT_CAST
3374 && d_check_char (di, '_'))
3375 operand = d_exprlist (di, 'E');
3376 else if (code && !strcmp (code, "sP"))
3377 operand = d_template_args_1 (di);
3378 else
3379 operand = d_expression_1 (di);
3381 if (suffix)
3382 /* Indicate the suffix variant for d_print_comp. */
3383 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3384 d_make_comp (di,
3385 DEMANGLE_COMPONENT_BINARY_ARGS,
3386 operand, operand));
3387 else
3388 return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
3389 operand);
3391 case 2:
3393 struct demangle_component *left;
3394 struct demangle_component *right;
3396 if (code == NULL)
3397 return NULL;
3398 if (op_is_new_cast (op))
3399 left = cplus_demangle_type (di);
3400 else if (code[0] == 'f')
3401 /* fold-expression. */
3402 left = d_operator_name (di);
3403 else
3404 left = d_expression_1 (di);
3405 if (!strcmp (code, "cl"))
3406 right = d_exprlist (di, 'E');
3407 else if (!strcmp (code, "dt") || !strcmp (code, "pt"))
3409 right = d_unqualified_name (di);
3410 if (d_peek_char (di) == 'I')
3411 right = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE,
3412 right, d_template_args (di));
3414 else
3415 right = d_expression_1 (di);
3417 return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
3418 d_make_comp (di,
3419 DEMANGLE_COMPONENT_BINARY_ARGS,
3420 left, right));
3422 case 3:
3424 struct demangle_component *first;
3425 struct demangle_component *second;
3426 struct demangle_component *third;
3428 if (code == NULL)
3429 return NULL;
3430 else if (!strcmp (code, "qu"))
3432 /* ?: expression. */
3433 first = d_expression_1 (di);
3434 second = d_expression_1 (di);
3435 third = d_expression_1 (di);
3436 if (third == NULL)
3437 return NULL;
3439 else if (code[0] == 'f')
3441 /* fold-expression. */
3442 first = d_operator_name (di);
3443 second = d_expression_1 (di);
3444 third = d_expression_1 (di);
3445 if (third == NULL)
3446 return NULL;
3448 else if (code[0] == 'n')
3450 /* new-expression. */
3451 if (code[1] != 'w' && code[1] != 'a')
3452 return NULL;
3453 first = d_exprlist (di, '_');
3454 second = cplus_demangle_type (di);
3455 if (d_peek_char (di) == 'E')
3457 d_advance (di, 1);
3458 third = NULL;
3460 else if (d_peek_char (di) == 'p'
3461 && d_peek_next_char (di) == 'i')
3463 /* Parenthesized initializer. */
3464 d_advance (di, 2);
3465 third = d_exprlist (di, 'E');
3467 else if (d_peek_char (di) == 'i'
3468 && d_peek_next_char (di) == 'l')
3469 /* initializer-list. */
3470 third = d_expression_1 (di);
3471 else
3472 return NULL;
3474 else
3475 return NULL;
3476 return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
3477 d_make_comp (di,
3478 DEMANGLE_COMPONENT_TRINARY_ARG1,
3479 first,
3480 d_make_comp (di,
3481 DEMANGLE_COMPONENT_TRINARY_ARG2,
3482 second, third)));
3484 default:
3485 return NULL;
3490 static struct demangle_component *
3491 d_expression (struct d_info *di)
3493 struct demangle_component *ret;
3494 int was_expression = di->is_expression;
3496 di->is_expression = 1;
3497 ret = d_expression_1 (di);
3498 di->is_expression = was_expression;
3499 return ret;
3502 /* <expr-primary> ::= L <type> <(value) number> E
3503 ::= L <type> <(value) float> E
3504 ::= L <mangled-name> E
3507 static struct demangle_component *
3508 d_expr_primary (struct d_info *di)
3510 struct demangle_component *ret;
3512 if (! d_check_char (di, 'L'))
3513 return NULL;
3514 if (d_peek_char (di) == '_'
3515 /* Workaround for G++ bug; see comment in write_template_arg. */
3516 || d_peek_char (di) == 'Z')
3517 ret = cplus_demangle_mangled_name (di, 0);
3518 else
3520 struct demangle_component *type;
3521 enum demangle_component_type t;
3522 const char *s;
3524 type = cplus_demangle_type (di);
3525 if (type == NULL)
3526 return NULL;
3528 /* If we have a type we know how to print, we aren't going to
3529 print the type name itself. */
3530 if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
3531 && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
3532 di->expansion -= type->u.s_builtin.type->len;
3534 /* Rather than try to interpret the literal value, we just
3535 collect it as a string. Note that it's possible to have a
3536 floating point literal here. The ABI specifies that the
3537 format of such literals is machine independent. That's fine,
3538 but what's not fine is that versions of g++ up to 3.2 with
3539 -fabi-version=1 used upper case letters in the hex constant,
3540 and dumped out gcc's internal representation. That makes it
3541 hard to tell where the constant ends, and hard to dump the
3542 constant in any readable form anyhow. We don't attempt to
3543 handle these cases. */
3545 t = DEMANGLE_COMPONENT_LITERAL;
3546 if (d_peek_char (di) == 'n')
3548 t = DEMANGLE_COMPONENT_LITERAL_NEG;
3549 d_advance (di, 1);
3551 s = d_str (di);
3552 while (d_peek_char (di) != 'E')
3554 if (d_peek_char (di) == '\0')
3555 return NULL;
3556 d_advance (di, 1);
3558 ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
3560 if (! d_check_char (di, 'E'))
3561 return NULL;
3562 return ret;
3565 /* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
3566 ::= Z <(function) encoding> E s [<discriminator>]
3567 ::= Z <(function) encoding> E d [<parameter> number>] _ <entity name>
3570 static struct demangle_component *
3571 d_local_name (struct d_info *di)
3573 struct demangle_component *function;
3575 if (! d_check_char (di, 'Z'))
3576 return NULL;
3578 function = d_encoding (di, 0);
3580 if (! d_check_char (di, 'E'))
3581 return NULL;
3583 if (d_peek_char (di) == 's')
3585 d_advance (di, 1);
3586 if (! d_discriminator (di))
3587 return NULL;
3588 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
3589 d_make_name (di, "string literal",
3590 sizeof "string literal" - 1));
3592 else
3594 struct demangle_component *name;
3595 int num = -1;
3597 if (d_peek_char (di) == 'd')
3599 /* Default argument scope: d <number> _. */
3600 d_advance (di, 1);
3601 num = d_compact_number (di);
3602 if (num < 0)
3603 return NULL;
3606 name = d_name (di);
3607 if (name)
3608 switch (name->type)
3610 /* Lambdas and unnamed types have internal discriminators. */
3611 case DEMANGLE_COMPONENT_LAMBDA:
3612 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
3613 break;
3614 default:
3615 if (! d_discriminator (di))
3616 return NULL;
3618 if (num >= 0)
3619 name = d_make_default_arg (di, num, name);
3620 return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
3624 /* <discriminator> ::= _ <number> # when number < 10
3625 ::= __ <number> _ # when number >= 10
3627 <discriminator> ::= _ <number> # when number >=10
3628 is also accepted to support gcc versions that wrongly mangled that way.
3630 We demangle the discriminator, but we don't print it out. FIXME:
3631 We should print it out in verbose mode. */
3633 static int
3634 d_discriminator (struct d_info *di)
3636 int discrim, num_underscores = 1;
3638 if (d_peek_char (di) != '_')
3639 return 1;
3640 d_advance (di, 1);
3641 if (d_peek_char (di) == '_')
3643 ++num_underscores;
3644 d_advance (di, 1);
3647 discrim = d_number (di);
3648 if (discrim < 0)
3649 return 0;
3650 if (num_underscores > 1 && discrim >= 10)
3652 if (d_peek_char (di) == '_')
3653 d_advance (di, 1);
3654 else
3655 return 0;
3658 return 1;
3661 /* <closure-type-name> ::= Ul <lambda-sig> E [ <nonnegative number> ] _ */
3663 static struct demangle_component *
3664 d_lambda (struct d_info *di)
3666 struct demangle_component *tl;
3667 struct demangle_component *ret;
3668 int num;
3670 if (! d_check_char (di, 'U'))
3671 return NULL;
3672 if (! d_check_char (di, 'l'))
3673 return NULL;
3675 tl = d_parmlist (di);
3676 if (tl == NULL)
3677 return NULL;
3679 if (! d_check_char (di, 'E'))
3680 return NULL;
3682 num = d_compact_number (di);
3683 if (num < 0)
3684 return NULL;
3686 ret = d_make_empty (di);
3687 if (ret)
3689 ret->type = DEMANGLE_COMPONENT_LAMBDA;
3690 ret->u.s_unary_num.sub = tl;
3691 ret->u.s_unary_num.num = num;
3694 if (! d_add_substitution (di, ret))
3695 return NULL;
3697 return ret;
3700 /* <unnamed-type-name> ::= Ut [ <nonnegative number> ] _ */
3702 static struct demangle_component *
3703 d_unnamed_type (struct d_info *di)
3705 struct demangle_component *ret;
3706 int num;
3708 if (! d_check_char (di, 'U'))
3709 return NULL;
3710 if (! d_check_char (di, 't'))
3711 return NULL;
3713 num = d_compact_number (di);
3714 if (num < 0)
3715 return NULL;
3717 ret = d_make_empty (di);
3718 if (ret)
3720 ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
3721 ret->u.s_number.number = num;
3724 if (! d_add_substitution (di, ret))
3725 return NULL;
3727 return ret;
3730 /* <clone-suffix> ::= [ . <clone-type-identifier> ] [ . <nonnegative number> ]*
3733 static struct demangle_component *
3734 d_clone_suffix (struct d_info *di, struct demangle_component *encoding)
3736 const char *suffix = d_str (di);
3737 const char *pend = suffix;
3738 struct demangle_component *n;
3740 if (*pend == '.' && (IS_LOWER (pend[1]) || pend[1] == '_'))
3742 pend += 2;
3743 while (IS_LOWER (*pend) || *pend == '_')
3744 ++pend;
3746 while (*pend == '.' && IS_DIGIT (pend[1]))
3748 pend += 2;
3749 while (IS_DIGIT (*pend))
3750 ++pend;
3752 d_advance (di, pend - suffix);
3753 n = d_make_name (di, suffix, pend - suffix);
3754 return d_make_comp (di, DEMANGLE_COMPONENT_CLONE, encoding, n);
3757 /* Add a new substitution. */
3759 static int
3760 d_add_substitution (struct d_info *di, struct demangle_component *dc)
3762 if (dc == NULL)
3763 return 0;
3764 if (di->next_sub >= di->num_subs)
3765 return 0;
3766 di->subs[di->next_sub] = dc;
3767 ++di->next_sub;
3768 return 1;
3771 /* <substitution> ::= S <seq-id> _
3772 ::= S_
3773 ::= St
3774 ::= Sa
3775 ::= Sb
3776 ::= Ss
3777 ::= Si
3778 ::= So
3779 ::= Sd
3781 If PREFIX is non-zero, then this type is being used as a prefix in
3782 a qualified name. In this case, for the standard substitutions, we
3783 need to check whether we are being used as a prefix for a
3784 constructor or destructor, and return a full template name.
3785 Otherwise we will get something like std::iostream::~iostream()
3786 which does not correspond particularly well to any function which
3787 actually appears in the source.
3790 static const struct d_standard_sub_info standard_subs[] =
3792 { 't', NL ("std"),
3793 NL ("std"),
3794 NULL, 0 },
3795 { 'a', NL ("std::allocator"),
3796 NL ("std::allocator"),
3797 NL ("allocator") },
3798 { 'b', NL ("std::basic_string"),
3799 NL ("std::basic_string"),
3800 NL ("basic_string") },
3801 { 's', NL ("std::string"),
3802 NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
3803 NL ("basic_string") },
3804 { 'i', NL ("std::istream"),
3805 NL ("std::basic_istream<char, std::char_traits<char> >"),
3806 NL ("basic_istream") },
3807 { 'o', NL ("std::ostream"),
3808 NL ("std::basic_ostream<char, std::char_traits<char> >"),
3809 NL ("basic_ostream") },
3810 { 'd', NL ("std::iostream"),
3811 NL ("std::basic_iostream<char, std::char_traits<char> >"),
3812 NL ("basic_iostream") }
3815 static struct demangle_component *
3816 d_substitution (struct d_info *di, int prefix)
3818 char c;
3820 if (! d_check_char (di, 'S'))
3821 return NULL;
3823 c = d_next_char (di);
3824 if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
3826 unsigned int id;
3828 id = 0;
3829 if (c != '_')
3833 unsigned int new_id;
3835 if (IS_DIGIT (c))
3836 new_id = id * 36 + c - '0';
3837 else if (IS_UPPER (c))
3838 new_id = id * 36 + c - 'A' + 10;
3839 else
3840 return NULL;
3841 if (new_id < id)
3842 return NULL;
3843 id = new_id;
3844 c = d_next_char (di);
3846 while (c != '_');
3848 ++id;
3851 if (id >= (unsigned int) di->next_sub)
3852 return NULL;
3854 return di->subs[id];
3856 else
3858 int verbose;
3859 const struct d_standard_sub_info *p;
3860 const struct d_standard_sub_info *pend;
3862 verbose = (di->options & DMGL_VERBOSE) != 0;
3863 if (! verbose && prefix)
3865 char peek;
3867 peek = d_peek_char (di);
3868 if (peek == 'C' || peek == 'D')
3869 verbose = 1;
3872 pend = (&standard_subs[0]
3873 + sizeof standard_subs / sizeof standard_subs[0]);
3874 for (p = &standard_subs[0]; p < pend; ++p)
3876 if (c == p->code)
3878 const char *s;
3879 int len;
3880 struct demangle_component *dc;
3882 if (p->set_last_name != NULL)
3883 di->last_name = d_make_sub (di, p->set_last_name,
3884 p->set_last_name_len);
3885 if (verbose)
3887 s = p->full_expansion;
3888 len = p->full_len;
3890 else
3892 s = p->simple_expansion;
3893 len = p->simple_len;
3895 di->expansion += len;
3896 dc = d_make_sub (di, s, len);
3897 if (d_peek_char (di) == 'B')
3899 /* If there are ABI tags on the abbreviation, it becomes
3900 a substitution candidate. */
3901 dc = d_abi_tags (di, dc);
3902 if (! d_add_substitution (di, dc))
3903 return NULL;
3905 return dc;
3909 return NULL;
3913 static void
3914 d_checkpoint (struct d_info *di, struct d_info_checkpoint *checkpoint)
3916 checkpoint->n = di->n;
3917 checkpoint->next_comp = di->next_comp;
3918 checkpoint->next_sub = di->next_sub;
3919 checkpoint->expansion = di->expansion;
3922 static void
3923 d_backtrack (struct d_info *di, struct d_info_checkpoint *checkpoint)
3925 di->n = checkpoint->n;
3926 di->next_comp = checkpoint->next_comp;
3927 di->next_sub = checkpoint->next_sub;
3928 di->expansion = checkpoint->expansion;
3931 /* Initialize a growable string. */
3933 static void
3934 d_growable_string_init (struct d_growable_string *dgs, size_t estimate)
3936 dgs->buf = NULL;
3937 dgs->len = 0;
3938 dgs->alc = 0;
3939 dgs->allocation_failure = 0;
3941 if (estimate > 0)
3942 d_growable_string_resize (dgs, estimate);
3945 /* Grow a growable string to a given size. */
3947 static inline void
3948 d_growable_string_resize (struct d_growable_string *dgs, size_t need)
3950 size_t newalc;
3951 char *newbuf;
3953 if (dgs->allocation_failure)
3954 return;
3956 /* Start allocation at two bytes to avoid any possibility of confusion
3957 with the special value of 1 used as a return in *palc to indicate
3958 allocation failures. */
3959 newalc = dgs->alc > 0 ? dgs->alc : 2;
3960 while (newalc < need)
3961 newalc <<= 1;
3963 newbuf = (char *) realloc (dgs->buf, newalc);
3964 if (newbuf == NULL)
3966 free (dgs->buf);
3967 dgs->buf = NULL;
3968 dgs->len = 0;
3969 dgs->alc = 0;
3970 dgs->allocation_failure = 1;
3971 return;
3973 dgs->buf = newbuf;
3974 dgs->alc = newalc;
3977 /* Append a buffer to a growable string. */
3979 static inline void
3980 d_growable_string_append_buffer (struct d_growable_string *dgs,
3981 const char *s, size_t l)
3983 size_t need;
3985 need = dgs->len + l + 1;
3986 if (need > dgs->alc)
3987 d_growable_string_resize (dgs, need);
3989 if (dgs->allocation_failure)
3990 return;
3992 memcpy (dgs->buf + dgs->len, s, l);
3993 dgs->buf[dgs->len + l] = '\0';
3994 dgs->len += l;
3997 /* Bridge growable strings to the callback mechanism. */
3999 static void
4000 d_growable_string_callback_adapter (const char *s, size_t l, void *opaque)
4002 struct d_growable_string *dgs = (struct d_growable_string*) opaque;
4004 d_growable_string_append_buffer (dgs, s, l);
4007 /* Walk the tree, counting the number of templates encountered, and
4008 the number of times a scope might be saved. These counts will be
4009 used to allocate data structures for d_print_comp, so the logic
4010 here must mirror the logic d_print_comp will use. It is not
4011 important that the resulting numbers are exact, so long as they
4012 are larger than the actual numbers encountered. */
4014 static void
4015 d_count_templates_scopes (int *num_templates, int *num_scopes,
4016 const struct demangle_component *dc)
4018 if (dc == NULL)
4019 return;
4021 switch (dc->type)
4023 case DEMANGLE_COMPONENT_NAME:
4024 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4025 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4026 case DEMANGLE_COMPONENT_SUB_STD:
4027 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4028 case DEMANGLE_COMPONENT_OPERATOR:
4029 case DEMANGLE_COMPONENT_CHARACTER:
4030 case DEMANGLE_COMPONENT_NUMBER:
4031 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4032 break;
4034 case DEMANGLE_COMPONENT_TEMPLATE:
4035 (*num_templates)++;
4036 goto recurse_left_right;
4038 case DEMANGLE_COMPONENT_REFERENCE:
4039 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4040 if (d_left (dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4041 (*num_scopes)++;
4042 goto recurse_left_right;
4044 case DEMANGLE_COMPONENT_QUAL_NAME:
4045 case DEMANGLE_COMPONENT_LOCAL_NAME:
4046 case DEMANGLE_COMPONENT_TYPED_NAME:
4047 case DEMANGLE_COMPONENT_VTABLE:
4048 case DEMANGLE_COMPONENT_VTT:
4049 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4050 case DEMANGLE_COMPONENT_TYPEINFO:
4051 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4052 case DEMANGLE_COMPONENT_TYPEINFO_FN:
4053 case DEMANGLE_COMPONENT_THUNK:
4054 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4055 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4056 case DEMANGLE_COMPONENT_JAVA_CLASS:
4057 case DEMANGLE_COMPONENT_GUARD:
4058 case DEMANGLE_COMPONENT_TLS_INIT:
4059 case DEMANGLE_COMPONENT_TLS_WRAPPER:
4060 case DEMANGLE_COMPONENT_REFTEMP:
4061 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4062 case DEMANGLE_COMPONENT_RESTRICT:
4063 case DEMANGLE_COMPONENT_VOLATILE:
4064 case DEMANGLE_COMPONENT_CONST:
4065 case DEMANGLE_COMPONENT_RESTRICT_THIS:
4066 case DEMANGLE_COMPONENT_VOLATILE_THIS:
4067 case DEMANGLE_COMPONENT_CONST_THIS:
4068 case DEMANGLE_COMPONENT_REFERENCE_THIS:
4069 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
4070 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
4071 case DEMANGLE_COMPONENT_NOEXCEPT:
4072 case DEMANGLE_COMPONENT_THROW_SPEC:
4073 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
4074 case DEMANGLE_COMPONENT_POINTER:
4075 case DEMANGLE_COMPONENT_COMPLEX:
4076 case DEMANGLE_COMPONENT_IMAGINARY:
4077 case DEMANGLE_COMPONENT_VENDOR_TYPE:
4078 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
4079 case DEMANGLE_COMPONENT_ARRAY_TYPE:
4080 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
4081 case DEMANGLE_COMPONENT_VECTOR_TYPE:
4082 case DEMANGLE_COMPONENT_ARGLIST:
4083 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
4084 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
4085 case DEMANGLE_COMPONENT_CAST:
4086 case DEMANGLE_COMPONENT_CONVERSION:
4087 case DEMANGLE_COMPONENT_NULLARY:
4088 case DEMANGLE_COMPONENT_UNARY:
4089 case DEMANGLE_COMPONENT_BINARY:
4090 case DEMANGLE_COMPONENT_BINARY_ARGS:
4091 case DEMANGLE_COMPONENT_TRINARY:
4092 case DEMANGLE_COMPONENT_TRINARY_ARG1:
4093 case DEMANGLE_COMPONENT_TRINARY_ARG2:
4094 case DEMANGLE_COMPONENT_LITERAL:
4095 case DEMANGLE_COMPONENT_LITERAL_NEG:
4096 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
4097 case DEMANGLE_COMPONENT_COMPOUND_NAME:
4098 case DEMANGLE_COMPONENT_DECLTYPE:
4099 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4100 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4101 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4102 case DEMANGLE_COMPONENT_TAGGED_NAME:
4103 case DEMANGLE_COMPONENT_CLONE:
4104 recurse_left_right:
4105 d_count_templates_scopes (num_templates, num_scopes,
4106 d_left (dc));
4107 d_count_templates_scopes (num_templates, num_scopes,
4108 d_right (dc));
4109 break;
4111 case DEMANGLE_COMPONENT_CTOR:
4112 d_count_templates_scopes (num_templates, num_scopes,
4113 dc->u.s_ctor.name);
4114 break;
4116 case DEMANGLE_COMPONENT_DTOR:
4117 d_count_templates_scopes (num_templates, num_scopes,
4118 dc->u.s_dtor.name);
4119 break;
4121 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4122 d_count_templates_scopes (num_templates, num_scopes,
4123 dc->u.s_extended_operator.name);
4124 break;
4126 case DEMANGLE_COMPONENT_FIXED_TYPE:
4127 d_count_templates_scopes (num_templates, num_scopes,
4128 dc->u.s_fixed.length);
4129 break;
4131 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
4132 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
4133 d_count_templates_scopes (num_templates, num_scopes,
4134 d_left (dc));
4135 break;
4137 case DEMANGLE_COMPONENT_LAMBDA:
4138 case DEMANGLE_COMPONENT_DEFAULT_ARG:
4139 d_count_templates_scopes (num_templates, num_scopes,
4140 dc->u.s_unary_num.sub);
4141 break;
4145 /* Initialize a print information structure. */
4147 static void
4148 d_print_init (struct d_print_info *dpi, demangle_callbackref callback,
4149 void *opaque, const struct demangle_component *dc)
4151 dpi->len = 0;
4152 dpi->last_char = '\0';
4153 dpi->templates = NULL;
4154 dpi->modifiers = NULL;
4155 dpi->pack_index = 0;
4156 dpi->flush_count = 0;
4158 dpi->callback = callback;
4159 dpi->opaque = opaque;
4161 dpi->demangle_failure = 0;
4162 dpi->recursion = 0;
4163 dpi->is_lambda_arg = 0;
4165 dpi->component_stack = NULL;
4167 dpi->saved_scopes = NULL;
4168 dpi->next_saved_scope = 0;
4169 dpi->num_saved_scopes = 0;
4171 dpi->copy_templates = NULL;
4172 dpi->next_copy_template = 0;
4173 dpi->num_copy_templates = 0;
4175 d_count_templates_scopes (&dpi->num_copy_templates,
4176 &dpi->num_saved_scopes, dc);
4177 dpi->num_copy_templates *= dpi->num_saved_scopes;
4179 dpi->current_template = NULL;
4182 /* Indicate that an error occurred during printing, and test for error. */
4184 static inline void
4185 d_print_error (struct d_print_info *dpi)
4187 dpi->demangle_failure = 1;
4190 static inline int
4191 d_print_saw_error (struct d_print_info *dpi)
4193 return dpi->demangle_failure != 0;
4196 /* Flush buffered characters to the callback. */
4198 static inline void
4199 d_print_flush (struct d_print_info *dpi)
4201 dpi->buf[dpi->len] = '\0';
4202 dpi->callback (dpi->buf, dpi->len, dpi->opaque);
4203 dpi->len = 0;
4204 dpi->flush_count++;
4207 /* Append characters and buffers for printing. */
4209 static inline void
4210 d_append_char (struct d_print_info *dpi, char c)
4212 if (dpi->len == sizeof (dpi->buf) - 1)
4213 d_print_flush (dpi);
4215 dpi->buf[dpi->len++] = c;
4216 dpi->last_char = c;
4219 static inline void
4220 d_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
4222 size_t i;
4224 for (i = 0; i < l; i++)
4225 d_append_char (dpi, s[i]);
4228 static inline void
4229 d_append_string (struct d_print_info *dpi, const char *s)
4231 d_append_buffer (dpi, s, strlen (s));
4234 static inline void
4235 d_append_num (struct d_print_info *dpi, int l)
4237 char buf[25];
4238 sprintf (buf,"%d", l);
4239 d_append_string (dpi, buf);
4242 static inline char
4243 d_last_char (struct d_print_info *dpi)
4245 return dpi->last_char;
4248 /* Turn components into a human readable string. OPTIONS is the
4249 options bits passed to the demangler. DC is the tree to print.
4250 CALLBACK is a function to call to flush demangled string segments
4251 as they fill the intermediate buffer, and OPAQUE is a generalized
4252 callback argument. On success, this returns 1. On failure,
4253 it returns 0, indicating a bad parse. It does not use heap
4254 memory to build an output string, so cannot encounter memory
4255 allocation failure. */
4257 CP_STATIC_IF_GLIBCPP_V3
4259 cplus_demangle_print_callback (int options,
4260 struct demangle_component *dc,
4261 demangle_callbackref callback, void *opaque)
4263 struct d_print_info dpi;
4265 d_print_init (&dpi, callback, opaque, dc);
4268 #ifdef CP_DYNAMIC_ARRAYS
4269 /* Avoid zero-length VLAs, which are prohibited by the C99 standard
4270 and flagged as errors by Address Sanitizer. */
4271 __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
4272 ? dpi.num_saved_scopes : 1];
4273 __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
4274 ? dpi.num_copy_templates : 1];
4276 dpi.saved_scopes = scopes;
4277 dpi.copy_templates = temps;
4278 #else
4279 dpi.saved_scopes = alloca (dpi.num_saved_scopes
4280 * sizeof (*dpi.saved_scopes));
4281 dpi.copy_templates = alloca (dpi.num_copy_templates
4282 * sizeof (*dpi.copy_templates));
4283 #endif
4285 d_print_comp (&dpi, options, dc);
4288 d_print_flush (&dpi);
4290 return ! d_print_saw_error (&dpi);
4293 /* Turn components into a human readable string. OPTIONS is the
4294 options bits passed to the demangler. DC is the tree to print.
4295 ESTIMATE is a guess at the length of the result. This returns a
4296 string allocated by malloc, or NULL on error. On success, this
4297 sets *PALC to the size of the allocated buffer. On failure, this
4298 sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
4299 failure. */
4301 CP_STATIC_IF_GLIBCPP_V3
4302 char *
4303 cplus_demangle_print (int options, struct demangle_component *dc,
4304 int estimate, size_t *palc)
4306 struct d_growable_string dgs;
4308 d_growable_string_init (&dgs, estimate);
4310 if (! cplus_demangle_print_callback (options, dc,
4311 d_growable_string_callback_adapter,
4312 &dgs))
4314 free (dgs.buf);
4315 *palc = 0;
4316 return NULL;
4319 *palc = dgs.allocation_failure ? 1 : dgs.alc;
4320 return dgs.buf;
4323 /* Returns the I'th element of the template arglist ARGS, or NULL on
4324 failure. If I is negative, return the entire arglist. */
4326 static struct demangle_component *
4327 d_index_template_argument (struct demangle_component *args, int i)
4329 struct demangle_component *a;
4331 if (i < 0)
4332 /* Print the whole argument pack. */
4333 return args;
4335 for (a = args;
4336 a != NULL;
4337 a = d_right (a))
4339 if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4340 return NULL;
4341 if (i <= 0)
4342 break;
4343 --i;
4345 if (i != 0 || a == NULL)
4346 return NULL;
4348 return d_left (a);
4351 /* Returns the template argument from the current context indicated by DC,
4352 which is a DEMANGLE_COMPONENT_TEMPLATE_PARAM, or NULL. */
4354 static struct demangle_component *
4355 d_lookup_template_argument (struct d_print_info *dpi,
4356 const struct demangle_component *dc)
4358 if (dpi->templates == NULL)
4360 d_print_error (dpi);
4361 return NULL;
4364 return d_index_template_argument
4365 (d_right (dpi->templates->template_decl),
4366 dc->u.s_number.number);
4369 /* Returns a template argument pack used in DC (any will do), or NULL. */
4371 static struct demangle_component *
4372 d_find_pack (struct d_print_info *dpi,
4373 const struct demangle_component *dc)
4375 struct demangle_component *a;
4376 if (dc == NULL)
4377 return NULL;
4379 switch (dc->type)
4381 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4382 a = d_lookup_template_argument (dpi, dc);
4383 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4384 return a;
4385 return NULL;
4387 case DEMANGLE_COMPONENT_PACK_EXPANSION:
4388 return NULL;
4390 case DEMANGLE_COMPONENT_LAMBDA:
4391 case DEMANGLE_COMPONENT_NAME:
4392 case DEMANGLE_COMPONENT_TAGGED_NAME:
4393 case DEMANGLE_COMPONENT_OPERATOR:
4394 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
4395 case DEMANGLE_COMPONENT_SUB_STD:
4396 case DEMANGLE_COMPONENT_CHARACTER:
4397 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
4398 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
4399 case DEMANGLE_COMPONENT_FIXED_TYPE:
4400 case DEMANGLE_COMPONENT_DEFAULT_ARG:
4401 case DEMANGLE_COMPONENT_NUMBER:
4402 return NULL;
4404 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
4405 return d_find_pack (dpi, dc->u.s_extended_operator.name);
4406 case DEMANGLE_COMPONENT_CTOR:
4407 return d_find_pack (dpi, dc->u.s_ctor.name);
4408 case DEMANGLE_COMPONENT_DTOR:
4409 return d_find_pack (dpi, dc->u.s_dtor.name);
4411 default:
4412 a = d_find_pack (dpi, d_left (dc));
4413 if (a)
4414 return a;
4415 return d_find_pack (dpi, d_right (dc));
4419 /* Returns the length of the template argument pack DC. */
4421 static int
4422 d_pack_length (const struct demangle_component *dc)
4424 int count = 0;
4425 while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST
4426 && d_left (dc) != NULL)
4428 ++count;
4429 dc = d_right (dc);
4431 return count;
4434 /* Returns the number of template args in DC, expanding any pack expansions
4435 found there. */
4437 static int
4438 d_args_length (struct d_print_info *dpi, const struct demangle_component *dc)
4440 int count = 0;
4441 for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
4442 dc = d_right (dc))
4444 struct demangle_component *elt = d_left (dc);
4445 if (elt == NULL)
4446 break;
4447 if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION)
4449 struct demangle_component *a = d_find_pack (dpi, d_left (elt));
4450 count += d_pack_length (a);
4452 else
4453 ++count;
4455 return count;
4458 /* DC is a component of a mangled expression. Print it, wrapped in parens
4459 if needed. */
4461 static void
4462 d_print_subexpr (struct d_print_info *dpi, int options,
4463 struct demangle_component *dc)
4465 int simple = 0;
4466 if (dc->type == DEMANGLE_COMPONENT_NAME
4467 || dc->type == DEMANGLE_COMPONENT_QUAL_NAME
4468 || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST
4469 || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM)
4470 simple = 1;
4471 if (!simple)
4472 d_append_char (dpi, '(');
4473 d_print_comp (dpi, options, dc);
4474 if (!simple)
4475 d_append_char (dpi, ')');
4478 /* Save the current scope. */
4480 static void
4481 d_save_scope (struct d_print_info *dpi,
4482 const struct demangle_component *container)
4484 struct d_saved_scope *scope;
4485 struct d_print_template *src, **link;
4487 if (dpi->next_saved_scope >= dpi->num_saved_scopes)
4489 d_print_error (dpi);
4490 return;
4492 scope = &dpi->saved_scopes[dpi->next_saved_scope];
4493 dpi->next_saved_scope++;
4495 scope->container = container;
4496 link = &scope->templates;
4498 for (src = dpi->templates; src != NULL; src = src->next)
4500 struct d_print_template *dst;
4502 if (dpi->next_copy_template >= dpi->num_copy_templates)
4504 d_print_error (dpi);
4505 return;
4507 dst = &dpi->copy_templates[dpi->next_copy_template];
4508 dpi->next_copy_template++;
4510 dst->template_decl = src->template_decl;
4511 *link = dst;
4512 link = &dst->next;
4515 *link = NULL;
4518 /* Attempt to locate a previously saved scope. Returns NULL if no
4519 corresponding saved scope was found. */
4521 static struct d_saved_scope *
4522 d_get_saved_scope (struct d_print_info *dpi,
4523 const struct demangle_component *container)
4525 int i;
4527 for (i = 0; i < dpi->next_saved_scope; i++)
4528 if (dpi->saved_scopes[i].container == container)
4529 return &dpi->saved_scopes[i];
4531 return NULL;
4534 /* If DC is a C++17 fold-expression, print it and return true; otherwise
4535 return false. */
4537 static int
4538 d_maybe_print_fold_expression (struct d_print_info *dpi, int options,
4539 struct demangle_component *dc)
4541 struct demangle_component *ops, *operator_, *op1, *op2;
4542 int save_idx;
4544 const char *fold_code = d_left (dc)->u.s_operator.op->code;
4545 if (fold_code[0] != 'f')
4546 return 0;
4548 ops = d_right (dc);
4549 operator_ = d_left (ops);
4550 op1 = d_right (ops);
4551 op2 = 0;
4552 if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2)
4554 op2 = d_right (op1);
4555 op1 = d_left (op1);
4558 /* Print the whole pack. */
4559 save_idx = dpi->pack_index;
4560 dpi->pack_index = -1;
4562 switch (fold_code[1])
4564 /* Unary left fold, (... + X). */
4565 case 'l':
4566 d_append_string (dpi, "(...");
4567 d_print_expr_op (dpi, options, operator_);
4568 d_print_subexpr (dpi, options, op1);
4569 d_append_char (dpi, ')');
4570 break;
4572 /* Unary right fold, (X + ...). */
4573 case 'r':
4574 d_append_char (dpi, '(');
4575 d_print_subexpr (dpi, options, op1);
4576 d_print_expr_op (dpi, options, operator_);
4577 d_append_string (dpi, "...)");
4578 break;
4580 /* Binary left fold, (42 + ... + X). */
4581 case 'L':
4582 /* Binary right fold, (X + ... + 42). */
4583 case 'R':
4584 d_append_char (dpi, '(');
4585 d_print_subexpr (dpi, options, op1);
4586 d_print_expr_op (dpi, options, operator_);
4587 d_append_string (dpi, "...");
4588 d_print_expr_op (dpi, options, operator_);
4589 d_print_subexpr (dpi, options, op2);
4590 d_append_char (dpi, ')');
4591 break;
4594 dpi->pack_index = save_idx;
4595 return 1;
4598 /* Subroutine to handle components. */
4600 static void
4601 d_print_comp_inner (struct d_print_info *dpi, int options,
4602 struct demangle_component *dc)
4604 /* Magic variable to let reference smashing skip over the next modifier
4605 without needing to modify *dc. */
4606 struct demangle_component *mod_inner = NULL;
4608 /* Variable used to store the current templates while a previously
4609 captured scope is used. */
4610 struct d_print_template *saved_templates;
4612 /* Nonzero if templates have been stored in the above variable. */
4613 int need_template_restore = 0;
4615 if (dc == NULL)
4617 d_print_error (dpi);
4618 return;
4620 if (d_print_saw_error (dpi))
4621 return;
4623 switch (dc->type)
4625 case DEMANGLE_COMPONENT_NAME:
4626 if ((options & DMGL_JAVA) == 0)
4627 d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
4628 else
4629 d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
4630 return;
4632 case DEMANGLE_COMPONENT_TAGGED_NAME:
4633 d_print_comp (dpi, options, d_left (dc));
4634 d_append_string (dpi, "[abi:");
4635 d_print_comp (dpi, options, d_right (dc));
4636 d_append_char (dpi, ']');
4637 return;
4639 case DEMANGLE_COMPONENT_QUAL_NAME:
4640 case DEMANGLE_COMPONENT_LOCAL_NAME:
4641 d_print_comp (dpi, options, d_left (dc));
4642 if ((options & DMGL_JAVA) == 0)
4643 d_append_string (dpi, "::");
4644 else
4645 d_append_char (dpi, '.');
4647 struct demangle_component *local_name = d_right (dc);
4648 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4650 d_append_string (dpi, "{default arg#");
4651 d_append_num (dpi, local_name->u.s_unary_num.num + 1);
4652 d_append_string (dpi, "}::");
4653 local_name = local_name->u.s_unary_num.sub;
4655 d_print_comp (dpi, options, local_name);
4657 return;
4659 case DEMANGLE_COMPONENT_TYPED_NAME:
4661 struct d_print_mod *hold_modifiers;
4662 struct demangle_component *typed_name;
4663 struct d_print_mod adpm[4];
4664 unsigned int i;
4665 struct d_print_template dpt;
4667 /* Pass the name down to the type so that it can be printed in
4668 the right place for the type. We also have to pass down
4669 any CV-qualifiers, which apply to the this parameter. */
4670 hold_modifiers = dpi->modifiers;
4671 dpi->modifiers = 0;
4672 i = 0;
4673 typed_name = d_left (dc);
4674 while (typed_name != NULL)
4676 if (i >= sizeof adpm / sizeof adpm[0])
4678 d_print_error (dpi);
4679 return;
4682 adpm[i].next = dpi->modifiers;
4683 dpi->modifiers = &adpm[i];
4684 adpm[i].mod = typed_name;
4685 adpm[i].printed = 0;
4686 adpm[i].templates = dpi->templates;
4687 ++i;
4689 if (!is_fnqual_component_type (typed_name->type))
4690 break;
4692 typed_name = d_left (typed_name);
4695 if (typed_name == NULL)
4697 d_print_error (dpi);
4698 return;
4701 /* If typed_name is a template, then it applies to the
4702 function type as well. */
4703 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4705 dpt.next = dpi->templates;
4706 dpi->templates = &dpt;
4707 dpt.template_decl = typed_name;
4710 /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
4711 there may be CV-qualifiers on its right argument which
4712 really apply here; this happens when parsing a class which
4713 is local to a function. */
4714 if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
4716 struct demangle_component *local_name;
4718 local_name = d_right (typed_name);
4719 if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
4720 local_name = local_name->u.s_unary_num.sub;
4721 if (local_name == NULL)
4723 d_print_error (dpi);
4724 return;
4726 while (is_fnqual_component_type (local_name->type))
4728 if (i >= sizeof adpm / sizeof adpm[0])
4730 d_print_error (dpi);
4731 return;
4734 adpm[i] = adpm[i - 1];
4735 adpm[i].next = &adpm[i - 1];
4736 dpi->modifiers = &adpm[i];
4738 adpm[i - 1].mod = local_name;
4739 adpm[i - 1].printed = 0;
4740 adpm[i - 1].templates = dpi->templates;
4741 ++i;
4743 local_name = d_left (local_name);
4747 d_print_comp (dpi, options, d_right (dc));
4749 if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
4750 dpi->templates = dpt.next;
4752 /* If the modifiers didn't get printed by the type, print them
4753 now. */
4754 while (i > 0)
4756 --i;
4757 if (! adpm[i].printed)
4759 d_append_char (dpi, ' ');
4760 d_print_mod (dpi, options, adpm[i].mod);
4764 dpi->modifiers = hold_modifiers;
4766 return;
4769 case DEMANGLE_COMPONENT_TEMPLATE:
4771 struct d_print_mod *hold_dpm;
4772 struct demangle_component *dcl;
4773 const struct demangle_component *hold_current;
4775 /* This template may need to be referenced by a cast operator
4776 contained in its subtree. */
4777 hold_current = dpi->current_template;
4778 dpi->current_template = dc;
4780 /* Don't push modifiers into a template definition. Doing so
4781 could give the wrong definition for a template argument.
4782 Instead, treat the template essentially as a name. */
4784 hold_dpm = dpi->modifiers;
4785 dpi->modifiers = NULL;
4787 dcl = d_left (dc);
4789 if ((options & DMGL_JAVA) != 0
4790 && dcl->type == DEMANGLE_COMPONENT_NAME
4791 && dcl->u.s_name.len == 6
4792 && strncmp (dcl->u.s_name.s, "JArray", 6) == 0)
4794 /* Special-case Java arrays, so that JArray<TYPE> appears
4795 instead as TYPE[]. */
4797 d_print_comp (dpi, options, d_right (dc));
4798 d_append_string (dpi, "[]");
4800 else
4802 d_print_comp (dpi, options, dcl);
4803 if (d_last_char (dpi) == '<')
4804 d_append_char (dpi, ' ');
4805 d_append_char (dpi, '<');
4806 d_print_comp (dpi, options, d_right (dc));
4807 /* Avoid generating two consecutive '>' characters, to avoid
4808 the C++ syntactic ambiguity. */
4809 if (d_last_char (dpi) == '>')
4810 d_append_char (dpi, ' ');
4811 d_append_char (dpi, '>');
4814 dpi->modifiers = hold_dpm;
4815 dpi->current_template = hold_current;
4817 return;
4820 case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
4821 if (dpi->is_lambda_arg)
4823 /* Show the template parm index, as that's how g++ displays
4824 these, and future proofs us against potential
4825 '[]<typename T> (T *a, T *b) {...}'. */
4826 d_append_buffer (dpi, "auto:", 5);
4827 d_append_num (dpi, dc->u.s_number.number + 1);
4829 else
4831 struct d_print_template *hold_dpt;
4832 struct demangle_component *a = d_lookup_template_argument (dpi, dc);
4834 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
4835 a = d_index_template_argument (a, dpi->pack_index);
4837 if (a == NULL)
4839 d_print_error (dpi);
4840 return;
4843 /* While processing this parameter, we need to pop the list
4844 of templates. This is because the template parameter may
4845 itself be a reference to a parameter of an outer
4846 template. */
4848 hold_dpt = dpi->templates;
4849 dpi->templates = hold_dpt->next;
4851 d_print_comp (dpi, options, a);
4853 dpi->templates = hold_dpt;
4855 return;
4857 case DEMANGLE_COMPONENT_CTOR:
4858 d_print_comp (dpi, options, dc->u.s_ctor.name);
4859 return;
4861 case DEMANGLE_COMPONENT_DTOR:
4862 d_append_char (dpi, '~');
4863 d_print_comp (dpi, options, dc->u.s_dtor.name);
4864 return;
4866 case DEMANGLE_COMPONENT_VTABLE:
4867 d_append_string (dpi, "vtable for ");
4868 d_print_comp (dpi, options, d_left (dc));
4869 return;
4871 case DEMANGLE_COMPONENT_VTT:
4872 d_append_string (dpi, "VTT for ");
4873 d_print_comp (dpi, options, d_left (dc));
4874 return;
4876 case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
4877 d_append_string (dpi, "construction vtable for ");
4878 d_print_comp (dpi, options, d_left (dc));
4879 d_append_string (dpi, "-in-");
4880 d_print_comp (dpi, options, d_right (dc));
4881 return;
4883 case DEMANGLE_COMPONENT_TYPEINFO:
4884 d_append_string (dpi, "typeinfo for ");
4885 d_print_comp (dpi, options, d_left (dc));
4886 return;
4888 case DEMANGLE_COMPONENT_TYPEINFO_NAME:
4889 d_append_string (dpi, "typeinfo name for ");
4890 d_print_comp (dpi, options, d_left (dc));
4891 return;
4893 case DEMANGLE_COMPONENT_TYPEINFO_FN:
4894 d_append_string (dpi, "typeinfo fn for ");
4895 d_print_comp (dpi, options, d_left (dc));
4896 return;
4898 case DEMANGLE_COMPONENT_THUNK:
4899 d_append_string (dpi, "non-virtual thunk to ");
4900 d_print_comp (dpi, options, d_left (dc));
4901 return;
4903 case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
4904 d_append_string (dpi, "virtual thunk to ");
4905 d_print_comp (dpi, options, d_left (dc));
4906 return;
4908 case DEMANGLE_COMPONENT_COVARIANT_THUNK:
4909 d_append_string (dpi, "covariant return thunk to ");
4910 d_print_comp (dpi, options, d_left (dc));
4911 return;
4913 case DEMANGLE_COMPONENT_JAVA_CLASS:
4914 d_append_string (dpi, "java Class for ");
4915 d_print_comp (dpi, options, d_left (dc));
4916 return;
4918 case DEMANGLE_COMPONENT_GUARD:
4919 d_append_string (dpi, "guard variable for ");
4920 d_print_comp (dpi, options, d_left (dc));
4921 return;
4923 case DEMANGLE_COMPONENT_TLS_INIT:
4924 d_append_string (dpi, "TLS init function for ");
4925 d_print_comp (dpi, options, d_left (dc));
4926 return;
4928 case DEMANGLE_COMPONENT_TLS_WRAPPER:
4929 d_append_string (dpi, "TLS wrapper function for ");
4930 d_print_comp (dpi, options, d_left (dc));
4931 return;
4933 case DEMANGLE_COMPONENT_REFTEMP:
4934 d_append_string (dpi, "reference temporary #");
4935 d_print_comp (dpi, options, d_right (dc));
4936 d_append_string (dpi, " for ");
4937 d_print_comp (dpi, options, d_left (dc));
4938 return;
4940 case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
4941 d_append_string (dpi, "hidden alias for ");
4942 d_print_comp (dpi, options, d_left (dc));
4943 return;
4945 case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
4946 d_append_string (dpi, "transaction clone for ");
4947 d_print_comp (dpi, options, d_left (dc));
4948 return;
4950 case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
4951 d_append_string (dpi, "non-transaction clone for ");
4952 d_print_comp (dpi, options, d_left (dc));
4953 return;
4955 case DEMANGLE_COMPONENT_SUB_STD:
4956 d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
4957 return;
4959 case DEMANGLE_COMPONENT_RESTRICT:
4960 case DEMANGLE_COMPONENT_VOLATILE:
4961 case DEMANGLE_COMPONENT_CONST:
4963 struct d_print_mod *pdpm;
4965 /* When printing arrays, it's possible to have cases where the
4966 same CV-qualifier gets pushed on the stack multiple times.
4967 We only need to print it once. */
4969 for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
4971 if (! pdpm->printed)
4973 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
4974 && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
4975 && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
4976 break;
4977 if (pdpm->mod->type == dc->type)
4979 d_print_comp (dpi, options, d_left (dc));
4980 return;
4985 goto modifier;
4987 case DEMANGLE_COMPONENT_REFERENCE:
4988 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
4990 /* Handle reference smashing: & + && = &. */
4991 struct demangle_component *sub = d_left (dc);
4992 if (!dpi->is_lambda_arg
4993 && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
4995 struct d_saved_scope *scope = d_get_saved_scope (dpi, sub);
4996 struct demangle_component *a;
4998 if (scope == NULL)
5000 /* This is the first time SUB has been traversed.
5001 We need to capture the current templates so
5002 they can be restored if SUB is reentered as a
5003 substitution. */
5004 d_save_scope (dpi, sub);
5005 if (d_print_saw_error (dpi))
5006 return;
5008 else
5010 const struct d_component_stack *dcse;
5011 int found_self_or_parent = 0;
5013 /* This traversal is reentering SUB as a substition.
5014 If we are not beneath SUB or DC in the tree then we
5015 need to restore SUB's template stack temporarily. */
5016 for (dcse = dpi->component_stack; dcse != NULL;
5017 dcse = dcse->parent)
5019 if (dcse->dc == sub
5020 || (dcse->dc == dc
5021 && dcse != dpi->component_stack))
5023 found_self_or_parent = 1;
5024 break;
5028 if (!found_self_or_parent)
5030 saved_templates = dpi->templates;
5031 dpi->templates = scope->templates;
5032 need_template_restore = 1;
5036 a = d_lookup_template_argument (dpi, sub);
5037 if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
5038 a = d_index_template_argument (a, dpi->pack_index);
5040 if (a == NULL)
5042 if (need_template_restore)
5043 dpi->templates = saved_templates;
5045 d_print_error (dpi);
5046 return;
5049 sub = a;
5052 if (sub->type == DEMANGLE_COMPONENT_REFERENCE
5053 || sub->type == dc->type)
5054 dc = sub;
5055 else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
5056 mod_inner = d_left (sub);
5058 /* Fall through. */
5060 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5061 case DEMANGLE_COMPONENT_POINTER:
5062 case DEMANGLE_COMPONENT_COMPLEX:
5063 case DEMANGLE_COMPONENT_IMAGINARY:
5064 FNQUAL_COMPONENT_CASE:
5065 modifier:
5067 /* We keep a list of modifiers on the stack. */
5068 struct d_print_mod dpm;
5070 dpm.next = dpi->modifiers;
5071 dpi->modifiers = &dpm;
5072 dpm.mod = dc;
5073 dpm.printed = 0;
5074 dpm.templates = dpi->templates;
5076 if (!mod_inner)
5077 mod_inner = d_left (dc);
5079 d_print_comp (dpi, options, mod_inner);
5081 /* If the modifier didn't get printed by the type, print it
5082 now. */
5083 if (! dpm.printed)
5084 d_print_mod (dpi, options, dc);
5086 dpi->modifiers = dpm.next;
5088 if (need_template_restore)
5089 dpi->templates = saved_templates;
5091 return;
5094 case DEMANGLE_COMPONENT_BUILTIN_TYPE:
5095 if ((options & DMGL_JAVA) == 0)
5096 d_append_buffer (dpi, dc->u.s_builtin.type->name,
5097 dc->u.s_builtin.type->len);
5098 else
5099 d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
5100 dc->u.s_builtin.type->java_len);
5101 return;
5103 case DEMANGLE_COMPONENT_VENDOR_TYPE:
5104 d_print_comp (dpi, options, d_left (dc));
5105 return;
5107 case DEMANGLE_COMPONENT_FUNCTION_TYPE:
5109 if ((options & DMGL_RET_POSTFIX) != 0)
5110 d_print_function_type (dpi,
5111 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5112 dc, dpi->modifiers);
5114 /* Print return type if present */
5115 if (d_left (dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
5116 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5117 d_left (dc));
5118 else if (d_left (dc) != NULL && (options & DMGL_RET_DROP) == 0)
5120 struct d_print_mod dpm;
5122 /* We must pass this type down as a modifier in order to
5123 print it in the right location. */
5124 dpm.next = dpi->modifiers;
5125 dpi->modifiers = &dpm;
5126 dpm.mod = dc;
5127 dpm.printed = 0;
5128 dpm.templates = dpi->templates;
5130 d_print_comp (dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5131 d_left (dc));
5133 dpi->modifiers = dpm.next;
5135 if (dpm.printed)
5136 return;
5138 /* In standard prefix notation, there is a space between the
5139 return type and the function signature. */
5140 if ((options & DMGL_RET_POSTFIX) == 0)
5141 d_append_char (dpi, ' ');
5144 if ((options & DMGL_RET_POSTFIX) == 0)
5145 d_print_function_type (dpi,
5146 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
5147 dc, dpi->modifiers);
5149 return;
5152 case DEMANGLE_COMPONENT_ARRAY_TYPE:
5154 struct d_print_mod *hold_modifiers;
5155 struct d_print_mod adpm[4];
5156 unsigned int i;
5157 struct d_print_mod *pdpm;
5159 /* We must pass this type down as a modifier in order to print
5160 multi-dimensional arrays correctly. If the array itself is
5161 CV-qualified, we act as though the element type were
5162 CV-qualified. We do this by copying the modifiers down
5163 rather than fiddling pointers, so that we don't wind up
5164 with a d_print_mod higher on the stack pointing into our
5165 stack frame after we return. */
5167 hold_modifiers = dpi->modifiers;
5169 adpm[0].next = hold_modifiers;
5170 dpi->modifiers = &adpm[0];
5171 adpm[0].mod = dc;
5172 adpm[0].printed = 0;
5173 adpm[0].templates = dpi->templates;
5175 i = 1;
5176 pdpm = hold_modifiers;
5177 while (pdpm != NULL
5178 && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
5179 || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
5180 || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
5182 if (! pdpm->printed)
5184 if (i >= sizeof adpm / sizeof adpm[0])
5186 d_print_error (dpi);
5187 return;
5190 adpm[i] = *pdpm;
5191 adpm[i].next = dpi->modifiers;
5192 dpi->modifiers = &adpm[i];
5193 pdpm->printed = 1;
5194 ++i;
5197 pdpm = pdpm->next;
5200 d_print_comp (dpi, options, d_right (dc));
5202 dpi->modifiers = hold_modifiers;
5204 if (adpm[0].printed)
5205 return;
5207 while (i > 1)
5209 --i;
5210 d_print_mod (dpi, options, adpm[i].mod);
5213 d_print_array_type (dpi, options, dc, dpi->modifiers);
5215 return;
5218 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5219 case DEMANGLE_COMPONENT_VECTOR_TYPE:
5221 struct d_print_mod dpm;
5223 dpm.next = dpi->modifiers;
5224 dpi->modifiers = &dpm;
5225 dpm.mod = dc;
5226 dpm.printed = 0;
5227 dpm.templates = dpi->templates;
5229 d_print_comp (dpi, options, d_right (dc));
5231 /* If the modifier didn't get printed by the type, print it
5232 now. */
5233 if (! dpm.printed)
5234 d_print_mod (dpi, options, dc);
5236 dpi->modifiers = dpm.next;
5238 return;
5241 case DEMANGLE_COMPONENT_FIXED_TYPE:
5242 if (dc->u.s_fixed.sat)
5243 d_append_string (dpi, "_Sat ");
5244 /* Don't print "int _Accum". */
5245 if (dc->u.s_fixed.length->u.s_builtin.type
5246 != &cplus_demangle_builtin_types['i'-'a'])
5248 d_print_comp (dpi, options, dc->u.s_fixed.length);
5249 d_append_char (dpi, ' ');
5251 if (dc->u.s_fixed.accum)
5252 d_append_string (dpi, "_Accum");
5253 else
5254 d_append_string (dpi, "_Fract");
5255 return;
5257 case DEMANGLE_COMPONENT_ARGLIST:
5258 case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
5259 if (d_left (dc) != NULL)
5260 d_print_comp (dpi, options, d_left (dc));
5261 if (d_right (dc) != NULL)
5263 size_t len;
5264 unsigned long int flush_count;
5265 /* Make sure ", " isn't flushed by d_append_string, otherwise
5266 dpi->len -= 2 wouldn't work. */
5267 if (dpi->len >= sizeof (dpi->buf) - 2)
5268 d_print_flush (dpi);
5269 d_append_string (dpi, ", ");
5270 len = dpi->len;
5271 flush_count = dpi->flush_count;
5272 d_print_comp (dpi, options, d_right (dc));
5273 /* If that didn't print anything (which can happen with empty
5274 template argument packs), remove the comma and space. */
5275 if (dpi->flush_count == flush_count && dpi->len == len)
5276 dpi->len -= 2;
5278 return;
5280 case DEMANGLE_COMPONENT_INITIALIZER_LIST:
5282 struct demangle_component *type = d_left (dc);
5283 struct demangle_component *list = d_right (dc);
5285 if (type)
5286 d_print_comp (dpi, options, type);
5287 d_append_char (dpi, '{');
5288 d_print_comp (dpi, options, list);
5289 d_append_char (dpi, '}');
5291 return;
5293 case DEMANGLE_COMPONENT_OPERATOR:
5295 const struct demangle_operator_info *op = dc->u.s_operator.op;
5296 int len = op->len;
5298 d_append_string (dpi, "operator");
5299 /* Add a space before new/delete. */
5300 if (IS_LOWER (op->name[0]))
5301 d_append_char (dpi, ' ');
5302 /* Omit a trailing space. */
5303 if (op->name[len-1] == ' ')
5304 --len;
5305 d_append_buffer (dpi, op->name, len);
5306 return;
5309 case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
5310 d_append_string (dpi, "operator ");
5311 d_print_comp (dpi, options, dc->u.s_extended_operator.name);
5312 return;
5314 case DEMANGLE_COMPONENT_CONVERSION:
5315 d_append_string (dpi, "operator ");
5316 d_print_conversion (dpi, options, dc);
5317 return;
5319 case DEMANGLE_COMPONENT_NULLARY:
5320 d_print_expr_op (dpi, options, d_left (dc));
5321 return;
5323 case DEMANGLE_COMPONENT_UNARY:
5325 struct demangle_component *op = d_left (dc);
5326 struct demangle_component *operand = d_right (dc);
5327 const char *code = NULL;
5329 if (op->type == DEMANGLE_COMPONENT_OPERATOR)
5331 code = op->u.s_operator.op->code;
5332 if (!strcmp (code, "ad"))
5334 /* Don't print the argument list for the address of a
5335 function. */
5336 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME
5337 && d_left (operand)->type == DEMANGLE_COMPONENT_QUAL_NAME
5338 && d_right (operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5339 operand = d_left (operand);
5341 if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS)
5343 /* This indicates a suffix operator. */
5344 operand = d_left (operand);
5345 d_print_subexpr (dpi, options, operand);
5346 d_print_expr_op (dpi, options, op);
5347 return;
5351 /* For sizeof..., just print the pack length. */
5352 if (code && !strcmp (code, "sZ"))
5354 struct demangle_component *a = d_find_pack (dpi, operand);
5355 int len = d_pack_length (a);
5356 d_append_num (dpi, len);
5357 return;
5359 else if (code && !strcmp (code, "sP"))
5361 int len = d_args_length (dpi, operand);
5362 d_append_num (dpi, len);
5363 return;
5366 if (op->type != DEMANGLE_COMPONENT_CAST)
5367 d_print_expr_op (dpi, options, op);
5368 else
5370 d_append_char (dpi, '(');
5371 d_print_cast (dpi, options, op);
5372 d_append_char (dpi, ')');
5374 if (code && !strcmp (code, "gs"))
5375 /* Avoid parens after '::'. */
5376 d_print_comp (dpi, options, operand);
5377 else if (code && !strcmp (code, "st"))
5378 /* Always print parens for sizeof (type). */
5380 d_append_char (dpi, '(');
5381 d_print_comp (dpi, options, operand);
5382 d_append_char (dpi, ')');
5384 else
5385 d_print_subexpr (dpi, options, operand);
5387 return;
5389 case DEMANGLE_COMPONENT_BINARY:
5390 if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
5392 d_print_error (dpi);
5393 return;
5396 if (op_is_new_cast (d_left (dc)))
5398 d_print_expr_op (dpi, options, d_left (dc));
5399 d_append_char (dpi, '<');
5400 d_print_comp (dpi, options, d_left (d_right (dc)));
5401 d_append_string (dpi, ">(");
5402 d_print_comp (dpi, options, d_right (d_right (dc)));
5403 d_append_char (dpi, ')');
5404 return;
5407 if (d_maybe_print_fold_expression (dpi, options, dc))
5408 return;
5410 /* We wrap an expression which uses the greater-than operator in
5411 an extra layer of parens so that it does not get confused
5412 with the '>' which ends the template parameters. */
5413 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5414 && d_left (dc)->u.s_operator.op->len == 1
5415 && d_left (dc)->u.s_operator.op->name[0] == '>')
5416 d_append_char (dpi, '(');
5418 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") == 0
5419 && d_left (d_right (dc))->type == DEMANGLE_COMPONENT_TYPED_NAME)
5421 /* Function call used in an expression should not have printed types
5422 of the function arguments. Values of the function arguments still
5423 get printed below. */
5425 const struct demangle_component *func = d_left (d_right (dc));
5427 if (d_right (func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
5428 d_print_error (dpi);
5429 d_print_subexpr (dpi, options, d_left (func));
5431 else
5432 d_print_subexpr (dpi, options, d_left (d_right (dc)));
5433 if (strcmp (d_left (dc)->u.s_operator.op->code, "ix") == 0)
5435 d_append_char (dpi, '[');
5436 d_print_comp (dpi, options, d_right (d_right (dc)));
5437 d_append_char (dpi, ']');
5439 else
5441 if (strcmp (d_left (dc)->u.s_operator.op->code, "cl") != 0)
5442 d_print_expr_op (dpi, options, d_left (dc));
5443 d_print_subexpr (dpi, options, d_right (d_right (dc)));
5446 if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
5447 && d_left (dc)->u.s_operator.op->len == 1
5448 && d_left (dc)->u.s_operator.op->name[0] == '>')
5449 d_append_char (dpi, ')');
5451 return;
5453 case DEMANGLE_COMPONENT_BINARY_ARGS:
5454 /* We should only see this as part of DEMANGLE_COMPONENT_BINARY. */
5455 d_print_error (dpi);
5456 return;
5458 case DEMANGLE_COMPONENT_TRINARY:
5459 if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
5460 || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
5462 d_print_error (dpi);
5463 return;
5465 if (d_maybe_print_fold_expression (dpi, options, dc))
5466 return;
5468 struct demangle_component *op = d_left (dc);
5469 struct demangle_component *first = d_left (d_right (dc));
5470 struct demangle_component *second = d_left (d_right (d_right (dc)));
5471 struct demangle_component *third = d_right (d_right (d_right (dc)));
5473 if (!strcmp (op->u.s_operator.op->code, "qu"))
5475 d_print_subexpr (dpi, options, first);
5476 d_print_expr_op (dpi, options, op);
5477 d_print_subexpr (dpi, options, second);
5478 d_append_string (dpi, " : ");
5479 d_print_subexpr (dpi, options, third);
5481 else
5483 d_append_string (dpi, "new ");
5484 if (d_left (first) != NULL)
5486 d_print_subexpr (dpi, options, first);
5487 d_append_char (dpi, ' ');
5489 d_print_comp (dpi, options, second);
5490 if (third)
5491 d_print_subexpr (dpi, options, third);
5494 return;
5496 case DEMANGLE_COMPONENT_TRINARY_ARG1:
5497 case DEMANGLE_COMPONENT_TRINARY_ARG2:
5498 /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY. */
5499 d_print_error (dpi);
5500 return;
5502 case DEMANGLE_COMPONENT_LITERAL:
5503 case DEMANGLE_COMPONENT_LITERAL_NEG:
5505 enum d_builtin_type_print tp;
5507 /* For some builtin types, produce simpler output. */
5508 tp = D_PRINT_DEFAULT;
5509 if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
5511 tp = d_left (dc)->u.s_builtin.type->print;
5512 switch (tp)
5514 case D_PRINT_INT:
5515 case D_PRINT_UNSIGNED:
5516 case D_PRINT_LONG:
5517 case D_PRINT_UNSIGNED_LONG:
5518 case D_PRINT_LONG_LONG:
5519 case D_PRINT_UNSIGNED_LONG_LONG:
5520 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
5522 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5523 d_append_char (dpi, '-');
5524 d_print_comp (dpi, options, d_right (dc));
5525 switch (tp)
5527 default:
5528 break;
5529 case D_PRINT_UNSIGNED:
5530 d_append_char (dpi, 'u');
5531 break;
5532 case D_PRINT_LONG:
5533 d_append_char (dpi, 'l');
5534 break;
5535 case D_PRINT_UNSIGNED_LONG:
5536 d_append_string (dpi, "ul");
5537 break;
5538 case D_PRINT_LONG_LONG:
5539 d_append_string (dpi, "ll");
5540 break;
5541 case D_PRINT_UNSIGNED_LONG_LONG:
5542 d_append_string (dpi, "ull");
5543 break;
5545 return;
5547 break;
5549 case D_PRINT_BOOL:
5550 if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
5551 && d_right (dc)->u.s_name.len == 1
5552 && dc->type == DEMANGLE_COMPONENT_LITERAL)
5554 switch (d_right (dc)->u.s_name.s[0])
5556 case '0':
5557 d_append_string (dpi, "false");
5558 return;
5559 case '1':
5560 d_append_string (dpi, "true");
5561 return;
5562 default:
5563 break;
5566 break;
5568 default:
5569 break;
5573 d_append_char (dpi, '(');
5574 d_print_comp (dpi, options, d_left (dc));
5575 d_append_char (dpi, ')');
5576 if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
5577 d_append_char (dpi, '-');
5578 if (tp == D_PRINT_FLOAT)
5579 d_append_char (dpi, '[');
5580 d_print_comp (dpi, options, d_right (dc));
5581 if (tp == D_PRINT_FLOAT)
5582 d_append_char (dpi, ']');
5584 return;
5586 case DEMANGLE_COMPONENT_NUMBER:
5587 d_append_num (dpi, dc->u.s_number.number);
5588 return;
5590 case DEMANGLE_COMPONENT_JAVA_RESOURCE:
5591 d_append_string (dpi, "java resource ");
5592 d_print_comp (dpi, options, d_left (dc));
5593 return;
5595 case DEMANGLE_COMPONENT_COMPOUND_NAME:
5596 d_print_comp (dpi, options, d_left (dc));
5597 d_print_comp (dpi, options, d_right (dc));
5598 return;
5600 case DEMANGLE_COMPONENT_CHARACTER:
5601 d_append_char (dpi, dc->u.s_character.character);
5602 return;
5604 case DEMANGLE_COMPONENT_DECLTYPE:
5605 d_append_string (dpi, "decltype (");
5606 d_print_comp (dpi, options, d_left (dc));
5607 d_append_char (dpi, ')');
5608 return;
5610 case DEMANGLE_COMPONENT_PACK_EXPANSION:
5612 int len;
5613 int i;
5614 struct demangle_component *a = d_find_pack (dpi, d_left (dc));
5615 if (a == NULL)
5617 /* d_find_pack won't find anything if the only packs involved
5618 in this expansion are function parameter packs; in that
5619 case, just print the pattern and "...". */
5620 d_print_subexpr (dpi, options, d_left (dc));
5621 d_append_string (dpi, "...");
5622 return;
5625 len = d_pack_length (a);
5626 dc = d_left (dc);
5627 for (i = 0; i < len; ++i)
5629 dpi->pack_index = i;
5630 d_print_comp (dpi, options, dc);
5631 if (i < len-1)
5632 d_append_string (dpi, ", ");
5635 return;
5637 case DEMANGLE_COMPONENT_FUNCTION_PARAM:
5639 long num = dc->u.s_number.number;
5640 if (num == 0)
5641 d_append_string (dpi, "this");
5642 else
5644 d_append_string (dpi, "{parm#");
5645 d_append_num (dpi, num);
5646 d_append_char (dpi, '}');
5649 return;
5651 case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
5652 d_append_string (dpi, "global constructors keyed to ");
5653 d_print_comp (dpi, options, dc->u.s_binary.left);
5654 return;
5656 case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
5657 d_append_string (dpi, "global destructors keyed to ");
5658 d_print_comp (dpi, options, dc->u.s_binary.left);
5659 return;
5661 case DEMANGLE_COMPONENT_LAMBDA:
5662 d_append_string (dpi, "{lambda(");
5663 /* Generic lambda auto parms are mangled as the template type
5664 parm they are. */
5665 dpi->is_lambda_arg++;
5666 d_print_comp (dpi, options, dc->u.s_unary_num.sub);
5667 dpi->is_lambda_arg--;
5668 d_append_string (dpi, ")#");
5669 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5670 d_append_char (dpi, '}');
5671 return;
5673 case DEMANGLE_COMPONENT_UNNAMED_TYPE:
5674 d_append_string (dpi, "{unnamed type#");
5675 d_append_num (dpi, dc->u.s_number.number + 1);
5676 d_append_char (dpi, '}');
5677 return;
5679 case DEMANGLE_COMPONENT_CLONE:
5680 d_print_comp (dpi, options, d_left (dc));
5681 d_append_string (dpi, " [clone ");
5682 d_print_comp (dpi, options, d_right (dc));
5683 d_append_char (dpi, ']');
5684 return;
5686 default:
5687 d_print_error (dpi);
5688 return;
5692 static void
5693 d_print_comp (struct d_print_info *dpi, int options,
5694 struct demangle_component *dc)
5696 struct d_component_stack self;
5697 if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT)
5699 d_print_error (dpi);
5700 return;
5703 dc->d_printing++;
5704 dpi->recursion++;
5706 self.dc = dc;
5707 self.parent = dpi->component_stack;
5708 dpi->component_stack = &self;
5710 d_print_comp_inner (dpi, options, dc);
5712 dpi->component_stack = self.parent;
5713 dc->d_printing--;
5714 dpi->recursion--;
5717 /* Print a Java dentifier. For Java we try to handle encoded extended
5718 Unicode characters. The C++ ABI doesn't mention Unicode encoding,
5719 so we don't it for C++. Characters are encoded as
5720 __U<hex-char>+_. */
5722 static void
5723 d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
5725 const char *p;
5726 const char *end;
5728 end = name + len;
5729 for (p = name; p < end; ++p)
5731 if (end - p > 3
5732 && p[0] == '_'
5733 && p[1] == '_'
5734 && p[2] == 'U')
5736 unsigned long c;
5737 const char *q;
5739 c = 0;
5740 for (q = p + 3; q < end; ++q)
5742 int dig;
5744 if (IS_DIGIT (*q))
5745 dig = *q - '0';
5746 else if (*q >= 'A' && *q <= 'F')
5747 dig = *q - 'A' + 10;
5748 else if (*q >= 'a' && *q <= 'f')
5749 dig = *q - 'a' + 10;
5750 else
5751 break;
5753 c = c * 16 + dig;
5755 /* If the Unicode character is larger than 256, we don't try
5756 to deal with it here. FIXME. */
5757 if (q < end && *q == '_' && c < 256)
5759 d_append_char (dpi, c);
5760 p = q;
5761 continue;
5765 d_append_char (dpi, *p);
5769 /* Print a list of modifiers. SUFFIX is 1 if we are printing
5770 qualifiers on this after printing a function. */
5772 static void
5773 d_print_mod_list (struct d_print_info *dpi, int options,
5774 struct d_print_mod *mods, int suffix)
5776 struct d_print_template *hold_dpt;
5778 if (mods == NULL || d_print_saw_error (dpi))
5779 return;
5781 if (mods->printed
5782 || (! suffix
5783 && (is_fnqual_component_type (mods->mod->type))))
5785 d_print_mod_list (dpi, options, mods->next, suffix);
5786 return;
5789 mods->printed = 1;
5791 hold_dpt = dpi->templates;
5792 dpi->templates = mods->templates;
5794 if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
5796 d_print_function_type (dpi, options, mods->mod, mods->next);
5797 dpi->templates = hold_dpt;
5798 return;
5800 else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
5802 d_print_array_type (dpi, options, mods->mod, mods->next);
5803 dpi->templates = hold_dpt;
5804 return;
5806 else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
5808 struct d_print_mod *hold_modifiers;
5809 struct demangle_component *dc;
5811 /* When this is on the modifier stack, we have pulled any
5812 qualifiers off the right argument already. Otherwise, we
5813 print it as usual, but don't let the left argument see any
5814 modifiers. */
5816 hold_modifiers = dpi->modifiers;
5817 dpi->modifiers = NULL;
5818 d_print_comp (dpi, options, d_left (mods->mod));
5819 dpi->modifiers = hold_modifiers;
5821 if ((options & DMGL_JAVA) == 0)
5822 d_append_string (dpi, "::");
5823 else
5824 d_append_char (dpi, '.');
5826 dc = d_right (mods->mod);
5828 if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
5830 d_append_string (dpi, "{default arg#");
5831 d_append_num (dpi, dc->u.s_unary_num.num + 1);
5832 d_append_string (dpi, "}::");
5833 dc = dc->u.s_unary_num.sub;
5836 while (is_fnqual_component_type (dc->type))
5837 dc = d_left (dc);
5839 d_print_comp (dpi, options, dc);
5841 dpi->templates = hold_dpt;
5842 return;
5845 d_print_mod (dpi, options, mods->mod);
5847 dpi->templates = hold_dpt;
5849 d_print_mod_list (dpi, options, mods->next, suffix);
5852 /* Print a modifier. */
5854 static void
5855 d_print_mod (struct d_print_info *dpi, int options,
5856 struct demangle_component *mod)
5858 switch (mod->type)
5860 case DEMANGLE_COMPONENT_RESTRICT:
5861 case DEMANGLE_COMPONENT_RESTRICT_THIS:
5862 d_append_string (dpi, " restrict");
5863 return;
5864 case DEMANGLE_COMPONENT_VOLATILE:
5865 case DEMANGLE_COMPONENT_VOLATILE_THIS:
5866 d_append_string (dpi, " volatile");
5867 return;
5868 case DEMANGLE_COMPONENT_CONST:
5869 case DEMANGLE_COMPONENT_CONST_THIS:
5870 d_append_string (dpi, " const");
5871 return;
5872 case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
5873 d_append_string (dpi, " transaction_safe");
5874 return;
5875 case DEMANGLE_COMPONENT_NOEXCEPT:
5876 d_append_string (dpi, " noexcept");
5877 if (d_right (mod))
5879 d_append_char (dpi, '(');
5880 d_print_comp (dpi, options, d_right (mod));
5881 d_append_char (dpi, ')');
5883 return;
5884 case DEMANGLE_COMPONENT_THROW_SPEC:
5885 d_append_string (dpi, " throw");
5886 if (d_right (mod))
5888 d_append_char (dpi, '(');
5889 d_print_comp (dpi, options, d_right (mod));
5890 d_append_char (dpi, ')');
5892 return;
5893 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5894 d_append_char (dpi, ' ');
5895 d_print_comp (dpi, options, d_right (mod));
5896 return;
5897 case DEMANGLE_COMPONENT_POINTER:
5898 /* There is no pointer symbol in Java. */
5899 if ((options & DMGL_JAVA) == 0)
5900 d_append_char (dpi, '*');
5901 return;
5902 case DEMANGLE_COMPONENT_REFERENCE_THIS:
5903 /* For the ref-qualifier, put a space before the &. */
5904 d_append_char (dpi, ' ');
5905 /* FALLTHRU */
5906 case DEMANGLE_COMPONENT_REFERENCE:
5907 d_append_char (dpi, '&');
5908 return;
5909 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
5910 d_append_char (dpi, ' ');
5911 /* FALLTHRU */
5912 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5913 d_append_string (dpi, "&&");
5914 return;
5915 case DEMANGLE_COMPONENT_COMPLEX:
5916 d_append_string (dpi, "complex ");
5917 return;
5918 case DEMANGLE_COMPONENT_IMAGINARY:
5919 d_append_string (dpi, "imaginary ");
5920 return;
5921 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5922 if (d_last_char (dpi) != '(')
5923 d_append_char (dpi, ' ');
5924 d_print_comp (dpi, options, d_left (mod));
5925 d_append_string (dpi, "::*");
5926 return;
5927 case DEMANGLE_COMPONENT_TYPED_NAME:
5928 d_print_comp (dpi, options, d_left (mod));
5929 return;
5930 case DEMANGLE_COMPONENT_VECTOR_TYPE:
5931 d_append_string (dpi, " __vector(");
5932 d_print_comp (dpi, options, d_left (mod));
5933 d_append_char (dpi, ')');
5934 return;
5936 default:
5937 /* Otherwise, we have something that won't go back on the
5938 modifier stack, so we can just print it. */
5939 d_print_comp (dpi, options, mod);
5940 return;
5944 /* Print a function type, except for the return type. */
5946 static void
5947 d_print_function_type (struct d_print_info *dpi, int options,
5948 struct demangle_component *dc,
5949 struct d_print_mod *mods)
5951 int need_paren;
5952 int need_space;
5953 struct d_print_mod *p;
5954 struct d_print_mod *hold_modifiers;
5956 need_paren = 0;
5957 need_space = 0;
5958 for (p = mods; p != NULL; p = p->next)
5960 if (p->printed)
5961 break;
5963 switch (p->mod->type)
5965 case DEMANGLE_COMPONENT_POINTER:
5966 case DEMANGLE_COMPONENT_REFERENCE:
5967 case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
5968 need_paren = 1;
5969 break;
5970 case DEMANGLE_COMPONENT_RESTRICT:
5971 case DEMANGLE_COMPONENT_VOLATILE:
5972 case DEMANGLE_COMPONENT_CONST:
5973 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
5974 case DEMANGLE_COMPONENT_COMPLEX:
5975 case DEMANGLE_COMPONENT_IMAGINARY:
5976 case DEMANGLE_COMPONENT_PTRMEM_TYPE:
5977 need_space = 1;
5978 need_paren = 1;
5979 break;
5980 FNQUAL_COMPONENT_CASE:
5981 break;
5982 default:
5983 break;
5985 if (need_paren)
5986 break;
5989 if (need_paren)
5991 if (! need_space)
5993 if (d_last_char (dpi) != '('
5994 && d_last_char (dpi) != '*')
5995 need_space = 1;
5997 if (need_space && d_last_char (dpi) != ' ')
5998 d_append_char (dpi, ' ');
5999 d_append_char (dpi, '(');
6002 hold_modifiers = dpi->modifiers;
6003 dpi->modifiers = NULL;
6005 d_print_mod_list (dpi, options, mods, 0);
6007 if (need_paren)
6008 d_append_char (dpi, ')');
6010 d_append_char (dpi, '(');
6012 if (d_right (dc) != NULL)
6013 d_print_comp (dpi, options, d_right (dc));
6015 d_append_char (dpi, ')');
6017 d_print_mod_list (dpi, options, mods, 1);
6019 dpi->modifiers = hold_modifiers;
6022 /* Print an array type, except for the element type. */
6024 static void
6025 d_print_array_type (struct d_print_info *dpi, int options,
6026 struct demangle_component *dc,
6027 struct d_print_mod *mods)
6029 int need_space;
6031 need_space = 1;
6032 if (mods != NULL)
6034 int need_paren;
6035 struct d_print_mod *p;
6037 need_paren = 0;
6038 for (p = mods; p != NULL; p = p->next)
6040 if (! p->printed)
6042 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
6044 need_space = 0;
6045 break;
6047 else
6049 need_paren = 1;
6050 need_space = 1;
6051 break;
6056 if (need_paren)
6057 d_append_string (dpi, " (");
6059 d_print_mod_list (dpi, options, mods, 0);
6061 if (need_paren)
6062 d_append_char (dpi, ')');
6065 if (need_space)
6066 d_append_char (dpi, ' ');
6068 d_append_char (dpi, '[');
6070 if (d_left (dc) != NULL)
6071 d_print_comp (dpi, options, d_left (dc));
6073 d_append_char (dpi, ']');
6076 /* Print an operator in an expression. */
6078 static void
6079 d_print_expr_op (struct d_print_info *dpi, int options,
6080 struct demangle_component *dc)
6082 if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
6083 d_append_buffer (dpi, dc->u.s_operator.op->name,
6084 dc->u.s_operator.op->len);
6085 else
6086 d_print_comp (dpi, options, dc);
6089 /* Print a cast. */
6091 static void
6092 d_print_cast (struct d_print_info *dpi, int options,
6093 struct demangle_component *dc)
6095 d_print_comp (dpi, options, d_left (dc));
6098 /* Print a conversion operator. */
6100 static void
6101 d_print_conversion (struct d_print_info *dpi, int options,
6102 struct demangle_component *dc)
6104 struct d_print_template dpt;
6106 /* For a conversion operator, we need the template parameters from
6107 the enclosing template in scope for processing the type. */
6108 if (dpi->current_template != NULL)
6110 dpt.next = dpi->templates;
6111 dpi->templates = &dpt;
6112 dpt.template_decl = dpi->current_template;
6115 if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
6117 d_print_comp (dpi, options, d_left (dc));
6118 if (dpi->current_template != NULL)
6119 dpi->templates = dpt.next;
6121 else
6123 d_print_comp (dpi, options, d_left (d_left (dc)));
6125 /* For a templated cast operator, we need to remove the template
6126 parameters from scope after printing the operator name,
6127 so we need to handle the template printing here. */
6128 if (dpi->current_template != NULL)
6129 dpi->templates = dpt.next;
6131 if (d_last_char (dpi) == '<')
6132 d_append_char (dpi, ' ');
6133 d_append_char (dpi, '<');
6134 d_print_comp (dpi, options, d_right (d_left (dc)));
6135 /* Avoid generating two consecutive '>' characters, to avoid
6136 the C++ syntactic ambiguity. */
6137 if (d_last_char (dpi) == '>')
6138 d_append_char (dpi, ' ');
6139 d_append_char (dpi, '>');
6143 /* Initialize the information structure we use to pass around
6144 information. */
6146 CP_STATIC_IF_GLIBCPP_V3
6147 void
6148 cplus_demangle_init_info (const char *mangled, int options, size_t len,
6149 struct d_info *di)
6151 di->s = mangled;
6152 di->send = mangled + len;
6153 di->options = options;
6155 di->n = mangled;
6157 /* We can not need more components than twice the number of chars in
6158 the mangled string. Most components correspond directly to
6159 chars, but the ARGLIST types are exceptions. */
6160 di->num_comps = 2 * len;
6161 di->next_comp = 0;
6163 /* Similarly, we can not need more substitutions than there are
6164 chars in the mangled string. */
6165 di->num_subs = len;
6166 di->next_sub = 0;
6168 di->last_name = NULL;
6170 di->expansion = 0;
6171 di->is_expression = 0;
6172 di->is_conversion = 0;
6175 /* Internal implementation for the demangler. If MANGLED is a g++ v3 ABI
6176 mangled name, return strings in repeated callback giving the demangled
6177 name. OPTIONS is the usual libiberty demangler options. On success,
6178 this returns 1. On failure, returns 0. */
6180 static int
6181 d_demangle_callback (const char *mangled, int options,
6182 demangle_callbackref callback, void *opaque)
6184 enum
6186 DCT_TYPE,
6187 DCT_MANGLED,
6188 DCT_GLOBAL_CTORS,
6189 DCT_GLOBAL_DTORS
6191 type;
6192 struct d_info di;
6193 struct demangle_component *dc;
6194 int status;
6196 if (mangled[0] == '_' && mangled[1] == 'Z')
6197 type = DCT_MANGLED;
6198 else if (strncmp (mangled, "_GLOBAL_", 8) == 0
6199 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
6200 && (mangled[9] == 'D' || mangled[9] == 'I')
6201 && mangled[10] == '_')
6202 type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
6203 else
6205 if ((options & DMGL_TYPES) == 0)
6206 return 0;
6207 type = DCT_TYPE;
6210 cplus_demangle_init_info (mangled, options, strlen (mangled), &di);
6213 #ifdef CP_DYNAMIC_ARRAYS
6214 __extension__ struct demangle_component comps[di.num_comps];
6215 __extension__ struct demangle_component *subs[di.num_subs];
6217 di.comps = comps;
6218 di.subs = subs;
6219 #else
6220 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6221 di.subs = alloca (di.num_subs * sizeof (*di.subs));
6222 #endif
6224 switch (type)
6226 case DCT_TYPE:
6227 dc = cplus_demangle_type (&di);
6228 break;
6229 case DCT_MANGLED:
6230 dc = cplus_demangle_mangled_name (&di, 1);
6231 break;
6232 case DCT_GLOBAL_CTORS:
6233 case DCT_GLOBAL_DTORS:
6234 d_advance (&di, 11);
6235 dc = d_make_comp (&di,
6236 (type == DCT_GLOBAL_CTORS
6237 ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
6238 : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
6239 d_make_demangle_mangled_name (&di, d_str (&di)),
6240 NULL);
6241 d_advance (&di, strlen (d_str (&di)));
6242 break;
6243 default:
6244 abort (); /* We have listed all the cases. */
6247 /* If DMGL_PARAMS is set, then if we didn't consume the entire
6248 mangled string, then we didn't successfully demangle it. If
6249 DMGL_PARAMS is not set, we didn't look at the trailing
6250 parameters. */
6251 if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
6252 dc = NULL;
6254 #ifdef CP_DEMANGLE_DEBUG
6255 d_dump (dc, 0);
6256 #endif
6258 status = (dc != NULL)
6259 ? cplus_demangle_print_callback (options, dc, callback, opaque)
6260 : 0;
6263 return status;
6266 /* Entry point for the demangler. If MANGLED is a g++ v3 ABI mangled
6267 name, return a buffer allocated with malloc holding the demangled
6268 name. OPTIONS is the usual libiberty demangler options. On
6269 success, this sets *PALC to the allocated size of the returned
6270 buffer. On failure, this sets *PALC to 0 for a bad name, or 1 for
6271 a memory allocation failure, and returns NULL. */
6273 static char *
6274 d_demangle (const char *mangled, int options, size_t *palc)
6276 struct d_growable_string dgs;
6277 int status;
6279 d_growable_string_init (&dgs, 0);
6281 status = d_demangle_callback (mangled, options,
6282 d_growable_string_callback_adapter, &dgs);
6283 if (status == 0)
6285 free (dgs.buf);
6286 *palc = 0;
6287 return NULL;
6290 *palc = dgs.allocation_failure ? 1 : dgs.alc;
6291 return dgs.buf;
6294 #if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
6296 extern char *__cxa_demangle (const char *, char *, size_t *, int *);
6298 /* ia64 ABI-mandated entry point in the C++ runtime library for
6299 performing demangling. MANGLED_NAME is a NUL-terminated character
6300 string containing the name to be demangled.
6302 OUTPUT_BUFFER is a region of memory, allocated with malloc, of
6303 *LENGTH bytes, into which the demangled name is stored. If
6304 OUTPUT_BUFFER is not long enough, it is expanded using realloc.
6305 OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
6306 is placed in a region of memory allocated with malloc.
6308 If LENGTH is non-NULL, the length of the buffer containing the
6309 demangled name, is placed in *LENGTH.
6311 The return value is a pointer to the start of the NUL-terminated
6312 demangled name, or NULL if the demangling fails. The caller is
6313 responsible for deallocating this memory using free.
6315 *STATUS is set to one of the following values:
6316 0: The demangling operation succeeded.
6317 -1: A memory allocation failure occurred.
6318 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6319 -3: One of the arguments is invalid.
6321 The demangling is performed using the C++ ABI mangling rules, with
6322 GNU extensions. */
6324 char *
6325 __cxa_demangle (const char *mangled_name, char *output_buffer,
6326 size_t *length, int *status)
6328 char *demangled;
6329 size_t alc;
6331 if (mangled_name == NULL)
6333 if (status != NULL)
6334 *status = -3;
6335 return NULL;
6338 if (output_buffer != NULL && length == NULL)
6340 if (status != NULL)
6341 *status = -3;
6342 return NULL;
6345 demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
6347 if (demangled == NULL)
6349 if (status != NULL)
6351 if (alc == 1)
6352 *status = -1;
6353 else
6354 *status = -2;
6356 return NULL;
6359 if (output_buffer == NULL)
6361 if (length != NULL)
6362 *length = alc;
6364 else
6366 if (strlen (demangled) < *length)
6368 strcpy (output_buffer, demangled);
6369 free (demangled);
6370 demangled = output_buffer;
6372 else
6374 free (output_buffer);
6375 *length = alc;
6379 if (status != NULL)
6380 *status = 0;
6382 return demangled;
6385 extern int __gcclibcxx_demangle_callback (const char *,
6386 void (*)
6387 (const char *, size_t, void *),
6388 void *);
6390 /* Alternative, allocationless entry point in the C++ runtime library
6391 for performing demangling. MANGLED_NAME is a NUL-terminated character
6392 string containing the name to be demangled.
6394 CALLBACK is a callback function, called with demangled string
6395 segments as demangling progresses; it is called at least once,
6396 but may be called more than once. OPAQUE is a generalized pointer
6397 used as a callback argument.
6399 The return code is one of the following values, equivalent to
6400 the STATUS values of __cxa_demangle() (excluding -1, since this
6401 function performs no memory allocations):
6402 0: The demangling operation succeeded.
6403 -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
6404 -3: One of the arguments is invalid.
6406 The demangling is performed using the C++ ABI mangling rules, with
6407 GNU extensions. */
6410 __gcclibcxx_demangle_callback (const char *mangled_name,
6411 void (*callback) (const char *, size_t, void *),
6412 void *opaque)
6414 int status;
6416 if (mangled_name == NULL || callback == NULL)
6417 return -3;
6419 status = d_demangle_callback (mangled_name, DMGL_PARAMS | DMGL_TYPES,
6420 callback, opaque);
6421 if (status == 0)
6422 return -2;
6424 return 0;
6427 #else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
6429 /* Entry point for libiberty demangler. If MANGLED is a g++ v3 ABI
6430 mangled name, return a buffer allocated with malloc holding the
6431 demangled name. Otherwise, return NULL. */
6433 char *
6434 cplus_demangle_v3 (const char *mangled, int options)
6436 size_t alc;
6438 return d_demangle (mangled, options, &alc);
6442 cplus_demangle_v3_callback (const char *mangled, int options,
6443 demangle_callbackref callback, void *opaque)
6445 return d_demangle_callback (mangled, options, callback, opaque);
6448 /* Demangle a Java symbol. Java uses a subset of the V3 ABI C++ mangling
6449 conventions, but the output formatting is a little different.
6450 This instructs the C++ demangler not to emit pointer characters ("*"), to
6451 use Java's namespace separator symbol ("." instead of "::"), and to output
6452 JArray<TYPE> as TYPE[]. */
6454 char *
6455 java_demangle_v3 (const char *mangled)
6457 size_t alc;
6459 return d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
6463 java_demangle_v3_callback (const char *mangled,
6464 demangle_callbackref callback, void *opaque)
6466 return d_demangle_callback (mangled,
6467 DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
6468 callback, opaque);
6471 #endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
6473 #ifndef IN_GLIBCPP_V3
6475 /* Demangle a string in order to find out whether it is a constructor
6476 or destructor. Return non-zero on success. Set *CTOR_KIND and
6477 *DTOR_KIND appropriately. */
6479 static int
6480 is_ctor_or_dtor (const char *mangled,
6481 enum gnu_v3_ctor_kinds *ctor_kind,
6482 enum gnu_v3_dtor_kinds *dtor_kind)
6484 struct d_info di;
6485 struct demangle_component *dc;
6486 int ret;
6488 *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
6489 *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
6491 cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
6494 #ifdef CP_DYNAMIC_ARRAYS
6495 __extension__ struct demangle_component comps[di.num_comps];
6496 __extension__ struct demangle_component *subs[di.num_subs];
6498 di.comps = comps;
6499 di.subs = subs;
6500 #else
6501 di.comps = alloca (di.num_comps * sizeof (*di.comps));
6502 di.subs = alloca (di.num_subs * sizeof (*di.subs));
6503 #endif
6505 dc = cplus_demangle_mangled_name (&di, 1);
6507 /* Note that because we did not pass DMGL_PARAMS, we don't expect
6508 to demangle the entire string. */
6510 ret = 0;
6511 while (dc != NULL)
6513 switch (dc->type)
6515 /* These cannot appear on a constructor or destructor. */
6516 case DEMANGLE_COMPONENT_RESTRICT_THIS:
6517 case DEMANGLE_COMPONENT_VOLATILE_THIS:
6518 case DEMANGLE_COMPONENT_CONST_THIS:
6519 case DEMANGLE_COMPONENT_REFERENCE_THIS:
6520 case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
6521 default:
6522 dc = NULL;
6523 break;
6524 case DEMANGLE_COMPONENT_TYPED_NAME:
6525 case DEMANGLE_COMPONENT_TEMPLATE:
6526 dc = d_left (dc);
6527 break;
6528 case DEMANGLE_COMPONENT_QUAL_NAME:
6529 case DEMANGLE_COMPONENT_LOCAL_NAME:
6530 dc = d_right (dc);
6531 break;
6532 case DEMANGLE_COMPONENT_CTOR:
6533 *ctor_kind = dc->u.s_ctor.kind;
6534 ret = 1;
6535 dc = NULL;
6536 break;
6537 case DEMANGLE_COMPONENT_DTOR:
6538 *dtor_kind = dc->u.s_dtor.kind;
6539 ret = 1;
6540 dc = NULL;
6541 break;
6546 return ret;
6549 /* Return whether NAME is the mangled form of a g++ V3 ABI constructor
6550 name. A non-zero return indicates the type of constructor. */
6552 enum gnu_v3_ctor_kinds
6553 is_gnu_v3_mangled_ctor (const char *name)
6555 enum gnu_v3_ctor_kinds ctor_kind;
6556 enum gnu_v3_dtor_kinds dtor_kind;
6558 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6559 return (enum gnu_v3_ctor_kinds) 0;
6560 return ctor_kind;
6564 /* Return whether NAME is the mangled form of a g++ V3 ABI destructor
6565 name. A non-zero return indicates the type of destructor. */
6567 enum gnu_v3_dtor_kinds
6568 is_gnu_v3_mangled_dtor (const char *name)
6570 enum gnu_v3_ctor_kinds ctor_kind;
6571 enum gnu_v3_dtor_kinds dtor_kind;
6573 if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
6574 return (enum gnu_v3_dtor_kinds) 0;
6575 return dtor_kind;
6578 #endif /* IN_GLIBCPP_V3 */
6580 #ifdef STANDALONE_DEMANGLER
6582 #include "getopt.h"
6583 #include "dyn-string.h"
6585 static void print_usage (FILE* fp, int exit_value);
6587 #define IS_ALPHA(CHAR) \
6588 (((CHAR) >= 'a' && (CHAR) <= 'z') \
6589 || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
6591 /* Non-zero if CHAR is a character than can occur in a mangled name. */
6592 #define is_mangled_char(CHAR) \
6593 (IS_ALPHA (CHAR) || IS_DIGIT (CHAR) \
6594 || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
6596 /* The name of this program, as invoked. */
6597 const char* program_name;
6599 /* Prints usage summary to FP and then exits with EXIT_VALUE. */
6601 static void
6602 print_usage (FILE* fp, int exit_value)
6604 fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
6605 fprintf (fp, "Options:\n");
6606 fprintf (fp, " -h,--help Display this message.\n");
6607 fprintf (fp, " -p,--no-params Don't display function parameters\n");
6608 fprintf (fp, " -v,--verbose Produce verbose demanglings.\n");
6609 fprintf (fp, "If names are provided, they are demangled. Otherwise filters standard input.\n");
6611 exit (exit_value);
6614 /* Option specification for getopt_long. */
6615 static const struct option long_options[] =
6617 { "help", no_argument, NULL, 'h' },
6618 { "no-params", no_argument, NULL, 'p' },
6619 { "verbose", no_argument, NULL, 'v' },
6620 { NULL, no_argument, NULL, 0 },
6623 /* Main entry for a demangling filter executable. It will demangle
6624 its command line arguments, if any. If none are provided, it will
6625 filter stdin to stdout, replacing any recognized mangled C++ names
6626 with their demangled equivalents. */
6629 main (int argc, char *argv[])
6631 int i;
6632 int opt_char;
6633 int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
6635 /* Use the program name of this program, as invoked. */
6636 program_name = argv[0];
6638 /* Parse options. */
6641 opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
6642 switch (opt_char)
6644 case '?': /* Unrecognized option. */
6645 print_usage (stderr, 1);
6646 break;
6648 case 'h':
6649 print_usage (stdout, 0);
6650 break;
6652 case 'p':
6653 options &= ~ DMGL_PARAMS;
6654 break;
6656 case 'v':
6657 options |= DMGL_VERBOSE;
6658 break;
6661 while (opt_char != -1);
6663 if (optind == argc)
6664 /* No command line arguments were provided. Filter stdin. */
6666 dyn_string_t mangled = dyn_string_new (3);
6667 char *s;
6669 /* Read all of input. */
6670 while (!feof (stdin))
6672 char c;
6674 /* Pile characters into mangled until we hit one that can't
6675 occur in a mangled name. */
6676 c = getchar ();
6677 while (!feof (stdin) && is_mangled_char (c))
6679 dyn_string_append_char (mangled, c);
6680 if (feof (stdin))
6681 break;
6682 c = getchar ();
6685 if (dyn_string_length (mangled) > 0)
6687 #ifdef IN_GLIBCPP_V3
6688 s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
6689 #else
6690 s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
6691 #endif
6693 if (s != NULL)
6695 fputs (s, stdout);
6696 free (s);
6698 else
6700 /* It might not have been a mangled name. Print the
6701 original text. */
6702 fputs (dyn_string_buf (mangled), stdout);
6705 dyn_string_clear (mangled);
6708 /* If we haven't hit EOF yet, we've read one character that
6709 can't occur in a mangled name, so print it out. */
6710 if (!feof (stdin))
6711 putchar (c);
6714 dyn_string_delete (mangled);
6716 else
6717 /* Demangle command line arguments. */
6719 /* Loop over command line arguments. */
6720 for (i = optind; i < argc; ++i)
6722 char *s;
6723 #ifdef IN_GLIBCPP_V3
6724 int status;
6725 #endif
6727 /* Attempt to demangle. */
6728 #ifdef IN_GLIBCPP_V3
6729 s = __cxa_demangle (argv[i], NULL, NULL, &status);
6730 #else
6731 s = cplus_demangle_v3 (argv[i], options);
6732 #endif
6734 /* If it worked, print the demangled name. */
6735 if (s != NULL)
6737 printf ("%s\n", s);
6738 free (s);
6740 else
6742 #ifdef IN_GLIBCPP_V3
6743 fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
6744 #else
6745 fprintf (stderr, "Failed: %s\n", argv[i]);
6746 #endif
6751 return 0;
6754 #endif /* STANDALONE_DEMANGLER */