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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [libiberty/] [cplus-dem.c] - Blame information for rev 862

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

Line No. Rev Author Line
1 38 julius 
/* 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 
void * malloc ();
56 
void * realloc ();
57 
#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 
    return NULL;
988 
  else
989 
    return demangled;
990 
 
991 
 Suppress:
992 
  grow_vect (&demangled,
993 
             &demangled_size,  strlen (mangled) + 3,
994 
             sizeof (char));
995 
 
996 
  if (mangled[0] == '<')
997 
     strcpy (demangled, mangled);
998 
  else
999 
    sprintf (demangled, "<%s>", mangled);
1000 
 
1001 
  return demangled;
1002 
}
1003 
 
1004 
/* This function performs most of what cplus_demangle use to do, but
1005 
   to be able to demangle a name with a B, K or n code, we need to
1006 
   have a longer term memory of what types have been seen. The original
1007 
   now initializes and cleans up the squangle code info, while internal
1008 
   calls go directly to this routine to avoid resetting that info. */
1009 
 
1010 
static char *
1011 
internal_cplus_demangle (struct work_stuff *work, const char *mangled)
1012 
{
1013 
 
1014 
  string decl;
1015 
  int success = 0;
1016 
  char *demangled = NULL;
1017 
  int s1, s2, s3, s4;
1018 
  s1 = work->constructor;
1019 
  s2 = work->destructor;
1020 
  s3 = work->static_type;
1021 
  s4 = work->type_quals;
1022 
  work->constructor = work->destructor = 0;
1023 
  work->type_quals = TYPE_UNQUALIFIED;
1024 
  work->dllimported = 0;
1025 
 
1026 
  if ((mangled != NULL) && (*mangled != '\0'))
1027 
    {
1028 
      string_init (&decl);
1029 
 
1030 
      /* First check to see if gnu style demangling is active and if the
1031 
         string to be demangled contains a CPLUS_MARKER.  If so, attempt to
1032 
         recognize one of the gnu special forms rather than looking for a
1033 
         standard prefix.  In particular, don't worry about whether there
1034 
         is a "__" string in the mangled string.  Consider "_$_5__foo" for
1035 
         example.  */
1036 
 
1037 
      if ((AUTO_DEMANGLING || GNU_DEMANGLING))
1038 
        {
1039 
          success = gnu_special (work, &mangled, &decl);
1040 
        }
1041 
      if (!success)
1042 
        {
1043 
          success = demangle_prefix (work, &mangled, &decl);
1044 
        }
1045 
      if (success && (*mangled != '\0'))
1046 
        {
1047 
          success = demangle_signature (work, &mangled, &decl);
1048 
        }
1049 
      if (work->constructor == 2)
1050 
        {
1051 
          string_prepend (&decl, "global constructors keyed to ");
1052 
          work->constructor = 0;
1053 
        }
1054 
      else if (work->destructor == 2)
1055 
        {
1056 
          string_prepend (&decl, "global destructors keyed to ");
1057 
          work->destructor = 0;
1058 
        }
1059 
      else if (work->dllimported == 1)
1060 
        {
1061 
          string_prepend (&decl, "import stub for ");
1062 
          work->dllimported = 0;
1063 
        }
1064 
      demangled = mop_up (work, &decl, success);
1065 
    }
1066 
  work->constructor = s1;
1067 
  work->destructor = s2;
1068 
  work->static_type = s3;
1069 
  work->type_quals = s4;
1070 
  return demangled;
1071 
}
1072 
 
1073 
 
1074 
/* Clear out and squangling related storage */
1075 
static void
1076 
squangle_mop_up (struct work_stuff *work)
1077 
{
1078 
  /* clean up the B and K type mangling types. */
1079 
  forget_B_and_K_types (work);
1080 
  if (work -> btypevec != NULL)
1081 
    {
1082 
      free ((char *) work -> btypevec);
1083 
    }
1084 
  if (work -> ktypevec != NULL)
1085 
    {
1086 
      free ((char *) work -> ktypevec);
1087 
    }
1088 
}
1089 
 
1090 
 
1091 
/* Copy the work state and storage.  */
1092 
 
1093 
static void
1094 
work_stuff_copy_to_from (struct work_stuff *to, struct work_stuff *from)
1095 
{
1096 
  int i;
1097 
 
1098 
  delete_work_stuff (to);
1099 
 
1100 
  /* Shallow-copy scalars.  */
1101 
  memcpy (to, from, sizeof (*to));
1102 
 
1103 
  /* Deep-copy dynamic storage.  */
1104 
  if (from->typevec_size)
1105 
    to->typevec = XNEWVEC (char *, from->typevec_size);
1106 
 
1107 
  for (i = 0; i < from->ntypes; i++)
1108 
    {
1109 
      int len = strlen (from->typevec[i]) + 1;
1110 
 
1111 
      to->typevec[i] = XNEWVEC (char, len);
1112 
      memcpy (to->typevec[i], from->typevec[i], len);
1113 
    }
1114 
 
1115 
  if (from->ksize)
1116 
    to->ktypevec = XNEWVEC (char *, from->ksize);
1117 
 
1118 
  for (i = 0; i < from->numk; i++)
1119 
    {
1120 
      int len = strlen (from->ktypevec[i]) + 1;
1121 
 
1122 
      to->ktypevec[i] = XNEWVEC (char, len);
1123 
      memcpy (to->ktypevec[i], from->ktypevec[i], len);
1124 
    }
1125 
 
1126 
  if (from->bsize)
1127 
    to->btypevec = XNEWVEC (char *, from->bsize);
1128 
 
1129 
  for (i = 0; i < from->numb; i++)
1130 
    {
1131 
      int len = strlen (from->btypevec[i]) + 1;
1132 
 
1133 
      to->btypevec[i] = XNEWVEC (char , len);
1134 
      memcpy (to->btypevec[i], from->btypevec[i], len);
1135 
    }
1136 
 
1137 
  if (from->ntmpl_args)
1138 
    to->tmpl_argvec = XNEWVEC (char *, from->ntmpl_args);
1139 
 
1140 
  for (i = 0; i < from->ntmpl_args; i++)
1141 
    {
1142 
      int len = strlen (from->tmpl_argvec[i]) + 1;
1143 
 
1144 
      to->tmpl_argvec[i] = XNEWVEC (char, len);
1145 
      memcpy (to->tmpl_argvec[i], from->tmpl_argvec[i], len);
1146 
    }
1147 
 
1148 
  if (from->previous_argument)
1149 
    {
1150 
      to->previous_argument = XNEW (string);
1151 
      string_init (to->previous_argument);
1152 
      string_appends (to->previous_argument, from->previous_argument);
1153 
    }
1154 
}
1155 
 
1156 
 
1157 
/* Delete dynamic stuff in work_stuff that is not to be re-used.  */
1158 
 
1159 
static void
1160 
delete_non_B_K_work_stuff (struct work_stuff *work)
1161 
{
1162 
  /* Discard the remembered types, if any.  */
1163 
 
1164 
  forget_types (work);
1165 
  if (work -> typevec != NULL)
1166 
    {
1167 
      free ((char *) work -> typevec);
1168 
      work -> typevec = NULL;
1169 
      work -> typevec_size = 0;
1170 
    }
1171 
  if (work->tmpl_argvec)
1172 
    {
1173 
      int i;
1174 
 
1175 
      for (i = 0; i < work->ntmpl_args; i++)
1176 
        if (work->tmpl_argvec[i])
1177 
          free ((char*) work->tmpl_argvec[i]);
1178 
 
1179 
      free ((char*) work->tmpl_argvec);
1180 
      work->tmpl_argvec = NULL;
1181 
    }
1182 
  if (work->previous_argument)
1183 
    {
1184 
      string_delete (work->previous_argument);
1185 
      free ((char*) work->previous_argument);
1186 
      work->previous_argument = NULL;
1187 
    }
1188 
}
1189 
 
1190 
 
1191 
/* Delete all dynamic storage in work_stuff.  */
1192 
static void
1193 
delete_work_stuff (struct work_stuff *work)
1194 
{
1195 
  delete_non_B_K_work_stuff (work);
1196 
  squangle_mop_up (work);
1197 
}
1198 
 
1199 
 
1200 
/* Clear out any mangled storage */
1201 
 
1202 
static char *
1203 
mop_up (struct work_stuff *work, string *declp, int success)
1204 
{
1205 
  char *demangled = NULL;
1206 
 
1207 
  delete_non_B_K_work_stuff (work);
1208 
 
1209 
  /* If demangling was successful, ensure that the demangled string is null
1210 
     terminated and return it.  Otherwise, free the demangling decl.  */
1211 
 
1212 
  if (!success)
1213 
    {
1214 
      string_delete (declp);
1215 
    }
1216 
  else
1217 
    {
1218 
      string_appendn (declp, "", 1);
1219 
      demangled = declp->b;
1220 
    }
1221 
  return (demangled);
1222 
}
1223 
 
1224 
/*
1225 
 
1226 
LOCAL FUNCTION
1227 
 
1228 
        demangle_signature -- demangle the signature part of a mangled name
1229 
 
1230 
SYNOPSIS
1231 
 
1232 
        static int
1233 
        demangle_signature (struct work_stuff *work, const char **mangled,
1234 
                            string *declp);
1235 
 
1236 
DESCRIPTION
1237 
 
1238 
        Consume and demangle the signature portion of the mangled name.
1239 
 
1240 
        DECLP is the string where demangled output is being built.  At
1241 
        entry it contains the demangled root name from the mangled name
1242 
        prefix.  I.E. either a demangled operator name or the root function
1243 
        name.  In some special cases, it may contain nothing.
1244 
 
1245 
        *MANGLED points to the current unconsumed location in the mangled
1246 
        name.  As tokens are consumed and demangling is performed, the
1247 
        pointer is updated to continuously point at the next token to
1248 
        be consumed.
1249 
 
1250 
        Demangling GNU style mangled names is nasty because there is no
1251 
        explicit token that marks the start of the outermost function
1252 
        argument list.  */
1253 
 
1254 
static int
1255 
demangle_signature (struct work_stuff *work,
1256 
                    const char **mangled, string *declp)
1257 
{
1258 
  int success = 1;
1259 
  int func_done = 0;
1260 
  int expect_func = 0;
1261 
  int expect_return_type = 0;
1262 
  const char *oldmangled = NULL;
1263 
  string trawname;
1264 
  string tname;
1265 
 
1266 
  while (success && (**mangled != '\0'))
1267 
    {
1268 
      switch (**mangled)
1269 
        {
1270 
        case 'Q':
1271 
          oldmangled = *mangled;
1272 
          success = demangle_qualified (work, mangled, declp, 1, 0);
1273 
          if (success)
1274 
            remember_type (work, oldmangled, *mangled - oldmangled);
1275 
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
1276 
            expect_func = 1;
1277 
          oldmangled = NULL;
1278 
          break;
1279 
 
1280 
        case 'K':
1281 
          oldmangled = *mangled;
1282 
          success = demangle_qualified (work, mangled, declp, 1, 0);
1283 
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
1284 
            {
1285 
              expect_func = 1;
1286 
            }
1287 
          oldmangled = NULL;
1288 
          break;
1289 
 
1290 
        case 'S':
1291 
          /* Static member function */
1292 
          if (oldmangled == NULL)
1293 
            {
1294 
              oldmangled = *mangled;
1295 
            }
1296 
          (*mangled)++;
1297 
          work -> static_type = 1;
1298 
          break;
1299 
 
1300 
        case 'C':
1301 
        case 'V':
1302 
        case 'u':
1303 
          work->type_quals |= code_for_qualifier (**mangled);
1304 
 
1305 
          /* a qualified member function */
1306 
          if (oldmangled == NULL)
1307 
            oldmangled = *mangled;
1308 
          (*mangled)++;
1309 
          break;
1310 
 
1311 
        case 'L':
1312 
          /* Local class name follows after "Lnnn_" */
1313 
          if (HP_DEMANGLING)
1314 
            {
1315 
              while (**mangled && (**mangled != '_'))
1316 
                (*mangled)++;
1317 
              if (!**mangled)
1318 
                success = 0;
1319 
              else
1320 
                (*mangled)++;
1321 
            }
1322 
          else
1323 
            success = 0;
1324 
          break;
1325 
 
1326 
        case '0': case '1': case '2': case '3': case '4':
1327 
        case '5': case '6': case '7': case '8': case '9':
1328 
          if (oldmangled == NULL)
1329 
            {
1330 
              oldmangled = *mangled;
1331 
            }
1332 
          work->temp_start = -1; /* uppermost call to demangle_class */
1333 
          success = demangle_class (work, mangled, declp);
1334 
          if (success)
1335 
            {
1336 
              remember_type (work, oldmangled, *mangled - oldmangled);
1337 
            }
1338 
          if (AUTO_DEMANGLING || GNU_DEMANGLING || EDG_DEMANGLING)
1339 
            {
1340 
              /* EDG and others will have the "F", so we let the loop cycle
1341 
                 if we are looking at one. */
1342 
              if (**mangled != 'F')
1343 
                 expect_func = 1;
1344 
            }
1345 
          oldmangled = NULL;
1346 
          break;
1347 
 
1348 
        case 'B':
1349 
          {
1350 
            string s;
1351 
            success = do_type (work, mangled, &s);
1352 
            if (success)
1353 
              {
1354 
                string_append (&s, SCOPE_STRING (work));
1355 
                string_prepends (declp, &s);
1356 
                string_delete (&s);
1357 
              }
1358 
            oldmangled = NULL;
1359 
            expect_func = 1;
1360 
          }
1361 
          break;
1362 
 
1363 
        case 'F':
1364 
          /* Function */
1365 
          /* ARM/HP style demangling includes a specific 'F' character after
1366 
             the class name.  For GNU style, it is just implied.  So we can
1367 
             safely just consume any 'F' at this point and be compatible
1368 
             with either style.  */
1369 
 
1370 
          oldmangled = NULL;
1371 
          func_done = 1;
1372 
          (*mangled)++;
1373 
 
1374 
          /* For lucid/ARM/HP style we have to forget any types we might
1375 
             have remembered up to this point, since they were not argument
1376 
             types.  GNU style considers all types seen as available for
1377 
             back references.  See comment in demangle_args() */
1378 
 
1379 
          if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
1380 
            {
1381 
              forget_types (work);
1382 
            }
1383 
          success = demangle_args (work, mangled, declp);
1384 
          /* After picking off the function args, we expect to either
1385 
             find the function return type (preceded by an '_') or the
1386 
             end of the string. */
1387 
          if (success && (AUTO_DEMANGLING || EDG_DEMANGLING) && **mangled == '_')
1388 
            {
1389 
              ++(*mangled);
1390 
              /* At this level, we do not care about the return type. */
1391 
              success = do_type (work, mangled, &tname);
1392 
              string_delete (&tname);
1393 
            }
1394 
 
1395 
          break;
1396 
 
1397 
        case 't':
1398 
          /* G++ Template */
1399 
          string_init(&trawname);
1400 
          string_init(&tname);
1401 
          if (oldmangled == NULL)
1402 
            {
1403 
              oldmangled = *mangled;
1404 
            }
1405 
          success = demangle_template (work, mangled, &tname,
1406 
                                       &trawname, 1, 1);
1407 
          if (success)
1408 
            {
1409 
              remember_type (work, oldmangled, *mangled - oldmangled);
1410 
            }
1411 
          string_append (&tname, SCOPE_STRING (work));
1412 
 
1413 
          string_prepends(declp, &tname);
1414 
          if (work -> destructor & 1)
1415 
            {
1416 
              string_prepend (&trawname, "~");
1417 
              string_appends (declp, &trawname);
1418 
              work->destructor -= 1;
1419 
            }
1420 
          if ((work->constructor & 1) || (work->destructor & 1))
1421 
            {
1422 
              string_appends (declp, &trawname);
1423 
              work->constructor -= 1;
1424 
            }
1425 
          string_delete(&trawname);
1426 
          string_delete(&tname);
1427 
          oldmangled = NULL;
1428 
          expect_func = 1;
1429 
          break;
1430 
 
1431 
        case '_':
1432 
          if ((AUTO_DEMANGLING || GNU_DEMANGLING) && expect_return_type)
1433 
            {
1434 
              /* Read the return type. */
1435 
              string return_type;
1436 
 
1437 
              (*mangled)++;
1438 
              success = do_type (work, mangled, &return_type);
1439 
              APPEND_BLANK (&return_type);
1440 
 
1441 
              string_prepends (declp, &return_type);
1442 
              string_delete (&return_type);
1443 
              break;
1444 
            }
1445 
          else
1446 
            /* At the outermost level, we cannot have a return type specified,
1447 
               so if we run into another '_' at this point we are dealing with
1448 
               a mangled name that is either bogus, or has been mangled by
1449 
               some algorithm we don't know how to deal with.  So just
1450 
               reject the entire demangling.  */
1451 
            /* However, "_nnn" is an expected suffix for alternate entry point
1452 
               numbered nnn for a function, with HP aCC, so skip over that
1453 
               without reporting failure. pai/1997-09-04 */
1454 
            if (HP_DEMANGLING)
1455 
              {
1456 
                (*mangled)++;
1457 
                while (**mangled && ISDIGIT ((unsigned char)**mangled))
1458 
                  (*mangled)++;
1459 
              }
1460 
            else
1461 
              success = 0;
1462 
          break;
1463 
 
1464 
        case 'H':
1465 
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
1466 
            {
1467 
              /* A G++ template function.  Read the template arguments. */
1468 
              success = demangle_template (work, mangled, declp, 0, 0,
1469 
                                           0);
1470 
              if (!(work->constructor & 1))
1471 
                expect_return_type = 1;
1472 
              (*mangled)++;
1473 
              break;
1474 
            }
1475 
          else
1476 
            /* fall through */
1477 
            {;}
1478 
 
1479 
        default:
1480 
          if (AUTO_DEMANGLING || GNU_DEMANGLING)
1481 
            {
1482 
              /* Assume we have stumbled onto the first outermost function
1483 
                 argument token, and start processing args.  */
1484 
              func_done = 1;
1485 
              success = demangle_args (work, mangled, declp);
1486 
            }
1487 
          else
1488 
            {
1489 
              /* Non-GNU demanglers use a specific token to mark the start
1490 
                 of the outermost function argument tokens.  Typically 'F',
1491 
                 for ARM/HP-demangling, for example.  So if we find something
1492 
                 we are not prepared for, it must be an error.  */
1493 
              success = 0;
1494 
            }
1495 
          break;
1496 
        }
1497 
      /*
1498 
        if (AUTO_DEMANGLING || GNU_DEMANGLING)
1499 
        */
1500 
      {
1501 
        if (success && expect_func)
1502 
          {
1503 
            func_done = 1;
1504 
              if (LUCID_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING)
1505 
                {
1506 
                  forget_types (work);
1507 
                }
1508 
            success = demangle_args (work, mangled, declp);
1509 
            /* Since template include the mangling of their return types,
1510 
               we must set expect_func to 0 so that we don't try do
1511 
               demangle more arguments the next time we get here.  */
1512 
            expect_func = 0;
1513 
          }
1514 
      }
1515 
    }
1516 
  if (success && !func_done)
1517 
    {
1518 
      if (AUTO_DEMANGLING || GNU_DEMANGLING)
1519 
        {
1520 
          /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and
1521 
             bar__3fooi is 'foo::bar(int)'.  We get here when we find the
1522 
             first case, and need to ensure that the '(void)' gets added to
1523 
             the current declp.  Note that with ARM/HP, the first case
1524 
             represents the name of a static data member 'foo::bar',
1525 
             which is in the current declp, so we leave it alone.  */
1526 
          success = demangle_args (work, mangled, declp);
1527 
        }
1528 
    }
1529 
  if (success && PRINT_ARG_TYPES)
1530 
    {
1531 
      if (work->static_type)
1532 
        string_append (declp, " static");
1533 
      if (work->type_quals != TYPE_UNQUALIFIED)
1534 
        {
1535 
          APPEND_BLANK (declp);
1536 
          string_append (declp, qualifier_string (work->type_quals));
1537 
        }
1538 
    }
1539 
 
1540 
  return (success);
1541 
}
1542 
 
