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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [libiberty/] [cp-demangle.c] - Blame information for rev 826

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

Line No. Rev Author Line
1 38 julius
/* Demangler for g++ V3 ABI.
2
   Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
3
   Written by Ian Lance Taylor <ian@wasabisystems.com>.
4
 
5
   This file is part of the libiberty library, which is part of GCC.
6
 
7
   This file is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   In addition to the permissions in the GNU General Public License, the
13
   Free Software Foundation gives you unlimited permission to link the
14
   compiled version of this file into combinations with other programs,
15
   and to distribute those combinations without any restriction coming
16
   from the use of this file.  (The General Public License restrictions
17
   do apply in other respects; for example, they cover modification of
18
   the file, and distribution when not linked into a combined
19
   executable.)
20
 
21
   This program is distributed in the hope that it will be useful,
22
   but WITHOUT ANY WARRANTY; without even the implied warranty of
23
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24
   GNU General Public License for more details.
25
 
26
   You should have received a copy of the GNU General Public License
27
   along with this program; if not, write to the Free Software
28
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
29
*/
30
 
31
/* This code implements a demangler for the g++ V3 ABI.  The ABI is
32
   described on this web page:
33
       http://www.codesourcery.com/cxx-abi/abi.html#mangling
34
 
35
   This code was written while looking at the demangler written by
36
   Alex Samuel <samuel@codesourcery.com>.
37
 
38
   This code first pulls the mangled name apart into a list of
39
   components, and then walks the list generating the demangled
40
   name.
41
 
42
   This file will normally define the following functions, q.v.:
43
      char *cplus_demangle_v3(const char *mangled, int options)
44
      char *java_demangle_v3(const char *mangled)
45
      enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor (const char *name)
46
      enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor (const char *name)
47
 
48
   Also, the interface to the component list is public, and defined in
49
   demangle.h.  The interface consists of these types, which are
50
   defined in demangle.h:
51
      enum demangle_component_type
52
      struct demangle_component
53
   and these functions defined in this file:
54
      cplus_demangle_fill_name
55
      cplus_demangle_fill_extended_operator
56
      cplus_demangle_fill_ctor
57
      cplus_demangle_fill_dtor
58
      cplus_demangle_print
59
   and other functions defined in the file cp-demint.c.
60
 
61
   This file also defines some other functions and variables which are
62
   only to be used by the file cp-demint.c.
63
 
64
   Preprocessor macros you can define while compiling this file:
65
 
66
   IN_LIBGCC2
67
      If defined, this file defines the following function, q.v.:
68
         char *__cxa_demangle (const char *mangled, char *buf, size_t *len,
69
                               int *status)
70
      instead of cplus_demangle_v3() and java_demangle_v3().
71
 
72
   IN_GLIBCPP_V3
73
      If defined, this file defines only __cxa_demangle(), and no other
74
      publically visible functions or variables.
75
 
76
   STANDALONE_DEMANGLER
77
      If defined, this file defines a main() function which demangles
78
      any arguments, or, if none, demangles stdin.
79
 
80
   CP_DEMANGLE_DEBUG
81
      If defined, turns on debugging mode, which prints information on
82
      stdout about the mangled string.  This is not generally useful.
83
*/
84
 
85
#ifdef HAVE_CONFIG_H
86
#include "config.h"
87
#endif
88
 
89
#include <stdio.h>
90
 
91
#ifdef HAVE_STDLIB_H
92
#include <stdlib.h>
93
#endif
94
#ifdef HAVE_STRING_H
95
#include <string.h>
96
#endif
97
 
98
#include "ansidecl.h"
99
#include "libiberty.h"
100
#include "demangle.h"
101
#include "cp-demangle.h"
102
 
103
/* If IN_GLIBCPP_V3 is defined, some functions are made static.  We
104
   also rename them via #define to avoid compiler errors when the
105
   static definition conflicts with the extern declaration in a header
106
   file.  */
107
#ifdef IN_GLIBCPP_V3
108
 
109
#define CP_STATIC_IF_GLIBCPP_V3 static
110
 
111
#define cplus_demangle_fill_name d_fill_name
112
static int d_fill_name (struct demangle_component *, const char *, int);
113
 
114
#define cplus_demangle_fill_extended_operator d_fill_extended_operator
115
static int
116
d_fill_extended_operator (struct demangle_component *, int,
117
                          struct demangle_component *);
118
 
119
#define cplus_demangle_fill_ctor d_fill_ctor
120
static int
121
d_fill_ctor (struct demangle_component *, enum gnu_v3_ctor_kinds,
122
             struct demangle_component *);
123
 
124
#define cplus_demangle_fill_dtor d_fill_dtor
125
static int
126
d_fill_dtor (struct demangle_component *, enum gnu_v3_dtor_kinds,
127
             struct demangle_component *);
128
 
129
#define cplus_demangle_mangled_name d_mangled_name
130
static struct demangle_component *d_mangled_name (struct d_info *, int);
131
 
132
#define cplus_demangle_type d_type
133
static struct demangle_component *d_type (struct d_info *);
134
 
135
#define cplus_demangle_print d_print
136
static char *d_print (int, const struct demangle_component *, int, size_t *);
137
 
138
#define cplus_demangle_init_info d_init_info
139
static void d_init_info (const char *, int, size_t, struct d_info *);
140
 
141
#else /* ! defined(IN_GLIBCPP_V3) */
142
#define CP_STATIC_IF_GLIBCPP_V3
143
#endif /* ! defined(IN_GLIBCPP_V3) */
144
 
145
/* See if the compiler supports dynamic arrays.  */
146
 
147
#ifdef __GNUC__
148
#define CP_DYNAMIC_ARRAYS
149
#else
150
#ifdef __STDC__
151
#ifdef __STDC_VERSION__
152
#if __STDC_VERSION__ >= 199901L
153
#define CP_DYNAMIC_ARRAYS
154
#endif /* __STDC__VERSION >= 199901L */
155
#endif /* defined (__STDC_VERSION__) */
156
#endif /* defined (__STDC__) */
157
#endif /* ! defined (__GNUC__) */
158
 
159
/* We avoid pulling in the ctype tables, to prevent pulling in
160
   additional unresolved symbols when this code is used in a library.
161
   FIXME: Is this really a valid reason?  This comes from the original
162
   V3 demangler code.
163
 
164
   As of this writing this file has the following undefined references
165
   when compiled with -DIN_GLIBCPP_V3: malloc, realloc, free, memcpy,
166
   strcpy, strcat, strlen.  */
167
 
168
#define IS_DIGIT(c) ((c) >= '0' && (c) <= '9')
169
#define IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')
170
#define IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')
171
 
172
/* The prefix prepended by GCC to an identifier represnting the
173
   anonymous namespace.  */
174
#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"
175
#define ANONYMOUS_NAMESPACE_PREFIX_LEN \
176
  (sizeof (ANONYMOUS_NAMESPACE_PREFIX) - 1)
177
 
178
/* Information we keep for the standard substitutions.  */
179
 
180
struct d_standard_sub_info
181
{
182
  /* The code for this substitution.  */
183
  char code;
184
  /* The simple string it expands to.  */
185
  const char *simple_expansion;
186
  /* The length of the simple expansion.  */
187
  int simple_len;
188
  /* The results of a full, verbose, expansion.  This is used when
189
     qualifying a constructor/destructor, or when in verbose mode.  */
190
  const char *full_expansion;
191
  /* The length of the full expansion.  */
192
  int full_len;
193
  /* What to set the last_name field of d_info to; NULL if we should
194
     not set it.  This is only relevant when qualifying a
195
     constructor/destructor.  */
196
  const char *set_last_name;
197
  /* The length of set_last_name.  */
198
  int set_last_name_len;
199
};
200
 
201
/* Accessors for subtrees of struct demangle_component.  */
202
 
203
#define d_left(dc) ((dc)->u.s_binary.left)
204
#define d_right(dc) ((dc)->u.s_binary.right)
205
 
206
/* A list of templates.  This is used while printing.  */
207
 
208
struct d_print_template
209
{
210
  /* Next template on the list.  */
211
  struct d_print_template *next;
212
  /* This template.  */
213
  const struct demangle_component *template_decl;
214
};
215
 
216
/* A list of type modifiers.  This is used while printing.  */
217
 
218
struct d_print_mod
219
{
220
  /* Next modifier on the list.  These are in the reverse of the order
221
     in which they appeared in the mangled string.  */
222
  struct d_print_mod *next;
223
  /* The modifier.  */
224
  const struct demangle_component *mod;
225
  /* Whether this modifier was printed.  */
226
  int printed;
227
  /* The list of templates which applies to this modifier.  */
228
  struct d_print_template *templates;
229
};
230
 
231
/* We use this structure to hold information during printing.  */
232
 
233
struct d_print_info
234
{
235
  /* The options passed to the demangler.  */
236
  int options;
237
  /* Buffer holding the result.  */
238
  char *buf;
239
  /* Current length of data in buffer.  */
240
  size_t len;
241
  /* Allocated size of buffer.  */
242
  size_t alc;
243
  /* The current list of templates, if any.  */
244
  struct d_print_template *templates;
245
  /* The current list of modifiers (e.g., pointer, reference, etc.),
246
     if any.  */
247
  struct d_print_mod *modifiers;
248
  /* Set to 1 if we had a memory allocation failure.  */
249
  int allocation_failure;
250
};
251
 
252
#define d_print_saw_error(dpi) ((dpi)->buf == NULL)
253
 
254
#define d_append_char(dpi, c) \
255
  do \
256
    { \
257
      if ((dpi)->buf != NULL && (dpi)->len < (dpi)->alc) \
258
        (dpi)->buf[(dpi)->len++] = (c); \
259
      else \
260
        d_print_append_char ((dpi), (c)); \
261
    } \
262
  while (0)
263
 
264
#define d_append_buffer(dpi, s, l) \
265
  do \
266
    { \
267
      if ((dpi)->buf != NULL && (dpi)->len + (l) <= (dpi)->alc) \
268
        { \
269
          memcpy ((dpi)->buf + (dpi)->len, (s), (l)); \
270
          (dpi)->len += l; \
271
        } \
272
      else \
273
        d_print_append_buffer ((dpi), (s), (l)); \
274
    } \
275
  while (0)
276
 
277
#define d_append_string_constant(dpi, s) \
278
  d_append_buffer (dpi, (s), sizeof (s) - 1)
279
 
280
#define d_last_char(dpi) \
281
  ((dpi)->buf == NULL || (dpi)->len == 0 ? '\0' : (dpi)->buf[(dpi)->len - 1])
282
 
283
#ifdef CP_DEMANGLE_DEBUG
284
static void d_dump (struct demangle_component *, int);
285
#endif
286
 
287
static struct demangle_component *
288
d_make_empty (struct d_info *);
289
 
290
static struct demangle_component *
291
d_make_comp (struct d_info *, enum demangle_component_type,
292
             struct demangle_component *,
293
             struct demangle_component *);
294
 
295
static struct demangle_component *
296
d_make_name (struct d_info *, const char *, int);
297
 
298
static struct demangle_component *
299
d_make_builtin_type (struct d_info *,
300
                     const struct demangle_builtin_type_info *);
301
 
302
static struct demangle_component *
303
d_make_operator (struct d_info *,
304
                 const struct demangle_operator_info *);
305
 
306
static struct demangle_component *
307
d_make_extended_operator (struct d_info *, int,
308
                          struct demangle_component *);
309
 
310
static struct demangle_component *
311
d_make_ctor (struct d_info *, enum gnu_v3_ctor_kinds,
312
             struct demangle_component *);
313
 
314
static struct demangle_component *
315
d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
316
             struct demangle_component *);
317
 
318
static struct demangle_component *
319
d_make_template_param (struct d_info *, long);
320
 
321
static struct demangle_component *
322
d_make_sub (struct d_info *, const char *, int);
323
 
324
static int
325
has_return_type (struct demangle_component *);
326
 
327
static int
328
is_ctor_dtor_or_conversion (struct demangle_component *);
329
 
330
static struct demangle_component *d_encoding (struct d_info *, int);
331
 
332
static struct demangle_component *d_name (struct d_info *);
333
 
334
static struct demangle_component *d_nested_name (struct d_info *);
335
 
336
static struct demangle_component *d_prefix (struct d_info *);
337
 
338
static struct demangle_component *d_unqualified_name (struct d_info *);
339
 
340
static struct demangle_component *d_source_name (struct d_info *);
341
 
342
static long d_number (struct d_info *);
343
 
344
static struct demangle_component *d_identifier (struct d_info *, int);
345
 
346
static struct demangle_component *d_operator_name (struct d_info *);
347
 
348
static struct demangle_component *d_special_name (struct d_info *);
349
 
350
static int d_call_offset (struct d_info *, int);
351
 
352
static struct demangle_component *d_ctor_dtor_name (struct d_info *);
353
 
354
static struct demangle_component **
355
d_cv_qualifiers (struct d_info *, struct demangle_component **, int);
356
 
357
static struct demangle_component *
358
d_function_type (struct d_info *);
359
 
360
static struct demangle_component *
361
d_bare_function_type (struct d_info *, int);
362
 
363
static struct demangle_component *
364
d_class_enum_type (struct d_info *);
365
 
366
static struct demangle_component *d_array_type (struct d_info *);
367
 
368
static struct demangle_component *
369
d_pointer_to_member_type (struct d_info *);
370
 
371
static struct demangle_component *
372
d_template_param (struct d_info *);
373
 
374
static struct demangle_component *d_template_args (struct d_info *);
375
 
376
static struct demangle_component *
377
d_template_arg (struct d_info *);
378
 
379
static struct demangle_component *d_expression (struct d_info *);
380
 
381
static struct demangle_component *d_expr_primary (struct d_info *);
382
 
383
static struct demangle_component *d_local_name (struct d_info *);
384
 
385
static int d_discriminator (struct d_info *);
386
 
387
static int
388
d_add_substitution (struct d_info *, struct demangle_component *);
389
 
390
static struct demangle_component *d_substitution (struct d_info *, int);
391
 
392
static void d_print_resize (struct d_print_info *, size_t);
393
 
394
static void d_print_append_char (struct d_print_info *, int);
395
 
396
static void
397
d_print_append_buffer (struct d_print_info *, const char *, size_t);
398
 
399
static void d_print_error (struct d_print_info *);
400
 
401
static void
402
d_print_comp (struct d_print_info *, const struct demangle_component *);
403
 
404
static void
405
d_print_java_identifier (struct d_print_info *, const char *, int);
406
 
407
static void
408
d_print_mod_list (struct d_print_info *, struct d_print_mod *, int);
409
 
410
static void
411
d_print_mod (struct d_print_info *, const struct demangle_component *);
412
 
413
static void
414
d_print_function_type (struct d_print_info *,
415
                       const struct demangle_component *,
416
                       struct d_print_mod *);
417
 
418
static void
419
d_print_array_type (struct d_print_info *,
420
                    const struct demangle_component *,
421
                    struct d_print_mod *);
422
 
423
static void
424
d_print_expr_op (struct d_print_info *, const struct demangle_component *);
425
 
426
static void
427
d_print_cast (struct d_print_info *, const struct demangle_component *);
428
 
429
static char *d_demangle (const char *, int, size_t *);
430
 
431
#ifdef CP_DEMANGLE_DEBUG
432
 
433
static void
434
d_dump (struct demangle_component *dc, int indent)
435
{
436
  int i;
437
 
438
  if (dc == NULL)
439
    return;
440
 
441
  for (i = 0; i < indent; ++i)
442
    putchar (' ');
443
 
444
  switch (dc->type)
445
    {
446
    case DEMANGLE_COMPONENT_NAME:
447
      printf ("name '%.*s'\n", dc->u.s_name.len, dc->u.s_name.s);
448
      return;
449
    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
450
      printf ("template parameter %ld\n", dc->u.s_number.number);
451
      return;
452
    case DEMANGLE_COMPONENT_CTOR:
453
      printf ("constructor %d\n", (int) dc->u.s_ctor.kind);
454
      d_dump (dc->u.s_ctor.name, indent + 2);
455
      return;
456
    case DEMANGLE_COMPONENT_DTOR:
457
      printf ("destructor %d\n", (int) dc->u.s_dtor.kind);
458
      d_dump (dc->u.s_dtor.name, indent + 2);
459
      return;
460
    case DEMANGLE_COMPONENT_SUB_STD:
461
      printf ("standard substitution %s\n", dc->u.s_string.string);
462
      return;
463
    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
464
      printf ("builtin type %s\n", dc->u.s_builtin.type->name);
465
      return;
466
    case DEMANGLE_COMPONENT_OPERATOR:
467
      printf ("operator %s\n", dc->u.s_operator.op->name);
468
      return;
469
    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
470
      printf ("extended operator with %d args\n",
471
              dc->u.s_extended_operator.args);
472
      d_dump (dc->u.s_extended_operator.name, indent + 2);
473
      return;
474
 
475
    case DEMANGLE_COMPONENT_QUAL_NAME:
476
      printf ("qualified name\n");
477
      break;
478
    case DEMANGLE_COMPONENT_LOCAL_NAME:
479
      printf ("local name\n");
480
      break;
481
    case DEMANGLE_COMPONENT_TYPED_NAME:
482
      printf ("typed name\n");
483
      break;
484
    case DEMANGLE_COMPONENT_TEMPLATE:
485
      printf ("template\n");
486
      break;
487
    case DEMANGLE_COMPONENT_VTABLE:
488
      printf ("vtable\n");
489
      break;
490
    case DEMANGLE_COMPONENT_VTT:
491
      printf ("VTT\n");
492
      break;
493
    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
494
      printf ("construction vtable\n");
495
      break;
496
    case DEMANGLE_COMPONENT_TYPEINFO:
497
      printf ("typeinfo\n");
498
      break;
499
    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
500
      printf ("typeinfo name\n");
501
      break;
502
    case DEMANGLE_COMPONENT_TYPEINFO_FN:
503
      printf ("typeinfo function\n");
504
      break;
505
    case DEMANGLE_COMPONENT_THUNK:
506
      printf ("thunk\n");
507
      break;
508
    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
509
      printf ("virtual thunk\n");
510
      break;
511
    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
512
      printf ("covariant thunk\n");
513
      break;
514
    case DEMANGLE_COMPONENT_JAVA_CLASS:
515
      printf ("java class\n");
516
      break;
517
    case DEMANGLE_COMPONENT_GUARD:
518
      printf ("guard\n");
519
      break;
520
    case DEMANGLE_COMPONENT_REFTEMP:
521
      printf ("reference temporary\n");
522
      break;
523
    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
524
      printf ("hidden alias\n");
525
      break;
526
    case DEMANGLE_COMPONENT_RESTRICT:
527
      printf ("restrict\n");
528
      break;
529
    case DEMANGLE_COMPONENT_VOLATILE:
530
      printf ("volatile\n");
531
      break;
532
    case DEMANGLE_COMPONENT_CONST:
533
      printf ("const\n");
534
      break;
535
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
536
      printf ("restrict this\n");
537
      break;
538
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
539
      printf ("volatile this\n");
540
      break;
541
    case DEMANGLE_COMPONENT_CONST_THIS:
542
      printf ("const this\n");
543
      break;
544
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
545
      printf ("vendor type qualifier\n");
546
      break;
547
    case DEMANGLE_COMPONENT_POINTER:
548
      printf ("pointer\n");
549
      break;
550
    case DEMANGLE_COMPONENT_REFERENCE:
551
      printf ("reference\n");
552
      break;
553
    case DEMANGLE_COMPONENT_COMPLEX:
554
      printf ("complex\n");
555
      break;
556
    case DEMANGLE_COMPONENT_IMAGINARY:
557
      printf ("imaginary\n");
558
      break;
559
    case DEMANGLE_COMPONENT_VENDOR_TYPE:
560
      printf ("vendor type\n");
561
      break;
562
    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
563
      printf ("function type\n");
564
      break;
565
    case DEMANGLE_COMPONENT_ARRAY_TYPE:
566
      printf ("array type\n");
567
      break;
568
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
569
      printf ("pointer to member type\n");
570
      break;
571
    case DEMANGLE_COMPONENT_ARGLIST:
572
      printf ("argument list\n");
573
      break;
574
    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
575
      printf ("template argument list\n");
576
      break;
577
    case DEMANGLE_COMPONENT_CAST:
578
      printf ("cast\n");
579
      break;
580
    case DEMANGLE_COMPONENT_UNARY:
581
      printf ("unary operator\n");
582
      break;
583
    case DEMANGLE_COMPONENT_BINARY:
584
      printf ("binary operator\n");
585
      break;
586
    case DEMANGLE_COMPONENT_BINARY_ARGS:
587
      printf ("binary operator arguments\n");
588
      break;
589
    case DEMANGLE_COMPONENT_TRINARY:
590
      printf ("trinary operator\n");
591
      break;
592
    case DEMANGLE_COMPONENT_TRINARY_ARG1:
593
      printf ("trinary operator arguments 1\n");
594
      break;
595
    case DEMANGLE_COMPONENT_TRINARY_ARG2:
596
      printf ("trinary operator arguments 1\n");
597
      break;
598
    case DEMANGLE_COMPONENT_LITERAL:
599
      printf ("literal\n");
600
      break;
601
    case DEMANGLE_COMPONENT_LITERAL_NEG:
602
      printf ("negative literal\n");
603
      break;
604
    }
605
 
606
  d_dump (d_left (dc), indent + 2);
607
  d_dump (d_right (dc), indent + 2);
608
}
609
 
