#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "ansidecl.h"
#include "libiberty.h"
#include "demangle.h"
#include "cp-demangle.h"

Classes
struct	d_standard_sub_info

struct	d_print_template

struct	d_print_mod

struct	d_growable_string

struct	d_component_stack

struct	d_saved_scope

struct	d_info_checkpoint

struct	d_print_info

Macros
#define	INT_MAX (int)(((unsigned int)~0) >> 1) /* 0x7FFFFFFF */

#define	CP_STATIC_IF_GLIBCPP_V3

#define	IS_DIGIT(c) ((c) >= '0' && (c) <= '9')

#define	IS_UPPER(c) ((c) >= 'A' && (c) <= 'Z')

#define	IS_LOWER(c) ((c) >= 'a' && (c) <= 'z')

#define	ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"

#define	ANONYMOUS_NAMESPACE_PREFIX_LEN (sizeof(ANONYMOUS_NAMESPACE_PREFIX) - 1)

#define	d_left(dc) ((dc)->u.s_binary.left)

#define	d_right(dc) ((dc)->u.s_binary.right)

#define	MAX_RECURSION_COUNT 1024

#define	FNQUAL_COMPONENT_CASE

#define	NL(s) s, (sizeof s) - 1

Enumerations
enum	{ D_PRINT_BUFFER_LENGTH = 256 }

Functions
char *	alloca ()

static struct demangle_component *	d_make_empty (struct d_info *)

static struct demangle_component *	d_make_comp (struct d_info , enum demangle_component_type, struct demangle_component , struct demangle_component *)

static struct demangle_component *	d_make_name (struct d_info , const char , int)

static struct demangle_component *	d_make_demangle_mangled_name (struct d_info , const char )

static struct demangle_component *	d_make_builtin_type (struct d_info , const struct demangle_builtin_type_info )

static struct demangle_component *	d_make_operator (struct d_info , const struct demangle_operator_info )

static struct demangle_component *	d_make_extended_operator (struct d_info , int, struct demangle_component )

static struct demangle_component *	d_make_ctor (struct d_info , enum gnu_v3_ctor_kinds, struct demangle_component )

static struct demangle_component *	d_make_dtor (struct d_info , enum gnu_v3_dtor_kinds, struct demangle_component )

static struct demangle_component *	d_make_template_param (struct d_info *, int)

static struct demangle_component *	d_make_sub (struct d_info , const char , int)

static int	has_return_type (struct demangle_component *)

static int	is_ctor_dtor_or_conversion (struct demangle_component *)

static struct demangle_component *	d_encoding (struct d_info *, int)

static struct demangle_component *	d_name (struct d_info *)

static struct demangle_component *	d_nested_name (struct d_info *)

static struct demangle_component *	d_prefix (struct d_info *)

static struct demangle_component *	d_unqualified_name (struct d_info *)

static struct demangle_component *	d_source_name (struct d_info *)

static int	d_number (struct d_info *)

static struct demangle_component *	d_identifier (struct d_info *, int)

static struct demangle_component *	d_operator_name (struct d_info *)

static struct demangle_component *	d_special_name (struct d_info *)

static struct demangle_component *	d_parmlist (struct d_info *)

static int	d_call_offset (struct d_info *, int)

static struct demangle_component *	d_ctor_dtor_name (struct d_info *)

static struct demangle_component **	d_cv_qualifiers (struct d_info , struct demangle_component *, int)

static struct demangle_component *	d_ref_qualifier (struct d_info , struct demangle_component )

static struct demangle_component *	d_function_type (struct d_info *)

static struct demangle_component *	d_bare_function_type (struct d_info *, int)

static struct demangle_component *	d_class_enum_type (struct d_info *)

static struct demangle_component *	d_array_type (struct d_info *)

static struct demangle_component *	d_vector_type (struct d_info *)

static struct demangle_component *	d_pointer_to_member_type (struct d_info *)

static struct demangle_component *	d_template_param (struct d_info *)

static struct demangle_component *	d_template_args (struct d_info *)

static struct demangle_component *	d_template_args_1 (struct d_info *)

static struct demangle_component *	d_template_arg (struct d_info *)

static struct demangle_component *	d_expression (struct d_info *)

static struct demangle_component *	d_expr_primary (struct d_info *)

static struct demangle_component *	d_local_name (struct d_info *)

static int	d_discriminator (struct d_info *)

static struct demangle_component *	d_lambda (struct d_info *)

static struct demangle_component *	d_unnamed_type (struct d_info *)

static struct demangle_component *	d_clone_suffix (struct d_info , struct demangle_component )

static int	d_add_substitution (struct d_info , struct demangle_component )

static struct demangle_component *	d_substitution (struct d_info *, int)

static void	d_checkpoint (struct d_info , struct d_info_checkpoint )

static void	d_backtrack (struct d_info , struct d_info_checkpoint )

static void	d_growable_string_init (struct d_growable_string *, size_t)

static void	d_growable_string_resize (struct d_growable_string *, size_t)

static void	d_growable_string_append_buffer (struct d_growable_string , const char , size_t)

static void	d_growable_string_callback_adapter (const char , size_t, void )

static void	d_print_init (struct d_print_info , demangle_callbackref, void , const struct demangle_component *)

static void	d_print_error (struct d_print_info *)

static int	d_print_saw_error (struct d_print_info *)

static void	d_print_flush (struct d_print_info *)

static void	d_append_char (struct d_print_info *, char)

static void	d_append_buffer (struct d_print_info , const char , size_t)

static void	d_append_string (struct d_print_info , const char )

static char	d_last_char (struct d_print_info *)

static void	d_print_comp (struct d_print_info , int, struct demangle_component )

static void	d_print_java_identifier (struct d_print_info , const char , int)

static void	d_print_mod_list (struct d_print_info , int, struct d_print_mod , int)

static void	d_print_mod (struct d_print_info , int, struct demangle_component )

static void	d_print_function_type (struct d_print_info , int, struct demangle_component , struct d_print_mod *)

static void	d_print_array_type (struct d_print_info , int, struct demangle_component , struct d_print_mod *)

static void	d_print_expr_op (struct d_print_info , int, struct demangle_component )

static void	d_print_cast (struct d_print_info , int, struct demangle_component )

static void	d_print_conversion (struct d_print_info , int, struct demangle_component )

static int	d_demangle_callback (const char , int, demangle_callbackref, void )

static char *	d_demangle (const char , int, size_t )

static int	is_fnqual_component_type (enum demangle_component_type type)

CP_STATIC_IF_GLIBCPP_V3 int	cplus_demangle_fill_name (struct demangle_component p, const char s, int len)

CP_STATIC_IF_GLIBCPP_V3 int	cplus_demangle_fill_extended_operator (struct demangle_component p, int args, struct demangle_component name)

CP_STATIC_IF_GLIBCPP_V3 int	cplus_demangle_fill_ctor (struct demangle_component p, enum gnu_v3_ctor_kinds kind, struct demangle_component name)

CP_STATIC_IF_GLIBCPP_V3 int	cplus_demangle_fill_dtor (struct demangle_component p, enum gnu_v3_dtor_kinds kind, struct demangle_component name)

static struct demangle_component *	d_make_default_arg (struct d_info di, int num, struct demangle_component sub)

static struct demangle_component *	d_make_function_param (struct d_info *di, int i)

CP_STATIC_IF_GLIBCPP_V3 struct demangle_component *	cplus_demangle_mangled_name (struct d_info *di, int top_level)

static struct demangle_component *	d_abi_tags (struct d_info di, struct demangle_component dc)

static struct demangle_component *	d_number_component (struct d_info *di)

static struct demangle_component *	d_make_character (struct d_info *di, int c)

static struct demangle_component *	d_java_resource (struct d_info *di)

static int	next_is_type_qual (struct d_info *di)

CP_STATIC_IF_GLIBCPP_V3 struct demangle_component *	cplus_demangle_type (struct d_info *di)

static int	d_compact_number (struct d_info *di)

static struct demangle_component *	d_exprlist (struct d_info *di, char terminator)

static int	op_is_new_cast (struct demangle_component *op)

static struct demangle_component *	d_expression_1 (struct d_info *di)

static void	d_count_templates_scopes (int num_templates, int num_scopes, const struct demangle_component *dc)

static void	d_append_num (struct d_print_info *dpi, int l)

CP_STATIC_IF_GLIBCPP_V3 int	cplus_demangle_print_callback (int options, struct demangle_component dc, demangle_callbackref callback, void opaque)

CP_STATIC_IF_GLIBCPP_V3 char *	cplus_demangle_print (int options, struct demangle_component dc, int estimate, size_t palc)

static struct demangle_component *	d_index_template_argument (struct demangle_component *args, int i)

static struct demangle_component *	d_lookup_template_argument (struct d_print_info dpi, const struct demangle_component dc)

static struct demangle_component *	d_find_pack (struct d_print_info dpi, const struct demangle_component dc)

static int	d_pack_length (const struct demangle_component *dc)

static int	d_args_length (struct d_print_info dpi, const struct demangle_component dc)

static void	d_print_subexpr (struct d_print_info dpi, int options, struct demangle_component dc)

static void	d_save_scope (struct d_print_info dpi, const struct demangle_component container)

static struct d_saved_scope *	d_get_saved_scope (struct d_print_info dpi, const struct demangle_component container)

static int	d_maybe_print_fold_expression (struct d_print_info dpi, int options, struct demangle_component dc)

static void	d_print_comp_inner (struct d_print_info dpi, int options, struct demangle_component dc)

CP_STATIC_IF_GLIBCPP_V3 void	cplus_demangle_init_info (const char mangled, int options, size_t len, struct d_info di)

char *	cplus_demangle_v3 (const char *mangled, int options)

int	cplus_demangle_v3_callback (const char mangled, int options, demangle_callbackref callback, void opaque)

char *	java_demangle_v3 (const char *mangled)

int	java_demangle_v3_callback (const char mangled, demangle_callbackref callback, void opaque)

static int	is_ctor_or_dtor (const char mangled, enum gnu_v3_ctor_kinds ctor_kind, enum gnu_v3_dtor_kinds *dtor_kind)

enum gnu_v3_ctor_kinds	is_gnu_v3_mangled_ctor (const char *name)

enum gnu_v3_dtor_kinds	is_gnu_v3_mangled_dtor (const char *name)

Variables
CP_STATIC_IF_GLIBCPP_V3 const struct demangle_operator_info	cplus_demangle_operators []

CP_STATIC_IF_GLIBCPP_V3 const struct demangle_builtin_type_info	cplus_demangle_builtin_types [D_BUILTIN_TYPE_COUNT]

static const struct d_standard_sub_info	standard_subs []

Macro Definition Documentation

◆ ANONYMOUS_NAMESPACE_PREFIX

#define ANONYMOUS_NAMESPACE_PREFIX "_GLOBAL_"

Definition at line 214 of file cp-demangle.c.

◆ ANONYMOUS_NAMESPACE_PREFIX_LEN

#define ANONYMOUS_NAMESPACE_PREFIX_LEN (sizeof(ANONYMOUS_NAMESPACE_PREFIX) - 1)

Definition at line 215 of file cp-demangle.c.

◆ CP_STATIC_IF_GLIBCPP_V3

#define CP_STATIC_IF_GLIBCPP_V3

Definition at line 182 of file cp-demangle.c.

◆ d_left

#define d_left ( dc ) ((dc)->u.s_binary.left)

Definition at line 242 of file cp-demangle.c.

◆ d_right

#define d_right ( dc ) ((dc)->u.s_binary.right)

Definition at line 243 of file cp-demangle.c.

◆ FNQUAL_COMPONENT_CASE

#define FNQUAL_COMPONENT_CASE

Value:

    case DEMANGLE_COMPONENT_RESTRICT_THIS: \
    case DEMANGLE_COMPONENT_VOLATILE_THIS: \
    case DEMANGLE_COMPONENT_CONST_THIS: \
    case DEMANGLE_COMPONENT_REFERENCE_THIS: \
    case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS: \
    case DEMANGLE_COMPONENT_TRANSACTION_SAFE: \
    case DEMANGLE_COMPONENT_NOEXCEPT: \
    case DEMANGLE_COMPONENT_THROW_SPEC

Definition at line 560 of file cp-demangle.c.

◆ INT_MAX

#define INT_MAX (int)(((unsigned int)~0) >> 1) /* 0x7FFFFFFF */

Definition at line 131 of file cp-demangle.c.

◆ IS_DIGIT

#define IS_DIGIT ( c ) ((c) >= '0' && (c) <= '9')

Definition at line 208 of file cp-demangle.c.

◆ IS_LOWER

#define IS_LOWER ( c ) ((c) >= 'a' && (c) <= 'z')

Definition at line 210 of file cp-demangle.c.

◆ IS_UPPER

#define IS_UPPER ( c ) ((c) >= 'A' && (c) <= 'Z')

Definition at line 209 of file cp-demangle.c.

◆ MAX_RECURSION_COUNT

#define MAX_RECURSION_COUNT 1024

Definition at line 313 of file cp-demangle.c.

◆ NL

#define NL ( s ) s, (sizeof s) - 1

Definition at line 1663 of file cp-demangle.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
D_PRINT_BUFFER_LENGTH

Definition at line 315 of file cp-demangle.c.

315 { D_PRINT_BUFFER_LENGTH = 256 };

D_PRINT_BUFFER_LENGTH

@ D_PRINT_BUFFER_LENGTH

Definition: cp-demangle.c:315

Function Documentation

◆ alloca()

char* alloca ( )

Referenced by cplus_demangle_print_callback(), d_demangle_callback(), env_strncmp(), is_ctor_or_dtor(), and make_program_env().

◆ cplus_demangle_fill_ctor()

CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_ctor	(	struct demangle_component *	p,
		enum gnu_v3_ctor_kinds	kind,
		struct demangle_component *	name
	)

Definition at line 871 of file cp-demangle.c.

                                      {
     if (p == NULL || name == NULL || (int)kind < gnu_v3_complete_object_ctor || (int)kind > gnu_v3_object_ctor_group)
         return 0;
     p->d_printing = 0;
     p->type = DEMANGLE_COMPONENT_CTOR;
     p->u.s_ctor.kind = kind;
     p->u.s_ctor.name = name;
     return 1;
 }

References DEMANGLE_COMPONENT_CTOR, gnu_v3_complete_object_ctor, gnu_v3_object_ctor_group, demangle_component::kind, name, NULL, and p.

Referenced by d_make_ctor().

◆ cplus_demangle_fill_dtor()

CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_dtor	(	struct demangle_component *	p,
		enum gnu_v3_dtor_kinds	kind,
		struct demangle_component *	name
	)

Definition at line 886 of file cp-demangle.c.

                                      {
     if (p == NULL || name == NULL || (int)kind < gnu_v3_deleting_dtor || (int)kind > gnu_v3_object_dtor_group)
         return 0;
     p->d_printing = 0;
     p->type = DEMANGLE_COMPONENT_DTOR;
     p->u.s_dtor.kind = kind;
     p->u.s_dtor.name = name;
     return 1;
 }

References DEMANGLE_COMPONENT_DTOR, gnu_v3_deleting_dtor, gnu_v3_object_dtor_group, demangle_component::kind, name, NULL, and p.

Referenced by d_make_dtor().

◆ cplus_demangle_fill_extended_operator()

CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_extended_operator	(	struct demangle_component *	p,
		int	args,
		struct demangle_component *	name
	)

Definition at line 857 of file cp-demangle.c.

                                      {
     if (p == NULL || args < 0 || name == NULL)
         return 0;
     p->d_printing = 0;
     p->type = DEMANGLE_COMPONENT_EXTENDED_OPERATOR;
     p->u.s_extended_operator.args = args;
     p->u.s_extended_operator.name = name;
     return 1;
 }

References args, DEMANGLE_COMPONENT_EXTENDED_OPERATOR, name, NULL, and p.

Referenced by d_make_extended_operator().

◆ cplus_demangle_fill_name()

CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_fill_name	(	struct demangle_component *	p,
		const char *	s,
		int	len
	)

Definition at line 844 of file cp-demangle.c.

                                                                                    {
     if (p == NULL || s == NULL || len == 0)
         return 0;
     p->d_printing = 0;
     p->type = DEMANGLE_COMPONENT_NAME;
     p->u.s_name.s = s;
     p->u.s_name.len = len;
     return 1;
 }

References DEMANGLE_COMPONENT_NAME, len, NULL, p, and s.

Referenced by d_make_name().

◆ cplus_demangle_init_info()

CP_STATIC_IF_GLIBCPP_V3 void cplus_demangle_init_info	(	const char *	mangled,
		int	options,
		size_t	len,
		struct d_info *	di
	)

Definition at line 5681 of file cp-demangle.c.

                        {
     di->s = mangled;
     di->send = mangled + len;
     di->options = options;
  
     di->n = mangled;
  
     /* We can not need more components than twice the number of chars in
      the mangled string.  Most components correspond directly to
      chars, but the ARGLIST types are exceptions.  */
     di->num_comps = 2 * len;
     di->next_comp = 0;
  
     /* Similarly, we can not need more substitutions than there are
      chars in the mangled string.  */
     di->num_subs = len;
     di->next_sub = 0;
  
     di->last_name = NULL;
  
     di->expansion = 0;
     di->is_expression = 0;
     di->is_conversion = 0;
 }

References d_info::expansion, d_info::is_conversion, d_info::is_expression, d_info::last_name, len, d_info::n, d_info::next_comp, d_info::next_sub, NULL, d_info::num_comps, d_info::num_subs, options, d_info::options, d_info::s, and d_info::send.

Referenced by d_demangle_callback(), and is_ctor_or_dtor().

◆ cplus_demangle_mangled_name()

CP_STATIC_IF_GLIBCPP_V3 struct demangle_component* cplus_demangle_mangled_name	(	struct d_info *	di,
		int	top_level
	)

Definition at line 1170 of file cp-demangle.c.

                                                               {
     struct demangle_component *p;
  
     if (!d_check_char(di, '_')
         /* Allow missing _ if not at toplevel to work around a
      bug in G++ abi-version=2 mangling; see the comment in
      write_template_arg.  */
         && top_level)
         return NULL;
     if (!d_check_char(di, 'Z'))
         return NULL;
     p = d_encoding(di, top_level);
  
     /* If at top level and parsing parameters, check for a clone
      suffix.  */
     if (top_level && (di->options & DMGL_PARAMS) != 0)
         while (d_peek_char(di) == '.' && (IS_LOWER(d_peek_next_char(di)) || d_peek_next_char(di) == '_' || IS_DIGIT(d_peek_next_char(di))))
             p = d_clone_suffix(di, p);
  
     return p;
 }

References d_check_char, d_clone_suffix(), d_encoding(), d_peek_char, d_peek_next_char, DMGL_PARAMS, IS_DIGIT, IS_LOWER, NULL, d_info::options, and p.

Referenced by d_demangle_callback(), d_expr_primary(), and is_ctor_or_dtor().

◆ cplus_demangle_print()

CP_STATIC_IF_GLIBCPP_V3 char* cplus_demangle_print	(	int	options,
		struct demangle_component *	dc,
		int	estimate,
		size_t *	palc
	)

Definition at line 4010 of file cp-demangle.c.

                                 {
     struct d_growable_string dgs;
  
     d_growable_string_init(&dgs, estimate);
  
     if (!cplus_demangle_print_callback(options, dc,
             d_growable_string_callback_adapter,
             &dgs)) {
         free(dgs.buf);
         *palc = 0;
         return NULL;
     }
  
     *palc = dgs.allocation_failure ? 1 : dgs.alc;
     return dgs.buf;
 }

References d_growable_string::alc, d_growable_string::allocation_failure, d_growable_string::buf, cplus_demangle_print_callback(), d_growable_string_callback_adapter(), d_growable_string_init(), free(), NULL, and options.

◆ cplus_demangle_print_callback()

CP_STATIC_IF_GLIBCPP_V3 int cplus_demangle_print_callback	(	int	options,
		struct demangle_component *	dc,
		demangle_callbackref	callback,
		void *	opaque
	)

Definition at line 3967 of file cp-demangle.c.

                                                  {
     struct d_print_info dpi;
  
     d_print_init(&dpi, callback, opaque, dc);
  
     {
 #ifdef CP_DYNAMIC_ARRAYS
         /* Avoid zero-length VLAs, which are prohibited by the C99 standard
        and flagged as errors by Address Sanitizer.  */
         __extension__ struct d_saved_scope scopes[(dpi.num_saved_scopes > 0)
                 ? dpi.num_saved_scopes
                 : 1];
         __extension__ struct d_print_template temps[(dpi.num_copy_templates > 0)
                 ? dpi.num_copy_templates
                 : 1];
  
         dpi.saved_scopes = scopes;
         dpi.copy_templates = temps;
 #else
         dpi.saved_scopes = alloca(dpi.num_saved_scopes * sizeof(*dpi.saved_scopes));
         dpi.copy_templates = alloca(dpi.num_copy_templates * sizeof(*dpi.copy_templates));
 #endif
  
         d_print_comp(&dpi, options, dc);
     }
  
     d_print_flush(&dpi);
  
     return !d_print_saw_error(&dpi);
 }

References __extension__, alloca(), d_print_info::callback, CP_STATIC_IF_GLIBCPP_V3, d_print_comp(), d_print_flush(), d_print_init(), d_print_saw_error(), and d_print_info::opaque.

Referenced by cplus_demangle_print(), and d_demangle_callback().

◆ cplus_demangle_type()

CP_STATIC_IF_GLIBCPP_V3 struct demangle_component* cplus_demangle_type ( struct d_info * di )

