source: rtems-tools/rtemstoolkit/libiberty/cp-demangle.c @ 87e0e76

4.104.11
Last change on this file since 87e0e76 was 87e0e76, checked in by Chris Johns <chrisj@…>, on Sep 13, 2014 at 2:09:16 AM

Refactor code into the RTEMS Toolkit.

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