610
#endif /* CP_DEMANGLE_DEBUG */
611
 
612
/* Fill in a DEMANGLE_COMPONENT_NAME.  */
613
 
614
CP_STATIC_IF_GLIBCPP_V3
615
int
616
cplus_demangle_fill_name (struct demangle_component *p, const char *s, int len)
617
{
618
  if (p == NULL || s == NULL || len == 0)
619
    return 0;
620
  p->type = DEMANGLE_COMPONENT_NAME;
621
  p->u.s_name.s = s;
622
  p->u.s_name.len = len;
623
  return 1;
624
}
625
 
626
/* Fill in a DEMANGLE_COMPONENT_EXTENDED_OPERATOR.  */
627
 
628
CP_STATIC_IF_GLIBCPP_V3
629
int
630
cplus_demangle_fill_extended_operator (struct demangle_component *p, int args,
631
                                       struct demangle_component *name)
632
{
633
  if (p == NULL || args < 0 || name == NULL)
634
    return 0;
635
  p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
636
  p->u.s_extended_operator.args = args;
637
  p->u.s_extended_operator.name = name;
638
  return 1;
639
}
640
 
641
/* Fill in a DEMANGLE_COMPONENT_CTOR.  */
642
 
643
CP_STATIC_IF_GLIBCPP_V3
644
int
645
cplus_demangle_fill_ctor (struct demangle_component *p,
646
                          enum gnu_v3_ctor_kinds kind,
647
                          struct demangle_component *name)
648
{
649
  if (p == NULL
650
      || name == NULL
651
      || (kind < gnu_v3_complete_object_ctor
652
          && kind > gnu_v3_complete_object_allocating_ctor))
653
    return 0;
654
  p->type = DEMANGLE_COMPONENT_CTOR;
655
  p->u.s_ctor.kind = kind;
656
  p->u.s_ctor.name = name;
657
  return 1;
658
}
659
 
660
/* Fill in a DEMANGLE_COMPONENT_DTOR.  */
661
 
662
CP_STATIC_IF_GLIBCPP_V3
663
int
664
cplus_demangle_fill_dtor (struct demangle_component *p,
665
                          enum gnu_v3_dtor_kinds kind,
666
                          struct demangle_component *name)
667
{
668
  if (p == NULL
669
      || name == NULL
670
      || (kind < gnu_v3_deleting_dtor
671
          && kind > gnu_v3_base_object_dtor))
672
    return 0;
673
  p->type = DEMANGLE_COMPONENT_DTOR;
674
  p->u.s_dtor.kind = kind;
675
  p->u.s_dtor.name = name;
676
  return 1;
677
}
678
 
679
/* Add a new component.  */
680
 
681
static struct demangle_component *
682
d_make_empty (struct d_info *di)
683
{
684
  struct demangle_component *p;
685
 
686
  if (di->next_comp >= di->num_comps)
687
    return NULL;
688
  p = &di->comps[di->next_comp];
689
  ++di->next_comp;
690
  return p;
691
}
692
 
693
/* Add a new generic component.  */
694
 
695
static struct demangle_component *
696
d_make_comp (struct d_info *di, enum demangle_component_type type,
697
             struct demangle_component *left,
698
             struct demangle_component *right)
699
{
700
  struct demangle_component *p;
701
 
702
  /* We check for errors here.  A typical error would be a NULL return
703
     from a subroutine.  We catch those here, and return NULL
704
     upward.  */
705
  switch (type)
706
    {
707
      /* These types require two parameters.  */
708
    case DEMANGLE_COMPONENT_QUAL_NAME:
709
    case DEMANGLE_COMPONENT_LOCAL_NAME:
710
    case DEMANGLE_COMPONENT_TYPED_NAME:
711
    case DEMANGLE_COMPONENT_TEMPLATE:
712
    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
713
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
714
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
715
    case DEMANGLE_COMPONENT_UNARY:
716
    case DEMANGLE_COMPONENT_BINARY:
717
    case DEMANGLE_COMPONENT_BINARY_ARGS:
718
    case DEMANGLE_COMPONENT_TRINARY:
719
    case DEMANGLE_COMPONENT_TRINARY_ARG1:
720
    case DEMANGLE_COMPONENT_TRINARY_ARG2:
721
    case DEMANGLE_COMPONENT_LITERAL:
722
    case DEMANGLE_COMPONENT_LITERAL_NEG:
723
      if (left == NULL || right == NULL)
724
        return NULL;
725
      break;
726
 
727
      /* These types only require one parameter.  */
728
    case DEMANGLE_COMPONENT_VTABLE:
729
    case DEMANGLE_COMPONENT_VTT:
730
    case DEMANGLE_COMPONENT_TYPEINFO:
731
    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
732
    case DEMANGLE_COMPONENT_TYPEINFO_FN:
733
    case DEMANGLE_COMPONENT_THUNK:
734
    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
735
    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
736
    case DEMANGLE_COMPONENT_JAVA_CLASS:
737
    case DEMANGLE_COMPONENT_GUARD:
738
    case DEMANGLE_COMPONENT_REFTEMP:
739
    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
740
    case DEMANGLE_COMPONENT_POINTER:
741
    case DEMANGLE_COMPONENT_REFERENCE:
742
    case DEMANGLE_COMPONENT_COMPLEX:
743
    case DEMANGLE_COMPONENT_IMAGINARY:
744
    case DEMANGLE_COMPONENT_VENDOR_TYPE:
745
    case DEMANGLE_COMPONENT_ARGLIST:
746
    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
747
    case DEMANGLE_COMPONENT_CAST:
748
      if (left == NULL)
749
        return NULL;
750
      break;
751
 
752
      /* This needs a right parameter, but the left parameter can be
753
         empty.  */
754
    case DEMANGLE_COMPONENT_ARRAY_TYPE:
755
      if (right == NULL)
756
        return NULL;
757
      break;
758
 
759
      /* These are allowed to have no parameters--in some cases they
760
         will be filled in later.  */
761
    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
762
    case DEMANGLE_COMPONENT_RESTRICT:
763
    case DEMANGLE_COMPONENT_VOLATILE:
764
    case DEMANGLE_COMPONENT_CONST:
765
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
766
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
767
    case DEMANGLE_COMPONENT_CONST_THIS:
768
      break;
769
 
770
      /* Other types should not be seen here.  */
771
    default:
772
      return NULL;
773
    }
774
 
775
  p = d_make_empty (di);
776
  if (p != NULL)
777
    {
778
      p->type = type;
779
      p->u.s_binary.left = left;
780
      p->u.s_binary.right = right;
781
    }
782
  return p;
783
}
784
 
785
/* Add a new name component.  */
786
 
787
static struct demangle_component *
788
d_make_name (struct d_info *di, const char *s, int len)
789
{
790
  struct demangle_component *p;
791
 
792
  p = d_make_empty (di);
793
  if (! cplus_demangle_fill_name (p, s, len))
794
    return NULL;
795
  return p;
796
}
797
 
798
/* Add a new builtin type component.  */
799
 
800
static struct demangle_component *
801
d_make_builtin_type (struct d_info *di,
802
                     const struct demangle_builtin_type_info *type)
803
{
804
  struct demangle_component *p;
805
 
806
  if (type == NULL)
807
    return NULL;
808
  p = d_make_empty (di);
809
  if (p != NULL)
810
    {
811
      p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
812
      p->u.s_builtin.type = type;
813
    }
814
  return p;
815
}
816
 
817
/* Add a new operator component.  */
818
 
819
static struct demangle_component *
820
d_make_operator (struct d_info *di, const struct demangle_operator_info *op)
821
{
822
  struct demangle_component *p;
823
 
824
  p = d_make_empty (di);
825
  if (p != NULL)
826
    {
827
      p->type = DEMANGLE_COMPONENT_OPERATOR;
828
      p->u.s_operator.op = op;
829
    }
830
  return p;
831
}
832
 
833
/* Add a new extended operator component.  */
834
 
835
static struct demangle_component *
836
d_make_extended_operator (struct d_info *di, int args,
837
                          struct demangle_component *name)
838
{
839
  struct demangle_component *p;
840
 
841
  p = d_make_empty (di);
842
  if (! cplus_demangle_fill_extended_operator (p, args, name))
843
    return NULL;
844
  return p;
845
}
846
 
847
/* Add a new constructor component.  */
848
 
849
static struct demangle_component *
850
d_make_ctor (struct d_info *di, enum gnu_v3_ctor_kinds kind,
851
             struct demangle_component *name)
852
{
853
  struct demangle_component *p;
854
 
855
  p = d_make_empty (di);
856
  if (! cplus_demangle_fill_ctor (p, kind, name))
857
    return NULL;
858
  return p;
859
}
860
 
861
/* Add a new destructor component.  */
862
 
863
static struct demangle_component *
864
d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
865
             struct demangle_component *name)
866
{
867
  struct demangle_component *p;
868
 
869
  p = d_make_empty (di);
870
  if (! cplus_demangle_fill_dtor (p, kind, name))
871
    return NULL;
872
  return p;
873
}
874
 
875
/* Add a new template parameter.  */
876
 
877
static struct demangle_component *
878
d_make_template_param (struct d_info *di, long i)
879
{
880
  struct demangle_component *p;
881
 
882
  p = d_make_empty (di);
883
  if (p != NULL)
884
    {
885
      p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
886
      p->u.s_number.number = i;
887
    }
888
  return p;
889
}
890
 
891
/* Add a new standard substitution component.  */
892
 
893
static struct demangle_component *
894
d_make_sub (struct d_info *di, const char *name, int len)
895
{
896
  struct demangle_component *p;
897
 
898
  p = d_make_empty (di);
899
  if (p != NULL)
900
    {
901
      p->type = DEMANGLE_COMPONENT_SUB_STD;
902
      p->u.s_string.string = name;
903
      p->u.s_string.len = len;
904
    }
905
  return p;
906
}
907
 
908
/* <mangled-name> ::= _Z <encoding>
909
 
910
   TOP_LEVEL is non-zero when called at the top level.  */
911
 
912
CP_STATIC_IF_GLIBCPP_V3
913
struct demangle_component *
914
cplus_demangle_mangled_name (struct d_info *di, int top_level)
915
{
916
  if (d_next_char (di) != '_')
917
    return NULL;
918
  if (d_next_char (di) != 'Z')
919
    return NULL;
920
  return d_encoding (di, top_level);
921
}
922
 
923
/* Return whether a function should have a return type.  The argument
924
   is the function name, which may be qualified in various ways.  The
925
   rules are that template functions have return types with some
926
   exceptions, function types which are not part of a function name
927
   mangling have return types with some exceptions, and non-template
928
   function names do not have return types.  The exceptions are that
929
   constructors, destructors, and conversion operators do not have
930
   return types.  */
931
 
932
static int
933
has_return_type (struct demangle_component *dc)
934
{
935
  if (dc == NULL)
936
    return 0;
937
  switch (dc->type)
938
    {
939
    default:
940
      return 0;
941
    case DEMANGLE_COMPONENT_TEMPLATE:
942
      return ! is_ctor_dtor_or_conversion (d_left (dc));
943
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
944
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
945
    case DEMANGLE_COMPONENT_CONST_THIS:
946
      return has_return_type (d_left (dc));
947
    }
948
}
949
 
950
/* Return whether a name is a constructor, a destructor, or a
951
   conversion operator.  */
952
 
953
static int
954
is_ctor_dtor_or_conversion (struct demangle_component *dc)
955
{
956
  if (dc == NULL)
957
    return 0;
958
  switch (dc->type)
959
    {
960
    default:
961
      return 0;
962
    case DEMANGLE_COMPONENT_QUAL_NAME:
963
    case DEMANGLE_COMPONENT_LOCAL_NAME:
964
      return is_ctor_dtor_or_conversion (d_right (dc));
965
    case DEMANGLE_COMPONENT_CTOR:
966
    case DEMANGLE_COMPONENT_DTOR:
967
    case DEMANGLE_COMPONENT_CAST:
968
      return 1;
969
    }
970
}
971
 
972
/* <encoding> ::= <(function) name> <bare-function-type>
973
              ::= <(data) name>
974
              ::= <special-name>
975
 
976
   TOP_LEVEL is non-zero when called at the top level, in which case
977
   if DMGL_PARAMS is not set we do not demangle the function
978
   parameters.  We only set this at the top level, because otherwise
979
   we would not correctly demangle names in local scopes.  */
980
 
981
static struct demangle_component *
982
d_encoding (struct d_info *di, int top_level)
983
{
984
  char peek = d_peek_char (di);
985
 
986
  if (peek == 'G' || peek == 'T')
987
    return d_special_name (di);
988
  else
989
    {
990
      struct demangle_component *dc;
991
 
992
      dc = d_name (di);
993
 
994
      if (dc != NULL && top_level && (di->options & DMGL_PARAMS) == 0)
995
        {
996
          /* Strip off any initial CV-qualifiers, as they really apply
997
             to the `this' parameter, and they were not output by the
998
             v2 demangler without DMGL_PARAMS.  */
999
          while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1000
                 || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1001
                 || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
1002
            dc = d_left (dc);
1003
 
1004
          /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
1005
             there may be CV-qualifiers on its right argument which
1006
             really apply here; this happens when parsing a class
1007
             which is local to a function.  */
1008
          if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
1009
            {
1010
              struct demangle_component *dcr;
1011
 
1012
              dcr = d_right (dc);
1013
              while (dcr->type == DEMANGLE_COMPONENT_RESTRICT_THIS
1014
                     || dcr->type == DEMANGLE_COMPONENT_VOLATILE_THIS
1015
                     || dcr->type == DEMANGLE_COMPONENT_CONST_THIS)
1016
                dcr = d_left (dcr);
1017
              dc->u.s_binary.right = dcr;
1018
            }
1019
 
1020
          return dc;
1021
        }
1022
 
1023
      peek = d_peek_char (di);
1024
      if (peek == '\0' || peek == 'E')
1025
        return dc;
1026
      return d_make_comp (di, DEMANGLE_COMPONENT_TYPED_NAME, dc,
1027
                          d_bare_function_type (di, has_return_type (dc)));
1028
    }
1029
}
1030
 
1031
/* <name> ::= <nested-name>
1032
          ::= <unscoped-name>
1033
          ::= <unscoped-template-name> <template-args>
1034
          ::= <local-name>
1035
 
1036
   <unscoped-name> ::= <unqualified-name>
1037
                   ::= St <unqualified-name>
1038
 
1039
   <unscoped-template-name> ::= <unscoped-name>
1040
                            ::= <substitution>
1041
*/
1042
 
1043
static struct demangle_component *
1044
d_name (struct d_info *di)
1045
{
1046
  char peek = d_peek_char (di);
1047
  struct demangle_component *dc;
1048
 
1049
  switch (peek)
1050
    {
1051
    case 'N':
1052
      return d_nested_name (di);
1053
 
1054
    case 'Z':
1055
      return d_local_name (di);
1056
 
1057
    case 'S':
1058
      {
1059
        int subst;
1060
 
1061
        if (d_peek_next_char (di) != 't')
1062
          {
1063
            dc = d_substitution (di, 0);
1064
            subst = 1;
1065
          }
1066
        else
1067
          {
1068
            d_advance (di, 2);
1069
            dc = d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME,
1070
                              d_make_name (di, "std", 3),
1071
                              d_unqualified_name (di));
1072
            di->expansion += 3;
1073
            subst = 0;
1074
          }
1075
 
1076
        if (d_peek_char (di) != 'I')
1077
          {
1078
            /* The grammar does not permit this case to occur if we
1079
               called d_substitution() above (i.e., subst == 1).  We
1080
               don't bother to check.  */
1081
          }
1082
        else
1083
          {
1084
            /* This is <template-args>, which means that we just saw
1085
               <unscoped-template-name>, which is a substitution
1086
               candidate if we didn't just get it from a
1087
               substitution.  */
1088
            if (! subst)
1089
              {
1090
                if (! d_add_substitution (di, dc))
1091
                  return NULL;
1092
              }
1093
            dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1094
                              d_template_args (di));
1095
          }
1096
 
1097
        return dc;
1098
      }
1099
 
1100
    default:
1101
      dc = d_unqualified_name (di);
1102
      if (d_peek_char (di) == 'I')
1103
        {
1104
          /* This is <template-args>, which means that we just saw
1105
             <unscoped-template-name>, which is a substitution
1106
             candidate.  */
1107
          if (! d_add_substitution (di, dc))
1108
            return NULL;
1109
          dc = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, dc,
1110
                            d_template_args (di));