Definition at line 2212 of file cp-demangle.c.

                                        {
     char peek;
     struct demangle_component *ret;
     int can_subst;
  
     /* The ABI specifies that when CV-qualifiers are used, the base type
      is substitutable, and the fully qualified type is substitutable,
      but the base type with a strict subset of the CV-qualifiers is
      not substitutable.  The natural recursive implementation of the
      CV-qualifiers would cause subsets to be substitutable, so instead
      we pull them all off now.
  
      FIXME: The ABI says that order-insensitive vendor qualifiers
      should be handled in the same way, but we have no way to tell
      which vendor qualifiers are order-insensitive and which are
      order-sensitive.  So we just assume that they are all
      order-sensitive.  g++ 3.4 supports only one vendor qualifier,
      __vector, and it treats it as order-sensitive when mangling
      names.  */
  
     if (next_is_type_qual(di)) {
         struct demangle_component **pret;
  
         pret = d_cv_qualifiers(di, &ret, 0);
         if (pret == NULL)
             return NULL;
         if (d_peek_char(di) == 'F') {
             /* cv-qualifiers before a function type apply to 'this',
          so avoid adding the unqualified function type to
          the substitution list.  */
             *pret = d_function_type(di);
         } else
             *pret = cplus_demangle_type(di);
         if (!*pret)
             return NULL;
         if ((*pret)->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS || (*pret)->type == DEMANGLE_COMPONENT_REFERENCE_THIS) {
             /* Move the ref-qualifier outside the cv-qualifiers so that
          they are printed in the right order.  */
             struct demangle_component *fn = d_left(*pret);
             d_left(*pret) = ret;
             ret = *pret;
             *pret = fn;
         }
         if (!d_add_substitution(di, ret))
             return NULL;
         return ret;
     }
  
     can_subst = 1;
  
     peek = d_peek_char(di);
     switch (peek) {
     case 'a':
     case 'b':
     case 'c':
     case 'd':
     case 'e':
     case 'f':
     case 'g':
     case 'h':
     case 'i':
     case 'j':
     case 'l':
     case 'm':
     case 'n':
     case 'o':
     case 's':
     case 't':
     case 'v':
     case 'w':
     case 'x':
     case 'y':
     case 'z':
         ret = d_make_builtin_type(di,
             &cplus_demangle_builtin_types[peek - 'a']);
         di->expansion += ret->u.s_builtin.type->len;
         can_subst = 0;
         d_advance(di, 1);
         break;
  
     case 'u':
         d_advance(di, 1);
         ret = d_make_comp(di, DEMANGLE_COMPONENT_VENDOR_TYPE,
             d_source_name(di), NULL);
         break;
  
     case 'F':
         ret = d_function_type(di);
         break;
  
     case '0':
     case '1':
     case '2':
     case '3':
     case '4':
     case '5':
     case '6':
     case '7':
     case '8':
     case '9':
     case 'N':
     case 'Z':
         ret = d_class_enum_type(di);
         break;
  
     case 'A':
         ret = d_array_type(di);
         break;
  
     case 'M':
         ret = d_pointer_to_member_type(di);
         break;
  
     case 'T':
         ret = d_template_param(di);
         if (d_peek_char(di) == 'I') {
             /* This may be <template-template-param> <template-args>.
          If this is the type for a conversion operator, we can
          have a <template-template-param> here only by following
          a derivation like this:
  
          <nested-name>
          -> <template-prefix> <template-args>
          -> <prefix> <template-unqualified-name> <template-args>
          -> <unqualified-name> <template-unqualified-name> <template-args>
          -> <source-name> <template-unqualified-name> <template-args>
          -> <source-name> <operator-name> <template-args>
          -> <source-name> cv <type> <template-args>
          -> <source-name> cv <template-template-param> <template-args> <template-args>
  
          where the <template-args> is followed by another.
          Otherwise, we must have a derivation like this:
  
          <nested-name>
          -> <template-prefix> <template-args>
          -> <prefix> <template-unqualified-name> <template-args>
          -> <unqualified-name> <template-unqualified-name> <template-args>
          -> <source-name> <template-unqualified-name> <template-args>
          -> <source-name> <operator-name> <template-args>
          -> <source-name> cv <type> <template-args>
          -> <source-name> cv <template-param> <template-args>
  
          where we need to leave the <template-args> to be processed
          by d_prefix (following the <template-prefix>).
  
          The <template-template-param> part is a substitution
          candidate.  */
             if (!di->is_conversion) {
                 if (!d_add_substitution(di, ret))
                     return NULL;
                 ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                     d_template_args(di));
             } else {
                 struct demangle_component *args;
                 struct d_info_checkpoint checkpoint;
  
                 d_checkpoint(di, &checkpoint);
                 args = d_template_args(di);
                 if (d_peek_char(di) == 'I') {
                     if (!d_add_substitution(di, ret))
                         return NULL;
                     ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                         args);
                 } else
                     d_backtrack(di, &checkpoint);
             }
         }
         break;
  
     case 'S':
         /* If this is a special substitution, then it is the start of
      <class-enum-type>.  */
         {
             char peek_next;
  
             peek_next = d_peek_next_char(di);
             if (IS_DIGIT(peek_next) || peek_next == '_' || IS_UPPER(peek_next)) {
                 ret = d_substitution(di, 0);
                 /* The substituted name may have been a template name and
            may be followed by tepmlate args.  */
                 if (d_peek_char(di) == 'I')
                     ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                         d_template_args(di));
                 else
                     can_subst = 0;
             } else {
                 ret = d_class_enum_type(di);
                 /* If the substitution was a complete type, then it is not
            a new substitution candidate.  However, if the
            substitution was followed by template arguments, then
            the whole thing is a substitution candidate.  */
                 if (ret != NULL && ret->type == DEMANGLE_COMPONENT_SUB_STD)
                     can_subst = 0;
             }
         }
         break;
  
     case 'O':
         d_advance(di, 1);
         ret = d_make_comp(di, DEMANGLE_COMPONENT_RVALUE_REFERENCE,
             cplus_demangle_type(di), NULL);
         break;
  
     case 'P':
         d_advance(di, 1);
         ret = d_make_comp(di, DEMANGLE_COMPONENT_POINTER,
             cplus_demangle_type(di), NULL);
         break;
  
     case 'R':
         d_advance(di, 1);
         ret = d_make_comp(di, DEMANGLE_COMPONENT_REFERENCE,
             cplus_demangle_type(di), NULL);
         break;
  
     case 'C':
         d_advance(di, 1);
         ret = d_make_comp(di, DEMANGLE_COMPONENT_COMPLEX,
             cplus_demangle_type(di), NULL);
         break;
  
     case 'G':
         d_advance(di, 1);
         ret = d_make_comp(di, DEMANGLE_COMPONENT_IMAGINARY,
             cplus_demangle_type(di), NULL);
         break;
  
     case 'U':
         d_advance(di, 1);
         ret = d_source_name(di);
         if (d_peek_char(di) == 'I')
             ret = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, ret,
                 d_template_args(di));
         ret = d_make_comp(di, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL,
             cplus_demangle_type(di), ret);
         break;
  
     case 'D':
         can_subst = 0;
         d_advance(di, 1);
         peek = d_next_char(di);
         switch (peek) {
         case 'T':
         case 't':
             /* decltype (expression) */
             ret = d_make_comp(di, DEMANGLE_COMPONENT_DECLTYPE,
                 d_expression(di), NULL);
             if (ret && d_next_char(di) != 'E')
                 ret = NULL;
             can_subst = 1;
             break;
  
         case 'p':
             /* Pack expansion.  */
             ret = d_make_comp(di, DEMANGLE_COMPONENT_PACK_EXPANSION,
                 cplus_demangle_type(di), NULL);
             can_subst = 1;
             break;
  
         case 'a':
             /* auto */
             ret = d_make_name(di, "auto", 4);
             break;
         case 'c':
             /* decltype(auto) */
             ret = d_make_name(di, "decltype(auto)", 14);
             break;
  
         case 'f':
             /* 32-bit decimal floating point */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[26]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
         case 'd':
             /* 64-bit DFP */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[27]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
         case 'e':
             /* 128-bit DFP */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[28]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
         case 'h':
             /* 16-bit half-precision FP */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[29]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
         case 's':
             /* char16_t */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[30]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
         case 'i':
             /* char32_t */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[31]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
  
         case 'F':
             /* Fixed point types. DF<int bits><length><fract bits><sat>  */
             ret = d_make_empty(di);
             ret->type = DEMANGLE_COMPONENT_FIXED_TYPE;
             if ((ret->u.s_fixed.accum = IS_DIGIT(d_peek_char(di))))
                 /* For demangling we don't care about the bits.  */
                 d_number(di);
             ret->u.s_fixed.length = cplus_demangle_type(di);
             if (ret->u.s_fixed.length == NULL)
                 return NULL;
             d_number(di);
             peek = d_next_char(di);
             ret->u.s_fixed.sat = (peek == 's');
             break;
  
         case 'v':
             ret = d_vector_type(di);
             can_subst = 1;
             break;
  
         case 'n':
             /* decltype(nullptr) */
             ret = d_make_builtin_type(di, &cplus_demangle_builtin_types[32]);
             di->expansion += ret->u.s_builtin.type->len;
             break;
  
         default:
             return NULL;
         }
         break;
  
     default:
         return NULL;
     }
  
     if (can_subst) {
         if (!d_add_substitution(di, ret))
             return NULL;
     }
  
     return ret;
 }

Referenced by d_array_type(), d_bare_function_type(), d_ctor_dtor_name(), d_demangle_callback(), d_expr_primary(), d_expression_1(), d_operator_name(), d_parmlist(), d_pointer_to_member_type(), d_prefix(), d_special_name(), d_template_arg(), and d_vector_type().

◆ cplus_demangle_v3()

char* cplus_demangle_v3	(	const char *	mangled,
		int	options
	)

Definition at line 5942 of file cp-demangle.c.

                                                     {
     size_t alc;
  
     return d_demangle(mangled, options, &alc);
 }

References d_growable_string::alc, d_demangle(), and options.

◆ cplus_demangle_v3_callback()

int cplus_demangle_v3_callback	(	const char *	mangled,
		int	options,
		demangle_callbackref	callback,
		void *	opaque
	)

Definition at line 5948 of file cp-demangle.c.

                                                  {
     return d_demangle_callback(mangled, options, callback, opaque);
 }

References d_demangle_callback(), and options.

◆ d_abi_tags()

static struct demangle_component* d_abi_tags	(	struct d_info *	di,
		struct demangle_component *	dc
	)

static

Definition at line 1300 of file cp-demangle.c.

                                                              {
     struct demangle_component *hold_last_name;
     char peek;
  
     /* Preserve the last name, so the ABI tag doesn't clobber it.  */
     hold_last_name = di->last_name;
  
     while (peek = d_peek_char(di),
         peek == 'B') {
         struct demangle_component *tag;
         d_advance(di, 1);
         tag = d_source_name(di);
         dc = d_make_comp(di, DEMANGLE_COMPONENT_TAGGED_NAME, dc, tag);
     }
  
     di->last_name = hold_last_name;
  
     return dc;
 }

References d_advance, d_make_comp(), d_peek_char, d_source_name(), DEMANGLE_COMPONENT_TAGGED_NAME, d_info::last_name, and test-lz4-versions::tag.

Referenced by d_substitution(), and d_unqualified_name().

◆ d_add_substitution()

static int d_add_substitution	(	struct d_info *	di,
		struct demangle_component *	dc
	)

static

Definition at line 3503 of file cp-demangle.c.

                                                                      {
     if (dc == NULL)
         return 0;
     if (di->next_sub >= di->num_subs)
         return 0;
     di->subs[di->next_sub] = dc;
     ++di->next_sub;
     return 1;
 }

References d_info::next_sub, NULL, d_info::num_subs, and d_info::subs.

Referenced by cplus_demangle_type(), d_lambda(), d_name(), d_prefix(), d_substitution(), and d_unnamed_type().

◆ d_append_buffer()

static void d_append_buffer	(	struct d_print_info *	dpi,
		const char *	s,
		size_t	l
	)

inlinestatic

Definition at line 3933 of file cp-demangle.c.

                                                                    {
     size_t i;
  
     for (i = 0; i < l; i++)
         d_append_char(dpi, s[i]);
 }

References d_append_char(), i, and s.

Referenced by d_append_string(), d_print_comp_inner(), and d_print_expr_op().

◆ d_append_char()

static void d_append_char	(	struct d_print_info *	dpi,
		char	c
	)

inlinestatic

Definition at line 3924 of file cp-demangle.c.

                                                 {
     if (dpi->len == sizeof(dpi->buf) - 1)
         d_print_flush(dpi);
  
     dpi->buf[dpi->len++] = c;
     dpi->last_char = c;
 }

References d_print_info::buf, c, d_print_flush(), d_print_info::last_char, and d_print_info::len.

Referenced by d_append_buffer(), d_maybe_print_fold_expression(), d_print_array_type(), d_print_comp_inner(), d_print_conversion(), d_print_function_type(), d_print_java_identifier(), d_print_mod(), d_print_mod_list(), and d_print_subexpr().

◆ d_append_num()

static void d_append_num	(	struct d_print_info *	dpi,
		int	l
	)

inlinestatic

Definition at line 3946 of file cp-demangle.c.

                                               {
     char buf[25];
     sprintf(buf, "%d", l);
     d_append_string(dpi, buf);
 }

References d_append_string(), and sprintf.

Referenced by d_print_comp_inner(), and d_print_mod_list().

◆ d_append_string()

static void d_append_string	(	struct d_print_info *	dpi,
		const char *	s
	)

inlinestatic

Definition at line 3941 of file cp-demangle.c.

                                                          {
     d_append_buffer(dpi, s, strlen(s));
 }

References d_append_buffer(), and s.

Referenced by d_append_num(), d_maybe_print_fold_expression(), d_print_array_type(), d_print_comp_inner(), d_print_mod(), and d_print_mod_list().

◆ d_args_length()

static int d_args_length	(	struct d_print_info *	dpi,
		const struct demangle_component *	dc
	)

static

Definition at line 4133 of file cp-demangle.c.

                                                                              {
     int count = 0;
     for (; dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST;
         dc = d_right(dc)) {
         struct demangle_component *elt = d_left(dc);
         if (elt == NULL)
             break;
         if (elt->type == DEMANGLE_COMPONENT_PACK_EXPANSION) {
             struct demangle_component *a = d_find_pack(dpi, d_left(elt));
             count += d_pack_length(a);
         } else
             ++count;
     }
     return count;
 }

References a, count, d_find_pack(), d_left, d_pack_length(), d_right, DEMANGLE_COMPONENT_PACK_EXPANSION, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, and demangle_component::type.

Referenced by d_print_comp_inner().

◆ d_array_type()

static struct demangle_component * d_array_type ( struct d_info * di )

static

Definition at line 2773 of file cp-demangle.c.

                                 {
     char peek;
     struct demangle_component *dim;
  
     if (!d_check_char(di, 'A'))
         return NULL;
  
     peek = d_peek_char(di);
     if (peek == '_')
         dim = NULL;
     else if (IS_DIGIT(peek)) {
         const char *s;
  
         s = d_str(di);
         do {
             d_advance(di, 1);
             peek = d_peek_char(di);
         } while (IS_DIGIT(peek));
         dim = d_make_name(di, s, d_str(di) - s);
         if (dim == NULL)
             return NULL;
     } else {
         dim = d_expression(di);
         if (dim == NULL)
             return NULL;
     }
  
     if (!d_check_char(di, '_'))
         return NULL;
  
     return d_make_comp(di, DEMANGLE_COMPONENT_ARRAY_TYPE, dim,
         cplus_demangle_type(di));
 }

References cplus_demangle_type(), d_advance, d_check_char, d_expression(), d_make_comp(), d_make_name(), d_peek_char, d_str, DEMANGLE_COMPONENT_ARRAY_TYPE, IS_DIGIT, NULL, and s.

Referenced by cplus_demangle_type().

◆ d_backtrack()

static void d_backtrack	(	struct d_info *	di,
		struct d_info_checkpoint *	checkpoint
	)

static

Definition at line 3648 of file cp-demangle.c.

                                                                      {
     di->n = checkpoint->n;
     di->next_comp = checkpoint->next_comp;
     di->next_sub = checkpoint->next_sub;
     di->expansion = checkpoint->expansion;
 }

References d_info_checkpoint::expansion, d_info::expansion, d_info_checkpoint::n, d_info::n, d_info_checkpoint::next_comp, d_info::next_comp, d_info_checkpoint::next_sub, and d_info::next_sub.

Referenced by cplus_demangle_type().

◆ d_bare_function_type()

static struct demangle_component * d_bare_function_type	(	struct d_info *	di,
		int	has_return_type
	)

static

Definition at line 2733 of file cp-demangle.c.

                                                              {
     struct demangle_component *return_type;
     struct demangle_component *tl;
     char peek;
  
     /* Detect special qualifier indicating that the first argument
      is the return type.  */
     peek = d_peek_char(di);
     if (peek == 'J') {
         d_advance(di, 1);
         has_return_type = 1;
     }
  
     if (has_return_type) {
         return_type = cplus_demangle_type(di);
         if (return_type == NULL)
             return NULL;
     } else
         return_type = NULL;
  
     tl = d_parmlist(di);
     if (tl == NULL)
         return NULL;
  
     return d_make_comp(di, DEMANGLE_COMPONENT_FUNCTION_TYPE,
         return_type, tl);
 }

References cplus_demangle_type(), d_advance, d_make_comp(), d_parmlist(), d_peek_char, DEMANGLE_COMPONENT_FUNCTION_TYPE, has_return_type(), and NULL.

Referenced by d_encoding(), and d_function_type().

◆ d_call_offset()

static int d_call_offset	(	struct d_info *	di,
		int	c
	)

static

Definition at line 2030 of file cp-demangle.c.

                                         {
     if (c == '\0')
         c = d_next_char(di);
  
     if (c == 'h')
         d_number(di);
     else if (c == 'v') {
         d_number(di);
         if (!d_check_char(di, '_'))
             return 0;
         d_number(di);
     } else
         return 0;
  
     if (!d_check_char(di, '_'))
         return 0;
  
     return 1;
 }

References c, d_check_char, d_next_char, and d_number().

Referenced by d_special_name().

◆ d_checkpoint()

static void d_checkpoint	(	struct d_info *	di,
		struct d_info_checkpoint *	checkpoint
	)

static

Definition at line 3640 of file cp-demangle.c.

                                                                       {
     checkpoint->n = di->n;
     checkpoint->next_comp = di->next_comp;
     checkpoint->next_sub = di->next_sub;
     checkpoint->expansion = di->expansion;
 }

References d_info_checkpoint::expansion, d_info::expansion, d_info_checkpoint::n, d_info::n, d_info_checkpoint::next_comp, d_info::next_comp, d_info_checkpoint::next_sub, and d_info::next_sub.

Referenced by cplus_demangle_type().

◆ d_class_enum_type()

static struct demangle_component * d_class_enum_type ( struct d_info * di )

static

Definition at line 2764 of file cp-demangle.c.

                                      {
     return d_name(di);
 }

References d_name().

Referenced by cplus_demangle_type().

◆ d_clone_suffix()

static struct demangle_component * d_clone_suffix	(	struct d_info *	di,
		struct demangle_component *	encoding
	)

static

Definition at line 3480 of file cp-demangle.c.

                                                                        {
     const char *suffix = d_str(di);
     const char *pend = suffix;
     struct demangle_component *n;
  
     if (*pend == '.' && (IS_LOWER(pend[1]) || pend[1] == '_')) {
         pend += 2;
         while (IS_LOWER(*pend) || *pend == '_')
             ++pend;
     }
     while (*pend == '.' && IS_DIGIT(pend[1])) {
         pend += 2;
         while (IS_DIGIT(*pend))
             ++pend;
     }
     d_advance(di, pend - suffix);
     n = d_make_name(di, suffix, pend - suffix);
     return d_make_comp(di, DEMANGLE_COMPONENT_CLONE, encoding, n);
 }

References d_advance, d_make_comp(), d_make_name(), d_str, DEMANGLE_COMPONENT_CLONE, cmd_descs_generate::encoding, IS_DIGIT, IS_LOWER, n, and suffix.

Referenced by cplus_demangle_mangled_name().

◆ d_compact_number()

static int d_compact_number ( struct d_info * di )

static

Definition at line 2871 of file cp-demangle.c.

                                     {
     int num;
     if (d_peek_char(di) == '_')
         num = 0;
     else if (d_peek_char(di) == 'n')
         return -1;
     else
         num = d_number(di) + 1;
  
     if (num < 0 || !d_check_char(di, '_'))
         return -1;
     return num;
 }

References d_check_char, d_number(), d_peek_char, and num.

Referenced by d_expression_1(), d_lambda(), d_local_name(), d_template_param(), and d_unnamed_type().

◆ d_count_templates_scopes()

static void d_count_templates_scopes	(	int *	num_templates,
		int *	num_scopes,
		const struct demangle_component *	dc
	)

static

Definition at line 3734 of file cp-demangle.c.

                                          {
     if (dc == NULL)
         return;
  
     switch (dc->type) {
     case DEMANGLE_COMPONENT_NAME:
     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
     case DEMANGLE_COMPONENT_SUB_STD:
     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
     case DEMANGLE_COMPONENT_OPERATOR:
     case DEMANGLE_COMPONENT_CHARACTER:
     case DEMANGLE_COMPONENT_NUMBER:
     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
         break;
  
     case DEMANGLE_COMPONENT_TEMPLATE:
         (*num_templates)++;
         goto recurse_left_right;
  
     case DEMANGLE_COMPONENT_REFERENCE:
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
         if (d_left(dc)->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM)
             (*num_scopes)++;
         goto recurse_left_right;
  
     case DEMANGLE_COMPONENT_QUAL_NAME:
     case DEMANGLE_COMPONENT_LOCAL_NAME:
     case DEMANGLE_COMPONENT_TYPED_NAME:
     case DEMANGLE_COMPONENT_VTABLE:
     case DEMANGLE_COMPONENT_VTT:
     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
     case DEMANGLE_COMPONENT_TYPEINFO:
     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
     case DEMANGLE_COMPONENT_TYPEINFO_FN:
     case DEMANGLE_COMPONENT_THUNK:
     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
     case DEMANGLE_COMPONENT_JAVA_CLASS:
     case DEMANGLE_COMPONENT_GUARD:
     case DEMANGLE_COMPONENT_TLS_INIT:
     case DEMANGLE_COMPONENT_TLS_WRAPPER:
     case DEMANGLE_COMPONENT_REFTEMP:
     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_CONST:
     case DEMANGLE_COMPONENT_RESTRICT_THIS:
     case DEMANGLE_COMPONENT_VOLATILE_THIS:
     case DEMANGLE_COMPONENT_CONST_THIS:
     case DEMANGLE_COMPONENT_REFERENCE_THIS:
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
     case DEMANGLE_COMPONENT_NOEXCEPT:
     case DEMANGLE_COMPONENT_THROW_SPEC:
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
     case DEMANGLE_COMPONENT_POINTER:
     case DEMANGLE_COMPONENT_COMPLEX:
     case DEMANGLE_COMPONENT_IMAGINARY:
     case DEMANGLE_COMPONENT_VENDOR_TYPE:
     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
     case DEMANGLE_COMPONENT_ARRAY_TYPE:
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
     case DEMANGLE_COMPONENT_VECTOR_TYPE:
     case DEMANGLE_COMPONENT_ARGLIST:
     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
     case DEMANGLE_COMPONENT_TPARM_OBJ:
     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
     case DEMANGLE_COMPONENT_CAST:
     case DEMANGLE_COMPONENT_CONVERSION:
     case DEMANGLE_COMPONENT_NULLARY:
     case DEMANGLE_COMPONENT_UNARY:
     case DEMANGLE_COMPONENT_BINARY:
     case DEMANGLE_COMPONENT_BINARY_ARGS:
     case DEMANGLE_COMPONENT_TRINARY:
     case DEMANGLE_COMPONENT_TRINARY_ARG1:
     case DEMANGLE_COMPONENT_TRINARY_ARG2:
     case DEMANGLE_COMPONENT_LITERAL:
     case DEMANGLE_COMPONENT_LITERAL_NEG:
     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
     case DEMANGLE_COMPONENT_COMPOUND_NAME:
     case DEMANGLE_COMPONENT_DECLTYPE:
     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
     case DEMANGLE_COMPONENT_PACK_EXPANSION:
     case DEMANGLE_COMPONENT_TAGGED_NAME:
     case DEMANGLE_COMPONENT_CLONE:
     recurse_left_right:
         d_count_templates_scopes(num_templates, num_scopes,
             d_left(dc));
         d_count_templates_scopes(num_templates, num_scopes,
             d_right(dc));
         break;
  
     case DEMANGLE_COMPONENT_CTOR:
         d_count_templates_scopes(num_templates, num_scopes,
             dc->u.s_ctor.name);
         break;
  
     case DEMANGLE_COMPONENT_DTOR:
         d_count_templates_scopes(num_templates, num_scopes,
             dc->u.s_dtor.name);
         break;
  
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
         d_count_templates_scopes(num_templates, num_scopes,
             dc->u.s_extended_operator.name);
         break;
  
     case DEMANGLE_COMPONENT_FIXED_TYPE:
         d_count_templates_scopes(num_templates, num_scopes,
             dc->u.s_fixed.length);
         break;
  
     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
         d_count_templates_scopes(num_templates, num_scopes,
             d_left(dc));
         break;
  
     case DEMANGLE_COMPONENT_LAMBDA:
     case DEMANGLE_COMPONENT_DEFAULT_ARG:
         d_count_templates_scopes(num_templates, num_scopes,
             dc->u.s_unary_num.sub);
         break;
     }
 }

Referenced by d_print_init().

◆ d_ctor_dtor_name()

static struct demangle_component * d_ctor_dtor_name ( struct d_info * di )

static

Definition at line 2059 of file cp-demangle.c.

                                     {
     if (di->last_name != NULL) {
         if (di->last_name->type == DEMANGLE_COMPONENT_NAME)
             di->expansion += di->last_name->u.s_name.len;
         else if (di->last_name->type == DEMANGLE_COMPONENT_SUB_STD)
             di->expansion += di->last_name->u.s_string.len;
     }
     switch (d_peek_char(di)) {
     case 'C': {
         enum gnu_v3_ctor_kinds kind;
         int inheriting = 0;
  
         if (d_peek_next_char(di) == 'I') {
             inheriting = 1;
             d_advance(di, 1);
         }
  
         switch (d_peek_next_char(di)) {
         case '1':
             kind = gnu_v3_complete_object_ctor;
             break;
         case '2':
             kind = gnu_v3_base_object_ctor;
             break;
         case '3':
             kind = gnu_v3_complete_object_allocating_ctor;
             break;
         case '4':
             kind = gnu_v3_unified_ctor;
             break;
         case '5':
             kind = gnu_v3_object_ctor_group;
             break;
         default:
             return NULL;
         }
  
         d_advance(di, 2);
  
         if (inheriting)
             cplus_demangle_type(di);
  
         return d_make_ctor(di, kind, di->last_name);
     }
  
     case 'D': {
         enum gnu_v3_dtor_kinds kind;
  
         switch (d_peek_next_char(di)) {
         case '0':
             kind = gnu_v3_deleting_dtor;
             break;
         case '1':
             kind = gnu_v3_complete_object_dtor;
             break;
         case '2':
             kind = gnu_v3_base_object_dtor;
             break;
         /*  digit '3' is not used */
         case '4':
             kind = gnu_v3_unified_dtor;
             break;
         case '5':
             kind = gnu_v3_object_dtor_group;
             break;
         default:
             return NULL;
         }
         d_advance(di, 2);
         return d_make_dtor(di, kind, di->last_name);
     }
  
     default:
         return NULL;
     }
 }

