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