1111
        }
1112
      return dc;
1113
    }
1114
}
1115
 
1116
/* <nested-name> ::= N [<CV-qualifiers>] <prefix> <unqualified-name> E
1117
                 ::= N [<CV-qualifiers>] <template-prefix> <template-args> E
1118
*/
1119
 
1120
static struct demangle_component *
1121
d_nested_name (struct d_info *di)
1122
{
1123
  struct demangle_component *ret;
1124
  struct demangle_component **pret;
1125
 
1126
  if (d_next_char (di) != 'N')
1127
    return NULL;
1128
 
1129
  pret = d_cv_qualifiers (di, &ret, 1);
1130
  if (pret == NULL)
1131
    return NULL;
1132
 
1133
  *pret = d_prefix (di);
1134
  if (*pret == NULL)
1135
    return NULL;
1136
 
1137
  if (d_next_char (di) != 'E')
1138
    return NULL;
1139
 
1140
  return ret;
1141
}
1142
 
1143
/* <prefix> ::= <prefix> <unqualified-name>
1144
            ::= <template-prefix> <template-args>
1145
            ::= <template-param>
1146
            ::=
1147
            ::= <substitution>
1148
 
1149
   <template-prefix> ::= <prefix> <(template) unqualified-name>
1150
                     ::= <template-param>
1151
                     ::= <substitution>
1152
*/
1153
 
1154
static struct demangle_component *
1155
d_prefix (struct d_info *di)
1156
{
1157
  struct demangle_component *ret = NULL;
1158
 
1159
  while (1)
1160
    {
1161
      char peek;
1162
      enum demangle_component_type comb_type;
1163
      struct demangle_component *dc;
1164
 
1165
      peek = d_peek_char (di);
1166
      if (peek == '\0')
1167
        return NULL;
1168
 
1169
      /* The older code accepts a <local-name> here, but I don't see
1170
         that in the grammar.  The older code does not accept a
1171
         <template-param> here.  */
1172
 
1173
      comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
1174
      if (IS_DIGIT (peek)
1175
          || IS_LOWER (peek)
1176
          || peek == 'C'
1177
          || peek == 'D')
1178
        dc = d_unqualified_name (di);
1179
      else if (peek == 'S')
1180
        dc = d_substitution (di, 1);
1181
      else if (peek == 'I')
1182
        {
1183
          if (ret == NULL)
1184
            return NULL;
1185
          comb_type = DEMANGLE_COMPONENT_TEMPLATE;
1186
          dc = d_template_args (di);
1187
        }
1188
      else if (peek == 'T')
1189
        dc = d_template_param (di);
1190
      else if (peek == 'E')
1191
        return ret;
1192
      else
1193
        return NULL;
1194
 
1195
      if (ret == NULL)
1196
        ret = dc;
1197
      else
1198
        ret = d_make_comp (di, comb_type, ret, dc);
1199
 
1200
      if (peek != 'S' && d_peek_char (di) != 'E')
1201
        {
1202
          if (! d_add_substitution (di, ret))
1203
            return NULL;
1204
        }
1205
    }
1206
}
1207
 
1208
/* <unqualified-name> ::= <operator-name>
1209
                      ::= <ctor-dtor-name>
1210
                      ::= <source-name>
1211
*/
1212
 
1213
static struct demangle_component *
1214
d_unqualified_name (struct d_info *di)
1215
{
1216
  char peek;
1217
 
1218
  peek = d_peek_char (di);
1219
  if (IS_DIGIT (peek))
1220
    return d_source_name (di);
1221
  else if (IS_LOWER (peek))
1222
    {
1223
      struct demangle_component *ret;
1224
 
1225
      ret = d_operator_name (di);
1226
      if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR)
1227
        di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
1228
      return ret;
1229
    }
1230
  else if (peek == 'C' || peek == 'D')
1231
    return d_ctor_dtor_name (di);
1232
  else
1233
    return NULL;
1234
}
1235
 
1236
/* <source-name> ::= <(positive length) number> <identifier>  */
1237
 
1238
static struct demangle_component *
1239
d_source_name (struct d_info *di)
1240
{
1241
  long len;
1242
  struct demangle_component *ret;
1243
 
1244
  len = d_number (di);
1245
  if (len <= 0)
1246
    return NULL;
1247
  ret = d_identifier (di, len);
1248
  di->last_name = ret;
1249
  return ret;
1250
}
1251
 
1252
/* number ::= [n] <(non-negative decimal integer)>  */
1253
 
1254
static long
1255
d_number (struct d_info *di)
1256
{
1257
  int negative;
1258
  char peek;
1259
  long ret;
1260
 
1261
  negative = 0;
1262
  peek = d_peek_char (di);
1263
  if (peek == 'n')
1264
    {
1265
      negative = 1;
1266
      d_advance (di, 1);
1267
      peek = d_peek_char (di);
1268
    }
1269
 
1270
  ret = 0;
1271
  while (1)
1272
    {
1273
      if (! IS_DIGIT (peek))
1274
        {
1275
          if (negative)
1276
            ret = - ret;
1277
          return ret;
1278
        }
1279
      ret = ret * 10 + peek - '0';
1280
      d_advance (di, 1);
1281
      peek = d_peek_char (di);
1282
    }
1283
}
1284
 
1285
/* identifier ::= <(unqualified source code identifier)>  */
1286
 
1287
static struct demangle_component *
1288
d_identifier (struct d_info *di, int len)
1289
{
1290
  const char *name;
1291
 
1292
  name = d_str (di);
1293
 
1294
  if (di->send - name < len)
1295
    return NULL;
1296
 
1297
  d_advance (di, len);
1298
 
1299
  /* A Java mangled name may have a trailing '$' if it is a C++
1300
     keyword.  This '$' is not included in the length count.  We just
1301
     ignore the '$'.  */
1302
  if ((di->options & DMGL_JAVA) != 0
1303
      && d_peek_char (di) == '$')
1304
    d_advance (di, 1);
1305
 
1306
  /* Look for something which looks like a gcc encoding of an
1307
     anonymous namespace, and replace it with a more user friendly
1308
     name.  */
1309
  if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
1310
      && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
1311
                 ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
1312
    {
1313
      const char *s;
1314
 
1315
      s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
1316
      if ((*s == '.' || *s == '_' || *s == '$')
1317
          && s[1] == 'N')
1318
        {
1319
          di->expansion -= len - sizeof "(anonymous namespace)";
1320
          return d_make_name (di, "(anonymous namespace)",
1321
                              sizeof "(anonymous namespace)" - 1);
1322
        }
1323
    }
1324
 
1325
  return d_make_name (di, name, len);
1326
}
1327
 
1328
/* operator_name ::= many different two character encodings.
1329
                 ::= cv <type>
1330
                 ::= v <digit> <source-name>
1331
*/
1332
 
1333
#define NL(s) s, (sizeof s) - 1
1334
 
1335
CP_STATIC_IF_GLIBCPP_V3
1336
const struct demangle_operator_info cplus_demangle_operators[] =
1337
{
1338
  { "aN", NL ("&="),        2 },
1339
  { "aS", NL ("="),         2 },
1340
  { "aa", NL ("&&"),        2 },
1341
  { "ad", NL ("&"),         1 },
1342
  { "an", NL ("&"),         2 },
1343
  { "cl", NL ("()"),        0 },
1344
  { "cm", NL (","),         2 },
1345
  { "co", NL ("~"),         1 },
1346
  { "dV", NL ("/="),        2 },
1347
  { "da", NL ("delete[]"),  1 },
1348
  { "de", NL ("*"),         1 },
1349
  { "dl", NL ("delete"),    1 },
1350
  { "dv", NL ("/"),         2 },
1351
  { "eO", NL ("^="),        2 },
1352
  { "eo", NL ("^"),         2 },
1353
  { "eq", NL ("=="),        2 },
1354
  { "ge", NL (">="),        2 },
1355
  { "gt", NL (">"),         2 },
1356
  { "ix", NL ("[]"),        2 },
1357
  { "lS", NL ("<<="),       2 },
1358
  { "le", NL ("<="),        2 },
1359
  { "ls", NL ("<<"),        2 },
1360
  { "lt", NL ("<"),         2 },
1361
  { "mI", NL ("-="),        2 },
1362
  { "mL", NL ("*="),        2 },
1363
  { "mi", NL ("-"),         2 },
1364
  { "ml", NL ("*"),         2 },
1365
  { "mm", NL ("--"),        1 },
1366
  { "na", NL ("new[]"),     1 },
1367
  { "ne", NL ("!="),        2 },
1368
  { "ng", NL ("-"),         1 },
1369
  { "nt", NL ("!"),         1 },
1370
  { "nw", NL ("new"),       1 },
1371
  { "oR", NL ("|="),        2 },
1372
  { "oo", NL ("||"),        2 },
1373
  { "or", NL ("|"),         2 },
1374
  { "pL", NL ("+="),        2 },
1375
  { "pl", NL ("+"),         2 },
1376
  { "pm", NL ("->*"),       2 },
1377
  { "pp", NL ("++"),        1 },
1378
  { "ps", NL ("+"),         1 },
1379
  { "pt", NL ("->"),        2 },
1380
  { "qu", NL ("?"),         3 },
1381
  { "rM", NL ("%="),        2 },
1382
  { "rS", NL (">>="),       2 },
1383
  { "rm", NL ("%"),         2 },
1384
  { "rs", NL (">>"),        2 },
1385
  { "st", NL ("sizeof "),   1 },
1386
  { "sz", NL ("sizeof "),   1 },
1387
  { NULL, NULL, 0,          0 }
1388
};
1389
 
1390
static struct demangle_component *
1391
d_operator_name (struct d_info *di)
1392
{
1393
  char c1;
1394
  char c2;
1395
 
1396
  c1 = d_next_char (di);
1397
  c2 = d_next_char (di);
1398
  if (c1 == 'v' && IS_DIGIT (c2))
1399
    return d_make_extended_operator (di, c2 - '0', d_source_name (di));
1400
  else if (c1 == 'c' && c2 == 'v')
1401
    return d_make_comp (di, DEMANGLE_COMPONENT_CAST,
1402
                        cplus_demangle_type (di), NULL);
1403
  else
1404
    {
1405
      /* LOW is the inclusive lower bound.  */
1406
      int low = 0;
1407
      /* HIGH is the exclusive upper bound.  We subtract one to ignore
1408
         the sentinel at the end of the array.  */
1409
      int high = ((sizeof (cplus_demangle_operators)
1410
                   / sizeof (cplus_demangle_operators[0]))
1411
                  - 1);
1412
 
1413
      while (1)
1414
        {
1415
          int i;
1416
          const struct demangle_operator_info *p;
1417
 
1418
          i = low + (high - low) / 2;
1419
          p = cplus_demangle_operators + i;
1420
 
1421
          if (c1 == p->code[0] && c2 == p->code[1])
1422
            return d_make_operator (di, p);
1423
 
1424
          if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
1425
            high = i;
1426
          else
1427
            low = i + 1;
1428
          if (low == high)
1429
            return NULL;
1430
        }
1431
    }
1432
}
1433
 
1434
/* <special-name> ::= TV <type>
1435
                  ::= TT <type>
1436
                  ::= TI <type>
1437
                  ::= TS <type>
1438
                  ::= GV <(object) name>
1439
                  ::= T <call-offset> <(base) encoding>
1440
                  ::= Tc <call-offset> <call-offset> <(base) encoding>
1441
   Also g++ extensions:
1442
                  ::= TC <type> <(offset) number> _ <(base) type>
1443
                  ::= TF <type>
1444
                  ::= TJ <type>
1445
                  ::= GR <name>
1446
                  ::= GA <encoding>
1447
*/
1448
 
1449
static struct demangle_component *
1450
d_special_name (struct d_info *di)
1451
{
1452
  char c;
1453
 
1454
  di->expansion += 20;
1455
  c = d_next_char (di);
1456
  if (c == 'T')
1457
    {
1458
      switch (d_next_char (di))
1459
        {
1460
        case 'V':
1461
          di->expansion -= 5;
1462
          return d_make_comp (di, DEMANGLE_COMPONENT_VTABLE,
1463
                              cplus_demangle_type (di), NULL);
1464
        case 'T':
1465
          di->expansion -= 10;
1466
          return d_make_comp (di, DEMANGLE_COMPONENT_VTT,
1467
                              cplus_demangle_type (di), NULL);
1468
        case 'I':
1469
          return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO,
1470
                              cplus_demangle_type (di), NULL);
1471
        case 'S':
1472
          return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
1473
                              cplus_demangle_type (di), NULL);
1474
 
1475
        case 'h':
1476
          if (! d_call_offset (di, 'h'))
1477
            return NULL;
1478
          return d_make_comp (di, DEMANGLE_COMPONENT_THUNK,
1479
                              d_encoding (di, 0), NULL);
1480
 
1481
        case 'v':
1482
          if (! d_call_offset (di, 'v'))
1483
            return NULL;
1484
          return d_make_comp (di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
1485
                              d_encoding (di, 0), NULL);
1486
 
1487
        case 'c':
1488
          if (! d_call_offset (di, '\0'))
1489
            return NULL;
1490
          if (! d_call_offset (di, '\0'))
1491
            return NULL;
1492
          return d_make_comp (di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
1493
                              d_encoding (di, 0), NULL);
1494
 
1495
        case 'C':
1496
          {
1497
            struct demangle_component *derived_type;
1498
            long offset;
1499
            struct demangle_component *base_type;
1500
 
1501
            derived_type = cplus_demangle_type (di);
1502
            offset = d_number (di);
1503
            if (offset < 0)
1504
              return NULL;
1505
            if (d_next_char (di) != '_')
1506
              return NULL;
1507
            base_type = cplus_demangle_type (di);
1508
            /* We don't display the offset.  FIXME: We should display
1509
               it in verbose mode.  */
1510
            di->expansion += 5;
1511
            return d_make_comp (di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
1512
                                base_type, derived_type);
1513
          }
1514
 
1515
        case 'F':
1516
          return d_make_comp (di, DEMANGLE_COMPONENT_TYPEINFO_FN,
1517
                              cplus_demangle_type (di), NULL);
1518
        case 'J':
1519
          return d_make_comp (di, DEMANGLE_COMPONENT_JAVA_CLASS,
1520
                              cplus_demangle_type (di), NULL);
1521
 
1522
        default:
1523
          return NULL;
1524
        }
1525
    }
1526
  else if (c == 'G')
1527
    {
1528
      switch (d_next_char (di))
1529
        {
1530
        case 'V':
1531
          return d_make_comp (di, DEMANGLE_COMPONENT_GUARD, d_name (di), NULL);
1532
 
1533
        case 'R':
1534
          return d_make_comp (di, DEMANGLE_COMPONENT_REFTEMP, d_name (di),
1535
                              NULL);
1536
 
1537
        case 'A':
1538
          return d_make_comp (di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
1539
                              d_encoding (di, 0), NULL);
1540
 
1541
        default:
1542
          return NULL;
1543
        }
1544
    }
1545
  else
1546
    return NULL;
1547
}
1548
 
1549
/* <call-offset> ::= h <nv-offset> _
1550
                 ::= v <v-offset> _
1551
 
1552
   <nv-offset> ::= <(offset) number>
1553
 
1554
   <v-offset> ::= <(offset) number> _ <(virtual offset) number>
1555
 
1556
   The C parameter, if not '\0', is a character we just read which is
1557
   the start of the <call-offset>.
1558
 
1559
   We don't display the offset information anywhere.  FIXME: We should
1560
   display it in verbose mode.  */
1561
 
1562
static int
1563
d_call_offset (struct d_info *di, int c)
1564
{
1565
  if (c == '\0')
1566
    c = d_next_char (di);
1567
 
1568
  if (c == 'h')
1569
    d_number (di);
1570
  else if (c == 'v')
1571
    {
1572
      d_number (di);
1573
      if (d_next_char (di) != '_')
1574
        return 0;
1575
      d_number (di);
1576
    }
1577
  else
1578
    return 0;
1579
 
1580
  if (d_next_char (di) != '_')
1581
    return 0;
1582
 
1583
  return 1;
1584
}
1585
 
1586
/* <ctor-dtor-name> ::= C1
1587
                    ::= C2
1588
                    ::= C3
1589
                    ::= D0
1590
                    ::= D1
1591
                    ::= D2
1592
*/
1593
 
1594
static struct demangle_component *
1595
d_ctor_dtor_name (struct d_info *di)
1596
{
1597
  if (di->last_name != NULL)
1598
    {
1599
      if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
1600
        di->expansion += di->last_name->u.s_name.len;
1601
      else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
1602
        di->expansion += di->last_name->u.s_string.len;
1603
    }
1604
  switch (d_next_char (di))
1605
    {
1606
    case 'C':
1607
      {
1608
        enum gnu_v3_ctor_kinds kind;
1609
 
1610
        switch (d_next_char (di))
1611
          {
1612
          case '1':
1613
            kind = gnu_v3_complete_object_ctor;
1614
            break;
1615
          case '2':
1616
            kind = gnu_v3_base_object_ctor;
1617
            break;
1618
          case '3':
1619
            kind = gnu_v3_complete_object_allocating_ctor;
1620
            break;
1621
          default:
1622
            return NULL;
1623
          }
1624
        return d_make_ctor (di, kind, di->last_name);
1625
      }
1626
 
1627
    case 'D':
1628
      {
1629
        enum gnu_v3_dtor_kinds kind;
1630
 
1631
        switch (d_next_char (di))
1632
          {
1633
          case '0':
1634
            kind = gnu_v3_deleting_dtor;
1635
            break;
1636
          case '1':
1637
            kind = gnu_v3_complete_object_dtor;
1638
            break;
1639
          case '2':
1640
            kind = gnu_v3_base_object_dtor;
1641
            break;
1642
          default:
1643
            return NULL;
1644
          }
1645
        return d_make_dtor (di, kind, di->last_name);
1646
      }
1647
 
1648
    default:
1649
      return NULL;
1650
    }
1651
}
1652
 
1653
/* <type> ::= <builtin-type>
1654
          ::= <function-type>
1655
          ::= <class-enum-type>
1656
          ::= <array-type>
1657
          ::= <pointer-to-member-type>
1658
          ::= <template-param>
1659
          ::= <template-template-param> <template-args>
1660
          ::= <substitution>
1661
          ::= <CV-qualifiers> <type>
1662
          ::= P <type>
1663
          ::= R <type>
1664
          ::= C <type>
1665
          ::= G <type>
1666
          ::= U <source-name> <type>
1667
 
1668
   <builtin-type> ::= various one letter codes
1669
                  ::= u <source-name>
1670
*/
1671
 