References cplus_demangle_type(), d_advance, d_make_ctor(), d_make_dtor(), d_peek_char, d_peek_next_char, DEMANGLE_COMPONENT_NAME, DEMANGLE_COMPONENT_SUB_STD, d_info::expansion, gnu_v3_base_object_ctor, gnu_v3_base_object_dtor, gnu_v3_complete_object_allocating_ctor, gnu_v3_complete_object_ctor, gnu_v3_complete_object_dtor, gnu_v3_deleting_dtor, gnu_v3_object_ctor_group, gnu_v3_object_dtor_group, gnu_v3_unified_ctor, gnu_v3_unified_dtor, demangle_component::kind, d_info::last_name, NULL, demangle_component::s_name, demangle_component::s_string, demangle_component::type, and demangle_component::u.

Referenced by d_unqualified_name().

◆ d_cv_qualifiers()

static struct demangle_component ** d_cv_qualifiers	(	struct d_info *	di,
		struct demangle_component **	pret,
		int	member_fn
	)

static

Definition at line 2557 of file cp-demangle.c.

                                                      {
     struct demangle_component **pstart;
     char peek;
  
     pstart = pret;
     peek = d_peek_char(di);
     while (next_is_type_qual(di)) {
         enum demangle_component_type t;
         struct demangle_component *right = NULL;
  
         d_advance(di, 1);
         if (peek == 'r') {
             t = (member_fn
                     ? DEMANGLE_COMPONENT_RESTRICT_THIS
                     : DEMANGLE_COMPONENT_RESTRICT);
             di->expansion += sizeof "restrict";
         } else if (peek == 'V') {
             t = (member_fn
                     ? DEMANGLE_COMPONENT_VOLATILE_THIS
                     : DEMANGLE_COMPONENT_VOLATILE);
             di->expansion += sizeof "volatile";
         } else if (peek == 'K') {
             t = (member_fn
                     ? DEMANGLE_COMPONENT_CONST_THIS
                     : DEMANGLE_COMPONENT_CONST);
             di->expansion += sizeof "const";
         } else {
             peek = d_next_char(di);
             if (peek == 'x') {
                 t = DEMANGLE_COMPONENT_TRANSACTION_SAFE;
                 di->expansion += sizeof "transaction_safe";
             } else if (peek == 'o' || peek == 'O') {
                 t = DEMANGLE_COMPONENT_NOEXCEPT;
                 di->expansion += sizeof "noexcept";
                 if (peek == 'O') {
                     right = d_expression(di);
                     if (right == NULL)
                         return NULL;
                     if (!d_check_char(di, 'E'))
                         return NULL;
                 }
             } else if (peek == 'w') {
                 t = DEMANGLE_COMPONENT_THROW_SPEC;
                 di->expansion += sizeof "throw";
                 right = d_parmlist(di);
                 if (right == NULL)
                     return NULL;
                 if (!d_check_char(di, 'E'))
                     return NULL;
             } else
                 return NULL;
         }
  
         *pret = d_make_comp(di, t, NULL, right);
         if (*pret == NULL)
             return NULL;
         pret = &d_left(*pret);
  
         peek = d_peek_char(di);
     }
  
     if (!member_fn && peek == 'F') {
         while (pstart != pret) {
             switch ((*pstart)->type) {
             case DEMANGLE_COMPONENT_RESTRICT:
                 (*pstart)->type = DEMANGLE_COMPONENT_RESTRICT_THIS;
                 break;
             case DEMANGLE_COMPONENT_VOLATILE:
                 (*pstart)->type = DEMANGLE_COMPONENT_VOLATILE_THIS;
                 break;
             case DEMANGLE_COMPONENT_CONST:
                 (*pstart)->type = DEMANGLE_COMPONENT_CONST_THIS;
                 break;
             default:
                 break;
             }
             pstart = &d_left(*pstart);
         }
     }
  
     return pret;
 }

References d_advance, d_check_char, d_expression(), d_left, d_make_comp(), d_next_char, d_parmlist(), d_peek_char, DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_CONST_THIS, DEMANGLE_COMPONENT_NOEXCEPT, DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RESTRICT_THIS, DEMANGLE_COMPONENT_THROW_SPEC, DEMANGLE_COMPONENT_TRANSACTION_SAFE, DEMANGLE_COMPONENT_VOLATILE, DEMANGLE_COMPONENT_VOLATILE_THIS, d_info::expansion, next_is_type_qual(), NULL, and demangle_component::right.

Referenced by cplus_demangle_type(), and d_nested_name().

◆ d_demangle()

static char * d_demangle	(	const char *	mangled,
		int	options,
		size_t *	palc
	)

static

Definition at line 5798 of file cp-demangle.c.

                                                            {
     struct d_growable_string dgs;
     int status;
  
     d_growable_string_init(&dgs, 0);
  
     status = d_demangle_callback(mangled, options,
         d_growable_string_callback_adapter, &dgs);
     if (status == 0) {
         free(dgs.buf);
         *palc = 0;
         return NULL;
     }
  
     *palc = dgs.allocation_failure ? 1 : dgs.alc;
     return dgs.buf;
 }

References d_growable_string::alc, d_growable_string::allocation_failure, d_growable_string::buf, d_demangle_callback(), d_growable_string_callback_adapter(), d_growable_string_init(), free(), NULL, options, and status.

Referenced by cplus_demangle_v3(), and java_demangle_v3().

◆ d_demangle_callback()

static int d_demangle_callback	(	const char *	mangled,
		int	options,
		demangle_callbackref	callback,
		void *	opaque
	)

static

Definition at line 5713 of file cp-demangle.c.

                                                  {
     enum {
         DCT_TYPE,
         DCT_MANGLED,
         DCT_GLOBAL_CTORS,
         DCT_GLOBAL_DTORS
     } type;
     struct d_info di;
     struct demangle_component *dc;
     int status;
  
     if (mangled[0] == '_' && mangled[1] == 'Z')
         type = DCT_MANGLED;
     else if (strncmp(mangled, "_GLOBAL_", 8) == 0 && (mangled[8] == '.' || mangled[8] == '_' || mangled[8] == '$') && (mangled[9] == 'D' || mangled[9] == 'I') && mangled[10] == '_')
         type = mangled[9] == 'I' ? DCT_GLOBAL_CTORS : DCT_GLOBAL_DTORS;
     else {
         if ((options & DMGL_TYPES) == 0)
             return 0;
         type = DCT_TYPE;
     }
  
     cplus_demangle_init_info(mangled, options, strlen(mangled), &di);
  
     {
 #ifdef CP_DYNAMIC_ARRAYS
         __extension__ struct demangle_component comps[di.num_comps];
         __extension__ struct demangle_component *subs[di.num_subs];
  
         di.comps = comps;
         di.subs = subs;
 #else
         di.comps = alloca(di.num_comps * sizeof(*di.comps));
         di.subs = alloca(di.num_subs * sizeof(*di.subs));
 #endif
  
         switch (type) {
         case DCT_TYPE:
             dc = cplus_demangle_type(&di);
             break;
         case DCT_MANGLED:
             dc = cplus_demangle_mangled_name(&di, 1);
             break;
         case DCT_GLOBAL_CTORS:
         case DCT_GLOBAL_DTORS:
             d_advance(&di, 11);
             dc = d_make_comp(&di,
                 (type == DCT_GLOBAL_CTORS
                         ? DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS
                         : DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS),
                 d_make_demangle_mangled_name(&di, d_str(&di)),
                 NULL);
             d_advance(&di, strlen(d_str(&di)));
             break;
         default:
             abort(); /* We have listed all the cases.  */
         }
  
         /* If DMGL_PARAMS is set, then if we didn't consume the entire
        mangled string, then we didn't successfully demangle it.  If
        DMGL_PARAMS is not set, we didn't look at the trailing
        parameters.  */
         if (((options & DMGL_PARAMS) != 0) && d_peek_char(&di) != '\0')
             dc = NULL;
  
 #ifdef CP_DEMANGLE_DEBUG
         d_dump(dc, 0);
 #endif
  
         status = (dc != NULL)
             ? cplus_demangle_print_callback(options, dc, callback, opaque)
             : 0;
     }
  
     return status;
 }

References __extension__, alloca(), cplus_demangle_init_info(), cplus_demangle_mangled_name(), cplus_demangle_print_callback(), cplus_demangle_type(), d_advance, d_make_comp(), d_make_demangle_mangled_name(), d_peek_char, d_str, DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS, DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS, DMGL_PARAMS, DMGL_TYPES, NULL, options, status, and type.

Referenced by cplus_demangle_v3_callback(), d_demangle(), and java_demangle_v3_callback().

◆ d_discriminator()

static int d_discriminator ( struct d_info * di )

static

Definition at line 3387 of file cp-demangle.c.

                                    {
     int discrim, num_underscores = 1;
  
     if (d_peek_char(di) != '_')
         return 1;
     d_advance(di, 1);
     if (d_peek_char(di) == '_') {
         ++num_underscores;
         d_advance(di, 1);
     }
  
     discrim = d_number(di);
     if (discrim < 0)
         return 0;
     if (num_underscores > 1 && discrim >= 10) {
         if (d_peek_char(di) == '_')
             d_advance(di, 1);
         else
             return 0;
     }
  
     return 1;
 }

References d_advance, d_number(), and d_peek_char.

Referenced by d_local_name(), and d_unqualified_name().

◆ d_encoding()

static struct demangle_component * d_encoding	(	struct d_info *	di,
		int	top_level
	)

static

Definition at line 1247 of file cp-demangle.c.

                                              {
     char peek = d_peek_char(di);
     struct demangle_component *dc;
  
     if (peek == 'G' || peek == 'T')
         dc = d_special_name(di);
     else {
         dc = d_name(di);
  
         if (!dc)
             /* Failed already.  */;
         else if (top_level && (di->options & DMGL_PARAMS) == 0) {
             /* Strip off any initial CV-qualifiers, as they really apply
          to the `this' parameter, and they were not output by the
          v2 demangler without DMGL_PARAMS.  */
             while (is_fnqual_component_type(dc->type))
                 dc = d_left(dc);
  
             /* If the top level is a DEMANGLE_COMPONENT_LOCAL_NAME, then
          there may be function-qualifiers on its right argument which
          really apply here; this happens when parsing a class
          which is local to a function.  */
             if (dc->type == DEMANGLE_COMPONENT_LOCAL_NAME)
                 while (is_fnqual_component_type(d_right(dc)->type))
                     d_right(dc) = d_left(d_right(dc));
         } else {
             peek = d_peek_char(di);
             if (peek != '\0' && peek != 'E') {
                 struct demangle_component *ftype;
  
                 ftype = d_bare_function_type(di, has_return_type(dc));
                 if (ftype) {
                     /* If this is a non-top-level local-name, clear the
              return type, so it doesn't confuse the user by
              being confused with the return type of whaever
              this is nested within.  */
                     if (!top_level && dc->type == DEMANGLE_COMPONENT_LOCAL_NAME && ftype->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
                         d_left(ftype) = NULL;
  
                     dc = d_make_comp(di, DEMANGLE_COMPONENT_TYPED_NAME,
                         dc, ftype);
                 } else
                     dc = NULL;
             }
         }
     }
  
     return dc;
 }

References d_bare_function_type(), d_left, d_make_comp(), d_name(), d_peek_char, d_right, d_special_name(), DEMANGLE_COMPONENT_FUNCTION_TYPE, DEMANGLE_COMPONENT_LOCAL_NAME, DEMANGLE_COMPONENT_TYPED_NAME, DMGL_PARAMS, has_return_type(), is_fnqual_component_type(), NULL, d_info::options, type, and demangle_component::type.

Referenced by cplus_demangle_mangled_name(), d_local_name(), d_make_demangle_mangled_name(), and d_special_name().

◆ d_expr_primary()

static struct demangle_component * d_expr_primary ( struct d_info * di )

static

Definition at line 3265 of file cp-demangle.c.

                                   {
     struct demangle_component *ret;
  
     if (!d_check_char(di, 'L'))
         return NULL;
     if (d_peek_char(di) == '_'
         /* Workaround for G++ bug; see comment in write_template_arg.  */
         || d_peek_char(di) == 'Z')
         ret = cplus_demangle_mangled_name(di, 0);
     else {
         struct demangle_component *type;
         enum demangle_component_type t;
         const char *s;
  
         type = cplus_demangle_type(di);
         if (type == NULL)
             return NULL;
  
         /* If we have a type we know how to print, we aren't going to
      print the type name itself.  */
         if (type->type == DEMANGLE_COMPONENT_BUILTIN_TYPE && type->u.s_builtin.type->print != D_PRINT_DEFAULT)
             di->expansion -= type->u.s_builtin.type->len;
  
         /* Rather than try to interpret the literal value, we just
      collect it as a string.  Note that it's possible to have a
      floating point literal here.  The ABI specifies that the
      format of such literals is machine independent.  That's fine,
      but what's not fine is that versions of g++ up to 3.2 with
      -fabi-version=1 used upper case letters in the hex constant,
      and dumped out gcc's internal representation.  That makes it
      hard to tell where the constant ends, and hard to dump the
      constant in any readable form anyhow.  We don't attempt to
      handle these cases.  */
  
         t = DEMANGLE_COMPONENT_LITERAL;
         if (d_peek_char(di) == 'n') {
             t = DEMANGLE_COMPONENT_LITERAL_NEG;
             d_advance(di, 1);
         }
         s = d_str(di);
         while (d_peek_char(di) != 'E') {
             if (d_peek_char(di) == '\0')
                 return NULL;
             d_advance(di, 1);
         }
         ret = d_make_comp(di, t, type, d_make_name(di, s, d_str(di) - s));
     }
     if (!d_check_char(di, 'E'))
         return NULL;
     return ret;
 }

References cplus_demangle_mangled_name(), cplus_demangle_type(), d_advance, d_check_char, d_make_comp(), d_make_name(), d_peek_char, D_PRINT_DEFAULT, d_str, DEMANGLE_COMPONENT_BUILTIN_TYPE, DEMANGLE_COMPONENT_LITERAL, DEMANGLE_COMPONENT_LITERAL_NEG, d_info::expansion, NULL, s, and type.

Referenced by d_expression_1(), and d_template_arg().

◆ d_expression()

static struct demangle_component * d_expression ( struct d_info * di )

static

Definition at line 3249 of file cp-demangle.c.

                                 {
     struct demangle_component *ret;
     int was_expression = di->is_expression;
  
     di->is_expression = 1;
     ret = d_expression_1(di);
     di->is_expression = was_expression;
     return ret;
 }

References d_expression_1(), and d_info::is_expression.

Referenced by cplus_demangle_type(), d_array_type(), d_cv_qualifiers(), d_exprlist(), d_template_arg(), and d_vector_type().

◆ d_expression_1()

static struct demangle_component* d_expression_1 ( struct d_info * di )

inlinestatic

Definition at line 3041 of file cp-demangle.c.

                                   {
     char peek;
  
     peek = d_peek_char(di);
     if (peek == 'L')
         return d_expr_primary(di);
     else if (peek == 'T')
         return d_template_param(di);
     else if (peek == 's' && d_peek_next_char(di) == 'r') {
         struct demangle_component *type;
         struct demangle_component *name;
  
         d_advance(di, 2);
         type = cplus_demangle_type(di);
         name = d_unqualified_name(di);
         if (d_peek_char(di) != 'I')
             return d_make_comp(di, DEMANGLE_COMPONENT_QUAL_NAME, type, name);
         else
             return d_make_comp(di, DEMANGLE_COMPONENT_QUAL_NAME, type,
                 d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, name,
                     d_template_args(di)));
     } else if (peek == 's' && d_peek_next_char(di) == 'p') {
         d_advance(di, 2);
         return d_make_comp(di, DEMANGLE_COMPONENT_PACK_EXPANSION,
             d_expression_1(di), NULL);
     } else if (peek == 'f' && d_peek_next_char(di) == 'p') {
         /* Function parameter used in a late-specified return type.  */
         int index;
         d_advance(di, 2);
         if (d_peek_char(di) == 'T') {
             /* 'this' parameter.  */
             d_advance(di, 1);
             index = 0;
         } else {
             index = d_compact_number(di);
             if (index == INT_MAX || index == -1)
                 return NULL;
             index++;
         }
         return d_make_function_param(di, index);
     } else if (IS_DIGIT(peek) || (peek == 'o' && d_peek_next_char(di) == 'n')) {
         /* We can get an unqualified name as an expression in the case of
          a dependent function call, i.e. decltype(f(t)).  */
         struct demangle_component *name;
  
         if (peek == 'o')
             /* operator-function-id, i.e. operator+(t).  */
             d_advance(di, 2);
  
         name = d_unqualified_name(di);
         if (name == NULL)
             return NULL;
         if (d_peek_char(di) == 'I')
             return d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, name,
                 d_template_args(di));
         else
             return name;
     } else if ((peek == 'i' || peek == 't') && d_peek_next_char(di) == 'l') {
         /* Brace-enclosed initializer list, untyped or typed.  */
         struct demangle_component *type = NULL;
         d_advance(di, 2);
         if (peek == 't')
             type = cplus_demangle_type(di);
         if (!d_peek_next_char(di))
             return NULL;
         return d_make_comp(di, DEMANGLE_COMPONENT_INITIALIZER_LIST,
             type, d_exprlist(di, 'E'));
     } else {
         struct demangle_component *op;
         const char *code = NULL;
         int args;
  
         op = d_operator_name(di);
         if (op == NULL)
             return NULL;
  
         if (op->type == DEMANGLE_COMPONENT_OPERATOR) {
             code = op->u.s_operator.op->code;
             di->expansion += op->u.s_operator.op->len - 2;
             if (strcmp(code, "st") == 0)
                 return d_make_comp(di, DEMANGLE_COMPONENT_UNARY, op,
                     cplus_demangle_type(di));
         }
  
         switch (op->type) {
         default:
             return NULL;
         case DEMANGLE_COMPONENT_OPERATOR:
             args = op->u.s_operator.op->args;
             break;
         case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
             args = op->u.s_extended_operator.args;
             break;
         case DEMANGLE_COMPONENT_CAST:
             args = 1;
             break;
         }
  
         switch (args) {
         case 0:
             return d_make_comp(di, DEMANGLE_COMPONENT_NULLARY, op, NULL);
  
         case 1: {
             struct demangle_component *operand;
             int suffix = 0;
  
             if (code && (code[0] == 'p' || code[0] == 'm') && code[1] == code[0])
                 /* pp_ and mm_ are the prefix variants.  */
                 suffix = !d_check_char(di, '_');
  
             if (op->type == DEMANGLE_COMPONENT_CAST && d_check_char(di, '_'))
                 operand = d_exprlist(di, 'E');
             else if (code && !strcmp(code, "sP"))
                 operand = d_template_args_1(di);
             else
                 operand = d_expression_1(di);
  
             if (suffix)
                 /* Indicate the suffix variant for d_print_comp.  */
                 operand = d_make_comp(di, DEMANGLE_COMPONENT_BINARY_ARGS,
                     operand, operand);
  
             return d_make_comp(di, DEMANGLE_COMPONENT_UNARY, op, operand);
         }
         case 2: {
             struct demangle_component *left;
             struct demangle_component *right;
  
             if (code == NULL)
                 return NULL;
             if (op_is_new_cast(op))
                 left = cplus_demangle_type(di);
             else if (code[0] == 'f')
                 /* fold-expression.  */
                 left = d_operator_name(di);
             else
                 left = d_expression_1(di);
             if (!strcmp(code, "cl"))
                 right = d_exprlist(di, 'E');
             else if (!strcmp(code, "dt") || !strcmp(code, "pt")) {
                 right = d_unqualified_name(di);
                 if (d_peek_char(di) == 'I')
                     right = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE,
                         right, d_template_args(di));
             } else
                 right = d_expression_1(di);
  
             return d_make_comp(di, DEMANGLE_COMPONENT_BINARY, op,
                 d_make_comp(di,
                     DEMANGLE_COMPONENT_BINARY_ARGS,
                     left, right));
         }
         case 3: {
             struct demangle_component *first;
             struct demangle_component *second;
             struct demangle_component *third;
  
             if (code == NULL)
                 return NULL;
             else if (!strcmp(code, "qu")) {
                 /* ?: expression.  */
                 first = d_expression_1(di);
                 second = d_expression_1(di);
                 third = d_expression_1(di);
                 if (third == NULL)
                     return NULL;
             } else if (code[0] == 'f') {
                 /* fold-expression.  */
                 first = d_operator_name(di);
                 second = d_expression_1(di);
                 third = d_expression_1(di);
                 if (third == NULL)
                     return NULL;
             } else if (code[0] == 'n') {
                 /* new-expression.  */
                 if (code[1] != 'w' && code[1] != 'a')
                     return NULL;
                 first = d_exprlist(di, '_');
                 second = cplus_demangle_type(di);
                 if (d_peek_char(di) == 'E') {
                     d_advance(di, 1);
                     third = NULL;
                 } else if (d_peek_char(di) == 'p' && d_peek_next_char(di) == 'i') {
                     /* Parenthesized initializer.  */
                     d_advance(di, 2);
                     third = d_exprlist(di, 'E');
                 } else if (d_peek_char(di) == 'i' && d_peek_next_char(di) == 'l')
                     /* initializer-list.  */
                     third = d_expression_1(di);
                 else
                     return NULL;
             } else
                 return NULL;
             return d_make_comp(di, DEMANGLE_COMPONENT_TRINARY, op,
                 d_make_comp(di,
                     DEMANGLE_COMPONENT_TRINARY_ARG1,
                     first,
                     d_make_comp(di,
                         DEMANGLE_COMPONENT_TRINARY_ARG2,
                         second, third)));
         }
         default:
             return NULL;
         }
     }
 }

Referenced by d_expression().

◆ d_exprlist()

static struct demangle_component* d_exprlist	(	struct d_info *	di,
		char	terminator
	)

static

Definition at line 2992 of file cp-demangle.c.

                                                {
     struct demangle_component *list = NULL;
     struct demangle_component **p = &list;
  
     if (d_peek_char(di) == terminator) {
         d_advance(di, 1);
         return d_make_comp(di, DEMANGLE_COMPONENT_ARGLIST, NULL, NULL);
     }
  
     while (1) {
         struct demangle_component *arg = d_expression(di);
         if (arg == NULL)
             return NULL;
  
         *p = d_make_comp(di, DEMANGLE_COMPONENT_ARGLIST, arg, NULL);
         if (*p == NULL)
             return NULL;
         p = &d_right(*p);
  
         if (d_peek_char(di) == terminator) {
             d_advance(di, 1);
             break;
         }
     }
  
     return list;
 }

References d_advance, d_expression(), d_make_comp(), d_peek_char, d_right, DEMANGLE_COMPONENT_ARGLIST, list(), NULL, and p.

Referenced by d_expression_1().

◆ d_find_pack()

static struct demangle_component* d_find_pack	(	struct d_print_info *	dpi,
		const struct demangle_component *	dc
	)

static

Definition at line 4072 of file cp-demangle.c.

                                          {
     struct demangle_component *a;
     if (dc == NULL)
         return NULL;
  
     switch (dc->type) {
     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
         a = d_lookup_template_argument(dpi, dc);
         if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
             return a;
         return NULL;
  
     case DEMANGLE_COMPONENT_PACK_EXPANSION:
         return NULL;
  
     case DEMANGLE_COMPONENT_LAMBDA:
     case DEMANGLE_COMPONENT_NAME:
     case DEMANGLE_COMPONENT_TAGGED_NAME:
     case DEMANGLE_COMPONENT_OPERATOR:
     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
     case DEMANGLE_COMPONENT_SUB_STD:
     case DEMANGLE_COMPONENT_CHARACTER:
     case DEMANGLE_COMPONENT_FUNCTION_PARAM:
     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
     case DEMANGLE_COMPONENT_FIXED_TYPE:
     case DEMANGLE_COMPONENT_DEFAULT_ARG:
     case DEMANGLE_COMPONENT_NUMBER:
         return NULL;
  
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
         return d_find_pack(dpi, dc->u.s_extended_operator.name);
     case DEMANGLE_COMPONENT_CTOR:
         return d_find_pack(dpi, dc->u.s_ctor.name);
     case DEMANGLE_COMPONENT_DTOR:
         return d_find_pack(dpi, dc->u.s_dtor.name);
  
     default:
         a = d_find_pack(dpi, d_left(dc));
         if (a)
             return a;
         return d_find_pack(dpi, d_right(dc));
     }
 }

