OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [libiberty/] [cplus-dem.c] - Blame information for rev 310

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.