1672
CP_STATIC_IF_GLIBCPP_V3
1673
const struct demangle_builtin_type_info
1674
cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT] =
1675
{
1676
  /* a */ { NL ("signed char"), NL ("signed char"),     D_PRINT_DEFAULT },
1677
  /* b */ { NL ("bool"),        NL ("boolean"),         D_PRINT_BOOL },
1678
  /* c */ { NL ("char"),        NL ("byte"),            D_PRINT_DEFAULT },
1679
  /* d */ { NL ("double"),      NL ("double"),          D_PRINT_FLOAT },
1680
  /* e */ { NL ("long double"), NL ("long double"),     D_PRINT_FLOAT },
1681
  /* f */ { NL ("float"),       NL ("float"),           D_PRINT_FLOAT },
1682
  /* g */ { NL ("__float128"),  NL ("__float128"),      D_PRINT_FLOAT },
1683
  /* h */ { NL ("unsigned char"), NL ("unsigned char"), D_PRINT_DEFAULT },
1684
  /* i */ { NL ("int"),         NL ("int"),             D_PRINT_INT },
1685
  /* j */ { NL ("unsigned int"), NL ("unsigned"),       D_PRINT_UNSIGNED },
1686
  /* k */ { NULL, 0,             NULL, 0,         D_PRINT_DEFAULT },
1687
  /* l */ { NL ("long"),        NL ("long"),            D_PRINT_LONG },
1688
  /* m */ { NL ("unsigned long"), NL ("unsigned long"), D_PRINT_UNSIGNED_LONG },
1689
  /* n */ { NL ("__int128"),    NL ("__int128"),        D_PRINT_DEFAULT },
1690
  /* o */ { NL ("unsigned __int128"), NL ("unsigned __int128"),
1691
            D_PRINT_DEFAULT },
1692
  /* p */ { NULL, 0,             NULL, 0,         D_PRINT_DEFAULT },
1693
  /* q */ { NULL, 0,             NULL, 0,         D_PRINT_DEFAULT },
1694
  /* r */ { NULL, 0,             NULL, 0,         D_PRINT_DEFAULT },
1695
  /* s */ { NL ("short"),       NL ("short"),           D_PRINT_DEFAULT },
1696
  /* t */ { NL ("unsigned short"), NL ("unsigned short"), D_PRINT_DEFAULT },
1697
  /* u */ { NULL, 0,             NULL, 0,         D_PRINT_DEFAULT },
1698
  /* v */ { NL ("void"),        NL ("void"),            D_PRINT_VOID },
1699
  /* w */ { NL ("wchar_t"),     NL ("char"),            D_PRINT_DEFAULT },
1700
  /* x */ { NL ("long long"),   NL ("long"),            D_PRINT_LONG_LONG },
1701
  /* y */ { NL ("unsigned long long"), NL ("unsigned long long"),
1702
            D_PRINT_UNSIGNED_LONG_LONG },
1703
  /* z */ { NL ("..."),         NL ("..."),             D_PRINT_DEFAULT },
1704
};
1705
 
1706
CP_STATIC_IF_GLIBCPP_V3
1707
struct demangle_component *
1708
cplus_demangle_type (struct d_info *di)
1709
{
1710
  char peek;
1711
  struct demangle_component *ret;
1712
  int can_subst;
1713
 
1714
  /* The ABI specifies that when CV-qualifiers are used, the base type
1715
     is substitutable, and the fully qualified type is substitutable,
1716
     but the base type with a strict subset of the CV-qualifiers is
1717
     not substitutable.  The natural recursive implementation of the
1718
     CV-qualifiers would cause subsets to be substitutable, so instead
1719
     we pull them all off now.
1720
 
1721
     FIXME: The ABI says that order-insensitive vendor qualifiers
1722
     should be handled in the same way, but we have no way to tell
1723
     which vendor qualifiers are order-insensitive and which are
1724
     order-sensitive.  So we just assume that they are all
1725
     order-sensitive.  g++ 3.4 supports only one vendor qualifier,
1726
     __vector, and it treats it as order-sensitive when mangling
1727
     names.  */
1728
 
1729
  peek = d_peek_char (di);
1730
  if (peek == 'r' || peek == 'V' || peek == 'K')
1731
    {
1732
      struct demangle_component **pret;
1733
 
1734
      pret = d_cv_qualifiers (di, &ret, 0);
1735
      if (pret == NULL)
1736
        return NULL;
1737
      *pret = cplus_demangle_type (di);
1738
      if (! d_add_substitution (di, ret))
1739
        return NULL;
1740
      return ret;
1741
    }
1742
 
1743
  can_subst = 1;
1744
 
1745
  switch (peek)
1746
    {
1747
    case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
1748
    case 'h': case 'i': case 'j':           case 'l': case 'm': case 'n':
1749
    case 'o':                               case 's': case 't':
1750
    case 'v': case 'w': case 'x': case 'y': case 'z':
1751
      ret = d_make_builtin_type (di,
1752
                                 &cplus_demangle_builtin_types[peek - 'a']);
1753
      di->expansion += ret->u.s_builtin.type->len;
1754
      can_subst = 0;
1755
      d_advance (di, 1);
1756
      break;
1757
 
1758
    case 'u':
1759
      d_advance (di, 1);
1760
      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE,
1761
                         d_source_name (di), NULL);
1762
      break;
1763
 
1764
    case 'F':
1765
      ret = d_function_type (di);
1766
      break;
1767
 
1768
    case '0': case '1': case '2': case '3': case '4':
1769
    case '5': case '6': case '7': case '8': case '9':
1770
    case 'N':
1771
    case 'Z':
1772
      ret = d_class_enum_type (di);
1773
      break;
1774
 
1775
    case 'A':
1776
      ret = d_array_type (di);
1777
      break;
1778
 
1779
    case 'M':
1780
      ret = d_pointer_to_member_type (di);
1781
      break;
1782
 
1783
    case 'T':
1784
      ret = d_template_param (di);
1785
      if (d_peek_char (di) == 'I')
1786
        {
1787
          /* This is <template-template-param> <template-args>.  The
1788
             <template-template-param> part is a substitution
1789
             candidate.  */
1790
          if (! d_add_substitution (di, ret))
1791
            return NULL;
1792
          ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
1793
                             d_template_args (di));
1794
        }
1795
      break;
1796
 
1797
    case 'S':
1798
      /* If this is a special substitution, then it is the start of
1799
         <class-enum-type>.  */
1800
      {
1801
        char peek_next;
1802
 
1803
        peek_next = d_peek_next_char (di);
1804
        if (IS_DIGIT (peek_next)
1805
            || peek_next == '_'
1806
            || IS_UPPER (peek_next))
1807
          {
1808
            ret = d_substitution (di, 0);
1809
            /* The substituted name may have been a template name and
1810
               may be followed by tepmlate args.  */
1811
            if (d_peek_char (di) == 'I')
1812
              ret = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, ret,
1813
                                 d_template_args (di));
1814
            else
1815
              can_subst = 0;
1816
          }
1817
        else
1818
          {
1819
            ret = d_class_enum_type (di);
1820
            /* If the substitution was a complete type, then it is not
1821
               a new substitution candidate.  However, if the
1822
               substitution was followed by template arguments, then
1823
               the whole thing is a substitution candidate.  */
1824
            if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
1825
              can_subst = 0;
1826
          }
1827
      }
1828
      break;
1829
 
1830
    case 'P':
1831
      d_advance (di, 1);
1832
      ret = d_make_comp (di, DEMANGLE_COMPONENT_POINTER,
1833
                         cplus_demangle_type (di), NULL);
1834
      break;
1835
 
1836
    case 'R':
1837
      d_advance (di, 1);
1838
      ret = d_make_comp (di, DEMANGLE_COMPONENT_REFERENCE,
1839
                         cplus_demangle_type (di), NULL);
1840
      break;
1841
 
1842
    case 'C':
1843
      d_advance (di, 1);
1844
      ret = d_make_comp (di, DEMANGLE_COMPONENT_COMPLEX,
1845
                         cplus_demangle_type (di), NULL);
1846
      break;
1847
 
1848
    case 'G':
1849
      d_advance (di, 1);
1850
      ret = d_make_comp (di, DEMANGLE_COMPONENT_IMAGINARY,
1851
                         cplus_demangle_type (di), NULL);
1852
      break;
1853
 
1854
    case 'U':
1855
      d_advance (di, 1);
1856
      ret = d_source_name (di);
1857
      ret = d_make_comp (di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
1858
                         cplus_demangle_type (di), ret);
1859
      break;
1860
 
1861
    default:
1862
      return NULL;
1863
    }
1864
 
1865
  if (can_subst)
1866
    {
1867
      if (! d_add_substitution (di, ret))
1868
        return NULL;
1869
    }
1870
 
1871
  return ret;
1872
}
1873
 
1874
/* <CV-qualifiers> ::= [r] [V] [K]  */
1875
 
1876
static struct demangle_component **
1877
d_cv_qualifiers (struct d_info *di,
1878
                 struct demangle_component **pret, int member_fn)
1879
{
1880
  char peek;
1881
 
1882
  peek = d_peek_char (di);
1883
  while (peek == 'r' || peek == 'V' || peek == 'K')
1884
    {
1885
      enum demangle_component_type t;
1886
 
1887
      d_advance (di, 1);
1888
      if (peek == 'r')
1889
        {
1890
          t = (member_fn
1891
               ? DEMANGLE_COMPONENT_RESTRICT_THIS
1892
               : DEMANGLE_COMPONENT_RESTRICT);
1893
          di->expansion += sizeof "restrict";
1894
        }
1895
      else if (peek == 'V')
1896
        {
1897
          t = (member_fn
1898
               ? DEMANGLE_COMPONENT_VOLATILE_THIS
1899
               : DEMANGLE_COMPONENT_VOLATILE);
1900
          di->expansion += sizeof "volatile";
1901
        }
1902
      else
1903
        {
1904
          t = (member_fn
1905
               ? DEMANGLE_COMPONENT_CONST_THIS
1906
               : DEMANGLE_COMPONENT_CONST);
1907
          di->expansion += sizeof "const";
1908
        }
1909
 
1910
      *pret = d_make_comp (di, t, NULL, NULL);
1911
      if (*pret == NULL)
1912
        return NULL;
1913
      pret = &d_left (*pret);
1914
 
1915
      peek = d_peek_char (di);
1916
    }
1917
 
1918
  return pret;
1919
}
1920
 
1921
/* <function-type> ::= F [Y] <bare-function-type> E  */
1922
 
1923
static struct demangle_component *
1924
d_function_type (struct d_info *di)
1925
{
1926
  struct demangle_component *ret;
1927
 
1928
  if (d_next_char (di) != 'F')
1929
    return NULL;
1930
  if (d_peek_char (di) == 'Y')
1931
    {
1932
      /* Function has C linkage.  We don't print this information.
1933
         FIXME: We should print it in verbose mode.  */
1934
      d_advance (di, 1);
1935
    }
1936
  ret = d_bare_function_type (di, 1);
1937
  if (d_next_char (di) != 'E')
1938
    return NULL;
1939
  return ret;
1940
}
1941
 
1942
/* <bare-function-type> ::= [J]<type>+  */
1943
 
