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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [libiberty/] [cp-demangle.c] - Blame information for rev 816

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

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

powered by: WebSVN 2.1.0

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