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