1543 
#if 0
1544 
 
1545 
static int
1546 
demangle_method_args (struct work_stuff *work, const char **mangled,
1547 
                      string *declp)
1548 
{
1549 
  int success = 0;
1550 
 
1551 
  if (work -> static_type)
1552 
    {
1553 
      string_append (declp, *mangled + 1);
1554 
      *mangled += strlen (*mangled);
1555 
      success = 1;
1556 
    }
1557 
  else
1558 
    {
1559 
      success = demangle_args (work, mangled, declp);
1560 
    }
1561 
  return (success);
1562 
}
1563 
 
1564 
#endif
1565 
 
1566 
static int
1567 
demangle_template_template_parm (struct work_stuff *work,
1568 
                                 const char **mangled, string *tname)
1569 
{
1570 
  int i;
1571 
  int r;
1572 
  int need_comma = 0;
1573 
  int success = 1;
1574 
  string temp;
1575 
 
1576 
  string_append (tname, "template <");
1577 
  /* get size of template parameter list */
1578 
  if (get_count (mangled, &r))
1579 
    {
1580 
      for (i = 0; i < r; i++)
1581 
        {
1582 
          if (need_comma)
1583 
            {
1584 
              string_append (tname, ", ");
1585 
            }
1586 
 
1587 
            /* Z for type parameters */
1588 
            if (**mangled == 'Z')
1589 
              {
1590 
                (*mangled)++;
1591 
                string_append (tname, "class");
1592 
              }
1593 
              /* z for template parameters */
1594 
            else if (**mangled == 'z')
1595 
              {
1596 
                (*mangled)++;
1597 
                success =
1598 
                  demangle_template_template_parm (work, mangled, tname);
1599 
                if (!success)
1600 
                  {
1601 
                    break;
1602 
                  }
1603 
              }
1604 
            else
1605 
              {
1606 
                /* temp is initialized in do_type */
1607 
                success = do_type (work, mangled, &temp);
1608 
                if (success)
1609 
                  {
1610 
                    string_appends (tname, &temp);
1611 
                  }
1612 
                string_delete(&temp);
1613 
                if (!success)
1614 
                  {
1615 
                    break;
1616 
                  }
1617 
              }
1618 
          need_comma = 1;
1619 
        }
1620 
 
1621 
    }
1622 
  if (tname->p[-1] == '>')
1623 
    string_append (tname, " ");
1624 
  string_append (tname, "> class");
1625 
  return (success);
1626 
}
1627 
 
1628 
static int
1629 
demangle_expression (struct work_stuff *work, const char **mangled,
1630 
                     string *s, type_kind_t tk)
1631 
{
1632 
  int need_operator = 0;
1633 
  int success;
1634 
 
1635 
  success = 1;
1636 
  string_appendn (s, "(", 1);
1637 
  (*mangled)++;
1638 
  while (success && **mangled != 'W' && **mangled != '\0')
1639 
    {
1640 
      if (need_operator)
1641 
        {
1642 
          size_t i;
1643 
          size_t len;
1644 
 
1645 
          success = 0;
1646 
 
1647 
          len = strlen (*mangled);
1648 
 
1649 
          for (i = 0; i < ARRAY_SIZE (optable); ++i)
1650 
            {
1651 
              size_t l = strlen (optable[i].in);
1652 
 
1653 
              if (l <= len
1654 
                  && memcmp (optable[i].in, *mangled, l) == 0)
1655 
                {
1656 
                  string_appendn (s, " ", 1);
1657 
                  string_append (s, optable[i].out);
1658 
                  string_appendn (s, " ", 1);
1659 
                  success = 1;
1660 
                  (*mangled) += l;
1661 
                  break;
1662 
                }
1663 
            }
1664 
 
1665 
          if (!success)
1666 
            break;
1667 
        }
1668 
      else
1669 
        need_operator = 1;
1670 
 
1671 
      success = demangle_template_value_parm (work, mangled, s, tk);
1672 
    }
1673 
 
1674 
  if (**mangled != 'W')
1675 
    success = 0;
1676 
  else
1677 
    {
1678 
      string_appendn (s, ")", 1);
1679 
      (*mangled)++;
1680 
    }
1681 
 
1682 
  return success;
1683 
}
1684 
 
1685 
static int
1686 
demangle_integral_value (struct work_stuff *work,
1687 
                         const char **mangled, string *s)
1688 
{
1689 
  int success;
1690 
 
1691 
  if (**mangled == 'E')
1692 
    success = demangle_expression (work, mangled, s, tk_integral);
1693 
  else if (**mangled == 'Q' || **mangled == 'K')
1694 
    success = demangle_qualified (work, mangled, s, 0, 1);
1695 
  else
1696 
    {
1697 
      int value;
1698 
 
1699 
      /* By default, we let the number decide whether we shall consume an
1700 
         underscore.  */
1701 
      int multidigit_without_leading_underscore = 0;
1702 
      int leave_following_underscore = 0;
1703 
 
1704 
      success = 0;
1705 
 
1706 
      if (**mangled == '_')
1707 
        {
1708 
          if (mangled[0][1] == 'm')
1709 
            {
1710 
              /* Since consume_count_with_underscores does not handle the
1711 
                 `m'-prefix we must do it here, using consume_count and
1712 
                 adjusting underscores: we have to consume the underscore
1713 
                 matching the prepended one.  */
1714 
              multidigit_without_leading_underscore = 1;
1715 
              string_appendn (s, "-", 1);
1716 
              (*mangled) += 2;
1717 
            }
1718 
          else
1719 
            {
1720 
              /* Do not consume a following underscore;
1721 
                 consume_count_with_underscores will consume what
1722 
                 should be consumed.  */
1723 
              leave_following_underscore = 1;
1724 
            }
1725 
        }
1726 
      else
1727 
        {
1728 
          /* Negative numbers are indicated with a leading `m'.  */
1729 
          if (**mangled == 'm')
1730 
          {
1731 
            string_appendn (s, "-", 1);
1732 
            (*mangled)++;
1733 
          }
1734 
          /* Since consume_count_with_underscores does not handle
1735 
             multi-digit numbers that do not start with an underscore,
1736 
             and this number can be an integer template parameter,
1737 
             we have to call consume_count. */
1738 
          multidigit_without_leading_underscore = 1;
1739 
          /* These multi-digit numbers never end on an underscore,
1740 
             so if there is one then don't eat it. */
1741 
          leave_following_underscore = 1;
1742 
        }
1743 
 
1744 
      /* We must call consume_count if we expect to remove a trailing
1745 
         underscore, since consume_count_with_underscores expects
1746 
         the leading underscore (that we consumed) if it is to handle
1747 
         multi-digit numbers.  */
1748 
      if (multidigit_without_leading_underscore)
1749 
        value = consume_count (mangled);
1750 
      else
1751 
        value = consume_count_with_underscores (mangled);
1752 
 
1753 
      if (value != -1)
1754 
        {
1755 
          char buf[INTBUF_SIZE];
1756 
          sprintf (buf, "%d", value);
1757 
          string_append (s, buf);
1758 
 
1759 
          /* Numbers not otherwise delimited, might have an underscore
1760 
             appended as a delimeter, which we should skip.
1761 
 
1762 
             ??? This used to always remove a following underscore, which
1763 
             is wrong.  If other (arbitrary) cases are followed by an
1764 
             underscore, we need to do something more radical.  */
1765 
 
1766 
          if ((value > 9 || multidigit_without_leading_underscore)
1767 
              && ! leave_following_underscore
1768 
              && **mangled == '_')
1769 
            (*mangled)++;
1770 
 
1771 
          /* All is well.  */
1772 
          success = 1;
1773 
        }
1774 
      }
1775 
 
1776 
  return success;
1777 
}
1778 
 
1779 
/* Demangle the real value in MANGLED.  */
1780 
 
1781 
static int
1782 
demangle_real_value (struct work_stuff *work,
1783 
                     const char **mangled, string *s)
1784 
{
1785 
  if (**mangled == 'E')
1786 
    return demangle_expression (work, mangled, s, tk_real);
1787 
 
1788 
  if (**mangled == 'm')
1789 
    {
1790 
      string_appendn (s, "-", 1);
1791 
      (*mangled)++;
1792 
    }
1793 
  while (ISDIGIT ((unsigned char)**mangled))
1794 
    {
1795 
      string_appendn (s, *mangled, 1);
1796 
      (*mangled)++;
1797 
    }
1798 
  if (**mangled == '.') /* fraction */
1799 
    {
1800 
      string_appendn (s, ".", 1);
1801 
      (*mangled)++;
1802 
      while (ISDIGIT ((unsigned char)**mangled))
1803 
        {
1804 
          string_appendn (s, *mangled, 1);
1805 
          (*mangled)++;
1806 
        }
1807 
    }
1808 
  if (**mangled == 'e') /* exponent */
1809 
    {
1810 
      string_appendn (s, "e", 1);
1811 
      (*mangled)++;
1812 
      while (ISDIGIT ((unsigned char)**mangled))
1813 
        {
1814 
          string_appendn (s, *mangled, 1);
1815 
          (*mangled)++;
1816 
        }
1817 
    }
1818 
 
1819 
  return 1;
1820 
}
1821 
 
1822 
static int
1823 
demangle_template_value_parm (struct work_stuff *work, const char **mangled,
1824 
                              string *s, type_kind_t tk)
1825 
{
1826 
  int success = 1;
1827 
 
1828 
  if (**mangled == 'Y')
1829 
    {
1830 
      /* The next argument is a template parameter. */
1831 
      int idx;
1832 
 
1833 
      (*mangled)++;
1834 
      idx = consume_count_with_underscores (mangled);
1835 
      if (idx == -1
1836 
          || (work->tmpl_argvec && idx >= work->ntmpl_args)
1837 
          || consume_count_with_underscores (mangled) == -1)
1838 
        return -1;
1839 
      if (work->tmpl_argvec)
1840 
        string_append (s, work->tmpl_argvec[idx]);
1841 
      else
1842 
        string_append_template_idx (s, idx);
1843 
    }
1844 
  else if (tk == tk_integral)
1845 
    success = demangle_integral_value (work, mangled, s);
1846 
  else if (tk == tk_char)
1847 
    {
1848 
      char tmp[2];
1849 
      int val;
1850 
      if (**mangled == 'm')
1851 
        {
1852 
          string_appendn (s, "-", 1);
1853 
          (*mangled)++;
1854 
        }
1855 
      string_appendn (s, "'", 1);
1856 
      val = consume_count(mangled);
1857 
      if (val <= 0)
1858 
        success = 0;
1859 
      else
1860 
        {
1861 
          tmp[0] = (char)val;
1862 
          tmp[1] = '\0';
1863 
          string_appendn (s, &tmp[0], 1);
1864 
          string_appendn (s, "'", 1);
1865 
        }
1866 
    }
1867 
  else if (tk == tk_bool)
1868 
    {
1869 
      int val = consume_count (mangled);
1870 
      if (val == 0)
1871 
        string_appendn (s, "false", 5);
1872 
      else if (val == 1)
1873 
        string_appendn (s, "true", 4);
1874 
      else
1875 
        success = 0;
1876 
    }
1877 
  else if (tk == tk_real)
1878 
    success = demangle_real_value (work, mangled, s);
1879 
  else if (tk == tk_pointer || tk == tk_reference)
1880 
    {
1881 
      if (**mangled == 'Q')
1882 
        success = demangle_qualified (work, mangled, s,
1883 
                                      /*isfuncname=*/0,
1884 
                                      /*append=*/1);
1885 
      else
1886 
        {
1887 
          int symbol_len  = consume_count (mangled);
1888 
          if (symbol_len == -1)
1889 
            return -1;
1890 
          if (symbol_len == 0)
1891 
            string_appendn (s, "0", 1);
1892 
          else
1893 
            {
1894 
              char *p = XNEWVEC (char, symbol_len + 1), *q;
1895 
              strncpy (p, *mangled, symbol_len);
1896 
              p [symbol_len] = '\0';
1897 
              /* We use cplus_demangle here, rather than
1898 
                 internal_cplus_demangle, because the name of the entity
1899 
                 mangled here does not make use of any of the squangling
1900 
                 or type-code information we have built up thus far; it is
1901 
                 mangled independently.  */
1902 
              q = cplus_demangle (p, work->options);
1903 
              if (tk == tk_pointer)
1904 
                string_appendn (s, "&", 1);
1905 
              /* FIXME: Pointer-to-member constants should get a
1906 
                 qualifying class name here.  */
1907 
              if (q)
1908 
                {
1909 
                  string_append (s, q);
1910 
                  free (q);
1911 
                }
1912 
              else
1913 
                string_append (s, p);
1914 
              free (p);
1915 
            }
1916 
          *mangled += symbol_len;
1917 
        }
1918 
    }
1919 
 
1920 
  return success;
1921 
}
1922 
 