1944
static struct demangle_component *
1945
d_bare_function_type (struct d_info *di, int has_return_type)
1946
{
1947
  struct demangle_component *return_type;
1948
  struct demangle_component *tl;
1949
  struct demangle_component **ptl;
1950
  char peek;
1951
 
1952
  /* Detect special qualifier indicating that the first argument
1953
     is the return type.  */
1954
  peek = d_peek_char (di);
1955
  if (peek == 'J')
1956
    {
1957
      d_advance (di, 1);
1958
      has_return_type = 1;
1959
    }
1960
 
1961
  return_type = NULL;
1962
  tl = NULL;
1963
  ptl = &tl;
1964
  while (1)
1965
    {
1966
      struct demangle_component *type;
1967
 
1968
      peek = d_peek_char (di);
1969
      if (peek == '\0' || peek == 'E')
1970
        break;
1971
      type = cplus_demangle_type (di);
1972
      if (type == NULL)
1973
        return NULL;
1974
      if (has_return_type)
1975
        {
1976
          return_type = type;
1977
          has_return_type = 0;
1978
        }
1979
      else
1980
        {
1981
          *ptl = d_make_comp (di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
1982
          if (*ptl == NULL)
1983
            return NULL;
1984
          ptl = &d_right (*ptl);
1985
        }
1986
    }
1987
 
1988
  /* There should be at least one parameter type besides the optional
1989
     return type.  A function which takes no arguments will have a
1990
     single parameter type void.  */
1991
  if (tl == NULL)
1992
    return NULL;
1993
 
1994
  /* If we have a single parameter type void, omit it.  */
1995
  if (d_right (tl) == NULL
1996
      && d_left (tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
1997
      && d_left (tl)->u.s_builtin.type->print == D_PRINT_VOID)
1998
    {
1999
      di->expansion -= d_left (tl)->u.s_builtin.type->len;
2000
      tl = NULL;
2001
    }
2002
 
2003
  return d_make_comp (di, DEMANGLE_COMPONENT_FUNCTION_TYPE, return_type, tl);
2004
}
2005
 
2006
/* <class-enum-type> ::= <name>  */
2007
 
2008
static struct demangle_component *
2009
d_class_enum_type (struct d_info *di)
2010
{
2011
  return d_name (di);
2012
}
2013
 
2014
/* <array-type> ::= A <(positive dimension) number> _ <(element) type>
2015
                ::= A [<(dimension) expression>] _ <(element) type>
2016
*/
2017
 
2018
static struct demangle_component *
2019
d_array_type (struct d_info *di)
2020
{
2021
  char peek;
2022
  struct demangle_component *dim;
2023
 
2024
  if (d_next_char (di) != 'A')
2025
    return NULL;
2026
 
2027
  peek = d_peek_char (di);
2028
  if (peek == '_')
2029
    dim = NULL;
2030
  else if (IS_DIGIT (peek))
2031
    {
2032
      const char *s;
2033
 
2034
      s = d_str (di);
2035
      do
2036
        {
2037
          d_advance (di, 1);
2038
          peek = d_peek_char (di);
2039
        }
2040
      while (IS_DIGIT (peek));
2041
      dim = d_make_name (di, s, d_str (di) - s);
2042
      if (dim == NULL)
2043
        return NULL;
2044
    }
2045
  else
2046
    {
2047
      dim = d_expression (di);
2048
      if (dim == NULL)
2049
        return NULL;
2050
    }
2051
 
2052
  if (d_next_char (di) != '_')
2053
    return NULL;
2054
 
2055
  return d_make_comp (di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
2056
                      cplus_demangle_type (di));
2057
}
2058
 
2059
/* <pointer-to-member-type> ::= M <(class) type> <(member) type>  */
2060
 
2061
static struct demangle_component *
2062
d_pointer_to_member_type (struct d_info *di)
2063
{
2064
  struct demangle_component *cl;
2065
  struct demangle_component *mem;
2066
  struct demangle_component **pmem;
2067
 
2068
  if (d_next_char (di) != 'M')
2069
    return NULL;
2070
 
2071
  cl = cplus_demangle_type (di);
2072
 
2073
  /* The ABI specifies that any type can be a substitution source, and
2074
     that M is followed by two types, and that when a CV-qualified
2075
     type is seen both the base type and the CV-qualified types are
2076
     substitution sources.  The ABI also specifies that for a pointer
2077
     to a CV-qualified member function, the qualifiers are attached to
2078
     the second type.  Given the grammar, a plain reading of the ABI
2079
     suggests that both the CV-qualified member function and the
2080
     non-qualified member function are substitution sources.  However,
2081
     g++ does not work that way.  g++ treats only the CV-qualified
2082
     member function as a substitution source.  FIXME.  So to work
2083
     with g++, we need to pull off the CV-qualifiers here, in order to
2084
     avoid calling add_substitution() in cplus_demangle_type().  But
2085
     for a CV-qualified member which is not a function, g++ does
2086
     follow the ABI, so we need to handle that case here by calling
2087
     d_add_substitution ourselves.  */
2088
 
2089
  pmem = d_cv_qualifiers (di, &mem, 1);
2090
  if (pmem == NULL)
2091
    return NULL;
2092
  *pmem = cplus_demangle_type (di);
2093
 
2094
  if (pmem != &mem && (*pmem)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
2095
    {
2096
      if (! d_add_substitution (di, mem))
2097
        return NULL;
2098
    }
2099
 
2100
  return d_make_comp (di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
2101
}
2102
 
2103
/* <template-param> ::= T_
2104
                    ::= T <(parameter-2 non-negative) number> _
2105
*/
2106
 
2107
static struct demangle_component *
2108
d_template_param (struct d_info *di)
2109
{
2110
  long param;
2111
 
2112
  if (d_next_char (di) != 'T')
2113
    return NULL;
2114
 
2115
  if (d_peek_char (di) == '_')
2116
    param = 0;
2117
  else
2118
    {
2119
      param = d_number (di);
2120
      if (param < 0)
2121
        return NULL;
2122
      param += 1;
2123
    }
2124
 
2125
  if (d_next_char (di) != '_')
2126
    return NULL;
2127
 
2128
  ++di->did_subs;
2129
 
2130
  return d_make_template_param (di, param);
2131
}
2132
 
2133
/* <template-args> ::= I <template-arg>+ E  */
2134
 
2135
static struct demangle_component *
2136
d_template_args (struct d_info *di)
2137
{
2138
  struct demangle_component *hold_last_name;
2139
  struct demangle_component *al;
2140
  struct demangle_component **pal;
2141
 
2142
  /* Preserve the last name we saw--don't let the template arguments
2143
     clobber it, as that would give us the wrong name for a subsequent
2144
     constructor or destructor.  */
2145
  hold_last_name = di->last_name;
2146
 
2147
  if (d_next_char (di) != 'I')
2148
    return NULL;
2149
 
2150
  al = NULL;
2151
  pal = &al;
2152
  while (1)
2153
    {
2154
      struct demangle_component *a;
2155
 
2156
      a = d_template_arg (di);
2157
      if (a == NULL)
2158
        return NULL;
2159
 
2160
      *pal = d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
2161
      if (*pal == NULL)
2162
        return NULL;
2163
      pal = &d_right (*pal);
2164
 
2165
      if (d_peek_char (di) == 'E')
2166
        {
2167
          d_advance (di, 1);
2168
          break;
2169
        }
2170
    }
2171
 
2172
  di->last_name = hold_last_name;
2173
 
2174
  return al;
2175
}
2176
 
2177
/* <template-arg> ::= <type>
2178
                  ::= X <expression> E
2179
                  ::= <expr-primary>
2180
*/
2181
 
2182
static struct demangle_component *
2183
d_template_arg (struct d_info *di)
2184
{
2185
  struct demangle_component *ret;
2186
 
2187
  switch (d_peek_char (di))
2188
    {
2189
    case 'X':
2190
      d_advance (di, 1);
2191
      ret = d_expression (di);
2192
      if (d_next_char (di) != 'E')
2193
        return NULL;
2194
      return ret;
2195
 
2196
    case 'L':
2197
      return d_expr_primary (di);
2198
 
2199
    default:
2200
      return cplus_demangle_type (di);
2201
    }
2202
}
2203
 
2204
/* <expression> ::= <(unary) operator-name> <expression>
2205
                ::= <(binary) operator-name> <expression> <expression>
2206
                ::= <(trinary) operator-name> <expression> <expression> <expression>
2207
                ::= st <type>
2208
                ::= <template-param>
2209
                ::= sr <type> <unqualified-name>
2210
                ::= sr <type> <unqualified-name> <template-args>
2211
                ::= <expr-primary>
2212
*/
2213
 
2214
static struct demangle_component *
2215
d_expression (struct d_info *di)
2216
{
2217
  char peek;
2218
 
2219
  peek = d_peek_char (di);
2220
  if (peek == 'L')
2221
    return d_expr_primary (di);
2222
  else if (peek == 'T')
2223
    return d_template_param (di);
2224
  else if (peek == 's' && d_peek_next_char (di) == 'r')
2225
    {
2226
      struct demangle_component *type;
2227
      struct demangle_component *name;
2228
 
2229
      d_advance (di, 2);
2230
      type = cplus_demangle_type (di);
2231
      name = d_unqualified_name (di);
2232
      if (d_peek_char (di) != 'I')
2233
        return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
2234
      else
2235
        return d_make_comp (di, DEMANGLE_COMPONENT_QUAL_NAME, type,
2236
                            d_make_comp (di, DEMANGLE_COMPONENT_TEMPLATE, name,
2237
                                         d_template_args (di)));
2238
    }
2239
  else
2240
    {
2241
      struct demangle_component *op;
2242
      int args;
2243
 
2244
      op = d_operator_name (di);
2245
      if (op == NULL)
2246
        return NULL;
2247
 
2248
      if (op->type == DEMANGLE_COMPONENT_OPERATOR)
2249
        di->expansion += op->u.s_operator.op->len - 2;
2250
 
2251
      if (op->type == DEMANGLE_COMPONENT_OPERATOR
2252
          && strcmp (op->u.s_operator.op->code, "st") == 0)
2253
        return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2254
                            cplus_demangle_type (di));
2255
 
2256
      switch (op->type)
2257
        {
2258
        default:
2259
          return NULL;
2260
        case DEMANGLE_COMPONENT_OPERATOR:
2261
          args = op->u.s_operator.op->args;
2262
          break;
2263
        case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
2264
          args = op->u.s_extended_operator.args;
2265
          break;
2266
        case DEMANGLE_COMPONENT_CAST:
2267
          args = 1;
2268
          break;
2269
        }
2270
 
2271
      switch (args)
2272
        {
2273
        case 1:
2274
          return d_make_comp (di, DEMANGLE_COMPONENT_UNARY, op,
2275
                              d_expression (di));
2276
        case 2:
2277
          {
2278
            struct demangle_component *left;
2279
 
2280
            left = d_expression (di);
2281
            return d_make_comp (di, DEMANGLE_COMPONENT_BINARY, op,
2282
                                d_make_comp (di,
2283
                                             DEMANGLE_COMPONENT_BINARY_ARGS,
2284
                                             left,
2285
                                             d_expression (di)));
2286
          }
2287
        case 3:
2288
          {
2289
            struct demangle_component *first;
2290
            struct demangle_component *second;
2291
 
2292
            first = d_expression (di);
2293
            second = d_expression (di);
2294
            return d_make_comp (di, DEMANGLE_COMPONENT_TRINARY, op,
2295
                                d_make_comp (di,
2296
                                             DEMANGLE_COMPONENT_TRINARY_ARG1,
2297
                                             first,
2298
                                             d_make_comp (di,
2299
                                                          DEMANGLE_COMPONENT_TRINARY_ARG2,
2300
                                                          second,
2301
                                                          d_expression (di))));
2302
          }
2303
        default:
2304
          return NULL;
2305
        }
2306
    }
2307
}
2308
 
2309
/* <expr-primary> ::= L <type> <(value) number> E
2310
                  ::= L <type> <(value) float> E
2311
                  ::= L <mangled-name> E
2312
*/
2313
 
2314
static struct demangle_component *
2315
d_expr_primary (struct d_info *di)
2316
{
2317
  struct demangle_component *ret;
2318
 
2319
  if (d_next_char (di) != 'L')
2320
    return NULL;
2321
  if (d_peek_char (di) == '_')
2322
    ret = cplus_demangle_mangled_name (di, 0);
2323
  else
2324
    {
2325
      struct demangle_component *type;
2326
      enum demangle_component_type t;
2327
      const char *s;
2328
 
2329
      type = cplus_demangle_type (di);
2330
      if (type == NULL)
2331
        return NULL;
2332
 
2333
      /* If we have a type we know how to print, we aren't going to
2334
         print the type name itself.  */
2335
      if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE
2336
          && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
2337
        di->expansion -= type->u.s_builtin.type->len;
2338
 
2339
      /* Rather than try to interpret the literal value, we just
2340
         collect it as a string.  Note that it's possible to have a
2341
         floating point literal here.  The ABI specifies that the
2342
         format of such literals is machine independent.  That's fine,
2343
         but what's not fine is that versions of g++ up to 3.2 with
2344
         -fabi-version=1 used upper case letters in the hex constant,
2345
         and dumped out gcc's internal representation.  That makes it
2346
         hard to tell where the constant ends, and hard to dump the
2347
         constant in any readable form anyhow.  We don't attempt to
2348
         handle these cases.  */
2349
 
2350
      t = DEMANGLE_COMPONENT_LITERAL;
2351
      if (d_peek_char (di) == 'n')
2352
        {
2353
          t = DEMANGLE_COMPONENT_LITERAL_NEG;
2354
          d_advance (di, 1);
2355
        }
2356
      s = d_str (di);
2357
      while (d_peek_char (di) != 'E')
2358
        {
2359
          if (d_peek_char (di) == '\0')
2360
            return NULL;
2361
          d_advance (di, 1);
2362
        }
2363
      ret = d_make_comp (di, t, type, d_make_name (di, s, d_str (di) - s));
2364
    }
2365
  if (d_next_char (di) != 'E')
2366
    return NULL;
2367
  return ret;
2368
}
2369
 
2370
/* <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
2371
                ::= Z <(function) encoding> E s [<discriminator>]
2372
*/
2373
 
2374
static struct demangle_component *
2375
d_local_name (struct d_info *di)
2376
{
2377
  struct demangle_component *function;
2378
 
2379
  if (d_next_char (di) != 'Z')
2380
    return NULL;
2381
 
2382
  function = d_encoding (di, 0);
2383
 
2384
  if (d_next_char (di) != 'E')
2385
    return NULL;
2386
 
2387
  if (d_peek_char (di) == 's')
2388
    {
2389
      d_advance (di, 1);
2390
      if (! d_discriminator (di))
2391
        return NULL;
2392
      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function,
2393
                          d_make_name (di, "string literal",
2394
                                       sizeof "string literal" - 1));
2395
    }
2396
  else
2397
    {
2398
      struct demangle_component *name;
2399
 
2400
      name = d_name (di);
2401
      if (! d_discriminator (di))
2402
        return NULL;
2403
      return d_make_comp (di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
2404
    }
2405
}
2406
 
2407
/* <discriminator> ::= _ <(non-negative) number>
2408
 
2409
   We demangle the discriminator, but we don't print it out.  FIXME:
2410
   We should print it out in verbose mode.  */
2411
 
2412
static int
2413
d_discriminator (struct d_info *di)
2414
{
2415
  long discrim;
2416
 
2417
  if (d_peek_char (di) != '_')
2418
    return 1;
2419
  d_advance (di, 1);
2420
  discrim = d_number (di);
2421
  if (discrim < 0)
2422
    return 0;
2423
  return 1;
2424
}
2425
 
2426
/* Add a new substitution.  */
2427
 
2428
static int
2429
d_add_substitution (struct d_info *di, struct demangle_component *dc)
2430
{
2431
  if (dc == NULL)
2432
    return 0;
2433
  if (di->next_sub >= di->num_subs)
2434
    return 0;
2435
  di->subs[di->next_sub] = dc;
2436
  ++di->next_sub;
2437
  return 1;
2438
}
2439
 
2440
/* <substitution> ::= S <seq-id> _
2441
                  ::= S_
2442
                  ::= St
2443
                  ::= Sa
2444
                  ::= Sb
2445
                  ::= Ss
2446
                  ::= Si
2447
                  ::= So
2448
                  ::= Sd
2449
 
2450
   If PREFIX is non-zero, then this type is being used as a prefix in
2451
   a qualified name.  In this case, for the standard substitutions, we
2452
   need to check whether we are being used as a prefix for a
2453
   constructor or destructor, and return a full template name.
2454
   Otherwise we will get something like std::iostream::~iostream()
2455
   which does not correspond particularly well to any function which
2456
   actually appears in the source.
2457
*/
2458
 
2459
static const struct d_standard_sub_info standard_subs[] =
2460
{
2461
  { 't', NL ("std"),
2462
    NL ("std"),
2463
    NULL, 0 },
2464
  { 'a', NL ("std::allocator"),
2465
    NL ("std::allocator"),
2466
    NL ("allocator") },
2467
  { 'b', NL ("std::basic_string"),
2468
    NL ("std::basic_string"),
2469
    NL ("basic_string") },
2470
  { 's', NL ("std::string"),
2471
    NL ("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
2472
    NL ("basic_string") },
2473
  { 'i', NL ("std::istream"),
2474
    NL ("std::basic_istream<char, std::char_traits<char> >"),
2475
    NL ("basic_istream") },
2476
  { 'o', NL ("std::ostream"),
2477
    NL ("std::basic_ostream<char, std::char_traits<char> >"),
2478
    NL ("basic_ostream") },
2479
  { 'd', NL ("std::iostream"),
2480
    NL ("std::basic_iostream<char, std::char_traits<char> >"),
2481
    NL ("basic_iostream") }
2482
};
2483
 
2484
static struct demangle_component *
2485
d_substitution (struct d_info *di, int prefix)
2486
{
2487
  char c;
2488
 
2489
  if (d_next_char (di) != 'S')
2490
    return NULL;
2491
 
2492
  c = d_next_char (di);
2493
  if (c == '_' || IS_DIGIT (c) || IS_UPPER (c))
2494
    {
2495
      int id;
2496
 
2497
      id = 0;
2498
      if (c != '_')
2499
        {
2500
          do
2501
            {
2502
              if (IS_DIGIT (c))
2503
                id = id * 36 + c - '0';
2504
              else if (IS_UPPER (c))
2505
                id = id * 36 + c - 'A' + 10;
2506
              else
2507
                return NULL;
2508
              if (id < 0)
2509
                return NULL;
2510
              c = d_next_char (di);
2511
            }
2512
          while (c != '_');
2513
 
2514
          ++id;
2515
        }
2516
 
2517
      if (id >= di->next_sub)
2518
        return NULL;
2519
 
2520
      ++di->did_subs;
2521
 
2522
      return di->subs[id];
2523
    }
2524
  else
2525
    {
2526
      int verbose;
2527
      const struct d_standard_sub_info *p;
2528
      const struct d_standard_sub_info *pend;
2529
 
2530
      verbose = (di->options & DMGL_VERBOSE) != 0;
2531
      if (! verbose && prefix)
2532
        {
2533
          char peek;
2534
 
2535
          peek = d_peek_char (di);
2536
          if (peek == 'C' || peek == 'D')
2537
            verbose = 1;
2538
        }
2539
 
2540
      pend = (&standard_subs[0]
2541
              + sizeof standard_subs / sizeof standard_subs[0]);
2542
      for (p = &standard_subs[0]; p < pend; ++p)
2543
        {
2544
          if (c == p->code)
2545
            {
2546
              const char *s;
2547
              int len;
2548
 
2549
              if (p->set_last_name != NULL)
2550
                di->last_name = d_make_sub (di, p->set_last_name,
2551
                                            p->set_last_name_len);
2552
              if (verbose)
2553
                {
2554
                  s = p->full_expansion;
2555
                  len = p->full_len;
2556
                }
2557
              else
2558
                {
2559
                  s = p->simple_expansion;
2560
                  len = p->simple_len;
2561
                }
2562
              di->expansion += len;
2563
              return d_make_sub (di, s, len);
2564
            }
2565
        }
2566
 
2567
      return NULL;
2568
    }
2569
}
2570
 
2571
/* Resize the print buffer.  */
2572
 
2573
static void
2574
d_print_resize (struct d_print_info *dpi, size_t add)
2575
{
2576
  size_t need;
2577
 
2578
  if (dpi->buf == NULL)
2579
    return;
2580
  need = dpi->len + add;
2581
  while (need > dpi->alc)
2582
    {
2583
      size_t newalc;
2584
      char *newbuf;
2585
 
2586
      newalc = dpi->alc * 2;
2587
      newbuf = (char *) realloc (dpi->buf, newalc);
2588
      if (newbuf == NULL)
2589
        {
2590
          free (dpi->buf);
2591
          dpi->buf = NULL;
2592
          dpi->allocation_failure = 1;
2593
          return;
2594
        }
2595
      dpi->buf = newbuf;
2596
      dpi->alc = newalc;
2597
    }
2598
}
2599
 
2600
/* Append a character to the print buffer.  */
2601
 
2602
static void
2603
d_print_append_char (struct d_print_info *dpi, int c)
2604
{
2605
  if (dpi->buf != NULL)
2606
    {
2607
      if (dpi->len >= dpi->alc)
2608
        {
2609
          d_print_resize (dpi, 1);
2610
          if (dpi->buf == NULL)
2611
            return;
2612
        }
2613
 
2614
      dpi->buf[dpi->len] = c;
2615
      ++dpi->len;
2616
    }
2617
}
2618
 
2619
/* Append a buffer to the print buffer.  */
2620
 
2621
static void
2622
d_print_append_buffer (struct d_print_info *dpi, const char *s, size_t l)
2623
{
2624
  if (dpi->buf != NULL)
2625
    {
2626
      if (dpi->len + l > dpi->alc)
2627
        {
2628
          d_print_resize (dpi, l);
2629
          if (dpi->buf == NULL)
2630
            return;
2631
        }
2632
 
2633
      memcpy (dpi->buf + dpi->len, s, l);
2634
      dpi->len += l;
2635
    }
2636
}
2637
 
2638
/* Indicate that an error occurred during printing.  */
2639
 
2640
static void
2641
d_print_error (struct d_print_info *dpi)
2642
{
2643
  free (dpi->buf);
2644
  dpi->buf = NULL;
2645
}
2646
 
2647
/* Turn components into a human readable string.  OPTIONS is the
2648
   options bits passed to the demangler.  DC is the tree to print.
2649
   ESTIMATE is a guess at the length of the result.  This returns a
2650
   string allocated by malloc, or NULL on error.  On success, this
2651
   sets *PALC to the size of the allocated buffer.  On failure, this
2652
   sets *PALC to 0 for a bad parse, or to 1 for a memory allocation
2653
   failure.  */
2654
 
2655
CP_STATIC_IF_GLIBCPP_V3
2656
char *
2657
cplus_demangle_print (int options, const struct demangle_component *dc,
2658
                      int estimate, size_t *palc)
2659
{
2660
  struct d_print_info dpi;
2661
 
2662
  dpi.options = options;
2663
 
2664
  dpi.alc = estimate + 1;
2665
  dpi.buf = (char *) malloc (dpi.alc);
2666
  if (dpi.buf == NULL)
2667
    {
2668
      *palc = 1;
2669
      return NULL;
2670
    }
2671
 
2672
  dpi.len = 0;
2673
  dpi.templates = NULL;
2674
  dpi.modifiers = NULL;
2675
 
2676
  dpi.allocation_failure = 0;
2677
 
2678
  d_print_comp (&dpi, dc);
2679
 
2680
  d_append_char (&dpi, '\0');
2681
 
2682
  if (dpi.buf != NULL)
2683
    *palc = dpi.alc;
2684
  else
2685
    *palc = dpi.allocation_failure;
2686
 
2687
  return dpi.buf;
2688
}
2689
 
2690
/* Subroutine to handle components.  */
2691
 
2692
static void
2693
d_print_comp (struct d_print_info *dpi,
2694
              const struct demangle_component *dc)
2695
{
2696
  if (dc == NULL)
2697
    {
2698
      d_print_error (dpi);
2699
      return;
2700
    }
2701
  if (d_print_saw_error (dpi))
2702
    return;
2703
 
2704
  switch (dc->type)
2705
    {
2706
    case DEMANGLE_COMPONENT_NAME:
2707
      if ((dpi->options & DMGL_JAVA) == 0)
2708
        d_append_buffer (dpi, dc->u.s_name.s, dc->u.s_name.len);
2709
      else
2710
        d_print_java_identifier (dpi, dc->u.s_name.s, dc->u.s_name.len);
2711
      return;
2712
 
2713
    case DEMANGLE_COMPONENT_QUAL_NAME:
2714
    case DEMANGLE_COMPONENT_LOCAL_NAME:
2715
      d_print_comp (dpi, d_left (dc));
2716
      if ((dpi->options & DMGL_JAVA) == 0)
2717
        d_append_string_constant (dpi, "::");
2718
      else
2719
        d_append_char (dpi, '.');
2720
      d_print_comp (dpi, d_right (dc));
2721
      return;
2722
 
2723
    case DEMANGLE_COMPONENT_TYPED_NAME:
2724
      {
2725
        struct d_print_mod *hold_modifiers;
2726
        struct demangle_component *typed_name;
2727
        struct d_print_mod adpm[4];
2728
        unsigned int i;
2729
        struct d_print_template dpt;
2730
 
2731
        /* Pass the name down to the type so that it can be printed in
2732
           the right place for the type.  We also have to pass down
2733
           any CV-qualifiers, which apply to the this parameter.  */
2734
        hold_modifiers = dpi->modifiers;
2735
        i = 0;
2736
        typed_name = d_left (dc);
2737
        while (typed_name != NULL)
2738
          {
2739
            if (i >= sizeof adpm / sizeof adpm[0])
2740
              {
2741
                d_print_error (dpi);
2742
                return;
2743
              }
2744
 
2745
            adpm[i].next = dpi->modifiers;
2746
            dpi->modifiers = &adpm[i];
2747
            adpm[i].mod = typed_name;
2748
            adpm[i].printed = 0;
2749
            adpm[i].templates = dpi->templates;
2750
            ++i;
2751
 
2752
            if (typed_name->type != DEMANGLE_COMPONENT_RESTRICT_THIS
2753
                && typed_name->type != DEMANGLE_COMPONENT_VOLATILE_THIS
2754
                && typed_name->type != DEMANGLE_COMPONENT_CONST_THIS)
2755
              break;
2756
 
2757
            typed_name = d_left (typed_name);
2758
          }
2759
 
2760
        /* If typed_name is a template, then it applies to the
2761
           function type as well.  */
2762
        if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
2763
          {
2764
            dpt.next = dpi->templates;
2765
            dpi->templates = &dpt;
2766
            dpt.template_decl = typed_name;
2767
          }
2768
 
2769
        /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
2770
           there may be CV-qualifiers on its right argument which
2771
           really apply here; this happens when parsing a class which
2772
           is local to a function.  */
2773
        if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME)
2774
          {
2775
            struct demangle_component *local_name;
2776
 
2777
            local_name = d_right (typed_name);
2778
            while (local_name->type == DEMANGLE_COMPONENT_RESTRICT_THIS
2779
                   || local_name->type == DEMANGLE_COMPONENT_VOLATILE_THIS
2780
                   || local_name->type == DEMANGLE_COMPONENT_CONST_THIS)
2781
              {
2782
                if (i >= sizeof adpm / sizeof adpm[0])
2783
                  {
2784
                    d_print_error (dpi);
2785
                    return;
2786
                  }
2787
 
2788
                adpm[i] = adpm[i - 1];
2789
                adpm[i].next = &adpm[i - 1];
2790
                dpi->modifiers = &adpm[i];
2791
 
2792
                adpm[i - 1].mod = local_name;
2793
                adpm[i - 1].printed = 0;
2794
                adpm[i - 1].templates = dpi->templates;
2795
                ++i;
2796
 
2797
                local_name = d_left (local_name);
2798
              }
2799
          }
2800
 
2801
        d_print_comp (dpi, d_right (dc));
2802
 
2803
        if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
2804
          dpi->templates = dpt.next;
2805
 
2806
        /* If the modifiers didn't get printed by the type, print them
2807
           now.  */
2808
        while (i > 0)
2809
          {
2810
            --i;
2811
            if (! adpm[i].printed)
2812
              {
2813
                d_append_char (dpi, ' ');
2814
                d_print_mod (dpi, adpm[i].mod);
2815
              }
2816
          }
2817
 
2818
        dpi->modifiers = hold_modifiers;
2819
 
2820
        return;
2821
      }
2822
 
2823
    case DEMANGLE_COMPONENT_TEMPLATE:
2824
      {
2825
        struct d_print_mod *hold_dpm;
2826
 
2827
        /* Don't push modifiers into a template definition.  Doing so
2828
           could give the wrong definition for a template argument.
2829
           Instead, treat the template essentially as a name.  */
2830
 
2831
        hold_dpm = dpi->modifiers;
2832
        dpi->modifiers = NULL;
2833
 
2834
        d_print_comp (dpi, d_left (dc));
2835
        if (d_last_char (dpi) == '<')
2836
          d_append_char (dpi, ' ');
2837
        d_append_char (dpi, '<');
2838
        d_print_comp (dpi, d_right (dc));
2839
        /* Avoid generating two consecutive '>' characters, to avoid
2840
           the C++ syntactic ambiguity.  */
2841
        if (d_last_char (dpi) == '>')
2842
          d_append_char (dpi, ' ');
2843
        d_append_char (dpi, '>');
2844
 
2845
        dpi->modifiers = hold_dpm;
2846
 
2847
        return;
2848
      }
2849
 
2850
    case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
2851
      {
2852
        long i;
2853
        struct demangle_component *a;
2854
        struct d_print_template *hold_dpt;
2855
 
2856
        if (dpi->templates == NULL)
2857
          {
2858
            d_print_error (dpi);
2859
            return;
2860
          }
2861
        i = dc->u.s_number.number;
2862
        for (a = d_right (dpi->templates->template_decl);
2863
             a != NULL;
2864
             a = d_right (a))
2865
          {
2866
            if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
2867
              {
2868
                d_print_error (dpi);
2869
                return;
2870
              }
2871
            if (i <= 0)
2872
              break;
2873
            --i;
2874
          }
2875
        if (i != 0 || a == NULL)
2876
          {
2877
            d_print_error (dpi);
2878
            return;
2879
          }
2880
 
2881
        /* While processing this parameter, we need to pop the list of
2882
           templates.  This is because the template parameter may
2883
           itself be a reference to a parameter of an outer
2884
           template.  */
2885
 
2886
        hold_dpt = dpi->templates;
2887
        dpi->templates = hold_dpt->next;
2888
 
2889
        d_print_comp (dpi, d_left (a));
2890
 
2891
        dpi->templates = hold_dpt;
2892
 
2893
        return;
2894
      }
2895
 
2896
    case DEMANGLE_COMPONENT_CTOR:
2897
      d_print_comp (dpi, dc->u.s_ctor.name);
2898
      return;
2899
 
2900
    case DEMANGLE_COMPONENT_DTOR:
2901
      d_append_char (dpi, '~');
2902
      d_print_comp (dpi, dc->u.s_dtor.name);
2903
      return;
2904
 
2905
    case DEMANGLE_COMPONENT_VTABLE:
2906
      d_append_string_constant (dpi, "vtable for ");
2907
      d_print_comp (dpi, d_left (dc));
2908
      return;
2909
 
2910
    case DEMANGLE_COMPONENT_VTT:
2911
      d_append_string_constant (dpi, "VTT for ");
2912
      d_print_comp (dpi, d_left (dc));
2913
      return;
2914
 
2915
    case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
2916
      d_append_string_constant (dpi, "construction vtable for ");
2917
      d_print_comp (dpi, d_left (dc));
2918
      d_append_string_constant (dpi, "-in-");
2919
      d_print_comp (dpi, d_right (dc));
2920
      return;
2921
 
2922
    case DEMANGLE_COMPONENT_TYPEINFO:
2923
      d_append_string_constant (dpi, "typeinfo for ");
2924
      d_print_comp (dpi, d_left (dc));
2925
      return;
2926
 
2927
    case DEMANGLE_COMPONENT_TYPEINFO_NAME:
2928
      d_append_string_constant (dpi, "typeinfo name for ");
2929
      d_print_comp (dpi, d_left (dc));
2930
      return;
2931
 
2932
    case DEMANGLE_COMPONENT_TYPEINFO_FN:
2933
      d_append_string_constant (dpi, "typeinfo fn for ");
2934
      d_print_comp (dpi, d_left (dc));
2935
      return;
2936
 
2937
    case DEMANGLE_COMPONENT_THUNK:
2938
      d_append_string_constant (dpi, "non-virtual thunk to ");
2939
      d_print_comp (dpi, d_left (dc));
2940
      return;
2941
 
2942
    case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
2943
      d_append_string_constant (dpi, "virtual thunk to ");
2944
      d_print_comp (dpi, d_left (dc));
2945
      return;
2946
 
2947
    case DEMANGLE_COMPONENT_COVARIANT_THUNK:
2948
      d_append_string_constant (dpi, "covariant return thunk to ");
2949
      d_print_comp (dpi, d_left (dc));
2950
      return;
2951
 
2952
    case DEMANGLE_COMPONENT_JAVA_CLASS:
2953
      d_append_string_constant (dpi, "java Class for ");
2954
      d_print_comp (dpi, d_left (dc));
2955
      return;
2956
 
2957
    case DEMANGLE_COMPONENT_GUARD:
2958
      d_append_string_constant (dpi, "guard variable for ");
2959
      d_print_comp (dpi, d_left (dc));
2960
      return;
2961
 
2962
    case DEMANGLE_COMPONENT_REFTEMP:
2963
      d_append_string_constant (dpi, "reference temporary for ");
2964
      d_print_comp (dpi, d_left (dc));
2965
      return;
2966
 
2967
    case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
2968
      d_append_string_constant (dpi, "hidden alias for ");
2969
      d_print_comp (dpi, d_left (dc));
2970
      return;
2971
 
2972
    case DEMANGLE_COMPONENT_SUB_STD:
2973
      d_append_buffer (dpi, dc->u.s_string.string, dc->u.s_string.len);
2974
      return;
2975
 
2976
    case DEMANGLE_COMPONENT_RESTRICT:
2977
    case DEMANGLE_COMPONENT_VOLATILE:
2978
    case DEMANGLE_COMPONENT_CONST:
2979
      {
2980
        struct d_print_mod *pdpm;
2981
 
2982
        /* When printing arrays, it's possible to have cases where the
2983
           same CV-qualifier gets pushed on the stack multiple times.
2984
           We only need to print it once.  */
2985
 
2986
        for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next)
2987
          {
2988
            if (! pdpm->printed)
2989
              {
2990
                if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT
2991
                    && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE
2992
                    && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
2993
                  break;
2994
                if (pdpm->mod->type == dc->type)
2995
                  {
2996
                    d_print_comp (dpi, d_left (dc));
2997
                    return;
2998
                  }
2999
              }
3000
          }
3001
      }
3002
      /* Fall through.  */
3003
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
3004
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
3005
    case DEMANGLE_COMPONENT_CONST_THIS:
3006
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3007
    case DEMANGLE_COMPONENT_POINTER:
3008
    case DEMANGLE_COMPONENT_REFERENCE:
3009
    case DEMANGLE_COMPONENT_COMPLEX:
3010
    case DEMANGLE_COMPONENT_IMAGINARY:
3011
      {
3012
        /* We keep a list of modifiers on the stack.  */
3013
        struct d_print_mod dpm;
3014
 
3015
        dpm.next = dpi->modifiers;
3016
        dpi->modifiers = &dpm;
3017
        dpm.mod = dc;
3018
        dpm.printed = 0;
3019
        dpm.templates = dpi->templates;
3020
 
3021
        d_print_comp (dpi, d_left (dc));
3022
 
3023
        /* If the modifier didn't get printed by the type, print it
3024
           now.  */
3025
        if (! dpm.printed)
3026
          d_print_mod (dpi, dc);
3027
 
3028
        dpi->modifiers = dpm.next;
3029
 
3030
        return;
3031
      }
3032
 
3033
    case DEMANGLE_COMPONENT_BUILTIN_TYPE:
3034
      if ((dpi->options & DMGL_JAVA) == 0)
3035
        d_append_buffer (dpi, dc->u.s_builtin.type->name,
3036
                         dc->u.s_builtin.type->len);
3037
      else
3038
        d_append_buffer (dpi, dc->u.s_builtin.type->java_name,
3039
                         dc->u.s_builtin.type->java_len);
3040
      return;
3041
 
3042
    case DEMANGLE_COMPONENT_VENDOR_TYPE:
3043
      d_print_comp (dpi, d_left (dc));
3044
      return;
3045
 
3046
    case DEMANGLE_COMPONENT_FUNCTION_TYPE:
3047
      {
3048
        if ((dpi->options & DMGL_RET_POSTFIX) != 0)
3049
          d_print_function_type (dpi, dc, dpi->modifiers);
3050
 
3051
        /* Print return type if present */
3052
        if (d_left (dc) != NULL)
3053
          {
3054
            struct d_print_mod dpm;
3055
 
3056
            /* We must pass this type down as a modifier in order to
3057
               print it in the right location.  */
3058
            dpm.next = dpi->modifiers;
3059
            dpi->modifiers = &dpm;
3060
            dpm.mod = dc;
3061
            dpm.printed = 0;
3062
            dpm.templates = dpi->templates;
3063
 
3064
            d_print_comp (dpi, d_left (dc));
3065
 
3066
            dpi->modifiers = dpm.next;
3067
 
3068
            if (dpm.printed)
3069
              return;
3070
 
3071
            /* In standard prefix notation, there is a space between the
3072
               return type and the function signature.  */
3073
            if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3074
              d_append_char (dpi, ' ');
3075
          }
3076
 
3077
        if ((dpi->options & DMGL_RET_POSTFIX) == 0)
3078
          d_print_function_type (dpi, dc, dpi->modifiers);
3079
 
3080
        return;
3081
      }
3082
 
3083
    case DEMANGLE_COMPONENT_ARRAY_TYPE:
3084
      {
3085
        struct d_print_mod *hold_modifiers;
3086
        struct d_print_mod adpm[4];
3087
        unsigned int i;
3088
        struct d_print_mod *pdpm;
3089
 
3090
        /* We must pass this type down as a modifier in order to print
3091
           multi-dimensional arrays correctly.  If the array itself is
3092
           CV-qualified, we act as though the element type were
3093
           CV-qualified.  We do this by copying the modifiers down
3094
           rather than fiddling pointers, so that we don't wind up
3095
           with a d_print_mod higher on the stack pointing into our
3096
           stack frame after we return.  */
3097
 
3098
        hold_modifiers = dpi->modifiers;
3099
 
3100
        adpm[0].next = hold_modifiers;
3101
        dpi->modifiers = &adpm[0];
3102
        adpm[0].mod = dc;
3103
        adpm[0].printed = 0;
3104
        adpm[0].templates = dpi->templates;
3105
 
3106
        i = 1;
3107
        pdpm = hold_modifiers;
3108
        while (pdpm != NULL
3109
               && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT
3110
                   || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE
3111
                   || pdpm->mod->type == DEMANGLE_COMPONENT_CONST))
3112
          {
3113
            if (! pdpm->printed)
3114
              {
3115
                if (i >= sizeof adpm / sizeof adpm[0])
3116
                  {
3117
                    d_print_error (dpi);
3118
                    return;
3119
                  }
3120
 
3121
                adpm[i] = *pdpm;
3122
                adpm[i].next = dpi->modifiers;
3123
                dpi->modifiers = &adpm[i];
3124
                pdpm->printed = 1;
3125
                ++i;
3126
              }
3127
 
3128
            pdpm = pdpm->next;
3129
          }
3130
 
3131
        d_print_comp (dpi, d_right (dc));
3132
 
3133
        dpi->modifiers = hold_modifiers;
3134
 
3135
        if (adpm[0].printed)
3136
          return;
3137
 
3138
        while (i > 1)
3139
          {
3140
            --i;
3141
            d_print_mod (dpi, adpm[i].mod);
3142
          }
3143
 
3144
        d_print_array_type (dpi, dc, dpi->modifiers);
3145
 
3146
        return;
3147
      }
3148
 
3149
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3150
      {
3151
        struct d_print_mod dpm;
3152
 
3153
        dpm.next = dpi->modifiers;
3154
        dpi->modifiers = &dpm;
3155
        dpm.mod = dc;
3156
        dpm.printed = 0;
3157
        dpm.templates = dpi->templates;
3158
 
3159
        d_print_comp (dpi, d_right (dc));
3160
 
3161
        /* If the modifier didn't get printed by the type, print it
3162
           now.  */
3163
        if (! dpm.printed)
3164
          {
3165
            d_append_char (dpi, ' ');
3166
            d_print_comp (dpi, d_left (dc));
3167
            d_append_string_constant (dpi, "::*");
3168
          }
3169
 
3170
        dpi->modifiers = dpm.next;
3171
 
3172
        return;
3173
      }
3174
 
3175
    case DEMANGLE_COMPONENT_ARGLIST:
3176
    case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
3177
      d_print_comp (dpi, d_left (dc));
3178
      if (d_right (dc) != NULL)
3179
        {
3180
          d_append_string_constant (dpi, ", ");
3181
          d_print_comp (dpi, d_right (dc));
3182
        }
3183
      return;
3184
 
3185
    case DEMANGLE_COMPONENT_OPERATOR:
3186
      {
3187
        char c;
3188
 
3189
        d_append_string_constant (dpi, "operator");
3190
        c = dc->u.s_operator.op->name[0];
3191
        if (IS_LOWER (c))
3192
          d_append_char (dpi, ' ');
3193
        d_append_buffer (dpi, dc->u.s_operator.op->name,
3194
                         dc->u.s_operator.op->len);
3195
        return;
3196
      }
3197
 
3198
    case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
3199
      d_append_string_constant (dpi, "operator ");
3200
      d_print_comp (dpi, dc->u.s_extended_operator.name);
3201
      return;
3202
 
3203
    case DEMANGLE_COMPONENT_CAST:
3204
      d_append_string_constant (dpi, "operator ");
3205
      d_print_cast (dpi, dc);
3206
      return;
3207
 
3208
    case DEMANGLE_COMPONENT_UNARY:
3209
      if (d_left (dc)->type != DEMANGLE_COMPONENT_CAST)
3210
        d_print_expr_op (dpi, d_left (dc));
3211
      else
3212
        {
3213
          d_append_char (dpi, '(');
3214
          d_print_cast (dpi, d_left (dc));
3215
          d_append_char (dpi, ')');
3216
        }
3217
      d_append_char (dpi, '(');
3218
      d_print_comp (dpi, d_right (dc));
3219
      d_append_char (dpi, ')');
3220
      return;
3221
 
3222
    case DEMANGLE_COMPONENT_BINARY:
3223
      if (d_right (dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS)
3224
        {
3225
          d_print_error (dpi);
3226
          return;
3227
        }
3228
 
3229
      /* We wrap an expression which uses the greater-than operator in
3230
         an extra layer of parens so that it does not get confused
3231
         with the '>' which ends the template parameters.  */
3232
      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3233
          && d_left (dc)->u.s_operator.op->len == 1
3234
          && d_left (dc)->u.s_operator.op->name[0] == '>')
3235
        d_append_char (dpi, '(');
3236
 
3237
      d_append_char (dpi, '(');
3238
      d_print_comp (dpi, d_left (d_right (dc)));
3239
      d_append_string_constant (dpi, ") ");
3240
      d_print_expr_op (dpi, d_left (dc));
3241
      d_append_string_constant (dpi, " (");
3242
      d_print_comp (dpi, d_right (d_right (dc)));
3243
      d_append_char (dpi, ')');
3244
 
3245
      if (d_left (dc)->type == DEMANGLE_COMPONENT_OPERATOR
3246
          && d_left (dc)->u.s_operator.op->len == 1
3247
          && d_left (dc)->u.s_operator.op->name[0] == '>')
3248
        d_append_char (dpi, ')');
3249
 
3250
      return;
3251
 
3252
    case DEMANGLE_COMPONENT_BINARY_ARGS:
3253
      /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
3254
      d_print_error (dpi);
3255
      return;
3256
 
3257
    case DEMANGLE_COMPONENT_TRINARY:
3258
      if (d_right (dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1
3259
          || d_right (d_right (dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2)
3260
        {
3261
          d_print_error (dpi);
3262
          return;
3263
        }
3264
      d_append_char (dpi, '(');
3265
      d_print_comp (dpi, d_left (d_right (dc)));
3266
      d_append_string_constant (dpi, ") ");
3267
      d_print_expr_op (dpi, d_left (dc));
3268
      d_append_string_constant (dpi, " (");
3269
      d_print_comp (dpi, d_left (d_right (d_right (dc))));
3270
      d_append_string_constant (dpi, ") : (");
3271
      d_print_comp (dpi, d_right (d_right (d_right (dc))));
3272
      d_append_char (dpi, ')');
3273
      return;
3274
 
3275
    case DEMANGLE_COMPONENT_TRINARY_ARG1:
3276
    case DEMANGLE_COMPONENT_TRINARY_ARG2:
3277
      /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
3278
      d_print_error (dpi);
3279
      return;
3280
 
3281
    case DEMANGLE_COMPONENT_LITERAL:
3282
    case DEMANGLE_COMPONENT_LITERAL_NEG:
3283
      {
3284
        enum d_builtin_type_print tp;
3285
 
3286
        /* For some builtin types, produce simpler output.  */
3287
        tp = D_PRINT_DEFAULT;
3288
        if (d_left (dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE)
3289
          {
3290
            tp = d_left (dc)->u.s_builtin.type->print;
3291
            switch (tp)
3292
              {
3293
              case D_PRINT_INT:
3294
              case D_PRINT_UNSIGNED:
3295
              case D_PRINT_LONG:
3296
              case D_PRINT_UNSIGNED_LONG:
3297
              case D_PRINT_LONG_LONG:
3298
              case D_PRINT_UNSIGNED_LONG_LONG:
3299
                if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME)
3300
                  {
3301
                    if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3302
                      d_append_char (dpi, '-');
3303
                    d_print_comp (dpi, d_right (dc));
3304
                    switch (tp)
3305
                      {
3306
                      default:
3307
                        break;
3308
                      case D_PRINT_UNSIGNED:
3309
                        d_append_char (dpi, 'u');
3310
                        break;
3311
                      case D_PRINT_LONG:
3312
                        d_append_char (dpi, 'l');
3313
                        break;
3314
                      case D_PRINT_UNSIGNED_LONG:
3315
                        d_append_string_constant (dpi, "ul");
3316
                        break;
3317
                      case D_PRINT_LONG_LONG:
3318
                        d_append_string_constant (dpi, "ll");
3319
                        break;
3320
                      case D_PRINT_UNSIGNED_LONG_LONG:
3321
                        d_append_string_constant (dpi, "ull");
3322
                        break;
3323
                      }
3324
                    return;
3325
                  }
3326
                break;
3327
 
3328
              case D_PRINT_BOOL:
3329
                if (d_right (dc)->type == DEMANGLE_COMPONENT_NAME
3330
                    && d_right (dc)->u.s_name.len == 1
3331
                    && dc->type == DEMANGLE_COMPONENT_LITERAL)
3332
                  {
3333
                    switch (d_right (dc)->u.s_name.s[0])
3334
                      {
3335
                      case '0':
3336
                        d_append_string_constant (dpi, "false");
3337
                        return;
3338
                      case '1':
3339
                        d_append_string_constant (dpi, "true");
3340
                        return;
3341
                      default:
3342
                        break;
3343
                      }
3344
                  }
3345
                break;
3346
 
3347
              default:
3348
                break;
3349
              }
3350
          }
3351
 
3352
        d_append_char (dpi, '(');
3353
        d_print_comp (dpi, d_left (dc));
3354
        d_append_char (dpi, ')');
3355
        if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
3356
          d_append_char (dpi, '-');
3357
        if (tp == D_PRINT_FLOAT)
3358
          d_append_char (dpi, '[');
3359
        d_print_comp (dpi, d_right (dc));
3360
        if (tp == D_PRINT_FLOAT)
3361
          d_append_char (dpi, ']');
3362
      }
3363
      return;
3364
 
3365
    default:
3366
      d_print_error (dpi);
3367
      return;
3368
    }
3369
}
3370
 
3371
/* Print a Java dentifier.  For Java we try to handle encoded extended
3372
   Unicode characters.  The C++ ABI doesn't mention Unicode encoding,
3373
   so we don't it for C++.  Characters are encoded as
3374
   __U<hex-char>+_.  */
3375
 
3376
static void
3377
d_print_java_identifier (struct d_print_info *dpi, const char *name, int len)
3378
{
3379
  const char *p;
3380
  const char *end;
3381
 
3382
  end = name + len;
3383
  for (p = name; p < end; ++p)
3384
    {
3385
      if (end - p > 3
3386
          && p[0] == '_'
3387
          && p[1] == '_'
3388
          && p[2] == 'U')
3389
        {
3390
          unsigned long c;
3391
          const char *q;
3392
 
3393
          c = 0;
3394
          for (q = p + 3; q < end; ++q)
3395
            {
3396
              int dig;
3397
 
3398
              if (IS_DIGIT (*q))
3399
                dig = *q - '0';
3400
              else if (*q >= 'A' && *q <= 'F')
3401
                dig = *q - 'A' + 10;
3402
              else if (*q >= 'a' && *q <= 'f')
3403
                dig = *q - 'a' + 10;
3404
              else
3405
                break;
3406
 
3407
              c = c * 16 + dig;
3408
            }
3409
          /* If the Unicode character is larger than 256, we don't try
3410
             to deal with it here.  FIXME.  */
3411
          if (q < end && *q == '_' && c < 256)
3412
            {
3413
              d_append_char (dpi, c);
3414
              p = q;
3415
              continue;
3416
            }
3417
        }
3418
 
3419
      d_append_char (dpi, *p);
3420
    }
3421
}
3422
 
3423
/* Print a list of modifiers.  SUFFIX is 1 if we are printing
3424
   qualifiers on this after printing a function.  */
3425
 
3426
static void
3427
d_print_mod_list (struct d_print_info *dpi,
3428
                  struct d_print_mod *mods, int suffix)
3429
{
3430
  struct d_print_template *hold_dpt;
3431
 
3432
  if (mods == NULL || d_print_saw_error (dpi))
3433
    return;
3434
 
3435
  if (mods->printed
3436
      || (! suffix
3437
          && (mods->mod->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3438
              || mods->mod->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3439
              || mods->mod->type == DEMANGLE_COMPONENT_CONST_THIS)))
3440
    {
3441
      d_print_mod_list (dpi, mods->next, suffix);
3442
      return;
3443
    }
3444
 
3445
  mods->printed = 1;
3446
 
3447
  hold_dpt = dpi->templates;
3448
  dpi->templates = mods->templates;
3449
 
3450
  if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
3451
    {
3452
      d_print_function_type (dpi, mods->mod, mods->next);
3453
      dpi->templates = hold_dpt;
3454
      return;
3455
    }
3456
  else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
3457
    {
3458
      d_print_array_type (dpi, mods->mod, mods->next);
3459
      dpi->templates = hold_dpt;
3460
      return;
3461
    }
3462
  else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME)
3463
    {
3464
      struct d_print_mod *hold_modifiers;
3465
      struct demangle_component *dc;
3466
 
3467
      /* When this is on the modifier stack, we have pulled any
3468
         qualifiers off the right argument already.  Otherwise, we
3469
         print it as usual, but don't let the left argument see any
3470
         modifiers.  */
3471
 
3472
      hold_modifiers = dpi->modifiers;
3473
      dpi->modifiers = NULL;
3474
      d_print_comp (dpi, d_left (mods->mod));
3475
      dpi->modifiers = hold_modifiers;
3476
 
3477
      if ((dpi->options & DMGL_JAVA) == 0)
3478
        d_append_string_constant (dpi, "::");
3479
      else
3480
        d_append_char (dpi, '.');
3481
 
3482
      dc = d_right (mods->mod);
3483
      while (dc->type == DEMANGLE_COMPONENT_RESTRICT_THIS
3484
             || dc->type == DEMANGLE_COMPONENT_VOLATILE_THIS
3485
             || dc->type == DEMANGLE_COMPONENT_CONST_THIS)
3486
        dc = d_left (dc);
3487
 
3488
      d_print_comp (dpi, dc);
3489
 
3490
      dpi->templates = hold_dpt;
3491
      return;
3492
    }
3493
 
3494
  d_print_mod (dpi, mods->mod);
3495
 
3496
  dpi->templates = hold_dpt;
3497
 
3498
  d_print_mod_list (dpi, mods->next, suffix);
3499
}
3500
 
3501
/* Print a modifier.  */
3502
 
3503
static void
3504
d_print_mod (struct d_print_info *dpi,
3505
             const struct demangle_component *mod)
3506
{
3507
  switch (mod->type)
3508
    {
3509
    case DEMANGLE_COMPONENT_RESTRICT:
3510
    case DEMANGLE_COMPONENT_RESTRICT_THIS:
3511
      d_append_string_constant (dpi, " restrict");
3512
      return;
3513
    case DEMANGLE_COMPONENT_VOLATILE:
3514
    case DEMANGLE_COMPONENT_VOLATILE_THIS:
3515
      d_append_string_constant (dpi, " volatile");
3516
      return;
3517
    case DEMANGLE_COMPONENT_CONST:
3518
    case DEMANGLE_COMPONENT_CONST_THIS:
3519
      d_append_string_constant (dpi, " const");
3520
      return;
3521
    case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3522
      d_append_char (dpi, ' ');
3523
      d_print_comp (dpi, d_right (mod));
3524
      return;
3525
    case DEMANGLE_COMPONENT_POINTER:
3526
      /* There is no pointer symbol in Java.  */
3527
      if ((dpi->options & DMGL_JAVA) == 0)
3528
        d_append_char (dpi, '*');
3529
      return;
3530
    case DEMANGLE_COMPONENT_REFERENCE:
3531
      d_append_char (dpi, '&');
3532
      return;
3533
    case DEMANGLE_COMPONENT_COMPLEX:
3534
      d_append_string_constant (dpi, "complex ");
3535
      return;
3536
    case DEMANGLE_COMPONENT_IMAGINARY:
3537
      d_append_string_constant (dpi, "imaginary ");
3538
      return;
3539
    case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3540
      if (d_last_char (dpi) != '(')
3541
        d_append_char (dpi, ' ');
3542
      d_print_comp (dpi, d_left (mod));
3543
      d_append_string_constant (dpi, "::*");
3544
      return;
3545
    case DEMANGLE_COMPONENT_TYPED_NAME:
3546
      d_print_comp (dpi, d_left (mod));
3547
      return;
3548
    default:
3549
      /* Otherwise, we have something that won't go back on the
3550
         modifier stack, so we can just print it.  */
3551
      d_print_comp (dpi, mod);
3552
      return;
3553
    }
3554
}
3555
 
3556
/* Print a function type, except for the return type.  */
3557
 
3558
static void
3559
d_print_function_type (struct d_print_info *dpi,
3560
                       const struct demangle_component *dc,
3561
                       struct d_print_mod *mods)
3562
{
3563
  int need_paren;
3564
  int saw_mod;
3565
  int need_space;
3566
  struct d_print_mod *p;
3567
  struct d_print_mod *hold_modifiers;
3568
 
3569
  need_paren = 0;
3570
  saw_mod = 0;
3571
  need_space = 0;
3572
  for (p = mods; p != NULL; p = p->next)
3573
    {
3574
      if (p->printed)
3575
        break;
3576
 
3577
      saw_mod = 1;
3578
      switch (p->mod->type)
3579
        {
3580
        case DEMANGLE_COMPONENT_POINTER:
3581
        case DEMANGLE_COMPONENT_REFERENCE:
3582
          need_paren = 1;
3583
          break;
3584
        case DEMANGLE_COMPONENT_RESTRICT:
3585
        case DEMANGLE_COMPONENT_VOLATILE:
3586
        case DEMANGLE_COMPONENT_CONST:
3587
        case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
3588
        case DEMANGLE_COMPONENT_COMPLEX:
3589
        case DEMANGLE_COMPONENT_IMAGINARY:
3590
        case DEMANGLE_COMPONENT_PTRMEM_TYPE:
3591
          need_space = 1;
3592
          need_paren = 1;
3593
          break;
3594
        case DEMANGLE_COMPONENT_RESTRICT_THIS:
3595
        case DEMANGLE_COMPONENT_VOLATILE_THIS:
3596
        case DEMANGLE_COMPONENT_CONST_THIS:
3597
          break;
3598
        default:
3599
          break;
3600
        }
3601
      if (need_paren)
3602
        break;
3603
    }
3604
 
3605
  if (d_left (dc) != NULL && ! saw_mod)
3606
    need_paren = 1;
3607
 
3608
  if (need_paren)
3609
    {
3610
      if (! need_space)
3611
        {
3612
          if (d_last_char (dpi) != '('
3613
              && d_last_char (dpi) != '*')
3614
            need_space = 1;
3615
        }
3616
      if (need_space && d_last_char (dpi) != ' ')
3617
        d_append_char (dpi, ' ');
3618
      d_append_char (dpi, '(');
3619
    }
3620
 
3621
  hold_modifiers = dpi->modifiers;
3622
  dpi->modifiers = NULL;
3623
 
3624
  d_print_mod_list (dpi, mods, 0);
3625
 
3626
  if (need_paren)
3627
    d_append_char (dpi, ')');
3628
 
3629
  d_append_char (dpi, '(');
3630
 
3631
  if (d_right (dc) != NULL)
3632
    d_print_comp (dpi, d_right (dc));
3633
 
3634
  d_append_char (dpi, ')');
3635
 
3636
  d_print_mod_list (dpi, mods, 1);
3637
 
3638
  dpi->modifiers = hold_modifiers;
3639
}
3640
 
3641
/* Print an array type, except for the element type.  */
3642
 
3643
static void
3644
d_print_array_type (struct d_print_info *dpi,
3645
                    const struct demangle_component *dc,
3646
                    struct d_print_mod *mods)
3647
{
3648
  int need_space;
3649
 
3650
  need_space = 1;
3651
  if (mods != NULL)
3652
    {
3653
      int need_paren;
3654
      struct d_print_mod *p;
3655
 
3656
      need_paren = 0;
3657
      for (p = mods; p != NULL; p = p->next)
3658
        {
3659
          if (! p->printed)
3660
            {
3661
              if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE)
3662
                {
3663
                  need_space = 0;
3664
                  break;
3665
                }
3666
              else
3667
                {
3668
                  need_paren = 1;
3669
                  need_space = 1;
3670
                  break;
3671
                }
3672
            }
3673
        }
3674
 
3675
      if (need_paren)
3676
        d_append_string_constant (dpi, " (");
3677
 
3678
      d_print_mod_list (dpi, mods, 0);
3679
 
3680
      if (need_paren)
3681
        d_append_char (dpi, ')');
3682
    }
3683
 
3684
  if (need_space)
3685
    d_append_char (dpi, ' ');
3686
 
3687
  d_append_char (dpi, '[');
3688
 
3689
  if (d_left (dc) != NULL)
3690
    d_print_comp (dpi, d_left (dc));
3691
 
3692
  d_append_char (dpi, ']');
3693
}
3694
 
3695
/* Print an operator in an expression.  */
3696
 
3697
static void
3698
d_print_expr_op (struct d_print_info *dpi,
3699
                 const struct demangle_component *dc)
3700
{
3701
  if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
3702
    d_append_buffer (dpi, dc->u.s_operator.op->name,
3703
                     dc->u.s_operator.op->len);
3704
  else
3705
    d_print_comp (dpi, dc);
3706
}
3707
 
3708
/* Print a cast.  */
3709
 
3710
static void
3711
d_print_cast (struct d_print_info *dpi,
3712
              const struct demangle_component *dc)
3713
{
3714
  if (d_left (dc)->type != DEMANGLE_COMPONENT_TEMPLATE)
3715
    d_print_comp (dpi, d_left (dc));
3716
  else
3717
    {
3718
      struct d_print_mod *hold_dpm;
3719
      struct d_print_template dpt;
3720
 
3721
      /* It appears that for a templated cast operator, we need to put
3722
         the template parameters in scope for the operator name, but
3723
         not for the parameters.  The effect is that we need to handle
3724
         the template printing here.  */
3725
 
3726
      hold_dpm = dpi->modifiers;
3727
      dpi->modifiers = NULL;
3728
 
3729
      dpt.next = dpi->templates;
3730
      dpi->templates = &dpt;
3731
      dpt.template_decl = d_left (dc);
3732
 
3733
      d_print_comp (dpi, d_left (d_left (dc)));
3734
 
3735
      dpi->templates = dpt.next;
3736
 
3737
      if (d_last_char (dpi) == '<')
3738
        d_append_char (dpi, ' ');
3739
      d_append_char (dpi, '<');
3740
      d_print_comp (dpi, d_right (d_left (dc)));
3741
      /* Avoid generating two consecutive '>' characters, to avoid
3742
         the C++ syntactic ambiguity.  */
3743
      if (d_last_char (dpi) == '>')
3744
        d_append_char (dpi, ' ');
3745
      d_append_char (dpi, '>');
3746
 
3747
      dpi->modifiers = hold_dpm;
3748
    }
3749
}
3750
 
3751
/* Initialize the information structure we use to pass around
3752
   information.  */
3753
 
3754
CP_STATIC_IF_GLIBCPP_V3
3755
void
3756
cplus_demangle_init_info (const char *mangled, int options, size_t len,
3757
                          struct d_info *di)
3758
{
3759
  di->s = mangled;
3760
  di->send = mangled + len;
3761
  di->options = options;
3762
 
3763
  di->n = mangled;
3764
 
3765
  /* We can not need more components than twice the number of chars in
3766
     the mangled string.  Most components correspond directly to
3767
     chars, but the ARGLIST types are exceptions.  */
3768
  di->num_comps = 2 * len;
3769
  di->next_comp = 0;
3770
 
3771
  /* Similarly, we can not need more substitutions than there are
3772
     chars in the mangled string.  */
3773
  di->num_subs = len;
3774
  di->next_sub = 0;
3775
  di->did_subs = 0;
3776
 
3777
  di->last_name = NULL;
3778
 
3779
  di->expansion = 0;
3780
}
3781
 
3782
/* Entry point for the demangler.  If MANGLED is a g++ v3 ABI mangled
3783
   name, return a buffer allocated with malloc holding the demangled
3784
   name.  OPTIONS is the usual libiberty demangler options.  On
3785
   success, this sets *PALC to the allocated size of the returned
3786
   buffer.  On failure, this sets *PALC to 0 for a bad name, or 1 for
3787
   a memory allocation failure.  On failure, this returns NULL.  */
3788
 
3789
static char *
3790
d_demangle (const char* mangled, int options, size_t *palc)
3791
{
3792
  size_t len;
3793
  int type;
3794
  struct d_info di;
3795
  struct demangle_component *dc;
3796
  int estimate;
3797
  char *ret;
3798
 
3799
  *palc = 0;
3800
 
3801
  len = strlen (mangled);
3802
 
3803
  if (mangled[0] == '_' && mangled[1] == 'Z')
3804
    type = 0;
3805
  else if (strncmp (mangled, "_GLOBAL_", 8) == 0
3806
           && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$')
3807
           && (mangled[9] == 'D' || mangled[9] == 'I')
3808
           && mangled[10] == '_')
3809
    {
3810
      char *r;
3811
 
3812
      r = (char *) malloc (40 + len - 11);
3813
      if (r == NULL)
3814
        *palc = 1;
3815
      else
3816
        {
3817
          if (mangled[9] == 'I')
3818
            strcpy (r, "global constructors keyed to ");
3819
          else
3820
            strcpy (r, "global destructors keyed to ");
3821
          strcat (r, mangled + 11);
3822
        }
3823
      return r;
3824
    }
3825
  else
3826
    {
3827
      if ((options & DMGL_TYPES) == 0)
3828
        return NULL;
3829
      type = 1;
3830
    }
3831
 
3832
  cplus_demangle_init_info (mangled, options, len, &di);
3833
 
3834
  {
3835
#ifdef CP_DYNAMIC_ARRAYS
3836
    __extension__ struct demangle_component comps[di.num_comps];
3837
    __extension__ struct demangle_component *subs[di.num_subs];
3838
 
3839
    di.comps = &comps[0];
3840
    di.subs = &subs[0];
3841
#else
3842
    di.comps = ((struct demangle_component *)
3843
                malloc (di.num_comps * sizeof (struct demangle_component)));
3844
    di.subs = ((struct demangle_component **)
3845
               malloc (di.num_subs * sizeof (struct demangle_component *)));
3846
    if (di.comps == NULL || di.subs == NULL)
3847
      {
3848
        if (di.comps != NULL)
3849
          free (di.comps);
3850
        if (di.subs != NULL)
3851
          free (di.subs);
3852
        *palc = 1;
3853
        return NULL;
3854
      }
3855
#endif
3856
 
3857
    if (! type)
3858
      dc = cplus_demangle_mangled_name (&di, 1);
3859
    else
3860
      dc = cplus_demangle_type (&di);
3861
 
3862
    /* If DMGL_PARAMS is set, then if we didn't consume the entire
3863
       mangled string, then we didn't successfully demangle it.  If
3864
       DMGL_PARAMS is not set, we didn't look at the trailing
3865
       parameters.  */
3866
    if (((options & DMGL_PARAMS) != 0) && d_peek_char (&di) != '\0')
3867
      dc = NULL;
3868
 
3869
#ifdef CP_DEMANGLE_DEBUG
3870
    if (dc == NULL)
3871
      printf ("failed demangling\n");
3872
    else
3873
      d_dump (dc, 0);
3874
#endif
3875
 
3876
    /* We try to guess the length of the demangled string, to minimize
3877
       calls to realloc during demangling.  */
3878
    estimate = len + di.expansion + 10 * di.did_subs;
3879
    estimate += estimate / 8;
3880
 
3881
    ret = NULL;
3882
    if (dc != NULL)
3883
      ret = cplus_demangle_print (options, dc, estimate, palc);
3884
 
3885
#ifndef CP_DYNAMIC_ARRAYS
3886
    free (di.comps);
3887
    free (di.subs);
3888
#endif
3889
 
3890
#ifdef CP_DEMANGLE_DEBUG
3891
    if (ret != NULL)
3892
      {
3893
        int rlen;
3894
 
3895
        rlen = strlen (ret);
3896
        if (rlen > 2 * estimate)
3897
          printf ("*** Length %d much greater than estimate %d\n",
3898
                  rlen, estimate);
3899
        else if (rlen > estimate)
3900
          printf ("*** Length %d greater than estimate %d\n",
3901
                  rlen, estimate);
3902
        else if (rlen < estimate / 2)
3903
          printf ("*** Length %d much less than estimate %d\n",
3904
                  rlen, estimate);
3905
      }
3906
#endif
3907
  }
3908
 
3909
  return ret;
3910
}
3911
 
3912
#if defined(IN_LIBGCC2) || defined(IN_GLIBCPP_V3)
3913
 
3914
extern char *__cxa_demangle (const char *, char *, size_t *, int *);
3915
 
3916
/* ia64 ABI-mandated entry point in the C++ runtime library for
3917
   performing demangling.  MANGLED_NAME is a NUL-terminated character
3918
   string containing the name to be demangled.
3919
 
3920
   OUTPUT_BUFFER is a region of memory, allocated with malloc, of
3921
   *LENGTH bytes, into which the demangled name is stored.  If
3922
   OUTPUT_BUFFER is not long enough, it is expanded using realloc.
3923
   OUTPUT_BUFFER may instead be NULL; in that case, the demangled name
3924
   is placed in a region of memory allocated with malloc.
3925
 
3926
   If LENGTH is non-NULL, the length of the buffer conaining the
3927
   demangled name, is placed in *LENGTH.
3928
 
3929
   The return value is a pointer to the start of the NUL-terminated
3930
   demangled name, or NULL if the demangling fails.  The caller is
3931
   responsible for deallocating this memory using free.
3932
 
3933
   *STATUS is set to one of the following values:
3934
      0: The demangling operation succeeded.
3935
     -1: A memory allocation failure occurred.
3936
     -2: MANGLED_NAME is not a valid name under the C++ ABI mangling rules.
3937
     -3: One of the arguments is invalid.
3938
 
3939
   The demangling is performed using the C++ ABI mangling rules, with
3940
   GNU extensions.  */
3941
 
3942
char *
3943
__cxa_demangle (const char *mangled_name, char *output_buffer,
3944
                size_t *length, int *status)
3945
{
3946
  char *demangled;
3947
  size_t alc;
3948
 
3949
  if (mangled_name == NULL)
3950
    {
3951
      if (status != NULL)
3952
        *status = -3;
3953
      return NULL;
3954
    }
3955
 
3956
  if (output_buffer != NULL && length == NULL)
3957
    {
3958
      if (status != NULL)
3959
        *status = -3;
3960
      return NULL;
3961
    }
3962
 
3963
  demangled = d_demangle (mangled_name, DMGL_PARAMS | DMGL_TYPES, &alc);
3964
 
3965
  if (demangled == NULL)
3966
    {
3967
      if (status != NULL)
3968
        {
3969
          if (alc == 1)
3970
            *status = -1;
3971
          else
3972
            *status = -2;
3973
        }
3974
      return NULL;
3975
    }
3976
 
3977
  if (output_buffer == NULL)
3978
    {
3979
      if (length != NULL)
3980
        *length = alc;
3981
    }
3982
  else
3983
    {
3984
      if (strlen (demangled) < *length)
3985
        {
3986
          strcpy (output_buffer, demangled);
3987
          free (demangled);
3988
          demangled = output_buffer;
3989
        }
3990
      else
3991
        {
3992
          free (output_buffer);
3993
          *length = alc;
3994
        }
3995
    }
3996
 
3997
  if (status != NULL)
3998
    *status = 0;
3999
 
4000
  return demangled;
4001
}
4002
 
4003
#else /* ! (IN_LIBGCC2 || IN_GLIBCPP_V3) */
4004
 
4005
/* Entry point for libiberty demangler.  If MANGLED is a g++ v3 ABI
4006
   mangled name, return a buffer allocated with malloc holding the
4007
   demangled name.  Otherwise, return NULL.  */
4008
 
4009
char *
4010
cplus_demangle_v3 (const char* mangled, int options)
4011
{
4012
  size_t alc;
4013
 
4014
  return d_demangle (mangled, options, &alc);
4015
}
4016
 
4017
/* Demangle a Java symbol.  Java uses a subset of the V3 ABI C++ mangling
4018
   conventions, but the output formatting is a little different.
4019
   This instructs the C++ demangler not to emit pointer characters ("*"), and
4020
   to use Java's namespace separator symbol ("." instead of "::").  It then
4021
   does an additional pass over the demangled output to replace instances
4022
   of JArray<TYPE> with TYPE[].  */
4023
 
4024
char *
4025
java_demangle_v3 (const char* mangled)
4026
{
4027
  size_t alc;
4028
  char *demangled;
4029
  int nesting;
4030
  char *from;
4031
  char *to;
4032
 
4033
  demangled = d_demangle (mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
4034
                          &alc);
4035
 
4036
  if (demangled == NULL)
4037
    return NULL;
4038
 
4039
  nesting = 0;
4040
  from = demangled;
4041
  to = from;
4042
  while (*from != '\0')
4043
    {
4044
      if (strncmp (from, "JArray<", 7) == 0)
4045
        {
4046
          from += 7;
4047
          ++nesting;
4048
        }
4049
      else if (nesting > 0 && *from == '>')
4050
        {
4051
          while (to > demangled && to[-1] == ' ')
4052
            --to;
4053
          *to++ = '[';
4054
          *to++ = ']';
4055
          --nesting;
4056
          ++from;
4057
        }
4058
      else
4059
        *to++ = *from++;
4060
    }
4061
 
4062
  *to = '\0';
4063
 
4064
  return demangled;
4065
}
4066
 
4067
#endif /* IN_LIBGCC2 || IN_GLIBCPP_V3 */
4068
 
4069
#ifndef IN_GLIBCPP_V3
4070
 
4071
/* Demangle a string in order to find out whether it is a constructor
4072
   or destructor.  Return non-zero on success.  Set *CTOR_KIND and
4073
   *DTOR_KIND appropriately.  */
4074
 
4075
static int
4076
is_ctor_or_dtor (const char *mangled,
4077
                 enum gnu_v3_ctor_kinds *ctor_kind,
4078
                 enum gnu_v3_dtor_kinds *dtor_kind)
4079
{
4080
  struct d_info di;
4081
  struct demangle_component *dc;
4082
  int ret;
4083
 
4084
  *ctor_kind = (enum gnu_v3_ctor_kinds) 0;
4085
  *dtor_kind = (enum gnu_v3_dtor_kinds) 0;
4086
 
4087
  cplus_demangle_init_info (mangled, DMGL_GNU_V3, strlen (mangled), &di);
4088
 
4089
  {
4090
#ifdef CP_DYNAMIC_ARRAYS
4091
    __extension__ struct demangle_component comps[di.num_comps];
4092
    __extension__ struct demangle_component *subs[di.num_subs];
4093
 
4094
    di.comps = &comps[0];
4095
    di.subs = &subs[0];
4096
#else
4097
    di.comps = ((struct demangle_component *)
4098
                malloc (di.num_comps * sizeof (struct demangle_component)));
4099
    di.subs = ((struct demangle_component **)
4100
               malloc (di.num_subs * sizeof (struct demangle_component *)));
4101
    if (di.comps == NULL || di.subs == NULL)
4102
      {
4103
        if (di.comps != NULL)
4104
          free (di.comps);
4105
        if (di.subs != NULL)
4106
          free (di.subs);
4107
        return 0;
4108
      }
4109
#endif
4110
 
4111
    dc = cplus_demangle_mangled_name (&di, 1);
4112
 
4113
    /* Note that because we did not pass DMGL_PARAMS, we don't expect
4114
       to demangle the entire string.  */
4115
 
4116
    ret = 0;
4117
    while (dc != NULL)
4118
      {
4119
        switch (dc->type)
4120
          {
4121
          default:
4122
            dc = NULL;
4123
            break;
4124
          case DEMANGLE_COMPONENT_TYPED_NAME:
4125
          case DEMANGLE_COMPONENT_TEMPLATE:
4126
          case DEMANGLE_COMPONENT_RESTRICT_THIS:
4127
          case DEMANGLE_COMPONENT_VOLATILE_THIS:
4128
          case DEMANGLE_COMPONENT_CONST_THIS:
4129
            dc = d_left (dc);
4130
            break;
4131
          case DEMANGLE_COMPONENT_QUAL_NAME:
4132
          case DEMANGLE_COMPONENT_LOCAL_NAME:
4133
            dc = d_right (dc);
4134
            break;
4135
          case DEMANGLE_COMPONENT_CTOR:
4136
            *ctor_kind = dc->u.s_ctor.kind;
4137
            ret = 1;
4138
            dc = NULL;
4139
            break;
4140
          case DEMANGLE_COMPONENT_DTOR:
4141
            *dtor_kind = dc->u.s_dtor.kind;
4142
            ret = 1;
4143
            dc = NULL;
4144
            break;
4145
          }
4146
      }
4147
 
4148
#ifndef CP_DYNAMIC_ARRAYS
4149
    free (di.subs);
4150
    free (di.comps);
4151
#endif
4152
  }
4153
 
4154
  return ret;
4155
}
4156
 
4157
/* Return whether NAME is the mangled form of a g++ V3 ABI constructor
4158
   name.  A non-zero return indicates the type of constructor.  */
4159
 
4160
enum gnu_v3_ctor_kinds
4161
is_gnu_v3_mangled_ctor (const char *name)
4162
{
4163
  enum gnu_v3_ctor_kinds ctor_kind;
4164
  enum gnu_v3_dtor_kinds dtor_kind;
4165
 
4166
  if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4167
    return (enum gnu_v3_ctor_kinds) 0;
4168
  return ctor_kind;
4169
}
4170
 
4171
 
4172
/* Return whether NAME is the mangled form of a g++ V3 ABI destructor
4173
   name.  A non-zero return indicates the type of destructor.  */
4174
 
4175
enum gnu_v3_dtor_kinds
4176
is_gnu_v3_mangled_dtor (const char *name)
4177
{
4178
  enum gnu_v3_ctor_kinds ctor_kind;
4179
  enum gnu_v3_dtor_kinds dtor_kind;
4180
 
4181
  if (! is_ctor_or_dtor (name, &ctor_kind, &dtor_kind))
4182
    return (enum gnu_v3_dtor_kinds) 0;
4183
  return dtor_kind;
4184
}
4185
 
4186
#endif /* IN_GLIBCPP_V3 */
4187
 
4188
#ifdef STANDALONE_DEMANGLER
4189
 
4190
#include "getopt.h"
4191
#include "dyn-string.h"
4192
 
4193
static void print_usage (FILE* fp, int exit_value);
4194
 
4195
#define IS_ALPHA(CHAR)                                                  \
4196
  (((CHAR) >= 'a' && (CHAR) <= 'z')                                     \
4197
   || ((CHAR) >= 'A' && (CHAR) <= 'Z'))
4198
 
4199
/* Non-zero if CHAR is a character than can occur in a mangled name.  */
4200
#define is_mangled_char(CHAR)                                           \
4201
  (IS_ALPHA (CHAR) || IS_DIGIT (CHAR)                                   \
4202
   || (CHAR) == '_' || (CHAR) == '.' || (CHAR) == '$')
4203
 
4204
/* The name of this program, as invoked.  */
4205
const char* program_name;
4206
 
4207
/* Prints usage summary to FP and then exits with EXIT_VALUE.  */
4208
 
4209
static void
4210
print_usage (FILE* fp, int exit_value)
4211
{
4212
  fprintf (fp, "Usage: %s [options] [names ...]\n", program_name);
4213
  fprintf (fp, "Options:\n");
4214
  fprintf (fp, "  -h,--help       Display this message.\n");
4215
  fprintf (fp, "  -p,--no-params  Don't display function parameters\n");
4216
  fprintf (fp, "  -v,--verbose    Produce verbose demanglings.\n");
4217
  fprintf (fp, "If names are provided, they are demangled.  Otherwise filters standard input.\n");
4218
 
4219
  exit (exit_value);
4220
}
4221
 
4222
/* Option specification for getopt_long.  */
4223
static const struct option long_options[] =
4224
{
4225
  { "help",      no_argument, NULL, 'h' },
4226
  { "no-params", no_argument, NULL, 'p' },
4227
  { "verbose",   no_argument, NULL, 'v' },
4228
  { NULL,        no_argument, NULL, 0   },
4229
};
4230
 
4231
/* Main entry for a demangling filter executable.  It will demangle
4232
   its command line arguments, if any.  If none are provided, it will
4233
   filter stdin to stdout, replacing any recognized mangled C++ names
4234
   with their demangled equivalents.  */
4235
 
4236
int
4237
main (int argc, char *argv[])
4238
{
4239
  int i;
4240
  int opt_char;
4241
  int options = DMGL_PARAMS | DMGL_ANSI | DMGL_TYPES;
4242
 
4243
  /* Use the program name of this program, as invoked.  */
4244
  program_name = argv[0];
4245
 
4246
  /* Parse options.  */
4247
  do
4248
    {
4249
      opt_char = getopt_long (argc, argv, "hpv", long_options, NULL);
4250
      switch (opt_char)
4251
        {
4252
        case '?':  /* Unrecognized option.  */
4253
          print_usage (stderr, 1);
4254
          break;
4255
 
4256
        case 'h':
4257
          print_usage (stdout, 0);
4258
          break;
4259
 
4260
        case 'p':
4261
          options &= ~ DMGL_PARAMS;
4262
          break;
4263
 
4264
        case 'v':
4265
          options |= DMGL_VERBOSE;
4266
          break;
4267
        }
4268
    }
4269
  while (opt_char != -1);
4270
 
4271
  if (optind == argc)
4272
    /* No command line arguments were provided.  Filter stdin.  */
4273
    {
4274
      dyn_string_t mangled = dyn_string_new (3);
4275
      char *s;
4276
 
4277
      /* Read all of input.  */
4278
      while (!feof (stdin))
4279
        {
4280
          char c;
4281
 
4282
          /* Pile characters into mangled until we hit one that can't
4283
             occur in a mangled name.  */
4284
          c = getchar ();
4285
          while (!feof (stdin) && is_mangled_char (c))
4286
            {
4287
              dyn_string_append_char (mangled, c);
4288
              if (feof (stdin))
4289
                break;
4290
              c = getchar ();
4291
            }
4292
 
4293
          if (dyn_string_length (mangled) > 0)
4294
            {
4295
#ifdef IN_GLIBCPP_V3
4296
              s = __cxa_demangle (dyn_string_buf (mangled), NULL, NULL, NULL);
4297
#else
4298
              s = cplus_demangle_v3 (dyn_string_buf (mangled), options);
4299
#endif
4300
 
4301
              if (s != NULL)
4302
                {
4303
                  fputs (s, stdout);
4304
                  free (s);
4305
                }
4306
              else
4307
                {
4308
                  /* It might not have been a mangled name.  Print the
4309
                     original text.  */
4310
                  fputs (dyn_string_buf (mangled), stdout);
4311
                }
4312
 
4313
              dyn_string_clear (mangled);
4314
            }
4315
 
4316
          /* If we haven't hit EOF yet, we've read one character that
4317
             can't occur in a mangled name, so print it out.  */
4318
          if (!feof (stdin))
4319
            putchar (c);
4320
        }
4321
 
4322
      dyn_string_delete (mangled);
4323
    }
4324
  else
4325
    /* Demangle command line arguments.  */
4326
    {
4327
      /* Loop over command line arguments.  */
4328
      for (i = optind; i < argc; ++i)
4329
        {
4330
          char *s;
4331
#ifdef IN_GLIBCPP_V3
4332
          int status;
4333
#endif
4334
 
4335
          /* Attempt to demangle.  */
4336
#ifdef IN_GLIBCPP_V3
4337
          s = __cxa_demangle (argv[i], NULL, NULL, &status);
4338
#else
4339
          s = cplus_demangle_v3 (argv[i], options);
4340
#endif
4341
 
4342
          /* If it worked, print the demangled name.  */
4343
          if (s != NULL)
4344
            {
4345
              printf ("%s\n", s);
4346
              free (s);
4347
            }
4348
          else
4349
            {
4350
#ifdef IN_GLIBCPP_V3
4351
              fprintf (stderr, "Failed: %s (status %d)\n", argv[i], status);
4352
#else
4353
              fprintf (stderr, "Failed: %s\n", argv[i]);
4354
#endif
4355
            }
4356
        }
4357
    }
4358
 
4359
  return 0;
4360
}
4361
 
4362
#endif /* STANDALONE_DEMANGLER */

powered by: WebSVN 2.1.0

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