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