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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [libiberty/] [cplus-dem.c] - Blame information for rev 853

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

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

powered by: WebSVN 2.1.0

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