1923 
/* Demangle the template name in MANGLED.  The full name of the
1924 
   template (e.g., S<int>) is placed in TNAME.  The name without the
1925 
   template parameters (e.g. S) is placed in TRAWNAME if TRAWNAME is
1926 
   non-NULL.  If IS_TYPE is nonzero, this template is a type template,
1927 
   not a function template.  If both IS_TYPE and REMEMBER are nonzero,
1928 
   the template is remembered in the list of back-referenceable
1929 
   types.  */
1930 
 
1931 
static int
1932 
demangle_template (struct work_stuff *work, const char **mangled,
1933 
                   string *tname, string *trawname,
1934 
                   int is_type, int remember)
1935 
{
1936 
  int i;
1937 
  int r;
1938 
  int need_comma = 0;
1939 
  int success = 0;
1940 
  int is_java_array = 0;
1941 
  string temp;
1942 
 
1943 
  (*mangled)++;
1944 
  if (is_type)
1945 
    {
1946 
      /* get template name */
1947 
      if (**mangled == 'z')
1948 
        {
1949 
          int idx;
1950 
          (*mangled)++;
1951 
          (*mangled)++;
1952 
 
1953 
          idx = consume_count_with_underscores (mangled);
1954 
          if (idx == -1
1955 
              || (work->tmpl_argvec && idx >= work->ntmpl_args)
1956 
              || consume_count_with_underscores (mangled) == -1)
1957 
            return (0);
1958 
 
1959 
          if (work->tmpl_argvec)
1960 
            {
1961 
              string_append (tname, work->tmpl_argvec[idx]);
1962 
              if (trawname)
1963 
                string_append (trawname, work->tmpl_argvec[idx]);
1964 
            }
1965 
          else
1966 
            {
1967 
              string_append_template_idx (tname, idx);
1968 
              if (trawname)
1969 
                string_append_template_idx (trawname, idx);
1970 
            }
1971 
        }
1972 
      else
1973 
        {
1974 
          if ((r = consume_count (mangled)) <= 0
1975 
              || (int) strlen (*mangled) < r)
1976 
            {
1977 
              return (0);
1978 
            }
1979 
          is_java_array = (work -> options & DMGL_JAVA)
1980 
            && strncmp (*mangled, "JArray1Z", 8) == 0;
1981 
          if (! is_java_array)
1982 
            {
1983 
              string_appendn (tname, *mangled, r);
1984 
            }
1985 
          if (trawname)
1986 
            string_appendn (trawname, *mangled, r);
1987 
          *mangled += r;
1988 
        }
1989 
    }
1990 
  if (!is_java_array)
1991 
    string_append (tname, "<");
1992 
  /* get size of template parameter list */
1993 
  if (!get_count (mangled, &r))
1994 
    {
1995 
      return (0);
1996 
    }
1997 
  if (!is_type)
1998 
    {
1999 
      /* Create an array for saving the template argument values. */
2000 
      work->tmpl_argvec = XNEWVEC (char *, r);
2001 
      work->ntmpl_args = r;
2002 
      for (i = 0; i < r; i++)
2003 
        work->tmpl_argvec[i] = 0;
2004 
    }
2005 
  for (i = 0; i < r; i++)
2006 
    {
2007 
      if (need_comma)
2008 
        {
2009 
          string_append (tname, ", ");
2010 
        }
2011 
      /* Z for type parameters */
2012 
      if (**mangled == 'Z')
2013 
        {
2014 
          (*mangled)++;
2015 
          /* temp is initialized in do_type */
2016 
          success = do_type (work, mangled, &temp);
2017 
          if (success)
2018 
            {
2019 
              string_appends (tname, &temp);
2020 
 
2021 
              if (!is_type)
2022 
                {
2023 
                  /* Save the template argument. */
2024 
                  int len = temp.p - temp.b;
2025 
                  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2026 
                  memcpy (work->tmpl_argvec[i], temp.b, len);
2027 
                  work->tmpl_argvec[i][len] = '\0';
2028 
                }
2029 
            }
2030 
          string_delete(&temp);
2031 
          if (!success)
2032 
            {
2033 
              break;
2034 
            }
2035 
        }
2036 
      /* z for template parameters */
2037 
      else if (**mangled == 'z')
2038 
        {
2039 
          int r2;
2040 
          (*mangled)++;
2041 
          success = demangle_template_template_parm (work, mangled, tname);
2042 
 
2043 
          if (success
2044 
              && (r2 = consume_count (mangled)) > 0
2045 
              && (int) strlen (*mangled) >= r2)
2046 
            {
2047 
              string_append (tname, " ");
2048 
              string_appendn (tname, *mangled, r2);
2049 
              if (!is_type)
2050 
                {
2051 
                  /* Save the template argument. */
2052 
                  int len = r2;
2053 
                  work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2054 
                  memcpy (work->tmpl_argvec[i], *mangled, len);
2055 
                  work->tmpl_argvec[i][len] = '\0';
2056 
                }
2057 
              *mangled += r2;
2058 
            }
2059 
          if (!success)
2060 
            {
2061 
              break;
2062 
            }
2063 
        }
2064 
      else
2065 
        {
2066 
          string  param;
2067 
          string* s;
2068 
 
2069 
          /* otherwise, value parameter */
2070 
 
2071 
          /* temp is initialized in do_type */
2072 
          success = do_type (work, mangled, &temp);
2073 
          string_delete(&temp);
2074 
          if (!success)
2075 
            break;
2076 
 
2077 
          if (!is_type)
2078 
            {
2079 
              s = &param;
2080 
              string_init (s);
2081 
            }
2082 
          else
2083 
            s = tname;
2084 
 
2085 
          success = demangle_template_value_parm (work, mangled, s,
2086 
                                                  (type_kind_t) success);
2087 
 
2088 
          if (!success)
2089 
            {
2090 
              if (!is_type)
2091 
                string_delete (s);
2092 
              success = 0;
2093 
              break;
2094 
            }
2095 
 
2096 
          if (!is_type)
2097 
            {
2098 
              int len = s->p - s->b;
2099 
              work->tmpl_argvec[i] = XNEWVEC (char, len + 1);
2100 
              memcpy (work->tmpl_argvec[i], s->b, len);
2101 
              work->tmpl_argvec[i][len] = '\0';
2102 
 
2103 
              string_appends (tname, s);
2104 
              string_delete (s);
2105 
            }
2106 
        }
2107 
      need_comma = 1;
2108 
    }
2109 
  if (is_java_array)
2110 
    {
2111 
      string_append (tname, "[]");
2112 
    }
2113 
  else
2114 
    {
2115 
      if (tname->p[-1] == '>')
2116 
        string_append (tname, " ");
2117 
      string_append (tname, ">");
2118 
    }
2119 
 
2120 
  if (is_type && remember)
2121 
    {
2122 
      const int bindex = register_Btype (work);
2123 
      remember_Btype (work, tname->b, LEN_STRING (tname), bindex);
2124 
    }
2125 
 
2126 
  /*
2127 
    if (work -> static_type)
2128 
    {
2129 
    string_append (declp, *mangled + 1);
2130 
    *mangled += strlen (*mangled);
2131 
    success = 1;
2132 
    }
2133 
    else
2134 
    {
2135 
    success = demangle_args (work, mangled, declp);
2136 
    }
2137 
    }
2138 
    */
2139 
  return (success);
2140 
}
2141 
 
2142 
static int
2143 
arm_pt (struct work_stuff *work, const char *mangled,
2144 
        int n, const char **anchor, const char **args)
2145 
{
2146 
  /* Check if ARM template with "__pt__" in it ("parameterized type") */
2147 
  /* Allow HP also here, because HP's cfront compiler follows ARM to some extent */
2148 
  if ((ARM_DEMANGLING || HP_DEMANGLING) && (*anchor = strstr (mangled, "__pt__")))
2149 
    {
2150 
      int len;
2151 
      *args = *anchor + 6;
2152 
      len = consume_count (args);
2153 
      if (len == -1)
2154 
        return 0;
2155 
      if (*args + len == mangled + n && **args == '_')
2156 
        {
2157 
          ++*args;
2158 
          return 1;
2159 
        }
2160 
    }
2161 
  if (AUTO_DEMANGLING || EDG_DEMANGLING)
2162 
    {
2163 
      if ((*anchor = strstr (mangled, "__tm__"))
2164 
          || (*anchor = strstr (mangled, "__ps__"))
2165 
          || (*anchor = strstr (mangled, "__pt__")))
2166 
        {
2167 
          int len;
2168 
          *args = *anchor + 6;
2169 
          len = consume_count (args);
2170 
          if (len == -1)
2171 
            return 0;
2172 
          if (*args + len == mangled + n && **args == '_')
2173 
            {
2174 
              ++*args;
2175 
              return 1;
2176 
            }
2177 
        }
2178 
      else if ((*anchor = strstr (mangled, "__S")))
2179 
        {
2180 
          int len;
2181 
          *args = *anchor + 3;
2182 
          len = consume_count (args);
2183 
          if (len == -1)
2184 
            return 0;
2185 
          if (*args + len == mangled + n && **args == '_')
2186 
            {
2187 
              ++*args;
2188 
              return 1;
2189 
            }
2190 
        }
2191 
    }
2192 
 
2193 
  return 0;
2194 
}
2195 
 
2196 
static void
2197 
demangle_arm_hp_template (struct work_stuff *work, const char **mangled,
2198 
                          int n, string *declp)
2199 
{
2200 
  const char *p;
2201 
  const char *args;
2202 
  const char *e = *mangled + n;
2203 
  string arg;
2204 
 
2205 
  /* Check for HP aCC template spec: classXt1t2 where t1, t2 are
2206 
     template args */
2207 
  if (HP_DEMANGLING && ((*mangled)[n] == 'X'))
2208 
    {
2209 
      char *start_spec_args = NULL;
2210 
      int hold_options;
2211 
 
2212 
      /* First check for and omit template specialization pseudo-arguments,
2213 
         such as in "Spec<#1,#1.*>" */
2214 
      start_spec_args = strchr (*mangled, '<');
2215 
      if (start_spec_args && (start_spec_args - *mangled < n))
2216 
        string_appendn (declp, *mangled, start_spec_args - *mangled);
2217 
      else
2218 
        string_appendn (declp, *mangled, n);
2219 
      (*mangled) += n + 1;
2220 
      string_init (&arg);
2221 
      if (work->temp_start == -1) /* non-recursive call */
2222 
        work->temp_start = declp->p - declp->b;
2223 
 
2224 
      /* We want to unconditionally demangle parameter types in
2225 
         template parameters.  */
2226 
      hold_options = work->options;
2227 
      work->options |= DMGL_PARAMS;
2228 
 
2229 
      string_append (declp, "<");
2230 
      while (1)
2231 
        {
2232 
          string_delete (&arg);
2233 
          switch (**mangled)
2234 
            {
2235 
              case 'T':
2236 
                /* 'T' signals a type parameter */
2237 
                (*mangled)++;
2238 
                if (!do_type (work, mangled, &arg))
2239 
                  goto hpacc_template_args_done;
2240 
                break;
2241 
 
2242 
              case 'U':
2243 
              case 'S':
2244 
                /* 'U' or 'S' signals an integral value */
2245 
                if (!do_hpacc_template_const_value (work, mangled, &arg))
2246 
                  goto hpacc_template_args_done;
2247 
                break;
2248 
 
2249 
              case 'A':
2250 
                /* 'A' signals a named constant expression (literal) */
2251 
                if (!do_hpacc_template_literal (work, mangled, &arg))
2252 
                  goto hpacc_template_args_done;
2253 
                break;
2254 
 
2255 
              default:
2256 
                /* Today, 1997-09-03, we have only the above types
2257 
                   of template parameters */
2258 
                /* FIXME: maybe this should fail and return null */
2259 
                goto hpacc_template_args_done;
2260 
            }
2261 
          string_appends (declp, &arg);
2262 
         /* Check if we're at the end of template args.
2263 
 
2264 
             _ if done with template args for a function */
2265 
          if ((**mangled == '\000') || (**mangled == '_'))
2266 
            break;
2267 
          else
2268 
            string_append (declp, ",");
2269 
        }
2270 
    hpacc_template_args_done:
2271 
      string_append (declp, ">");
2272 
      string_delete (&arg);
2273 
      if (**mangled == '_')
2274 
        (*mangled)++;
2275 
      work->options = hold_options;
2276 
      return;
2277 
    }
2278 
  /* ARM template? (Also handles HP cfront extensions) */
2279 
  else if (arm_pt (work, *mangled, n, &p, &args))
2280 
    {
2281 
      int hold_options;
2282 
      string type_str;
2283 
 
2284 
      string_init (&arg);
2285 
      string_appendn (declp, *mangled, p - *mangled);
2286 
      if (work->temp_start == -1)  /* non-recursive call */
2287 
        work->temp_start = declp->p - declp->b;
2288 
 
2289 
      /* We want to unconditionally demangle parameter types in
2290 
         template parameters.  */
2291 
      hold_options = work->options;
2292 
      work->options |= DMGL_PARAMS;
2293 
 
2294 
      string_append (declp, "<");
2295 
      /* should do error checking here */
2296 
      while (args < e) {
2297 
        string_delete (&arg);
2298 
 
2299 
        /* Check for type or literal here */
2300 
        switch (*args)
2301 
          {
2302 
            /* HP cfront extensions to ARM for template args */
2303 
            /* spec: Xt1Lv1 where t1 is a type, v1 is a literal value */
2304 
            /* FIXME: We handle only numeric literals for HP cfront */
2305 
          case 'X':
2306 
            /* A typed constant value follows */
2307 
            args++;
2308 
            if (!do_type (work, &args, &type_str))
2309 
              goto cfront_template_args_done;
2310 
            string_append (&arg, "(");
2311 
            string_appends (&arg, &type_str);
2312 
            string_delete (&type_str);
2313 
            string_append (&arg, ")");
2314 
            if (*args != 'L')
2315 
              goto cfront_template_args_done;
2316 
            args++;
2317 
            /* Now snarf a literal value following 'L' */
2318 
            if (!snarf_numeric_literal (&args, &arg))
2319 
              goto cfront_template_args_done;
2320 
            break;
2321 
 
2322 
          case 'L':
2323 
            /* Snarf a literal following 'L' */
2324 
            args++;
2325 
            if (!snarf_numeric_literal (&args, &arg))
2326 
              goto cfront_template_args_done;
2327 
            break;
2328 
          default:
2329 
            /* Not handling other HP cfront stuff */
2330 
            {
2331 
              const char* old_args = args;
2332 
              if (!do_type (work, &args, &arg))
2333 
                goto cfront_template_args_done;
2334 
 
2335 
              /* Fail if we didn't make any progress: prevent infinite loop. */
2336 
              if (args == old_args)
2337 
                {
2338 
                  work->options = hold_options;
2339 
                  return;
2340 
                }
2341 
            }
2342 
          }
2343 
        string_appends (declp, &arg);
2344 
        string_append (declp, ",");
2345 
      }
2346 
    cfront_template_args_done:
2347 
      string_delete (&arg);
2348 
      if (args >= e)
2349 
        --declp->p; /* remove extra comma */
2350 
      string_append (declp, ">");
2351 
      work->options = hold_options;
2352 
    }
2353 
  else if (n>10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2354 
           && (*mangled)[9] == 'N'
2355 
           && (*mangled)[8] == (*mangled)[10]
2356 
           && strchr (cplus_markers, (*mangled)[8]))
2357 
    {
2358 
      /* A member of the anonymous namespace.  */
2359 
      string_append (declp, "{anonymous}");
2360 
    }
2361 
  else
2362 
    {
2363 
      if (work->temp_start == -1) /* non-recursive call only */
2364 
        work->temp_start = 0;     /* disable in recursive calls */
2365 
      string_appendn (declp, *mangled, n);
2366 
    }
2367 
  *mangled += n;
2368 
}
2369 
 
2370 
/* Extract a class name, possibly a template with arguments, from the
2371 
   mangled string; qualifiers, local class indicators, etc. have
2372 
   already been dealt with */
2373 
 
2374 
static int
2375 
demangle_class_name (struct work_stuff *work, const char **mangled,
2376 
                     string *declp)
