?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2016-11-10 François Dumont <fdumont@gcc.gnu.org>
[official-gcc.git] / libiberty / cplus-dem.c
blobc955bfbe1e7d768b452a5ee24141c4581b3b7849
1 /* Demangler for GNU C++
2 Copyright 1989, 1991, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2010 Free Software Foundation, Inc.
4 Written by James Clark (jjc@jclark.uucp)
5 Rewritten by Fred Fish (fnf@cygnus.com) for ARM and Lucid demangling
6 Modified by Satish Pai (pai@apollo.hp.com) for HP demangling
7
8 This file is part of the libiberty library.
9 Libiberty is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Library General Public
11 License as published by the Free Software Foundation; either
12 version 2 of the License, or (at your option) any later version.
13
14 In addition to the permissions in the GNU Library General Public
15 License, the Free Software Foundation gives you unlimited permission
16 to link the compiled version of this file into combinations with other
17 programs, and to distribute those combinations without any restriction
18 coming from the use of this file. (The Library Public License
19 restrictions do apply in other respects; for example, they cover
20 modification of the file, and distribution when not linked into a
21 combined executable.)
22
23 Libiberty is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 Library General Public License for more details.
27
28 You should have received a copy of the GNU Library General Public
29 License along with libiberty; see the file COPYING.LIB. If
30 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
31 Boston, MA 02110-1301, USA. */
32
33 /* This file exports two functions; cplus_mangle_opname and cplus_demangle.
34
35 This file imports xmalloc and xrealloc, which are like malloc and
36 realloc except that they generate a fatal error if there is no
37 available memory. */
38
39 /* This file lives in both GCC and libiberty. When making changes, please
40 try not to break either. */
41
42 #ifdef HAVE_CONFIG_H
43 #include "config.h"
44 #endif
45
46 #include "safe-ctype.h"
47
48 #include <sys/types.h>
49 #include <string.h>
50 #include <stdio.h>
51
52 #ifdef HAVE_STDLIB_H
53 #include <stdlib.h>
54 #else
55 void * malloc ();
56 void * realloc ();
57 #endif
58
59 #ifdef HAVE_LIMITS_H
60 #include <limits.h>
61 #endif
62 #ifndef INT_MAX
63 # define INT_MAX (int)(((unsigned int) ~0) >> 1) /* 0x7FFFFFFF */
64 #endif
65
66 #include <demangle.h>
67 #undef CURRENT_DEMANGLING_STYLE
68 #define CURRENT_DEMANGLING_STYLE work->options
69
70 #include "libiberty.h"
71
72 #define min(X,Y) (((X) < (Y)) ? (X) : (Y))
73
74 /* A value at least one greater than the maximum number of characters
75 that will be output when using the `%d' format with `printf'. */
76 #define INTBUF_SIZE 32
77
78 extern void fancy_abort (void) ATTRIBUTE_NORETURN;
79
80 /* In order to allow a single demangler executable to demangle strings
81 using various common values of CPLUS_MARKER, as well as any specific
82 one set at compile time, we maintain a string containing all the
83 commonly used ones, and check to see if the marker we are looking for
84 is in that string. CPLUS_MARKER is usually '$' on systems where the
85 assembler can deal with that. Where the assembler can't, it's usually
86 '.' (but on many systems '.' is used for other things). We put the
87 current defined CPLUS_MARKER first (which defaults to '$'), followed
88 by the next most common value, followed by an explicit '$' in case
89 the value of CPLUS_MARKER is not '$'.
90
91 We could avoid this if we could just get g++ to tell us what the actual
92 cplus marker character is as part of the debug information, perhaps by
93 ensuring that it is the character that terminates the gcc<n>_compiled
94 marker symbol (FIXME). */
95
96 #if !defined (CPLUS_MARKER)
97 #define CPLUS_MARKER '$'
98 #endif
99
100 enum demangling_styles current_demangling_style = auto_demangling;
101
102 static char cplus_markers[] = { CPLUS_MARKER, '.', '$', '\0' };
103
104 static char char_str[2] = { '\000', '\000' };
105
106 void
107 set_cplus_marker_for_demangling (int ch)
108 {
109 cplus_markers[0] = ch;
110 }
111
112 typedef struct string /* Beware: these aren't required to be */
113 { /* '\0' terminated. */
114 char *b; /* pointer to start of string */
115 char *p; /* pointer after last character */
116 char *e; /* pointer after end of allocated space */
117 } string;
118
119 /* Stuff that is shared between sub-routines.
120 Using a shared structure allows cplus_demangle to be reentrant. */
121
122 struct work_stuff
123 {
124 int options;
125 char **typevec;
126 char **ktypevec;
127 char **btypevec;
128 int numk;
129 int numb;
130 int ksize;
131 int bsize;
132 int ntypes;
133 int typevec_size;
134 int constructor;
135 int destructor;
136 int static_type; /* A static member function */
137 int temp_start; /* index in demangled to start of template args */
138 int type_quals; /* The type qualifiers. */
139 int dllimported; /* Symbol imported from a PE DLL */
140 char **tmpl_argvec; /* Template function arguments. */
141 int ntmpl_args; /* The number of template function arguments. */
142 int forgetting_types; /* Nonzero if we are not remembering the types
143 we see. */
144 string* previous_argument; /* The last function argument demangled. */
145 int nrepeats; /* The number of times to repeat the previous
146 argument. */
147 int *proctypevec; /* Indices of currently processed remembered typevecs. */
148 int proctypevec_size;
149 int nproctypes;
150 };
151
152 #define PRINT_ANSI_QUALIFIERS (work -> options & DMGL_ANSI)
153 #define PRINT_ARG_TYPES (work -> options & DMGL_PARAMS)
154
155 static const struct optable
156 {
157 const char *const in;
158 const char *const out;
159 const int flags;
160 } optable[] = {
161 {"nw", " new", DMGL_ANSI}, /* new (1.92, ansi) */
162 {"dl", " delete", DMGL_ANSI}, /* new (1.92, ansi) */
163 {"new", " new", 0}, /* old (1.91, and 1.x) */
164 {"delete", " delete", 0}, /* old (1.91, and 1.x) */
165 {"vn", " new []", DMGL_ANSI}, /* GNU, pending ansi */
166 {"vd", " delete []", DMGL_ANSI}, /* GNU, pending ansi */
167 {"as", "=", DMGL_ANSI}, /* ansi */
168 {"ne", "!=", DMGL_ANSI}, /* old, ansi */
169 {"eq", "==", DMGL_ANSI}, /* old, ansi */
170 {"ge", ">=", DMGL_ANSI}, /* old, ansi */
171 {"gt", ">", DMGL_ANSI}, /* old, ansi */
172 {"le", "<=", DMGL_ANSI}, /* old, ansi */
173 {"lt", "<", DMGL_ANSI}, /* old, ansi */
174 {"plus", "+", 0}, /* old */
175 {"pl", "+", DMGL_ANSI}, /* ansi */
176 {"apl", "+=", DMGL_ANSI}, /* ansi */
177 {"minus", "-", 0}, /* old */
178 {"mi", "-", DMGL_ANSI}, /* ansi */
179 {"ami", "-=", DMGL_ANSI}, /* ansi */
180 {"mult", "*", 0}, /* old */
181 {"ml", "*", DMGL_ANSI}, /* ansi */
182 {"amu", "*=", DMGL_ANSI}, /* ansi (ARM/Lucid) */
183 {"aml", "*=", DMGL_ANSI}, /* ansi (GNU/g++) */
184 {"convert", "+", 0}, /* old (unary +) */
185 {"negate", "-", 0}, /* old (unary -) */
186 {"trunc_mod", "%", 0}, /* old */
187 {"md", "%", DMGL_ANSI}, /* ansi */
188 {"amd", "%=", DMGL_ANSI}, /* ansi */
189 {"trunc_div", "/", 0}, /* old */
190 {"dv", "/", DMGL_ANSI}, /* ansi */
191 {"adv", "/=", DMGL_ANSI}, /* ansi */
192 {"truth_andif", "&&", 0}, /* old */
193 {"aa", "&&", DMGL_ANSI}, /* ansi */
194 {"truth_orif", "||", 0}, /* old */
195 {"oo", "||", DMGL_ANSI}, /* ansi */
196 {"truth_not", "!", 0}, /* old */
197 {"nt", "!", DMGL_ANSI}, /* ansi */
198 {"postincrement","++", 0}, /* old */
199 {"pp", "++", DMGL_ANSI}, /* ansi */
200 {"postdecrement","--", 0}, /* old */
201 {"mm", "--", DMGL_ANSI}, /* ansi */
202 {"bit_ior", "|", 0}, /* old */
203 {"or", "|", DMGL_ANSI}, /* ansi */
204 {"aor", "|=", DMGL_ANSI}, /* ansi */
205 {"bit_xor", "^", 0}, /* old */
206 {"er", "^", DMGL_ANSI}, /* ansi */
207 {"aer", "^=", DMGL_ANSI}, /* ansi */
208 {"bit_and", "&", 0}, /* old */
209 {"ad", "&", DMGL_ANSI}, /* ansi */
210 {"aad", "&=", DMGL_ANSI}, /* ansi */
211 {"bit_not", "~", 0}, /* old */
212 {"co", "~", DMGL_ANSI}, /* ansi */
213 {"call", "()", 0}, /* old */
214 {"cl", "()", DMGL_ANSI}, /* ansi */
215 {"alshift", "<<", 0}, /* old */
216 {"ls", "<<", DMGL_ANSI}, /* ansi */
217 {"als", "<<=", DMGL_ANSI}, /* ansi */
218 {"arshift", ">>", 0}, /* old */
219 {"rs", ">>", DMGL_ANSI}, /* ansi */
220 {"ars", ">>=", DMGL_ANSI}, /* ansi */
221 {"component", "->", 0}, /* old */
222 {"pt", "->", DMGL_ANSI}, /* ansi; Lucid C++ form */
223 {"rf", "->", DMGL_ANSI}, /* ansi; ARM/GNU form */
224 {"indirect", "*", 0}, /* old */
225 {"method_call", "->()", 0}, /* old */
226 {"addr", "&", 0}, /* old (unary &) */
227 {"array", "[]", 0}, /* old */
228 {"vc", "[]", DMGL_ANSI}, /* ansi */
229 {"compound", ", ", 0}, /* old */
230 {"cm", ", ", DMGL_ANSI}, /* ansi */
231 {"cond", "?:", 0}, /* old */
232 {"cn", "?:", DMGL_ANSI}, /* pseudo-ansi */
233 {"max", ">?", 0}, /* old */
234 {"mx", ">?", DMGL_ANSI}, /* pseudo-ansi */
235 {"min", "<?", 0}, /* old */
236 {"mn", "<?", DMGL_ANSI}, /* pseudo-ansi */
237 {"nop", "", 0}, /* old (for operator=) */
238 {"rm", "->*", DMGL_ANSI}, /* ansi */
239 {"sz", "sizeof ", DMGL_ANSI} /* pseudo-ansi */
240 };
241
242 /* These values are used to indicate the various type varieties.
243 They are all non-zero so that they can be used as `success'
244 values. */
245 typedef enum type_kind_t
246 {
247 tk_none,
248 tk_pointer,
249 tk_reference,
250 tk_rvalue_reference,
251 tk_integral,
252 tk_bool,
253 tk_char,
254 tk_real
255 } type_kind_t;
256
257 const struct demangler_engine libiberty_demanglers[] =
258 {
259 {
260 NO_DEMANGLING_STYLE_STRING,
261 no_demangling,
262 "Demangling disabled"
263 }
264 ,
265 {
266 AUTO_DEMANGLING_STYLE_STRING,
267 auto_demangling,
268 "Automatic selection based on executable"
269 }
270 ,
271 {
272 GNU_DEMANGLING_STYLE_STRING,
273 gnu_demangling,
274 "GNU (g++) style demangling"
275 }
276 ,
277 {
278 LUCID_DEMANGLING_STYLE_STRING,
279 lucid_demangling,
280 "Lucid (lcc) style demangling"
281 }
282 ,
283 {
284 ARM_DEMANGLING_STYLE_STRING,
285 arm_demangling,
286 "ARM style demangling"
287 }
288 ,
289 {
290 HP_DEMANGLING_STYLE_STRING,
291 hp_demangling,
292 "HP (aCC) style demangling"
293 }
294 ,
295 {
296 EDG_DEMANGLING_STYLE_STRING,
297 edg_demangling,
298 "EDG style demangling"
299 }
300 ,
301 {
302 GNU_V3_DEMANGLING_STYLE_STRING,
303 gnu_v3_demangling,
304 "GNU (g++) V3 ABI-style demangling"
305 }
306 ,
307 {
308 JAVA_DEMANGLING_STYLE_STRING,
309 java_demangling,
310 "Java style demangling"
311 }
312 ,
313 {
314 GNAT_DEMANGLING_STYLE_STRING,
315 gnat_demangling,
316 "GNAT style demangling"
317 }
318 ,
319 {
320 DLANG_DEMANGLING_STYLE_STRING,
321 dlang_demangling,
322 "DLANG style demangling"
323 }
324 ,
325 {
326 NULL, unknown_demangling, NULL
327 }
328 };
329
330 #define STRING_EMPTY(str) ((str) -> b == (str) -> p)
331 #define APPEND_BLANK(str) {if (!STRING_EMPTY(str)) \
332 string_append(str, " ");}
333 #define LEN_STRING(str) ( (STRING_EMPTY(str))?0:((str)->p - (str)->b))
334
335 /* The scope separator appropriate for the language being demangled. */
336
337 #define SCOPE_STRING(work) ((work->options & DMGL_JAVA) ? "." : "::")
338
339 #define ARM_VTABLE_STRING "__vtbl__" /* Lucid/ARM virtual table prefix */
340 #define ARM_VTABLE_STRLEN 8 /* strlen (ARM_VTABLE_STRING) */
341
342 /* Prototypes for local functions */
343
344 static void delete_work_stuff (struct work_stuff *);
345
346 static void delete_non_B_K_work_stuff (struct work_stuff *);
347
348 static char *mop_up (struct work_stuff *, string *, int);
349
350 static void squangle_mop_up (struct work_stuff *);
351
352 static void work_stuff_copy_to_from (struct work_stuff *, struct work_stuff *);
353
354 #if 0
355 static int
356 demangle_method_args (struct work_stuff *, const char **, string *);
357 #endif
358
359 static char *
360 internal_cplus_demangle (struct work_stuff *, const char *);
361
362 static int
363 demangle_template_template_parm (struct work_stuff *work,
364 const char **, string *);
365
366 static int
367 demangle_template (struct work_stuff *work, const char **, string *,
368 string *, int, int);
369
370 static int
371 arm_pt (struct work_stuff *, const char *, int, const char **,
372 const char **);
373
374 static int
375 demangle_class_name (struct work_stuff *, const char **, string *);
376
377 static int
378 demangle_qualified (struct work_stuff *, const char **, string *,
379 int, int);
380
381 static int demangle_class (struct work_stuff *, const char **, string *);
382
383 static int demangle_fund_type (struct work_stuff *, const char **, string *);
384
385 static int demangle_signature (struct work_stuff *, const char **, string *);
386
387 static int demangle_prefix (struct work_stuff *, const char **, string *);
388
389 static int gnu_special (struct work_stuff *, const char **, string *);
390
391 static int arm_special (const char **, string *);
392
393 static void string_need (string *, int);
394
395 static void string_delete (string *);
396
397 static void
398 string_init (string *);
399
400 static void string_clear (string *);
401
402 #if 0
403 static int string_empty (string *);
404 #endif
405
406 static void string_append (string *, const char *);
407
408 static void string_appends (string *, string *);
409
410 static void string_appendn (string *, const char *, int);
411
412 static void string_prepend (string *, const char *);
413
414 static void string_prependn (string *, const char *, int);
415
416 static void string_append_template_idx (string *, int);
417
418 static int get_count (const char **, int *);
419
420 static int consume_count (const char **);
421
422 static int consume_count_with_underscores (const char**);
423
424 static int demangle_args (struct work_stuff *, const char **, string *);
425
426 static int demangle_nested_args (struct work_stuff*, const char**, string*);
427
428 static int do_type (struct work_stuff *, const char **, string *);
429
430 static int do_arg (struct work_stuff *, const char **, string *);
431
432 static int
433 demangle_function_name (struct work_stuff *, const char **, string *,
434 const char *);
435
436 static int
437 iterate_demangle_function (struct work_stuff *,
438 const char **, string *, const char *);
439
440 static void remember_type (struct work_stuff *, const char *, int);
441
442 static void push_processed_type (struct work_stuff *, int);
443
444 static void pop_processed_type (struct work_stuff *);
445
446 static void remember_Btype (struct work_stuff *, const char *, int, int);
447
448 static int register_Btype (struct work_stuff *);
449
450 static void remember_Ktype (struct work_stuff *, const char *, int);
451
452 static void forget_types (struct work_stuff *);
453
454 static void forget_B_and_K_types (struct work_stuff *);
455
456 static void string_prepends (string *, string *);
457
458 static int
459 demangle_template_value_parm (struct work_stuff*, const char**,
460 string*, type_kind_t);
461
462 static int
463 do_hpacc_template_const_value (struct work_stuff *, const char **, string *);
464
465 static int
466 do_hpacc_template_literal (struct work_stuff *, const char **, string *);
467
468 static int snarf_numeric_literal (const char **, string *);
469
470 /* There is a TYPE_QUAL value for each type qualifier. They can be
471 combined by bitwise-or to form the complete set of qualifiers for a
472 type. */
473
474 #define TYPE_UNQUALIFIED 0x0
475 #define TYPE_QUAL_CONST 0x1
476 #define TYPE_QUAL_VOLATILE 0x2
477 #define TYPE_QUAL_RESTRICT 0x4
478
479 static int code_for_qualifier (int);
480
481 static const char* qualifier_string (int);
482
483 static const char* demangle_qualifier (int);
484
485 static int demangle_expression (struct work_stuff *, const char **, string *,
486 type_kind_t);
487
488 static int
489 demangle_integral_value (struct work_stuff *, const char **, string *);
490
491 static int
492 demangle_real_value (struct work_stuff *, const char **, string *);
493
494 static void
495 demangle_arm_hp_template (struct work_stuff *, const char **, int, string *);
496
497 static void
498 recursively_demangle (struct work_stuff *, const char **, string *, int);
499
500 /* Translate count to integer, consuming tokens in the process.
501 Conversion terminates on the first non-digit character.
502
503 Trying to consume something that isn't a count results in no
504 consumption of input and a return of -1.
505
506 Overflow consumes the rest of the digits, and returns -1. */
507
508 static int
509 consume_count (const char **type)
510 {
511 int count = 0;
512
513 if (! ISDIGIT ((unsigned char)**type))
514 return -1;
515
516 while (ISDIGIT ((unsigned char)**type))
517 {
518 count *= 10;
519
520 /* Check for overflow.
521 We assume that count is represented using two's-complement;
522 no power of two is divisible by ten, so if an overflow occurs
523 when multiplying by ten, the result will not be a multiple of
524 ten. */
525 if ((count % 10) != 0)
526 {
527 while (ISDIGIT ((unsigned char) **type))
528 (*type)++;
529 return -1;
530 }
531
532 count += **type - '0';
533 (*type)++;
534 }
535
536 if (count < 0)
537 count = -1;
538
539 return (count);
540 }
541
542
543 /* Like consume_count, but for counts that are preceded and followed
544 by '_' if they are greater than 10. Also, -1 is returned for
545 failure, since 0 can be a valid value. */
546
547 static int
548 consume_count_with_underscores (const char **mangled)
549 {
550 int idx;
551
552 if (**mangled == '_')
553 {
554 (*mangled)++;
555 if (!ISDIGIT ((unsigned char)**mangled))
556 return -1;
557
558 idx = consume_count (mangled);
559 if (**mangled != '_')
560 /* The trailing underscore was missing. */
561 return -1;
562
563 (*mangled)++;
564 }
565 else
566 {
567 if (**mangled < '0' || **mangled > '9')
568 return -1;
569
570 idx = **mangled - '0';
571 (*mangled)++;
572 }
573
574 return idx;
575 }
576
577 /* C is the code for a type-qualifier. Return the TYPE_QUAL
578 corresponding to this qualifier. */
579
580 static int
581 code_for_qualifier (int c)
582 {
583 switch (c)
584 {
585 case 'C':
586 return TYPE_QUAL_CONST;
587
588 case 'V':
589 return TYPE_QUAL_VOLATILE;
590
591 case 'u':
592 return TYPE_QUAL_RESTRICT;
593
594 default:
595 break;
596 }
597
598 /* C was an invalid qualifier. */
599 abort ();
600 }
601
602 /* Return the string corresponding to the qualifiers given by
603 TYPE_QUALS. */
604
605 static const char*
606 qualifier_string (int type_quals)
607 {
608 switch (type_quals)
609 {
610 case TYPE_UNQUALIFIED:
611 return "";
612
613 case TYPE_QUAL_CONST:
614 return "const";
615
616 case TYPE_QUAL_VOLATILE:
617 return "volatile";
618
619 case TYPE_QUAL_RESTRICT:
620 return "__restrict";
621
622 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE:
623 return "const volatile";
624
625 case TYPE_QUAL_CONST | TYPE_QUAL_RESTRICT:
626 return "const __restrict";
627
628 case TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
629 return "volatile __restrict";
630
631 case TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE | TYPE_QUAL_RESTRICT:
632 return "const volatile __restrict";
633
634 default:
635 break;
636 }
637
638 /* TYPE_QUALS was an invalid qualifier set. */
639 abort ();
640 }
641
642 /* C is the code for a type-qualifier. Return the string
643 corresponding to this qualifier. This function should only be
644 called with a valid qualifier code. */
645
646 static const char*
647 demangle_qualifier (int c)
648 {
649 return qualifier_string (code_for_qualifier (c));
650 }
651
652 int
653 cplus_demangle_opname (const char *opname, char *result, int options)
654 {
655 int len, len1, ret;
656 string type;
657 struct work_stuff work[1];
658 const char *tem;
659
660 len = strlen(opname);
661 result[0] = '\0';
662 ret = 0;
663 memset ((char *) work, 0, sizeof (work));
664 work->options = options;
665
666 if (opname[0] == '_' && opname[1] == '_'
667 && opname[2] == 'o' && opname[3] == 'p')
668 {
669 /* ANSI. */
670 /* type conversion operator. */
671 tem = opname + 4;
672 if (do_type (work, &tem, &type))
673 {
674 strcat (result, "operator ");
675 strncat (result, type.b, type.p - type.b);
676 string_delete (&type);
677 ret = 1;
678 }
679 }
680 else if (opname[0] == '_' && opname[1] == '_'
681 && ISLOWER((unsigned char)opname[2])
682 && ISLOWER((unsigned char)opname[3]))
683 {
684 if (opname[4] == '\0')
685 {
686 /* Operator. */
687 size_t i;
688 for (i = 0; i < ARRAY_SIZE (optable); i++)
689 {
690 if (strlen (optable[i].in) == 2
691 && memcmp (optable[i].in, opname + 2, 2) == 0)
692 {
693 strcat (result, "operator");
694 strcat (result, optable[i].out);
695 ret = 1;
696 break;
697 }
698 }
699 }
700 else
701 {
702 if (opname[2] == 'a' && opname[5] == '\0')
703 {
704 /* Assignment. */
705 size_t i;
706 for (i = 0; i < ARRAY_SIZE (optable); i++)
707 {
708 if (strlen (optable[i].in) == 3
709 && memcmp (optable[i].in, opname + 2, 3) == 0)
710 {
711 strcat (result, "operator");
712 strcat (result, optable[i].out);
713 ret = 1;
714 break;
715 }
716 }
717 }
718 }
719 }
720 else if (len >= 3
721 && opname[0] == 'o'
722 && opname[1] == 'p'
723 && strchr (cplus_markers, opname[2]) != NULL)
724 {
725 /* see if it's an assignment expression */
726 if (len >= 10 /* op$assign_ */
727 && memcmp (opname + 3, "assign_", 7) == 0)
728 {
729 size_t i;
730 for (i = 0; i < ARRAY_SIZE (optable); i++)
731 {
732 len1 = len - 10;
733 if ((int) strlen (optable[i].in) == len1
734 && memcmp (optable[i].in, opname + 10, len1) == 0)
735 {
736 strcat (result, "operator");
737 strcat (result, optable[i].out);
738 strcat (result, "=");
739 ret = 1;
740 break;
741 }
742 }
743 }
744 else
745 {
746 size_t i;
747 for (i = 0; i < ARRAY_SIZE (optable); i++)
748 {
749 len1 = len - 3;
750 if ((int) strlen (optable[i].in) == len1
751 && memcmp (optable[i].in, opname + 3, len1) == 0)
752 {
753 strcat (result, "operator");
754 strcat (result, optable[i].out);
755 ret = 1;
756 break;
757 }
758 }
759 }
760 }
761 else if (len >= 5 && memcmp (opname, "type", 4) == 0
762 && strchr (cplus_markers, opname[4]) != NULL)
763 {
764 /* type conversion operator */
765 tem = opname + 5;
766 if (do_type (work, &tem, &type))
767 {
768 strcat (result, "operator ");
769 strncat (result, type.b, type.p - type.b);
770 string_delete (&type);
771 ret = 1;
772 }
773 }
774 squangle_mop_up (work);
775 return ret;
776
777 }
778
779 /* Takes operator name as e.g. "++" and returns mangled
780 operator name (e.g. "postincrement_expr"), or NULL if not found.
781
782 If OPTIONS & DMGL_ANSI == 1, return the ANSI name;
783 if OPTIONS & DMGL_ANSI == 0, return the old GNU name. */
784
785 const char *
786 cplus_mangle_opname (const char *opname, int options)
787 {
788 size_t i;
789 int len;
790
791 len = strlen (opname);
792 for (i = 0; i < ARRAY_SIZE (optable); i++)
793 {
794 if ((int) strlen (optable[i].out) == len
795 && (options & DMGL_ANSI) == (optable[i].flags & DMGL_ANSI)
796 && memcmp (optable[i].out, opname, len) == 0)
797 return optable[i].in;
798 }
799 return (0);
800 }
801
802 /* Add a routine to set the demangling style to be sure it is valid and
803 allow for any demangler initialization that maybe necessary. */
804
805 enum demangling_styles
806 cplus_demangle_set_style (enum demangling_styles style)
807 {
808 const struct demangler_engine *demangler = libiberty_demanglers;
809
810 for (; demangler->demangling_style != unknown_demangling; ++demangler)
811 if (style == demangler->demangling_style)
812 {
813 current_demangling_style = style;
814 return current_demangling_style;
815 }
816
817 return unknown_demangling;
818 }
819
820 /* Do string name to style translation */
821
822 enum demangling_styles
823 cplus_demangle_name_to_style (const char *name)
824 {
825 const struct demangler_engine *demangler = libiberty_demanglers;
826
827 for (; demangler->demangling_style != unknown_demangling; ++demangler)
828 if (strcmp (name, demangler->demangling_style_name) == 0)
829 return demangler->demangling_style;
830
831 return unknown_demangling;
832 }
833
834 /* char *cplus_demangle (const char *mangled, int options)
835
836 If MANGLED is a mangled function name produced by GNU C++, then
837 a pointer to a @code{malloc}ed string giving a C++ representation
838 of the name will be returned; otherwise NULL will be returned.
839 It is the caller's responsibility to free the string which
840 is returned.
841
842 The OPTIONS arg may contain one or more of the following bits:
843
844 DMGL_ANSI ANSI qualifiers such as `const' and `void' are
845 included.
846 DMGL_PARAMS Function parameters are included.
847
848 For example,
849
850 cplus_demangle ("foo__1Ai", DMGL_PARAMS) => "A::foo(int)"
851 cplus_demangle ("foo__1Ai", DMGL_PARAMS | DMGL_ANSI) => "A::foo(int)"
852 cplus_demangle ("foo__1Ai", 0) => "A::foo"
853
854 cplus_demangle ("foo__1Afe", DMGL_PARAMS) => "A::foo(float,...)"
855 cplus_demangle ("foo__1Afe", DMGL_PARAMS | DMGL_ANSI)=> "A::foo(float,...)"
856 cplus_demangle ("foo__1Afe", 0) => "A::foo"
857
858 Note that any leading underscores, or other such characters prepended by
859 the compilation system, are presumed to have already been stripped from
860 MANGLED. */
861
862 char *
863 cplus_demangle (const char *mangled, int options)
864 {
865 char *ret;
866 struct work_stuff work[1];
867
868 if (current_demangling_style == no_demangling)
869 return xstrdup (mangled);
870
871 memset ((char *) work, 0, sizeof (work));
872 work->options = options;
873 if ((work->options & DMGL_STYLE_MASK) == 0)
874 work->options |= (int) current_demangling_style & DMGL_STYLE_MASK;
875
876 /* The V3 ABI demangling is implemented elsewhere. */
877 if (GNU_V3_DEMANGLING || AUTO_DEMANGLING)
878 {
879 ret = cplus_demangle_v3 (mangled, work->options);
880 if (ret || GNU_V3_DEMANGLING)
881 return ret;
882 }
883
884 if (JAVA_DEMANGLING)
885 {
886 ret = java_demangle_v3 (mangled);
887 if (ret)
888 return ret;
889 }
890
891 if (GNAT_DEMANGLING)
892 return ada_demangle (mangled, options);
893
894 if (DLANG_DEMANGLING)
895 {
896 ret = dlang_demangle (mangled, options);
897 if (ret)
898 return ret;
899 }
900
901 ret = internal_cplus_demangle (work, mangled);
902 squangle_mop_up (work);
903 return (ret);
904 }
905
906 /* Demangle ada names. The encoding is documented in gcc/ada/exp_dbug.ads. */
907
908 char *
909 ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED)
910 {
911 int len0;
912 const char* p;
913 char *d;
914 char *demangled = NULL;
915
916 /* Discard leading _ada_, which is used for library level subprograms. */
917 if (strncmp (mangled, "_ada_", 5) == 0)
918 mangled += 5;
919
920 /* All ada unit names are lower-case. */
921 if (!ISLOWER (mangled[0]))
922 goto unknown;
923
924 /* Most of the demangling will trivially remove chars. Operator names
925 may add one char but because they are always preceeded by '__' which is
926 replaced by '.', they eventually never expand the size.
927 A few special names such as '___elabs' add a few chars (at most 7), but
928 they occur only once. */
929 len0 = strlen (mangled) + 7 + 1;
930 demangled = XNEWVEC (char, len0);
931
932 d = demangled;
933 p = mangled;
934 while (1)
935 {
936 /* An entity names is expected. */
937 if (ISLOWER (*p))
938 {
939 /* An identifier, which is always lower case. */
940 do
941 *d++ = *p++;
942 while (ISLOWER(*p) || ISDIGIT (*p)
943 || (p[0] == '_' && (ISLOWER (p[1]) || ISDIGIT (p[1]))));
944 }
945 else if (p[0] == 'O')
946 {
947 /* An operator name. */
948 static const char * const operators[][2] =
949 {{"Oabs", "abs"}, {"Oand", "and"}, {"Omod", "mod"},
950 {"Onot", "not"}, {"Oor", "or"}, {"Orem", "rem"},
951 {"Oxor", "xor"}, {"Oeq", "="}, {"One", "/="},
952 {"Olt", "<"}, {"Ole", "<="}, {"Ogt", ">"},
953 {"Oge", ">="}, {"Oadd", "+"}, {"Osubtract", "-"},
954 {"Oconcat", "&"}, {"Omultiply", "*"}, {"Odivide", "/"},
955 {"Oexpon", "**"}, {NULL, NULL}};
956 int k;
957
958 for (k = 0; operators[k][0] != NULL; k++)
959 {
960 size_t slen = strlen (operators[k][0]);
961 if (strncmp (p, operators[k][0], slen) == 0)
962 {
963 p += slen;
964 slen = strlen (operators[k][1]);
965 *d++ = '"';
966 memcpy (d, operators[k][1], slen);
967 d += slen;
968 *d++ = '"';
969 break;
970 }
971 }
972 /* Operator not found. */
973 if (operators[k][0] == NULL)
974 goto unknown;
975 }
976 else
977 {
978 /* Not a GNAT encoding. */
979 goto unknown;
980 }
981
982 /* The name can be directly followed by some uppercase letters. */
983 if (p[0] == 'T' && p[1] == 'K')
984 {
985 /* Task stuff. */
986 if (p[2] == 'B' && p[3] == 0)
987 {
988 /* Subprogram for task body. */
989 break;
990 }
991 else if (p[2] == '_' && p[3] == '_')
992 {
993 /* Inner declarations in a task. */
994 p += 4;
995 *d++ = '.';
996 continue;
997 }
998 else
999 goto unknown;
1000 }
1001 if (p[0] == 'E' && p[1] == 0)
1002 {
1003 /* Exception name. */
1004 goto unknown;
1005 }
1006 if ((p[0] == 'P' || p[0] == 'N') && p[1] == 0)
1007 {
1008 /* Protected type subprogram. */
1009 break;
1010 }
1011 if ((*p == 'N' || *p == 'S') && p[1] == 0)
1012 {
1013 /* Enumerated type name table. */
1014 goto unknown;
1015 }
1016 if (p[0] == 'X')
1017 {
1018 /* Body nested. */
1019 p++;
1020 while (p[0] == 'n' || p[0] == 'b')
1021 p++;
1022 }
1023 if (p[0] == 'S' && p[1] != 0 && (p[2] == '_' || p[2] == 0))
1024 {
1025 /* Stream operations. */
1026 const char *name;
1027 switch (p[1])
1028 {
1029 case 'R':
1030 name = "'Read";
1031 break;
1032 case 'W':
1033 name = "'Write";
1034 break;
1035 case 'I':
1036 name = "'Input";
1037 break;
1038 case 'O':
1039 name = "'Output";
1040 break;
1041 default:
1042 goto unknown;
1043 }
1044 p += 2;
1045 strcpy (d, name);
1046 d += strlen (name);
1047 }
1048 else if (p[0] == 'D')
1049 {
1050 /* Controlled type operation. */
1051 const char *name;
1052 switch (p[1])
1053 {
1054 case 'F':
1055 name = ".Finalize";
1056 break;
1057 case 'A':
1058 name = ".Adjust";
1059 break;
1060 default:
1061 goto unknown;
1062 }
1063 strcpy (d, name);
1064 d += strlen (name);
1065 break;
1066 }
1067
1068 if (p[0] == '_')
1069 {
1070 /* Separator. */
1071 if (p[1] == '_')
1072 {
1073 /* Standard separator. Handled first. */
1074 p += 2;
1075
1076 if (ISDIGIT (*p))
1077 {
1078 /* Overloading number. */
1079 do
1080 p++;
1081 while (ISDIGIT (*p) || (p[0] == '_' && ISDIGIT (p[1])));
1082 if (*p == 'X')
1083 {
1084 p++;
1085 while (p[0] == 'n' || p[0] == 'b')
1086 p++;
1087 }
1088 }
1089 else if (p[0] == '_' && p[1] != '_')
1090 {
1091 /* Special names. */
1092 static const char * const special[][2] = {
1093 { "_elabb", "'Elab_Body" },
1094 { "_elabs", "'Elab_Spec" },
1095 { "_size", "'Size" },
1096 { "_alignment", "'Alignment" },
1097 { "_assign", ".\":=\"" },
1098 { NULL, NULL }
1099 };
1100 int k;
1101
1102 for (k = 0; special[k][0] != NULL; k++)
1103 {
1104 size_t slen = strlen (special[k][0]);
1105 if (strncmp (p, special[k][0], slen) == 0)
1106 {
1107 p += slen;
1108 slen = strlen (special[k][1]);
1109 memcpy (d, special[k][1], slen);
1110 d += slen;
1111 break;
1112 }
1113 }
1114 if (special[k][0] != NULL)
1115 break;
1116 else
1117 goto unknown;
1118 }
1119 else
1120 {
1121 *d++ = '.';
1122 continue;
1123 }
1124 }
1125 else if (p[1] == 'B' || p[1] == 'E')
1126 {
1127 /* Entry Body or barrier Evaluation. */
1128 p += 2;
1129 while (ISDIGIT (*p))
1130 p++;
1131 if (p[0] == 's' && p[1] == 0)
1132 break;
1133 else
1134 goto unknown;
1135 }
1136 else
1137 goto unknown;
1138 }
1139
1140 if (p[0] == '.' && ISDIGIT (p[1]))
1141 {
1142 /* Nested subprogram. */
1143 p += 2;
1144 while (ISDIGIT (*p))
1145 p++;
1146 }
1147 if (*p == 0)
1148 {
1149 /* End of mangled name. */
1150 break;
1151 }
1152 else
1153 goto unknown;
1154 }
1155 *d = 0;
1156 return demangled;
1157
1158 unknown:
1159 XDELETEVEC (demangled);
1160 len0 = strlen (mangled);
1161 demangled = XNEWVEC (char, len0 + 3);
1162
1163 if (mangled[0] == '<')
1164 strcpy (demangled, mangled);
1165 else
1166 sprintf (demangled, "<%s>", mangled);
1167
1168 return demangled;
1169 }
1170
1171 /* This function performs most of what cplus_demangle use to do, but
1172 to be able to demangle a name with a B, K or n code, we need to
1173 have a longer term memory of what types have been seen. The original
1174 now initializes and cleans up the squangle code info, while internal
1175 calls go directly to this routine to avoid resetting that info. */
1176
1177 static char *
1178 internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1179 {
1180
1181 string decl;
1182 int success = 0;
1183 char *demangled = NULL;
1184 int s1, s2, s3, s4;
1185 s1 = work->constructor;
1186 s2 = work->destructor;
1187 s3 = work->static_type;
1188 s4 = work->type_quals;
1189 work->constructor = work->destructor = 0;
1190 work->type_quals = TYPE_UNQUALIFIED;
1191 work->dllimported = 0;
1192
1193 if ((mangled != NULL) && (*mangled != '\0'))
1194 {
1195 string_init (&decl);
1196
1197 /* First check to see if gnu style demangling is active and if the
1198 string to be demangled contains a CPLUS_MARKER. If so, attempt to
1199 recognize one of the gnu special forms rather than looking for a
1200 standard prefix. In particular, don't worry about whether there
1201 is a "__" string in the mangled string. Consider "_$_5__foo" for
1202 example. */
1203
1204 if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1205 {
1206 success = gnu_special (work, &mangled, &decl);
1207 if (!success)
1208 {
1209 delete_work_stuff (work);
1210 string_delete (&decl);
1211 }
1212 }
1213 if (!success)
1214 {
1215 success = demangle_prefix (work, &mangled, &decl);
1216 }
1217 if (success && (*mangled != '\0'))
1218 {
1219 success = demangle_signature (work, &mangled, &decl);
1220 }
1221 if (work->constructor == 2)
1222 {
1223 string_prepend (&decl, "global constructors keyed to ");
1224 work->constructor = 0;
1225 }
1226 else if (work->destructor == 2)
1227 {
1228 string_prepend (&decl, "global destructors keyed to ");
1229 work->destructor = 0;
1230 }
1231 else if (work->dllimported == 1)
1232 {
1233 string_prepend (&decl, "import stub for ");
1234 work->dllimported = 0;
1235 }
1236 demangled = mop_up (work, &decl, success);
1237 }
1238 work->constructor = s1;
1239 work->destructor = s2;
1240 work->static_type = s3;
1241 work->type_quals = s4;
1242 return demangled;
1243 }
1244
1245
1246 /* Clear out and squangling related storage */
1247 static void
1248 squangle_mop_up (struct work_stuff *work)
1249 {
1250 /* clean up the B and K type mangling types. */
1251 forget_B_and_K_types (work);
1252 if (work -> btypevec != NULL)
1253 {
1254 free ((char *) work -> btypevec);
1255 work->btypevec = NULL;
1256 work->bsize = 0;
1257 }
1258 if (work -> ktypevec != NULL)
1259 {
1260 free ((char *) work -> ktypevec);
1261 work->ktypevec = NULL;
1262 work->ksize = 0;
1263 }
1264 }
1265
1266
1267 /* Copy the work state and storage. */
1268
1269 static void
1270 work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
1271 {
1272 int i;
1273
1274 delete_work_stuff (to);
1275
1276 /* Shallow-copy scalars. */
1277 memcpy (to, from, sizeof (*to));
1278
1279 /* Deep-copy dynamic storage. */
1280 if (from->typevec_size)
1281 to->typevec = XNEWVEC (char *, from->typevec_size);
1282
1283 for (i = 0; i < from->ntypes; i++)
1284 {
1285 int len = strlen (from->typevec[i]) + 1;
1286
1287 to->typevec[i] = XNEWVEC (char, len);
1288 memcpy (to->typevec[i], from->typevec[i], len);
1289 }
1290
1291 if (from->ksize)
1292 to->ktypevec = XNEWVEC (char *, from->ksize);
1293
1294 for (i = 0; i < from->numk; i++)
1295 {
1296 int len = strlen (from->ktypevec[i]) + 1;
1297
1298 to->ktypevec[i] = XNEWVEC (char, len);
1299 memcpy (to->ktypevec[i], from->ktypevec[i], len);
1300 }
1301
1302 if (from->bsize)
1303 to->btypevec = XNEWVEC (char *, from->bsize);
1304
1305 for (i = 0; i < from->numb; i++)
1306 {
1307 int len = strlen (from->btypevec[i]) + 1;
1308
1309 to->btypevec[i] = XNEWVEC (char , len);
1310 memcpy (to->btypevec[i], from->btypevec[i], len);
1311 }
1312
1313 if (from->proctypevec)
1314 to->proctypevec =
1315 XDUPVEC (int, from->proctypevec, from->proctypevec_size);
1316
1317 if (from->ntmpl_args)
1318 to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
1319
1320 for (i = 0; i < from->ntmpl_args; i++)
1321 {
1322 int len = strlen (from->tmpl_argvec[i]) + 1;
1323
1324 to->tmpl_argvec[i] = XNEWVEC (char, len);
1325 memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1326 }
1327
1328 if (from->previous_argument)
1329 {
1330 to->previous_argument = XNEW (string);
1331 string_init (to->previous_argument);
1332 string_appends (to->previous_argument, from->previous_argument);
1333 }
1334 }
1335
1336
1337 /* Delete dynamic stuff in work_stuff that is not to be re-used. */
1338
1339 static void
1340 delete_non_B_K_work_stuff (struct work_stuff *work)
1341 {
1342 /* Discard the remembered types, if any. */
1343
1344 forget_types (work);
1345 if (work->typevec != NULL)
1346 {
1347 free ((char *) work->typevec);
1348 work->typevec = NULL;
1349 work->typevec_size = 0;
1350 }
1351 if (work->proctypevec != NULL)
1352 {
1353 free (work->proctypevec);
1354 work->proctypevec = NULL;
1355 work->proctypevec_size = 0;
1356 }
1357 if (work->tmpl_argvec)
1358 {
1359 int i;
1360
1361 for (i = 0; i < work->ntmpl_args; i++)
1362 free ((char*) work->tmpl_argvec[i]);
1363
1364 free ((char*) work->tmpl_argvec);
1365 work->tmpl_argvec = NULL;
1366 }
1367 if (work->previous_argument)
1368 {
1369 string_delete (work->previous_argument);
1370 free ((char*) work->previous_argument);
1371 work->previous_argument = NULL;
1372 }
1373 }
1374
1375
1376 /* Delete all dynamic storage in work_stuff. */
1377 static void
1378 delete_work_stuff (struct work_stuff *work)
1379 {
1380 delete_non_B_K_work_stuff (work);
1381 squangle_mop_up (work);
1382 }
1383
1384
1385 /* Clear out any mangled storage */
1386
1387 static char *
1388 mop_up (struct work_stuff *work, string *declp, int success)
1389 {
1390 char *demangled = NULL;
1391
1392 delete_non_B_K_work_stuff (work);
1393
1394 /* If demangling was successful, ensure that the demangled string is null
1395 terminated and return it. Otherwise, free the demangling decl. */
1396
1397 if (!success)
1398 {
1399 string_delete (declp);
1400 }
1401 else
1402 {
1403 string_appendn (declp, "", 1);
1404 demangled = declp->b;
1405 }
1406 return (demangled);
1407 }
1408
1409 /*
1410
1411 LOCAL FUNCTION
1412
1413 demangle_signature -- demangle the signature part of a mangled name
1414
1415 SYNOPSIS
1416
1417 static int
1418 demangle_signature (struct work_stuff *work, const char **mangled,
1419 string *declp);
1420
1421 DESCRIPTION
1422
1423 Consume and demangle the signature portion of the mangled name.
1424
1425 DECLP is the string where demangled output is being built. At
1426 entry it contains the demangled root name from the mangled name
1427 prefix. I.E. either a demangled operator name or the root function
1428 name. In some special cases, it may contain nothing.
1429
1430 *MANGLED points to the current unconsumed location in the mangled
1431 name. As tokens are consumed and demangling is performed, the
1432 pointer is updated to continuously point at the next token to
1433 be consumed.
1434
1435 Demangling GNU style mangled names is nasty because there is no
1436 explicit token that marks the start of the outermost function
1437 argument list. */
1438
1439 static int
1440 demangle_signature (struct work_stuff *work,
1441 const char **mangled, string *declp)
1442 {
1443 int success = 1;
1444 int func_done = 0;
1445 int expect_func = 0;
1446 int expect_return_type = 0;
1447 const char *oldmangled = NULL;
1448 string trawname;
1449 string tname;
1450
1451 while (success && (**mangled != '\0'))
1452 {
1453 switch (**mangled)
1454 {
1455 case 'Q':
1456 oldmangled = *mangled;
1457 success = demangle_qualified (work, mangled, declp, 1, 0);
1458 if (success)
1459 remember_type (work, oldmangled, *mangled - oldmangled);
1460 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1461 expect_func = 1;
1462 oldmangled = NULL;
1463 break;
1464
1465 case 'K':
1466 oldmangled = *mangled;
1467 success = demangle_qualified (work, mangled, declp, 1, 0);
1468 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1469 {
1470 expect_func = 1;
1471 }
1472 oldmangled = NULL;
1473 break;
1474
1475 case 'S':
1476 /* Static member function */
1477 if (oldmangled == NULL)
1478 {
1479 oldmangled = *mangled;
1480 }
1481 (*mangled)++;
1482 work -> static_type = 1;
1483 break;
1484
1485 case 'C':
1486 case 'V':
1487 case 'u':
1488 work->type_quals |= code_for_qualifier (**mangled);
1489
1490 /* a qualified member function */
1491 if (oldmangled == NULL)
1492 oldmangled = *mangled;
1493 (*mangled)++;
1494 break;
1495
1496 case 'L':
1497 /* Local class name follows after "Lnnn_" */
1498 if (HP_DEMANGLING)
1499 {
1500 while (**mangled && (**mangled != '_'))
1501 (*mangled)++;
1502 if (!**mangled)
1503 success = 0;
1504 else
1505 (*mangled)++;
1506 }
1507 else
1508 success = 0;
1509 break;
1510
1511 case '0': case '1': case '2': case '3': case '4':
1512 case '5': case '6': case '7': case '8': case '9':
1513 if (oldmangled == NULL)
1514 {
1515 oldmangled = *mangled;
1516 }
1517 work->temp_start = -1; /* uppermost call to demangle_class */
1518 success = demangle_class (work, mangled, declp);
1519 if (success)
1520 {
1521 remember_type (work, oldmangled, *mangled - oldmangled);
1522 }
1523 if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1524 {
1525 /* EDG and others will have the "F", so we let the loop cycle
1526 if we are looking at one. */
1527 if (**mangled != 'F')
1528 expect_func = 1;
1529 }
1530 oldmangled = NULL;
1531 break;
1532
1533 case 'B':
1534 {
1535 string s;
1536 success = do_type (work, mangled, &s);
1537 if (success)
1538 {
1539 string_append (&s, SCOPE_STRING (work));
1540 string_prepends (declp, &s);
1541 string_delete (&s);
1542 }
1543 oldmangled = NULL;
1544 expect_func = 1;
1545 }
1546 break;
1547
1548 case 'F':
1549 /* Function */
1550 /* ARM/HP style demangling includes a specific 'F' character after
1551 the class name. For GNU style, it is just implied. So we can
1552 safely just consume any 'F' at this point and be compatible
1553 with either style. */
1554
1555 oldmangled = NULL;
1556 func_done = 1;
1557 (*mangled)++;
1558
1559 /* For lucid/ARM/HP style we have to forget any types we might
1560 have remembered up to this point, since they were not argument
1561 types. GNU style considers all types seen as available for
1562 back references. See comment in demangle_args() */
1563
1564 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1565 {
1566 forget_types (work);
1567 }
1568 success = demangle_args (work, mangled, declp);
1569 /* After picking off the function args, we expect to either
1570 find the function return type (preceded by an '_') or the
1571 end of the string. */
1572 if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1573 {
1574 ++(*mangled);
1575 /* At this level, we do not care about the return type. */
1576 success = do_type (work, mangled, &tname);
1577 string_delete (&tname);
1578 }
1579
1580 break;
1581
1582 case 't':
1583 /* G++ Template */
1584 string_init(&trawname);
1585 string_init(&tname);
1586 if (oldmangled == NULL)
1587 {
1588 oldmangled = *mangled;
1589 }
1590 success = demangle_template (work, mangled, &tname,
1591 &trawname, 1, 1);
1592 if (success)
1593 {
1594 remember_type (work, oldmangled, *mangled - oldmangled);
1595 }
1596 string_append (&tname, SCOPE_STRING (work));
1597
1598 string_prepends(declp, &tname);
1599 if (work -> destructor & 1)
1600 {
1601 string_prepend (&trawname, "~");
1602 string_appends (declp, &trawname);
1603 work->destructor -= 1;
1604 }
1605 if ((work->constructor & 1) || (work->destructor & 1))
1606 {
1607 string_appends (declp, &trawname);
1608 work->constructor -= 1;
1609 }
1610 string_delete(&trawname);
1611 string_delete(&tname);
1612 oldmangled = NULL;
1613 expect_func = 1;
1614 break;
1615
1616 case '_':
1617 if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1618 {
1619 /* Read the return type. */
1620 string return_type;
1621
1622 (*mangled)++;
1623 success = do_type (work, mangled, &return_type);
1624 APPEND_BLANK (&return_type);
1625
1626 string_prepends (declp, &return_type);
1627 string_delete (&return_type);
1628 break;
1629 }
1630 else
1631 /* At the outermost level, we cannot have a return type specified,
1632 so if we run into another '_' at this point we are dealing with
1633 a mangled name that is either bogus, or has been mangled by
1634 some algorithm we don't know how to deal with. So just
1635 reject the entire demangling. */
1636 /* However, "_nnn" is an expected suffix for alternate entry point
1637 numbered nnn for a function, with HP aCC, so skip over that
1638 without reporting failure. pai/1997-09-04 */
1639 if (HP_DEMANGLING)
1640 {
1641 (*mangled)++;
1642 while (**mangled && ISDIGIT ((unsigned char)**mangled))
1643 (*mangled)++;
1644 }
1645 else
1646 success = 0;
1647 break;
1648
1649 case 'H':
1650 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1651 {
1652 /* A G++ template function. Read the template arguments. */
1653 success = demangle_template (work, mangled, declp, 0, 0,
1654 0);
1655 if (!(work->constructor & 1))
1656 expect_return_type = 1;
1657 (*mangled)++;
1658 break;
1659 }
1660 /* fall through */
1661
1662 default:
1663 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1664 {
1665 /* Assume we have stumbled onto the first outermost function
1666 argument token, and start processing args. */
1667 func_done = 1;
1668 success = demangle_args (work, mangled, declp);
1669 }
1670 else
1671 {
1672 /* Non-GNU demanglers use a specific token to mark the start
1673 of the outermost function argument tokens. Typically 'F',
1674 for ARM/HP-demangling, for example. So if we find something
1675 we are not prepared for, it must be an error. */
1676 success = 0;
1677 }
1678 break;
1679 }
1680 /*
1681 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1682 */
1683 {
1684 if (success && expect_func)
1685 {
1686 func_done = 1;
1687 if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1688 {
1689 forget_types (work);
1690 }
1691 success = demangle_args (work, mangled, declp);
1692 /* Since template include the mangling of their return types,
1693 we must set expect_func to 0 so that we don't try do
1694 demangle more arguments the next time we get here. */
1695 expect_func = 0;
1696 }
1697 }
1698 }
1699 if (success && !func_done)
1700 {
1701 if (AUTO_DEMANGLING || GNU_DEMANGLING)
1702 {
1703 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1704 bar__3fooi is 'foo::bar(int)'. We get here when we find the
1705 first case, and need to ensure that the '(void)' gets added to
1706 the current declp. Note that with ARM/HP, the first case
1707 represents the name of a static data member 'foo::bar',
1708 which is in the current declp, so we leave it alone. */
1709 success = demangle_args (work, mangled, declp);
1710 }
1711 }
1712 if (success && PRINT_ARG_TYPES)
1713 {
1714 if (work->static_type)
1715 string_append (declp, " static");
1716 if (work->type_quals != TYPE_UNQUALIFIED)
1717 {
1718 APPEND_BLANK (declp);
1719 string_append (declp, qualifier_string (work->type_quals));
1720 }
1721 }
1722
1723 return (success);
1724 }
1725
1726 #if 0
1727
1728 static int
1729 demangle_method_args (struct work_stuff *work, const char **mangled,
1730 string *declp)
1731 {
1732 int success = 0;
1733
1734 if (work -> static_type)
1735 {
1736 string_append (declp, *mangled + 1);
1737 *mangled += strlen (*mangled);
1738 success = 1;
1739 }
1740 else
1741 {
1742 success = demangle_args (work, mangled, declp);
1743 }
1744 return (success);
1745 }
1746
1747 #endif
1748
1749 static int
1750 demangle_template_template_parm (struct work_stuff *work,
1751 const char **mangled, string *tname)
1752 {
1753 int i;
1754 int r;
1755 int need_comma = 0;
1756 int success = 1;
1757 string temp;
1758
1759 string_append (tname, "template <");
1760 /* get size of template parameter list */
1761 if (get_count (mangled, &r))
1762 {
1763 for (i = 0; i < r; i++)
1764 {
1765 if (need_comma)
1766 {
1767 string_append (tname, ", ");
1768 }
1769
1770 /* Z for type parameters */
1771 if (**mangled == 'Z')
1772 {
1773 (*mangled)++;
1774 string_append (tname, "class");
1775 }
1776 /* z for template parameters */
1777 else if (**mangled == 'z')
1778 {
1779 (*mangled)++;
1780 success =
1781 demangle_template_template_parm (work, mangled, tname);
1782 if (!success)
1783 {
1784 break;
1785 }
1786 }
1787 else
1788 {
1789 /* temp is initialized in do_type */
1790 success = do_type (work, mangled, &temp);
1791 if (success)
1792 {
1793 string_appends (tname, &temp);
1794 }
1795 string_delete(&temp);
1796 if (!success)
1797 {
1798 break;
1799 }
1800 }
1801 need_comma = 1;
1802 }
1803
1804 }
1805 if (tname->p[-1] == '>')
1806 string_append (tname, " ");
1807 string_append (tname, "> class");
1808 return (success);
1809 }
1810
1811 static int
1812 demangle_expression (struct work_stuff *work, const char **mangled,
1813 string *s, type_kind_t tk)
1814 {
1815 int need_operator = 0;
1816 int success;
1817
1818 success = 1;
1819 string_appendn (s, "(", 1);
1820 (*mangled)++;
1821 while (success && **mangled != 'W' && **mangled != '\0')
1822 {
1823 if (need_operator)
1824 {
1825 size_t i;
1826 size_t len;
1827
1828 success = 0;
1829
1830 len = strlen (*mangled);
1831
1832 for (i = 0; i < ARRAY_SIZE (optable); ++i)
1833 {
1834 size_t l = strlen (optable[i].in);
1835
1836 if (l <= len
1837 && memcmp (optable[i].in, *mangled, l) == 0)
1838 {
1839 string_appendn (s, " ", 1);
1840 string_append (s, optable[i].out);
1841 string_appendn (s, " ", 1);
1842 success = 1;
1843 (*mangled) += l;
1844 break;
1845 }
1846 }
1847
1848 if (!success)
1849 break;
1850 }
1851 else
1852 need_operator = 1;
1853
1854 success = demangle_template_value_parm (work, mangled, s, tk);
1855 }
1856
1857 if (**mangled != 'W')
1858 success = 0;
1859 else
1860 {
1861 string_appendn (s, ")", 1);
1862 (*mangled)++;
1863 }
1864
1865 return success;
1866 }
1867
1868 static int
1869 demangle_integral_value (struct work_stuff *work,
1870 const char **mangled, string *s)
1871 {
1872 int success;
1873
1874 if (**mangled == 'E')
1875 success = demangle_expression (work, mangled, s, tk_integral);
1876 else if (**mangled == 'Q' || **mangled == 'K')
1877 success = demangle_qualified (work, mangled, s, 0, 1);
1878 else
1879 {
1880 int value;
1881
1882 /* By default, we let the number decide whether we shall consume an
1883 underscore. */
1884 int multidigit_without_leading_underscore = 0;
1885 int leave_following_underscore = 0;
1886
1887 success = 0;
1888
1889 if (**mangled == '_')
1890 {
1891 if (mangled[0][1] == 'm')
1892 {
1893 /* Since consume_count_with_underscores does not handle the
1894 `m'-prefix we must do it here, using consume_count and
1895 adjusting underscores: we have to consume the underscore
1896 matching the prepended one. */
1897 multidigit_without_leading_underscore = 1;
1898 string_appendn (s, "-", 1);
1899 (*mangled) += 2;
1900 }
1901 else
1902 {
1903 /* Do not consume a following underscore;
1904 consume_count_with_underscores will consume what
1905 should be consumed. */
1906 leave_following_underscore = 1;
1907 }
1908 }
1909 else
1910 {
1911 /* Negative numbers are indicated with a leading `m'. */
1912 if (**mangled == 'm')
1913 {
1914 string_appendn (s, "-", 1);
1915 (*mangled)++;
1916 }
1917 /* Since consume_count_with_underscores does not handle
1918 multi-digit numbers that do not start with an underscore,
1919 and this number can be an integer template parameter,
1920 we have to call consume_count. */
1921 multidigit_without_leading_underscore = 1;
1922 /* These multi-digit numbers never end on an underscore,
1923 so if there is one then don't eat it. */
1924 leave_following_underscore = 1;
1925 }
1926
1927 /* We must call consume_count if we expect to remove a trailing
1928 underscore, since consume_count_with_underscores expects
1929 the leading underscore (that we consumed) if it is to handle
1930 multi-digit numbers. */
1931 if (multidigit_without_leading_underscore)
1932 value = consume_count (mangled);
1933 else
1934 value = consume_count_with_underscores (mangled);
1935
1936 if (value != -1)
1937 {
1938 char buf[INTBUF_SIZE];
1939 sprintf (buf, "%d", value);
1940 string_append (s, buf);
1941
1942 /* Numbers not otherwise delimited, might have an underscore
1943 appended as a delimeter, which we should skip.
1944
1945 ??? This used to always remove a following underscore, which
1946 is wrong. If other (arbitrary) cases are followed by an
1947 underscore, we need to do something more radical. */
1948
1949 if ((value > 9 || multidigit_without_leading_underscore)
1950 && ! leave_following_underscore
1951 && **mangled == '_')
1952 (*mangled)++;
1953
1954 /* All is well. */
1955 success = 1;
1956 }
1957 }
1958
1959 return success;
1960 }
1961
1962 /* Demangle the real value in MANGLED. */
1963
1964 static int
1965 demangle_real_value (struct work_stuff *work,
1966 const char **mangled, string *s)
1967 {
1968 if (**mangled == 'E')
1969 return demangle_expression (work, mangled, s, tk_real);
1970
1971 if (**mangled == 'm')
1972 {
1973 string_appendn (s, "-", 1);
1974 (*mangled)++;
1975 }
1976 while (ISDIGIT ((unsigned char)**mangled))
1977 {
1978 string_appendn (s, *mangled, 1);
1979 (*mangled)++;
1980 }
1981 if (**mangled == '.') /* fraction */
1982 {
1983 string_appendn (s, ".", 1);
1984 (*mangled)++;
1985 while (ISDIGIT ((unsigned char)**mangled))
1986 {
1987 string_appendn (s, *mangled, 1);
1988 (*mangled)++;
1989 }
1990 }
1991 if (**mangled == 'e') /* exponent */
1992 {
1993 string_appendn (s, "e", 1);
1994 (*mangled)++;
1995 while (ISDIGIT ((unsigned char)**mangled))
1996 {
1997 string_appendn (s, *mangled, 1);
1998 (*mangled)++;
1999 }
2000 }
2001
2002 return 1;
2003 }
2004
2005 static int
2006 demangle_template_value_parm (struct work_stuff *work, const char **mangled,
2007 string *s, type_kind_t tk)
2008 {
2009 int success = 1;
2010
2011 if (**mangled == 'Y')
2012 {
2013 /* The next argument is a template parameter. */
2014 int idx;
2015
2016 (*mangled)++;
2017 idx = consume_count_with_underscores (mangled);
2018 if (idx == -1
2019 || (work->tmpl_argvec && idx >= work->ntmpl_args)
2020 || consume_count_with_underscores (mangled) == -1)
2021 return -1;
2022 if (work->tmpl_argvec)
2023 string_append (s, work->tmpl_argvec[idx]);
2024 else
2025 string_append_template_idx (s, idx);
2026 }
2027 else if (tk == tk_integral)
2028 success = demangle_integral_value (work, mangled, s);
2029 else if (tk == tk_char)
2030 {
2031 char tmp[2];
2032 int val;
2033 if (**mangled == 'm')
2034 {
2035 string_appendn (s, "-", 1);
2036 (*mangled)++;
2037 }
2038 string_appendn (s, "'", 1);
2039 val = consume_count(mangled);
2040 if (val <= 0)
2041 success = 0;
2042 else
2043 {
2044 tmp[0] = (char)val;
2045 tmp[1] = '\0';
2046 string_appendn (s, &tmp[0], 1);
2047 string_appendn (s, "'", 1);
2048 }
2049 }
2050 else if (tk == tk_bool)
2051 {
2052 int val = consume_count (mangled);
2053 if (val == 0)
2054 string_appendn (s, "false", 5);
2055 else if (val == 1)
2056 string_appendn (s, "true", 4);
2057 else
2058 success = 0;
2059 }
2060 else if (tk == tk_real)
2061 success = demangle_real_value (work, mangled, s);
2062 else if (tk == tk_pointer || tk == tk_reference
2063 || tk == tk_rvalue_reference)
2064 {
2065 if (**mangled == 'Q')
2066 success = demangle_qualified (work, mangled, s,
2067 /*isfuncname=*/0,
2068 /*append=*/1);
2069 else
2070 {
2071 int symbol_len = consume_count (mangled);
2072 if (symbol_len == -1
2073 || symbol_len > (long) strlen (*mangled))
2074 return -1;
2075 if (symbol_len == 0)
2076 string_appendn (s, "0", 1);
2077 else
2078 {
2079 char *p = XNEWVEC (char, symbol_len + 1), *q;
2080 strncpy (p, *mangled, symbol_len);
2081 p [symbol_len] = '\0';
2082 /* We use cplus_demangle here, rather than
2083 internal_cplus_demangle, because the name of the entity
2084 mangled here does not make use of any of the squangling
2085 or type-code information we have built up thus far; it is
2086 mangled independently. */
2087 q = cplus_demangle (p, work->options);
2088 if (tk == tk_pointer)
2089 string_appendn (s, "&", 1);
2090 /* FIXME: Pointer-to-member constants should get a
2091 qualifying class name here. */
2092 if (q)
2093 {
2094 string_append (s, q);
2095 free (q);
2096 }
2097 else
2098 string_append (s, p);
2099 free (p);
2100 }
2101 *mangled += symbol_len;
2102 }
2103 }
2104
2105 return success;
2106 }
2107
2108 /* Demangle the template name in MANGLED. The full name of the
2109 template (e.g., S<int>) is placed in TNAME. The name without the
2110 template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
2111 non-NULL. If IS_TYPE is nonzero, this template is a type template,
2112 not a function template. If both IS_TYPE and REMEMBER are nonzero,
2113 the template is remembered in the list of back-referenceable
2114 types. */
2115
2116 static int
2117 demangle_template (struct work_stuff *work, const char **mangled,
2118 string *tname, string *trawname,
2119 int is_type, int remember)
2120 {
2121 int i;
2122 int r;
2123 int need_comma = 0;
2124 int success = 0;
2125 int is_java_array = 0;
2126 string temp;
2127
2128 (*mangled)++;
2129 if (is_type)
2130 {
2131 /* get template name */
2132 if (**mangled == 'z')
2133 {
2134 int idx;
2135 (*mangled)++;
2136 (*mangled)++;
2137
2138 idx = consume_count_with_underscores (mangled);
2139 if (idx == -1
2140 || (work->tmpl_argvec && idx >= work->ntmpl_args)
2141 || consume_count_with_underscores (mangled) == -1)
2142 return (0);
2143
2144 if (work->tmpl_argvec)
2145 {
2146 string_append (tname, work->tmpl_argvec[idx]);
2147 if (trawname)
2148 string_append (trawname, work->tmpl_argvec[idx]);
2149 }
2150 else
2151 {
2152 string_append_template_idx (tname, idx);
2153 if (trawname)
2154 string_append_template_idx (trawname, idx);
2155 }
2156 }
2157 else
2158 {
2159 if ((r = consume_count (mangled)) <= 0
2160 || (int) strlen (*mangled) < r)
2161 {
2162 return (0);
2163 }
2164 is_java_array = (work -> options & DMGL_JAVA)
2165 && strncmp (*mangled, "JArray1Z", 8) == 0;
2166 if (! is_java_array)
2167 {
2168 string_appendn (tname, *mangled, r);
2169 }
2170 if (trawname)
2171 string_appendn (trawname, *mangled, r);
2172 *mangled += r;
2173 }
2174 }
2175 if (!is_java_array)
2176 string_append (tname, "<");
2177 /* get size of template parameter list */
2178 if (!get_count (mangled, &r))
2179 {
2180 return (0);
2181 }
2182 if (!is_type)
2183 {
2184 /* Create an array for saving the template argument values. */
2185 work->tmpl_argvec = XNEWVEC (char *, r);
2186 work->ntmpl_args = r;
2187 for (i = 0; i < r; i++)
2188 work->tmpl_argvec[i] = 0;
2189 }
2190 for (i = 0; i < r; i++)
2191 {
2192 if (need_comma)
2193 {
2194 string_append (tname, ", ");
2195 }
2196 /* Z for type parameters */
2197 if (**mangled == 'Z')
2198 {
2199 (*mangled)++;
2200 /* temp is initialized in do_type */
2201 success = do_type (work, mangled, &temp);
2202 if (success)
2203 {
2204 string_appends (tname, &temp);
2205
2206 if (!is_type)
2207 {
2208 /* Save the template argument. */
2209 int len = temp.p - temp.b;
2210 work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2211 memcpy (work->tmpl_argvec[i], temp.b, len);
2212 work->tmpl_argvec[i][len] = '\0';
2213 }
2214 }
2215 string_delete(&temp);
2216 if (!success)
2217 {
2218 break;
2219 }
2220 }
2221 /* z for template parameters */
2222 else if (**mangled == 'z')
2223 {
2224 int r2;
2225 (*mangled)++;
2226 success = demangle_template_template_parm (work, mangled, tname);
2227
2228 if (success
2229 && (r2 = consume_count (mangled)) > 0
2230 && (int) strlen (*mangled) >= r2)
2231 {
2232 string_append (tname, " ");
2233 string_appendn (tname, *mangled, r2);
2234 if (!is_type)
2235 {
2236 /* Save the template argument. */
2237 int len = r2;
2238 work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2239 memcpy (work->tmpl_argvec[i], *mangled, len);
2240 work->tmpl_argvec[i][len] = '\0';
2241 }
2242 *mangled += r2;
2243 }
2244 if (!success)
2245 {
2246 break;
2247 }
2248 }
2249 else
2250 {
2251 string param;
2252 string* s;
2253
2254 /* otherwise, value parameter */
2255
2256 /* temp is initialized in do_type */
2257 success = do_type (work, mangled, &temp);
2258 string_delete(&temp);
2259 if (!success)
2260 break;
2261
2262 if (!is_type)
2263 {
2264 s = &param;
2265 string_init (s);
2266 }
2267 else
2268 s = tname;
2269
2270 success = demangle_template_value_parm (work, mangled, s,
2271 (type_kind_t) success);
2272
2273 if (!success)
2274 {
2275 if (!is_type)
2276 string_delete (s);
2277 success = 0;
2278 break;
2279 }
2280
2281 if (!is_type)
2282 {
2283 int len = s->p - s->b;
2284 work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2285 memcpy (work->tmpl_argvec[i], s->b, len);
2286 work->tmpl_argvec[i][len] = '\0';
2287
2288 string_appends (tname, s);
2289 string_delete (s);
2290 }
2291 }
2292 need_comma = 1;
2293 }
2294 if (is_java_array)
2295 {
2296 string_append (tname, "[]");
2297 }
2298 else
2299 {
2300 if (tname->p[-1] == '>')
2301 string_append (tname, " ");
2302 string_append (tname, ">");
2303 }
2304
2305 if (is_type && remember)
2306 {
2307 const int bindex = register_Btype (work);
2308 remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2309 }
2310
2311 /*
2312 if (work -> static_type)
2313 {
2314 string_append (declp, *mangled + 1);
2315 *mangled += strlen (*mangled);
2316 success = 1;
2317 }
2318 else
2319 {
2320 success = demangle_args (work, mangled, declp);
2321 }
2322 }
2323 */
2324 return (success);
2325 }
2326
2327 static int
2328 arm_pt (struct work_stuff *work, const char *mangled,
2329 int n, const char **anchor, const char **args)
2330 {
2331 /* Check if ARM template with "__pt__" in it ("parameterized type") */
2332 /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2333 if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2334 {
2335 int len;
2336 *args = *anchor + 6;
2337 len = consume_count (args);
2338 if (len == -1)
2339 return 0;
2340 if (*args + len == mangled + n && **args == '_')
2341 {
2342 ++*args;
2343 return 1;
2344 }
2345 }
2346 if (AUTO_DEMANGLING || EDG_DEMANGLING)
2347 {
2348 if ((*anchor = strstr (mangled, "__tm__"))
2349 || (*anchor = strstr (mangled, "__ps__"))
2350 || (*anchor = strstr (mangled, "__pt__")))
2351 {
2352 int len;
2353 *args = *anchor + 6;
2354 len = consume_count (args);
2355 if (len == -1)
2356 return 0;
2357 if (*args + len == mangled + n && **args == '_')
2358 {
2359 ++*args;
2360 return 1;
2361 }
2362 }
2363 else if ((*anchor = strstr (mangled, "__S")))
2364 {
2365 int len;
2366 *args = *anchor + 3;
2367 len = consume_count (args);
2368 if (len == -1)
2369 return 0;
2370 if (*args + len == mangled + n && **args == '_')
2371 {
2372 ++*args;
2373 return 1;
2374 }
2375 }
2376 }
2377
2378 return 0;
2379 }
2380
2381 static void
2382 demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2383 int n, string *declp)
2384 {
2385 const char *p;
2386 const char *args;
2387 const char *e = *mangled + n;
2388 string arg;
2389
2390 /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2391 template args */
2392 if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2393 {
2394 char *start_spec_args = NULL;
2395 int hold_options;
2396
2397 /* First check for and omit template specialization pseudo-arguments,
2398 such as in "Spec<#1,#1.*>" */
2399 start_spec_args = strchr (*mangled, '<');
2400 if (start_spec_args && (start_spec_args - *mangled < n))
2401 string_appendn (declp, *mangled, start_spec_args - *mangled);
2402 else
2403 string_appendn (declp, *mangled, n);
2404 (*mangled) += n + 1;
2405 string_init (&arg);
2406 if (work->temp_start == -1) /* non-recursive call */
2407 work->temp_start = declp->p - declp->b;
2408
2409 /* We want to unconditionally demangle parameter types in
2410 template parameters. */
2411 hold_options = work->options;
2412 work->options |= DMGL_PARAMS;
2413
2414 string_append (declp, "<");
2415 while (1)
2416 {
2417 string_delete (&arg);
2418 switch (**mangled)
2419 {
2420 case 'T':
2421 /* 'T' signals a type parameter */
2422 (*mangled)++;
2423 if (!do_type (work, mangled, &arg))
2424 goto hpacc_template_args_done;
2425 break;
2426
2427 case 'U':
2428 case 'S':
2429 /* 'U' or 'S' signals an integral value */
2430 if (!do_hpacc_template_const_value (work, mangled, &arg))
2431 goto hpacc_template_args_done;
2432 break;
2433
2434 case 'A':
2435 /* 'A' signals a named constant expression (literal) */
2436 if (!do_hpacc_template_literal (work, mangled, &arg))
2437 goto hpacc_template_args_done;
2438 break;
2439
2440 default:
2441 /* Today, 1997-09-03, we have only the above types
2442 of template parameters */
2443 /* FIXME: maybe this should fail and return null */
2444 goto hpacc_template_args_done;
2445 }
2446 string_appends (declp, &arg);
2447 /* Check if we're at the end of template args.
2448 0 if at end of static member of template class,
2449 _ if done with template args for a function */
2450 if ((**mangled == '\000') || (**mangled == '_'))
2451 break;
2452 else
2453 string_append (declp, ",");
2454 }
2455 hpacc_template_args_done:
2456 string_append (declp, ">");
2457 string_delete (&arg);
2458 if (**mangled == '_')
2459 (*mangled)++;
2460 work->options = hold_options;
2461 return;
2462 }
2463 /* ARM template? (Also handles HP cfront extensions) */
2464 else if (arm_pt (work, *mangled, n, &p, &args))
2465 {
2466 int hold_options;
2467 string type_str;
2468
2469 string_init (&arg);
2470 string_appendn (declp, *mangled, p - *mangled);
2471 if (work->temp_start == -1) /* non-recursive call */
2472 work->temp_start = declp->p - declp->b;
2473
2474 /* We want to unconditionally demangle parameter types in
2475 template parameters. */
2476 hold_options = work->options;
2477 work->options |= DMGL_PARAMS;
2478
2479 string_append (declp, "<");
2480 /* should do error checking here */
2481 while (args < e) {
2482 string_delete (&arg);
2483
2484 /* Check for type or literal here */
2485 switch (*args)
2486 {
2487 /* HP cfront extensions to ARM for template args */
2488 /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2489 /* FIXME: We handle only numeric literals for HP cfront */
2490 case 'X':
2491 /* A typed constant value follows */
2492 args++;
2493 if (!do_type (work, &args, &type_str))
2494 goto cfront_template_args_done;
2495 string_append (&arg, "(");
2496 string_appends (&arg, &type_str);
2497 string_delete (&type_str);
2498 string_append (&arg, ")");
2499 if (*args != 'L')
2500 goto cfront_template_args_done;
2501 args++;
2502 /* Now snarf a literal value following 'L' */
2503 if (!snarf_numeric_literal (&args, &arg))
2504 goto cfront_template_args_done;
2505 break;
2506
2507 case 'L':
2508 /* Snarf a literal following 'L' */
2509 args++;
2510 if (!snarf_numeric_literal (&args, &arg))
2511 goto cfront_template_args_done;
2512 break;
2513 default:
2514 /* Not handling other HP cfront stuff */
2515 {
2516 const char* old_args = args;
2517 if (!do_type (work, &args, &arg))
2518 goto cfront_template_args_done;
2519
2520 /* Fail if we didn't make any progress: prevent infinite loop. */
2521 if (args == old_args)
2522 {
2523 work->options = hold_options;
2524 return;
2525 }
2526 }
2527 }
2528 string_appends (declp, &arg);
2529 string_append (declp, ",");
2530 }
2531 cfront_template_args_done:
2532 string_delete (&arg);
2533 if (args >= e)
2534 --declp->p; /* remove extra comma */
2535 string_append (declp, ">");
2536 work->options = hold_options;
2537 }
2538 else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2539 && (*mangled)[9] == 'N'
2540 && (*mangled)[8] == (*mangled)[10]
2541 && strchr (cplus_markers, (*mangled)[8]))
2542 {
2543 /* A member of the anonymous namespace. */
2544 string_append (declp, "{anonymous}");
2545 }
2546 else
2547 {
2548 if (work->temp_start == -1) /* non-recursive call only */
2549 work->temp_start = 0; /* disable in recursive calls */
2550 string_appendn (declp, *mangled, n);
2551 }
2552 *mangled += n;
2553 }
2554
2555 /* Extract a class name, possibly a template with arguments, from the
2556 mangled string; qualifiers, local class indicators, etc. have
2557 already been dealt with */
2558
2559 static int
2560 demangle_class_name (struct work_stuff *work, const char **mangled,
2561 string *declp)
2562 {
2563 int n;
2564 int success = 0;
2565
2566 n = consume_count (mangled);
2567 if (n == -1)
2568 return 0;
2569 if ((int) strlen (*mangled) >= n)
2570 {
2571 demangle_arm_hp_template (work, mangled, n, declp);
2572 success = 1;
2573 }
2574
2575 return (success);
2576 }
2577
2578 /*
2579
2580 LOCAL FUNCTION
2581
2582 demangle_class -- demangle a mangled class sequence
2583
2584 SYNOPSIS
2585
2586 static int
2587 demangle_class (struct work_stuff *work, const char **mangled,
2588 strint *declp)
2589
2590 DESCRIPTION
2591
2592 DECLP points to the buffer into which demangling is being done.
2593
2594 *MANGLED points to the current token to be demangled. On input,
2595 it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2596 On exit, it points to the next token after the mangled class on
2597 success, or the first unconsumed token on failure.
2598
2599 If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2600 we are demangling a constructor or destructor. In this case
2601 we prepend "class::class" or "class::~class" to DECLP.
2602
2603 Otherwise, we prepend "class::" to the current DECLP.
2604
2605 Reset the constructor/destructor flags once they have been
2606 "consumed". This allows demangle_class to be called later during
2607 the same demangling, to do normal class demangling.
2608
2609 Returns 1 if demangling is successful, 0 otherwise.
2610
2611 */
2612
2613 static int
2614 demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2615 {
2616 int success = 0;
2617 int btype;
2618 string class_name;
2619 char *save_class_name_end = 0;
2620
2621 string_init (&class_name);
2622 btype = register_Btype (work);
2623 if (demangle_class_name (work, mangled, &class_name))
2624 {
2625 save_class_name_end = class_name.p;
2626 if ((work->constructor & 1) || (work->destructor & 1))
2627 {
2628 /* adjust so we don't include template args */
2629 if (work->temp_start && (work->temp_start != -1))
2630 {
2631 class_name.p = class_name.b + work->temp_start;
2632 }
2633 string_prepends (declp, &class_name);
2634 if (work -> destructor & 1)
2635 {
2636 string_prepend (declp, "~");
2637 work -> destructor -= 1;
2638 }
2639 else
2640 {
2641 work -> constructor -= 1;
2642 }
2643 }
2644 class_name.p = save_class_name_end;
2645 remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2646 remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2647 string_prepend (declp, SCOPE_STRING (work));
2648 string_prepends (declp, &class_name);
2649 success = 1;
2650 }
2651 string_delete (&class_name);
2652 return (success);
2653 }
2654
2655
2656 /* Called when there's a "__" in the mangled name, with `scan' pointing to
2657 the rightmost guess.
2658
2659 Find the correct "__"-sequence where the function name ends and the
2660 signature starts, which is ambiguous with GNU mangling.
2661 Call demangle_signature here, so we can make sure we found the right
2662 one; *mangled will be consumed so caller will not make further calls to
2663 demangle_signature. */
2664
2665 static int
2666 iterate_demangle_function (struct work_stuff *work, const char **mangled,
2667 string *declp, const char *scan)
2668 {
2669 const char *mangle_init = *mangled;
2670 int success = 0;
2671 string decl_init;
2672 struct work_stuff work_init;
2673
2674 if (*(scan + 2) == '\0')
2675 return 0;
2676
2677 /* Do not iterate for some demangling modes, or if there's only one
2678 "__"-sequence. This is the normal case. */
2679 if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2680 || strstr (scan + 2, "__") == NULL)
2681 return demangle_function_name (work, mangled, declp, scan);
2682
2683 /* Save state so we can restart if the guess at the correct "__" was
2684 wrong. */
2685 string_init (&decl_init);
2686 string_appends (&decl_init, declp);
2687 memset (&work_init, 0, sizeof work_init);
2688 work_stuff_copy_to_from (&work_init, work);
2689
2690 /* Iterate over occurrences of __, allowing names and types to have a
2691 "__" sequence in them. We must start with the first (not the last)
2692 occurrence, since "__" most often occur between independent mangled
2693 parts, hence starting at the last occurence inside a signature
2694 might get us a "successful" demangling of the signature. */
2695
2696 while (scan[2])
2697 {
2698 if (demangle_function_name (work, mangled, declp, scan))
2699 {
2700 success = demangle_signature (work, mangled, declp);
2701 if (success)
2702 break;
2703 }
2704
2705 /* Reset demangle state for the next round. */
2706 *mangled = mangle_init;
2707 string_clear (declp);
2708 string_appends (declp, &decl_init);
2709 work_stuff_copy_to_from (work, &work_init);
2710
2711 /* Leave this underscore-sequence. */
2712 scan += 2;
2713
2714 /* Scan for the next "__" sequence. */
2715 while (*scan && (scan[0] != '_' || scan[1] != '_'))
2716 scan++;
2717
2718 /* Move to last "__" in this sequence. */
2719 while (*scan && *scan == '_')
2720 scan++;
2721 scan -= 2;
2722 }
2723
2724 /* Delete saved state. */
2725 delete_work_stuff (&work_init);
2726 string_delete (&decl_init);
2727
2728 return success;
2729 }
2730
2731 /*
2732
2733 LOCAL FUNCTION
2734
2735 demangle_prefix -- consume the mangled name prefix and find signature
2736
2737 SYNOPSIS
2738
2739 static int
2740 demangle_prefix (struct work_stuff *work, const char **mangled,
2741 string *declp);
2742
2743 DESCRIPTION
2744
2745 Consume and demangle the prefix of the mangled name.
2746 While processing the function name root, arrange to call
2747 demangle_signature if the root is ambiguous.
2748
2749 DECLP points to the string buffer into which demangled output is
2750 placed. On entry, the buffer is empty. On exit it contains
2751 the root function name, the demangled operator name, or in some
2752 special cases either nothing or the completely demangled result.
2753
2754 MANGLED points to the current pointer into the mangled name. As each
2755 token of the mangled name is consumed, it is updated. Upon entry
2756 the current mangled name pointer points to the first character of
2757 the mangled name. Upon exit, it should point to the first character
2758 of the signature if demangling was successful, or to the first
2759 unconsumed character if demangling of the prefix was unsuccessful.
2760
2761 Returns 1 on success, 0 otherwise.
2762 */
2763
2764 static int
2765 demangle_prefix (struct work_stuff *work, const char **mangled,
2766 string *declp)
2767 {
2768 int success = 1;
2769 const char *scan;
2770 int i;
2771
2772 if (strlen(*mangled) > 6
2773 && (strncmp(*mangled, "_imp__", 6) == 0
2774 || strncmp(*mangled, "__imp_", 6) == 0))
2775 {
2776 /* it's a symbol imported from a PE dynamic library. Check for both
2777 new style prefix _imp__ and legacy __imp_ used by older versions
2778 of dlltool. */
2779 (*mangled) += 6;
2780 work->dllimported = 1;
2781 }
2782 else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2783 {
2784 char *marker = strchr (cplus_markers, (*mangled)[8]);
2785 if (marker != NULL && *marker == (*mangled)[10])
2786 {
2787 if ((*mangled)[9] == 'D')
2788 {
2789 /* it's a GNU global destructor to be executed at program exit */
2790 (*mangled) += 11;
2791 work->destructor = 2;
2792 if (gnu_special (work, mangled, declp))
2793 return success;
2794 }
2795 else if ((*mangled)[9] == 'I')
2796 {
2797 /* it's a GNU global constructor to be executed at program init */
2798 (*mangled) += 11;
2799 work->constructor = 2;
2800 if (gnu_special (work, mangled, declp))
2801 return success;
2802 }
2803 }
2804 }
2805 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2806 {
2807 /* it's a ARM global destructor to be executed at program exit */
2808 (*mangled) += 7;
2809 work->destructor = 2;
2810 }
2811 else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2812 {
2813 /* it's a ARM global constructor to be executed at program initial */
2814 (*mangled) += 7;
2815 work->constructor = 2;
2816 }
2817
2818 /* This block of code is a reduction in strength time optimization
2819 of:
2820 scan = strstr (*mangled, "__"); */
2821
2822 {
2823 scan = *mangled;
2824
2825 do {
2826 scan = strchr (scan, '_');
2827 } while (scan != NULL && *++scan != '_');
2828
2829 if (scan != NULL) --scan;
2830 }
2831
2832 if (scan != NULL)
2833 {
2834 /* We found a sequence of two or more '_', ensure that we start at
2835 the last pair in the sequence. */
2836 i = strspn (scan, "_");
2837 if (i > 2)
2838 {
2839 scan += (i - 2);
2840 }
2841 }
2842
2843 if (scan == NULL)
2844 {
2845 success = 0;
2846 }
2847 else if (work -> static_type)
2848 {
2849 if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2850 {
2851 success = 0;
2852 }
2853 }
2854 else if ((scan == *mangled)
2855 && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2856 || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2857 {
2858 /* The ARM says nothing about the mangling of local variables.
2859 But cfront mangles local variables by prepending __<nesting_level>
2860 to them. As an extension to ARM demangling we handle this case. */
2861 if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2862 && ISDIGIT ((unsigned char)scan[2]))
2863 {
2864 *mangled = scan + 2;
2865 consume_count (mangled);
2866 string_append (declp, *mangled);
2867 *mangled += strlen (*mangled);
2868 success = 1;
2869 }
2870 else
2871 {
2872 /* A GNU style constructor starts with __[0-9Qt]. But cfront uses
2873 names like __Q2_3foo3bar for nested type names. So don't accept
2874 this style of constructor for cfront demangling. A GNU
2875 style member-template constructor starts with 'H'. */
2876 if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2877 work -> constructor += 1;
2878 *mangled = scan + 2;
2879 }
2880 }
2881 else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2882 {
2883 /* Cfront-style parameterized type. Handled later as a signature. */
2884 success = 1;
2885
2886 /* ARM template? */
2887 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2888 }
2889 else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2890 || (scan[2] == 'p' && scan[3] == 's')
2891 || (scan[2] == 'p' && scan[3] == 't')))
2892 {
2893 /* EDG-style parameterized type. Handled later as a signature. */
2894 success = 1;
2895
2896 /* EDG template? */
2897 demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2898 }
2899 else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2900 && (scan[2] != 't'))
2901 {
2902 /* Mangled name starts with "__". Skip over any leading '_' characters,
2903 then find the next "__" that separates the prefix from the signature.
2904 */
2905 if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2906 || (arm_special (mangled, declp) == 0))
2907 {
2908 while (*scan == '_')
2909 {
2910 scan++;
2911 }
2912 if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2913 {
2914 /* No separator (I.E. "__not_mangled"), or empty signature
2915 (I.E. "__not_mangled_either__") */
2916 success = 0;
2917 }
2918 else
2919 return iterate_demangle_function (work, mangled, declp, scan);
2920 }
2921 }
2922 else if (*(scan + 2) != '\0')
2923 {
2924 /* Mangled name does not start with "__" but does have one somewhere
2925 in there with non empty stuff after it. Looks like a global
2926 function name. Iterate over all "__":s until the right
2927 one is found. */
2928 return iterate_demangle_function (work, mangled, declp, scan);
2929 }
2930 else
2931 {
2932 /* Doesn't look like a mangled name */
2933 success = 0;
2934 }
2935
2936 if (!success && (work->constructor == 2 || work->destructor == 2))
2937 {
2938 string_append (declp, *mangled);
2939 *mangled += strlen (*mangled);
2940 success = 1;
2941 }
2942 return (success);
2943 }
2944
2945 /*
2946
2947 LOCAL FUNCTION
2948
2949 gnu_special -- special handling of gnu mangled strings
2950
2951 SYNOPSIS
2952
2953 static int
2954 gnu_special (struct work_stuff *work, const char **mangled,
2955 string *declp);
2956
2957
2958 DESCRIPTION
2959
2960 Process some special GNU style mangling forms that don't fit
2961 the normal pattern. For example:
2962
2963 _$_3foo (destructor for class foo)
2964 _vt$foo (foo virtual table)
2965 _vt$foo$bar (foo::bar virtual table)
2966 __vt_foo (foo virtual table, new style with thunks)
2967 _3foo$varname (static data member)
2968 _Q22rs2tu$vw (static data member)
2969 __t6vector1Zii (constructor with template)
2970 __thunk_4__$_7ostream (virtual function thunk)
2971 */
2972
2973 static int
2974 gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2975 {
2976 int n;
2977 int success = 1;
2978 const char *p;
2979
2980 if ((*mangled)[0] == '_'
2981 && strchr (cplus_markers, (*mangled)[1]) != NULL
2982 && (*mangled)[2] == '_')
2983 {
2984 /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2985 (*mangled) += 3;
2986 work -> destructor += 1;
2987 }
2988 else if ((*mangled)[0] == '_'
2989 && (((*mangled)[1] == '_'
2990 && (*mangled)[2] == 'v'
2991 && (*mangled)[3] == 't'
2992 && (*mangled)[4] == '_')
2993 || ((*mangled)[1] == 'v'
2994 && (*mangled)[2] == 't'
2995 && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2996 {
2997 /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2998 and create the decl. Note that we consume the entire mangled
2999 input string, which means that demangle_signature has no work
3000 to do. */
3001 if ((*mangled)[2] == 'v')
3002 (*mangled) += 5; /* New style, with thunks: "__vt_" */
3003 else
3004 (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
3005 while (**mangled != '\0')
3006 {
3007 switch (**mangled)
3008 {
3009 case 'Q':
3010 case 'K':
3011 success = demangle_qualified (work, mangled, declp, 0, 1);
3012 break;
3013 case 't':
3014 success = demangle_template (work, mangled, declp, 0, 1,
3015 1);
3016 break;
3017 default:
3018 if (ISDIGIT((unsigned char)*mangled[0]))
3019 {
3020 n = consume_count(mangled);
3021 /* We may be seeing a too-large size, or else a
3022 ".<digits>" indicating a static local symbol. In
3023 any case, declare victory and move on; *don't* try
3024 to use n to allocate. */
3025 if (n > (int) strlen (*mangled))
3026 {
3027 success = 1;
3028 break;
3029 }
3030 else if (n == -1)
3031 {
3032 success = 0;
3033 break;
3034 }
3035 }
3036 else
3037 {
3038 n = strcspn (*mangled, cplus_markers);
3039 }
3040 string_appendn (declp, *mangled, n);
3041 (*mangled) += n;
3042 }
3043
3044 p = strpbrk (*mangled, cplus_markers);
3045 if (success && ((p == NULL) || (p == *mangled)))
3046 {
3047 if (p != NULL)
3048 {
3049 string_append (declp, SCOPE_STRING (work));
3050 (*mangled)++;
3051 }
3052 }
3053 else
3054 {
3055 success = 0;
3056 break;
3057 }
3058 }
3059 if (success)
3060 string_append (declp, " virtual table");
3061 }
3062 else if ((*mangled)[0] == '_'
3063 && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
3064 && (p = strpbrk (*mangled, cplus_markers)) != NULL)
3065 {
3066 /* static data member, "_3foo$varname" for example */
3067 (*mangled)++;
3068 switch (**mangled)
3069 {
3070 case 'Q':
3071 case 'K':
3072 success = demangle_qualified (work, mangled, declp, 0, 1);
3073 break;
3074 case 't':
3075 success = demangle_template (work, mangled, declp, 0, 1, 1);
3076 break;
3077 default:
3078 n = consume_count (mangled);
3079 if (n < 0 || n > (long) strlen (*mangled))
3080 {
3081 success = 0;
3082 break;
3083 }
3084
3085 if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
3086 && (*mangled)[9] == 'N'
3087 && (*mangled)[8] == (*mangled)[10]
3088 && strchr (cplus_markers, (*mangled)[8]))
3089 {
3090 /* A member of the anonymous namespace. There's information
3091 about what identifier or filename it was keyed to, but
3092 it's just there to make the mangled name unique; we just
3093 step over it. */
3094 string_append (declp, "{anonymous}");
3095 (*mangled) += n;
3096
3097 /* Now p points to the marker before the N, so we need to
3098 update it to the first marker after what we consumed. */
3099 p = strpbrk (*mangled, cplus_markers);
3100 break;
3101 }
3102
3103 string_appendn (declp, *mangled, n);
3104 (*mangled) += n;
3105 }
3106 if (success && (p == *mangled))
3107 {
3108 /* Consumed everything up to the cplus_marker, append the
3109 variable name. */
3110 (*mangled)++;
3111 string_append (declp, SCOPE_STRING (work));
3112 n = strlen (*mangled);
3113 string_appendn (declp, *mangled, n);
3114 (*mangled) += n;
3115 }
3116 else
3117 {
3118 success = 0;
3119 }
3120 }
3121 else if (strncmp (*mangled, "__thunk_", 8) == 0)
3122 {
3123 int delta;
3124
3125 (*mangled) += 8;
3126 delta = consume_count (mangled);
3127 if (delta == -1)
3128 success = 0;
3129 else
3130 {
3131 char *method = internal_cplus_demangle (work, ++*mangled);
3132
3133 if (method)
3134 {
3135 char buf[50];
3136 sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
3137 string_append (declp, buf);
3138 string_append (declp, method);
3139 free (method);
3140 n = strlen (*mangled);
3141 (*mangled) += n;
3142 }
3143 else
3144 {
3145 success = 0;
3146 }
3147 }
3148 }
3149 else if (strncmp (*mangled, "__t", 3) == 0
3150 && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
3151 {
3152 p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
3153 (*mangled) += 4;
3154 switch (**mangled)
3155 {
3156 case 'Q':
3157 case 'K':
3158 success = demangle_qualified (work, mangled, declp, 0, 1);
3159 break;
3160 case 't':
3161 success = demangle_template (work, mangled, declp, 0, 1, 1);
3162 break;
3163 default:
3164 success = do_type (work, mangled, declp);
3165 break;
3166 }
3167 if (success && **mangled != '\0')
3168 success = 0;
3169 if (success)
3170 string_append (declp, p);
3171 }
3172 else
3173 {
3174 success = 0;
3175 }
3176 return (success);
3177 }
3178
3179 static void
3180 recursively_demangle(struct work_stuff *work, const char **mangled,
3181 string *result, int namelength)
3182 {
3183 char * recurse = (char *)NULL;
3184 char * recurse_dem = (char *)NULL;
3185
3186 recurse = XNEWVEC (char, namelength + 1);
3187 memcpy (recurse, *mangled, namelength);
3188 recurse[namelength] = '\000';
3189
3190 recurse_dem = cplus_demangle (recurse, work->options);
3191
3192 if (recurse_dem)
3193 {
3194 string_append (result, recurse_dem);
3195 free (recurse_dem);
3196 }
3197 else
3198 {
3199 string_appendn (result, *mangled, namelength);
3200 }
3201 free (recurse);
3202 *mangled += namelength;
3203 }
3204
3205 /*
3206
3207 LOCAL FUNCTION
3208
3209 arm_special -- special handling of ARM/lucid mangled strings
3210
3211 SYNOPSIS
3212
3213 static int
3214 arm_special (const char **mangled,
3215 string *declp);
3216
3217
3218 DESCRIPTION
3219
3220 Process some special ARM style mangling forms that don't fit
3221 the normal pattern. For example:
3222
3223 __vtbl__3foo (foo virtual table)
3224 __vtbl__3foo__3bar (bar::foo virtual table)
3225
3226 */
3227
3228 static int
3229 arm_special (const char **mangled, string *declp)
3230 {
3231 int n;
3232 int success = 1;
3233 const char *scan;
3234
3235 if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3236 {
3237 /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3238 and create the decl. Note that we consume the entire mangled
3239 input string, which means that demangle_signature has no work
3240 to do. */
3241 scan = *mangled + ARM_VTABLE_STRLEN;
3242 while (*scan != '\0') /* first check it can be demangled */
3243 {
3244 n = consume_count (&scan);
3245 if (n == -1)
3246 {
3247 return (0); /* no good */
3248 }
3249 scan += n;
3250 if (scan[0] == '_' && scan[1] == '_')
3251 {
3252 scan += 2;
3253 }
3254 }
3255 (*mangled) += ARM_VTABLE_STRLEN;
3256 while (**mangled != '\0')
3257 {
3258 n = consume_count (mangled);
3259 if (n == -1
3260 || n > (long) strlen (*mangled))
3261 return 0;
3262 string_prependn (declp, *mangled, n);
3263 (*mangled) += n;
3264 if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3265 {
3266 string_prepend (declp, "::");
3267 (*mangled) += 2;
3268 }
3269 }
3270 string_append (declp, " virtual table");
3271 }
3272 else
3273 {
3274 success = 0;
3275 }
3276 return (success);
3277 }
3278
3279 /*
3280
3281 LOCAL FUNCTION
3282
3283 demangle_qualified -- demangle 'Q' qualified name strings
3284
3285 SYNOPSIS
3286
3287 static int
3288 demangle_qualified (struct work_stuff *, const char *mangled,
3289 string *result, int isfuncname, int append);
3290
3291 DESCRIPTION
3292
3293 Demangle a qualified name, such as "Q25Outer5Inner" which is
3294 the mangled form of "Outer::Inner". The demangled output is
3295 prepended or appended to the result string according to the
3296 state of the append flag.
3297
3298 If isfuncname is nonzero, then the qualified name we are building
3299 is going to be used as a member function name, so if it is a
3300 constructor or destructor function, append an appropriate
3301 constructor or destructor name. I.E. for the above example,
3302 the result for use as a constructor is "Outer::Inner::Inner"
3303 and the result for use as a destructor is "Outer::Inner::~Inner".
3304
3305 BUGS
3306
3307 Numeric conversion is ASCII dependent (FIXME).
3308
3309 */
3310
3311 static int
3312 demangle_qualified (struct work_stuff *work, const char **mangled,
3313 string *result, int isfuncname, int append)
3314 {
3315 int qualifiers = 0;
3316 int success = 1;
3317 char num[2];
3318 string temp;
3319 string last_name;
3320 int bindex = register_Btype (work);
3321
3322 /* We only make use of ISFUNCNAME if the entity is a constructor or
3323 destructor. */
3324 isfuncname = (isfuncname
3325 && ((work->constructor & 1) || (work->destructor & 1)));
3326
3327 string_init (&temp);
3328 string_init (&last_name);
3329
3330 if ((*mangled)[0] == 'K')
3331 {
3332 /* Squangling qualified name reuse */
3333 int idx;
3334 (*mangled)++;
3335 idx = consume_count_with_underscores (mangled);
3336 if (idx == -1 || idx >= work -> numk)
3337 success = 0;
3338 else
3339 string_append (&temp, work -> ktypevec[idx]);
3340 }
3341 else
3342 switch ((*mangled)[1])
3343 {
3344 case '_':
3345 /* GNU mangled name with more than 9 classes. The count is preceded
3346 by an underscore (to distinguish it from the <= 9 case) and followed
3347 by an underscore. */
3348 (*mangled)++;
3349 qualifiers = consume_count_with_underscores (mangled);
3350 if (qualifiers == -1)
3351 success = 0;
3352 break;
3353
3354 case '1':
3355 case '2':
3356 case '3':
3357 case '4':
3358 case '5':
3359 case '6':
3360 case '7':
3361 case '8':
3362 case '9':
3363 /* The count is in a single digit. */
3364 num[0] = (*mangled)[1];
3365 num[1] = '\0';
3366 qualifiers = atoi (num);
3367
3368 /* If there is an underscore after the digit, skip it. This is
3369 said to be for ARM-qualified names, but the ARM makes no
3370 mention of such an underscore. Perhaps cfront uses one. */
3371 if ((*mangled)[2] == '_')
3372 {
3373 (*mangled)++;
3374 }
3375 (*mangled) += 2;
3376 break;
3377
3378 case '0':
3379 default:
3380 success = 0;
3381 }
3382
3383 if (!success)
3384 return success;
3385
3386 /* Pick off the names and collect them in the temp buffer in the order
3387 in which they are found, separated by '::'. */
3388
3389 while (qualifiers-- > 0)
3390 {
3391 int remember_K = 1;
3392 string_clear (&last_name);
3393
3394 if (*mangled[0] == '_')
3395 (*mangled)++;
3396
3397 if (*mangled[0] == 't')
3398 {
3399 /* Here we always append to TEMP since we will want to use
3400 the template name without the template parameters as a
3401 constructor or destructor name. The appropriate
3402 (parameter-less) value is returned by demangle_template
3403 in LAST_NAME. We do not remember the template type here,
3404 in order to match the G++ mangling algorithm. */
3405 success = demangle_template(work, mangled, &temp,
3406 &last_name, 1, 0);
3407 if (!success)
3408 break;
3409 }
3410 else if (*mangled[0] == 'K')
3411 {
3412 int idx;
3413 (*mangled)++;
3414 idx = consume_count_with_underscores (mangled);
3415 if (idx == -1 || idx >= work->numk)
3416 success = 0;
3417 else
3418 string_append (&temp, work->ktypevec[idx]);
3419 remember_K = 0;
3420
3421 if (!success) break;
3422 }
3423 else
3424 {
3425 if (EDG_DEMANGLING)
3426 {
3427 int namelength;
3428 /* Now recursively demangle the qualifier
3429 * This is necessary to deal with templates in
3430 * mangling styles like EDG */
3431 namelength = consume_count (mangled);
3432 if (namelength == -1)
3433 {
3434 success = 0;
3435 break;
3436 }
3437 recursively_demangle(work, mangled, &temp, namelength);
3438 }
3439 else
3440 {
3441 string_delete (&last_name);
3442 success = do_type (work, mangled, &last_name);
3443 if (!success)
3444 break;
3445 string_appends (&temp, &last_name);
3446 }
3447 }
3448
3449 if (remember_K)
3450 remember_Ktype (work, temp.b, LEN_STRING (&temp));
3451
3452 if (qualifiers > 0)
3453 string_append (&temp, SCOPE_STRING (work));
3454 }
3455
3456 remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3457
3458 /* If we are using the result as a function name, we need to append
3459 the appropriate '::' separated constructor or destructor name.
3460 We do this here because this is the most convenient place, where
3461 we already have a pointer to the name and the length of the name. */
3462
3463 if (isfuncname)
3464 {
3465 string_append (&temp, SCOPE_STRING (work));
3466 if (work -> destructor & 1)
3467 string_append (&temp, "~");
3468 string_appends (&temp, &last_name);
3469 }
3470
3471 /* Now either prepend the temp buffer to the result, or append it,
3472 depending upon the state of the append flag. */
3473
3474 if (append)
3475 string_appends (result, &temp);
3476 else
3477 {
3478 if (!STRING_EMPTY (result))
3479 string_append (&temp, SCOPE_STRING (work));
3480 string_prepends (result, &temp);
3481 }
3482
3483 string_delete (&last_name);
3484 string_delete (&temp);
3485 return (success);
3486 }
3487
3488 /*
3489
3490 LOCAL FUNCTION
3491
3492 get_count -- convert an ascii count to integer, consuming tokens
3493
3494 SYNOPSIS
3495
3496 static int
3497 get_count (const char **type, int *count)
3498
3499 DESCRIPTION
3500
3501 Assume that *type points at a count in a mangled name; set
3502 *count to its value, and set *type to the next character after
3503 the count. There are some weird rules in effect here.
3504
3505 If *type does not point at a string of digits, return zero.
3506
3507 If *type points at a string of digits followed by an
3508 underscore, set *count to their value as an integer, advance
3509 *type to point *after the underscore, and return 1.
3510
3511 If *type points at a string of digits not followed by an
3512 underscore, consume only the first digit. Set *count to its
3513 value as an integer, leave *type pointing after that digit,
3514 and return 1.
3515
3516 The excuse for this odd behavior: in the ARM and HP demangling
3517 styles, a type can be followed by a repeat count of the form
3518 `Nxy', where:
3519
3520 `x' is a single digit specifying how many additional copies
3521 of the type to append to the argument list, and
3522
3523 `y' is one or more digits, specifying the zero-based index of
3524 the first repeated argument in the list. Yes, as you're
3525 unmangling the name you can figure this out yourself, but
3526 it's there anyway.
3527
3528 So, for example, in `bar__3fooFPiN51', the first argument is a
3529 pointer to an integer (`Pi'), and then the next five arguments
3530 are the same (`N5'), and the first repeat is the function's
3531 second argument (`1').
3532 */
3533
3534 static int
3535 get_count (const char **type, int *count)
3536 {
3537 const char *p;
3538 int n;
3539
3540 if (!ISDIGIT ((unsigned char)**type))
3541 return (0);
3542 else
3543 {
3544 *count = **type - '0';
3545 (*type)++;
3546 if (ISDIGIT ((unsigned char)**type))
3547 {
3548 p = *type;
3549 n = *count;
3550 do
3551 {
3552 n *= 10;
3553 n += *p - '0';
3554 p++;
3555 }
3556 while (ISDIGIT ((unsigned char)*p));
3557 if (*p == '_')
3558 {
3559 *type = p + 1;
3560 *count = n;
3561 }
3562 }
3563 }
3564 return (1);
3565 }
3566
3567 /* RESULT will be initialised here; it will be freed on failure. The
3568 value returned is really a type_kind_t. */
3569
3570 static int
3571 do_type (struct work_stuff *work, const char **mangled, string *result)
3572 {
3573 int n;
3574 int i;
3575 int is_proctypevec;
3576 int done;
3577 int success;
3578 string decl;
3579 const char *remembered_type;
3580 int type_quals;
3581 type_kind_t tk = tk_none;
3582
3583 string_init (&decl);
3584 string_init (result);
3585
3586 done = 0;
3587 success = 1;
3588 is_proctypevec = 0;
3589 while (success && !done)
3590 {
3591 int member;
3592 switch (**mangled)
3593 {
3594
3595 /* A pointer type */
3596 case 'P':
3597 case 'p':
3598 (*mangled)++;
3599 if (! (work -> options & DMGL_JAVA))
3600 string_prepend (&decl, "*");
3601 if (tk == tk_none)
3602 tk = tk_pointer;
3603 break;
3604
3605 /* A reference type */
3606 case 'R':
3607 (*mangled)++;
3608 string_prepend (&decl, "&");
3609 if (tk == tk_none)
3610 tk = tk_reference;
3611 break;
3612
3613 /* An rvalue reference type */
3614 case 'O':
3615 (*mangled)++;
3616 string_prepend (&decl, "&&");
3617 if (tk == tk_none)
3618 tk = tk_rvalue_reference;
3619 break;
3620
3621 /* An array */
3622 case 'A':
3623 {
3624 ++(*mangled);
3625 if (!STRING_EMPTY (&decl)
3626 && (decl.b[0] == '*' || decl.b[0] == '&'))
3627 {
3628 string_prepend (&decl, "(");
3629 string_append (&decl, ")");
3630 }
3631 string_append (&decl, "[");
3632 if (**mangled != '_')
3633 success = demangle_template_value_parm (work, mangled, &decl,
3634 tk_integral);
3635 if (**mangled == '_')
3636 ++(*mangled);
3637 string_append (&decl, "]");
3638 break;
3639 }
3640
3641 /* A back reference to a previously seen type */
3642 case 'T':
3643 (*mangled)++;
3644 if (!get_count (mangled, &n) || n < 0 || n >= work -> ntypes)
3645 {
3646 success = 0;
3647 }
3648 else
3649 for (i = 0; i < work->nproctypes; i++)
3650 if (work -> proctypevec [i] == n)
3651 success = 0;
3652
3653 if (success)
3654 {
3655 is_proctypevec = 1;
3656 push_processed_type (work, n);
3657 remembered_type = work->typevec[n];
3658 mangled = &remembered_type;
3659 }
3660 break;
3661
3662 /* A function */
3663 case 'F':
3664 (*mangled)++;
3665 if (!STRING_EMPTY (&decl)
3666 && (decl.b[0] == '*' || decl.b[0] == '&'))
3667 {
3668 string_prepend (&decl, "(");
3669 string_append (&decl, ")");
3670 }
3671 /* After picking off the function args, we expect to either find the
3672 function return type (preceded by an '_') or the end of the
3673 string. */
3674 if (!demangle_nested_args (work, mangled, &decl)
3675 || (**mangled != '_' && **mangled != '\0'))
3676 {
3677 success = 0;
3678 break;
3679 }
3680 if (success && (**mangled == '_'))
3681 (*mangled)++;
3682 break;
3683
3684 case 'M':
3685 {
3686 type_quals = TYPE_UNQUALIFIED;
3687
3688 member = **mangled == 'M';
3689 (*mangled)++;
3690
3691 string_append (&decl, ")");
3692
3693 /* We don't need to prepend `::' for a qualified name;
3694 demangle_qualified will do that for us. */
3695 if (**mangled != 'Q')
3696 string_prepend (&decl, SCOPE_STRING (work));
3697
3698 if (ISDIGIT ((unsigned char)**mangled))
3699 {
3700 n = consume_count (mangled);
3701 if (n == -1
3702 || (int) strlen (*mangled) < n)
3703 {
3704 success = 0;
3705 break;
3706 }
3707 string_prependn (&decl, *mangled, n);
3708 *mangled += n;
3709 }
3710 else if (**mangled == 'X' || **mangled == 'Y')
3711 {
3712 string temp;
3713 do_type (work, mangled, &temp);
3714 string_prepends (&decl, &temp);
3715 string_delete (&temp);
3716 }
3717 else if (**mangled == 't')
3718 {
3719 string temp;
3720 string_init (&temp);
3721 success = demangle_template (work, mangled, &temp,
3722 NULL, 1, 1);
3723 if (success)
3724 {
3725 string_prependn (&decl, temp.b, temp.p - temp.b);
3726 string_delete (&temp);
3727 }
3728 else
3729 {
3730 string_delete (&temp);
3731 break;
3732 }
3733 }
3734 else if (**mangled == 'Q')
3735 {
3736 success = demangle_qualified (work, mangled, &decl,
3737 /*isfuncnam=*/0,
3738 /*append=*/0);
3739 if (!success)
3740 break;
3741 }
3742 else
3743 {
3744 success = 0;
3745 break;
3746 }
3747
3748 string_prepend (&decl, "(");
3749 if (member)
3750 {
3751 switch (**mangled)
3752 {
3753 case 'C':
3754 case 'V':
3755 case 'u':
3756 type_quals |= code_for_qualifier (**mangled);
3757 (*mangled)++;
3758 break;
3759
3760 default:
3761 break;
3762 }
3763
3764 if (*(*mangled)++ != 'F')
3765 {
3766 success = 0;
3767 break;
3768 }
3769 }
3770 if ((member && !demangle_nested_args (work, mangled, &decl))
3771 || **mangled != '_')
3772 {
3773 success = 0;
3774 break;
3775 }
3776 (*mangled)++;
3777 if (! PRINT_ANSI_QUALIFIERS)
3778 {
3779 break;
3780 }
3781 if (type_quals != TYPE_UNQUALIFIED)
3782 {
3783 APPEND_BLANK (&decl);
3784 string_append (&decl, qualifier_string (type_quals));
3785 }
3786 break;
3787 }
3788 case 'G':
3789 (*mangled)++;
3790 break;
3791
3792 case 'C':
3793 case 'V':
3794 case 'u':
3795 if (PRINT_ANSI_QUALIFIERS)
3796 {
3797 if (!STRING_EMPTY (&decl))
3798 string_prepend (&decl, " ");
3799
3800 string_prepend (&decl, demangle_qualifier (**mangled));
3801 }
3802 (*mangled)++;
3803 break;
3804 /*
3805 }
3806 */
3807
3808 /* fall through */
3809 default:
3810 done = 1;
3811 break;
3812 }
3813 }
3814
3815 if (success) switch (**mangled)
3816 {
3817 /* A qualified name, such as "Outer::Inner". */
3818 case 'Q':
3819 case 'K':
3820 {
3821 success = demangle_qualified (work, mangled, result, 0, 1);
3822 break;
3823 }
3824
3825 /* A back reference to a previously seen squangled type */
3826 case 'B':
3827 (*mangled)++;
3828 if (!get_count (mangled, &n) || n < 0 || n >= work -> numb)
3829 success = 0;
3830 else
3831 string_append (result, work->btypevec[n]);
3832 break;
3833
3834 case 'X':
3835 case 'Y':
3836 /* A template parm. We substitute the corresponding argument. */
3837 {
3838 int idx;
3839
3840 (*mangled)++;
3841 idx = consume_count_with_underscores (mangled);
3842
3843 if (idx == -1
3844 || (work->tmpl_argvec && idx >= work->ntmpl_args)
3845 || consume_count_with_underscores (mangled) == -1)
3846 {
3847 success = 0;
3848 break;
3849 }
3850
3851 if (work->tmpl_argvec)
3852 string_append (result, work->tmpl_argvec[idx]);
3853 else
3854 string_append_template_idx (result, idx);
3855
3856 success = 1;
3857 }
3858 break;
3859
3860 default:
3861 success = demangle_fund_type (work, mangled, result);
3862 if (tk == tk_none)
3863 tk = (type_kind_t) success;
3864 break;
3865 }
3866
3867 if (success)
3868 {
3869 if (!STRING_EMPTY (&decl))
3870 {
3871 string_append (result, " ");
3872 string_appends (result, &decl);
3873 }
3874 }
3875 else
3876 string_delete (result);
3877 string_delete (&decl);
3878
3879 if (is_proctypevec)
3880 pop_processed_type (work);
3881
3882 if (success)
3883 /* Assume an integral type, if we're not sure. */
3884 return (int) ((tk == tk_none) ? tk_integral : tk);
3885 else
3886 return 0;
3887 }
3888
3889 /* Given a pointer to a type string that represents a fundamental type
3890 argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3891 string in which the demangled output is being built in RESULT, and
3892 the WORK structure, decode the types and add them to the result.
3893
3894 For example:
3895
3896 "Ci" => "const int"
3897 "Sl" => "signed long"
3898 "CUs" => "const unsigned short"
3899
3900 The value returned is really a type_kind_t. */
3901
3902 static int
3903 demangle_fund_type (struct work_stuff *work,
3904 const char **mangled, string *result)
3905 {
3906 int done = 0;
3907 int success = 1;
3908 char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
3909 unsigned int dec = 0;
3910 type_kind_t tk = tk_integral;
3911
3912 /* First pick off any type qualifiers. There can be more than one. */
3913
3914 while (!done)
3915 {
3916 switch (**mangled)
3917 {
3918 case 'C':
3919 case 'V':
3920 case 'u':
3921 if (PRINT_ANSI_QUALIFIERS)
3922 {
3923 if (!STRING_EMPTY (result))
3924 string_prepend (result, " ");
3925 string_prepend (result, demangle_qualifier (**mangled));
3926 }
3927 (*mangled)++;
3928 break;
3929 case 'U':
3930 (*mangled)++;
3931 APPEND_BLANK (result);
3932 string_append (result, "unsigned");
3933 break;
3934 case 'S': /* signed char only */
3935 (*mangled)++;
3936 APPEND_BLANK (result);
3937 string_append (result, "signed");
3938 break;
3939 case 'J':
3940 (*mangled)++;
3941 APPEND_BLANK (result);
3942 string_append (result, "__complex");
3943 break;
3944 default:
3945 done = 1;
3946 break;
3947 }
3948 }
3949
3950 /* Now pick off the fundamental type. There can be only one. */
3951
3952 switch (**mangled)
3953 {
3954 case '\0':
3955 case '_':
3956 break;
3957 case 'v':
3958 (*mangled)++;
3959 APPEND_BLANK (result);
3960 string_append (result, "void");
3961 break;
3962 case 'x':
3963 (*mangled)++;
3964 APPEND_BLANK (result);
3965 string_append (result, "long long");
3966 break;
3967 case 'l':
3968 (*mangled)++;
3969 APPEND_BLANK (result);
3970 string_append (result, "long");
3971 break;
3972 case 'i':
3973 (*mangled)++;
3974 APPEND_BLANK (result);
3975 string_append (result, "int");
3976 break;
3977 case 's':
3978 (*mangled)++;
3979 APPEND_BLANK (result);
3980 string_append (result, "short");
3981 break;
3982 case 'b':
3983 (*mangled)++;
3984 APPEND_BLANK (result);
3985 string_append (result, "bool");
3986 tk = tk_bool;
3987 break;
3988 case 'c':
3989 (*mangled)++;
3990 APPEND_BLANK (result);
3991 string_append (result, "char");
3992 tk = tk_char;
3993 break;
3994 case 'w':
3995 (*mangled)++;
3996 APPEND_BLANK (result);
3997 string_append (result, "wchar_t");
3998 tk = tk_char;
3999 break;
4000 case 'r':
4001 (*mangled)++;
4002 APPEND_BLANK (result);
4003 string_append (result, "long double");
4004 tk = tk_real;
4005 break;
4006 case 'd':
4007 (*mangled)++;
4008 APPEND_BLANK (result);
4009 string_append (result, "double");
4010 tk = tk_real;
4011 break;
4012 case 'f':
4013 (*mangled)++;
4014 APPEND_BLANK (result);
4015 string_append (result, "float");
4016 tk = tk_real;
4017 break;
4018 case 'G':
4019 (*mangled)++;
4020 if (!ISDIGIT ((unsigned char)**mangled))
4021 {
4022 success = 0;
4023 break;
4024 }
4025 /* fall through */
4026 case 'I':
4027 (*mangled)++;
4028 if (**mangled == '_')
4029 {
4030 int i;
4031 (*mangled)++;
4032 for (i = 0;
4033 i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
4034 (*mangled)++, i++)
4035 buf[i] = **mangled;
4036 if (**mangled != '_')
4037 {
4038 success = 0;
4039 break;
4040 }
4041 buf[i] = '\0';
4042 (*mangled)++;
4043 }
4044 else
4045 {
4046 strncpy (buf, *mangled, 2);
4047 buf[2] = '\0';
4048 *mangled += min (strlen (*mangled), 2);
4049 }
4050 sscanf (buf, "%x", &dec);
4051 sprintf (buf, "int%u_t", dec);
4052 APPEND_BLANK (result);
4053 string_append (result, buf);
4054 break;
4055
4056 /* fall through */
4057 /* An explicit type, such as "6mytype" or "7integer" */
4058 case '0':
4059 case '1':
4060 case '2':
4061 case '3':
4062 case '4':
4063 case '5':
4064 case '6':
4065 case '7':
4066 case '8':
4067 case '9':
4068 {
4069 int bindex = register_Btype (work);
4070 string btype;
4071 string_init (&btype);
4072 if (demangle_class_name (work, mangled, &btype)) {
4073 remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
4074 APPEND_BLANK (result);
4075 string_appends (result, &btype);
4076 }
4077 else
4078 success = 0;
4079 string_delete (&btype);
4080 break;
4081 }
4082 case 't':
4083 {
4084 string btype;
4085 string_init (&btype);
4086 success = demangle_template (work, mangled, &btype, 0, 1, 1);
4087 string_appends (result, &btype);
4088 string_delete (&btype);
4089 break;
4090 }
4091 default:
4092 success = 0;
4093 break;
4094 }
4095
4096 return success ? ((int) tk) : 0;
4097 }
4098
4099
4100 /* Handle a template's value parameter for HP aCC (extension from ARM)
4101 **mangled points to 'S' or 'U' */
4102
4103 static int
4104 do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
4105 const char **mangled, string *result)
4106 {
4107 int unsigned_const;
4108
4109 if (**mangled != 'U' && **mangled != 'S')
4110 return 0;
4111
4112 unsigned_const = (**mangled == 'U');
4113
4114 (*mangled)++;
4115
4116 switch (**mangled)
4117 {
4118 case 'N':
4119 string_append (result, "-");
4120 /* fall through */
4121 case 'P':
4122 (*mangled)++;
4123 break;
4124 case 'M':
4125 /* special case for -2^31 */
4126 string_append (result, "-2147483648");
4127 (*mangled)++;
4128 return 1;
4129 default:
4130 return 0;
4131 }
4132
4133 /* We have to be looking at an integer now */
4134 if (!(ISDIGIT ((unsigned char)**mangled)))
4135 return 0;
4136
4137 /* We only deal with integral values for template
4138 parameters -- so it's OK to look only for digits */
4139 while (ISDIGIT ((unsigned char)**mangled))
4140 {
4141 char_str[0] = **mangled;
4142 string_append (result, char_str);
4143 (*mangled)++;
4144 }
4145
4146 if (unsigned_const)
4147 string_append (result, "U");
4148
4149 /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
4150 with L or LL suffixes. pai/1997-09-03 */
4151
4152 return 1; /* success */
4153 }
4154
4155 /* Handle a template's literal parameter for HP aCC (extension from ARM)
4156 **mangled is pointing to the 'A' */
4157
4158 static int
4159 do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
4160 string *result)
4161 {
4162 int literal_len = 0;
4163 char * recurse;
4164 char * recurse_dem;
4165
4166 if (**mangled != 'A')
4167 return 0;
4168
4169 (*mangled)++;
4170
4171 literal_len = consume_count (mangled);
4172
4173 if (literal_len <= 0
4174 || literal_len > (long) strlen (*mangled))
4175 return 0;
4176
4177 /* Literal parameters are names of arrays, functions, etc. and the
4178 canonical representation uses the address operator */
4179 string_append (result, "&");
4180
4181 /* Now recursively demangle the literal name */
4182 recurse = XNEWVEC (char, literal_len + 1);
4183 memcpy (recurse, *mangled, literal_len);
4184 recurse[literal_len] = '\000';
4185
4186 recurse_dem = cplus_demangle (recurse, work->options);
4187
4188 if (recurse_dem)
4189 {
4190 string_append (result, recurse_dem);
4191 free (recurse_dem);
4192 }
4193 else
4194 {
4195 string_appendn (result, *mangled, literal_len);
4196 }
4197 (*mangled) += literal_len;
4198 free (recurse);
4199
4200 return 1;
4201 }
4202
4203 static int
4204 snarf_numeric_literal (const char **args, string *arg)
4205 {
4206 if (**args == '-')
4207 {
4208 char_str[0] = '-';
4209 string_append (arg, char_str);
4210 (*args)++;
4211 }
4212 else if (**args == '+')
4213 (*args)++;
4214
4215 if (!ISDIGIT ((unsigned char)**args))
4216 return 0;
4217
4218 while (ISDIGIT ((unsigned char)**args))
4219 {
4220 char_str[0] = **args;
4221 string_append (arg, char_str);
4222 (*args)++;
4223 }
4224
4225 return 1;
4226 }
4227
4228 /* Demangle the next argument, given by MANGLED into RESULT, which
4229 *should be an uninitialized* string. It will be initialized here,
4230 and free'd should anything go wrong. */
4231
4232 static int
4233 do_arg (struct work_stuff *work, const char **mangled, string *result)
4234 {
4235 /* Remember where we started so that we can record the type, for
4236 non-squangling type remembering. */
4237 const char *start = *mangled;
4238
4239 string_init (result);
4240
4241 if (work->nrepeats > 0)
4242 {
4243 --work->nrepeats;
4244
4245 if (work->previous_argument == 0)
4246 return 0;
4247
4248 /* We want to reissue the previous type in this argument list. */
4249 string_appends (result, work->previous_argument);
4250 return 1;
4251 }
4252
4253 if (**mangled == 'n')
4254 {
4255 /* A squangling-style repeat. */
4256 (*mangled)++;
4257 work->nrepeats = consume_count(mangled);
4258
4259 if (work->nrepeats <= 0)
4260 /* This was not a repeat count after all. */
4261 return 0;
4262
4263 if (work->nrepeats > 9)
4264 {
4265 if (**mangled != '_')
4266 /* The repeat count should be followed by an '_' in this
4267 case. */
4268 return 0;
4269 else
4270 (*mangled)++;
4271 }
4272
4273 /* Now, the repeat is all set up. */
4274 return do_arg (work, mangled, result);
4275 }
4276
4277 /* Save the result in WORK->previous_argument so that we can find it
4278 if it's repeated. Note that saving START is not good enough: we
4279 do not want to add additional types to the back-referenceable
4280 type vector when processing a repeated type. */
4281 if (work->previous_argument)
4282 string_delete (work->previous_argument);
4283 else
4284 work->previous_argument = XNEW (string);
4285
4286 if (!do_type (work, mangled, work->previous_argument))
4287 return 0;
4288
4289 string_appends (result, work->previous_argument);
4290
4291 remember_type (work, start, *mangled - start);
4292 return 1;
4293 }
4294
4295 static void
4296 push_processed_type (struct work_stuff *work, int typevec_index)
4297 {
4298 if (work->nproctypes >= work->proctypevec_size)
4299 {
4300 if (!work->proctypevec_size)
4301 {
4302 work->proctypevec_size = 4;
4303 work->proctypevec = XNEWVEC (int, work->proctypevec_size);
4304 }
4305 else
4306 {
4307 if (work->proctypevec_size < 16)
4308 /* Double when small. */
4309 work->proctypevec_size *= 2;
4310 else
4311 {
4312 /* Grow slower when large. */
4313 if (work->proctypevec_size > (INT_MAX / 3) * 2)
4314 xmalloc_failed (INT_MAX);
4315 work->proctypevec_size = (work->proctypevec_size * 3 / 2);
4316 }
4317 work->proctypevec
4318 = XRESIZEVEC (int, work->proctypevec, work->proctypevec_size);
4319 }
4320 }
4321 work->proctypevec [work->nproctypes++] = typevec_index;
4322 }
4323
4324 static void
4325 pop_processed_type (struct work_stuff *work)
4326 {
4327 work->nproctypes--;
4328 }
4329
4330 static void
4331 remember_type (struct work_stuff *work, const char *start, int len)
4332 {
4333 char *tem;
4334
4335 if (work->forgetting_types)
4336 return;
4337
4338 if (work -> ntypes >= work -> typevec_size)
4339 {
4340 if (work -> typevec_size == 0)
4341 {
4342 work -> typevec_size = 3;
4343 work -> typevec = XNEWVEC (char *, work->typevec_size);
4344 }
4345 else
4346 {
4347 if (work -> typevec_size > INT_MAX / 2)
4348 xmalloc_failed (INT_MAX);
4349 work -> typevec_size *= 2;
4350 work -> typevec
4351 = XRESIZEVEC (char *, work->typevec, work->typevec_size);
4352 }
4353 }
4354 tem = XNEWVEC (char, len + 1);
4355 memcpy (tem, start, len);
4356 tem[len] = '\0';
4357 work -> typevec[work -> ntypes++] = tem;
4358 }
4359
4360
4361 /* Remember a K type class qualifier. */
4362 static void
4363 remember_Ktype (struct work_stuff *work, const char *start, int len)
4364 {
4365 char *tem;
4366
4367 if (work -> numk >= work -> ksize)
4368 {
4369 if (work -> ksize == 0)
4370 {
4371 work -> ksize = 5;
4372 work -> ktypevec = XNEWVEC (char *, work->ksize);
4373 }
4374 else
4375 {
4376 if (work -> ksize > INT_MAX / 2)
4377 xmalloc_failed (INT_MAX);
4378 work -> ksize *= 2;
4379 work -> ktypevec
4380 = XRESIZEVEC (char *, work->ktypevec, work->ksize);
4381 }
4382 }
4383 tem = XNEWVEC (char, len + 1);
4384 memcpy (tem, start, len);
4385 tem[len] = '\0';
4386 work -> ktypevec[work -> numk++] = tem;
4387 }
4388
4389 /* Register a B code, and get an index for it. B codes are registered
4390 as they are seen, rather than as they are completed, so map<temp<char> >
4391 registers map<temp<char> > as B0, and temp<char> as B1 */
4392
4393 static int
4394 register_Btype (struct work_stuff *work)
4395 {
4396 int ret;
4397
4398 if (work -> numb >= work -> bsize)
4399 {
4400 if (work -> bsize == 0)
4401 {
4402 work -> bsize = 5;
4403 work -> btypevec = XNEWVEC (char *, work->bsize);
4404 }
4405 else
4406 {
4407 if (work -> bsize > INT_MAX / 2)
4408 xmalloc_failed (INT_MAX);
4409 work -> bsize *= 2;
4410 work -> btypevec
4411 = XRESIZEVEC (char *, work->btypevec, work->bsize);
4412 }
4413 }
4414 ret = work -> numb++;
4415 work -> btypevec[ret] = NULL;
4416 return(ret);
4417 }
4418
4419 /* Store a value into a previously registered B code type. */
4420
4421 static void
4422 remember_Btype (struct work_stuff *work, const char *start,
4423 int len, int index)
4424 {
4425 char *tem;
4426
4427 tem = XNEWVEC (char, len + 1);
4428 memcpy (tem, start, len);
4429 tem[len] = '\0';
4430 work -> btypevec[index] = tem;
4431 }
4432
4433 /* Lose all the info related to B and K type codes. */
4434 static void
4435 forget_B_and_K_types (struct work_stuff *work)
4436 {
4437 int i;
4438
4439 while (work -> numk > 0)
4440 {
4441 i = --(work -> numk);
4442 if (work -> ktypevec[i] != NULL)
4443 {
4444 free (work -> ktypevec[i]);
4445 work -> ktypevec[i] = NULL;
4446 }
4447 }
4448
4449 while (work -> numb > 0)
4450 {
4451 i = --(work -> numb);
4452 if (work -> btypevec[i] != NULL)
4453 {
4454 free (work -> btypevec[i]);
4455 work -> btypevec[i] = NULL;
4456 }
4457 }
4458 }
4459 /* Forget the remembered types, but not the type vector itself. */
4460
4461 static void
4462 forget_types (struct work_stuff *work)
4463 {
4464 int i;
4465
4466 while (work -> ntypes > 0)
4467 {
4468 i = --(work -> ntypes);
4469 if (work -> typevec[i] != NULL)
4470 {
4471 free (work -> typevec[i]);
4472 work -> typevec[i] = NULL;
4473 }
4474 }
4475 }
4476
4477 /* Process the argument list part of the signature, after any class spec
4478 has been consumed, as well as the first 'F' character (if any). For
4479 example:
4480
4481 "__als__3fooRT0" => process "RT0"
4482 "complexfunc5__FPFPc_PFl_i" => process "PFPc_PFl_i"
4483
4484 DECLP must be already initialised, usually non-empty. It won't be freed
4485 on failure.
4486
4487 Note that g++ differs significantly from ARM and lucid style mangling
4488 with regards to references to previously seen types. For example, given
4489 the source fragment:
4490
4491 class foo {
4492 public:
4493 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4494 };
4495
4496 foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4497 void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4498
4499 g++ produces the names:
4500
4501 __3fooiRT0iT2iT2
4502 foo__FiR3fooiT1iT1
4503
4504 while lcc (and presumably other ARM style compilers as well) produces:
4505
4506 foo__FiR3fooT1T2T1T2
4507 __ct__3fooFiR3fooT1T2T1T2
4508
4509 Note that g++ bases its type numbers starting at zero and counts all
4510 previously seen types, while lucid/ARM bases its type numbers starting
4511 at one and only considers types after it has seen the 'F' character
4512 indicating the start of the function args. For lucid/ARM style, we
4513 account for this difference by discarding any previously seen types when
4514 we see the 'F' character, and subtracting one from the type number
4515 reference.
4516
4517 */
4518
4519 static int
4520 demangle_args (struct work_stuff *work, const char **mangled,
4521 string *declp)
4522 {
4523 string arg;
4524 int need_comma = 0;
4525 int r;
4526 int t;
4527 const char *tem;
4528 char temptype;
4529
4530 if (PRINT_ARG_TYPES)
4531 {
4532 string_append (declp, "(");
4533 if (**mangled == '\0')
4534 {
4535 string_append (declp, "void");
4536 }
4537 }
4538
4539 while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4540 || work->nrepeats > 0)
4541 {
4542 if ((**mangled == 'N') || (**mangled == 'T'))
4543 {
4544 temptype = *(*mangled)++;
4545
4546 if (temptype == 'N')
4547 {
4548 if (!get_count (mangled, &r))
4549 {
4550 return (0);
4551 }
4552 }
4553 else
4554 {
4555 r = 1;
4556 }
4557 if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4558 {
4559 /* If we have 10 or more types we might have more than a 1 digit
4560 index so we'll have to consume the whole count here. This
4561 will lose if the next thing is a type name preceded by a
4562 count but it's impossible to demangle that case properly
4563 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4564 Pc, ...)" or "(..., type12, char *, ...)" */
4565 if ((t = consume_count(mangled)) <= 0)
4566 {
4567 return (0);
4568 }
4569 }
4570 else
4571 {
4572 if (!get_count (mangled, &t))
4573 {
4574 return (0);
4575 }
4576 }
4577 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4578 {
4579 t--;
4580 }
4581 /* Validate the type index. Protect against illegal indices from
4582 malformed type strings. */
4583 if ((t < 0) || (t >= work -> ntypes))
4584 {
4585 return (0);
4586 }
4587 while (work->nrepeats > 0 || --r >= 0)
4588 {
4589 tem = work -> typevec[t];
4590 if (need_comma && PRINT_ARG_TYPES)
4591 {
4592 string_append (declp, ", ");
4593 }
4594 push_processed_type (work, t);
4595 if (!do_arg (work, &tem, &arg))
4596 {
4597 pop_processed_type (work);
4598 return (0);
4599 }
4600 pop_processed_type (work);
4601 if (PRINT_ARG_TYPES)
4602 {
4603 string_appends (declp, &arg);
4604 }
4605 string_delete (&arg);
4606 need_comma = 1;
4607 }
4608 }
4609 else
4610 {
4611 if (need_comma && PRINT_ARG_TYPES)
4612 string_append (declp, ", ");
4613 if (!do_arg (work, mangled, &arg))
4614 return (0);
4615 if (PRINT_ARG_TYPES)
4616 string_appends (declp, &arg);
4617 string_delete (&arg);
4618 need_comma = 1;
4619 }
4620 }
4621
4622 if (**mangled == 'e')
4623 {
4624 (*mangled)++;
4625 if (PRINT_ARG_TYPES)
4626 {
4627 if (need_comma)
4628 {
4629 string_append (declp, ",");
4630 }
4631 string_append (declp, "...");
4632 }
4633 }
4634
4635 if (PRINT_ARG_TYPES)
4636 {
4637 string_append (declp, ")");
4638 }
4639 return (1);
4640 }
4641
4642 /* Like demangle_args, but for demangling the argument lists of function
4643 and method pointers or references, not top-level declarations. */
4644
4645 static int
4646 demangle_nested_args (struct work_stuff *work, const char **mangled,
4647 string *declp)
4648 {
4649 string* saved_previous_argument;
4650 int result;
4651 int saved_nrepeats;
4652
4653 /* The G++ name-mangling algorithm does not remember types on nested
4654 argument lists, unless -fsquangling is used, and in that case the
4655 type vector updated by remember_type is not used. So, we turn
4656 off remembering of types here. */
4657 ++work->forgetting_types;
4658
4659 /* For the repeat codes used with -fsquangling, we must keep track of
4660 the last argument. */
4661 saved_previous_argument = work->previous_argument;
4662 saved_nrepeats = work->nrepeats;
4663 work->previous_argument = 0;
4664 work->nrepeats = 0;
4665
4666 /* Actually demangle the arguments. */
4667 result = demangle_args (work, mangled, declp);
4668
4669 /* Restore the previous_argument field. */
4670 if (work->previous_argument)
4671 {
4672 string_delete (work->previous_argument);
4673 free ((char *) work->previous_argument);
4674 }
4675 work->previous_argument = saved_previous_argument;
4676 --work->forgetting_types;
4677 work->nrepeats = saved_nrepeats;
4678
4679 return result;
4680 }
4681
4682 /* Returns 1 if a valid function name was found or 0 otherwise. */
4683
4684 static int
4685 demangle_function_name (struct work_stuff *work, const char **mangled,
4686 string *declp, const char *scan)
4687 {
4688 size_t i;
4689 string type;
4690 const char *tem;
4691
4692 string_appendn (declp, (*mangled), scan - (*mangled));
4693 string_need (declp, 1);
4694 *(declp -> p) = '\0';
4695
4696 /* Consume the function name, including the "__" separating the name
4697 from the signature. We are guaranteed that SCAN points to the
4698 separator. */
4699
4700 (*mangled) = scan + 2;
4701 /* We may be looking at an instantiation of a template function:
4702 foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4703 following _F marks the start of the function arguments. Handle
4704 the template arguments first. */
4705
4706 if (HP_DEMANGLING && (**mangled == 'X'))
4707 {
4708 demangle_arm_hp_template (work, mangled, 0, declp);
4709 /* This leaves MANGLED pointing to the 'F' marking func args */
4710 }
4711
4712 if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4713 {
4714
4715 /* See if we have an ARM style constructor or destructor operator.
4716 If so, then just record it, clear the decl, and return.
4717 We can't build the actual constructor/destructor decl until later,
4718 when we recover the class name from the signature. */
4719
4720 if (strcmp (declp -> b, "__ct") == 0)
4721 {
4722 work -> constructor += 1;
4723 string_clear (declp);
4724 return 1;
4725 }
4726 else if (strcmp (declp -> b, "__dt") == 0)
4727 {
4728 work -> destructor += 1;
4729 string_clear (declp);
4730 return 1;
4731 }
4732 }
4733
4734 if (declp->p - declp->b >= 3
4735 && declp->b[0] == 'o'
4736 && declp->b[1] == 'p'
4737 && strchr (cplus_markers, declp->b[2]) != NULL)
4738 {
4739 /* see if it's an assignment expression */
4740 if (declp->p - declp->b >= 10 /* op$assign_ */
4741 && memcmp (declp->b + 3, "assign_", 7) == 0)
4742 {
4743 for (i = 0; i < ARRAY_SIZE (optable); i++)
4744 {
4745 int len = declp->p - declp->b - 10;
4746 if ((int) strlen (optable[i].in) == len
4747 && memcmp (optable[i].in, declp->b + 10, len) == 0)
4748 {
4749 string_clear (declp);
4750 string_append (declp, "operator");
4751 string_append (declp, optable[i].out);
4752 string_append (declp, "=");
4753 break;
4754 }
4755 }
4756 }
4757 else
4758 {
4759 for (i = 0; i < ARRAY_SIZE (optable); i++)
4760 {
4761 int len = declp->p - declp->b - 3;
4762 if ((int) strlen (optable[i].in) == len
4763 && memcmp (optable[i].in, declp->b + 3, len) == 0)
4764 {
4765 string_clear (declp);
4766 string_append (declp, "operator");
4767 string_append (declp, optable[i].out);
4768 break;
4769 }
4770 }
4771 }
4772 }
4773 else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4774 && strchr (cplus_markers, declp->b[4]) != NULL)
4775 {
4776 /* type conversion operator */
4777 tem = declp->b + 5;
4778 if (do_type (work, &tem, &type))
4779 {
4780 string_clear (declp);
4781 string_append (declp, "operator ");
4782 string_appends (declp, &type);
4783 string_delete (&type);
4784 }
4785 }
4786 else if (declp->b[0] == '_' && declp->b[1] == '_'
4787 && declp->b[2] == 'o' && declp->b[3] == 'p')
4788 {
4789 /* ANSI. */
4790 /* type conversion operator. */
4791 tem = declp->b + 4;
4792 if (do_type (work, &tem, &type))
4793 {
4794 string_clear (declp);
4795 string_append (declp, "operator ");
4796 string_appends (declp, &type);
4797 string_delete (&type);
4798 }
4799 }
4800 else if (declp->b[0] == '_' && declp->b[1] == '_'
4801 && ISLOWER((unsigned char)declp->b[2])
4802 && ISLOWER((unsigned char)declp->b[3]))
4803 {
4804 if (declp->b[4] == '\0')
4805 {
4806 /* Operator. */
4807 for (i = 0; i < ARRAY_SIZE (optable); i++)
4808 {
4809 if (strlen (optable[i].in) == 2
4810 && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4811 {
4812 string_clear (declp);
4813 string_append (declp, "operator");
4814 string_append (declp, optable[i].out);
4815 break;
4816 }
4817 }
4818 }
4819 else
4820 {
4821 if (declp->b[2] == 'a' && declp->b[5] == '\0')
4822 {
4823 /* Assignment. */
4824 for (i = 0; i < ARRAY_SIZE (optable); i++)
4825 {
4826 if (strlen (optable[i].in) == 3
4827 && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4828 {
4829 string_clear (declp);
4830 string_append (declp, "operator");
4831 string_append (declp, optable[i].out);
4832 break;
4833 }
4834 }
4835 }
4836 }
4837 }
4838
4839 /* If a function name was obtained but it's not valid, we were not
4840 successful. */
4841 if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
4842 return 0;
4843 else
4844 return 1;
4845 }
4846
4847 /* a mini string-handling package */
4848
4849 static void
4850 string_need (string *s, int n)
4851 {
4852 int tem;
4853
4854 if (s->b == NULL)
4855 {
4856 if (n < 32)
4857 {
4858 n = 32;
4859 }
4860 s->p = s->b = XNEWVEC (char, n);
4861 s->e = s->b + n;
4862 }
4863 else if (s->e - s->p < n)
4864 {
4865 tem = s->p - s->b;
4866 if (n > INT_MAX / 2 - tem)
4867 xmalloc_failed (INT_MAX);
4868 n += tem;
4869 n *= 2;
4870 s->b = XRESIZEVEC (char, s->b, n);
4871 s->p = s->b + tem;
4872 s->e = s->b + n;
4873 }
4874 }
4875
4876 static void
4877 string_delete (string *s)
4878 {
4879 if (s->b != NULL)
4880 {
4881 free (s->b);
4882 s->b = s->e = s->p = NULL;
4883 }
4884 }
4885
4886 static void
4887 string_init (string *s)
4888 {
4889 s->b = s->p = s->e = NULL;
4890 }
4891
4892 static void
4893 string_clear (string *s)
4894 {
4895 s->p = s->b;
4896 }
4897
4898 #if 0
4899
4900 static int
4901 string_empty (string *s)
4902 {
4903 return (s->b == s->p);
4904 }
4905
4906 #endif
4907
4908 static void
4909 string_append (string *p, const char *s)
4910 {
4911 int n;
4912 if (s == NULL || *s == '\0')
4913 return;
4914 n = strlen (s);
4915 string_need (p, n);
4916 memcpy (p->p, s, n);
4917 p->p += n;
4918 }
4919
4920 static void
4921 string_appends (string *p, string *s)
4922 {
4923 int n;
4924
4925 if (s->b != s->p)
4926 {
4927 n = s->p - s->b;
4928 string_need (p, n);
4929 memcpy (p->p, s->b, n);
4930 p->p += n;
4931 }
4932 }
4933
4934 static void
4935 string_appendn (string *p, const char *s, int n)
4936 {
4937 if (n != 0)
4938 {
4939 string_need (p, n);
4940 memcpy (p->p, s, n);
4941 p->p += n;
4942 }
4943 }
4944
4945 static void
4946 string_prepend (string *p, const char *s)
4947 {
4948 if (s != NULL && *s != '\0')
4949 {
4950 string_prependn (p, s, strlen (s));
4951 }
4952 }
4953
4954 static void
4955 string_prepends (string *p, string *s)
4956 {
4957 if (s->b != s->p)
4958 {
4959 string_prependn (p, s->b, s->p - s->b);
4960 }
4961 }
4962
4963 static void
4964 string_prependn (string *p, const char *s, int n)
4965 {
4966 char *q;
4967
4968 if (n != 0)
4969 {
4970 string_need (p, n);
4971 for (q = p->p - 1; q >= p->b; q--)
4972 {
4973 q[n] = q[0];
4974 }
4975 memcpy (p->b, s, n);
4976 p->p += n;
4977 }
4978 }
4979
4980 static void
4981 string_append_template_idx (string *s, int idx)
4982 {
4983 char buf[INTBUF_SIZE + 1 /* 'T' */];
4984 sprintf(buf, "T%d", idx);
4985 string_append (s, buf);
4986 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org