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