Referenced by d_args_length(), and d_print_comp_inner().

◆ d_function_type()

static struct demangle_component * d_function_type ( struct d_info * di )

static

Definition at line 2670 of file cp-demangle.c.

                                    {
     struct demangle_component *ret;
  
     if (!d_check_char(di, 'F'))
         return NULL;
     if (d_peek_char(di) == 'Y') {
         /* Function has C linkage.  We don't print this information.
      FIXME: We should print it in verbose mode.  */
         d_advance(di, 1);
     }
     ret = d_bare_function_type(di, 1);
     ret = d_ref_qualifier(di, ret);
  
     if (!d_check_char(di, 'E'))
         return NULL;
     return ret;
 }

References d_advance, d_bare_function_type(), d_check_char, d_peek_char, d_ref_qualifier(), and NULL.

Referenced by cplus_demangle_type().

◆ d_get_saved_scope()

static struct d_saved_scope* d_get_saved_scope	(	struct d_print_info *	dpi,
		const struct demangle_component *	container
	)

static

Definition at line 4205 of file cp-demangle.c.

                                                 {
     int i;
  
     for (i = 0; i < dpi->next_saved_scope; i++)
         if (dpi->saved_scopes[i].container == container)
             return &dpi->saved_scopes[i];
  
     return NULL;
 }

References d_saved_scope::container, i, d_print_info::next_saved_scope, NULL, and d_print_info::saved_scopes.

Referenced by d_print_comp_inner().

◆ d_growable_string_append_buffer()

static void d_growable_string_append_buffer	(	struct d_growable_string *	dgs,
		const char *	s,
		size_t	l
	)

inlinestatic

Definition at line 3701 of file cp-demangle.c.

                              {
     size_t need;
  
     need = dgs->len + l + 1;
     if (need > dgs->alc)
         d_growable_string_resize(dgs, need);
  
     if (dgs->allocation_failure)
         return;
  
     memcpy(dgs->buf + dgs->len, s, l);
     dgs->buf[dgs->len + l] = '\0';
     dgs->len += l;
 }

References d_growable_string::alc, d_growable_string::allocation_failure, d_growable_string::buf, d_growable_string_resize(), d_growable_string::len, memcpy(), and s.

Referenced by d_growable_string_callback_adapter().

◆ d_growable_string_callback_adapter()

static void d_growable_string_callback_adapter	(	const char *	s,
		size_t	l,
		void *	opaque
	)

static

Definition at line 3720 of file cp-demangle.c.

                                                                           {
     struct d_growable_string *dgs = (struct d_growable_string *)opaque;
  
     d_growable_string_append_buffer(dgs, s, l);
 }

References d_growable_string_append_buffer(), and s.

Referenced by cplus_demangle_print(), and d_demangle().

◆ d_growable_string_init()

static void d_growable_string_init	(	struct d_growable_string *	dgs,
		size_t	estimate
	)

static

Definition at line 3658 of file cp-demangle.c.

                                                                        {
     dgs->buf = NULL;
     dgs->len = 0;
     dgs->alc = 0;
     dgs->allocation_failure = 0;
  
     if (estimate > 0)
         d_growable_string_resize(dgs, estimate);
 }

References d_growable_string::alc, d_growable_string::allocation_failure, d_growable_string::buf, d_growable_string_resize(), d_growable_string::len, and NULL.

Referenced by cplus_demangle_print(), and d_demangle().

◆ d_growable_string_resize()

static void d_growable_string_resize	(	struct d_growable_string *	dgs,
		size_t	need
	)

inlinestatic

Definition at line 3671 of file cp-demangle.c.

                                                                      {
     size_t newalc;
     char *newbuf;
  
     if (dgs->allocation_failure)
         return;
  
     /* Start allocation at two bytes to avoid any possibility of confusion
      with the special value of 1 used as a return in *palc to indicate
      allocation failures.  */
     newalc = dgs->alc > 0 ? dgs->alc : 2;
     while (newalc < need)
         newalc <<= 1;
  
     newbuf = (char *)realloc(dgs->buf, newalc);
     if (newbuf == NULL) {
         free(dgs->buf);
         dgs->buf = NULL;
         dgs->len = 0;
         dgs->alc = 0;
         dgs->allocation_failure = 1;
         return;
     }
     dgs->buf = newbuf;
     dgs->alc = newalc;
 }

References d_growable_string::alc, d_growable_string::allocation_failure, d_growable_string::buf, free(), d_growable_string::len, NULL, and realloc().

Referenced by d_growable_string_append_buffer(), and d_growable_string_init().

◆ d_identifier()

static struct demangle_component * d_identifier	(	struct d_info *	di,
		int	len
	)

static

Definition at line 1624 of file cp-demangle.c.

                                          {
     const char *name;
  
     name = d_str(di);
  
     if (di->send - name < len)
         return NULL;
  
     d_advance(di, len);
  
     /* A Java mangled name may have a trailing '$' if it is a C++
      keyword.  This '$' is not included in the length count.  We just
      ignore the '$'.  */
     if ((di->options & DMGL_JAVA) != 0 && d_peek_char(di) == '$')
         d_advance(di, 1);
  
     /* Look for something which looks like a gcc encoding of an
      anonymous namespace, and replace it with a more user friendly
      name.  */
     if (len >= (int)ANONYMOUS_NAMESPACE_PREFIX_LEN + 2 && memcmp(name, ANONYMOUS_NAMESPACE_PREFIX, ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0) {
         const char *s;
  
         s = name + ANONYMOUS_NAMESPACE_PREFIX_LEN;
         if ((*s == '.' || *s == '_' || *s == '$') && s[1] == 'N') {
             di->expansion -= len - sizeof "(anonymous namespace)";
             return d_make_name(di, "(anonymous namespace)",
                 sizeof "(anonymous namespace)" - 1);
         }
     }
  
     return d_make_name(di, name, len);
 }

References ANONYMOUS_NAMESPACE_PREFIX, ANONYMOUS_NAMESPACE_PREFIX_LEN, d_advance, d_make_name(), d_peek_char, d_str, DMGL_JAVA, d_info::expansion, len, name, NULL, d_info::options, s, and d_info::send.

Referenced by d_source_name().

◆ d_index_template_argument()

static struct demangle_component* d_index_template_argument	(	struct demangle_component *	args,
		int	i
	)

static

Definition at line 4032 of file cp-demangle.c.

                                                                   {
     struct demangle_component *a;
  
     if (i < 0)
         /* Print the whole argument pack.  */
         return args;
  
     for (a = args;
         a != NULL;
         a = d_right(a)) {
         if (a->type != DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
             return NULL;
         if (i <= 0)
             break;
         --i;
     }
     if (i != 0 || a == NULL)
         return NULL;
  
     return d_left(a);
 }

References a, args, d_left, d_right, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, i, and NULL.

Referenced by d_lookup_template_argument(), and d_print_comp_inner().

◆ d_java_resource()

static struct demangle_component* d_java_resource ( struct d_info * di )

static

Definition at line 1798 of file cp-demangle.c.

                                    {
     struct demangle_component *p = NULL;
     struct demangle_component *next = NULL;
     int len, i;
     char c;
     const char *str;
  
     len = d_number(di);
     if (len <= 1)
         return NULL;
  
     /* Eat the leading '_'.  */
     if (d_next_char(di) != '_')
         return NULL;
     len--;
  
     str = d_str(di);
     i = 0;
  
     while (len > 0) {
         c = str[i];
         if (!c)
             return NULL;
  
         /* Each chunk is either a '$' escape...  */
         if (c == '$') {
             i++;
             switch (str[i++]) {
             case 'S':
                 c = '/';
                 break;
             case '_':
                 c = '.';
                 break;
             case '$':
                 c = '$';
                 break;
             default:
                 return NULL;
             }
             next = d_make_character(di, c);
             d_advance(di, i);
             str = d_str(di);
             len -= i;
             i = 0;
             if (next == NULL)
                 return NULL;
         }
         /* ... or a sequence of characters.  */
         else {
             while (i < len && str[i] && str[i] != '$')
                 i++;
  
             next = d_make_name(di, str, i);
             d_advance(di, i);
             str = d_str(di);
             len -= i;
             i = 0;
             if (next == NULL)
                 return NULL;
         }
  
         if (p == NULL)
             p = next;
         else {
             p = d_make_comp(di, DEMANGLE_COMPONENT_COMPOUND_NAME, p, next);
             if (p == NULL)
                 return NULL;
         }
     }
  
     p = d_make_comp(di, DEMANGLE_COMPONENT_JAVA_RESOURCE, p, NULL);
  
     return p;
 }

References c, d_advance, d_make_character(), d_make_comp(), d_make_name(), d_next_char, d_number(), d_str, DEMANGLE_COMPONENT_COMPOUND_NAME, DEMANGLE_COMPONENT_JAVA_RESOURCE, i, len, NULL, p, and cmd_descs_generate::str.

Referenced by d_special_name().

◆ d_lambda()

static struct demangle_component * d_lambda ( struct d_info * di )

static

Definition at line 3414 of file cp-demangle.c.

                             {
     struct demangle_component *tl;
     struct demangle_component *ret;
     int num;
  
     if (!d_check_char(di, 'U'))
         return NULL;
     if (!d_check_char(di, 'l'))
         return NULL;
  
     tl = d_parmlist(di);
     if (tl == NULL)
         return NULL;
  
     if (!d_check_char(di, 'E'))
         return NULL;
  
     num = d_compact_number(di);
     if (num < 0)
         return NULL;
  
     ret = d_make_empty(di);
     if (ret) {
         ret->type = DEMANGLE_COMPONENT_LAMBDA;
         ret->u.s_unary_num.sub = tl;
         ret->u.s_unary_num.num = num;
     }
  
     if (!d_add_substitution(di, ret))
         return NULL;
  
     return ret;
 }

References d_add_substitution(), d_check_char, d_compact_number(), d_make_empty(), d_parmlist(), DEMANGLE_COMPONENT_LAMBDA, NULL, num, demangle_component::s_unary_num, demangle_component::type, and demangle_component::u.

Referenced by d_unqualified_name().

◆ d_last_char()

static char d_last_char ( struct d_print_info * dpi )

inlinestatic

Definition at line 3953 of file cp-demangle.c.

                                       {
     return dpi->last_char;
 }

References d_print_info::last_char.

Referenced by d_print_comp_inner(), d_print_conversion(), d_print_function_type(), and d_print_mod().

◆ d_local_name()

static struct demangle_component * d_local_name ( struct d_info * di )

static

Definition at line 3323 of file cp-demangle.c.

                                 {
     struct demangle_component *function;
     struct demangle_component *name;
  
     if (!d_check_char(di, 'Z'))
         return NULL;
  
     function = d_encoding(di, 0);
     if (!function)
         return NULL;
  
     if (!d_check_char(di, 'E'))
         return NULL;
  
     if (d_peek_char(di) == 's') {
         d_advance(di, 1);
         if (!d_discriminator(di))
             return NULL;
         name = d_make_name(di, "string literal", sizeof "string literal" - 1);
     } else {
         int num = -1;
  
         if (d_peek_char(di) == 'd') {
             /* Default argument scope: d <number> _.  */
             d_advance(di, 1);
             num = d_compact_number(di);
             if (num < 0)
                 return NULL;
         }
  
         name = d_name(di);
  
         if (name
             /* Lambdas and unnamed types have internal discriminators
          and are not functions.  */
             && name->type != DEMANGLE_COMPONENT_LAMBDA && name->type != DEMANGLE_COMPONENT_UNNAMED_TYPE) {
             /* Read and ignore an optional discriminator.  */
             if (!d_discriminator(di))
                 return NULL;
         }
  
         if (num >= 0)
             name = d_make_default_arg(di, num, name);
     }
  
     /* Elide the return type of the containing function so as to not
      confuse the user thinking it is the return type of whatever local
      function we might be containing.  */
     if (function->type == DEMANGLE_COMPONENT_TYPED_NAME && d_right(function)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
         d_left(d_right(function)) = NULL;
  
     return d_make_comp(di, DEMANGLE_COMPONENT_LOCAL_NAME, function, name);
 }

References d_advance, d_check_char, d_compact_number(), d_discriminator(), d_encoding(), d_left, d_make_comp(), d_make_default_arg(), d_make_name(), d_name(), d_peek_char, d_right, DEMANGLE_COMPONENT_FUNCTION_TYPE, DEMANGLE_COMPONENT_LAMBDA, DEMANGLE_COMPONENT_LOCAL_NAME, DEMANGLE_COMPONENT_TYPED_NAME, DEMANGLE_COMPONENT_UNNAMED_TYPE, name, NULL, num, and type.

Referenced by d_name().

◆ d_lookup_template_argument()

static struct demangle_component* d_lookup_template_argument	(	struct d_print_info *	dpi,
		const struct demangle_component *	dc
	)

static

Definition at line 4058 of file cp-demangle.c.

                                          {
     if (dpi->templates == NULL) {
         d_print_error(dpi);
         return NULL;
     }
  
     return d_index_template_argument(d_right(dpi->templates->template_decl),
         dc->u.s_number.number);
 }

References d_index_template_argument(), d_print_error(), d_right, NULL, demangle_component::s_number, d_print_template::template_decl, d_print_info::templates, and demangle_component::u.

Referenced by d_find_pack(), and d_print_comp_inner().

◆ d_make_builtin_type()

static struct demangle_component * d_make_builtin_type	(	struct d_info *	di,
		const struct demangle_builtin_type_info *	type
	)

static

Definition at line 1042 of file cp-demangle.c.

                                                    {
     struct demangle_component *p;
  
     if (type == NULL)
         return NULL;
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = DEMANGLE_COMPONENT_BUILTIN_TYPE;
         p->u.s_builtin.type = type;
     }
     return p;
 }

References d_make_empty(), DEMANGLE_COMPONENT_BUILTIN_TYPE, NULL, p, and type.

Referenced by cplus_demangle_type().

◆ d_make_character()

static struct demangle_component* d_make_character	(	struct d_info *	di,
		int	c
	)

static

Definition at line 1787 of file cp-demangle.c.

                                            {
     struct demangle_component *p;
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = DEMANGLE_COMPONENT_CHARACTER;
         p->u.s_character.character = c;
     }
     return p;
 }

References c, d_make_empty(), DEMANGLE_COMPONENT_CHARACTER, NULL, and p.

Referenced by d_java_resource().

◆ d_make_comp()

static struct demangle_component * d_make_comp	(	struct d_info *	di,
		enum demangle_component_type	type,
		struct demangle_component *	left,
		struct demangle_component *	right
	)

static

Definition at line 915 of file cp-demangle.c.

                                       {
     struct demangle_component *p;
  
     /* We check for errors here.  A typical error would be a NULL return
      from a subroutine.  We catch those here, and return NULL
      upward.  */
     switch (type) {
         /* These types require two parameters.  */
     case DEMANGLE_COMPONENT_QUAL_NAME:
     case DEMANGLE_COMPONENT_LOCAL_NAME:
     case DEMANGLE_COMPONENT_TYPED_NAME:
     case DEMANGLE_COMPONENT_TAGGED_NAME:
     case DEMANGLE_COMPONENT_TEMPLATE:
     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
     case DEMANGLE_COMPONENT_UNARY:
     case DEMANGLE_COMPONENT_BINARY:
     case DEMANGLE_COMPONENT_BINARY_ARGS:
     case DEMANGLE_COMPONENT_TRINARY:
     case DEMANGLE_COMPONENT_TRINARY_ARG1:
     case DEMANGLE_COMPONENT_LITERAL:
     case DEMANGLE_COMPONENT_LITERAL_NEG:
     case DEMANGLE_COMPONENT_COMPOUND_NAME:
     case DEMANGLE_COMPONENT_VECTOR_TYPE:
     case DEMANGLE_COMPONENT_CLONE:
         if (left == NULL || right == NULL)
             return NULL;
         break;
  
         /* These types only require one parameter.  */
     case DEMANGLE_COMPONENT_VTABLE:
     case DEMANGLE_COMPONENT_VTT:
     case DEMANGLE_COMPONENT_TYPEINFO:
     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
     case DEMANGLE_COMPONENT_TYPEINFO_FN:
     case DEMANGLE_COMPONENT_THUNK:
     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
     case DEMANGLE_COMPONENT_JAVA_CLASS:
     case DEMANGLE_COMPONENT_GUARD:
     case DEMANGLE_COMPONENT_TLS_INIT:
     case DEMANGLE_COMPONENT_TLS_WRAPPER:
     case DEMANGLE_COMPONENT_REFTEMP:
     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
     case DEMANGLE_COMPONENT_POINTER:
     case DEMANGLE_COMPONENT_REFERENCE:
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
     case DEMANGLE_COMPONENT_COMPLEX:
     case DEMANGLE_COMPONENT_IMAGINARY:
     case DEMANGLE_COMPONENT_VENDOR_TYPE:
     case DEMANGLE_COMPONENT_CAST:
     case DEMANGLE_COMPONENT_CONVERSION:
     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
     case DEMANGLE_COMPONENT_DECLTYPE:
     case DEMANGLE_COMPONENT_PACK_EXPANSION:
     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
     case DEMANGLE_COMPONENT_NULLARY:
     case DEMANGLE_COMPONENT_TRINARY_ARG2:
     case DEMANGLE_COMPONENT_TPARM_OBJ:
         if (left == NULL)
             return NULL;
         break;
  
         /* This needs a right parameter, but the left parameter can be
      empty.  */
     case DEMANGLE_COMPONENT_ARRAY_TYPE:
     case DEMANGLE_COMPONENT_INITIALIZER_LIST:
         if (right == NULL)
             return NULL;
         break;
  
         /* These are allowed to have no parameters--in some cases they
      will be filled in later.  */
     case DEMANGLE_COMPONENT_FUNCTION_TYPE:
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_CONST:
     case DEMANGLE_COMPONENT_ARGLIST:
     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
     FNQUAL_COMPONENT_CASE:
         break;
  
         /* Other types should not be seen here.  */
     default:
         return NULL;
     }
  
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = type;
         p->u.s_binary.left = left;
         p->u.s_binary.right = right;
     }
     return p;
 }

Referenced by cplus_demangle_type(), d_abi_tags(), d_array_type(), d_bare_function_type(), d_clone_suffix(), d_cv_qualifiers(), d_demangle_callback(), d_encoding(), d_expr_primary(), d_expression_1(), d_exprlist(), d_java_resource(), d_local_name(), d_name(), d_operator_name(), d_parmlist(), d_pointer_to_member_type(), d_prefix(), d_ref_qualifier(), d_special_name(), d_template_args_1(), d_unqualified_name(), and d_vector_type().

◆ d_make_ctor()

static struct demangle_component * d_make_ctor	(	struct d_info *	di,
		enum gnu_v3_ctor_kinds	kind,
		struct demangle_component *	name
	)

static

Definition at line 1098 of file cp-demangle.c.

                                      {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (!cplus_demangle_fill_ctor(p, kind, name))
         return NULL;
     return p;
 }

References cplus_demangle_fill_ctor(), d_make_empty(), demangle_component::kind, NULL, and p.

Referenced by d_ctor_dtor_name().

◆ d_make_default_arg()

static struct demangle_component* d_make_default_arg	(	struct d_info *	di,
		int	num,
		struct demangle_component *	sub
	)

static

Definition at line 1084 of file cp-demangle.c.

                                     {
     struct demangle_component *p = d_make_empty(di);
     if (p) {
         p->type = DEMANGLE_COMPONENT_DEFAULT_ARG;
         p->u.s_unary_num.num = num;
         p->u.s_unary_num.sub = sub;
     }
     return p;
 }

References d_make_empty(), DEMANGLE_COMPONENT_DEFAULT_ARG, num, p, and demangle_component::sub.

Referenced by d_local_name().

◆ d_make_demangle_mangled_name()

static struct demangle_component * d_make_demangle_mangled_name	(	struct d_info *	di,
		const char *	s
	)

static

Definition at line 1020 of file cp-demangle.c.

                                                                {
     if (d_peek_char(di) != '_' || d_peek_next_char(di) != 'Z')
         return d_make_name(di, s, strlen(s));
     d_advance(di, 2);
     return d_encoding(di, 0);
 }

References d_advance, d_encoding(), d_make_name(), d_peek_char, d_peek_next_char, and s.

Referenced by d_demangle_callback().

◆ d_make_dtor()

static struct demangle_component * d_make_dtor	(	struct d_info *	di,
		enum gnu_v3_dtor_kinds	kind,
		struct demangle_component *	name
	)

static

Definition at line 1111 of file cp-demangle.c.

                                      {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (!cplus_demangle_fill_dtor(p, kind, name))
         return NULL;
     return p;
 }

References cplus_demangle_fill_dtor(), d_make_empty(), demangle_component::kind, NULL, and p.

Referenced by d_ctor_dtor_name().

◆ d_make_empty()

static struct demangle_component * d_make_empty ( struct d_info * di )

static

Definition at line 901 of file cp-demangle.c.

                                 {
     struct demangle_component *p;
  
     if (di->next_comp >= di->num_comps)
         return NULL;
     p = &di->comps[di->next_comp];
     p->d_printing = 0;
     ++di->next_comp;
     return p;
 }

References d_info::comps, d_info::next_comp, NULL, d_info::num_comps, and p.

Referenced by cplus_demangle_type(), d_lambda(), d_make_builtin_type(), d_make_character(), d_make_comp(), d_make_ctor(), d_make_default_arg(), d_make_dtor(), d_make_extended_operator(), d_make_function_param(), d_make_name(), d_make_operator(), d_make_sub(), d_make_template_param(), d_number_component(), and d_unnamed_type().

◆ d_make_extended_operator()

static struct demangle_component * d_make_extended_operator	(	struct d_info *	di,
		int	args,
		struct demangle_component *	name
	)

static

Definition at line 1073 of file cp-demangle.c.

                                      {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (!cplus_demangle_fill_extended_operator(p, args, name))
         return NULL;
     return p;
 }

References args, cplus_demangle_fill_extended_operator(), d_make_empty(), NULL, and p.

Referenced by d_operator_name().

◆ d_make_function_param()

static struct demangle_component* d_make_function_param	(	struct d_info *	di,
		int	i
	)

static

Definition at line 1138 of file cp-demangle.c.

                                                 {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = DEMANGLE_COMPONENT_FUNCTION_PARAM;
         p->u.s_number.number = i;
     }
     return p;
 }

References d_make_empty(), DEMANGLE_COMPONENT_FUNCTION_PARAM, i, NULL, and p.

Referenced by d_expression_1().

◆ d_make_name()

static struct demangle_component * d_make_name	(	struct d_info *	di,
		const char *	s,
		int	len
	)

static

Definition at line 1030 of file cp-demangle.c.

                                                        {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (!cplus_demangle_fill_name(p, s, len))
         return NULL;
     return p;
 }

References cplus_demangle_fill_name(), d_make_empty(), len, NULL, p, and s.

Referenced by cplus_demangle_type(), d_array_type(), d_clone_suffix(), d_expr_primary(), d_identifier(), d_java_resource(), d_local_name(), d_make_demangle_mangled_name(), and d_name().

◆ d_make_operator()

static struct demangle_component * d_make_operator	(	struct d_info *	di,
		const struct demangle_operator_info *	op
	)

static

Definition at line 1059 of file cp-demangle.c.

                                                                             {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = DEMANGLE_COMPONENT_OPERATOR;
         p->u.s_operator.op = op;
     }
     return p;
 }

References d_make_empty(), DEMANGLE_COMPONENT_OPERATOR, NULL, op, and p.

Referenced by d_operator_name().

◆ d_make_sub()

static struct demangle_component * d_make_sub	(	struct d_info *	di,
		const char *	name,
		int	len
	)

static

Definition at line 1152 of file cp-demangle.c.

                                                          {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = DEMANGLE_COMPONENT_SUB_STD;
         p->u.s_string.string = name;
         p->u.s_string.len = len;
     }
     return p;
 }

References d_make_empty(), DEMANGLE_COMPONENT_SUB_STD, len, name, NULL, and p.

Referenced by d_substitution().

◆ d_make_template_param()

static struct demangle_component * d_make_template_param	(	struct d_info *	di,
		int	i
	)

static