2377 
{
2378 
  int n;
2379 
  int success = 0;
2380 
 
2381 
  n = consume_count (mangled);
2382 
  if (n == -1)
2383 
    return 0;
2384 
  if ((int) strlen (*mangled) >= n)
2385 
    {
2386 
      demangle_arm_hp_template (work, mangled, n, declp);
2387 
      success = 1;
2388 
    }
2389 
 
2390 
  return (success);
2391 
}
2392 
 
2393 
/*
2394 
 
2395 
LOCAL FUNCTION
2396 
 
2397 
        demangle_class -- demangle a mangled class sequence
2398 
 
2399 
SYNOPSIS
2400 
 
2401 
        static int
2402 
        demangle_class (struct work_stuff *work, const char **mangled,
2403 
                        strint *declp)
2404 
 
2405 
DESCRIPTION
2406 
 
2407 
        DECLP points to the buffer into which demangling is being done.
2408 
 
2409 
        *MANGLED points to the current token to be demangled.  On input,
2410 
        it points to a mangled class (I.E. "3foo", "13verylongclass", etc.)
2411 
        On exit, it points to the next token after the mangled class on
2412 
        success, or the first unconsumed token on failure.
2413 
 
2414 
        If the CONSTRUCTOR or DESTRUCTOR flags are set in WORK, then
2415 
        we are demangling a constructor or destructor.  In this case
2416 
        we prepend "class::class" or "class::~class" to DECLP.
2417 
 
2418 
        Otherwise, we prepend "class::" to the current DECLP.
2419 
 
2420 
        Reset the constructor/destructor flags once they have been
2421 
        "consumed".  This allows demangle_class to be called later during
2422 
        the same demangling, to do normal class demangling.
2423 
 
2424 
        Returns 1 if demangling is successful, 0 otherwise.
2425 
 
2426 
*/
2427 
 
2428 
static int
2429 
demangle_class (struct work_stuff *work, const char **mangled, string *declp)
2430 
{
2431 
  int success = 0;
2432 
  int btype;
2433 
  string class_name;
2434 
  char *save_class_name_end = 0;
2435 
 
2436 
  string_init (&class_name);
2437 
  btype = register_Btype (work);
2438 
  if (demangle_class_name (work, mangled, &class_name))
2439 
    {
2440 
      save_class_name_end = class_name.p;
2441 
      if ((work->constructor & 1) || (work->destructor & 1))
2442 
        {
2443 
          /* adjust so we don't include template args */
2444 
          if (work->temp_start && (work->temp_start != -1))
2445 
            {
2446 
              class_name.p = class_name.b + work->temp_start;
2447 
            }
2448 
          string_prepends (declp, &class_name);
2449 
          if (work -> destructor & 1)
2450 
            {
2451 
              string_prepend (declp, "~");
2452 
              work -> destructor -= 1;
2453 
            }
2454 
          else
2455 
            {
2456 
              work -> constructor -= 1;
2457 
            }
2458 
        }
2459 
      class_name.p = save_class_name_end;
2460 
      remember_Ktype (work, class_name.b, LEN_STRING(&class_name));
2461 
      remember_Btype (work, class_name.b, LEN_STRING(&class_name), btype);
2462 
      string_prepend (declp, SCOPE_STRING (work));
2463 
      string_prepends (declp, &class_name);
2464 
      success = 1;
2465 
    }
2466 
  string_delete (&class_name);
2467 
  return (success);
2468 
}
2469 
 
2470 
 
2471 
/* Called when there's a "__" in the mangled name, with `scan' pointing to
2472 
   the rightmost guess.
2473 
 
2474 
   Find the correct "__"-sequence where the function name ends and the
2475 
   signature starts, which is ambiguous with GNU mangling.
2476 
   Call demangle_signature here, so we can make sure we found the right
2477 
   one; *mangled will be consumed so caller will not make further calls to
2478 
   demangle_signature.  */
2479 
 
2480 
static int
2481 
iterate_demangle_function (struct work_stuff *work, const char **mangled,
2482 
                           string *declp, const char *scan)
2483 
{
2484 
  const char *mangle_init = *mangled;
2485 
  int success = 0;
2486 
  string decl_init;
2487 
  struct work_stuff work_init;
2488 
 
2489 
  if (*(scan + 2) == '\0')
2490 
    return 0;
2491 
 
2492 
  /* Do not iterate for some demangling modes, or if there's only one
2493 
     "__"-sequence.  This is the normal case.  */
2494 
  if (ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING
2495 
      || strstr (scan + 2, "__") == NULL)
2496 
    return demangle_function_name (work, mangled, declp, scan);
2497 
 
2498 
  /* Save state so we can restart if the guess at the correct "__" was
2499 
     wrong.  */
2500 
  string_init (&decl_init);
2501 
  string_appends (&decl_init, declp);
2502 
  memset (&work_init, 0, sizeof work_init);
2503 
  work_stuff_copy_to_from (&work_init, work);
2504 
 
2505 
  /* Iterate over occurrences of __, allowing names and types to have a
2506 
     "__" sequence in them.  We must start with the first (not the last)
2507 
     occurrence, since "__" most often occur between independent mangled
2508 
     parts, hence starting at the last occurence inside a signature
2509 
     might get us a "successful" demangling of the signature.  */
2510 
 
2511 
  while (scan[2])
2512 
    {
2513 
      if (demangle_function_name (work, mangled, declp, scan))
2514 
        {
2515 
          success = demangle_signature (work, mangled, declp);
2516 
          if (success)
2517 
            break;
2518 
        }
2519 
 
2520 
      /* Reset demangle state for the next round.  */
2521 
      *mangled = mangle_init;
2522 
      string_clear (declp);
2523 
      string_appends (declp, &decl_init);
2524 
      work_stuff_copy_to_from (work, &work_init);
2525 
 
2526 
      /* Leave this underscore-sequence.  */
2527 
      scan += 2;
2528 
 
2529 
      /* Scan for the next "__" sequence.  */
2530 
      while (*scan && (scan[0] != '_' || scan[1] != '_'))
2531 
        scan++;
2532 
 
2533 
      /* Move to last "__" in this sequence.  */
2534 
      while (*scan && *scan == '_')
2535 
        scan++;
2536 
      scan -= 2;
2537 
    }
2538 
 
2539 
  /* Delete saved state.  */
2540 
  delete_work_stuff (&work_init);
2541 
  string_delete (&decl_init);
2542 
 
2543 
  return success;
2544 
}
2545 
 
2546 
/*
2547 
 
2548 
LOCAL FUNCTION
2549 
 
2550 
        demangle_prefix -- consume the mangled name prefix and find signature
2551 
 
2552 
SYNOPSIS
2553 
 
2554 
        static int
2555 
        demangle_prefix (struct work_stuff *work, const char **mangled,
2556 
                         string *declp);
2557 
 
2558 
DESCRIPTION
2559 
 
2560 
        Consume and demangle the prefix of the mangled name.
2561 
        While processing the function name root, arrange to call
2562 
        demangle_signature if the root is ambiguous.
2563 
 
2564 
        DECLP points to the string buffer into which demangled output is
2565 
        placed.  On entry, the buffer is empty.  On exit it contains
2566 
        the root function name, the demangled operator name, or in some
2567 
        special cases either nothing or the completely demangled result.
2568 
 
2569 
        MANGLED points to the current pointer into the mangled name.  As each
2570 
        token of the mangled name is consumed, it is updated.  Upon entry
2571 
        the current mangled name pointer points to the first character of
2572 
        the mangled name.  Upon exit, it should point to the first character
2573 
        of the signature if demangling was successful, or to the first
2574 
        unconsumed character if demangling of the prefix was unsuccessful.
2575 
 
2576 
        Returns 1 on success, 0 otherwise.
2577 
 */
2578 
 
2579 
static int
2580 
demangle_prefix (struct work_stuff *work, const char **mangled,
2581 
                 string *declp)
