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

Subversion Repositories openrisc_me

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

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

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

powered by: WebSVN 2.1.0

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