?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
This commit was manufactured by cvs2svn to create branch
[official-gcc.git] / libstdc++-v3 / include / ext / demangle.h
blob5de4f04a22461e88fcaa15f9009f9fa9182b6cc9
1 // C++ IA64 / g++ v3 demangler -*- C++ -*-
2
3 // Copyright (C) 2003, 2004 Free Software Foundation, Inc.
4 // Written by Carlo Wood <carlo@alinoe.com>
5 //
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING. If not, write to the Free
19 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 // USA.
21
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction. Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License. This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 // This file implements demangling of "C++ ABI for Itanium"-mangled symbol
32 // and type names as described in Revision 1.73 of the C++ ABI as can be found
33 // at http://www.codesourcery.com/cxx-abi/abi.html#mangling
34
35 #ifndef _DEMANGLER_H
36 #define _DEMANGLER_H 1
37
38 #include <vector>
39 #include <string>
40 #include <ext/new_allocator.h>
41
42 #ifndef _GLIBCXX_DEMANGLER_DEBUG
43 #define _GLIBCXX_DEMANGLER_CWDEBUG 0
44 #define _GLIBCXX_DEMANGLER_DEBUG(x)
45 #define _GLIBCXX_DEMANGLER_DOUT(cntrl, data)
46 #define _GLIBCXX_DEMANGLER_DOUT_ENTERING(x)
47 #define _GLIBCXX_DEMANGLER_DOUT_ENTERING2(x)
48 #define _GLIBCXX_DEMANGLER_DOUT_ENTERING3(x)
49 #define _GLIBCXX_DEMANGLER_RETURN return M_result
50 #define _GLIBCXX_DEMANGLER_RETURN2 return M_result
51 #define _GLIBCXX_DEMANGLER_RETURN3
52 #define _GLIBCXX_DEMANGLER_FAILURE \
53 do { M_result = false; return false; } while(0)
54 #else
55 #define _GLIBCXX_DEMANGLER_CWDEBUG 1
56 #endif
57
58 namespace __gnu_cxx
59 {
60 namespace demangler
61 {
62 enum substitution_nt
63 {
64 type,
65 template_template_param,
66 nested_name_prefix,
67 nested_name_template_prefix,
68 unscoped_template_name
69 };
70
71 struct substitution_st
72 {
73 int M_start_pos;
74 substitution_nt M_type;
75 int M_number_of_prefixes;
76
77 substitution_st(int start_pos,
78 substitution_nt type,
79 int number_of_prefixes)
80 : M_start_pos(start_pos), M_type(type),
81 M_number_of_prefixes(number_of_prefixes)
82 { }
83 };
84
85 enum simple_qualifier_nt
86 {
87 complex_or_imaginary = 'G',
88 pointer = 'P',
89 reference = 'R'
90 };
91
92 enum cv_qualifier_nt
93 {
94 cv_qualifier = 'K'
95 };
96
97 enum param_qualifier_nt
98 {
99 vendor_extension = 'U',
100 array = 'A',
101 pointer_to_member = 'M'
102 };
103
104 template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
105 class qualifier;
106
107 template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
108 class qualifier_list;
109
110 template<typename Tp, typename Allocator = __gnu_cxx::new_allocator<Tp> >
111 class session;
112
113 template<typename Tp, typename Allocator>
114 class qualifier
115 {
116 typedef typename Allocator::template rebind<char>::other
117 char_Allocator;
118 typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
119 string_type;
120
121 private:
122 char M_qualifier1;
123 char M_qualifier2;
124 char M_qualifier3;
125 mutable unsigned char M_cnt;
126 string_type M_optional_type;
127 int M_start_pos;
128 bool M_part_of_substitution;
129
130 public:
131 qualifier(int start_pos,
132 simple_qualifier_nt simple_qualifier,
133 int inside_substitution)
134 : M_qualifier1(simple_qualifier),
135 M_start_pos(start_pos),
136 M_part_of_substitution(inside_substitution)
137 { }
138
139 qualifier(int start_pos,
140 cv_qualifier_nt,
141 char const* start,
142 int count,
143 int inside_substitution)
144 : M_qualifier1(start[0]),
145 M_qualifier2((count > 1) ? start[1] : '\0'),
146 M_qualifier3((count > 2) ? start[2] : '\0'),
147 M_start_pos(start_pos),
148 M_part_of_substitution(inside_substitution)
149 { }
150
151 qualifier(int start_pos,
152 param_qualifier_nt param_qualifier,
153 string_type optional_type,
154 int inside_substitution)
155 : M_qualifier1(param_qualifier),
156 M_optional_type(optional_type),
157 M_start_pos(start_pos),
158 M_part_of_substitution(inside_substitution)
159 { }
160
161 int
162 get_start_pos(void) const
163 { return M_start_pos; }
164
165 char
166 first_qualifier(void) const
167 { M_cnt = 1; return M_qualifier1; }
168
169 char
170 next_qualifier(void) const
171 {
172 return (++M_cnt == 2) ? M_qualifier2
173 : ((M_cnt == 3) ? M_qualifier3 : 0);
174 }
175
176 string_type const&
177 get_optional_type(void) const
178 { return M_optional_type; }
179
180 bool
181 part_of_substitution(void) const
182 { return M_part_of_substitution; }
183
184 #if _GLIBCXX_DEMANGLER_CWDEBUG
185 friend std::ostream& operator<<(std::ostream& os, qualifier const& qual)
186 {
187 os << (char)qual.M_qualifier1;
188 if (qual.M_qualifier1 == vendor_extension ||
189 qual.M_qualifier1 == array ||
190 qual.M_qualifier1 == pointer_to_member)
191 os << " [" << qual.M_optional_type << ']';
192 else if (qual.M_qualifier1 == 'K' ||
193 qual.M_qualifier1 == 'V' ||
194 qual.M_qualifier1 == 'r')
195 {
196 if (qual.M_qualifier2)
197 {
198 os << (char)qual.M_qualifier2;
199 if (qual.M_qualifier3)
200 os << (char)qual.M_qualifier3;
201 }
202 }
203 return os;
204 }
205 #endif
206 };
207
208 template<typename Tp, typename Allocator>
209 class qualifier_list
210 {
211 typedef typename Allocator::template rebind<char>::other
212 char_Allocator;
213 typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
214 string_type;
215
216 private:
217 mutable bool M_printing_suppressed;
218 typedef qualifier<Tp, Allocator> qual;
219 typedef typename Allocator::template rebind<qual>::other qual_Allocator;
220 typedef std::vector<qual, qual_Allocator> qual_vector;
221 qual_vector M_qualifier_starts;
222 session<Tp, Allocator>& M_demangler;
223
224 void decode_KVrA(string_type& prefix, string_type& postfix, int cvq,
225 typename qual_vector::
226 const_reverse_iterator const& iter_array) const;
227
228 public:
229 qualifier_list(session<Tp, Allocator>& demangler_obj)
230 : M_printing_suppressed(false), M_demangler(demangler_obj)
231 { }
232
233 void
234 add_qualifier_start(simple_qualifier_nt simple_qualifier,
235 int start_pos,
236 int inside_substitution)
237 { M_qualifier_starts.
238 push_back(qualifier<Tp, Allocator>(start_pos,
239 simple_qualifier, inside_substitution)); }
240
241 void
242 add_qualifier_start(cv_qualifier_nt cv_qualifier,
243 int start_pos,
244 int count,
245 int inside_substitution)
246 { M_qualifier_starts.
247 push_back(qualifier<Tp, Allocator>(start_pos,
248 cv_qualifier, &M_demangler.M_str[start_pos],
249 count, inside_substitution)); }
250
251 void
252 add_qualifier_start(param_qualifier_nt param_qualifier,
253 int start_pos,
254 string_type optional_type,
255 int inside_substitution)
256 { M_qualifier_starts.
257 push_back(qualifier<Tp, Allocator>(start_pos,
258 param_qualifier, optional_type, inside_substitution)); }
259
260 void
261 decode_qualifiers(string_type& prefix,
262 string_type& postfix,
263 bool member_function_pointer_qualifiers) const;
264
265 bool
266 suppressed(void) const
267 { return M_printing_suppressed; }
268
269 void
270 printing_suppressed(void)
271 { M_printing_suppressed = true; }
272
273 size_t
274 size(void) const
275 { return M_qualifier_starts.size(); }
276
277 #if _GLIBCXX_DEMANGLER_CWDEBUG
278 friend std::ostream& operator<<(std::ostream& os, qualifier_list const& list)
279 {
280 typename qual_vector::const_iterator
281 iter = list.M_qualifier_starts.begin();
282 if (iter != list.M_qualifier_starts.end())
283 {
284 os << "{ " << *iter;
285 while (++iter != list.M_qualifier_starts.end())
286 os << ", " << *iter;
287 os << " }";
288 }
289 else
290 os << "{ }";
291 return os;
292 }
293 #endif
294 };
295
296 struct implementation_details
297 {
298 private:
299 unsigned int M_style;
300
301 public:
302 // The following flags change the behaviour of the demangler. The
303 // default behaviour is that none of these flags is set.
304
305 static unsigned int const style_void = 1;
306 // Default behaviour: int f()
307 // Use (void) instead of (): int f(void)
308
309 static unsigned int const style_literal = 2;
310 // Default behaviour: (long)13,
311 // (unsigned long long)19
312 // Use extensions 'u', 'l' and 'll' for integral
313 // literals (as in template arguments): 13l, 19ull
314
315 static unsigned int const style_literal_int = 4;
316 // Default behaviour: 4
317 // Use also an explicit
318 // cast for int in literals: (int)4
319
320 static unsigned int const style_compact_expr_ops = 8;
321 // Default behaviour: (i) < (3), sizeof (int)
322 // Don't output spaces around
323 // operators in expressions: (i)<(3), sizeof(int)
324
325 static unsigned int const style_sizeof_typename = 16;
326 // Default behaviour: sizeof (X::t)
327 // Put 'typename' infront of <nested-name>
328 // types inside a 'sizeof': sizeof (typename X::t)
329
330 public:
331 implementation_details(unsigned int style_flags = 0) :
332 M_style(style_flags) { }
333 virtual ~implementation_details() { }
334 bool get_style_void(void) const
335 { return (M_style & style_void); }
336 bool get_style_literal(void) const
337 { return (M_style & style_literal); }
338 bool get_style_literal_int(void) const
339 { return (M_style & style_literal_int); }
340 bool get_style_compact_expr_ops(void) const
341 { return (M_style & style_compact_expr_ops); }
342 bool get_style_sizeof_typename(void) const
343 { return (M_style & style_sizeof_typename); }
344 // This can be overridden by user implementations.
345 virtual bool decode_real(char* /* output */, unsigned long* /* input */,
346 size_t /* size_of_real */) const
347 { return false; }
348 };
349
350 template<typename Tp, typename Allocator>
351 class session
352 {
353 public:
354 friend class qualifier_list<Tp, Allocator>;
355 typedef typename Allocator::template rebind<char>::other
356 char_Allocator;
357 typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
358 string_type;
359
360 private:
361 char const* M_str;
362 int M_pos;
363 int M_maxpos;
364 bool M_result;
365 int M_inside_template_args;
366 int M_inside_type;
367 int M_inside_substitution;
368 bool M_saw_destructor;
369 bool M_name_is_cdtor;
370 bool M_name_is_template;
371 bool M_name_is_conversion_operator;
372 bool M_template_args_need_space;
373 string_type M_function_name;
374 typedef typename Allocator::template rebind<int>::other
375 int_Allocator;
376 typedef typename Allocator::template rebind<substitution_st>::other
377 subst_Allocator;
378 std::vector<int, int_Allocator> M_template_arg_pos;
379 int M_template_arg_pos_offset;
380 std::vector<substitution_st, subst_Allocator> M_substitutions_pos;
381 implementation_details const& M_implementation_details;
382 typedef typename Allocator::template
383 rebind<qualifier_list<Allocator> >::other qualifier_list_Allocator;
384 qualifier_list_Allocator M_qualifier_list_alloc;
385 #if _GLIBCXX_DEMANGLER_CWDEBUG
386 bool M_inside_add_substitution;
387 #endif
388
389 public:
390 explicit session(char const* in, int len,
391 implementation_details const& id = implementation_details())
392 : M_str(in), M_pos(0), M_maxpos(len - 1), M_result(true),
393 M_inside_template_args(0), M_inside_type(0),
394 M_inside_substitution(0), M_saw_destructor(false),
395 M_name_is_cdtor(false), M_name_is_template(false),
396 M_name_is_conversion_operator(false),
397 M_template_args_need_space(false), M_template_arg_pos_offset(0),
398 M_implementation_details(id)
399 #if _GLIBCXX_DEMANGLER_CWDEBUG
400 , M_inside_add_substitution(false)
401 #endif
402 { }
403
404 static int
405 decode_encoding(string_type& output, char const* input, int len,
406 implementation_details const& id = implementation_details());
407
408 bool
409 decode_type(string_type& output,
410 qualifier_list<Tp, Allocator>* qualifiers = NULL)
411 {
412 string_type postfix;
413 bool res = decode_type_with_postfix(output, postfix, qualifiers);
414 output += postfix;
415 return res;
416 }
417
418 bool
419 remaining_input_characters(void) const
420 { return current() != 0; }
421
422 private:
423 char
424 current(void) const
425 { return (M_pos > M_maxpos) ? 0 : M_str[M_pos]; }
426
427 char
428 next_peek(void) const
429 { return (M_pos >= M_maxpos) ? 0 : M_str[M_pos + 1]; }
430
431 char
432 next(void)
433 { return (M_pos >= M_maxpos) ? 0 : M_str[++M_pos]; }
434
435 char
436 eat_current(void)
437 { return (M_pos > M_maxpos) ? 0 : M_str[M_pos++]; }
438
439 void
440 store(int& saved_pos)
441 { saved_pos = M_pos; }
442
443 void
444 restore(int saved_pos)
445 { M_pos = saved_pos; M_result = true; }
446
447 void
448 add_substitution(int start_pos,
449 substitution_nt sub_type,
450 int number_of_prefixes);
451
452 bool decode_type_with_postfix(string_type& prefix,
453 string_type& postfix, qualifier_list<Tp, Allocator>* qualifiers = NULL);
454 bool decode_bare_function_type(string_type& output);
455 bool decode_builtin_type(string_type& output);
456 bool decode_call_offset(string_type& output);
457 bool decode_class_enum_type(string_type& output);
458 bool decode_expression(string_type& output);
459 bool decode_literal(string_type& output);
460 bool decode_local_name(string_type& output);
461 bool decode_name(string_type& output,
462 string_type& nested_name_qualifiers);
463 bool decode_nested_name(string_type& output,
464 string_type& qualifiers);
465 bool decode_number(string_type& output);
466 bool decode_operator_name(string_type& output);
467 bool decode_source_name(string_type& output);
468 bool decode_substitution(string_type& output,
469 qualifier_list<Tp, Allocator>* qualifiers = NULL);
470 bool decode_template_args(string_type& output);
471 bool decode_template_param(string_type& output,
472 qualifier_list<Tp, Allocator>* qualifiers = NULL);
473 bool decode_unqualified_name(string_type& output);
474 bool decode_unscoped_name(string_type& output);
475 bool decode_non_negative_decimal_integer(string_type& output);
476 bool decode_special_name(string_type& output);
477 bool decode_real(string_type& output, size_t size_of_real);
478 };
479
480 template<typename Tp, typename Allocator>
481 #if !_GLIBCXX_DEMANGLER_CWDEBUG
482 inline
483 #endif
484 void
485 session<Tp, Allocator>::add_substitution(int start_pos,
486 substitution_nt sub_type,
487 int number_of_prefixes = 0)
488 {
489 if (!M_inside_substitution)
490 {
491 #if _GLIBCXX_DEMANGLER_CWDEBUG
492 if (M_inside_add_substitution)
493 return;
494 #endif
495 M_substitutions_pos.
496 push_back(substitution_st(start_pos,
497 sub_type, number_of_prefixes));
498 #if _GLIBCXX_DEMANGLER_CWDEBUG
499 if (!DEBUGCHANNELS::dc::demangler.is_on())
500 return;
501 string_type substitution_name("S");
502 int n = M_substitutions_pos.size() - 1;
503 if (n > 0)
504 substitution_name += (n <= 10) ? (char)(n + '0' - 1)
505 : (char)(n + 'A' - 11);
506 substitution_name += '_';
507 string_type subst;
508 int saved_pos = M_pos;
509 M_pos = start_pos;
510 M_inside_add_substitution = true;
511 _GLIBCXX_DEMANGLER_DEBUG( dc::demangler.off() );
512 switch(sub_type)
513 {
514 case type:
515 decode_type(subst);
516 break;
517 case template_template_param:
518 decode_template_param(subst);
519 break;
520 case nested_name_prefix:
521 case nested_name_template_prefix:
522 for (int cnt = number_of_prefixes; cnt > 0; --cnt)
523 {
524 if (current() == 'I')
525 {
526 subst += ' ';
527 decode_template_args(subst);
528 }
529 else
530 {
531 if (cnt < number_of_prefixes)
532 subst += "::";
533 if (current() == 'S')
534 decode_substitution(subst);
535 else if (current() == 'T')
536 decode_template_param(subst);
537 else
538 decode_unqualified_name(subst);
539 }
540 }
541 break;
542 case unscoped_template_name:
543 decode_unscoped_name(subst);
544 break;
545 }
546 M_pos = saved_pos;
547 _GLIBCXX_DEMANGLER_DEBUG( dc::demangler.on() );
548 _GLIBCXX_DEMANGLER_DOUT(dc::demangler,
549 "Adding substitution " << substitution_name
550 << " : " << subst
551 << " (from " << location_ct((char*)__builtin_return_address(0)
552 + builtin_return_address_offset)
553 << " <- " << location_ct((char*)__builtin_return_address(1)
554 + builtin_return_address_offset)
555 << " <- " << location_ct((char*)__builtin_return_address(2)
556 + builtin_return_address_offset)
557 << ").");
558 M_inside_add_substitution = false;
559 #endif
560 }
561 }
562
563 // We don't want to depend on locale (or include <cctype> for that matter).
564 // We also don't want to use "safe-ctype.h" because that headerfile is not
565 // available to the users.
566 inline bool isdigit(char c) { return c >= '0' && c <= '9'; }
567 inline bool islower(char c) { return c >= 'a' && c <= 'z'; }
568 inline bool isupper(char c) { return c >= 'A' && c <= 'Z'; }
569 inline char tolower(char c) { return isupper(c) ? c - 'A' + 'a' : c; }
570
571 //
572 // <non-negative decimal integer> ::= 0
573 // ::= 1|2|3|4|5|6|7|8|9 [<digit>+]
574 // <digit> ::= 0|1|2|3|4|5|6|7|8|9
575 //
576 template<typename Tp, typename Allocator>
577 bool
578 session<Tp, Allocator>::
579 decode_non_negative_decimal_integer(string_type& output)
580 {
581 char c = current();
582 if (c == '0')
583 {
584 output += '0';
585 eat_current();
586 }
587 else if (!isdigit(c))
588 M_result = false;
589 else
590 {
591 do
592 {
593 output += c;
594 }
595 while (isdigit((c = next())));
596 }
597 return M_result;
598 }
599
600 // <number> ::= [n] <non-negative decimal integer>
601 //
602 template<typename Tp, typename Allocator>
603 bool
604 session<Tp, Allocator>::decode_number(string_type& output)
605 {
606 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_number");
607 if (current() != 'n')
608 decode_non_negative_decimal_integer(output);
609 else
610 {
611 output += '-';
612 eat_current();
613 decode_non_negative_decimal_integer(output);
614 }
615 _GLIBCXX_DEMANGLER_RETURN;
616 }
617
618 // <builtin-type> ::= v # void
619 // ::= w # wchar_t
620 // ::= b # bool
621 // ::= c # char
622 // ::= a # signed char
623 // ::= h # unsigned char
624 // ::= s # short
625 // ::= t # unsigned short
626 // ::= i # int
627 // ::= j # unsigned int
628 // ::= l # long
629 // ::= m # unsigned long
630 // ::= x # long long, __int64
631 // ::= y # unsigned long long, __int64
632 // ::= n # __int128
633 // ::= o # unsigned __int128
634 // ::= f # float
635 // ::= d # double
636 // ::= e # long double, __float80
637 // ::= g # __float128
638 // ::= z # ellipsis
639 // ::= u <source-name> # vendor extended type
640 //
641 char const* const builtin_type_c[26] =
642 {
643 "signed char", // a
644 "bool", // b
645 "char", // c
646 "double", // d
647 "long double", // e
648 "float", // f
649 "__float128", // g
650 "unsigned char", // h
651 "int", // i
652 "unsigned int", // j
653 NULL, // k
654 "long", // l
655 "unsigned long", // m
656 "__int128", // n
657 "unsigned __int128", // o
658 NULL, // p
659 NULL, // q
660 NULL, // r
661 "short", // s
662 "unsigned short", // t
663 NULL, // u
664 "void", // v
665 "wchar_t", // w
666 "long long", // x
667 "unsigned long long", // y
668 "..." // z
669 };
670
671 //
672 template<typename Tp, typename Allocator>
673 bool
674 session<Tp, Allocator>::decode_builtin_type(string_type& output)
675 {
676 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_builtin_type");
677 char const* bt;
678 if (!islower(current()) || !(bt = builtin_type_c[current() - 'a']))
679 _GLIBCXX_DEMANGLER_FAILURE;
680 output += bt;
681 eat_current();
682 _GLIBCXX_DEMANGLER_RETURN;
683 }
684
685 // <class-enum-type> ::= <name>
686 //
687 template<typename Tp, typename Allocator>
688 bool
689 session<Tp, Allocator>::decode_class_enum_type(string_type& output)
690 {
691 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_class_enum_type");
692 string_type nested_name_qualifiers;
693 if (!decode_name(output, nested_name_qualifiers))
694 _GLIBCXX_DEMANGLER_FAILURE;
695 output += nested_name_qualifiers;
696 _GLIBCXX_DEMANGLER_RETURN;
697 }
698
699 // <substitution> ::=
700 // S <seq-id> _
701 // S_
702 // St # ::std::
703 // Sa # ::std::allocator
704 // Sb # ::std::basic_string
705 // Ss # ::std::basic_string<char, std::char_traits<char>,
706 // std::allocator<char> >
707 // Si # ::std::basic_istream<char, std::char_traits<char> >
708 // So # ::std::basic_ostream<char, std::char_traits<char> >
709 // Sd # ::std::basic_iostream<char, std::char_traits<char> >
710 //
711 // <seq-id> ::=
712 // 0|1|2|3|4|5|6|7|8|9|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R|S|T|U|V|W|X|Y|Z
713 // [<seq-id>] # Base 36 number
714 //
715 template<typename Tp, typename Allocator>
716 bool
717 session<Tp, Allocator>::decode_substitution(string_type& output,
718 qualifier_list<Tp, Allocator>* qualifiers)
719 {
720 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_substitution");
721 unsigned int value = 0;
722 char c = next();
723 if (c != '_')
724 {
725 switch(c)
726 {
727 case 'a':
728 {
729 output += "std::allocator";
730 if (!M_inside_template_args)
731 {
732 M_function_name = "allocator";
733 M_name_is_template = true;
734 M_name_is_cdtor = false;
735 M_name_is_conversion_operator = false;
736 }
737 eat_current();
738 if (qualifiers)
739 qualifiers->printing_suppressed();
740 _GLIBCXX_DEMANGLER_RETURN;
741 }
742 case 'b':
743 {
744 output += "std::basic_string";
745 if (!M_inside_template_args)
746 {
747 M_function_name = "basic_string";
748 M_name_is_template = true;
749 M_name_is_cdtor = false;
750 M_name_is_conversion_operator = false;
751 }
752 eat_current();
753 if (qualifiers)
754 qualifiers->printing_suppressed();
755 _GLIBCXX_DEMANGLER_RETURN;
756 }
757 case 'd':
758 output += "std::iostream";
759 if (!M_inside_template_args)
760 {
761 M_function_name = "iostream";
762 M_name_is_template = true;
763 M_name_is_cdtor = false;
764 M_name_is_conversion_operator = false;
765 }
766 eat_current();
767 if (qualifiers)
768 qualifiers->printing_suppressed();
769 _GLIBCXX_DEMANGLER_RETURN;
770 case 'i':
771 output += "std::istream";
772 if (!M_inside_template_args)
773 {
774 M_function_name = "istream";
775 M_name_is_template = true;
776 M_name_is_cdtor = false;
777 M_name_is_conversion_operator = false;
778 }
779 eat_current();
780 if (qualifiers)
781 qualifiers->printing_suppressed();
782 _GLIBCXX_DEMANGLER_RETURN;
783 case 'o':
784 output += "std::ostream";
785 if (!M_inside_template_args)
786 {
787 M_function_name = "ostream";
788 M_name_is_template = true;
789 M_name_is_cdtor = false;
790 M_name_is_conversion_operator = false;
791 }
792 eat_current();
793 if (qualifiers)
794 qualifiers->printing_suppressed();
795 _GLIBCXX_DEMANGLER_RETURN;
796 case 's':
797 output += "std::string";
798 if (!M_inside_template_args)
799 {
800 M_function_name = "string";
801 M_name_is_template = true;
802 M_name_is_cdtor = false;
803 M_name_is_conversion_operator = false;
804 }
805 eat_current();
806 if (qualifiers)
807 qualifiers->printing_suppressed();
808 _GLIBCXX_DEMANGLER_RETURN;
809 case 't':
810 output += "std";
811 eat_current();
812 if (qualifiers)
813 qualifiers->printing_suppressed();
814 _GLIBCXX_DEMANGLER_RETURN;
815 default:
816 for(;; c = next())
817 {
818 if (isdigit(c))
819 value = value * 36 + c - '0';
820 else if (isupper(c))
821 value = value * 36 + c - 'A' + 10;
822 else if (c == '_')
823 break;
824 else
825 _GLIBCXX_DEMANGLER_FAILURE;
826 }
827 ++value;
828 break;
829 }
830 }
831 eat_current();
832 if (value >= M_substitutions_pos.size() ||
833 M_inside_type > 20) // Rather than core dump.
834 _GLIBCXX_DEMANGLER_FAILURE;
835 ++M_inside_substitution;
836 int saved_pos = M_pos;
837 substitution_st& substitution(M_substitutions_pos[value]);
838 M_pos = substitution.M_start_pos;
839 switch(substitution.M_type)
840 {
841 case type:
842 decode_type(output, qualifiers);
843 break;
844 case template_template_param:
845 decode_template_param(output, qualifiers);
846 break;
847 case nested_name_prefix:
848 case nested_name_template_prefix:
849 for (int cnt = substitution.M_number_of_prefixes; cnt > 0; --cnt)
850 {
851 if (current() == 'I')
852 {
853 if (M_template_args_need_space)
854 output += ' ';
855 M_template_args_need_space = false;
856 if (!decode_template_args(output))
857 _GLIBCXX_DEMANGLER_FAILURE;
858 }
859 else
860 {
861 if (cnt < substitution.M_number_of_prefixes)
862 output += "::";
863 if (current() == 'S')
864 {
865 if (!decode_substitution(output))
866 _GLIBCXX_DEMANGLER_FAILURE;
867 }
868 else if (!decode_unqualified_name(output))
869 _GLIBCXX_DEMANGLER_FAILURE;
870 }
871 }
872 if (qualifiers)
873 qualifiers->printing_suppressed();
874 break;
875 case unscoped_template_name:
876 decode_unscoped_name(output);
877 if (qualifiers)
878 qualifiers->printing_suppressed();
879 break;
880 }
881 M_pos = saved_pos;
882 --M_inside_substitution;
883 _GLIBCXX_DEMANGLER_RETURN;
884 }
885
886 // <template-param> ::= T_ # first template parameter
887 // ::= T <parameter-2 non-negative number> _
888 //
889 template<typename Tp, typename Allocator>
890 bool
891 session<Tp, Allocator>::decode_template_param(string_type& output,
892 qualifier_list<Tp, Allocator>* qualifiers)
893 {
894 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_template_parameter");
895 if (current() != 'T')
896 _GLIBCXX_DEMANGLER_FAILURE;
897 unsigned int value = 0;
898 char c;
899 if ((c = next()) != '_')
900 {
901 while(isdigit(c))
902 {
903 value = value * 10 + c - '0';
904 c = next();
905 }
906 ++value;
907 }
908 if (eat_current() != '_')
909 _GLIBCXX_DEMANGLER_FAILURE;
910 value += M_template_arg_pos_offset;
911 if (value >= M_template_arg_pos.size())
912 _GLIBCXX_DEMANGLER_FAILURE;
913 int saved_pos = M_pos;
914 M_pos = M_template_arg_pos[value];
915 if (M_inside_type > 20) // Rather than core dump.
916 _GLIBCXX_DEMANGLER_FAILURE;
917 ++M_inside_substitution;
918 if (current() == 'X')
919 {
920 eat_current();
921 decode_expression(output);
922 }
923 else if (current() == 'L')
924 decode_literal(output);
925 else
926 decode_type(output, qualifiers);
927 --M_inside_substitution;
928 M_pos = saved_pos;
929 _GLIBCXX_DEMANGLER_RETURN;
930 }
931
932 template<typename Tp, typename Allocator>
933 bool
934 session<Tp, Allocator>::decode_real(string_type& output, size_t size_of_real)
935 {
936 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_real");
937
938 unsigned long words[4]; // 32 bit per long, maximum of 128 bits.
939 unsigned long* word = &words[0];
940
941 int saved_pos;
942 store(saved_pos);
943
944 // The following assumes that leading zeroes are also included in the
945 // mangled name, I am not sure that is conforming to the C++-ABI, but
946 // it is what g++ does.
947 unsigned char nibble, c = current();
948 for(size_t word_cnt = size_of_real / 4; word_cnt > 0; --word_cnt)
949 {
950 for (int nibble_cnt = 0; nibble_cnt < 8; ++nibble_cnt)
951 {
952 // Translate character into nibble.
953 if (c < '0' || c > 'f')
954 _GLIBCXX_DEMANGLER_FAILURE;
955 if (c <= '9')
956 nibble = c - '0';
957 else if (c >= 'a')
958 nibble = c - 'a' + 10;
959 else
960 _GLIBCXX_DEMANGLER_FAILURE;
961 // Write nibble into word array.
962 if (nibble_cnt == 0)
963 *word = nibble << 28;
964 else
965 *word |= (nibble << (28 - 4 * nibble_cnt));
966 c = next();
967 }
968 ++word;
969 }
970 char buf[24];
971 if (M_implementation_details.decode_real(buf, words, size_of_real))
972 {
973 output += buf;
974 _GLIBCXX_DEMANGLER_RETURN;
975 }
976 restore(saved_pos);
977
978 output += '[';
979 c = current();
980 for(size_t nibble_cnt = 0; nibble_cnt < 2 * size_of_real; ++nibble_cnt)
981 {
982 if (c < '0' || c > 'f' || (c > '9' && c < 'a'))
983 _GLIBCXX_DEMANGLER_FAILURE;
984 output += c;
985 c = next();
986 }
987 output += ']';
988
989 _GLIBCXX_DEMANGLER_RETURN;
990 }
991
992 template<typename Tp, typename Allocator>
993 bool
994 session<Tp, Allocator>::decode_literal(string_type& output)
995 {
996 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_literal");
997 eat_current(); // Eat the 'L'.
998 if (current() == '_')
999 {
1000 if (next() != 'Z')
1001 _GLIBCXX_DEMANGLER_FAILURE;
1002 eat_current();
1003 if ((M_pos += decode_encoding(output, M_str + M_pos,
1004 M_maxpos - M_pos + 1, M_implementation_details)) < 0)
1005 _GLIBCXX_DEMANGLER_FAILURE;
1006 }
1007 else
1008 {
1009 // Special cases
1010 if (current() == 'b')
1011 {
1012 if (next() == '0')
1013 output += "false";
1014 else
1015 output += "true";
1016 eat_current();
1017 _GLIBCXX_DEMANGLER_RETURN;
1018 }
1019 char c = current();
1020 if ((c == 'i' || c == 'j' || c == 'l' ||
1021 c == 'm' || c == 'x' || c == 'y') &&
1022 M_implementation_details.get_style_literal())
1023 eat_current();
1024 else if (c == 'i' &&
1025 !M_implementation_details.get_style_literal_int())
1026 eat_current();
1027 else
1028 {
1029 output += '(';
1030 if (!decode_type(output))
1031 _GLIBCXX_DEMANGLER_FAILURE;
1032 output += ')';
1033 }
1034 if (c >= 'd' && c <= 'g')
1035 {
1036 size_t size_of_real = (c == 'd') ? sizeof(double) :
1037 ((c == 'f') ? sizeof(float) :
1038 (c == 'e') ? sizeof(long double) : 16);
1039 if (!decode_real(output, size_of_real))
1040 _GLIBCXX_DEMANGLER_FAILURE;
1041 }
1042 else if (!decode_number(output))
1043 _GLIBCXX_DEMANGLER_FAILURE;
1044 if (M_implementation_details.get_style_literal())
1045 {
1046 if (c == 'j' || c == 'm' || c == 'y')
1047 output += 'u';
1048 if (c == 'l' || c == 'm')
1049 output += 'l';
1050 if (c == 'x' || c == 'y')
1051 output += "ll";
1052 }
1053 }
1054 _GLIBCXX_DEMANGLER_RETURN;
1055 }
1056
1057 // <operator-name> ::=
1058 // nw # new
1059 // na # new[]
1060 // dl # delete
1061 // da # delete[]
1062 // ps # + (unary)
1063 // ng # - (unary)
1064 // ad # & (unary)
1065 // de # * (unary)
1066 // co # ~
1067 // pl # +
1068 // mi # -
1069 // ml # *
1070 // dv # /
1071 // rm # %
1072 // an # &
1073 // or # |
1074 // eo # ^
1075 // aS # =
1076 // pL # +=
1077 // mI # -=
1078 // mL # *=
1079 // dV # /=
1080 // rM # %=
1081 // aN # &=
1082 // oR # |=
1083 // eO # ^=
1084 // ls # <<
1085 // rs # >>
1086 // lS # <<=
1087 // rS # >>=
1088 // eq # ==
1089 // ne # !=
1090 // lt # <
1091 // gt # >
1092 // le # <=
1093 // ge # >=
1094 // nt # !
1095 // aa # &&
1096 // oo # ||
1097 // pp # ++
1098 // mm # --
1099 // cm # ,
1100 // pm # ->*
1101 // pt # ->
1102 // cl # ()
1103 // ix # []
1104 // qu # ?
1105 // st # sizeof (a type)
1106 // sz # sizeof (an expression)
1107 // cv <type> # (cast)
1108 // v <digit> <source-name> # vendor extended operator
1109 //
1110 // Symbol operator codes exist of two characters, we need to find a
1111 // quick hash so that their names can be looked up in a table.
1112 //
1113 // The puzzle :)
1114 // Shift the rows so that there is at most one character per column.
1115 //
1116 // A perfect solution (Oh no, it's THE MATRIX!):
1117 // horizontal
1118 // ....................................... offset + 'a'
1119 // a, a||d|||||||||n||||s|||||||||||||||||||| 0
1120 // c, || |||||||lm o||| |||||||||||||||||||| 0
1121 // d, || a|||e|| l|| ||||||v||||||||||||| 4
1122 // e, || ||| || || |||o|q ||||||||||||| 8
1123 // g, || ||| || || e|| | ||||||||t|||| 15
1124 // i, || ||| || || || | |||||||| |||x 15
1125 // l, |e ||| || st || | |||||||| ||| -2
1126 // m, | |i| lm || | |||||||| ||| -2
1127 // n, a e g t| w |||||||| ||| 1
1128 // o, | ||||o||r ||| 16
1129 // p, | ||lm |p st| 17
1130 // q, | u| | | 6
1131 // r, m s | | 9
1132 // s, t z 12
1133 // .......................................
1134 // ^ ^__ second character
1135 // |___ first character
1136 //
1137
1138 // Putting that solution in tables:
1139
1140 char const offset_table_c [1 + CHAR_MAX - CHAR_MIN ] =
1141 {
1142 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1143 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1145 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1148 #if (CHAR_MIN < 0)
1149 // Add -CHAR_MIN extra zeroes (128):
1150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1152 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1153 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1154 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1155 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1156 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1157 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1158 // a b c d e f g h i j k
1159 0, -97, 0, -97, -93, -89, 0, -82, 0, -82, 0, 0,
1160 // l m n o p q r s t u v
1161 -99, -99, -96, -81, -80, -91, -88, -85, 0, 0, 0,
1162 #else
1163 // a b c d e f g h i j k
1164 0, 159, 0, 159, 163, 167, 0, 174, 0, 174, 0, 0,
1165 // l m n o p q r s t u v
1166 157, 157, 160, 175, 176, 165, 168, 171, 0, 0, 0,
1167 #endif
1168 // ... more zeros
1169 };
1170
1171 enum xary_nt {
1172 unary,
1173 binary,
1174 trinary
1175 };
1176
1177 struct entry_st
1178 {
1179 char const* opcode;
1180 char const* symbol_name;
1181 xary_nt type;
1182 };
1183
1184 entry_st const symbol_name_table_c[39] = {
1185 { "aa", "operator&&", binary },
1186 { "na", "operator new[]", unary },
1187 { "le", "operator<=", binary },
1188 { "ad", "operator&", unary },
1189 { "da", "operator delete[]", unary },
1190 { "ne", "operator!=", binary },
1191 { "mi=", "operator-", binary },
1192 { "ng", "operator-", unary },
1193 { "de", "operator*", unary },
1194 { "ml=", "operator*", binary },
1195 { "mm", "operator--", unary },
1196 { "cl", "operator()", unary },
1197 { "cm", "operator,", binary },
1198 { "an=", "operator&", binary },
1199 { "co", "operator~", binary },
1200 { "dl", "operator delete", unary },
1201 { "ls=", "operator<<", binary },
1202 { "lt", "operator<", binary },
1203 { "as=", "operator", binary },
1204 { "ge", "operator>=", binary },
1205 { "nt", "operator!", unary },
1206 { "rm=", "operator%", binary },
1207 { "eo=", "operator^", binary },
1208 { "nw", "operator new", unary },
1209 { "eq", "operator==", binary },
1210 { "dv=", "operator/", binary },
1211 { "qu", "operator?", trinary },
1212 { "rs=", "operator>>", binary },
1213 { "pl=", "operator+", binary },
1214 { "pm", "operator->*", binary },
1215 { "oo", "operator||", binary },
1216 { "st", "sizeof", unary },
1217 { "pp", "operator++", unary },
1218 { "or=", "operator|", binary },
1219 { "gt", "operator>", binary },
1220 { "ps", "operator+", unary },
1221 { "pt", "operator->", binary },
1222 { "sz", "sizeof", unary },
1223 { "ix", "operator[]", unary }
1224 };
1225
1226 template<typename Tp, typename Allocator>
1227 bool
1228 session<Tp, Allocator>::decode_operator_name(string_type& output)
1229 {
1230 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_operator_name");
1231
1232 char opcode0 = current();
1233 char opcode1 = tolower(next());
1234
1235 register char hash;
1236 if ((hash = offset_table_c[opcode0 - CHAR_MIN]))
1237 {
1238 hash += opcode1;
1239 if (
1240 #if (CHAR_MIN < 0)
1241 hash >= 0 &&
1242 #endif
1243 hash < 39)
1244 {
1245 int index = static_cast<int>(static_cast<unsigned char>(hash));
1246 entry_st entry = symbol_name_table_c[index];
1247 if (entry.opcode[0] == opcode0 && entry.opcode[1] == opcode1
1248 && (opcode1 == current() || entry.opcode[2] == '='))
1249 {
1250 output += entry.symbol_name;
1251 if (opcode1 != current())
1252 output += '=';
1253 eat_current();
1254 if (hash == 16 || hash == 17)
1255 M_template_args_need_space = true;
1256 _GLIBCXX_DEMANGLER_RETURN;
1257 }
1258 else if (opcode0 == 'c' && opcode1 == 'v') // casting operator
1259 {
1260 eat_current();
1261 output += "operator ";
1262 if (current() == 'T')
1263 {
1264 // This is a templated cast operator.
1265 // It must be of the form "cvT_I...E".
1266 // Let M_template_arg_pos already point
1267 // to the template argument.
1268 M_template_arg_pos_offset = M_template_arg_pos.size();
1269 M_template_arg_pos.push_back(M_pos + 3);
1270 }
1271 if (!decode_type(output))
1272 _GLIBCXX_DEMANGLER_FAILURE;
1273 if (!M_inside_template_args)
1274 M_name_is_conversion_operator = true;
1275 _GLIBCXX_DEMANGLER_RETURN;
1276 }
1277 }
1278 }
1279 _GLIBCXX_DEMANGLER_FAILURE;
1280 }
1281
1282 //
1283 // <expression> ::= <unary operator-name> <expression>
1284 // ::= <binary operator-name> <expression> <expression>
1285 // ::= <trinary operator-name> <expression> <expression> <expression>
1286 // ::= st <type>
1287 // ::= <template-param>
1288 // ::= sr <type> <unqualified-name> # dependent name
1289 // ::= sr <type> <unqualified-name> <template-args> # dependent template-id
1290 // ::= <expr-primary>
1291 //
1292 // <expr-primary> ::= L <type> <value number> E # integer literal
1293 // ::= L <type> <value float> E # floating literal
1294 // ::= L <mangled-name> E # external name
1295 //
1296 template<typename Tp, typename Allocator>
1297 bool
1298 session<Tp, Allocator>::decode_expression(string_type& output)
1299 {
1300 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_expression");
1301 if (current() == 'T')
1302 {
1303 if (!decode_template_param(output))
1304 _GLIBCXX_DEMANGLER_FAILURE;
1305 _GLIBCXX_DEMANGLER_RETURN;
1306 }
1307 else if (current() == 'L')
1308 {
1309 if (!decode_literal(output))
1310 _GLIBCXX_DEMANGLER_FAILURE;
1311 if (current() != 'E')
1312 _GLIBCXX_DEMANGLER_FAILURE;
1313 eat_current();
1314 _GLIBCXX_DEMANGLER_RETURN;
1315 }
1316 else if (current() == 's')
1317 {
1318 char opcode1 = next();
1319 if (opcode1 == 't' || opcode1 == 'z')
1320 {
1321 eat_current();
1322 if (M_implementation_details.get_style_compact_expr_ops())
1323 output += "sizeof(";
1324 else
1325 output += "sizeof (";
1326 if (opcode1 == 't')
1327 {
1328 // I cannot think of a mangled name that is valid for both cases
1329 // when just replacing the 't' by a 'z' or vica versa, which
1330 // indicates that there is no ambiguity that dictates the need
1331 // for a seperate "st" case, except to be able catch invalid
1332 // mangled names. However there CAN be ambiguity in the demangled
1333 // name when there are both a type and a symbol of the same name,
1334 // which then leads to different encoding (of course) with
1335 // sizeof (type) or sizeof (expression) respectively, but that
1336 // ambiguity is not per se related to "sizeof" except that that
1337 // is the only place where both a type AND an expression are valid
1338 // in as part of a (template function) type.
1339 //
1340 // Example:
1341 //
1342 // struct B { typedef int t; };
1343 // struct A : public B { static int t[2]; };
1344 // template<int i, int j> struct C { typedef int q; };
1345 // template<int i, typename T>
1346 // void f(typename C<sizeof (typename T::t),
1347 // sizeof (T::t)>::q) { }
1348 // void instantiate() { f<5, A>(0); }
1349 //
1350 // Leads to _Z1fILi5E1AEvN1CIXstN1T1tEEXszsrS2_1tEE1qE which
1351 // demangles as
1352 // void f<5, A>(C<sizeof (T::t), sizeof (T::t)>::q)
1353 //
1354 // This is ambiguity is very unlikely to happen and it is kind
1355 // of fuzzy to detect when adding a 'typename' makes sense.
1356 //
1357 if (M_implementation_details.get_style_sizeof_typename())
1358 {
1359 // We can only get here inside a template parameter,
1360 // so this is syntactically correct if the given type is
1361 // a typedef. The only disadvantage is that it is inconsistent
1362 // with all other places where the 'typename' keyword should be
1363 // used and we don't.
1364 // With this, the above example will demangle as
1365 // void f<5, A>(C<sizeof (typename T::t), sizeof (T::t)>::q)
1366 if (current() == 'N' || // <nested-name>
1367 // This should be a safe bet.
1368 (current() == 'S' &&
1369 next_peek() == 't')) // std::something, guess that
1370 // this involves a typedef.
1371 output += "typename ";
1372 }
1373 if (!decode_type(output))
1374 _GLIBCXX_DEMANGLER_FAILURE;
1375 }
1376 else
1377 {
1378 if (!decode_expression(output))
1379 _GLIBCXX_DEMANGLER_FAILURE;
1380 }
1381 output += ')';
1382 _GLIBCXX_DEMANGLER_RETURN;
1383 }
1384 else if (current() == 'r')
1385 {
1386 eat_current();
1387 if (!decode_type(output))
1388 _GLIBCXX_DEMANGLER_FAILURE;
1389 output += "::";
1390 if (!decode_unqualified_name(output))
1391 _GLIBCXX_DEMANGLER_FAILURE;
1392 if (current() != 'I' || decode_template_args(output))
1393 _GLIBCXX_DEMANGLER_RETURN;
1394 }
1395 }
1396 else
1397 {
1398 char opcode0 = current();
1399 char opcode1 = tolower(next());
1400
1401 register char hash;
1402 if ((hash = offset_table_c[opcode0 - CHAR_MIN]))
1403 {
1404 hash += opcode1;
1405 if (
1406 #if (CHAR_MIN < 0)
1407 hash >= 0 &&
1408 #endif
1409 hash < 39)
1410 {
1411 int index = static_cast<int>(static_cast<unsigned char>(hash));
1412 entry_st entry = symbol_name_table_c[index];
1413 if (entry.opcode[0] == opcode0 && entry.opcode[1] == opcode1
1414 && (opcode1 == current() || entry.opcode[2] == '='))
1415 {
1416 char const* op = entry.symbol_name + 8; // Skip "operator".
1417 if (*op == ' ') // operator new and delete.
1418 ++op;
1419 if (entry.type == unary)
1420 output += op;
1421 bool is_eq = (opcode1 != current());
1422 eat_current();
1423 if (index == 34 && M_inside_template_args) // operator>
1424 output += '(';
1425 output += '(';
1426 if (!decode_expression(output))
1427 _GLIBCXX_DEMANGLER_FAILURE;
1428 output += ')';
1429 if (entry.type != unary)
1430 {
1431 if (!M_implementation_details.get_style_compact_expr_ops())
1432 output += ' ';
1433 output += op;
1434 if (is_eq)
1435 output += '=';
1436 if (!M_implementation_details.get_style_compact_expr_ops())
1437 output += ' ';
1438 output += '(';
1439 if (!decode_expression(output))
1440 _GLIBCXX_DEMANGLER_FAILURE;
1441 output += ')';
1442 if (index == 34 && M_inside_template_args)
1443 output += ')';
1444 if (entry.type == trinary)
1445 {
1446 if (M_implementation_details.get_style_compact_expr_ops())
1447 output += ":(";
1448 else
1449 output += " : (";
1450 if (!decode_expression(output))
1451 _GLIBCXX_DEMANGLER_FAILURE;
1452 output += ')';
1453 }
1454 }
1455 _GLIBCXX_DEMANGLER_RETURN;
1456 }
1457 else if (opcode0 == 'c' &&
1458 opcode1 == 'v') // casting operator.
1459 {
1460 eat_current();
1461 output += '(';
1462 if (!decode_type(output))
1463 _GLIBCXX_DEMANGLER_FAILURE;
1464 output += ")(";
1465 if (!decode_expression(output))
1466 _GLIBCXX_DEMANGLER_FAILURE;
1467 output += ')';
1468 _GLIBCXX_DEMANGLER_RETURN;
1469 }
1470 }
1471 }
1472 }
1473 _GLIBCXX_DEMANGLER_FAILURE;
1474 }
1475
1476 //
1477 // <template-args> ::= I <template-arg>+ E
1478 // <template-arg> ::= <type> # type or template
1479 // ::= L <type> <value number> E # integer literal
1480 // ::= L <type> <value float> E # floating literal
1481 // ::= L <mangled-name> E # external name
1482 // ::= X <expression> E # expression
1483 template<typename Tp, typename Allocator>
1484 bool
1485 session<Tp, Allocator>::decode_template_args(string_type& output)
1486 {
1487 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_template_args");
1488 if (eat_current() != 'I')
1489 _GLIBCXX_DEMANGLER_FAILURE;
1490 int prev_size = M_template_arg_pos.size();
1491 ++M_inside_template_args;
1492 if (M_template_args_need_space)
1493 {
1494 output += ' ';
1495 M_template_args_need_space = false;
1496 }
1497 output += '<';
1498 for(;;)
1499 {
1500 if (M_inside_template_args == 1 && !M_inside_type)
1501 M_template_arg_pos.push_back(M_pos);
1502 if (current() == 'X')
1503 {
1504 eat_current();
1505 if (!decode_expression(output))
1506 _GLIBCXX_DEMANGLER_FAILURE;
1507 if (current() != 'E')
1508 _GLIBCXX_DEMANGLER_FAILURE;
1509 eat_current();
1510 }
1511 else if (current() == 'L')
1512 {
1513 if (!decode_literal(output))
1514 _GLIBCXX_DEMANGLER_FAILURE;
1515 if (current() != 'E')
1516 _GLIBCXX_DEMANGLER_FAILURE;
1517 eat_current();
1518 }
1519 else if (!decode_type(output))
1520 _GLIBCXX_DEMANGLER_FAILURE;
1521 if (current() == 'E')
1522 break;
1523 output += ", ";
1524 }
1525 eat_current();
1526 if (*(output.rbegin()) == '>')
1527 output += ' ';
1528 output += '>';
1529 --M_inside_template_args;
1530 if (!M_inside_template_args && !M_inside_type)
1531 {
1532 M_name_is_template = true;
1533 M_template_arg_pos_offset = prev_size;
1534 }
1535 _GLIBCXX_DEMANGLER_RETURN;
1536 }
1537
1538 // <bare-function-type> ::=
1539 // <signature type>+ # Types are parameter types.
1540 //
1541 // Note that the possible return type of the <bare-function-type>
1542 // has already been eaten before we call this function. This makes
1543 // our <bare-function-type> slightly different from the one in
1544 // the C++-ABI description.
1545 //
1546 template<typename Tp, typename Allocator>
1547 bool
1548 session<Tp, Allocator>::decode_bare_function_type(string_type& output)
1549 {
1550 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_bare_function_type");
1551 if (M_saw_destructor)
1552 {
1553 if (eat_current() != 'v' || (current() != 'E' && current() != 0))
1554 _GLIBCXX_DEMANGLER_FAILURE;
1555 output += "()";
1556 M_saw_destructor = false;
1557 _GLIBCXX_DEMANGLER_RETURN;
1558 }
1559 if (current() == 'v' && !M_implementation_details.get_style_void())
1560 {
1561 eat_current();
1562 if (current() != 'E' && current() != 0)
1563 _GLIBCXX_DEMANGLER_FAILURE;
1564 output += "()";
1565 M_saw_destructor = false;
1566 _GLIBCXX_DEMANGLER_RETURN;
1567 }
1568 output += '(';
1569 M_template_args_need_space = false;
1570 if (!decode_type(output)) // Must have at least one parameter.
1571 _GLIBCXX_DEMANGLER_FAILURE;
1572 while (current() != 'E' && current() != 0)
1573 {
1574 output += ", ";
1575 if (!decode_type(output))
1576 _GLIBCXX_DEMANGLER_FAILURE;
1577 }
1578 output += ')';
1579 _GLIBCXX_DEMANGLER_RETURN;
1580 }
1581
1582 // <type> ::=
1583 // <builtin-type> # Starts with a lower case character != r.
1584 // <function-type> # Starts with F
1585 // <class-enum-type> # Starts with N, S, C, D, Z, a digit or a lower
1586 // # case character. Since a lower case character
1587 // # would be an operator name, that would be an
1588 // # error. The S is a substitution or St
1589 // # (::std::). A 'C' would be a constructor and
1590 // # thus also an error.
1591 // <template-param> # Starts with T
1592 // <substitution> # Starts with S
1593 // <template-template-param> <template-args> # Starts with T or S,
1594 // # equivalent with the above.
1595 //
1596 // <array-type> # Starts with A
1597 // <pointer-to-member-type> # Starts with M
1598 // <CV-qualifiers> <type> # Starts with r, V or K
1599 // P <type> # pointer-to # Starts with P
1600 // R <type> # reference-to # Starts with R
1601 // C <type> # complex (C 2000) # Starts with C
1602 // G <type> # imaginary (C 2000)# Starts with G
1603 // U <source-name> <type> # vendor extended type qualifier,
1604 // # starts with U
1605 //
1606 // <template-template-param> ::= <template-param>
1607 // ::= <substitution>
1608
1609 // My own analysis of how to decode qualifiers:
1610 //
1611 // F is a <function-type>, <T> is a <builtin-type>, <class-enum-type>,
1612 // <template-param> or <template-template-param> <template-args>.
1613 // <Q> represents a series of qualifiers (not G or C).
1614 // <C> is an unqualified type.
1615 // <R> is a qualified type.
1616 // <B> is the bare-function-type without return type.
1617 // <I> is the array index.
1618 // Substitutions:
1619 // <Q>M<C><Q2>F<R><B>E ==> R (C::*Q)B Q2 "<C>", "F<R><B>E"
1620 // (<R> and <B> recursive),
1621 // "M<C><Q2>F<R><B>E".
1622 // <Q>F<R><B>E ==> R (Q)B "<R>", "<B>" (<B> recursive)
1623 // and "F<R><B>E".
1624 //
1625 // Note that if <R> has postfix qualifiers (an array or function), then
1626 // those are added AFTER the (member) function type. For example:
1627 // <Q>FPA<R><B>E ==> R (*(Q)B) [], where the PA added the prefix
1628 // "(*" and the postfix ") []".
1629 //
1630 // <Q>G<T> ==> imaginary T Q "<T>", "G<T>" (<T> recursive).
1631 // <Q>C<T> ==> complex T Q "<T>", "C<T>" (<T> recursive).
1632 // <Q><T> ==> T Q "<T>" (<T> recursive).
1633 //
1634 // where <Q> is any of:
1635 //
1636 // <Q>P ==> *Q "P..."
1637 // <Q>R ==> &Q "R..."
1638 // <Q>[K|V|r]+ ==> [ const| volatile| restrict]+Q "KVr..."
1639 // <Q>U<S> ==> SQ "U<S>..."
1640 // <Q>M<C> ==> C::*Q "M<C>..." (<C> recurs.)
1641 // A<I> ==> [I] "A<I>..." (<I> recurs.)
1642 // <Q>A<I> ==> (Q) [I] "A<I>..." (<I> recurs.)
1643 // Note that when <Q> ends on an A<I2> then the brackets are omitted
1644 // and no space is written between the two:
1645 // A<I2>A<I> ==> [I2][I]
1646 // If <Q> ends on [KVr]+, which can happen in combination with
1647 // substitutions only, then special handling is required, see below.
1648 //
1649 // A <substitution> is handled with an input position switch during which
1650 // new substitutions are turned off. Because recursive handling of types
1651 // (and therefore the order in which substitutions must be generated) must
1652 // be done left to right, but the generation of Q needs processing right to
1653 // left, substitutions per <type> are generated by reading the input left
1654 // to right and marking the starts of all substitutions only - implicitly
1655 // finishing them at the end of the type. Then the output and real
1656 // substitutions are generated.
1657 //
1658 // The following comment was for the demangling of g++ version 3.0.x. The
1659 // mangling (and I believe even the ABI description) have been fixed now
1660 // (as of g++ version 3.1).
1661 //
1662 // g++ 3.0.x only:
1663 // The ABI specifies for pointer-to-member function types the format
1664 // <Q>M<T>F<R><B>E. In other words, the qualifier <Q2> (see above) is
1665 // implicitely contained in <T> instead of explicitly part of the M format.
1666 // I am convinced that this is a bug in the ABI. Unfortunately, this is
1667 // how we have to demangle things as it has a direct impact on the order
1668 // in which substitutions are stored. This ill-formed design results in
1669 // rather ill-formed demangler code too however :/
1670 //
1671 // <Q2> is now explicitely part of the M format.
1672 // For some weird reason, g++ (3.2.1) does not add substitutions for
1673 // qualified member function pointers. I think that is another bug.
1674 //
1675
1676 // In the case of
1677 // <Q>A<I>
1678 // where <Q> ends on [K|V|r]+ then that part should be processed as
1679 // if it was behind the A<I> instead of in front of it. This is
1680 // because a constant array of ints is normally always mangled as
1681 // an array of constant ints. KVr qualifiers can end up in front
1682 // of an array when the array is part of a substitution or template
1683 // parameter, but the demangling should still result in the same
1684 // syntax; thus KA2_i (const array of ints) must result in the same
1685 // demangling as A2_Ki (array of const ints). As a result we must
1686 // demangle ...[...[[KVr]+A<I0>][KVr]+A<I1>]...[KVr]+A<In>[KVr]+
1687 // as A<I0>A<I1>...A<In>[KVr]+ where each K, V and r in the series
1688 // collapses to a single character at the right of the string.
1689 // For example:
1690 // VA9_KrA6_KVi --> A9_A6_KVri --> int volatile const restrict [9][6]
1691 // Note that substitutions are still added as usual (the translation
1692 // to A9_A6_KVri does not really happen).
1693 //
1694 // This decoding is achieved by delaying the decoding of any sequence
1695 // of [KVrA]'s and processing them together in the order: first the
1696 // short-circuited KVr part and then the arrays.
1697 static int const cvq_K = 1; // Saw at least one K
1698 static int const cvq_V = 2; // Saw at least one V
1699 static int const cvq_r = 4; // Saw at least one r
1700 static int const cvq_A = 8; // Saw at least one A
1701 static int const cvq_last = 16; // No remaining qualifiers.
1702 static int const cvq_A_cnt = 32; // Bit 5 and higher represent the
1703 // number of A's in the series.
1704 // In the function below, iter_array points to the first (right most)
1705 // A in the series, if any.
1706 template<typename Tp, typename Allocator>
1707 void
1708 qualifier_list<Tp, Allocator>::decode_KVrA(
1709 string_type& prefix, string_type& postfix, int cvq,
1710 typename qual_vector::const_reverse_iterator const& iter_array) const
1711 {
1712 _GLIBCXX_DEMANGLER_DOUT_ENTERING3("decode_KVrA");
1713 if ((cvq & cvq_K))
1714 prefix += " const";
1715 if ((cvq & cvq_V))
1716 prefix += " volatile";
1717 if ((cvq & cvq_r))
1718 prefix += " restrict";
1719 if ((cvq & cvq_A))
1720 {
1721 int n = cvq >> 5;
1722 for (typename qual_vector::
1723 const_reverse_iterator iter = iter_array;
1724 iter != M_qualifier_starts.rend(); ++iter)
1725 {
1726 switch((*iter).first_qualifier())
1727 {
1728 case 'K':
1729 case 'V':
1730 case 'r':
1731 break;
1732 case 'A':
1733 {
1734 string_type index = (*iter).get_optional_type();
1735 if (--n == 0 && (cvq & cvq_last))
1736 postfix = " [" + index + "]" + postfix;
1737 else if (n > 0)
1738 postfix = "[" + index + "]" + postfix;
1739 else
1740 {
1741 prefix += " (";
1742 postfix = ") [" + index + "]" + postfix;
1743 }
1744 break;
1745 }
1746 default:
1747 _GLIBCXX_DEMANGLER_RETURN3;
1748 }
1749 }
1750 }
1751 _GLIBCXX_DEMANGLER_RETURN3;
1752 }
1753
1754 template<typename Tp, typename Allocator>
1755 void
1756 qualifier_list<Tp, Allocator>::decode_qualifiers(
1757 string_type& prefix,
1758 string_type& postfix,
1759 bool member_function_pointer_qualifiers = false) const
1760 {
1761 _GLIBCXX_DEMANGLER_DOUT_ENTERING3("decode_qualifiers");
1762 int cvq = 0;
1763 typename qual_vector::const_reverse_iterator iter_array;
1764 for(typename qual_vector::
1765 const_reverse_iterator iter = M_qualifier_starts.rbegin();
1766 iter != M_qualifier_starts.rend(); ++iter)
1767 {
1768 if (!member_function_pointer_qualifiers
1769 && !(*iter).part_of_substitution())
1770 {
1771 int saved_inside_substitution = M_demangler.M_inside_substitution;
1772 M_demangler.M_inside_substitution = 0;
1773 M_demangler.add_substitution((*iter).get_start_pos(), type);
1774 M_demangler.M_inside_substitution = saved_inside_substitution;
1775 }
1776 char qualifier_char = (*iter).first_qualifier();
1777 for(; qualifier_char; qualifier_char = (*iter).next_qualifier())
1778 {
1779 switch(qualifier_char)
1780 {
1781 case 'P':
1782 if (cvq)
1783 {
1784 decode_KVrA(prefix, postfix, cvq, iter_array);
1785 cvq = 0;
1786 }
1787 prefix += "*";
1788 break;
1789 case 'R':
1790 if (cvq)
1791 {
1792 decode_KVrA(prefix, postfix, cvq, iter_array);
1793 cvq = 0;
1794 }
1795 prefix += "&";
1796 break;
1797 case 'K':
1798 cvq |= cvq_K;
1799 continue;
1800 case 'V':
1801 cvq |= cvq_V;
1802 continue;
1803 case 'r':
1804 cvq |= cvq_r;
1805 continue;
1806 case 'A':
1807 if (!(cvq & cvq_A))
1808 {
1809 cvq |= cvq_A;
1810 iter_array = iter;
1811 }
1812 cvq += cvq_A_cnt;
1813 break;
1814 case 'M':
1815 if (cvq)
1816 {
1817 decode_KVrA(prefix, postfix, cvq, iter_array);
1818 cvq = 0;
1819 }
1820 prefix += " ";
1821 prefix += (*iter).get_optional_type();
1822 prefix += "::*";
1823 break;
1824 case 'U':
1825 if (cvq)
1826 {
1827 decode_KVrA(prefix, postfix, cvq, iter_array);
1828 cvq = 0;
1829 }
1830 prefix += " ";
1831 prefix += (*iter).get_optional_type();
1832 break;
1833 case 'G': // Only here so we added a substitution.
1834 break;
1835 }
1836 break;
1837 }
1838 }
1839 if (cvq)
1840 decode_KVrA(prefix, postfix, cvq|cvq_last, iter_array);
1841 M_printing_suppressed = false;
1842 _GLIBCXX_DEMANGLER_RETURN3;
1843 }
1844
1845 //
1846 template<typename Tp, typename Allocator>
1847 bool
1848 session<Tp, Allocator>::decode_type_with_postfix(
1849 string_type& prefix, string_type& postfix,
1850 qualifier_list<Tp, Allocator>* qualifiers)
1851 {
1852 _GLIBCXX_DEMANGLER_DOUT_ENTERING2("decode_type");
1853 ++M_inside_type;
1854 bool recursive_template_param_or_substitution_call;
1855 if (!(recursive_template_param_or_substitution_call = qualifiers))
1856 {
1857 qualifier_list<Allocator>* raw_qualifiers = M_qualifier_list_alloc.allocate(1);
1858 qualifiers = new (raw_qualifiers) qualifier_list<Allocator>(*this);
1859 }
1860 // First eat all qualifiers.
1861 bool failure = false;
1862 for(;;) // So we can use 'continue' to eat the next qualifier.
1863 {
1864 int start_pos = M_pos;
1865 switch(current())
1866 {
1867 case 'P':
1868 qualifiers->add_qualifier_start(pointer, start_pos,
1869 M_inside_substitution);
1870 eat_current();
1871 continue;
1872 case 'R':
1873 qualifiers->add_qualifier_start(reference, start_pos,
1874 M_inside_substitution);
1875 eat_current();
1876 continue;
1877 case 'K':
1878 case 'V':
1879 case 'r':
1880 {
1881 char c;
1882 int count = 0;
1883 do
1884 {
1885 ++count;
1886 c = next();
1887 }
1888 while(c == 'K' || c == 'V' || c == 'r');
1889 qualifiers->add_qualifier_start(cv_qualifier, start_pos, count,
1890 M_inside_substitution);
1891 continue;
1892 }
1893 case 'U':
1894 {
1895 eat_current();
1896 string_type source_name;
1897 if (!decode_source_name(source_name))
1898 {
1899 failure = true;
1900 break;
1901 }
1902 qualifiers->add_qualifier_start(vendor_extension, start_pos,
1903 source_name, M_inside_substitution);
1904 continue;
1905 }
1906 case 'A':
1907 {
1908 // <array-type> ::= A <positive dimension number> _ <element type>
1909 // ::= A [<dimension expression>] _ <element type>
1910 //
1911 string_type index;
1912 int saved_pos;
1913 store(saved_pos);
1914 if (next() == 'n' || !decode_number(index))
1915 {
1916 restore(saved_pos);
1917 if (next() != '_' && !decode_expression(index))
1918 {
1919 failure = true;
1920 break;
1921 }
1922 }
1923 if (eat_current() != '_')
1924 {
1925 failure = true;
1926 break;
1927 }
1928 qualifiers->add_qualifier_start(array, start_pos, index,
1929 M_inside_substitution);
1930 continue;
1931 }
1932 case 'M':
1933 {
1934 // <pointer-to-member-type> ::= M <class type> <member type>
1935 // <Q>M<C> or <Q>M<C><Q2>F<R><B>E
1936 eat_current();
1937 string_type class_type;
1938 if (!decode_type(class_type)) // Substitution: "<C>".
1939 {
1940 failure = true;
1941 break;
1942 }
1943 char c = current();
1944 if (c == 'F' || c == 'K' || c == 'V' || c == 'r')
1945 // Must be CV-qualifiers and a member function pointer.
1946 {
1947 // <Q>M<C><Q2>F<R><B>E ==> R (C::*Q)B Q2
1948 // substitutions: "<C>", "F<R><B>E" (<R> and <B>
1949 // recursive), "M<C><Q2>F<R><B>E".
1950 int count = 0;
1951 int Q2_start_pos = M_pos;
1952 while(c == 'K' || c == 'V' || c == 'r') // Decode <Q2>.
1953 {
1954 ++count;
1955 c = next();
1956 }
1957 qualifier_list<Tp, Allocator> class_type_qualifiers(*this);
1958 if (count)
1959 class_type_qualifiers.
1960 add_qualifier_start(cv_qualifier, Q2_start_pos,
1961 count, M_inside_substitution);
1962 string_type member_function_qualifiers;
1963 // It is unclear why g++ doesn't add a substitution for
1964 // "<Q2>F<R><B>E" as it should I think.
1965 string_type member_function_qualifiers_postfix;
1966 class_type_qualifiers.
1967 decode_qualifiers(member_function_qualifiers,
1968 member_function_qualifiers_postfix, true);
1969 member_function_qualifiers +=
1970 member_function_qualifiers_postfix;
1971 // I don't think this substitution is actually ever used.
1972 int function_pos = M_pos;
1973 if (eat_current() != 'F')
1974 {
1975 failure = true;
1976 break;
1977 }
1978 // Return type.
1979 // Constructors, destructors and conversion operators don't
1980 // have a return type, but seem to never get here.
1981 string_type return_type_postfix;
1982 if (!decode_type_with_postfix(prefix, return_type_postfix))
1983 // substitution: <R> recursive
1984 {
1985 failure = true;
1986 break;
1987 }
1988 prefix += " (";
1989 prefix += class_type;
1990 prefix += "::*";
1991 string_type bare_function_type;
1992 if (!decode_bare_function_type(bare_function_type)
1993 || eat_current() != 'E') // Substitution: <B> recursive.
1994 {
1995 failure = true;
1996 break;
1997 }
1998 // substitution: "F<R><B>E".
1999 add_substitution(function_pos, type);
2000 // substitution: "M<C><Q2>F<R><B>E".
2001 add_substitution(start_pos, type);
2002 // substitution: all qualified types if any.
2003 qualifiers->decode_qualifiers(prefix, postfix);
2004 postfix += ")";
2005 postfix += bare_function_type;
2006 postfix += member_function_qualifiers;
2007 postfix += return_type_postfix;
2008 goto decode_type_exit;
2009 }
2010 qualifiers->add_qualifier_start(pointer_to_member, start_pos,
2011 class_type, M_inside_substitution);
2012 continue;
2013 }
2014 default:
2015 break;
2016 }
2017 break;
2018 }
2019 if (!failure)
2020 {
2021 // <Q>G<T> ==> imaginary T Q
2022 // substitutions: "<T>", "G<T>" (<T> recursive).
2023 // <Q>C<T> ==> complex T Q
2024 // substitutions: "<T>", "C<T>" (<T> recursive).
2025 if (current() == 'C' || current() == 'G')
2026 {
2027 prefix += current() == 'C' ? "complex " : "imaginary ";
2028 qualifiers->add_qualifier_start(complex_or_imaginary, M_pos,
2029 M_inside_substitution);
2030 eat_current();
2031 }
2032 int start_pos = M_pos;
2033 switch(current())
2034 {
2035 case 'F':
2036 {
2037 // <function-type> ::= F [Y] <bare-function-type> E
2038 //
2039 // Note that g++ never generates the 'Y', but we try to
2040 // demangle it anyway.
2041 bool extern_C = (next() == 'Y');
2042 if (extern_C)
2043 eat_current();
2044
2045 // <Q>F<R><B>E ==> R (Q)B
2046 // substitution: "<R>", "<B>" (<B> recursive) and "F<R><B>E".
2047
2048 // Return type.
2049 string_type return_type_postfix;
2050 if (!decode_type_with_postfix(prefix, return_type_postfix))
2051 // Substitution: "<R>".
2052 {
2053 failure = true;
2054 break;
2055 }
2056 // Only array and function (pointer) types have a postfix.
2057 // In that case we don't want the space but expect something
2058 // like prefix is "int (*" and postfix is ") [1]".
2059 // We do want the space if this pointer is qualified.
2060 if (return_type_postfix.size() == 0 ||
2061 (prefix.size() > 0 && *prefix.rbegin() != '*'))
2062 prefix += ' ';
2063 prefix += '(';
2064 string_type bare_function_type;
2065 if (!decode_bare_function_type(bare_function_type)
2066 // substitution: "<B>" (<B> recursive).
2067 || eat_current() != 'E')
2068 {
2069 failure = true;
2070 break;
2071 }
2072 add_substitution(start_pos, type); // Substitution: "F<R><B>E".
2073 qualifiers->decode_qualifiers(prefix, postfix);
2074 // substitution: all qualified types, if any.
2075 postfix += ")";
2076 if (extern_C)
2077 postfix += " [extern \"C\"] ";
2078 postfix += bare_function_type;
2079 postfix += return_type_postfix;
2080 break;
2081 }
2082 case 'T':
2083 if (!decode_template_param(prefix, qualifiers))
2084 {
2085 failure = true;
2086 break;
2087 }
2088 if (current() == 'I')
2089 {
2090 add_substitution(start_pos, template_template_param);
2091 // substitution: "<template-template-param>".
2092 if (!decode_template_args(prefix))
2093 {
2094 failure = true;
2095 break;
2096 }
2097 }
2098 if (!recursive_template_param_or_substitution_call
2099 && qualifiers->suppressed())
2100 {
2101 add_substitution(start_pos, type);
2102 // substitution: "<template-param>" or
2103 // "<template-template-param> <template-args>".
2104 qualifiers->decode_qualifiers(prefix, postfix);
2105 // substitution: all qualified types, if any.
2106 }
2107 break;
2108 case 'S':
2109 if (M_pos >= M_maxpos)
2110 {
2111 failure = true;
2112 break;
2113 }
2114 if (M_str[M_pos + 1] != 't')
2115 {
2116 if (!decode_substitution(prefix, qualifiers))
2117 {
2118 failure = true;
2119 break;
2120 }
2121 if (current() == 'I')
2122 {
2123 if (!decode_template_args(prefix))
2124 {
2125 failure = true;
2126 break;
2127 }
2128 if (!recursive_template_param_or_substitution_call
2129 && qualifiers->suppressed())
2130 add_substitution(start_pos, type);
2131 // Substitution:
2132 // "<template-template-param> <template-args>".
2133 }
2134 if (!recursive_template_param_or_substitution_call
2135 && qualifiers->suppressed())
2136 qualifiers->decode_qualifiers(prefix, postfix);
2137 // Substitution: all qualified types, if any.
2138 break;
2139 }
2140 /* Fall-through for St */
2141 case 'N':
2142 case 'Z':
2143 case '0':
2144 case '1':
2145 case '2':
2146 case '3':
2147 case '4':
2148 case '5':
2149 case '6':
2150 case '7':
2151 case '8':
2152 case '9':
2153 // <Q><T> ==> T Q
2154 // substitutions: "<T>" (<T> recursive).
2155 if (!decode_class_enum_type(prefix))
2156 {
2157 failure = true;
2158 break;
2159 }
2160 if (!recursive_template_param_or_substitution_call)
2161 {
2162 add_substitution(start_pos, type);
2163 // substitution: "<class-enum-type>".
2164 qualifiers->decode_qualifiers(prefix, postfix);
2165 // substitution: all qualified types, if any.
2166 }
2167 else
2168 qualifiers->printing_suppressed();
2169 break;
2170 default:
2171 // <Q><T> ==> T Q
2172 // substitutions: "<T>" (<T> recursive).
2173 if (!decode_builtin_type(prefix))
2174 {
2175 failure = true;
2176 break;
2177 }
2178 // If decode_type was called from decode_template_param then we
2179 // need to suppress calling qualifiers here in order to get a
2180 // substitution added anyway (for the <template-param>).
2181 if (!recursive_template_param_or_substitution_call)
2182 qualifiers->decode_qualifiers(prefix, postfix);
2183 else
2184 qualifiers->printing_suppressed();
2185 break;
2186 }
2187 }
2188 decode_type_exit:
2189 --M_inside_type;
2190 if (!recursive_template_param_or_substitution_call)
2191 {
2192 qualifiers->~qualifier_list<Allocator>();
2193 M_qualifier_list_alloc.deallocate(qualifiers, 1);
2194 }
2195 if (failure)
2196 _GLIBCXX_DEMANGLER_FAILURE;
2197 _GLIBCXX_DEMANGLER_RETURN2;
2198 }
2199
2200 // <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
2201 // ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
2202 //
2203 // <prefix> ::= <prefix> <unqualified-name>
2204 // ::= <template-prefix> <template-args>
2205 // ::= <template-param>
2206 // ::= # empty
2207 // ::= <substitution>
2208 //
2209 // <template-prefix> ::= <prefix> <template unqualified-name>
2210 // ::= <template-param>
2211 // ::= <substitution>
2212 //
2213 template<typename Tp, typename Allocator>
2214 bool
2215 session<Tp, Allocator>::decode_nested_name(string_type& output,
2216 string_type& qualifiers)
2217 {
2218 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_nested_name");
2219
2220 if (current() != 'N' || M_pos >= M_maxpos)
2221 _GLIBCXX_DEMANGLER_FAILURE;
2222
2223 // <CV-qualifiers> ::= [r] [V] [K] # restrict (C99), volatile, const
2224 char const* qualifiers_start = &M_str[M_pos + 1];
2225 for (char c = next(); c == 'K' || c == 'V' || c == 'r'; c = next());
2226 for (char const* qualifier_ptr = &M_str[M_pos - 1];
2227 qualifier_ptr >= qualifiers_start; --qualifier_ptr)
2228 switch(*qualifier_ptr)
2229 {
2230 case 'K':
2231 qualifiers += " const";
2232 break;
2233 case 'V':
2234 qualifiers += " volatile";
2235 break;
2236 case 'r':
2237 qualifiers += " restrict";
2238 break;
2239 }
2240
2241 int number_of_prefixes = 0;
2242 int substitution_start = M_pos;
2243 for(;;)
2244 {
2245 ++number_of_prefixes;
2246 if (current() == 'S')
2247 {
2248 if (!decode_substitution(output))
2249 _GLIBCXX_DEMANGLER_FAILURE;
2250 }
2251 else if (current() == 'I')
2252 {
2253 if (!decode_template_args(output))
2254 _GLIBCXX_DEMANGLER_FAILURE;
2255 if (current() != 'E')
2256 {
2257 // substitution: "<template-prefix> <template-args>".
2258 add_substitution(substitution_start, nested_name_prefix,
2259 number_of_prefixes);
2260 }
2261 }
2262 else
2263 {
2264 if (current() == 'T')
2265 {
2266 if (!decode_template_param(output))
2267 _GLIBCXX_DEMANGLER_FAILURE;
2268 }
2269 else if (!decode_unqualified_name(output))
2270 _GLIBCXX_DEMANGLER_FAILURE;
2271 if (current() != 'E')
2272 {
2273 // substitution: "<prefix> <unqualified-name>" or
2274 // "<prefix> <template unqualified-name>".
2275 add_substitution(substitution_start,
2276 (current() == 'I') ? nested_name_template_prefix
2277 : nested_name_prefix,
2278 number_of_prefixes);
2279 }
2280 }
2281 if (current() == 'E')
2282 {
2283 eat_current();
2284 _GLIBCXX_DEMANGLER_RETURN;
2285 }
2286 if (current() != 'I')
2287 output += "::";
2288 else if (M_template_args_need_space)
2289 output += ' ';
2290 M_template_args_need_space = false;
2291 }
2292 _GLIBCXX_DEMANGLER_FAILURE;
2293 }
2294
2295 // <local-name> := Z <function encoding> E <entity name> [<discriminator>]
2296 // := Z <function encoding> E s [<discriminator>]
2297 // <discriminator> := _ <non-negative number>
2298 //
2299 template<typename Tp, typename Allocator>
2300 bool
2301 session<Tp, Allocator>::decode_local_name(string_type& output)
2302 {
2303 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_local_name");
2304 if (current() != 'Z' || M_pos >= M_maxpos)
2305 _GLIBCXX_DEMANGLER_FAILURE;
2306 if ((M_pos += decode_encoding(output, M_str + M_pos + 1,
2307 M_maxpos - M_pos, M_implementation_details) + 1) < 0 ||
2308 eat_current() != 'E')
2309 _GLIBCXX_DEMANGLER_FAILURE;
2310 output += "::";
2311 if (current() == 's')
2312 {
2313 eat_current();
2314 output += "string literal";
2315 }
2316 else
2317 {
2318 string_type nested_name_qualifiers;
2319 if (!decode_name(output, nested_name_qualifiers))
2320 _GLIBCXX_DEMANGLER_FAILURE;
2321 output += nested_name_qualifiers;
2322 }
2323 string_type discriminator;
2324 if (current() == '_' && next() != 'n' && !decode_number(discriminator))
2325 _GLIBCXX_DEMANGLER_FAILURE;
2326 _GLIBCXX_DEMANGLER_RETURN;
2327 }
2328
2329 // <source-name> ::= <positive length number> <identifier>
2330 //
2331 template<typename Tp, typename Allocator>
2332 bool
2333 session<Tp, Allocator>::decode_source_name(string_type& output)
2334 {
2335 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_source_name");
2336 int length = current() - '0';
2337 if (length < 1 || length > 9)
2338 _GLIBCXX_DEMANGLER_FAILURE;
2339 while(isdigit(next()))
2340 length = 10 * length + current() - '0';
2341 char const* ptr = &M_str[M_pos];
2342 if (length > 11 && !strncmp(ptr, "_GLOBAL_", 8) && ptr[9] == 'N'
2343 && ptr[8] == ptr[10])
2344 {
2345 output += "(anonymous namespace)";
2346 if ((M_pos += length) > M_maxpos + 1)
2347 _GLIBCXX_DEMANGLER_FAILURE;
2348 }
2349 else
2350 while(length--)
2351 {
2352 if (current() == 0)
2353 _GLIBCXX_DEMANGLER_FAILURE;
2354 output += eat_current();
2355 }
2356 _GLIBCXX_DEMANGLER_RETURN;
2357 }
2358
2359 // <unqualified-name> ::= <operator-name> # Starts with lower case.
2360 // ::= <ctor-dtor-name> # Starts with 'C' or 'D'.
2361 // ::= <source-name> # Starts with a digit.
2362 //
2363 template<typename Tp, typename Allocator>
2364 bool
2365 session<Tp, Allocator>::decode_unqualified_name(string_type& output)
2366 {
2367 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_unqualified_name");
2368 if (M_inside_template_args)
2369 {
2370 if (!decode_source_name(output))
2371 _GLIBCXX_DEMANGLER_FAILURE;
2372 }
2373 else if (isdigit(current()))
2374 {
2375 bool recursive_unqualified_name = (&M_function_name == &output);
2376 // This can be a recursive call when we are decoding
2377 // an <operator-name> that is a cast operator for a some
2378 // <unqualified-name>; for example "operator Foo()".
2379 // In that case this is thus not a ctor or dtor and we
2380 // are not interested in updating M_function_name.
2381 if (!recursive_unqualified_name)
2382 M_function_name.clear();
2383 M_name_is_template = false;
2384 M_name_is_cdtor = false;
2385 M_name_is_conversion_operator = false;
2386 if (!decode_source_name(M_function_name))
2387 _GLIBCXX_DEMANGLER_FAILURE;
2388 if (!recursive_unqualified_name)
2389 output += M_function_name;
2390 }
2391 else if (islower(current()))
2392 {
2393 M_function_name.clear();
2394 M_name_is_template = false;
2395 M_name_is_cdtor = false;
2396 M_name_is_conversion_operator = false;
2397 if (!decode_operator_name(M_function_name))
2398 _GLIBCXX_DEMANGLER_FAILURE;
2399 output += M_function_name;
2400 }
2401 else if (current() == 'C' || current() == 'D')
2402 {
2403 // <ctor-dtor-name> ::=
2404 // C1 # complete object (in-charge) constructor
2405 // C2 # base object (not-in-charge) constructor
2406 // C3 # complete object (in-charge) allocating constructor
2407 // D0 # deleting (in-charge) destructor
2408 // D1 # complete object (in-charge) destructor
2409 // D2 # base object (not-in-charge) destructor
2410 //
2411 if (current() == 'C')
2412 {
2413 char c = next();
2414 if (c < '1' || c > '3')
2415 _GLIBCXX_DEMANGLER_FAILURE;
2416 }
2417 else
2418 {
2419 char c = next();
2420 if (c < '0' || c > '2')
2421 _GLIBCXX_DEMANGLER_FAILURE;
2422 output += '~';
2423 M_saw_destructor = true;
2424 }
2425 M_name_is_cdtor = true;
2426 eat_current();
2427 output += M_function_name;
2428 }
2429 else
2430 _GLIBCXX_DEMANGLER_FAILURE;
2431 _GLIBCXX_DEMANGLER_RETURN;
2432 }
2433
2434 // <unscoped-name> ::=
2435 // <unqualified-name> # Starts not with an 'S'
2436 // St <unqualified-name> # ::std::
2437 //
2438 template<typename Tp, typename Allocator>
2439 bool
2440 session<Tp, Allocator>::decode_unscoped_name(string_type& output)
2441 {
2442 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_unscoped_name");
2443 if (current() == 'S')
2444 {
2445 if (next() != 't')
2446 _GLIBCXX_DEMANGLER_FAILURE;
2447 eat_current();
2448 output += "std::";
2449 }
2450 decode_unqualified_name(output);
2451 _GLIBCXX_DEMANGLER_RETURN;
2452 }
2453
2454 // <name> ::=
2455 // <nested-name> # Starts with 'N'
2456 // <unscoped-template-name> <template-args> # idem
2457 // <local-name> # Starts with 'Z'
2458 // <unscoped-name> # Starts with 'S', 'C', 'D',
2459 // # a digit or a lower case
2460 // # character.
2461 //
2462 // <unscoped-template-name> ::= <unscoped-name>
2463 // ::= <substitution>
2464 template<typename Tp, typename Allocator>
2465 bool
2466 session<Tp, Allocator>::decode_name(string_type& output,
2467 string_type& nested_name_qualifiers)
2468 {
2469 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_name");
2470 int substitution_start = M_pos;
2471 if (current() == 'S' && (M_pos >= M_maxpos || M_str[M_pos + 1] != 't'))
2472 {
2473 if (!decode_substitution(output))
2474 _GLIBCXX_DEMANGLER_FAILURE;
2475 }
2476 else if (current() == 'N')
2477 {
2478 decode_nested_name(output, nested_name_qualifiers);
2479 _GLIBCXX_DEMANGLER_RETURN;
2480 }
2481 else if (current() == 'Z')
2482 {
2483 decode_local_name(output);
2484 _GLIBCXX_DEMANGLER_RETURN;
2485 }
2486 else if (!decode_unscoped_name(output))
2487 _GLIBCXX_DEMANGLER_FAILURE;
2488 if (current() == 'I')
2489 {
2490 // Must have been an <unscoped-template-name>.
2491 add_substitution(substitution_start, unscoped_template_name);
2492 if (!decode_template_args(output))
2493 _GLIBCXX_DEMANGLER_FAILURE;
2494 }
2495 M_template_args_need_space = false;
2496 _GLIBCXX_DEMANGLER_RETURN;
2497 }
2498
2499 // <call-offset> ::= h <nv-offset> _
2500 // ::= v <v-offset> _
2501 // <nv-offset> ::= <offset number>
2502 // non-virtual base override
2503 //
2504 // <v-offset> ::= <offset number> _ <virtual offset number>
2505 // virtual base override, with vcall offset
2506 template<typename Tp, typename Allocator>
2507 bool
2508 session<Tp, Allocator>::decode_call_offset(string_type&
2509 #if _GLIBCXX_DEMANGLER_CWDEBUG
2510 output
2511 #endif
2512 )
2513 {
2514 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_call_offset");
2515 if (current() == 'h')
2516 {
2517 string_type dummy;
2518 eat_current();
2519 if (decode_number(dummy) && current() == '_')
2520 {
2521 eat_current();
2522 _GLIBCXX_DEMANGLER_RETURN;
2523 }
2524 }
2525 else if (current() == 'v')
2526 {
2527 string_type dummy;
2528 eat_current();
2529 if (decode_number(dummy) && current() == '_')
2530 {
2531 eat_current();
2532 if (decode_number(dummy) && current() == '_')
2533 {
2534 eat_current();
2535 _GLIBCXX_DEMANGLER_RETURN;
2536 }
2537 }
2538 }
2539 _GLIBCXX_DEMANGLER_FAILURE;
2540 }
2541
2542 //
2543 // <special-name> ::=
2544 // TV <type> # virtual table
2545 // TT <type> # VTT structure (construction
2546 // vtable index).
2547 // TI <type> # typeinfo structure
2548 // TS <type> # typeinfo name (null-terminated
2549 // byte string).
2550 // GV <object name> # Guard variable for one-time
2551 // initialization of static objects in
2552 // a local scope.
2553 // T <call-offset> <base encoding># base is the nominal target function
2554 // of thunk.
2555 // Tc <call-offset> <call-offset> <base encoding> # base is the nominal
2556 // target function of thunk; first
2557 // call-offset is 'this' adjustment;
2558 // second call-offset is result
2559 // adjustment
2560 //
2561 template<typename Tp, typename Allocator>
2562 bool
2563 session<Tp, Allocator>::decode_special_name(string_type& output)
2564 {
2565 _GLIBCXX_DEMANGLER_DOUT_ENTERING("decode_special_name");
2566 if (current() == 'G')
2567 {
2568 if (next() != 'V')
2569 _GLIBCXX_DEMANGLER_FAILURE;
2570 output += "guard variable for ";
2571 string_type nested_name_qualifiers;
2572 eat_current();
2573 if (!decode_name(output, nested_name_qualifiers))
2574 _GLIBCXX_DEMANGLER_FAILURE;
2575 output += nested_name_qualifiers;
2576 _GLIBCXX_DEMANGLER_RETURN;
2577 }
2578 else if (current() != 'T')
2579 _GLIBCXX_DEMANGLER_FAILURE;
2580 switch(next())
2581 {
2582 case 'V':
2583 output += "vtable for ";
2584 eat_current();
2585 decode_type(output);
2586 _GLIBCXX_DEMANGLER_RETURN;
2587 case 'T':
2588 output += "VTT for ";
2589 eat_current();
2590 decode_type(output);
2591 _GLIBCXX_DEMANGLER_RETURN;
2592 case 'I':
2593 output += "typeinfo for ";
2594 eat_current();
2595 decode_type(output);
2596 _GLIBCXX_DEMANGLER_RETURN;
2597 case 'S':
2598 output += "typeinfo name for ";
2599 eat_current();
2600 decode_type(output);
2601 _GLIBCXX_DEMANGLER_RETURN;
2602 case 'c':
2603 output += "covariant return thunk to ";
2604 if (!decode_call_offset(output)
2605 || !decode_call_offset(output)
2606 || (M_pos += decode_encoding(output, M_str + M_pos,
2607 M_maxpos - M_pos + 1, M_implementation_details)) < 0)
2608 _GLIBCXX_DEMANGLER_FAILURE;
2609 _GLIBCXX_DEMANGLER_RETURN;
2610 case 'C': // GNU extension?
2611 {
2612 string_type first;
2613 output += "construction vtable for ";
2614 eat_current();
2615 if (!decode_type(first))
2616 _GLIBCXX_DEMANGLER_FAILURE;
2617 while(isdigit(current()))
2618 eat_current();
2619 if (eat_current() != '_')
2620 _GLIBCXX_DEMANGLER_FAILURE;
2621 if (!decode_type(output))
2622 _GLIBCXX_DEMANGLER_FAILURE;
2623 output += "-in-";
2624 output += first;
2625 _GLIBCXX_DEMANGLER_RETURN;
2626 }
2627 default:
2628 if (current() == 'v')
2629 output += "virtual thunk to ";
2630 else
2631 output += "non-virtual thunk to ";
2632 if (!decode_call_offset(output)
2633 || (M_pos += decode_encoding(output, M_str + M_pos,
2634 M_maxpos - M_pos + 1, M_implementation_details)) < 0)
2635 _GLIBCXX_DEMANGLER_FAILURE;
2636 _GLIBCXX_DEMANGLER_RETURN;
2637 }
2638 }
2639
2640 // <encoding> ::=
2641 // <function name> <bare-function-type> # Starts with 'C', 'D', 'N',
2642 // 'S', a digit or a lower case
2643 // character.
2644 // <data name> # Idem.
2645 // <special-name> # Starts with 'T' or 'G'.
2646 template<typename Tp, typename Allocator>
2647 int
2648 session<Tp, Allocator>::decode_encoding(string_type& output,
2649 char const* in, int len, implementation_details const& id)
2650 {
2651 #if _GLIBCXX_DEMANGLER_CWDEBUG
2652 _GLIBCXX_DEMANGLER_DOUT(dc::demangler,
2653 "Output thus far: \"" << output << '"');
2654 string_type input(in, len > 0x40000000 ? strlen(in) : len);
2655 _GLIBCXX_DEMANGLER_DOUT(
2656 dc::demangler, "Entering decode_encoding(\"" << input << "\")");
2657 #endif
2658 if (len <= 0)
2659 return INT_MIN;
2660 session<Tp, Allocator> demangler_session(in, len, id);
2661 string_type nested_name_qualifiers;
2662 int saved_pos;
2663 demangler_session.store(saved_pos);
2664 if (demangler_session.decode_special_name(output))
2665 return demangler_session.M_pos;
2666 demangler_session.restore(saved_pos);
2667 string_type name;
2668 if (!demangler_session.decode_name(name, nested_name_qualifiers))
2669 return INT_MIN;
2670 if (demangler_session.current() == 0
2671 || demangler_session.current() == 'E')
2672 {
2673 output += name;
2674 output += nested_name_qualifiers;
2675 return demangler_session.M_pos;
2676 }
2677 // Must have been a <function name>.
2678 string_type return_type_postfix;
2679 if (demangler_session.M_name_is_template
2680 && !(demangler_session.M_name_is_cdtor
2681 || demangler_session.M_name_is_conversion_operator))
2682 {
2683 // Return type of function
2684 if (!demangler_session.decode_type_with_postfix(output,
2685 return_type_postfix))
2686 return INT_MIN;
2687 output += ' ';
2688 }
2689 output += name;
2690 if (!demangler_session.decode_bare_function_type(output))
2691 return INT_MIN;
2692 output += nested_name_qualifiers;
2693 output += return_type_postfix;
2694 return demangler_session.M_pos;
2695 }
2696
2697 } // namespace demangler
2698
2699 // Public interface
2700 template<typename Tp, typename Allocator>
2701 struct demangle
2702 {
2703 typedef typename Allocator::template rebind<char>::other char_Allocator;
2704 typedef std::basic_string<char, std::char_traits<char>, char_Allocator>
2705 string_type;
2706 static string_type symbol(char const* in,
2707 demangler::implementation_details const& id);
2708 static string_type type(char const* in,
2709 demangler::implementation_details const& id);
2710 };
2711
2712 // demangle::symbol()
2713 //
2714 // Demangle `input' which should be a mangled function name as for
2715 // instance returned by nm(1).
2716 template<typename Tp, typename Allocator>
2717 typename demangle<Tp, Allocator>::string_type
2718 demangle<Tp, Allocator>::symbol(char const* input,
2719 demangler::implementation_details const& id)
2720 {
2721 // <mangled-name> ::= _Z <encoding>
2722 // <mangled-name> ::= _GLOBAL_ _<type>_ <disambiguation part>
2723 // <type> can be I or D (GNU extension)
2724 typedef demangler::session<Tp, Allocator> demangler_type;
2725 string_type result;
2726 bool failure = (input[0] != '_');
2727
2728 if (!failure)
2729 {
2730 if (input[1] == 'G')
2731 {
2732 if (!strncmp(input, "_GLOBAL__", 9)
2733 && (input[9] == 'D' || input[9] == 'I')
2734 && input[10] == '_')
2735 {
2736 if (input[9] == 'D')
2737 result.assign("global destructors keyed to ", 28);
2738 else
2739 result.assign("global constructors keyed to ", 29);
2740 // Output the disambiguation part as-is.
2741 result += input + 11;
2742 }
2743 else
2744 failure = true;
2745 }
2746 else if (input[1] == 'Z')
2747 {
2748 int cnt =
2749 demangler_type::decode_encoding(result, input + 2, INT_MAX, id);
2750 if (cnt < 0 || input[cnt + 2] != 0)
2751 failure = true;
2752 }
2753 else
2754 failure = true;
2755 }
2756
2757 // Failure to demangle, return the mangled name.
2758 if (failure)
2759 result.assign(input, strlen(input));
2760
2761 return result;
2762 }
2763
2764 // demangle::type()
2765 // Demangle `input' which must be a zero terminated mangled type
2766 // name as for instance returned by std::type_info::name().
2767 template<typename Tp, typename Allocator>
2768 typename demangle<Tp, Allocator>::string_type
2769 demangle<Tp, Allocator>::type(char const* input,
2770 demangler::implementation_details const& id)
2771 {
2772 std::basic_string<char, std::char_traits<char>, Allocator> result;
2773 if (input == NULL)
2774 result = "(null)";
2775 else
2776 {
2777 demangler::session<Tp, Allocator> demangler_session(input, INT_MAX, id);
2778 if (!demangler_session.decode_type(result)
2779 || demangler_session.remaining_input_characters())
2780 {
2781 // Failure to demangle, return the mangled name.
2782 result = input;
2783 }
2784 }
2785 return result;
2786 }
2787 } // namespace __gnu_cxx
2788
2789 #endif // __DEMANGLE_H
Mirror of the offical gcc git repository hosted at gcc.gnu.org