Definition at line 1124 of file cp-demangle.c.

                                                 {
     struct demangle_component *p;
  
     p = d_make_empty(di);
     if (p != NULL) {
         p->type = DEMANGLE_COMPONENT_TEMPLATE_PARAM;
         p->u.s_number.number = i;
     }
     return p;
 }

References d_make_empty(), DEMANGLE_COMPONENT_TEMPLATE_PARAM, i, NULL, and p.

Referenced by d_template_param().

◆ d_maybe_print_fold_expression()

static int d_maybe_print_fold_expression	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 4220 of file cp-demangle.c.

                                    {
     struct demangle_component *ops, *operator_, *op1, *op2;
     int save_idx;
  
     const char *fold_code = d_left(dc)->u.s_operator.op->code;
     if (fold_code[0] != 'f')
         return 0;
  
     ops = d_right(dc);
     operator_ = d_left(ops);
     op1 = d_right(ops);
     op2 = 0;
     if (op1->type == DEMANGLE_COMPONENT_TRINARY_ARG2) {
         op2 = d_right(op1);
         op1 = d_left(op1);
     }
  
     /* Print the whole pack.  */
     save_idx = dpi->pack_index;
     dpi->pack_index = -1;
  
     switch (fold_code[1]) {
         /* Unary left fold, (... + X).  */
     case 'l':
         d_append_string(dpi, "(...");
         d_print_expr_op(dpi, options, operator_);
         d_print_subexpr(dpi, options, op1);
         d_append_char(dpi, ')');
         break;
  
         /* Unary right fold, (X + ...).  */
     case 'r':
         d_append_char(dpi, '(');
         d_print_subexpr(dpi, options, op1);
         d_print_expr_op(dpi, options, operator_);
         d_append_string(dpi, "...)");
         break;
  
         /* Binary left fold, (42 + ... + X).  */
     case 'L':
         /* Binary right fold, (X + ... + 42).  */
     case 'R':
         d_append_char(dpi, '(');
         d_print_subexpr(dpi, options, op1);
         d_print_expr_op(dpi, options, operator_);
         d_append_string(dpi, "...");
         d_print_expr_op(dpi, options, operator_);
         d_print_subexpr(dpi, options, op2);
         d_append_char(dpi, ')');
         break;
     }
  
     dpi->pack_index = save_idx;
     return 1;
 }

References d_append_char(), d_append_string(), d_left, d_print_expr_op(), d_print_subexpr(), d_right, DEMANGLE_COMPONENT_TRINARY_ARG2, ops, options, d_print_info::pack_index, and demangle_component::type.

Referenced by d_print_comp_inner().

◆ d_name()

static struct demangle_component * d_name ( struct d_info * di )

static

Definition at line 1333 of file cp-demangle.c.

                           {
     char peek = d_peek_char(di);
     struct demangle_component *dc;
  
     switch (peek) {
     case 'N':
         return d_nested_name(di);
  
     case 'Z':
         return d_local_name(di);
  
     case 'U':
         return d_unqualified_name(di);
  
     case 'S': {
         int subst;
  
         if (d_peek_next_char(di) != 't') {
             dc = d_substitution(di, 0);
             subst = 1;
         } else {
             d_advance(di, 2);
             dc = d_make_comp(di, DEMANGLE_COMPONENT_QUAL_NAME,
                 d_make_name(di, "std", 3),
                 d_unqualified_name(di));
             di->expansion += 3;
             subst = 0;
         }
  
         if (d_peek_char(di) != 'I') {
             /* The grammar does not permit this case to occur if we
            called d_substitution() above (i.e., subst == 1).  We
            don't bother to check.  */
         } else {
             /* This is <template-args>, which means that we just saw
            <unscoped-template-name>, which is a substitution
            candidate if we didn't just get it from a
            substitution.  */
             if (!subst) {
                 if (!d_add_substitution(di, dc))
                     return NULL;
             }
             dc = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, dc,
                 d_template_args(di));
         }
  
         return dc;
     }
  
     case 'L':
     default:
         dc = d_unqualified_name(di);
         if (d_peek_char(di) == 'I') {
             /* This is <template-args>, which means that we just saw
          <unscoped-template-name>, which is a substitution
          candidate.  */
             if (!d_add_substitution(di, dc))
                 return NULL;
             dc = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE, dc,
                 d_template_args(di));
         }
         return dc;
     }
 }

References d_add_substitution(), d_advance, d_local_name(), d_make_comp(), d_make_name(), d_nested_name(), d_peek_char, d_peek_next_char, d_substitution(), d_template_args(), d_unqualified_name(), DEMANGLE_COMPONENT_QUAL_NAME, DEMANGLE_COMPONENT_TEMPLATE, d_info::expansion, and NULL.

Referenced by d_class_enum_type(), d_encoding(), d_local_name(), and d_special_name().

◆ d_nested_name()

static struct demangle_component * d_nested_name ( struct d_info * di )

static

Definition at line 1403 of file cp-demangle.c.

                                  {
     struct demangle_component *ret;
     struct demangle_component **pret;
     struct demangle_component *rqual;
  
     if (!d_check_char(di, 'N'))
         return NULL;
  
     pret = d_cv_qualifiers(di, &ret, 1);
     if (pret == NULL)
         return NULL;
  
     /* Parse the ref-qualifier now and then attach it
      once we have something to attach it to.  */
     rqual = d_ref_qualifier(di, NULL);
  
     *pret = d_prefix(di);
     if (*pret == NULL)
         return NULL;
  
     if (rqual) {
         d_left(rqual) = ret;
         ret = rqual;
     }
  
     if (!d_check_char(di, 'E'))
         return NULL;
  
     return ret;
 }

References d_check_char, d_cv_qualifiers(), d_left, d_prefix(), d_ref_qualifier(), and NULL.

Referenced by d_name().

◆ d_number()

static int d_number ( struct d_info * di )

static

Definition at line 1581 of file cp-demangle.c.

                             {
     int negative;
     char peek;
     int ret;
  
     negative = 0;
     peek = d_peek_char(di);
     if (peek == 'n') {
         negative = 1;
         d_advance(di, 1);
         peek = d_peek_char(di);
     }
  
     ret = 0;
     while (1) {
         if (!IS_DIGIT(peek)) {
             if (negative)
                 ret = -ret;
             return ret;
         }
         if (ret > ((INT_MAX - (peek - '0')) / 10))
             return -1;
         ret = ret * 10 + peek - '0';
         d_advance(di, 1);
         peek = d_peek_char(di);
     }
 }

References d_advance, d_peek_char, INT_MAX, and IS_DIGIT.

Referenced by cplus_demangle_type(), d_call_offset(), d_compact_number(), d_discriminator(), d_java_resource(), d_number_component(), d_source_name(), and d_special_name().

◆ d_number_component()

static struct demangle_component* d_number_component ( struct d_info * di )

static

Definition at line 1612 of file cp-demangle.c.

                                       {
     struct demangle_component *ret = d_make_empty(di);
     if (ret) {
         ret->type = DEMANGLE_COMPONENT_NUMBER;
         ret->u.s_number.number = d_number(di);
     }
     return ret;
 }

References d_make_empty(), d_number(), DEMANGLE_COMPONENT_NUMBER, demangle_component::s_number, demangle_component::type, and demangle_component::u.

Referenced by d_special_name(), and d_vector_type().

◆ d_operator_name()

static struct demangle_component * d_operator_name ( struct d_info * di )

static

Definition at line 1738 of file cp-demangle.c.

                                    {
     char c1;
     char c2;
  
     c1 = d_next_char(di);
     c2 = d_next_char(di);
     if (c1 == 'v' && IS_DIGIT(c2))
         return d_make_extended_operator(di, c2 - '0', d_source_name(di));
     else if (c1 == 'c' && c2 == 'v') {
         struct demangle_component *type;
         int was_conversion = di->is_conversion;
         struct demangle_component *res;
  
         di->is_conversion = !di->is_expression;
         type = cplus_demangle_type(di);
         if (di->is_conversion)
             res = d_make_comp(di, DEMANGLE_COMPONENT_CONVERSION, type, NULL);
         else
             res = d_make_comp(di, DEMANGLE_COMPONENT_CAST, type, NULL);
         di->is_conversion = was_conversion;
         return res;
     } else {
         /* LOW is the inclusive lower bound.  */
         int low = 0;
         /* HIGH is the exclusive upper bound.  We subtract one to ignore
      the sentinel at the end of the array.  */
         int high = ((sizeof(cplus_demangle_operators) / sizeof(cplus_demangle_operators[0])) - 1);
  
         while (1) {
             int i;
             const struct demangle_operator_info *p;
  
             i = low + (high - low) / 2;
             p = cplus_demangle_operators + i;
  
             if (c1 == p->code[0] && c2 == p->code[1])
                 return d_make_operator(di, p);
  
             if (c1 < p->code[0] || (c1 == p->code[0] && c2 < p->code[1]))
                 high = i;
             else
                 low = i + 1;
             if (low == high)
                 return NULL;
         }
     }
 }

References c1, c2, cplus_demangle_operators, cplus_demangle_type(), d_make_comp(), d_make_extended_operator(), d_make_operator(), d_next_char, d_source_name(), DEMANGLE_COMPONENT_CAST, DEMANGLE_COMPONENT_CONVERSION, i, d_info::is_conversion, IS_DIGIT, d_info::is_expression, NULL, p, and type.

Referenced by d_expression_1(), and d_unqualified_name().

◆ d_pack_length()

static int d_pack_length ( const struct demangle_component * dc )

static

Definition at line 4120 of file cp-demangle.c.

                                                    {
     int count = 0;
     while (dc && dc->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST && d_left(dc) != NULL) {
         ++count;
         dc = d_right(dc);
     }
     return count;
 }

References count, d_left, d_right, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, and demangle_component::type.

Referenced by d_args_length(), and d_print_comp_inner().

◆ d_parmlist()

static struct demangle_component * d_parmlist ( struct d_info * di )

static

Definition at line 2691 of file cp-demangle.c.

                               {
     struct demangle_component *tl;
     struct demangle_component **ptl;
  
     tl = NULL;
     ptl = &tl;
     while (1) {
         struct demangle_component *type;
  
         char peek = d_peek_char(di);
         if (peek == '\0' || peek == 'E' || peek == '.')
             break;
         if ((peek == 'R' || peek == 'O') && d_peek_next_char(di) == 'E')
             /* Function ref-qualifier, not a ref prefix for a parameter type.  */
             break;
         type = cplus_demangle_type(di);
         if (type == NULL)
             return NULL;
         *ptl = d_make_comp(di, DEMANGLE_COMPONENT_ARGLIST, type, NULL);
         if (*ptl == NULL)
             return NULL;
         ptl = &d_right(*ptl);
     }
  
     /* There should be at least one parameter type besides the optional
      return type.  A function which takes no arguments will have a
      single parameter type void.  */
     if (tl == NULL)
         return NULL;
  
     /* If we have a single parameter type void, omit it.  */
     if (d_right(tl) == NULL && d_left(tl)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE && d_left(tl)->u.s_builtin.type->print == D_PRINT_VOID) {
         di->expansion -= d_left(tl)->u.s_builtin.type->len;
         d_left(tl) = NULL;
     }
  
     return tl;
 }

References cplus_demangle_type(), d_left, d_make_comp(), d_peek_char, d_peek_next_char, D_PRINT_VOID, d_right, DEMANGLE_COMPONENT_ARGLIST, DEMANGLE_COMPONENT_BUILTIN_TYPE, d_info::expansion, NULL, type, and demangle_component::u.

Referenced by d_bare_function_type(), d_cv_qualifiers(), and d_lambda().

◆ d_pointer_to_member_type()

static struct demangle_component * d_pointer_to_member_type ( struct d_info * di )

static

Definition at line 2835 of file cp-demangle.c.

                                             {
     struct demangle_component *cl;
     struct demangle_component *mem;
  
     if (!d_check_char(di, 'M'))
         return NULL;
  
     cl = cplus_demangle_type(di);
     if (cl == NULL)
         return NULL;
  
     /* The ABI says, "The type of a non-static member function is considered
      to be different, for the purposes of substitution, from the type of a
      namespace-scope or static member function whose type appears
      similar. The types of two non-static member functions are considered
      to be different, for the purposes of substitution, if the functions
      are members of different classes. In other words, for the purposes of
      substitution, the class of which the function is a member is
      considered part of the type of function."
  
      For a pointer to member function, this call to cplus_demangle_type
      will end up adding a (possibly qualified) non-member function type to
      the substitution table, which is not correct; however, the member
      function type will never be used in a substitution, so putting the
      wrong type in the substitution table is harmless.  */
  
     mem = cplus_demangle_type(di);
     if (mem == NULL)
         return NULL;
  
     return d_make_comp(di, DEMANGLE_COMPONENT_PTRMEM_TYPE, cl, mem);
 }

References cplus_demangle_type(), d_check_char, d_make_comp(), DEMANGLE_COMPONENT_PTRMEM_TYPE, mem, and NULL.

Referenced by cplus_demangle_type().

◆ d_prefix()

static struct demangle_component * d_prefix ( struct d_info * di )

static

Definition at line 1447 of file cp-demangle.c.

                             {
     struct demangle_component *ret = NULL;
  
     while (1) {
         char peek;
         enum demangle_component_type comb_type;
         struct demangle_component *dc;
  
         peek = d_peek_char(di);
         if (peek == '\0')
             return NULL;
  
         /* The older code accepts a <local-name> here, but I don't see
      that in the grammar.  The older code does not accept a
      <template-param> here.  */
  
         comb_type = DEMANGLE_COMPONENT_QUAL_NAME;
         if (peek == 'D') {
             char peek2 = d_peek_next_char(di);
             if (peek2 == 'T' || peek2 == 't')
                 /* Decltype.  */
                 dc = cplus_demangle_type(di);
             else
                 /* Destructor name.  */
                 dc = d_unqualified_name(di);
         } else if (IS_DIGIT(peek) || IS_LOWER(peek) || peek == 'C' || peek == 'U' || peek == 'L')
             dc = d_unqualified_name(di);
         else if (peek == 'S')
             dc = d_substitution(di, 1);
         else if (peek == 'I') {
             if (ret == NULL)
                 return NULL;
             comb_type = DEMANGLE_COMPONENT_TEMPLATE;
             dc = d_template_args(di);
         } else if (peek == 'T')
             dc = d_template_param(di);
         else if (peek == 'E')
             return ret;
         else if (peek == 'M') {
             /* Initializer scope for a lambda.  We don't need to represent
          this; the normal code will just treat the variable as a type
          scope, which gives appropriate output.  */
             if (ret == NULL)
                 return NULL;
             d_advance(di, 1);
             continue;
         } else
             return NULL;
  
         if (ret == NULL)
             ret = dc;
         else
             ret = d_make_comp(di, comb_type, ret, dc);
  
         if (peek != 'S' && d_peek_char(di) != 'E') {
             if (!d_add_substitution(di, ret))
                 return NULL;
         }
     }
 }

References cplus_demangle_type(), d_add_substitution(), d_advance, d_make_comp(), d_peek_char, d_peek_next_char, d_substitution(), d_template_args(), d_template_param(), d_unqualified_name(), DEMANGLE_COMPONENT_QUAL_NAME, DEMANGLE_COMPONENT_TEMPLATE, IS_DIGIT, IS_LOWER, and NULL.

Referenced by d_nested_name().

◆ d_print_array_type()

static void d_print_array_type	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc,
		struct d_print_mod *	mods
	)

static

Definition at line 5573 of file cp-demangle.c.

                               {
     int need_space;
  
     need_space = 1;
     if (mods != NULL) {
         int need_paren;
         struct d_print_mod *p;
  
         need_paren = 0;
         for (p = mods; p != NULL; p = p->next) {
             if (!p->printed) {
                 if (p->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) {
                     need_space = 0;
                     break;
                 } else {
                     need_paren = 1;
                     need_space = 1;
                     break;
                 }
             }
         }
  
         if (need_paren)
             d_append_string(dpi, " (");
  
         d_print_mod_list(dpi, options, mods, 0);
  
         if (need_paren)
             d_append_char(dpi, ')');
     }
  
     if (need_space)
         d_append_char(dpi, ' ');
  
     d_append_char(dpi, '[');
  
     if (d_left(dc) != NULL)
         d_print_comp(dpi, options, d_left(dc));
  
     d_append_char(dpi, ']');
 }

References d_append_char(), d_append_string(), d_left, d_print_comp(), d_print_mod_list(), DEMANGLE_COMPONENT_ARRAY_TYPE, NULL, options, and p.

Referenced by d_print_comp_inner(), and d_print_mod_list().

◆ d_print_cast()

static void d_print_cast	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 5632 of file cp-demangle.c.

                                    {
     d_print_comp(dpi, options, d_left(dc));
 }

References d_left, d_print_comp(), and options.

Referenced by d_print_comp_inner().

◆ d_print_comp()

static void d_print_comp	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 5271 of file cp-demangle.c.

                                    {
     struct d_component_stack self;
     if (dc == NULL || dc->d_printing > 1 || dpi->recursion > MAX_RECURSION_COUNT) {
         d_print_error(dpi);
         return;
     }
  
     dc->d_printing++;
     dpi->recursion++;
  
     self.dc = dc;
     self.parent = dpi->component_stack;
     dpi->component_stack = &self;
  
     d_print_comp_inner(dpi, options, dc);
  
     dpi->component_stack = self.parent;
     dc->d_printing--;
     dpi->recursion--;
 }

References d_print_info::component_stack, d_print_comp_inner(), d_print_error(), demangle_component::d_printing, d_component_stack::dc, MAX_RECURSION_COUNT, NULL, options, d_component_stack::parent, and d_print_info::recursion.

Referenced by cplus_demangle_print_callback(), d_print_array_type(), d_print_cast(), d_print_comp_inner(), d_print_conversion(), d_print_expr_op(), d_print_function_type(), d_print_mod(), d_print_mod_list(), and d_print_subexpr().

◆ d_print_comp_inner()

