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