2582 
{
2583 
  int success = 1;
2584 
  const char *scan;
2585 
  int i;
2586 
 
2587 
  if (strlen(*mangled) > 6
2588 
      && (strncmp(*mangled, "_imp__", 6) == 0
2589 
          || strncmp(*mangled, "__imp_", 6) == 0))
2590 
    {
2591 
      /* it's a symbol imported from a PE dynamic library. Check for both
2592 
         new style prefix _imp__ and legacy __imp_ used by older versions
2593 
         of dlltool. */
2594 
      (*mangled) += 6;
2595 
      work->dllimported = 1;
2596 
    }
2597 
  else if (strlen(*mangled) >= 11 && strncmp(*mangled, "_GLOBAL_", 8) == 0)
2598 
    {
2599 
      char *marker = strchr (cplus_markers, (*mangled)[8]);
2600 
      if (marker != NULL && *marker == (*mangled)[10])
2601 
        {
2602 
          if ((*mangled)[9] == 'D')
2603 
            {
2604 
              /* it's a GNU global destructor to be executed at program exit */
2605 
              (*mangled) += 11;
2606 
              work->destructor = 2;
2607 
              if (gnu_special (work, mangled, declp))
2608 
                return success;
2609 
            }
2610 
          else if ((*mangled)[9] == 'I')
2611 
            {
2612 
              /* it's a GNU global constructor to be executed at program init */
2613 
              (*mangled) += 11;
2614 
              work->constructor = 2;
2615 
              if (gnu_special (work, mangled, declp))
2616 
                return success;
2617 
            }
2618 
        }
2619 
    }
2620 
  else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__std__", 7) == 0)
2621 
    {
2622 
      /* it's a ARM global destructor to be executed at program exit */
2623 
      (*mangled) += 7;
2624 
      work->destructor = 2;
2625 
    }
2626 
  else if ((ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING) && strncmp(*mangled, "__sti__", 7) == 0)
2627 
    {
2628 
      /* it's a ARM global constructor to be executed at program initial */
2629 
      (*mangled) += 7;
2630 
      work->constructor = 2;
2631 
    }
2632 
 
2633 
  /*  This block of code is a reduction in strength time optimization
2634 
      of:
2635 
      scan = strstr (*mangled, "__"); */
2636 
 
2637 
  {
2638 
    scan = *mangled;
2639 
 
2640 
    do {
2641 
      scan = strchr (scan, '_');
2642 
    } while (scan != NULL && *++scan != '_');
2643 
 
2644 
    if (scan != NULL) --scan;
2645 
  }
2646 
 
2647 
  if (scan != NULL)
2648 
    {
2649 
      /* We found a sequence of two or more '_', ensure that we start at
2650 
         the last pair in the sequence.  */
2651 
      i = strspn (scan, "_");
2652 
      if (i > 2)
2653 
        {
2654 
          scan += (i - 2);
2655 
        }
2656 
    }
2657 
 
2658 
  if (scan == NULL)
2659 
    {
2660 
      success = 0;
2661 
    }
2662 
  else if (work -> static_type)
2663 
    {
2664 
      if (!ISDIGIT ((unsigned char)scan[0]) && (scan[0] != 't'))
2665 
        {
2666 
          success = 0;
2667 
        }
2668 
    }
2669 
  else if ((scan == *mangled)
2670 
           && (ISDIGIT ((unsigned char)scan[2]) || (scan[2] == 'Q')
2671 
               || (scan[2] == 't') || (scan[2] == 'K') || (scan[2] == 'H')))
2672 
    {
2673 
      /* The ARM says nothing about the mangling of local variables.
2674 
         But cfront mangles local variables by prepending __<nesting_level>
2675 
         to them. As an extension to ARM demangling we handle this case.  */
2676 
      if ((LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING)
2677 
          && ISDIGIT ((unsigned char)scan[2]))
2678 
        {
2679 
          *mangled = scan + 2;
2680 
          consume_count (mangled);
2681 
          string_append (declp, *mangled);
2682 
          *mangled += strlen (*mangled);
2683 
          success = 1;
2684 
        }
2685 
      else
2686 
        {
2687 
          /* A GNU style constructor starts with __[0-9Qt].  But cfront uses
2688 
             names like __Q2_3foo3bar for nested type names.  So don't accept
2689 
             this style of constructor for cfront demangling.  A GNU
2690 
             style member-template constructor starts with 'H'. */
2691 
          if (!(LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING))
2692 
            work -> constructor += 1;
2693 
          *mangled = scan + 2;
2694 
        }
2695 
    }
2696 
  else if (ARM_DEMANGLING && scan[2] == 'p' && scan[3] == 't')
2697 
    {
2698 
      /* Cfront-style parameterized type.  Handled later as a signature. */
2699 
      success = 1;
2700 
 
2701 
      /* ARM template? */
2702 
      demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2703 
    }
2704 
  else if (EDG_DEMANGLING && ((scan[2] == 't' && scan[3] == 'm')
2705 
                              || (scan[2] == 'p' && scan[3] == 's')
2706 
                              || (scan[2] == 'p' && scan[3] == 't')))
2707 
    {
2708 
      /* EDG-style parameterized type.  Handled later as a signature. */
2709 
      success = 1;
2710 
 
2711 
      /* EDG template? */
2712 
      demangle_arm_hp_template (work, mangled, strlen (*mangled), declp);
2713 
    }
2714 
  else if ((scan == *mangled) && !ISDIGIT ((unsigned char)scan[2])
2715 
           && (scan[2] != 't'))
2716 
    {
2717 
      /* Mangled name starts with "__".  Skip over any leading '_' characters,
2718 
         then find the next "__" that separates the prefix from the signature.
2719 
         */
2720 
      if (!(ARM_DEMANGLING || LUCID_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
2721 
          || (arm_special (mangled, declp) == 0))
2722 
        {
2723 
          while (*scan == '_')
2724 
            {
2725 
              scan++;
2726 
            }
2727 
          if ((scan = strstr (scan, "__")) == NULL || (*(scan + 2) == '\0'))
2728 
            {
2729 
              /* No separator (I.E. "__not_mangled"), or empty signature
2730 
                 (I.E. "__not_mangled_either__") */
2731 
              success = 0;
2732 
            }
2733 
          else
2734 
            return iterate_demangle_function (work, mangled, declp, scan);
2735 
        }
2736 
    }
2737 
  else if (*(scan + 2) != '\0')
2738 
    {
2739 
      /* Mangled name does not start with "__" but does have one somewhere
2740 
         in there with non empty stuff after it.  Looks like a global
2741 
         function name.  Iterate over all "__":s until the right
2742 
         one is found.  */
2743 
      return iterate_demangle_function (work, mangled, declp, scan);
2744 
    }
2745 
  else
2746 
    {
2747 
      /* Doesn't look like a mangled name */
2748 
      success = 0;
2749 
    }
2750 
 
2751 
  if (!success && (work->constructor == 2 || work->destructor == 2))
2752 
    {
2753 
      string_append (declp, *mangled);
2754 
      *mangled += strlen (*mangled);
2755 
      success = 1;
2756 
    }
2757 
  return (success);
2758 
}
2759 
 
2760 
/*
2761 
 
2762 
LOCAL FUNCTION
2763 
 
2764 
        gnu_special -- special handling of gnu mangled strings
2765 
 
2766 
SYNOPSIS
2767 
 
2768 
        static int
2769 
        gnu_special (struct work_stuff *work, const char **mangled,
2770 
                     string *declp);
2771 
 
2772 
 
2773 
DESCRIPTION
2774 
 
2775 
        Process some special GNU style mangling forms that don't fit
2776 
        the normal pattern.  For example:
2777 
 
2778 
                _$_3foo         (destructor for class foo)
2779 
                _vt$foo         (foo virtual table)
2780 
                _vt$foo$bar     (foo::bar virtual table)
2781 
                __vt_foo        (foo virtual table, new style with thunks)
2782 
                _3foo$varname   (static data member)
2783 
                _Q22rs2tu$vw    (static data member)
2784 
                __t6vector1Zii  (constructor with template)
2785 
                __thunk_4__$_7ostream (virtual function thunk)
2786 
 */
2787 
 
2788 
static int
2789 
gnu_special (struct work_stuff *work, const char **mangled, string *declp)
2790 
{
2791 
  int n;
2792 
  int success = 1;
2793 
  const char *p;
2794 
 
2795 
  if ((*mangled)[0] == '_'
2796 
      && strchr (cplus_markers, (*mangled)[1]) != NULL
2797 
      && (*mangled)[2] == '_')
2798 
    {
2799 
      /* Found a GNU style destructor, get past "_<CPLUS_MARKER>_" */
2800 
      (*mangled) += 3;
2801 
      work -> destructor += 1;
2802 
    }
2803 
  else if ((*mangled)[0] == '_'
2804 
           && (((*mangled)[1] == '_'
2805 
                && (*mangled)[2] == 'v'
2806 
                && (*mangled)[3] == 't'
2807 
                && (*mangled)[4] == '_')
2808 
               || ((*mangled)[1] == 'v'
2809 
                   && (*mangled)[2] == 't'
2810 
                   && strchr (cplus_markers, (*mangled)[3]) != NULL)))
2811 
    {
2812 
      /* Found a GNU style virtual table, get past "_vt<CPLUS_MARKER>"
2813 
         and create the decl.  Note that we consume the entire mangled
2814 
         input string, which means that demangle_signature has no work
2815 
         to do.  */
2816 
      if ((*mangled)[2] == 'v')
2817 
        (*mangled) += 5; /* New style, with thunks: "__vt_" */
2818 
      else
2819 
        (*mangled) += 4; /* Old style, no thunks: "_vt<CPLUS_MARKER>" */
2820 
      while (**mangled != '\0')
2821 
        {
2822 
          switch (**mangled)
2823 
            {
2824 
            case 'Q':
2825 
            case 'K':
2826 
              success = demangle_qualified (work, mangled, declp, 0, 1);
2827 
              break;
2828 
            case 't':
2829 
              success = demangle_template (work, mangled, declp, 0, 1,
2830 
                                           1);
2831 
              break;
2832 
            default:
2833 
              if (ISDIGIT((unsigned char)*mangled[0]))
2834 
                {
2835 
                  n = consume_count(mangled);
2836 
                  /* We may be seeing a too-large size, or else a
2837 
                     ".<digits>" indicating a static local symbol.  In
2838 
                     any case, declare victory and move on; *don't* try
2839 
                     to use n to allocate.  */
2840 
                  if (n > (int) strlen (*mangled))
2841 
                    {
2842 
                      success = 1;
2843 
                      break;
2844 
                    }
2845 
                }
2846 
              else
2847 
                {
2848 
                  n = strcspn (*mangled, cplus_markers);
2849 
                }
2850 
              string_appendn (declp, *mangled, n);
2851 
              (*mangled) += n;
2852 
            }
2853 
 
2854 
          p = strpbrk (*mangled, cplus_markers);
2855 
          if (success && ((p == NULL) || (p == *mangled)))
2856 
            {
2857 
              if (p != NULL)
2858 
                {
2859 
                  string_append (declp, SCOPE_STRING (work));
2860 
                  (*mangled)++;
2861 
                }
2862 
            }
2863 
          else
2864 
            {
2865 
              success = 0;
2866 
              break;
2867 
            }
2868 
        }
2869 
      if (success)
2870 
        string_append (declp, " virtual table");
2871 
    }
2872 
  else if ((*mangled)[0] == '_'
2873 
           && (strchr("0123456789Qt", (*mangled)[1]) != NULL)
2874 
           && (p = strpbrk (*mangled, cplus_markers)) != NULL)
2875 
    {
2876 
      /* static data member, "_3foo$varname" for example */
2877 
      (*mangled)++;
2878 
      switch (**mangled)
2879 
        {
2880 
        case 'Q':
2881 
        case 'K':
2882 
          success = demangle_qualified (work, mangled, declp, 0, 1);
2883 
          break;
2884 
        case 't':
2885 
          success = demangle_template (work, mangled, declp, 0, 1, 1);
2886 
          break;
2887 
        default:
2888 
          n = consume_count (mangled);
2889 
          if (n < 0 || n > (long) strlen (*mangled))
2890 
            {
2891 
              success = 0;
2892 
              break;
2893 
            }
2894 
 
2895 
          if (n > 10 && strncmp (*mangled, "_GLOBAL_", 8) == 0
2896 
              && (*mangled)[9] == 'N'
2897 
              && (*mangled)[8] == (*mangled)[10]
2898 
              && strchr (cplus_markers, (*mangled)[8]))
2899 
            {
2900 
              /* A member of the anonymous namespace.  There's information
2901 
                 about what identifier or filename it was keyed to, but
2902 
                 it's just there to make the mangled name unique; we just
2903 
                 step over it.  */
2904 
              string_append (declp, "{anonymous}");
2905 
              (*mangled) += n;
2906 
 
2907 
              /* Now p points to the marker before the N, so we need to
2908 
                 update it to the first marker after what we consumed.  */
2909 
              p = strpbrk (*mangled, cplus_markers);
2910 
              break;
2911 
            }
2912 
 
2913 
          string_appendn (declp, *mangled, n);
2914 
          (*mangled) += n;
2915 
        }
2916 
      if (success && (p == *mangled))
2917 
        {
2918 
          /* Consumed everything up to the cplus_marker, append the
2919 
             variable name.  */
2920 
          (*mangled)++;
2921 
          string_append (declp, SCOPE_STRING (work));
2922 
          n = strlen (*mangled);
2923 
          string_appendn (declp, *mangled, n);
2924 
          (*mangled) += n;
2925 
        }
2926 
      else
2927 
        {
2928 
          success = 0;
2929 
        }
2930 
    }
2931 
  else if (strncmp (*mangled, "__thunk_", 8) == 0)
2932 
    {
2933 
      int delta;
2934 
 
2935 
      (*mangled) += 8;
2936 
      delta = consume_count (mangled);
2937 
      if (delta == -1)
2938 
        success = 0;
2939 
      else
2940 
        {
2941 
          char *method = internal_cplus_demangle (work, ++*mangled);
2942 
 
2943 
          if (method)
2944 
            {
2945 
              char buf[50];
2946 
              sprintf (buf, "virtual function thunk (delta:%d) for ", -delta);
2947 
              string_append (declp, buf);
2948 
              string_append (declp, method);
2949 
              free (method);
2950 
              n = strlen (*mangled);
2951 
              (*mangled) += n;
2952 
            }
2953 
          else
2954 
            {
2955 
              success = 0;
2956 
            }
2957 
        }
2958 
    }
2959 
  else if (strncmp (*mangled, "__t", 3) == 0
2960 
           && ((*mangled)[3] == 'i' || (*mangled)[3] == 'f'))
2961 
    {
2962 
      p = (*mangled)[3] == 'i' ? " type_info node" : " type_info function";
2963 
      (*mangled) += 4;
2964 
      switch (**mangled)
2965 
        {
2966 
        case 'Q':
2967 
        case 'K':
2968 
          success = demangle_qualified (work, mangled, declp, 0, 1);
2969 
          break;
2970 
        case 't':
2971 
          success = demangle_template (work, mangled, declp, 0, 1, 1);
2972 
          break;
2973 
        default:
2974 
          success = do_type (work, mangled, declp);
2975 
          break;
2976 
        }
2977 
      if (success && **mangled != '\0')
2978 
        success = 0;
2979 
      if (success)
2980 
        string_append (declp, p);
2981 
    }
2982 
  else
2983 
    {
2984 
      success = 0;
2985 
    }
2986 
  return (success);
2987 
}
2988 
 
2989 
static void
2990 
recursively_demangle(struct work_stuff *work, const char **mangled,
2991 
                     string *result, int namelength)
2992 
{
2993 
  char * recurse = (char *)NULL;
2994 
  char * recurse_dem = (char *)NULL;
2995 
 
2996 
  recurse = XNEWVEC (char, namelength + 1);
2997 
  memcpy (recurse, *mangled, namelength);
2998 
  recurse[namelength] = '\000';
2999 
 
3000 
  recurse_dem = cplus_demangle (recurse, work->options);
3001 
 
3002 
  if (recurse_dem)
3003 
    {
3004 
      string_append (result, recurse_dem);
3005 
      free (recurse_dem);
3006 
    }
3007 
  else
3008 
    {
3009 
      string_appendn (result, *mangled, namelength);
3010 
    }
3011 
  free (recurse);
3012 
  *mangled += namelength;
3013 
}
3014 
 
3015 
/*
3016 
 
3017 
LOCAL FUNCTION
3018 
 
3019 
        arm_special -- special handling of ARM/lucid mangled strings
3020 
 
3021 
SYNOPSIS
3022 
 
3023 
        static int
3024 
        arm_special (const char **mangled,
3025 
                     string *declp);
3026 
 
3027 
 
3028 
DESCRIPTION
3029 
 
3030 
        Process some special ARM style mangling forms that don't fit
3031 
        the normal pattern.  For example:
3032 
 
3033 
                __vtbl__3foo            (foo virtual table)
3034 
                __vtbl__3foo__3bar      (bar::foo virtual table)
3035 
 
3036 
 */
3037 
 
3038 
static int
3039 
arm_special (const char **mangled, string *declp)
3040 
{
3041 
  int n;
3042 
  int success = 1;
3043 
  const char *scan;
3044 
 
3045 
  if (strncmp (*mangled, ARM_VTABLE_STRING, ARM_VTABLE_STRLEN) == 0)
3046 
    {
3047 
      /* Found a ARM style virtual table, get past ARM_VTABLE_STRING
3048 
         and create the decl.  Note that we consume the entire mangled
3049 
         input string, which means that demangle_signature has no work
3050 
         to do.  */
3051 
      scan = *mangled + ARM_VTABLE_STRLEN;
3052 
      while (*scan != '\0')        /* first check it can be demangled */
3053 
        {
3054 
          n = consume_count (&scan);
3055 
          if (n == -1)
3056 
            {
3057 
              return (0);           /* no good */
3058 
            }
3059 
          scan += n;
3060 
          if (scan[0] == '_' && scan[1] == '_')
3061 
            {
3062 
              scan += 2;
3063 
            }
3064 
        }
3065 
      (*mangled) += ARM_VTABLE_STRLEN;
3066 
      while (**mangled != '\0')
3067 
        {
3068 
          n = consume_count (mangled);
3069 
          if (n == -1
3070 
              || n > (long) strlen (*mangled))
3071 
            return 0;
3072 
          string_prependn (declp, *mangled, n);
3073 
          (*mangled) += n;
3074 
          if ((*mangled)[0] == '_' && (*mangled)[1] == '_')
3075 
            {
3076 
              string_prepend (declp, "::");
3077 
              (*mangled) += 2;
3078 
            }
3079 
        }
3080 
      string_append (declp, " virtual table");
3081 
    }
3082 
  else
3083 
    {
3084 
      success = 0;
3085 
    }
3086 
  return (success);
3087 
}
3088 
 
3089 
/*
3090 
 
3091 
LOCAL FUNCTION
3092 
 
3093 
        demangle_qualified -- demangle 'Q' qualified name strings
3094 
 
3095 
SYNOPSIS
3096 
 
3097 
        static int
3098 
        demangle_qualified (struct work_stuff *, const char *mangled,
3099 
                            string *result, int isfuncname, int append);
3100 
 
3101 
DESCRIPTION
3102 
 
3103 
        Demangle a qualified name, such as "Q25Outer5Inner" which is
3104 
        the mangled form of "Outer::Inner".  The demangled output is
3105 
        prepended or appended to the result string according to the
3106 
        state of the append flag.
3107 
 
3108 
        If isfuncname is nonzero, then the qualified name we are building
3109 
        is going to be used as a member function name, so if it is a
3110 
        constructor or destructor function, append an appropriate
3111 
        constructor or destructor name.  I.E. for the above example,
3112 
        the result for use as a constructor is "Outer::Inner::Inner"
3113 
        and the result for use as a destructor is "Outer::Inner::~Inner".
3114 
 
3115 
BUGS
3116 
 
3117 
        Numeric conversion is ASCII dependent (FIXME).
3118 
 
3119 
 */
3120 
 
3121 
static int
3122 
demangle_qualified (struct work_stuff *work, const char **mangled,
3123 
                    string *result, int isfuncname, int append)
3124 
{
3125 
  int qualifiers = 0;
3126 
  int success = 1;
3127 
  char num[2];
3128 
  string temp;
3129 
  string last_name;
3130 
  int bindex = register_Btype (work);
3131 
 
3132 
  /* We only make use of ISFUNCNAME if the entity is a constructor or
3133 
     destructor.  */
3134 
  isfuncname = (isfuncname
3135 
                && ((work->constructor & 1) || (work->destructor & 1)));
3136 
 
3137 
  string_init (&temp);
3138 
  string_init (&last_name);
3139 
 
3140 
  if ((*mangled)[0] == 'K')
3141 
    {
3142 
    /* Squangling qualified name reuse */
3143 
      int idx;
3144 
      (*mangled)++;
3145 
      idx = consume_count_with_underscores (mangled);
3146 
      if (idx == -1 || idx >= work -> numk)
3147 
        success = 0;
3148 
      else
3149 
        string_append (&temp, work -> ktypevec[idx]);
3150 
    }
3151 
  else
3152 
    switch ((*mangled)[1])
3153 
    {
3154 
    case '_':
3155 
      /* GNU mangled name with more than 9 classes.  The count is preceded
3156 
         by an underscore (to distinguish it from the <= 9 case) and followed
3157 
         by an underscore.  */
3158 
      (*mangled)++;
3159 
      qualifiers = consume_count_with_underscores (mangled);
3160 
      if (qualifiers == -1)
3161 
        success = 0;
3162 
      break;
3163 
 
3164 
    case '1':
3165 
    case '2':
3166 
    case '3':
3167 
    case '4':
3168 
    case '5':
3169 
    case '6':
3170 
    case '7':
3171 
    case '8':
3172 
    case '9':
3173 
      /* The count is in a single digit.  */
3174 
      num[0] = (*mangled)[1];
3175 
      num[1] = '\0';
3176 
      qualifiers = atoi (num);
3177 
 
3178 
      /* If there is an underscore after the digit, skip it.  This is
3179 
         said to be for ARM-qualified names, but the ARM makes no
3180 
         mention of such an underscore.  Perhaps cfront uses one.  */
3181 
      if ((*mangled)[2] == '_')
3182 
        {
3183 
          (*mangled)++;
3184 
        }
3185 
      (*mangled) += 2;
3186 
      break;
3187 
 
3188 
    case '0':
3189 
    default:
3190 
      success = 0;
3191 
    }
3192 
 
3193 
  if (!success)
3194 
    return success;
3195 
 
3196 
  /* Pick off the names and collect them in the temp buffer in the order
3197 
     in which they are found, separated by '::'.  */
3198 
 
3199 
  while (qualifiers-- > 0)
3200 
    {
3201 
      int remember_K = 1;
3202 
      string_clear (&last_name);
3203 
 
3204 
      if (*mangled[0] == '_')
3205 
        (*mangled)++;
3206 
 
3207 
      if (*mangled[0] == 't')
3208 
        {
3209 
          /* Here we always append to TEMP since we will want to use
3210 
             the template name without the template parameters as a
3211 
             constructor or destructor name.  The appropriate
3212 
             (parameter-less) value is returned by demangle_template
3213 
             in LAST_NAME.  We do not remember the template type here,
3214 
             in order to match the G++ mangling algorithm.  */
3215 
          success = demangle_template(work, mangled, &temp,
3216 
                                      &last_name, 1, 0);
3217 
          if (!success)
3218 
            break;
3219 
        }
3220 
      else if (*mangled[0] == 'K')
3221 
        {
3222 
          int idx;
3223 
          (*mangled)++;
3224 
          idx = consume_count_with_underscores (mangled);
3225 
          if (idx == -1 || idx >= work->numk)
3226 
            success = 0;
3227 
          else
3228 
            string_append (&temp, work->ktypevec[idx]);
3229 
          remember_K = 0;
3230 
 
3231 
          if (!success) break;
3232 
        }
3233 
      else
3234 
        {
3235 
          if (EDG_DEMANGLING)
3236 
            {
3237 
              int namelength;
3238 
              /* Now recursively demangle the qualifier
3239 
               * This is necessary to deal with templates in
3240 
               * mangling styles like EDG */
3241 
              namelength = consume_count (mangled);
3242 
              if (namelength == -1)
3243 
                {
3244 
                  success = 0;
3245 
                  break;
3246 
                }
3247 
              recursively_demangle(work, mangled, &temp, namelength);
3248 
            }
3249 
          else
3250 
            {
3251 
              string_delete (&last_name);
3252 
              success = do_type (work, mangled, &last_name);
3253 
              if (!success)
3254 
                break;
3255 
              string_appends (&temp, &last_name);
3256 
            }
3257 
        }
3258 
 
3259 
      if (remember_K)
3260 
        remember_Ktype (work, temp.b, LEN_STRING (&temp));
3261 
 
3262 
      if (qualifiers > 0)
3263 
        string_append (&temp, SCOPE_STRING (work));
3264 
    }
3265 
 
3266 
  remember_Btype (work, temp.b, LEN_STRING (&temp), bindex);
3267 
 
3268 
  /* If we are using the result as a function name, we need to append
3269 
     the appropriate '::' separated constructor or destructor name.
3270 
     We do this here because this is the most convenient place, where
3271 
     we already have a pointer to the name and the length of the name.  */
3272 
 
3273 
  if (isfuncname)
3274 
    {
3275 
      string_append (&temp, SCOPE_STRING (work));
3276 
      if (work -> destructor & 1)
3277 
        string_append (&temp, "~");
3278 
      string_appends (&temp, &last_name);
3279 
    }
3280 
 
3281 
  /* Now either prepend the temp buffer to the result, or append it,
3282 
     depending upon the state of the append flag.  */
3283 
 
3284 
  if (append)
3285 
    string_appends (result, &temp);
3286 
  else
3287 
    {
3288 
      if (!STRING_EMPTY (result))
3289 
        string_append (&temp, SCOPE_STRING (work));
3290 
      string_prepends (result, &temp);
3291 
    }
3292 
 
3293 
  string_delete (&last_name);
3294 
  string_delete (&temp);
3295 
  return (success);
3296 
}
3297 
 
3298 
/*
3299 
 
3300 
LOCAL FUNCTION
3301 
 
3302 
        get_count -- convert an ascii count to integer, consuming tokens
3303 
 
3304 
SYNOPSIS
3305 
 
3306 
        static int
3307 
        get_count (const char **type, int *count)
3308 
 
3309 
DESCRIPTION
3310 
 
3311 
        Assume that *type points at a count in a mangled name; set
3312 
        *count to its value, and set *type to the next character after
3313 
        the count.  There are some weird rules in effect here.
3314 
 
3315 
        If *type does not point at a string of digits, return zero.
3316 
 
3317 
        If *type points at a string of digits followed by an
3318 
        underscore, set *count to their value as an integer, advance
3319 
        *type to point *after the underscore, and return 1.
3320 
 
3321 
        If *type points at a string of digits not followed by an
3322 
        underscore, consume only the first digit.  Set *count to its
3323 
        value as an integer, leave *type pointing after that digit,
3324 
        and return 1.
3325 
 
3326 
        The excuse for this odd behavior: in the ARM and HP demangling
3327 
        styles, a type can be followed by a repeat count of the form
3328 
        `Nxy', where:
3329 
 
3330 
        `x' is a single digit specifying how many additional copies
3331 
            of the type to append to the argument list, and
3332 
 
3333 
        `y' is one or more digits, specifying the zero-based index of
3334 
            the first repeated argument in the list.  Yes, as you're
3335 
            unmangling the name you can figure this out yourself, but
3336 
            it's there anyway.
3337 
 
3338 
        So, for example, in `bar__3fooFPiN51', the first argument is a
3339 
        pointer to an integer (`Pi'), and then the next five arguments
3340 
        are the same (`N5'), and the first repeat is the function's
3341 
        second argument (`1').
3342 
*/
3343 
 
3344 
static int
3345 
get_count (const char **type, int *count)
3346 
{
3347 
  const char *p;
3348 
  int n;
3349 
 
3350 
  if (!ISDIGIT ((unsigned char)**type))
3351 
    return (0);
3352 
  else
3353 
    {
3354 
      *count = **type - '0';
3355 
      (*type)++;
3356 
      if (ISDIGIT ((unsigned char)**type))
3357 
        {
3358 
          p = *type;
3359 
          n = *count;
3360 
          do
3361 
            {
3362 
              n *= 10;
3363 
              n += *p - '0';
3364 
              p++;
3365 
            }
3366 
          while (ISDIGIT ((unsigned char)*p));
3367 
          if (*p == '_')
3368 
            {
3369 
              *type = p + 1;
3370 
              *count = n;
3371 
            }
3372 
        }
3373 
    }
3374 
  return (1);
3375 
}
3376 
 
3377 
/* RESULT will be initialised here; it will be freed on failure.  The
3378 
   value returned is really a type_kind_t.  */
3379 
 
3380 
static int
3381 
do_type (struct work_stuff *work, const char **mangled, string *result)
3382 
{
3383 
  int n;
3384 
  int done;
3385 
  int success;
3386 
  string decl;
3387 
  const char *remembered_type;
3388 
  int type_quals;
3389 
  type_kind_t tk = tk_none;
3390 
 
3391 
  string_init (&decl);
3392 
  string_init (result);
3393 
 
3394 
  done = 0;
3395 
  success = 1;
3396 
  while (success && !done)
3397 
    {
3398 
      int member;
3399 
      switch (**mangled)
3400 
        {
3401 
 
3402 
          /* A pointer type */
3403 
        case 'P':
3404 
        case 'p':
3405 
          (*mangled)++;
3406 
          if (! (work -> options & DMGL_JAVA))
3407 
            string_prepend (&decl, "*");
3408 
          if (tk == tk_none)
3409 
            tk = tk_pointer;
3410 
          break;
3411 
 
3412 
          /* A reference type */
3413 
        case 'R':
3414 
          (*mangled)++;
3415 
          string_prepend (&decl, "&");
3416 
          if (tk == tk_none)
3417 
            tk = tk_reference;
3418 
          break;
3419 
 
3420 
          /* An array */
3421 
        case 'A':
3422 
          {
3423 
            ++(*mangled);
3424 
            if (!STRING_EMPTY (&decl)
3425 
                && (decl.b[0] == '*' || decl.b[0] == '&'))
3426 
              {
3427 
                string_prepend (&decl, "(");
3428 
                string_append (&decl, ")");
3429 
              }
3430 
            string_append (&decl, "[");
3431 
            if (**mangled != '_')
3432 
              success = demangle_template_value_parm (work, mangled, &decl,
3433 
                                                      tk_integral);
3434 
            if (**mangled == '_')
3435 
              ++(*mangled);
3436 
            string_append (&decl, "]");
3437 
            break;
3438 
          }
3439 
 
3440 
        /* A back reference to a previously seen type */
3441 
        case 'T':
3442 
          (*mangled)++;
3443 
          if (!get_count (mangled, &n) || n >= work -> ntypes)
3444 
            {
3445 
              success = 0;
3446 
            }
3447 
          else
3448 
            {
3449 
              remembered_type = work -> typevec[n];
3450 
              mangled = &remembered_type;
3451 
            }
3452 
          break;
3453 
 
3454 
          /* A function */
3455 
        case 'F':
3456 
          (*mangled)++;
3457 
            if (!STRING_EMPTY (&decl)
3458 
                && (decl.b[0] == '*' || decl.b[0] == '&'))
3459 
            {
3460 
              string_prepend (&decl, "(");
3461 
              string_append (&decl, ")");
3462 
            }
3463 
          /* After picking off the function args, we expect to either find the
3464 
             function return type (preceded by an '_') or the end of the
3465 
             string.  */
3466 
          if (!demangle_nested_args (work, mangled, &decl)
3467 
              || (**mangled != '_' && **mangled != '\0'))
3468 
            {
3469 
              success = 0;
3470 
              break;
3471 
            }
3472 
          if (success && (**mangled == '_'))
3473 
            (*mangled)++;
3474 
          break;
3475 
 
3476 
        case 'M':
3477 
        case 'O':
3478 
          {
3479 
            type_quals = TYPE_UNQUALIFIED;
3480 
 
3481 
            member = **mangled == 'M';
3482 
            (*mangled)++;
3483 
 
3484 
            string_append (&decl, ")");
3485 
 
3486 
            /* We don't need to prepend `::' for a qualified name;
3487 
               demangle_qualified will do that for us.  */
3488 
            if (**mangled != 'Q')
3489 
              string_prepend (&decl, SCOPE_STRING (work));
3490 
 
3491 
            if (ISDIGIT ((unsigned char)**mangled))
3492 
              {
3493 
                n = consume_count (mangled);
3494 
                if (n == -1
3495 
                    || (int) strlen (*mangled) < n)
3496 
                  {
3497 
                    success = 0;
3498 
                    break;
3499 
                  }
3500 
                string_prependn (&decl, *mangled, n);
3501 
                *mangled += n;
3502 
              }
3503 
            else if (**mangled == 'X' || **mangled == 'Y')
3504 
              {
3505 
                string temp;
3506 
                do_type (work, mangled, &temp);
3507 
                string_prepends (&decl, &temp);
3508 
                string_delete (&temp);
3509 
              }
3510 
            else if (**mangled == 't')
3511 
              {
3512 
                string temp;
3513 
                string_init (&temp);
3514 
                success = demangle_template (work, mangled, &temp,
3515 
                                             NULL, 1, 1);
3516 
                if (success)
3517 
                  {
3518 
                    string_prependn (&decl, temp.b, temp.p - temp.b);
3519 
                    string_delete (&temp);
3520 
                  }
3521 
                else
3522 
                  break;
3523 
              }
3524 
            else if (**mangled == 'Q')
3525 
              {
3526 
                success = demangle_qualified (work, mangled, &decl,
3527 
                                              /*isfuncnam=*/0,
3528 
                                              /*append=*/0);
3529 
                if (!success)
3530 
                  break;
3531 
              }
3532 
            else
3533 
              {
3534 
                success = 0;
3535 
                break;
3536 
              }
3537 
 
3538 
            string_prepend (&decl, "(");
3539 
            if (member)
3540 
              {
3541 
                switch (**mangled)
3542 
                  {
3543 
                  case 'C':
3544 
                  case 'V':
3545 
                  case 'u':
3546 
                    type_quals |= code_for_qualifier (**mangled);
3547 
                    (*mangled)++;
3548 
                    break;
3549 
 
3550 
                  default:
3551 
                    break;
3552 
                  }
3553 
 
3554 
                if (*(*mangled)++ != 'F')
3555 
                  {
3556 
                    success = 0;
3557 
                    break;
3558 
                  }
3559 
              }
3560 
            if ((member && !demangle_nested_args (work, mangled, &decl))
3561 
                || **mangled != '_')
3562 
              {
3563 
                success = 0;
3564 
                break;
3565 
              }
3566 
            (*mangled)++;
3567 
            if (! PRINT_ANSI_QUALIFIERS)
3568 
              {
3569 
                break;
3570 
              }
3571 
            if (type_quals != TYPE_UNQUALIFIED)
3572 
              {
3573 
                APPEND_BLANK (&decl);
3574 
                string_append (&decl, qualifier_string (type_quals));
3575 
              }
3576 
            break;
3577 
          }
3578 
        case 'G':
3579 
          (*mangled)++;
3580 
          break;
3581 
 
3582 
        case 'C':
3583 
        case 'V':
3584 
        case 'u':
3585 
          if (PRINT_ANSI_QUALIFIERS)
3586 
            {
3587 
              if (!STRING_EMPTY (&decl))
3588 
                string_prepend (&decl, " ");
3589 
 
3590 
              string_prepend (&decl, demangle_qualifier (**mangled));
3591 
            }
3592 
          (*mangled)++;
3593 
          break;
3594 
          /*
3595 
            }
3596 
            */
3597 
 
3598 
          /* fall through */
3599 
        default:
3600 
          done = 1;
3601 
          break;
3602 
        }
3603 
    }
3604 
 
3605 
  if (success) switch (**mangled)
3606 
    {
3607 
      /* A qualified name, such as "Outer::Inner".  */
3608 
    case 'Q':
3609 
    case 'K':
3610 
      {
3611 
        success = demangle_qualified (work, mangled, result, 0, 1);
3612 
        break;
3613 
      }
3614 
 
3615 
    /* A back reference to a previously seen squangled type */
3616 
    case 'B':
3617 
      (*mangled)++;
3618 
      if (!get_count (mangled, &n) || n >= work -> numb)
3619 
        success = 0;
3620 
      else
3621 
        string_append (result, work->btypevec[n]);
3622 
      break;
3623 
 
3624 
    case 'X':
3625 
    case 'Y':
3626 
      /* A template parm.  We substitute the corresponding argument. */
3627 
      {
3628 
        int idx;
3629 
 
3630 
        (*mangled)++;
3631 
        idx = consume_count_with_underscores (mangled);
3632 
 
3633 
        if (idx == -1
3634 
            || (work->tmpl_argvec && idx >= work->ntmpl_args)
3635 
            || consume_count_with_underscores (mangled) == -1)
3636 
          {
3637 
            success = 0;
3638 
            break;
3639 
          }
3640 
 
3641 
        if (work->tmpl_argvec)
3642 
          string_append (result, work->tmpl_argvec[idx]);
3643 
        else
3644 
          string_append_template_idx (result, idx);
3645 
 
3646 
        success = 1;
3647 
      }
3648 
    break;
3649 
 
3650 
    default:
3651 
      success = demangle_fund_type (work, mangled, result);
3652 
      if (tk == tk_none)
3653 
        tk = (type_kind_t) success;
3654 
      break;
3655 
    }
3656 
 
3657 
  if (success)
3658 
    {
3659 
      if (!STRING_EMPTY (&decl))
3660 
        {
3661 
          string_append (result, " ");
3662 
          string_appends (result, &decl);
3663 
        }
3664 
    }
3665 
  else
3666 
    string_delete (result);
3667 
  string_delete (&decl);
3668 
 
3669 
  if (success)
3670 
    /* Assume an integral type, if we're not sure.  */
3671 
    return (int) ((tk == tk_none) ? tk_integral : tk);
3672 
  else
3673 
    return 0;
3674 
}
3675 
 
3676 
/* Given a pointer to a type string that represents a fundamental type
3677 
   argument (int, long, unsigned int, etc) in TYPE, a pointer to the
3678 
   string in which the demangled output is being built in RESULT, and
3679 
   the WORK structure, decode the types and add them to the result.
3680 
 
3681 
   For example:
3682 
 
3683 
        "Ci"    =>      "const int"
3684 
        "Sl"    =>      "signed long"
3685 
        "CUs"   =>      "const unsigned short"
3686 
 
3687 
   The value returned is really a type_kind_t.  */
3688 
 
3689 
static int
3690 
demangle_fund_type (struct work_stuff *work,
3691 
                    const char **mangled, string *result)
3692 
{
3693 
  int done = 0;
3694 
  int success = 1;
3695 
  char buf[INTBUF_SIZE + 5 /* 'int%u_t' */];
3696 
  unsigned int dec = 0;
3697 
  type_kind_t tk = tk_integral;
3698 
 
3699 
  /* First pick off any type qualifiers.  There can be more than one.  */
3700 
 
3701 
  while (!done)
3702 
    {
3703 
      switch (**mangled)
3704 
        {
3705 
        case 'C':
3706 
        case 'V':
3707 
        case 'u':
3708 
          if (PRINT_ANSI_QUALIFIERS)
3709 
            {
3710 
              if (!STRING_EMPTY (result))
3711 
                string_prepend (result, " ");
3712 
              string_prepend (result, demangle_qualifier (**mangled));
3713 
            }
3714 
          (*mangled)++;
3715 
          break;
3716 
        case 'U':
3717 
          (*mangled)++;
3718 
          APPEND_BLANK (result);
3719 
          string_append (result, "unsigned");
3720 
          break;
3721 
        case 'S': /* signed char only */
3722 
          (*mangled)++;
3723 
          APPEND_BLANK (result);
3724 
          string_append (result, "signed");
3725 
          break;
3726 
        case 'J':
3727 
          (*mangled)++;
3728 
          APPEND_BLANK (result);
3729 
          string_append (result, "__complex");
3730 
          break;
3731 
        default:
3732 
          done = 1;
3733 
          break;
3734 
        }
3735 
    }
3736 
 
3737 
  /* Now pick off the fundamental type.  There can be only one.  */
3738 
 
3739 
  switch (**mangled)
3740 
    {
3741 
    case '\0':
3742 
    case '_':
3743 
      break;
3744 
    case 'v':
3745 
      (*mangled)++;
3746 
      APPEND_BLANK (result);
3747 
      string_append (result, "void");
3748 
      break;
3749 
    case 'x':
3750 
      (*mangled)++;
3751 
      APPEND_BLANK (result);
3752 
      string_append (result, "long long");
3753 
      break;
3754 
    case 'l':
3755 
      (*mangled)++;
3756 
      APPEND_BLANK (result);
3757 
      string_append (result, "long");
3758 
      break;
3759 
    case 'i':
3760 
      (*mangled)++;
3761 
      APPEND_BLANK (result);
3762 
      string_append (result, "int");
3763 
      break;
3764 
    case 's':
3765 
      (*mangled)++;
3766 
      APPEND_BLANK (result);
3767 
      string_append (result, "short");
3768 
      break;
3769 
    case 'b':
3770 
      (*mangled)++;
3771 
      APPEND_BLANK (result);
3772 
      string_append (result, "bool");
3773 
      tk = tk_bool;
3774 
      break;
3775 
    case 'c':
3776 
      (*mangled)++;
3777 
      APPEND_BLANK (result);
3778 
      string_append (result, "char");
3779 
      tk = tk_char;
3780 
      break;
3781 
    case 'w':
3782 
      (*mangled)++;
3783 
      APPEND_BLANK (result);
3784 
      string_append (result, "wchar_t");
3785 
      tk = tk_char;
3786 
      break;
3787 
    case 'r':
3788 
      (*mangled)++;
3789 
      APPEND_BLANK (result);
3790 
      string_append (result, "long double");
3791 
      tk = tk_real;
3792 
      break;
3793 
    case 'd':
3794 
      (*mangled)++;
3795 
      APPEND_BLANK (result);
3796 
      string_append (result, "double");
3797 
      tk = tk_real;
3798 
      break;
3799 
    case 'f':
3800 
      (*mangled)++;
3801 
      APPEND_BLANK (result);
3802 
      string_append (result, "float");
3803 
      tk = tk_real;
3804 
      break;
3805 
    case 'G':
3806 
      (*mangled)++;
3807 
      if (!ISDIGIT ((unsigned char)**mangled))
3808 
        {
3809 
          success = 0;
3810 
          break;
3811 
        }
3812 
    case 'I':
3813 
      (*mangled)++;
3814 
      if (**mangled == '_')
3815 
        {
3816 
          int i;
3817 
          (*mangled)++;
3818 
          for (i = 0;
3819 
               i < (long) sizeof (buf) - 1 && **mangled && **mangled != '_';
3820 
               (*mangled)++, i++)
3821 
            buf[i] = **mangled;
3822 
          if (**mangled != '_')
3823 
            {
3824 
              success = 0;
3825 
              break;
3826 
            }
3827 
          buf[i] = '\0';
3828 
          (*mangled)++;
3829 
        }
3830 
      else
3831 
        {
3832 
          strncpy (buf, *mangled, 2);
3833 
          buf[2] = '\0';
3834 
          *mangled += min (strlen (*mangled), 2);
3835 
        }
3836 
      sscanf (buf, "%x", &dec);
3837 
      sprintf (buf, "int%u_t", dec);
3838 
      APPEND_BLANK (result);
3839 
      string_append (result, buf);
3840 
      break;
3841 
 
3842 
      /* fall through */
3843 
      /* An explicit type, such as "6mytype" or "7integer" */
3844 
    case '0':
3845 
    case '1':
3846 
    case '2':
3847 
    case '3':
3848 
    case '4':
3849 
    case '5':
3850 
    case '6':
3851 
    case '7':
3852 
    case '8':
3853 
    case '9':
3854 
      {
3855 
        int bindex = register_Btype (work);
3856 
        string btype;
3857 
        string_init (&btype);
3858 
        if (demangle_class_name (work, mangled, &btype)) {
3859 
          remember_Btype (work, btype.b, LEN_STRING (&btype), bindex);
3860 
          APPEND_BLANK (result);
3861 
          string_appends (result, &btype);
3862 
        }
3863 
        else
3864 
          success = 0;
3865 
        string_delete (&btype);
3866 
        break;
3867 
      }
3868 
    case 't':
3869 
      {
3870 
        string btype;
3871 
        string_init (&btype);
3872 
        success = demangle_template (work, mangled, &btype, 0, 1, 1);
3873 
        string_appends (result, &btype);
3874 
        string_delete (&btype);
3875 
        break;
3876 
      }
3877 
    default:
3878 
      success = 0;
3879 
      break;
3880 
    }
3881 
 
3882 
  return success ? ((int) tk) : 0;
3883 
}
3884 
 
3885 
 
3886 
/* Handle a template's value parameter for HP aCC (extension from ARM)
3887 
   **mangled points to 'S' or 'U' */
3888 
 
3889 
static int
3890 
do_hpacc_template_const_value (struct work_stuff *work ATTRIBUTE_UNUSED,
3891 
                               const char **mangled, string *result)
3892 
{
3893 
  int unsigned_const;
3894 
 
3895 
  if (**mangled != 'U' && **mangled != 'S')
3896 
    return 0;
3897 
 
3898 
  unsigned_const = (**mangled == 'U');
3899 
 
3900 
  (*mangled)++;
3901 
 
3902 
  switch (**mangled)
3903 
    {
3904 
      case 'N':
3905 
        string_append (result, "-");
3906 
        /* fall through */
3907 
      case 'P':
3908 
        (*mangled)++;
3909 
        break;
3910 
      case 'M':
3911 
        /* special case for -2^31 */
3912 
        string_append (result, "-2147483648");
3913 
        (*mangled)++;
3914 
        return 1;
3915 
      default:
3916 
        return 0;
3917 
    }
3918 
 
3919 
  /* We have to be looking at an integer now */
3920 
  if (!(ISDIGIT ((unsigned char)**mangled)))
3921 
    return 0;
3922 
 
3923 
  /* We only deal with integral values for template
3924 
     parameters -- so it's OK to look only for digits */
3925 
  while (ISDIGIT ((unsigned char)**mangled))
3926 
    {
3927 
      char_str[0] = **mangled;
3928 
      string_append (result, char_str);
3929 
      (*mangled)++;
3930 
    }
3931 
 
3932 
  if (unsigned_const)
3933 
    string_append (result, "U");
3934 
 
3935 
  /* FIXME? Some day we may have 64-bit (or larger :-) ) constants
3936 
     with L or LL suffixes. pai/1997-09-03 */
3937 
 
3938 
  return 1; /* success */
3939 
}
3940 
 
3941 
/* Handle a template's literal parameter for HP aCC (extension from ARM)
3942 
   **mangled is pointing to the 'A' */
3943 
 
3944 
static int
3945 
do_hpacc_template_literal (struct work_stuff *work, const char **mangled,
3946 
                           string *result)
3947 
{
3948 
  int literal_len = 0;
3949 
  char * recurse;
3950 
  char * recurse_dem;
3951 
 
3952 
  if (**mangled != 'A')
3953 
    return 0;
3954 
 
3955 
  (*mangled)++;
3956 
 
3957 
  literal_len = consume_count (mangled);
3958 
 
3959 
  if (literal_len <= 0)
3960 
    return 0;
3961 
 
3962 
  /* Literal parameters are names of arrays, functions, etc.  and the
3963 
     canonical representation uses the address operator */
3964 
  string_append (result, "&");
3965 
 
3966 
  /* Now recursively demangle the literal name */
3967 
  recurse = XNEWVEC (char, literal_len + 1);
3968 
  memcpy (recurse, *mangled, literal_len);
3969 
  recurse[literal_len] = '\000';
3970 
 
3971 
  recurse_dem = cplus_demangle (recurse, work->options);
3972 
 
3973 
  if (recurse_dem)
3974 
    {
3975 
      string_append (result, recurse_dem);
3976 
      free (recurse_dem);
3977 
    }
3978 
  else
3979 
    {
3980 
      string_appendn (result, *mangled, literal_len);
3981 
    }
3982 
  (*mangled) += literal_len;
3983 
  free (recurse);
3984 
 
3985 
  return 1;
3986 
}
3987 
 
3988 
static int
3989 
snarf_numeric_literal (const char **args, string *arg)
3990 
{
3991 
  if (**args == '-')
3992 
    {
3993 
      char_str[0] = '-';
3994 
      string_append (arg, char_str);
3995 
      (*args)++;
3996 
    }
3997 
  else if (**args == '+')
3998 
    (*args)++;
3999 
 
4000 
  if (!ISDIGIT ((unsigned char)**args))
4001 
    return 0;
4002 
 
4003 
  while (ISDIGIT ((unsigned char)**args))
4004 
    {
4005 
      char_str[0] = **args;
4006 
      string_append (arg, char_str);
4007 
      (*args)++;
4008 
    }
4009 
 
4010 
  return 1;
4011 
}
4012 
 
4013 
/* Demangle the next argument, given by MANGLED into RESULT, which
4014 
   *should be an uninitialized* string.  It will be initialized here,
4015 
   and free'd should anything go wrong.  */
4016 
 
4017 
static int
4018 
do_arg (struct work_stuff *work, const char **mangled, string *result)
4019 
{
4020 
  /* Remember where we started so that we can record the type, for
4021 
     non-squangling type remembering.  */
4022 
  const char *start = *mangled;
4023 
 
4024 
  string_init (result);
4025 
 
4026 
  if (work->nrepeats > 0)
4027 
    {
4028 
      --work->nrepeats;
4029 
 
4030 
      if (work->previous_argument == 0)
4031 
        return 0;
4032 
 
4033 
      /* We want to reissue the previous type in this argument list.  */
4034 
      string_appends (result, work->previous_argument);
4035 
      return 1;
4036 
    }
4037 
 
4038 
  if (**mangled == 'n')
4039 
    {
4040 
      /* A squangling-style repeat.  */
4041 
      (*mangled)++;
4042 
      work->nrepeats = consume_count(mangled);
4043 
 
4044 
      if (work->nrepeats <= 0)
4045 
        /* This was not a repeat count after all.  */
4046 
        return 0;
4047 
 
4048 
      if (work->nrepeats > 9)
4049 
        {
4050 
          if (**mangled != '_')
4051 
            /* The repeat count should be followed by an '_' in this
4052 
               case.  */
4053 
            return 0;
4054 
          else
4055 
            (*mangled)++;
4056 
        }
4057 
 
4058 
      /* Now, the repeat is all set up.  */
4059 
      return do_arg (work, mangled, result);
4060 
    }
4061 
 
4062 
  /* Save the result in WORK->previous_argument so that we can find it
4063 
     if it's repeated.  Note that saving START is not good enough: we
4064 
     do not want to add additional types to the back-referenceable
4065 
     type vector when processing a repeated type.  */
4066 
  if (work->previous_argument)
4067 
    string_delete (work->previous_argument);
4068 
  else
4069 
    work->previous_argument = XNEW (string);
4070 
 
4071 
  if (!do_type (work, mangled, work->previous_argument))
4072 
    return 0;
4073 
 
4074 
  string_appends (result, work->previous_argument);
4075 
 
4076 
  remember_type (work, start, *mangled - start);
4077 
  return 1;
4078 
}
4079 
 
4080 
static void
4081 
remember_type (struct work_stuff *work, const char *start, int len)
4082 
{
4083 
  char *tem;
4084 
 
4085 
  if (work->forgetting_types)
4086 
    return;
4087 
 
4088 
  if (work -> ntypes >= work -> typevec_size)
4089 
    {
4090 
      if (work -> typevec_size == 0)
4091 
        {
4092 
          work -> typevec_size = 3;
4093 
          work -> typevec = XNEWVEC (char *, work->typevec_size);
4094 
        }
4095 
      else
4096 
        {
4097 
          work -> typevec_size *= 2;
4098 
          work -> typevec
4099 
            = XRESIZEVEC (char *, work->typevec, work->typevec_size);
4100 
        }
4101 
    }
4102 
  tem = XNEWVEC (char, len + 1);
4103 
  memcpy (tem, start, len);
4104 
  tem[len] = '\0';
4105 
  work -> typevec[work -> ntypes++] = tem;
4106 
}
4107 
 
4108 
 
4109 
/* Remember a K type class qualifier. */
4110 
static void
4111 
remember_Ktype (struct work_stuff *work, const char *start, int len)
4112 
{
4113 
  char *tem;
4114 
 
4115 
  if (work -> numk >= work -> ksize)
4116 
    {
4117 
      if (work -> ksize == 0)
4118 
        {
4119 
          work -> ksize = 5;
4120 
          work -> ktypevec = XNEWVEC (char *, work->ksize);
4121 
        }
4122 
      else
4123 
        {
4124 
          work -> ksize *= 2;
4125 
          work -> ktypevec
4126 
            = XRESIZEVEC (char *, work->ktypevec, work->ksize);
4127 
        }
4128 
    }
4129 
  tem = XNEWVEC (char, len + 1);
4130 
  memcpy (tem, start, len);
4131 
  tem[len] = '\0';
4132 
  work -> ktypevec[work -> numk++] = tem;
4133 
}
4134 
 
4135 
/* Register a B code, and get an index for it. B codes are registered
4136 
   as they are seen, rather than as they are completed, so map<temp<char> >
4137 
   registers map<temp<char> > as B0, and temp<char> as B1 */
4138 
 
4139 
static int
4140 
register_Btype (struct work_stuff *work)
4141 
{
4142 
  int ret;
4143 
 
4144 
  if (work -> numb >= work -> bsize)
4145 
    {
4146 
      if (work -> bsize == 0)
4147 
        {
4148 
          work -> bsize = 5;
4149 
          work -> btypevec = XNEWVEC (char *, work->bsize);
4150 
        }
4151 
      else
4152 
        {
4153 
          work -> bsize *= 2;
4154 
          work -> btypevec
4155 
            = XRESIZEVEC (char *, work->btypevec, work->bsize);
4156 
        }
4157 
    }
4158 
  ret = work -> numb++;
4159 
  work -> btypevec[ret] = NULL;
4160 
  return(ret);
4161 
}
4162 
 
4163 
/* Store a value into a previously registered B code type. */
4164 
 
4165 
static void
4166 
remember_Btype (struct work_stuff *work, const char *start,
4167 
                int len, int index)
4168 
{
4169 
  char *tem;
4170 
 
4171 
  tem = XNEWVEC (char, len + 1);
4172 
  memcpy (tem, start, len);
4173 
  tem[len] = '\0';
4174 
  work -> btypevec[index] = tem;
4175 
}
4176 
 
4177 
/* Lose all the info related to B and K type codes. */
4178 
static void
4179 
forget_B_and_K_types (struct work_stuff *work)
4180 
{
4181 
  int i;
4182 
 
4183 
  while (work -> numk > 0)
4184 
    {
4185 
      i = --(work -> numk);
4186 
      if (work -> ktypevec[i] != NULL)
4187 
        {
4188 
          free (work -> ktypevec[i]);
4189 
          work -> ktypevec[i] = NULL;
4190 
        }
4191 
    }
4192 
 
4193 
  while (work -> numb > 0)
4194 
    {
4195 
      i = --(work -> numb);
4196 
      if (work -> btypevec[i] != NULL)
4197 
        {
4198 
          free (work -> btypevec[i]);
4199 
          work -> btypevec[i] = NULL;
4200 
        }
4201 
    }
4202 
}
4203 
/* Forget the remembered types, but not the type vector itself.  */
4204 
 
4205 
static void
4206 
forget_types (struct work_stuff *work)
4207 
{
4208 
  int i;
4209 
 
4210 
  while (work -> ntypes > 0)
4211 
    {
4212 
      i = --(work -> ntypes);
4213 
      if (work -> typevec[i] != NULL)
4214 
        {
4215 
          free (work -> typevec[i]);
4216 
          work -> typevec[i] = NULL;
4217 
        }
4218 
    }
4219 
}
4220 
 
4221 
/* Process the argument list part of the signature, after any class spec
4222 
   has been consumed, as well as the first 'F' character (if any).  For
4223 
   example:
4224 
 
4225 
   "__als__3fooRT0"             =>      process "RT0"
4226 
   "complexfunc5__FPFPc_PFl_i"  =>      process "PFPc_PFl_i"
4227 
 
4228 
   DECLP must be already initialised, usually non-empty.  It won't be freed
4229 
   on failure.
4230 
 
4231 
   Note that g++ differs significantly from ARM and lucid style mangling
4232 
   with regards to references to previously seen types.  For example, given
4233 
   the source fragment:
4234 
 
4235 
     class foo {
4236 
       public:
4237 
       foo::foo (int, foo &ia, int, foo &ib, int, foo &ic);
4238 
     };
4239 
 
4240 
     foo::foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4241 
     void foo (int, foo &ia, int, foo &ib, int, foo &ic) { ia = ib = ic; }
4242 
 
4243 
   g++ produces the names:
4244 
 
4245 
     __3fooiRT0iT2iT2
4246 
     foo__FiR3fooiT1iT1
4247 
 
4248 
   while lcc (and presumably other ARM style compilers as well) produces:
4249 
 
4250 
     foo__FiR3fooT1T2T1T2
4251 
     __ct__3fooFiR3fooT1T2T1T2
4252 
 
4253 
   Note that g++ bases its type numbers starting at zero and counts all
4254 
   previously seen types, while lucid/ARM bases its type numbers starting
4255 
   at one and only considers types after it has seen the 'F' character
4256 
   indicating the start of the function args.  For lucid/ARM style, we
4257 
   account for this difference by discarding any previously seen types when
4258 
   we see the 'F' character, and subtracting one from the type number
4259 
   reference.
4260 
 
4261 
 */
4262 
 
4263 
static int
4264 
demangle_args (struct work_stuff *work, const char **mangled,
4265 
               string *declp)
4266 
{
4267 
  string arg;
4268 
  int need_comma = 0;
4269 
  int r;
4270 
  int t;
4271 
  const char *tem;
4272 
  char temptype;
4273 
 
4274 
  if (PRINT_ARG_TYPES)
4275 
    {
4276 
      string_append (declp, "(");
4277 
      if (**mangled == '\0')
4278 
        {
4279 
          string_append (declp, "void");
4280 
        }
4281 
    }
4282 
 
4283 
  while ((**mangled != '_' && **mangled != '\0' && **mangled != 'e')
4284 
         || work->nrepeats > 0)
4285 
    {
4286 
      if ((**mangled == 'N') || (**mangled == 'T'))
4287 
        {
4288 
          temptype = *(*mangled)++;
4289 
 
4290 
          if (temptype == 'N')
4291 
            {
4292 
              if (!get_count (mangled, &r))
4293 
                {
4294 
                  return (0);
4295 
                }
4296 
            }
4297 
          else
4298 
            {
4299 
              r = 1;
4300 
            }
4301 
          if ((HP_DEMANGLING || ARM_DEMANGLING || EDG_DEMANGLING) && work -> ntypes >= 10)
4302 
            {
4303 
              /* If we have 10 or more types we might have more than a 1 digit
4304 
                 index so we'll have to consume the whole count here. This
4305 
                 will lose if the next thing is a type name preceded by a
4306 
                 count but it's impossible to demangle that case properly
4307 
                 anyway. Eg if we already have 12 types is T12Pc "(..., type1,
4308 
                 Pc, ...)"  or "(..., type12, char *, ...)" */
4309 
              if ((t = consume_count(mangled)) <= 0)
4310 
                {
4311 
                  return (0);
4312 
                }
4313 
            }
4314 
          else
4315 
            {
4316 
              if (!get_count (mangled, &t))
4317 
                {
4318 
                  return (0);
4319 
                }
4320 
            }
4321 
          if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4322 
            {
4323 
              t--;
4324 
            }
4325 
          /* Validate the type index.  Protect against illegal indices from
4326 
             malformed type strings.  */
4327 
          if ((t < 0) || (t >= work -> ntypes))
4328 
            {
4329 
              return (0);
4330 
            }
4331 
          while (work->nrepeats > 0 || --r >= 0)
4332 
            {
4333 
              tem = work -> typevec[t];
4334 
              if (need_comma && PRINT_ARG_TYPES)
4335 
                {
4336 
                  string_append (declp, ", ");
4337 
                }
4338 
              if (!do_arg (work, &tem, &arg))
4339 
                {
4340 
                  return (0);
4341 
                }
4342 
              if (PRINT_ARG_TYPES)
4343 
                {
4344 
                  string_appends (declp, &arg);
4345 
                }
4346 
              string_delete (&arg);
4347 
              need_comma = 1;
4348 
            }
4349 
        }
4350 
      else
4351 
        {
4352 
          if (need_comma && PRINT_ARG_TYPES)
4353 
            string_append (declp, ", ");
4354 
          if (!do_arg (work, mangled, &arg))
4355 
            return (0);
4356 
          if (PRINT_ARG_TYPES)
4357 
            string_appends (declp, &arg);
4358 
          string_delete (&arg);
4359 
          need_comma = 1;
4360 
        }
4361 
    }
4362 
 
4363 
  if (**mangled == 'e')
4364 
    {
4365 
      (*mangled)++;
4366 
      if (PRINT_ARG_TYPES)
4367 
        {
4368 
          if (need_comma)
4369 
            {
4370 
              string_append (declp, ",");
4371 
            }
4372 
          string_append (declp, "...");
4373 
        }
4374 
    }
4375 
 
4376 
  if (PRINT_ARG_TYPES)
4377 
    {
4378 
      string_append (declp, ")");
4379 
    }
4380 
  return (1);
4381 
}
4382 
 
4383 
/* Like demangle_args, but for demangling the argument lists of function
4384 
   and method pointers or references, not top-level declarations.  */
4385 
 
4386 
static int
4387 
demangle_nested_args (struct work_stuff *work, const char **mangled,
4388 
                      string *declp)
4389 
{
4390 
  string* saved_previous_argument;
4391 
  int result;
4392 
  int saved_nrepeats;
4393 
 
4394 
  /* The G++ name-mangling algorithm does not remember types on nested
4395 
     argument lists, unless -fsquangling is used, and in that case the
4396 
     type vector updated by remember_type is not used.  So, we turn
4397 
     off remembering of types here.  */
4398 
  ++work->forgetting_types;
4399 
 
4400 
  /* For the repeat codes used with -fsquangling, we must keep track of
4401 
     the last argument.  */
4402 
  saved_previous_argument = work->previous_argument;
4403 
  saved_nrepeats = work->nrepeats;
4404 
  work->previous_argument = 0;
4405 
  work->nrepeats = 0;
4406 
 
4407 
  /* Actually demangle the arguments.  */
4408 
  result = demangle_args (work, mangled, declp);
4409 
 
4410 
  /* Restore the previous_argument field.  */
4411 
  if (work->previous_argument)
4412 
    {
4413 
      string_delete (work->previous_argument);
4414 
      free ((char *) work->previous_argument);
4415 
    }
4416 
  work->previous_argument = saved_previous_argument;
4417 
  --work->forgetting_types;
4418 
  work->nrepeats = saved_nrepeats;
4419 
 
4420 
  return result;
4421 
}
4422 
 
4423 
/* Returns 1 if a valid function name was found or 0 otherwise.  */
4424 
 
4425 
static int
4426 
demangle_function_name (struct work_stuff *work, const char **mangled,
4427 
                        string *declp, const char *scan)
4428 
{
4429 
  size_t i;
4430 
  string type;
4431 
  const char *tem;
4432 
 
4433 
  string_appendn (declp, (*mangled), scan - (*mangled));
4434 
  string_need (declp, 1);
4435 
  *(declp -> p) = '\0';
4436 
 
4437 
  /* Consume the function name, including the "__" separating the name
4438 
     from the signature.  We are guaranteed that SCAN points to the
4439 
     separator.  */
4440 
 
4441 
  (*mangled) = scan + 2;
4442 
  /* We may be looking at an instantiation of a template function:
4443 
     foo__Xt1t2_Ft3t4, where t1, t2, ... are template arguments and a
4444 
     following _F marks the start of the function arguments.  Handle
4445 
     the template arguments first. */
4446 
 
4447 
  if (HP_DEMANGLING && (**mangled == 'X'))
4448 
    {
4449 
      demangle_arm_hp_template (work, mangled, 0, declp);
4450 
      /* This leaves MANGLED pointing to the 'F' marking func args */
4451 
    }
4452 
 
4453 
  if (LUCID_DEMANGLING || ARM_DEMANGLING || HP_DEMANGLING || EDG_DEMANGLING)
4454 
    {
4455 
 
4456 
      /* See if we have an ARM style constructor or destructor operator.
4457 
         If so, then just record it, clear the decl, and return.
4458 
         We can't build the actual constructor/destructor decl until later,
4459 
         when we recover the class name from the signature.  */
4460 
 
4461 
      if (strcmp (declp -> b, "__ct") == 0)
4462 
        {
4463 
          work -> constructor += 1;
4464 
          string_clear (declp);
4465 
          return 1;
4466 
        }
4467 
      else if (strcmp (declp -> b, "__dt") == 0)
4468 
        {
4469 
          work -> destructor += 1;
4470 
          string_clear (declp);
4471 
          return 1;
4472 
        }
4473 
    }
4474 
 
4475 
  if (declp->p - declp->b >= 3
4476 
      && declp->b[0] == 'o'
4477 
      && declp->b[1] == 'p'
4478 
      && strchr (cplus_markers, declp->b[2]) != NULL)
4479 
    {
4480 
      /* see if it's an assignment expression */
4481 
      if (declp->p - declp->b >= 10 /* op$assign_ */
4482 
          && memcmp (declp->b + 3, "assign_", 7) == 0)
4483 
        {
4484 
          for (i = 0; i < ARRAY_SIZE (optable); i++)
4485 
            {
4486 
              int len = declp->p - declp->b - 10;
4487 
              if ((int) strlen (optable[i].in) == len
4488 
                  && memcmp (optable[i].in, declp->b + 10, len) == 0)
4489 
                {
4490 
                  string_clear (declp);
4491 
                  string_append (declp, "operator");
4492 
                  string_append (declp, optable[i].out);
4493 
                  string_append (declp, "=");
4494 
                  break;
4495 
                }
4496 
            }
4497 
        }
4498 
      else
4499 
        {
4500 
          for (i = 0; i < ARRAY_SIZE (optable); i++)
4501 
            {
4502 
              int len = declp->p - declp->b - 3;
4503 
              if ((int) strlen (optable[i].in) == len
4504 
                  && memcmp (optable[i].in, declp->b + 3, len) == 0)
4505 
                {
4506 
                  string_clear (declp);
4507 
                  string_append (declp, "operator");
4508 
                  string_append (declp, optable[i].out);
4509 
                  break;
4510 
                }
4511 
            }
4512 
        }
4513 
    }
4514 
  else if (declp->p - declp->b >= 5 && memcmp (declp->b, "type", 4) == 0
4515 
           && strchr (cplus_markers, declp->b[4]) != NULL)
4516 
    {
4517 
      /* type conversion operator */
4518 
      tem = declp->b + 5;
4519 
      if (do_type (work, &tem, &type))
4520 
        {
4521 
          string_clear (declp);
4522 
          string_append (declp, "operator ");
4523 
          string_appends (declp, &type);
4524 
          string_delete (&type);
4525 
        }
4526 
    }
4527 
  else if (declp->b[0] == '_' && declp->b[1] == '_'
4528 
           && declp->b[2] == 'o' && declp->b[3] == 'p')
4529 
    {
4530 
      /* ANSI.  */
4531 
      /* type conversion operator.  */
4532 
      tem = declp->b + 4;
4533 
      if (do_type (work, &tem, &type))
4534 
        {
4535 
          string_clear (declp);
4536 
          string_append (declp, "operator ");
4537 
          string_appends (declp, &type);
4538 
          string_delete (&type);
4539 
        }
4540 
    }
4541 
  else if (declp->b[0] == '_' && declp->b[1] == '_'
4542 
           && ISLOWER((unsigned char)declp->b[2])
4543 
           && ISLOWER((unsigned char)declp->b[3]))
4544 
    {
4545 
      if (declp->b[4] == '\0')
4546 
        {
4547 
          /* Operator.  */
4548 
          for (i = 0; i < ARRAY_SIZE (optable); i++)
4549 
            {
4550 
              if (strlen (optable[i].in) == 2
4551 
                  && memcmp (optable[i].in, declp->b + 2, 2) == 0)
4552 
                {
4553 
                  string_clear (declp);
4554 
                  string_append (declp, "operator");
4555 
                  string_append (declp, optable[i].out);
4556 
                  break;
4557 
                }
4558 
            }
4559 
        }
4560 
      else
4561 
        {
4562 
          if (declp->b[2] == 'a' && declp->b[5] == '\0')
4563 
            {
4564 
              /* Assignment.  */
4565 
              for (i = 0; i < ARRAY_SIZE (optable); i++)
4566 
                {
4567 
                  if (strlen (optable[i].in) == 3
4568 
                      && memcmp (optable[i].in, declp->b + 2, 3) == 0)
4569 
                    {
4570 
                      string_clear (declp);
4571 
                      string_append (declp, "operator");
4572 
                      string_append (declp, optable[i].out);
4573 
                      break;
4574 
                    }
4575 
                }
4576 
            }
4577 
        }
4578 
    }
4579 
 
4580 
  /* If a function name was obtained but it's not valid, we were not
4581 
     successful.  */
4582 
  if (LEN_STRING (declp) == 1 && declp->b[0] == '.')
4583 
    return 0;
4584 
  else
4585 
    return 1;
4586 
}
4587 
 
4588 
/* a mini string-handling package */
4589 
 
4590 
static void
4591 
string_need (string *s, int n)
4592 
{
4593 
  int tem;
4594 
 
4595 
  if (s->b == NULL)
4596 
    {
4597 
      if (n < 32)
4598 
        {
4599 
          n = 32;
4600 
        }
4601 
      s->p = s->b = XNEWVEC (char, n);
4602 
      s->e = s->b + n;
4603 
    }
4604 
  else if (s->e - s->p < n)
4605 
    {
4606 
      tem = s->p - s->b;
4607 
      n += tem;
4608 
      n *= 2;
4609 
      s->b = XRESIZEVEC (char, s->b, n);
4610 
      s->p = s->b + tem;
4611 
      s->e = s->b + n;
4612 
    }
4613 
}
4614 
 
4615 
static void
4616 
string_delete (string *s)
4617 
{
4618 
  if (s->b != NULL)
4619 
    {
4620 
      free (s->b);
4621 
      s->b = s->e = s->p = NULL;
4622 
    }
4623 
}
4624 
 
4625 
static void
4626 
string_init (string *s)
4627 
{
4628 
  s->b = s->p = s->e = NULL;
4629 
}
4630 
 
4631 
static void
4632 
string_clear (string *s)
4633 
{
4634 
  s->p = s->b;
4635 
}
4636 
 
4637 
#if 0
4638 
 
4639 
static int
4640 
string_empty (string *s)
4641 
{
4642 
  return (s->b == s->p);
4643 
}
4644 
 
4645 
#endif
4646 
 
4647 
static void
4648 
string_append (string *p, const char *s)
4649 
{
4650 
  int n;
4651 
  if (s == NULL || *s == '\0')
4652 
    return;
4653 
  n = strlen (s);
4654 
  string_need (p, n);
4655 
  memcpy (p->p, s, n);
4656 
  p->p += n;
4657 
}
4658 
 
4659 
static void
4660 
string_appends (string *p, string *s)
4661 
{
4662 
  int n;
4663 
 
4664 
  if (s->b != s->p)
4665 
    {
4666 
      n = s->p - s->b;
4667 
      string_need (p, n);
4668 
      memcpy (p->p, s->b, n);
4669 
      p->p += n;
4670 
    }
4671 
}
4672 
 
4673 
static void
4674 
string_appendn (string *p, const char *s, int n)
4675 
{
4676 
  if (n != 0)
4677 
    {
4678 
      string_need (p, n);
4679 
      memcpy (p->p, s, n);
4680 
      p->p += n;
4681 
    }
4682 
}
4683 
 
4684 
static void
4685 
string_prepend (string *p, const char *s)
4686 
{
4687 
  if (s != NULL && *s != '\0')
4688 
    {
4689 
      string_prependn (p, s, strlen (s));
4690 
    }
4691 
}
4692 
 
4693 
static void
4694 
string_prepends (string *p, string *s)
4695 
{
4696 
  if (s->b != s->p)
4697 
    {
4698 
      string_prependn (p, s->b, s->p - s->b);
4699 
    }
4700 
}
4701 
 
4702 
static void
4703 
string_prependn (string *p, const char *s, int n)
4704 
{
4705 
  char *q;
4706 
 
4707 
  if (n != 0)
4708 
    {
4709 
      string_need (p, n);
4710 
      for (q = p->p - 1; q >= p->b; q--)
4711 
        {
4712 
          q[n] = q[0];
4713 
        }
4714 
      memcpy (p->b, s, n);
4715 
      p->p += n;
4716 
    }
4717 
}
4718 
 
4719 
static void
4720 
string_append_template_idx (string *s, int idx)
4721 
{
4722 
  char buf[INTBUF_SIZE + 1 /* 'T' */];
4723 
  sprintf(buf, "T%d", idx);
4724 
  string_append (s, buf);
4725 
}

powered by: WebSVN 2.1.0

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