static void d_print_comp_inner	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 4280 of file cp-demangle.c.

                                    {
     /* Magic variable to let reference smashing skip over the next modifier
      without needing to modify *dc.  */
     struct demangle_component *mod_inner = NULL;
  
     /* Variable used to store the current templates while a previously
      captured scope is used.  */
     struct d_print_template *saved_templates;
  
     /* Nonzero if templates have been stored in the above variable.  */
     int need_template_restore = 0;
  
     if (dc == NULL) {
         d_print_error(dpi);
         return;
     }
     if (d_print_saw_error(dpi))
         return;
  
     switch (dc->type) {
     case DEMANGLE_COMPONENT_NAME:
         if ((options & DMGL_JAVA) == 0)
             d_append_buffer(dpi, dc->u.s_name.s, dc->u.s_name.len);
         else
             d_print_java_identifier(dpi, dc->u.s_name.s, dc->u.s_name.len);
         return;
  
     case DEMANGLE_COMPONENT_TAGGED_NAME:
         d_print_comp(dpi, options, d_left(dc));
         d_append_string(dpi, "[abi:");
         d_print_comp(dpi, options, d_right(dc));
         d_append_char(dpi, ']');
         return;
  
     case DEMANGLE_COMPONENT_QUAL_NAME:
     case DEMANGLE_COMPONENT_LOCAL_NAME:
         d_print_comp(dpi, options, d_left(dc));
         if ((options & DMGL_JAVA) == 0)
             d_append_string(dpi, "::");
         else
             d_append_char(dpi, '.');
         {
             struct demangle_component *local_name = d_right(dc);
             if (local_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG) {
                 d_append_string(dpi, "{default arg#");
                 d_append_num(dpi, local_name->u.s_unary_num.num + 1);
                 d_append_string(dpi, "}::");
                 local_name = local_name->u.s_unary_num.sub;
             }
             d_print_comp(dpi, options, local_name);
         }
         return;
  
     case DEMANGLE_COMPONENT_TYPED_NAME: {
         struct d_print_mod *hold_modifiers;
         struct demangle_component *typed_name;
         struct d_print_mod adpm[4];
         unsigned int i;
         struct d_print_template dpt;
         dpt.next = NULL;
  
         /* Pass the name down to the type so that it can be printed in
        the right place for the type.  We also have to pass down
        any CV-qualifiers, which apply to the this parameter.  */
         hold_modifiers = dpi->modifiers;
         dpi->modifiers = 0;
         i = 0;
         typed_name = d_left(dc);
         while (typed_name != NULL) {
             if (i >= sizeof adpm / sizeof adpm[0]) {
                 d_print_error(dpi);
                 return;
             }
  
             adpm[i].next = dpi->modifiers;
             dpi->modifiers = &adpm[i];
             adpm[i].mod = typed_name;
             adpm[i].printed = 0;
             adpm[i].templates = dpi->templates;
             ++i;
  
             if (!is_fnqual_component_type(typed_name->type))
                 break;
  
             typed_name = d_left(typed_name);
         }
  
         if (typed_name == NULL) {
             d_print_error(dpi);
             return;
         }
  
         /* If typed_name is a DEMANGLE_COMPONENT_LOCAL_NAME, then
        there may be CV-qualifiers on its right argument which
        really apply here; this happens when parsing a class that
        is local to a function.  */
         if (typed_name->type == DEMANGLE_COMPONENT_LOCAL_NAME) {
             typed_name = d_right(typed_name);
             if (typed_name->type == DEMANGLE_COMPONENT_DEFAULT_ARG)
                 typed_name = typed_name->u.s_unary_num.sub;
             if (typed_name == NULL) {
                 d_print_error(dpi);
                 return;
             }
             while (is_fnqual_component_type(typed_name->type)) {
                 if (i >= sizeof adpm / sizeof adpm[0]) {
                     d_print_error(dpi);
                     return;
                 }
  
                 adpm[i] = adpm[i - 1];
                 adpm[i].next = &adpm[i - 1];
                 dpi->modifiers = &adpm[i];
  
                 adpm[i - 1].mod = typed_name;
                 adpm[i - 1].printed = 0;
                 adpm[i - 1].templates = dpi->templates;
                 ++i;
  
                 typed_name = d_left(typed_name);
             }
         }
  
         /* If typed_name is a template, then it applies to the
        function type as well.  */
         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE) {
             dpt.next = dpi->templates;
             dpi->templates = &dpt;
             dpt.template_decl = typed_name;
         }
  
         d_print_comp(dpi, options, d_right(dc));
  
         if (typed_name->type == DEMANGLE_COMPONENT_TEMPLATE)
             dpi->templates = dpt.next;
  
         /* If the modifiers didn't get printed by the type, print them
        now.  */
         while (i > 0) {
             --i;
             if (!adpm[i].printed) {
                 d_append_char(dpi, ' ');
                 d_print_mod(dpi, options, adpm[i].mod);
             }
         }
  
         dpi->modifiers = hold_modifiers;
  
         return;
     }
  
     case DEMANGLE_COMPONENT_TEMPLATE: {
         struct d_print_mod *hold_dpm;
         struct demangle_component *dcl;
         const struct demangle_component *hold_current;
  
         /* This template may need to be referenced by a cast operator
        contained in its subtree.  */
         hold_current = dpi->current_template;
         dpi->current_template = dc;
  
         /* Don't push modifiers into a template definition.  Doing so
        could give the wrong definition for a template argument.
        Instead, treat the template essentially as a name.  */
  
         hold_dpm = dpi->modifiers;
         dpi->modifiers = NULL;
  
         dcl = d_left(dc);
  
         if ((options & DMGL_JAVA) != 0 && dcl->type == DEMANGLE_COMPONENT_NAME && dcl->u.s_name.len == 6 && strncmp(dcl->u.s_name.s, "JArray", 6) == 0) {
             /* Special-case Java arrays, so that JArray<TYPE> appears
                instead as TYPE[].  */
  
             d_print_comp(dpi, options, d_right(dc));
             d_append_string(dpi, "[]");
         } else {
             d_print_comp(dpi, options, dcl);
             if (d_last_char(dpi) == '<')
                 d_append_char(dpi, ' ');
             d_append_char(dpi, '<');
             d_print_comp(dpi, options, d_right(dc));
             /* Avoid generating two consecutive '>' characters, to avoid
            the C++ syntactic ambiguity.  */
             if (d_last_char(dpi) == '>')
                 d_append_char(dpi, ' ');
             d_append_char(dpi, '>');
         }
  
         dpi->modifiers = hold_dpm;
         dpi->current_template = hold_current;
  
         return;
     }
  
     case DEMANGLE_COMPONENT_TEMPLATE_PARAM:
         if (dpi->is_lambda_arg) {
             /* Show the template parm index, as that's how g++ displays
          these, and future proofs us against potential
          '[]<typename T> (T *a, T *b) {...}'.  */
             d_append_buffer(dpi, "auto:", 5);
             d_append_num(dpi, dc->u.s_number.number + 1);
         } else {
             struct d_print_template *hold_dpt;
             struct demangle_component *a = d_lookup_template_argument(dpi, dc);
  
             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
                 a = d_index_template_argument(a, dpi->pack_index);
  
             if (a == NULL) {
                 d_print_error(dpi);
                 return;
             }
  
             /* While processing this parameter, we need to pop the list
          of templates.  This is because the template parameter may
          itself be a reference to a parameter of an outer
          template.  */
  
             hold_dpt = dpi->templates;
             dpi->templates = hold_dpt->next;
  
             d_print_comp(dpi, options, a);
  
             dpi->templates = hold_dpt;
         }
         return;
  
     case DEMANGLE_COMPONENT_TPARM_OBJ:
         d_append_string(dpi, "template parameter object for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_CTOR:
         d_print_comp(dpi, options, dc->u.s_ctor.name);
         return;
  
     case DEMANGLE_COMPONENT_DTOR:
         d_append_char(dpi, '~');
         d_print_comp(dpi, options, dc->u.s_dtor.name);
         return;
  
     case DEMANGLE_COMPONENT_VTABLE:
         d_append_string(dpi, "vtable for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_VTT:
         d_append_string(dpi, "VTT for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE:
         d_append_string(dpi, "construction vtable for ");
         d_print_comp(dpi, options, d_left(dc));
         d_append_string(dpi, "-in-");
         d_print_comp(dpi, options, d_right(dc));
         return;
  
     case DEMANGLE_COMPONENT_TYPEINFO:
         d_append_string(dpi, "typeinfo for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_TYPEINFO_NAME:
         d_append_string(dpi, "typeinfo name for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_TYPEINFO_FN:
         d_append_string(dpi, "typeinfo fn for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_THUNK:
         d_append_string(dpi, "non-virtual thunk to ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_VIRTUAL_THUNK:
         d_append_string(dpi, "virtual thunk to ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_COVARIANT_THUNK:
         d_append_string(dpi, "covariant return thunk to ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_JAVA_CLASS:
         d_append_string(dpi, "java Class for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_GUARD:
         d_append_string(dpi, "guard variable for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_TLS_INIT:
         d_append_string(dpi, "TLS init function for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_TLS_WRAPPER:
         d_append_string(dpi, "TLS wrapper function for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_REFTEMP:
         d_append_string(dpi, "reference temporary #");
         d_print_comp(dpi, options, d_right(dc));
         d_append_string(dpi, " for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_HIDDEN_ALIAS:
         d_append_string(dpi, "hidden alias for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_TRANSACTION_CLONE:
         d_append_string(dpi, "transaction clone for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_NONTRANSACTION_CLONE:
         d_append_string(dpi, "non-transaction clone for ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_SUB_STD:
         d_append_buffer(dpi, dc->u.s_string.string, dc->u.s_string.len);
         return;
  
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_CONST: {
         struct d_print_mod *pdpm;
  
         /* When printing arrays, it's possible to have cases where the
        same CV-qualifier gets pushed on the stack multiple times.
        We only need to print it once.  */
  
         for (pdpm = dpi->modifiers; pdpm != NULL; pdpm = pdpm->next) {
             if (!pdpm->printed) {
                 if (pdpm->mod->type != DEMANGLE_COMPONENT_RESTRICT && pdpm->mod->type != DEMANGLE_COMPONENT_VOLATILE && pdpm->mod->type != DEMANGLE_COMPONENT_CONST)
                     break;
                 if (pdpm->mod->type == dc->type) {
                     d_print_comp(dpi, options, d_left(dc));
                     return;
                 }
             }
         }
     }
         goto modifier;
  
     case DEMANGLE_COMPONENT_REFERENCE:
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE: {
         /* Handle reference smashing: & + && = &.  */
         struct demangle_component *sub = d_left(dc);
         if (!dpi->is_lambda_arg && sub->type == DEMANGLE_COMPONENT_TEMPLATE_PARAM) {
             struct d_saved_scope *scope = d_get_saved_scope(dpi, sub);
             struct demangle_component *a;
  
             if (scope == NULL) {
                 /* This is the first time SUB has been traversed.
            We need to capture the current templates so
            they can be restored if SUB is reentered as a
            substitution.  */
                 d_save_scope(dpi, sub);
                 if (d_print_saw_error(dpi))
                     return;
             } else {
                 const struct d_component_stack *dcse;
                 int found_self_or_parent = 0;
  
                 /* This traversal is reentering SUB as a substition.
            If we are not beneath SUB or DC in the tree then we
            need to restore SUB's template stack temporarily.  */
                 for (dcse = dpi->component_stack; dcse != NULL;
                     dcse = dcse->parent) {
                     if (dcse->dc == sub || (dcse->dc == dc && dcse != dpi->component_stack)) {
                         found_self_or_parent = 1;
                         break;
                     }
                 }
  
                 if (!found_self_or_parent) {
                     saved_templates = dpi->templates;
                     dpi->templates = scope->templates;
                     need_template_restore = 1;
                 }
             }
  
             a = d_lookup_template_argument(dpi, sub);
             if (a && a->type == DEMANGLE_COMPONENT_TEMPLATE_ARGLIST)
                 a = d_index_template_argument(a, dpi->pack_index);
  
             if (a == NULL) {
                 if (need_template_restore)
                     dpi->templates = saved_templates;
  
                 d_print_error(dpi);
                 return;
             }
  
             sub = a;
         }
  
         if (sub->type == DEMANGLE_COMPONENT_REFERENCE || sub->type == dc->type)
             dc = sub;
         else if (sub->type == DEMANGLE_COMPONENT_RVALUE_REFERENCE)
             mod_inner = d_left(sub);
     }
         /* Fall through.  */
  
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
     case DEMANGLE_COMPONENT_POINTER:
     case DEMANGLE_COMPONENT_COMPLEX:
     case DEMANGLE_COMPONENT_IMAGINARY:
     FNQUAL_COMPONENT_CASE:
     modifier : {
         /* We keep a list of modifiers on the stack.  */
         struct d_print_mod dpm;
  
         dpm.next = dpi->modifiers;
         dpi->modifiers = &dpm;
         dpm.mod = dc;
         dpm.printed = 0;
         dpm.templates = dpi->templates;
  
         if (!mod_inner)
             mod_inner = d_left(dc);
  
         d_print_comp(dpi, options, mod_inner);
  
         /* If the modifier didn't get printed by the type, print it
        now.  */
         if (!dpm.printed)
             d_print_mod(dpi, options, dc);
  
         dpi->modifiers = dpm.next;
  
         if (need_template_restore)
             dpi->templates = saved_templates;
  
         return;
     }
  
     case DEMANGLE_COMPONENT_BUILTIN_TYPE:
         if ((options & DMGL_JAVA) == 0)
             d_append_buffer(dpi, dc->u.s_builtin.type->name,
                 dc->u.s_builtin.type->len);
         else
             d_append_buffer(dpi, dc->u.s_builtin.type->java_name,
                 dc->u.s_builtin.type->java_len);
         return;
  
     case DEMANGLE_COMPONENT_VENDOR_TYPE:
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_FUNCTION_TYPE: {
         if ((options & DMGL_RET_POSTFIX) != 0)
             d_print_function_type(dpi,
                 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
                 dc, dpi->modifiers);
  
         /* Print return type if present */
         if (d_left(dc) != NULL && (options & DMGL_RET_POSTFIX) != 0)
             d_print_comp(dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
                 d_left(dc));
         else if (d_left(dc) != NULL && (options & DMGL_RET_DROP) == 0) {
             struct d_print_mod dpm;
  
             /* We must pass this type down as a modifier in order to
            print it in the right location.  */
             dpm.next = dpi->modifiers;
             dpi->modifiers = &dpm;
             dpm.mod = dc;
             dpm.printed = 0;
             dpm.templates = dpi->templates;
  
             d_print_comp(dpi, options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
                 d_left(dc));
  
             dpi->modifiers = dpm.next;
  
             if (dpm.printed)
                 return;
  
             /* In standard prefix notation, there is a space between the
            return type and the function signature.  */
             if ((options & DMGL_RET_POSTFIX) == 0)
                 d_append_char(dpi, ' ');
         }
  
         if ((options & DMGL_RET_POSTFIX) == 0)
             d_print_function_type(dpi,
                 options & ~(DMGL_RET_POSTFIX | DMGL_RET_DROP),
                 dc, dpi->modifiers);
  
         return;
     }
  
     case DEMANGLE_COMPONENT_ARRAY_TYPE: {
         struct d_print_mod *hold_modifiers;
         struct d_print_mod adpm[4];
         unsigned int i;
         struct d_print_mod *pdpm;
  
         /* We must pass this type down as a modifier in order to print
        multi-dimensional arrays correctly.  If the array itself is
        CV-qualified, we act as though the element type were
        CV-qualified.  We do this by copying the modifiers down
        rather than fiddling pointers, so that we don't wind up
        with a d_print_mod higher on the stack pointing into our
        stack frame after we return.  */
  
         hold_modifiers = dpi->modifiers;
  
         adpm[0].next = hold_modifiers;
         dpi->modifiers = &adpm[0];
         adpm[0].mod = dc;
         adpm[0].printed = 0;
         adpm[0].templates = dpi->templates;
  
         i = 1;
         pdpm = hold_modifiers;
         while (pdpm != NULL && (pdpm->mod->type == DEMANGLE_COMPONENT_RESTRICT || pdpm->mod->type == DEMANGLE_COMPONENT_VOLATILE || pdpm->mod->type == DEMANGLE_COMPONENT_CONST)) {
             if (!pdpm->printed) {
                 if (i >= sizeof adpm / sizeof adpm[0]) {
                     d_print_error(dpi);
                     return;
                 }
  
                 adpm[i] = *pdpm;
                 adpm[i].next = dpi->modifiers;
                 dpi->modifiers = &adpm[i];
                 pdpm->printed = 1;
                 ++i;
             }
  
             pdpm = pdpm->next;
         }
  
         d_print_comp(dpi, options, d_right(dc));
  
         dpi->modifiers = hold_modifiers;
  
         if (adpm[0].printed)
             return;
  
         while (i > 1) {
             --i;
             d_print_mod(dpi, options, adpm[i].mod);
         }
  
         d_print_array_type(dpi, options, dc, dpi->modifiers);
  
         return;
     }
  
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
     case DEMANGLE_COMPONENT_VECTOR_TYPE: {
         struct d_print_mod dpm;
  
         dpm.next = dpi->modifiers;
         dpi->modifiers = &dpm;
         dpm.mod = dc;
         dpm.printed = 0;
         dpm.templates = dpi->templates;
  
         d_print_comp(dpi, options, d_right(dc));
  
         /* If the modifier didn't get printed by the type, print it
        now.  */
         if (!dpm.printed)
             d_print_mod(dpi, options, dc);
  
         dpi->modifiers = dpm.next;
  
         return;
     }
  
     case DEMANGLE_COMPONENT_FIXED_TYPE:
         if (dc->u.s_fixed.sat)
             d_append_string(dpi, "_Sat ");
         /* Don't print "int _Accum".  */
         if (dc->u.s_fixed.length->u.s_builtin.type != &cplus_demangle_builtin_types['i' - 'a']) {
             d_print_comp(dpi, options, dc->u.s_fixed.length);
             d_append_char(dpi, ' ');
         }
         if (dc->u.s_fixed.accum)
             d_append_string(dpi, "_Accum");
         else
             d_append_string(dpi, "_Fract");
         return;
  
     case DEMANGLE_COMPONENT_ARGLIST:
     case DEMANGLE_COMPONENT_TEMPLATE_ARGLIST:
         if (d_left(dc) != NULL)
             d_print_comp(dpi, options, d_left(dc));
         if (d_right(dc) != NULL) {
             size_t len;
             unsigned long int flush_count;
             /* Make sure ", " isn't flushed by d_append_string, otherwise
          dpi->len -= 2 wouldn't work.  */
             if (dpi->len >= sizeof(dpi->buf) - 2)
                 d_print_flush(dpi);
             d_append_string(dpi, ", ");
             len = dpi->len;
             flush_count = dpi->flush_count;
             d_print_comp(dpi, options, d_right(dc));
             /* If that didn't print anything (which can happen with empty
          template argument packs), remove the comma and space.  */
             if (dpi->flush_count == flush_count && dpi->len == len)
                 dpi->len -= 2;
         }
         return;
  
     case DEMANGLE_COMPONENT_INITIALIZER_LIST: {
         struct demangle_component *type = d_left(dc);
         struct demangle_component *list = d_right(dc);
  
         if (type)
             d_print_comp(dpi, options, type);
         d_append_char(dpi, '{');
         d_print_comp(dpi, options, list);
         d_append_char(dpi, '}');
     }
         return;
  
     case DEMANGLE_COMPONENT_OPERATOR: {
         const struct demangle_operator_info *op = dc->u.s_operator.op;
         int len = op->len;
  
         d_append_string(dpi, "operator");
         /* Add a space before new/delete.  */
         if (IS_LOWER(op->name[0]))
             d_append_char(dpi, ' ');
         /* Omit a trailing space.  */
         if (op->name[len - 1] == ' ')
             --len;
         d_append_buffer(dpi, op->name, len);
         return;
     }
  
     case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
         d_append_string(dpi, "operator ");
         d_print_comp(dpi, options, dc->u.s_extended_operator.name);
         return;
  
     case DEMANGLE_COMPONENT_CONVERSION:
         d_append_string(dpi, "operator ");
         d_print_conversion(dpi, options, dc);
         return;
  
     case DEMANGLE_COMPONENT_NULLARY:
         d_print_expr_op(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_UNARY: {
         struct demangle_component *op = d_left(dc);
         struct demangle_component *operand = d_right(dc);
         const char *code = NULL;
  
         if (op->type == DEMANGLE_COMPONENT_OPERATOR) {
             code = op->u.s_operator.op->code;
             if (!strcmp(code, "ad")) {
                 /* Don't print the argument list for the address of a
            function.  */
                 if (operand->type == DEMANGLE_COMPONENT_TYPED_NAME && d_left(operand)->type == DEMANGLE_COMPONENT_QUAL_NAME && d_right(operand)->type == DEMANGLE_COMPONENT_FUNCTION_TYPE)
                     operand = d_left(operand);
             }
             if (operand->type == DEMANGLE_COMPONENT_BINARY_ARGS) {
                 /* This indicates a suffix operator.  */
                 operand = d_left(operand);
                 d_print_subexpr(dpi, options, operand);
                 d_print_expr_op(dpi, options, op);
                 return;
             }
         }
  
         /* For sizeof..., just print the pack length.  */
         if (code && !strcmp(code, "sZ")) {
             struct demangle_component *a = d_find_pack(dpi, operand);
             int len = d_pack_length(a);
             d_append_num(dpi, len);
             return;
         } else if (code && !strcmp(code, "sP")) {
             int len = d_args_length(dpi, operand);
             d_append_num(dpi, len);
             return;
         }
  
         if (op->type != DEMANGLE_COMPONENT_CAST)
             d_print_expr_op(dpi, options, op);
         else {
             d_append_char(dpi, '(');
             d_print_cast(dpi, options, op);
             d_append_char(dpi, ')');
         }
         if (code && !strcmp(code, "gs"))
             /* Avoid parens after '::'.  */
             d_print_comp(dpi, options, operand);
         else if (code && !strcmp(code, "st"))
         /* Always print parens for sizeof (type).  */
         {
             d_append_char(dpi, '(');
             d_print_comp(dpi, options, operand);
             d_append_char(dpi, ')');
         } else
             d_print_subexpr(dpi, options, operand);
     }
         return;
  
     case DEMANGLE_COMPONENT_BINARY:
         if (d_right(dc)->type != DEMANGLE_COMPONENT_BINARY_ARGS) {
             d_print_error(dpi);
             return;
         }
  
         if (op_is_new_cast(d_left(dc))) {
             d_print_expr_op(dpi, options, d_left(dc));
             d_append_char(dpi, '<');
             d_print_comp(dpi, options, d_left(d_right(dc)));
             d_append_string(dpi, ">(");
             d_print_comp(dpi, options, d_right(d_right(dc)));
             d_append_char(dpi, ')');
             return;
         }
  
         if (d_maybe_print_fold_expression(dpi, options, dc))
             return;
  
         /* We wrap an expression which uses the greater-than operator in
      an extra layer of parens so that it does not get confused
      with the '>' which ends the template parameters.  */
         if (d_left(dc)->type == DEMANGLE_COMPONENT_OPERATOR && d_left(dc)->u.s_operator.op->len == 1 && d_left(dc)->u.s_operator.op->name[0] == '>')
             d_append_char(dpi, '(');
  
         if (strcmp(d_left(dc)->u.s_operator.op->code, "cl") == 0 && d_left(d_right(dc))->type == DEMANGLE_COMPONENT_TYPED_NAME) {
             /* Function call used in an expression should not have printed types
          of the function arguments.  Values of the function arguments still
          get printed below.  */
  
             const struct demangle_component *func = d_left(d_right(dc));
  
             if (d_right(func)->type != DEMANGLE_COMPONENT_FUNCTION_TYPE)
                 d_print_error(dpi);
             d_print_subexpr(dpi, options, d_left(func));
         } else
             d_print_subexpr(dpi, options, d_left(d_right(dc)));
         if (strcmp(d_left(dc)->u.s_operator.op->code, "ix") == 0) {
             d_append_char(dpi, '[');
             d_print_comp(dpi, options, d_right(d_right(dc)));
             d_append_char(dpi, ']');
         } else {
             if (strcmp(d_left(dc)->u.s_operator.op->code, "cl") != 0)
                 d_print_expr_op(dpi, options, d_left(dc));
             d_print_subexpr(dpi, options, d_right(d_right(dc)));
         }
  
         if (d_left(dc)->type == DEMANGLE_COMPONENT_OPERATOR && d_left(dc)->u.s_operator.op->len == 1 && d_left(dc)->u.s_operator.op->name[0] == '>')
             d_append_char(dpi, ')');
  
         return;
  
     case DEMANGLE_COMPONENT_BINARY_ARGS:
         /* We should only see this as part of DEMANGLE_COMPONENT_BINARY.  */
         d_print_error(dpi);
         return;
  
     case DEMANGLE_COMPONENT_TRINARY:
         if (d_right(dc)->type != DEMANGLE_COMPONENT_TRINARY_ARG1 || d_right(d_right(dc))->type != DEMANGLE_COMPONENT_TRINARY_ARG2) {
             d_print_error(dpi);
             return;
         }
         if (d_maybe_print_fold_expression(dpi, options, dc))
             return;
         {
             struct demangle_component *op = d_left(dc);
             struct demangle_component *first = d_left(d_right(dc));
             struct demangle_component *second = d_left(d_right(d_right(dc)));
             struct demangle_component *third = d_right(d_right(d_right(dc)));
  
             if (!strcmp(op->u.s_operator.op->code, "qu")) {
                 d_print_subexpr(dpi, options, first);
                 d_print_expr_op(dpi, options, op);
                 d_print_subexpr(dpi, options, second);
                 d_append_string(dpi, " : ");
                 d_print_subexpr(dpi, options, third);
             } else {
                 d_append_string(dpi, "new ");
                 if (d_left(first) != NULL) {
                     d_print_subexpr(dpi, options, first);
                     d_append_char(dpi, ' ');
                 }
                 d_print_comp(dpi, options, second);
                 if (third)
                     d_print_subexpr(dpi, options, third);
             }
         }
         return;
  
     case DEMANGLE_COMPONENT_TRINARY_ARG1:
     case DEMANGLE_COMPONENT_TRINARY_ARG2:
         /* We should only see these are part of DEMANGLE_COMPONENT_TRINARY.  */
         d_print_error(dpi);
         return;
  
     case DEMANGLE_COMPONENT_LITERAL:
     case DEMANGLE_COMPONENT_LITERAL_NEG: {
         enum d_builtin_type_print tp;
  
         /* For some builtin types, produce simpler output.  */
         tp = D_PRINT_DEFAULT;
         if (d_left(dc)->type == DEMANGLE_COMPONENT_BUILTIN_TYPE) {
             tp = d_left(dc)->u.s_builtin.type->print;
             switch (tp) {
             case D_PRINT_INT:
             case D_PRINT_UNSIGNED:
             case D_PRINT_LONG:
             case D_PRINT_UNSIGNED_LONG:
             case D_PRINT_LONG_LONG:
             case D_PRINT_UNSIGNED_LONG_LONG:
                 if (d_right(dc)->type == DEMANGLE_COMPONENT_NAME) {
                     if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
                         d_append_char(dpi, '-');
                     d_print_comp(dpi, options, d_right(dc));
                     switch (tp) {
                     default:
                         break;
                     case D_PRINT_UNSIGNED:
                         d_append_char(dpi, 'u');
                         break;
                     case D_PRINT_LONG:
                         d_append_char(dpi, 'l');
                         break;
                     case D_PRINT_UNSIGNED_LONG:
                         d_append_string(dpi, "ul");
                         break;
                     case D_PRINT_LONG_LONG:
                         d_append_string(dpi, "ll");
                         break;
                     case D_PRINT_UNSIGNED_LONG_LONG:
                         d_append_string(dpi, "ull");
                         break;
                     }
                     return;
                 }
                 break;
  
             case D_PRINT_BOOL:
                 if (d_right(dc)->type == DEMANGLE_COMPONENT_NAME && d_right(dc)->u.s_name.len == 1 && dc->type == DEMANGLE_COMPONENT_LITERAL) {
                     switch (d_right(dc)->u.s_name.s[0]) {
                     case '0':
                         d_append_string(dpi, "false");
                         return;
                     case '1':
                         d_append_string(dpi, "true");
                         return;
                     default:
                         break;
                     }
                 }
                 break;
  
             default:
                 break;
             }
         }
  
         d_append_char(dpi, '(');
         d_print_comp(dpi, options, d_left(dc));
         d_append_char(dpi, ')');
         if (dc->type == DEMANGLE_COMPONENT_LITERAL_NEG)
             d_append_char(dpi, '-');
         if (tp == D_PRINT_FLOAT)
             d_append_char(dpi, '[');
         d_print_comp(dpi, options, d_right(dc));
         if (tp == D_PRINT_FLOAT)
             d_append_char(dpi, ']');
     }
         return;
  
     case DEMANGLE_COMPONENT_NUMBER:
         d_append_num(dpi, dc->u.s_number.number);
         return;
  
     case DEMANGLE_COMPONENT_JAVA_RESOURCE:
         d_append_string(dpi, "java resource ");
         d_print_comp(dpi, options, d_left(dc));
         return;
  
     case DEMANGLE_COMPONENT_COMPOUND_NAME:
         d_print_comp(dpi, options, d_left(dc));
         d_print_comp(dpi, options, d_right(dc));
         return;
  
     case DEMANGLE_COMPONENT_CHARACTER:
         d_append_char(dpi, dc->u.s_character.character);
         return;
  
     case DEMANGLE_COMPONENT_DECLTYPE:
         d_append_string(dpi, "decltype (");
         d_print_comp(dpi, options, d_left(dc));
         d_append_char(dpi, ')');
         return;
  
     case DEMANGLE_COMPONENT_PACK_EXPANSION: {
         int len;
         int i;
         struct demangle_component *a = d_find_pack(dpi, d_left(dc));
         if (a == NULL) {
             /* d_find_pack won't find anything if the only packs involved
            in this expansion are function parameter packs; in that
            case, just print the pattern and "...".  */
             d_print_subexpr(dpi, options, d_left(dc));
             d_append_string(dpi, "...");
             return;
         }
  
         len = d_pack_length(a);
         dc = d_left(dc);
         for (i = 0; i < len; ++i) {
             dpi->pack_index = i;
             d_print_comp(dpi, options, dc);
             if (i < len - 1)
                 d_append_string(dpi, ", ");
         }
     }
         return;
  
     case DEMANGLE_COMPONENT_FUNCTION_PARAM: {
         long num = dc->u.s_number.number;
         if (num == 0)
             d_append_string(dpi, "this");
         else {
             d_append_string(dpi, "{parm#");
             d_append_num(dpi, num);
             d_append_char(dpi, '}');
         }
     }
         return;
  
     case DEMANGLE_COMPONENT_GLOBAL_CONSTRUCTORS:
         d_append_string(dpi, "global constructors keyed to ");
         d_print_comp(dpi, options, dc->u.s_binary.left);
         return;
  
     case DEMANGLE_COMPONENT_GLOBAL_DESTRUCTORS:
         d_append_string(dpi, "global destructors keyed to ");
         d_print_comp(dpi, options, dc->u.s_binary.left);
         return;
  
     case DEMANGLE_COMPONENT_LAMBDA:
         d_append_string(dpi, "{lambda(");
         /* Generic lambda auto parms are mangled as the template type
      parm they are.  */
         dpi->is_lambda_arg++;
         d_print_comp(dpi, options, dc->u.s_unary_num.sub);
         dpi->is_lambda_arg--;
         d_append_string(dpi, ")#");
         d_append_num(dpi, dc->u.s_unary_num.num + 1);
         d_append_char(dpi, '}');
         return;
  
     case DEMANGLE_COMPONENT_UNNAMED_TYPE:
         d_append_string(dpi, "{unnamed type#");
         d_append_num(dpi, dc->u.s_number.number + 1);
         d_append_char(dpi, '}');
         return;
  
     case DEMANGLE_COMPONENT_CLONE:
         d_print_comp(dpi, options, d_left(dc));
         d_append_string(dpi, " [clone ");
         d_print_comp(dpi, options, d_right(dc));
         d_append_char(dpi, ']');
         return;
  
     default:
         d_print_error(dpi);
         return;
     }
 }

Referenced by d_print_comp().

◆ d_print_conversion()

static void d_print_conversion	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 5640 of file cp-demangle.c.

                                    {
     struct d_print_template dpt = { 0 };
  
     /* For a conversion operator, we need the template parameters from
      the enclosing template in scope for processing the type.  */
     if (dpi->current_template != NULL) {
         dpt.next = dpi->templates;
         dpi->templates = &dpt;
         dpt.template_decl = dpi->current_template;
     }
  
     if (d_left(dc)->type != DEMANGLE_COMPONENT_TEMPLATE) {
         d_print_comp(dpi, options, d_left(dc));
         if (dpi->current_template != NULL)
             dpi->templates = dpt.next;
     } else {
         d_print_comp(dpi, options, d_left(d_left(dc)));
  
         /* For a templated cast operator, we need to remove the template
      parameters from scope after printing the operator name,
      so we need to handle the template printing here.  */
         if (dpi->current_template != NULL)
             dpi->templates = dpt.next;
  
         if (d_last_char(dpi) == '<')
             d_append_char(dpi, ' ');
         d_append_char(dpi, '<');
         d_print_comp(dpi, options, d_right(d_left(dc)));
         /* Avoid generating two consecutive '>' characters, to avoid
      the C++ syntactic ambiguity.  */
         if (d_last_char(dpi) == '>')
             d_append_char(dpi, ' ');
         d_append_char(dpi, '>');
     }
 }

References d_print_info::current_template, d_append_char(), d_last_char(), d_left, d_print_comp(), d_right, DEMANGLE_COMPONENT_TEMPLATE, d_print_template::next, NULL, options, d_print_template::template_decl, d_print_info::templates, and type.

Referenced by d_print_comp_inner().

◆ d_print_error()

static void d_print_error ( struct d_print_info * dpi )

inlinestatic

Definition at line 3902 of file cp-demangle.c.

                                         {
     dpi->demangle_failure = 1;
 }

References d_print_info::demangle_failure.

Referenced by d_lookup_template_argument(), d_print_comp(), d_print_comp_inner(), and d_save_scope().

◆ d_print_expr_op()

static void d_print_expr_op	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 5620 of file cp-demangle.c.

                                    {
     if (dc->type == DEMANGLE_COMPONENT_OPERATOR)
         d_append_buffer(dpi, dc->u.s_operator.op->name,
             dc->u.s_operator.op->len);
     else
         d_print_comp(dpi, options, dc);
 }

References d_append_buffer(), d_print_comp(), DEMANGLE_COMPONENT_OPERATOR, options, demangle_component::s_operator, demangle_component::type, and demangle_component::u.

Referenced by d_maybe_print_fold_expression(), and d_print_comp_inner().

◆ d_print_flush()

static void d_print_flush ( struct d_print_info * dpi )

inlinestatic

Definition at line 3914 of file cp-demangle.c.

                                         {
     dpi->buf[dpi->len] = '\0';
     dpi->callback(dpi->buf, dpi->len, dpi->opaque);
     dpi->len = 0;
     dpi->flush_count++;
 }

References d_print_info::buf, d_print_info::callback, d_print_info::flush_count, d_print_info::len, and d_print_info::opaque.

Referenced by cplus_demangle_print_callback(), d_append_char(), and d_print_comp_inner().

◆ d_print_function_type()

static void d_print_function_type	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc,
		struct d_print_mod *	mods
	)

static

Definition at line 5501 of file cp-demangle.c.

                               {
     int need_paren;
     int need_space;
     struct d_print_mod *p;
     struct d_print_mod *hold_modifiers;
  
     need_paren = 0;
     need_space = 0;
     for (p = mods; p != NULL; p = p->next) {
         if (p->printed)
             break;
  
         switch (p->mod->type) {
         case DEMANGLE_COMPONENT_POINTER:
         case DEMANGLE_COMPONENT_REFERENCE:
         case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
             need_paren = 1;
             break;
         case DEMANGLE_COMPONENT_RESTRICT:
         case DEMANGLE_COMPONENT_VOLATILE:
         case DEMANGLE_COMPONENT_CONST:
         case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
         case DEMANGLE_COMPONENT_COMPLEX:
         case DEMANGLE_COMPONENT_IMAGINARY:
         case DEMANGLE_COMPONENT_PTRMEM_TYPE:
             need_space = 1;
             need_paren = 1;
             break;
         FNQUAL_COMPONENT_CASE:
             break;
         default:
             break;
         }
         if (need_paren)
             break;
     }
  
     if (need_paren) {
         if (!need_space) {
             if (d_last_char(dpi) != '(' && d_last_char(dpi) != '*')
                 need_space = 1;
         }
         if (need_space && d_last_char(dpi) != ' ')
             d_append_char(dpi, ' ');
         d_append_char(dpi, '(');
     }
  
     hold_modifiers = dpi->modifiers;
     dpi->modifiers = NULL;
  
     d_print_mod_list(dpi, options, mods, 0);
  
     if (need_paren)
         d_append_char(dpi, ')');
  
     d_append_char(dpi, '(');
  
     if (d_right(dc) != NULL)
         d_print_comp(dpi, options, d_right(dc));
  
     d_append_char(dpi, ')');
  
     d_print_mod_list(dpi, options, mods, 1);
  
     dpi->modifiers = hold_modifiers;
 }

References d_append_char(), d_last_char(), d_print_comp(), d_print_mod_list(), d_right, DEMANGLE_COMPONENT_COMPLEX, DEMANGLE_COMPONENT_CONST, DEMANGLE_COMPONENT_IMAGINARY, DEMANGLE_COMPONENT_POINTER, DEMANGLE_COMPONENT_PTRMEM_TYPE, DEMANGLE_COMPONENT_REFERENCE, DEMANGLE_COMPONENT_RESTRICT, DEMANGLE_COMPONENT_RVALUE_REFERENCE, DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL, DEMANGLE_COMPONENT_VOLATILE, FNQUAL_COMPONENT_CASE, d_print_info::modifiers, NULL, options, and p.

Referenced by d_print_comp_inner(), and d_print_mod_list().

◆ d_print_init()

static void d_print_init	(	struct d_print_info *	dpi,
		demangle_callbackref	callback,
		void *	opaque,
		const struct demangle_component *	dc
	)

static

Definition at line 3866 of file cp-demangle.c.

                                                        {
     dpi->len = 0;
     dpi->last_char = '\0';
     dpi->templates = NULL;
     dpi->modifiers = NULL;
     dpi->pack_index = 0;
     dpi->flush_count = 0;
  
     dpi->callback = callback;
     dpi->opaque = opaque;
  
     dpi->demangle_failure = 0;
     dpi->recursion = 0;
     dpi->is_lambda_arg = 0;
  
     dpi->component_stack = NULL;
  
     dpi->saved_scopes = NULL;
     dpi->next_saved_scope = 0;
     dpi->num_saved_scopes = 0;
  
     dpi->copy_templates = NULL;
     dpi->next_copy_template = 0;
     dpi->num_copy_templates = 0;
  
     d_count_templates_scopes(&dpi->num_copy_templates,
         &dpi->num_saved_scopes, dc);
     dpi->num_copy_templates *= dpi->num_saved_scopes;
  
     dpi->current_template = NULL;
 }

References d_print_info::callback, d_print_info::component_stack, d_print_info::copy_templates, d_print_info::current_template, d_count_templates_scopes(), d_print_info::demangle_failure, d_print_info::flush_count, d_print_info::is_lambda_arg, d_print_info::last_char, d_print_info::len, d_print_info::modifiers, d_print_info::next_copy_template, d_print_info::next_saved_scope, NULL, d_print_info::num_copy_templates, d_print_info::num_saved_scopes, d_print_info::opaque, d_print_info::pack_index, d_print_info::recursion, d_print_info::saved_scopes, and d_print_info::templates.

Referenced by cplus_demangle_print_callback().

◆ d_print_java_identifier()

static void d_print_java_identifier	(	struct d_print_info *	dpi,
		const char *	name,
		int	len
	)

static

Definition at line 5299 of file cp-demangle.c.

                                                                              {
     const char *p;
     const char *end;
  
     end = name + len;
     for (p = name; p < end; ++p) {
         if (end - p > 3 && p[0] == '_' && p[1] == '_' && p[2] == 'U') {
             unsigned long c;
             const char *q;
  
             c = 0;
             for (q = p + 3; q < end; ++q) {
                 int dig;
  
                 if (IS_DIGIT(*q))
                     dig = *q - '0';
                 else if (*q >= 'A' && *q <= 'F')
                     dig = *q - 'A' + 10;
                 else if (*q >= 'a' && *q <= 'f')
                     dig = *q - 'a' + 10;
                 else
                     break;
  
                 c = c * 16 + dig;
             }
             /* If the Unicode character is larger than 256, we don't try
          to deal with it here.  FIXME.  */
             if (q < end && *q == '_' && c < 256) {
                 d_append_char(dpi, c);
                 p = q;
                 continue;
             }
         }
  
         d_append_char(dpi, *p);
     }
 }

References c, d_append_char(), test_evm::end, IS_DIGIT, len, and p.

Referenced by d_print_comp_inner().

◆ d_print_mod()

static void d_print_mod	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	mod
	)

static

Definition at line 5413 of file cp-demangle.c.

                                     {
     switch (mod->type) {
     case DEMANGLE_COMPONENT_RESTRICT:
     case DEMANGLE_COMPONENT_RESTRICT_THIS:
         d_append_string(dpi, " restrict");
         return;
     case DEMANGLE_COMPONENT_VOLATILE:
     case DEMANGLE_COMPONENT_VOLATILE_THIS:
         d_append_string(dpi, " volatile");
         return;
     case DEMANGLE_COMPONENT_CONST:
     case DEMANGLE_COMPONENT_CONST_THIS:
         d_append_string(dpi, " const");
         return;
     case DEMANGLE_COMPONENT_TRANSACTION_SAFE:
         d_append_string(dpi, " transaction_safe");
         return;
     case DEMANGLE_COMPONENT_NOEXCEPT:
         d_append_string(dpi, " noexcept");
         if (d_right(mod)) {
             d_append_char(dpi, '(');
             d_print_comp(dpi, options, d_right(mod));
             d_append_char(dpi, ')');
         }
         return;
     case DEMANGLE_COMPONENT_THROW_SPEC:
         d_append_string(dpi, " throw");
         if (d_right(mod)) {
             d_append_char(dpi, '(');
             d_print_comp(dpi, options, d_right(mod));
             d_append_char(dpi, ')');
         }
         return;
     case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
         d_append_char(dpi, ' ');
         d_print_comp(dpi, options, d_right(mod));
         return;
     case DEMANGLE_COMPONENT_POINTER:
         /* There is no pointer symbol in Java.  */
         if ((options & DMGL_JAVA) == 0)
             d_append_char(dpi, '*');
         return;
     case DEMANGLE_COMPONENT_REFERENCE_THIS:
         /* For the ref-qualifier, put a space before the &.  */
         d_append_char(dpi, ' ');
         /* FALLTHRU */
     case DEMANGLE_COMPONENT_REFERENCE:
         d_append_char(dpi, '&');
         return;
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
         d_append_char(dpi, ' ');
         /* FALLTHRU */
     case DEMANGLE_COMPONENT_RVALUE_REFERENCE:
         d_append_string(dpi, "&&");
         return;
     case DEMANGLE_COMPONENT_COMPLEX:
         d_append_string(dpi, "complex ");
         return;
     case DEMANGLE_COMPONENT_IMAGINARY:
         d_append_string(dpi, "imaginary ");
         return;
     case DEMANGLE_COMPONENT_PTRMEM_TYPE:
         if (d_last_char(dpi) != '(')
             d_append_char(dpi, ' ');
         d_print_comp(dpi, options, d_left(mod));
         d_append_string(dpi, "::*");
         return;
     case DEMANGLE_COMPONENT_TYPED_NAME:
         d_print_comp(dpi, options, d_left(mod));
         return;
     case DEMANGLE_COMPONENT_VECTOR_TYPE:
         d_append_string(dpi, " __vector(");
         d_print_comp(dpi, options, d_left(mod));
         d_append_char(dpi, ')');
         return;
  
     default:
         /* Otherwise, we have something that won't go back on the
      modifier stack, so we can just print it.  */
         d_print_comp(dpi, options, mod);
         return;
     }
 }

Referenced by d_print_comp_inner(), and d_print_mod_list().

◆ d_print_mod_list()

static void d_print_mod_list	(	struct d_print_info *	dpi,
		int	options,
		struct d_print_mod *	mods,
		int	suffix
	)

static

Definition at line 5341 of file cp-demangle.c.

                                           {
     struct d_print_template *hold_dpt;
  
     if (mods == NULL || d_print_saw_error(dpi))
         return;
  
     if (mods->printed || (!suffix && (is_fnqual_component_type(mods->mod->type)))) {
         d_print_mod_list(dpi, options, mods->next, suffix);
         return;
     }
  
     mods->printed = 1;
  
     hold_dpt = dpi->templates;
     dpi->templates = mods->templates;
  
     if (mods->mod->type == DEMANGLE_COMPONENT_FUNCTION_TYPE) {
         d_print_function_type(dpi, options, mods->mod, mods->next);
         dpi->templates = hold_dpt;
         return;
     } else if (mods->mod->type == DEMANGLE_COMPONENT_ARRAY_TYPE) {
         d_print_array_type(dpi, options, mods->mod, mods->next);
         dpi->templates = hold_dpt;
         return;
     } else if (mods->mod->type == DEMANGLE_COMPONENT_LOCAL_NAME) {
         struct d_print_mod *hold_modifiers;
         struct demangle_component *dc;
  
         /* When this is on the modifier stack, we have pulled any
      qualifiers off the right argument already.  Otherwise, we
      print it as usual, but don't let the left argument see any
      modifiers.  */
  
         hold_modifiers = dpi->modifiers;
         dpi->modifiers = NULL;
         d_print_comp(dpi, options, d_left(mods->mod));
         dpi->modifiers = hold_modifiers;
  
         if ((options & DMGL_JAVA) == 0)
             d_append_string(dpi, "::");
         else
             d_append_char(dpi, '.');
  
         dc = d_right(mods->mod);
  
         if (dc->type == DEMANGLE_COMPONENT_DEFAULT_ARG) {
             d_append_string(dpi, "{default arg#");
             d_append_num(dpi, dc->u.s_unary_num.num + 1);
             d_append_string(dpi, "}::");
             dc = dc->u.s_unary_num.sub;
         }
  
         while (is_fnqual_component_type(dc->type))
             dc = d_left(dc);
  
         d_print_comp(dpi, options, dc);
  
         dpi->templates = hold_dpt;
         return;
     }
  
     d_print_mod(dpi, options, mods->mod);
  
     dpi->templates = hold_dpt;
  
     d_print_mod_list(dpi, options, mods->next, suffix);
 }

References d_append_char(), d_append_num(), d_append_string(), d_left, d_print_array_type(), d_print_comp(), d_print_function_type(), d_print_mod(), d_print_saw_error(), d_right, DEMANGLE_COMPONENT_ARRAY_TYPE, DEMANGLE_COMPONENT_DEFAULT_ARG, DEMANGLE_COMPONENT_FUNCTION_TYPE, DEMANGLE_COMPONENT_LOCAL_NAME, DMGL_JAVA, is_fnqual_component_type(), d_print_mod::mod, d_print_info::modifiers, d_print_mod::next, NULL, options, d_print_mod::printed, demangle_component::s_unary_num, suffix, d_print_mod::templates, d_print_info::templates, demangle_component::type, and demangle_component::u.

Referenced by d_print_array_type(), and d_print_function_type().

◆ d_print_saw_error()

static int d_print_saw_error ( struct d_print_info * dpi )

inlinestatic

Definition at line 3907 of file cp-demangle.c.

                                             {
     return dpi->demangle_failure != 0;
 }

References d_print_info::demangle_failure.

Referenced by cplus_demangle_print_callback(), d_print_comp_inner(), and d_print_mod_list().

◆ d_print_subexpr()

static void d_print_subexpr	(	struct d_print_info *	dpi,
		int	options,
		struct demangle_component *	dc
	)

static

Definition at line 4153 of file cp-demangle.c.

                                    {
     int simple = 0;
     if (dc && (dc->type == DEMANGLE_COMPONENT_NAME || dc->type == DEMANGLE_COMPONENT_QUAL_NAME || dc->type == DEMANGLE_COMPONENT_INITIALIZER_LIST || dc->type == DEMANGLE_COMPONENT_FUNCTION_PARAM))
         simple = 1;
     if (!simple)
         d_append_char(dpi, '(');
     d_print_comp(dpi, options, dc);
     if (!simple)
         d_append_char(dpi, ')');
 }

References d_append_char(), d_print_comp(), DEMANGLE_COMPONENT_FUNCTION_PARAM, DEMANGLE_COMPONENT_INITIALIZER_LIST, DEMANGLE_COMPONENT_NAME, DEMANGLE_COMPONENT_QUAL_NAME, options, and demangle_component::type.

Referenced by d_maybe_print_fold_expression(), and d_print_comp_inner().

◆ d_ref_qualifier()

static struct demangle_component * d_ref_qualifier	(	struct d_info *	di,
		struct demangle_component *	sub
	)

static

Definition at line 2645 of file cp-demangle.c.

                                                                    {
     struct demangle_component *ret = sub;
     char peek;
  
     peek = d_peek_char(di);
     if (peek == 'R' || peek == 'O') {
         enum demangle_component_type t;
         if (peek == 'R') {
             t = DEMANGLE_COMPONENT_REFERENCE_THIS;
             di->expansion += sizeof "&";
         } else {
             t = DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS;
             di->expansion += sizeof "&&";
         }
         d_advance(di, 1);
  
         ret = d_make_comp(di, t, ret, NULL);
     }
  
     return ret;
 }

References d_advance, d_make_comp(), d_peek_char, DEMANGLE_COMPONENT_REFERENCE_THIS, DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS, d_info::expansion, NULL, and demangle_component::sub.

Referenced by d_function_type(), and d_nested_name().

◆ d_save_scope()

static void d_save_scope	(	struct d_print_info *	dpi,
		const struct demangle_component *	container
	)

static

Definition at line 4168 of file cp-demangle.c.

                                                 {
     struct d_saved_scope *scope;
     struct d_print_template *src, **link;
  
     if (dpi->next_saved_scope >= dpi->num_saved_scopes) {
         d_print_error(dpi);
         return;
     }
     scope = &dpi->saved_scopes[dpi->next_saved_scope];
     dpi->next_saved_scope++;
  
     scope->container = container;
     link = &scope->templates;
  
     for (src = dpi->templates; src != NULL; src = src->next) {
         struct d_print_template *dst;
  
         if (dpi->next_copy_template >= dpi->num_copy_templates) {
             d_print_error(dpi);
             return;
         }
         dst = &dpi->copy_templates[dpi->next_copy_template];
         dpi->next_copy_template++;
  
         dst->template_decl = src->template_decl;
         *link = dst;
         link = &dst->next;
     }
  
     *link = NULL;
 }

References d_saved_scope::container, d_print_info::copy_templates, d_print_error(), dst, link, d_print_info::next_copy_template, d_print_info::next_saved_scope, NULL, d_print_info::num_copy_templates, d_print_info::num_saved_scopes, d_print_info::saved_scopes, src, d_saved_scope::templates, and d_print_info::templates.

Referenced by d_print_comp_inner().

◆ d_source_name()

static struct demangle_component * d_source_name ( struct d_info * di )

static

Definition at line 1566 of file cp-demangle.c.

                                  {
     int len;
     struct demangle_component *ret;
  
     len = d_number(di);
     if (len <= 0)
         return NULL;
     ret = d_identifier(di, len);
     di->last_name = ret;
     return ret;
 }

References d_identifier(), d_number(), d_info::last_name, len, and NULL.

Referenced by cplus_demangle_type(), d_abi_tags(), d_operator_name(), and d_unqualified_name().

◆ d_special_name()

static struct demangle_component * d_special_name ( struct d_info * di )

static

Definition at line 1894 of file cp-demangle.c.

                                   {
     di->expansion += 20;
     if (d_check_char(di, 'T')) {
         switch (d_next_char(di)) {
         case 'V':
             di->expansion -= 5;
             return d_make_comp(di, DEMANGLE_COMPONENT_VTABLE,
                 cplus_demangle_type(di), NULL);
         case 'T':
             di->expansion -= 10;
             return d_make_comp(di, DEMANGLE_COMPONENT_VTT,
                 cplus_demangle_type(di), NULL);
         case 'I':
             return d_make_comp(di, DEMANGLE_COMPONENT_TYPEINFO,
                 cplus_demangle_type(di), NULL);
         case 'S':
             return d_make_comp(di, DEMANGLE_COMPONENT_TYPEINFO_NAME,
                 cplus_demangle_type(di), NULL);
  
         case 'h':
             if (!d_call_offset(di, 'h'))
                 return NULL;
             return d_make_comp(di, DEMANGLE_COMPONENT_THUNK,
                 d_encoding(di, 0), NULL);
  
         case 'v':
             if (!d_call_offset(di, 'v'))
                 return NULL;
             return d_make_comp(di, DEMANGLE_COMPONENT_VIRTUAL_THUNK,
                 d_encoding(di, 0), NULL);
  
         case 'c':
             if (!d_call_offset(di, '\0'))
                 return NULL;
             if (!d_call_offset(di, '\0'))
                 return NULL;
             return d_make_comp(di, DEMANGLE_COMPONENT_COVARIANT_THUNK,
                 d_encoding(di, 0), NULL);
  
         case 'C': {
             struct demangle_component *derived_type;
             int offset;
             struct demangle_component *base_type;
  
             derived_type = cplus_demangle_type(di);
             offset = d_number(di);
             if (offset < 0)
                 return NULL;
             if (!d_check_char(di, '_'))
                 return NULL;
             base_type = cplus_demangle_type(di);
             /* We don't display the offset.  FIXME: We should display
            it in verbose mode.  */
             di->expansion += 5;
             return d_make_comp(di, DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE,
                 base_type, derived_type);
         }
  
         case 'F':
             return d_make_comp(di, DEMANGLE_COMPONENT_TYPEINFO_FN,
                 cplus_demangle_type(di), NULL);
         case 'J':
             return d_make_comp(di, DEMANGLE_COMPONENT_JAVA_CLASS,
                 cplus_demangle_type(di), NULL);
  
         case 'H':
             return d_make_comp(di, DEMANGLE_COMPONENT_TLS_INIT,
                 d_name(di), NULL);
  
         case 'W':
             return d_make_comp(di, DEMANGLE_COMPONENT_TLS_WRAPPER,
                 d_name(di), NULL);
  
         case 'A':
             return d_make_comp(di, DEMANGLE_COMPONENT_TPARM_OBJ,
                 d_template_arg(di), NULL);
  
         default:
             return NULL;
         }
     } else if (d_check_char(di, 'G')) {
         switch (d_next_char(di)) {
         case 'V':
             return d_make_comp(di, DEMANGLE_COMPONENT_GUARD,
                 d_name(di), NULL);
  
         case 'R': {
             struct demangle_component *name = d_name(di);
             return d_make_comp(di, DEMANGLE_COMPONENT_REFTEMP, name,
                 d_number_component(di));
         }
  
         case 'A':
             return d_make_comp(di, DEMANGLE_COMPONENT_HIDDEN_ALIAS,
                 d_encoding(di, 0), NULL);
  
         case 'T':
             switch (d_next_char(di)) {
             case 'n':
                 return d_make_comp(di, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE,
                     d_encoding(di, 0), NULL);
             default:
                 /* ??? The proposal is that other letters (such as 'h') stand
          for different variants of transaction cloning, such as
          compiling directly for hardware transaction support.  But
          they still should all be transactional clones of some sort
          so go ahead and call them that.  */
             case 't':
                 return d_make_comp(di, DEMANGLE_COMPONENT_TRANSACTION_CLONE,
                     d_encoding(di, 0), NULL);
             }
  
         case 'r':
             return d_java_resource(di);
  
         default:
             return NULL;
         }
     } else
         return NULL;
 }

References cplus_demangle_type(), d_call_offset(), d_check_char, d_encoding(), d_java_resource(), d_make_comp(), d_name(), d_next_char, d_number(), d_number_component(), d_template_arg(), DEMANGLE_COMPONENT_CONSTRUCTION_VTABLE, DEMANGLE_COMPONENT_COVARIANT_THUNK, DEMANGLE_COMPONENT_GUARD, DEMANGLE_COMPONENT_HIDDEN_ALIAS, DEMANGLE_COMPONENT_JAVA_CLASS, DEMANGLE_COMPONENT_NONTRANSACTION_CLONE, DEMANGLE_COMPONENT_REFTEMP, DEMANGLE_COMPONENT_THUNK, DEMANGLE_COMPONENT_TLS_INIT, DEMANGLE_COMPONENT_TLS_WRAPPER, DEMANGLE_COMPONENT_TPARM_OBJ, DEMANGLE_COMPONENT_TRANSACTION_CLONE, DEMANGLE_COMPONENT_TYPEINFO, DEMANGLE_COMPONENT_TYPEINFO_FN, DEMANGLE_COMPONENT_TYPEINFO_NAME, DEMANGLE_COMPONENT_VIRTUAL_THUNK, DEMANGLE_COMPONENT_VTABLE, DEMANGLE_COMPONENT_VTT, d_info::expansion, and NULL.

Referenced by d_encoding().

◆ d_substitution()

static struct demangle_component * d_substitution	(	struct d_info *	di,
		int	prefix
	)

static

Definition at line 3557 of file cp-demangle.c.

                                               {
     char c;
  
     if (!d_check_char(di, 'S'))
         return NULL;
  
     c = d_next_char(di);
     if (c == '_' || IS_DIGIT(c) || IS_UPPER(c)) {
         unsigned int id;
  
         id = 0;
         if (c != '_') {
             do {
                 unsigned int new_id;
  
                 if (IS_DIGIT(c))
                     new_id = id * 36 + c - '0';
                 else if (IS_UPPER(c))
                     new_id = id * 36 + c - 'A' + 10;
                 else
                     return NULL;
                 if (new_id < id)
                     return NULL;
                 id = new_id;
                 c = d_next_char(di);
             } while (c != '_');
  
             ++id;
         }
  
         if (id >= (unsigned int)di->next_sub)
             return NULL;
  
         return di->subs[id];
     } else {
         int verbose;
         const struct d_standard_sub_info *p;
         const struct d_standard_sub_info *pend;
  
         verbose = (di->options & DMGL_VERBOSE) != 0;
         if (!verbose && prefix) {
             char peek;
  
             peek = d_peek_char(di);
             if (peek == 'C' || peek == 'D')
                 verbose = 1;
         }
  
         pend = (&standard_subs[0] + sizeof standard_subs / sizeof standard_subs[0]);
         for (p = &standard_subs[0]; p < pend; ++p) {
             if (c == p->code) {
                 const char *s;
                 int len;
                 struct demangle_component *dc;
  
                 if (p->set_last_name != NULL)
                     di->last_name = d_make_sub(di, p->set_last_name,
                         p->set_last_name_len);
                 if (verbose) {
                     s = p->full_expansion;
                     len = p->full_len;
                 } else {
                     s = p->simple_expansion;
                     len = p->simple_len;
                 }
                 di->expansion += len;
                 dc = d_make_sub(di, s, len);
                 if (d_peek_char(di) == 'B') {
                     /* If there are ABI tags on the abbreviation, it becomes
              a substitution candidate.  */
                     dc = d_abi_tags(di, dc);
                     if (!d_add_substitution(di, dc))
                         return NULL;
                 }
                 return dc;
             }
         }
  
         return NULL;
     }
 }

References c, d_abi_tags(), d_add_substitution(), d_check_char, d_make_sub(), d_next_char, d_peek_char, DMGL_VERBOSE, d_info::expansion, id, IS_DIGIT, IS_UPPER, d_info::last_name, len, d_info::next_sub, NULL, d_info::options, p, prefix, s, standard_subs, d_info::subs, and verbose.

Referenced by cplus_demangle_type(), d_name(), and d_prefix().

◆ d_template_arg()

static struct demangle_component * d_template_arg ( struct d_info * di )

static

Definition at line 2964 of file cp-demangle.c.

                                   {
     struct demangle_component *ret;
  
     switch (d_peek_char(di)) {
     case 'X':
         d_advance(di, 1);
         ret = d_expression(di);
         if (!d_check_char(di, 'E'))
             return NULL;
         return ret;
  
     case 'L':
         return d_expr_primary(di);
  
     case 'I':
     case 'J':
         /* An argument pack.  */
         return d_template_args(di);
  
     default:
         return cplus_demangle_type(di);
     }
 }

References cplus_demangle_type(), d_advance, d_check_char, d_expr_primary(), d_expression(), d_peek_char, d_template_args(), and NULL.

Referenced by d_special_name(), and d_template_args_1().

◆ d_template_args()

static struct demangle_component * d_template_args ( struct d_info * di )

static

Definition at line 2906 of file cp-demangle.c.

                                    {
     if (d_peek_char(di) != 'I' && d_peek_char(di) != 'J')
         return NULL;
     d_advance(di, 1);
  
     return d_template_args_1(di);
 }

References d_advance, d_peek_char, d_template_args_1(), and NULL.

Referenced by cplus_demangle_type(), d_expression_1(), d_name(), d_prefix(), and d_template_arg().

◆ d_template_args_1()

static struct demangle_component * d_template_args_1 ( struct d_info * di )

static

Definition at line 2917 of file cp-demangle.c.

                                      {
     struct demangle_component *hold_last_name;
     struct demangle_component *al;
     struct demangle_component **pal;
  
     /* Preserve the last name we saw--don't let the template arguments
      clobber it, as that would give us the wrong name for a subsequent
      constructor or destructor.  */
     hold_last_name = di->last_name;
  
     if (d_peek_char(di) == 'E') {
         /* An argument pack can be empty.  */
         d_advance(di, 1);
         return d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, NULL, NULL);
     }
  
     al = NULL;
     pal = &al;
     while (1) {
         struct demangle_component *a;
  
         a = d_template_arg(di);
         if (a == NULL)
             return NULL;
  
         *pal = d_make_comp(di, DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, a, NULL);
         if (*pal == NULL)
             return NULL;
         pal = &d_right(*pal);
  
         if (d_peek_char(di) == 'E') {
             d_advance(di, 1);
             break;
         }
     }
  
     di->last_name = hold_last_name;
  
     return al;
 }

References a, al, d_advance, d_make_comp(), d_peek_char, d_right, d_template_arg(), DEMANGLE_COMPONENT_TEMPLATE_ARGLIST, d_info::last_name, and NULL.

Referenced by d_expression_1(), and d_template_args().

◆ d_template_param()

static struct demangle_component * d_template_param ( struct d_info * di )

static

Definition at line 2890 of file cp-demangle.c.

                                     {
     int param;
  
     if (!d_check_char(di, 'T'))
         return NULL;
  
     param = d_compact_number(di);
     if (param < 0)
         return NULL;
  
     return d_make_template_param(di, param);
 }

References d_check_char, d_compact_number(), d_make_template_param(), and NULL.

Referenced by cplus_demangle_type(), d_expression_1(), and d_prefix().

◆ d_unnamed_type()

static struct demangle_component * d_unnamed_type ( struct d_info * di )

static

Definition at line 3451 of file cp-demangle.c.

                                   {
     struct demangle_component *ret;
     int num;
  
     if (!d_check_char(di, 'U'))
         return NULL;
     if (!d_check_char(di, 't'))
         return NULL;
  
     num = d_compact_number(di);
     if (num < 0)
         return NULL;
  
     ret = d_make_empty(di);
     if (ret) {
         ret->type = DEMANGLE_COMPONENT_UNNAMED_TYPE;
         ret->u.s_number.number = num;
     }
  
     if (!d_add_substitution(di, ret))
         return NULL;
  
     return ret;
 }

References d_add_substitution(), d_check_char, d_compact_number(), d_make_empty(), DEMANGLE_COMPONENT_UNNAMED_TYPE, NULL, num, demangle_component::s_number, demangle_component::type, and demangle_component::u.

Referenced by d_unqualified_name().

◆ d_unqualified_name()

static struct demangle_component * d_unqualified_name ( struct d_info * di )

static

Definition at line 1517 of file cp-demangle.c.

                                       {
     struct demangle_component *ret;
     char peek;
  
     peek = d_peek_char(di);
     if (IS_DIGIT(peek))
         ret = d_source_name(di);
     else if (IS_LOWER(peek)) {
         if (peek == 'o' && d_peek_next_char(di) == 'n')
             d_advance(di, 2);
         ret = d_operator_name(di);
         if (ret != NULL && ret->type == DEMANGLE_COMPONENT_OPERATOR) {
             di->expansion += sizeof "operator" + ret->u.s_operator.op->len - 2;
             if (!strcmp(ret->u.s_operator.op->code, "li"))
                 ret = d_make_comp(di, DEMANGLE_COMPONENT_UNARY, ret,
                     d_source_name(di));
         }
     } else if (peek == 'C' || peek == 'D')
         ret = d_ctor_dtor_name(di);
     else if (peek == 'L') {
         d_advance(di, 1);
  
         ret = d_source_name(di);
         if (ret == NULL)
             return NULL;
         if (!d_discriminator(di))
             return NULL;
     } else if (peek == 'U') {
         switch (d_peek_next_char(di)) {
         case 'l':
             ret = d_lambda(di);
             break;
         case 't':
             ret = d_unnamed_type(di);
             break;
         default:
             return NULL;
         }
     } else
         return NULL;
  
     if (d_peek_char(di) == 'B')
         ret = d_abi_tags(di, ret);
     return ret;
 }

References d_abi_tags(), d_advance, d_ctor_dtor_name(), d_discriminator(), d_lambda(), d_make_comp(), d_operator_name(), d_peek_char, d_peek_next_char, d_source_name(), d_unnamed_type(), DEMANGLE_COMPONENT_OPERATOR, DEMANGLE_COMPONENT_UNARY, d_info::expansion, IS_DIGIT, IS_LOWER, NULL, demangle_component::s_operator, demangle_component::type, and demangle_component::u.

Referenced by d_expression_1(), d_name(), and d_prefix().

◆ d_vector_type()

static struct demangle_component * d_vector_type ( struct d_info * di )

static

Definition at line 2811 of file cp-demangle.c.

                                  {
     char peek;
     struct demangle_component *dim;
  
     peek = d_peek_char(di);
     if (peek == '_') {
         d_advance(di, 1);
         dim = d_expression(di);
     } else
         dim = d_number_component(di);
  
     if (dim == NULL)
         return NULL;
  
     if (!d_check_char(di, '_'))
         return NULL;
  
     return d_make_comp(di, DEMANGLE_COMPONENT_VECTOR_TYPE, dim,
         cplus_demangle_type(di));
 }

References cplus_demangle_type(), d_advance, d_check_char, d_expression(), d_make_comp(), d_number_component(), d_peek_char, DEMANGLE_COMPONENT_VECTOR_TYPE, and NULL.

Referenced by cplus_demangle_type().

◆ has_return_type()

static int has_return_type ( struct demangle_component * dc )

static

Definition at line 1202 of file cp-demangle.c.

                                                {
     if (dc == NULL)
         return 0;
     switch (dc->type) {
     default:
         return 0;
     case DEMANGLE_COMPONENT_LOCAL_NAME:
         return has_return_type(d_right(dc));
     case DEMANGLE_COMPONENT_TEMPLATE:
         return !is_ctor_dtor_or_conversion(d_left(dc));
     FNQUAL_COMPONENT_CASE:
         return has_return_type(d_left(dc));
     }
 }

References d_left, d_right, DEMANGLE_COMPONENT_LOCAL_NAME, DEMANGLE_COMPONENT_TEMPLATE, FNQUAL_COMPONENT_CASE, is_ctor_dtor_or_conversion(), NULL, and demangle_component::type.

Referenced by d_bare_function_type(), and d_encoding().

◆ is_ctor_dtor_or_conversion()

static int is_ctor_dtor_or_conversion ( struct demangle_component * dc )

static

Definition at line 1221 of file cp-demangle.c.

                                                           {
     if (dc == NULL)
         return 0;
     switch (dc->type) {
     default:
         return 0;
     case DEMANGLE_COMPONENT_QUAL_NAME:
     case DEMANGLE_COMPONENT_LOCAL_NAME:
         return is_ctor_dtor_or_conversion(d_right(dc));
     case DEMANGLE_COMPONENT_CTOR:
     case DEMANGLE_COMPONENT_DTOR:
     case DEMANGLE_COMPONENT_CONVERSION:
         return 1;
     }
 }

References d_right, DEMANGLE_COMPONENT_CONVERSION, DEMANGLE_COMPONENT_CTOR, DEMANGLE_COMPONENT_DTOR, DEMANGLE_COMPONENT_LOCAL_NAME, DEMANGLE_COMPONENT_QUAL_NAME, NULL, and demangle_component::type.

Referenced by has_return_type().

◆ is_ctor_or_dtor()

static int is_ctor_or_dtor	(	const char *	mangled,
		enum gnu_v3_ctor_kinds *	ctor_kind,
		enum gnu_v3_dtor_kinds *	dtor_kind
	)

static

Definition at line 5982 of file cp-demangle.c.

                                        {
     struct d_info di;
     struct demangle_component *dc;
     int ret;
  
     *ctor_kind = (enum gnu_v3_ctor_kinds)0;
     *dtor_kind = (enum gnu_v3_dtor_kinds)0;
  
     cplus_demangle_init_info(mangled, DMGL_GNU_V3, strlen(mangled), &di);
  
     {
 #ifdef CP_DYNAMIC_ARRAYS
         __extension__ struct demangle_component comps[di.num_comps];
         __extension__ struct demangle_component *subs[di.num_subs];
  
         di.comps = comps;
         di.subs = subs;
 #else
         di.comps = alloca(di.num_comps * sizeof(*di.comps));
         di.subs = alloca(di.num_subs * sizeof(*di.subs));
 #endif
  
         dc = cplus_demangle_mangled_name(&di, 1);
  
         /* Note that because we did not pass DMGL_PARAMS, we don't expect
        to demangle the entire string.  */
  
         ret = 0;
         while (dc != NULL) {
             switch (dc->type) {
                 /* These cannot appear on a constructor or destructor.  */
             case DEMANGLE_COMPONENT_RESTRICT_THIS:
             case DEMANGLE_COMPONENT_VOLATILE_THIS:
             case DEMANGLE_COMPONENT_CONST_THIS:
             case DEMANGLE_COMPONENT_REFERENCE_THIS:
             case DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS:
             default:
                 dc = NULL;
                 break;
             case DEMANGLE_COMPONENT_TYPED_NAME:
             case DEMANGLE_COMPONENT_TEMPLATE:
                 dc = d_left(dc);
                 break;
             case DEMANGLE_COMPONENT_QUAL_NAME:
             case DEMANGLE_COMPONENT_LOCAL_NAME:
                 dc = d_right(dc);
                 break;
             case DEMANGLE_COMPONENT_CTOR:
                 *ctor_kind = dc->u.s_ctor.kind;
                 ret = 1;
                 dc = NULL;
                 break;
             case DEMANGLE_COMPONENT_DTOR:
                 *dtor_kind = dc->u.s_dtor.kind;
                 ret = 1;
                 dc = NULL;
                 break;
             }
         }
     }
  
     return ret;
 }

References __extension__, alloca(), cplus_demangle_init_info(), cplus_demangle_mangled_name(), d_left, d_right, DEMANGLE_COMPONENT_CONST_THIS, DEMANGLE_COMPONENT_CTOR, DEMANGLE_COMPONENT_DTOR, DEMANGLE_COMPONENT_LOCAL_NAME, DEMANGLE_COMPONENT_QUAL_NAME, DEMANGLE_COMPONENT_REFERENCE_THIS, DEMANGLE_COMPONENT_RESTRICT_THIS, DEMANGLE_COMPONENT_RVALUE_REFERENCE_THIS, DEMANGLE_COMPONENT_TEMPLATE, DEMANGLE_COMPONENT_TYPED_NAME, DEMANGLE_COMPONENT_VOLATILE_THIS, DMGL_GNU_V3, NULL, demangle_component::s_ctor, demangle_component::s_dtor, demangle_component::type, and demangle_component::u.

◆ is_fnqual_component_type()

static int is_fnqual_component_type ( enum demangle_component_type type )

static

Definition at line 574 of file cp-demangle.c.

                                                             {
     switch (type) {
     FNQUAL_COMPONENT_CASE:
         return 1;
     default:
         break;
     }
     return 0;
 }

References FNQUAL_COMPONENT_CASE, and type.

Referenced by d_encoding(), d_print_comp_inner(), and d_print_mod_list().

◆ is_gnu_v3_mangled_ctor()

enum gnu_v3_ctor_kinds is_gnu_v3_mangled_ctor ( const char * name )

Definition at line 5982 of file cp-demangle.c.

                                          {
     enum gnu_v3_ctor_kinds ctor_kind;
     enum gnu_v3_dtor_kinds dtor_kind;
  
     if (!is_ctor_or_dtor(name, &ctor_kind, &dtor_kind))
         return (enum gnu_v3_ctor_kinds)0;
     return ctor_kind;
 }

◆ is_gnu_v3_mangled_dtor()

enum gnu_v3_dtor_kinds is_gnu_v3_mangled_dtor ( const char * name )

Definition at line 5982 of file cp-demangle.c.

                                          {
     enum gnu_v3_ctor_kinds ctor_kind;
     enum gnu_v3_dtor_kinds dtor_kind;
  
     if (!is_ctor_or_dtor(name, &ctor_kind, &dtor_kind))
         return (enum gnu_v3_dtor_kinds)0;
     return dtor_kind;
 }

◆ java_demangle_v3()

char* java_demangle_v3 ( const char * mangled )

Definition at line 5960 of file cp-demangle.c.

                                       {
     size_t alc;
  
     return d_demangle(mangled, DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX, &alc);
 }

References d_growable_string::alc, d_demangle(), DMGL_JAVA, DMGL_PARAMS, and DMGL_RET_POSTFIX.

◆ java_demangle_v3_callback()

int java_demangle_v3_callback	(	const char *	mangled,
		demangle_callbackref	callback,
		void *	opaque
	)

Definition at line 5966 of file cp-demangle.c.

                                                  {
     return d_demangle_callback(mangled,
         DMGL_JAVA | DMGL_PARAMS | DMGL_RET_POSTFIX,
         callback, opaque);
 }

References d_demangle_callback(), DMGL_JAVA, DMGL_PARAMS, and DMGL_RET_POSTFIX.

◆ next_is_type_qual()

static int next_is_type_qual ( struct d_info * di )

static

Definition at line 2140 of file cp-demangle.c.

                                      {
     char peek = d_peek_char(di);
     if (peek == 'r' || peek == 'V' || peek == 'K')
         return 1;
     if (peek == 'D') {
         peek = d_peek_next_char(di);
         if (peek == 'x' || peek == 'o' || peek == 'O' || peek == 'w')
             return 1;
     }
     return 0;
 }

References d_peek_char, and d_peek_next_char.

Referenced by cplus_demangle_type(), and d_cv_qualifiers().

◆ op_is_new_cast()

static int op_is_new_cast ( struct demangle_component * op )

static

Definition at line 3024 of file cp-demangle.c.

                                               {
     const char *code = op->u.s_operator.op->code;
     return (code[1] == 'c' && (code[0] == 's' || code[0] == 'd' || code[0] == 'c' || code[0] == 'r'));
 }

References op::code.

Referenced by d_expression_1(), and d_print_comp_inner().

Variable Documentation

◆ cplus_demangle_builtin_types

CP_STATIC_IF_GLIBCPP_V3 const struct demangle_builtin_type_info cplus_demangle_builtin_types[D_BUILTIN_TYPE_COUNT]

Definition at line 2172 of file cp-demangle.c.

Referenced by cplus_demangle_type(), and d_print_comp_inner().

◆ cplus_demangle_operators

CP_STATIC_IF_GLIBCPP_V3 const struct demangle_operator_info cplus_demangle_operators[]

Definition at line 1665 of file cp-demangle.c.

Referenced by d_operator_name().

◆ standard_subs

const struct d_standard_sub_info standard_subs[]

static

Initial value:

= {
    { 't', NL("std"),
        NL("std"),
        NULL, 0 },
    { 'a', NL("std::allocator"),
        NL("std::allocator"),
        NL("allocator") },
    { 'b', NL("std::basic_string"),
        NL("std::basic_string"),
        NL("basic_string") },
    { 's', NL("std::string"),
        NL("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
        NL("basic_string") },
    { 'i', NL("std::istream"),
        NL("std::basic_istream<char, std::char_traits<char> >"),
        NL("basic_istream") },
    { 'o', NL("std::ostream"),
        NL("std::basic_ostream<char, std::char_traits<char> >"),
        NL("basic_ostream") },
    { 'd', NL("std::iostream"),
        NL("std::basic_iostream<char, std::char_traits<char> >"),
        NL("basic_iostream") }
}

Definition at line 3503 of file cp-demangle.c.

Referenced by d_substitution().

Classes

Macros

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ANONYMOUS_NAMESPACE_PREFIX

◆ ANONYMOUS_NAMESPACE_PREFIX_LEN

◆ CP_STATIC_IF_GLIBCPP_V3

◆ d_left

◆ d_right

◆ FNQUAL_COMPONENT_CASE

◆ INT_MAX

◆ IS_DIGIT

◆ IS_LOWER

◆ IS_UPPER

◆ MAX_RECURSION_COUNT

◆ NL

Enumeration Type Documentation

◆ anonymous enum

Function Documentation

◆ alloca()

◆ cplus_demangle_fill_ctor()

◆ cplus_demangle_fill_dtor()

◆ cplus_demangle_fill_extended_operator()

◆ cplus_demangle_fill_name()

◆ cplus_demangle_init_info()

◆ cplus_demangle_mangled_name()

◆ cplus_demangle_print()

◆ cplus_demangle_print_callback()

◆ cplus_demangle_type()

◆ cplus_demangle_v3()

◆ cplus_demangle_v3_callback()

◆ d_abi_tags()

◆ d_add_substitution()

◆ d_append_buffer()

◆ d_append_char()

◆ d_append_num()

◆ d_append_string()

◆ d_args_length()

◆ d_array_type()

◆ d_backtrack()

◆ d_bare_function_type()

◆ d_call_offset()

◆ d_checkpoint()

◆ d_class_enum_type()

◆ d_clone_suffix()

◆ d_compact_number()

◆ d_count_templates_scopes()

◆ d_ctor_dtor_name()

◆ d_cv_qualifiers()

◆ d_demangle()

◆ d_demangle_callback()

◆ d_discriminator()

◆ d_encoding()

◆ d_expr_primary()

◆ d_expression()

◆ d_expression_1()

◆ d_exprlist()

◆ d_find_pack()

◆ d_function_type()

◆ d_get_saved_scope()

◆ d_growable_string_append_buffer()

◆ d_growable_string_callback_adapter()

◆ d_growable_string_init()

◆ d_growable_string_resize()

◆ d_identifier()

◆ d_index_template_argument()

◆ d_java_resource()

◆ d_lambda()

◆ d_last_char()

◆ d_local_name()

◆ d_lookup_template_argument()

◆ d_make_builtin_type()

◆ d_make_character()

◆ d_make_comp()

◆ d_make_ctor()

◆ d_make_default_arg()

◆ d_make_demangle_mangled_name()

◆ d_make_dtor()