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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [libiberty/] [cp-demangle.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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