[thirdparty/binutils-gdb.git] / gdb / d-lang.c

/* D language support routines for GDB, the GNU debugger.

   Copyright (C) 2005-2020 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "symtab.h"
#include "language.h"
#include "varobj.h"
#include "d-lang.h"
#include "c-lang.h"
#include "demangle.h"
#include "cp-support.h"
#include "gdbarch.h"

/* The name of the symbol to use to get the name of the main subprogram.  */
static const char D_MAIN[] = "D main";

/* Function returning the special symbol name used by D for the main
   procedure in the main program if it is found in minimal symbol list.
   This function tries to find minimal symbols so that it finds them even
   if the program was compiled without debugging information.  */

const char *
d_main_name (void)
{
  struct bound_minimal_symbol msym;

  msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
  if (msym.minsym != NULL)
    return D_MAIN;

  /* No known entry procedure found, the main program is probably not D.  */
  return NULL;
}

/* Implements the la_demangle language_defn routine for language D.  */

char *
d_demangle (const char *symbol, int options)
{
  return gdb_demangle (symbol, options | DMGL_DLANG);
}

/* Table mapping opcodes into strings for printing operators
   and precedences of the operators.  */
static const struct op_print d_op_print_tab[] =
{
  {",", BINOP_COMMA, PREC_COMMA, 0},
  {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
  {"||", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
  {"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
  {"|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
  {"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
  {"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
  {"==", BINOP_EQUAL, PREC_ORDER, 0},
  {"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
  {"<=", BINOP_LEQ, PREC_ORDER, 0},
  {">=", BINOP_GEQ, PREC_ORDER, 0},
  {">", BINOP_GTR, PREC_ORDER, 0},
  {"<", BINOP_LESS, PREC_ORDER, 0},
  {">>", BINOP_RSH, PREC_SHIFT, 0},
  {"<<", BINOP_LSH, PREC_SHIFT, 0},
  {"+", BINOP_ADD, PREC_ADD, 0},
  {"-", BINOP_SUB, PREC_ADD, 0},
  {"~", BINOP_CONCAT, PREC_ADD, 0},
  {"*", BINOP_MUL, PREC_MUL, 0},
  {"/", BINOP_DIV, PREC_MUL, 0},
  {"%", BINOP_REM, PREC_MUL, 0},
  {"^^", BINOP_EXP, PREC_REPEAT, 0},
  {"@", BINOP_REPEAT, PREC_REPEAT, 0},
  {"-", UNOP_NEG, PREC_PREFIX, 0},
  {"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
  {"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
  {"*", UNOP_IND, PREC_PREFIX, 0},
  {"&", UNOP_ADDR, PREC_PREFIX, 0},
  {"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
  {"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
  {"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
  {NULL, OP_NULL, PREC_PREFIX, 0}
};

/* Mapping of all D basic data types into the language vector.  */

enum d_primitive_types {
  d_primitive_type_void,
  d_primitive_type_bool,
  d_primitive_type_byte,
  d_primitive_type_ubyte,
  d_primitive_type_short,
  d_primitive_type_ushort,
  d_primitive_type_int,
  d_primitive_type_uint,
  d_primitive_type_long,
  d_primitive_type_ulong,
  d_primitive_type_cent,    /* Signed 128 bit integer.  */
  d_primitive_type_ucent,   /* Unsigned 128 bit integer.  */
  d_primitive_type_float,
  d_primitive_type_double,
  d_primitive_type_real,
  d_primitive_type_ifloat,  /* Imaginary float types.  */
  d_primitive_type_idouble,
  d_primitive_type_ireal,
  d_primitive_type_cfloat,  /* Complex number of two float values.  */
  d_primitive_type_cdouble,
  d_primitive_type_creal,
  d_primitive_type_char,    /* Unsigned character types.  */
  d_primitive_type_wchar,
  d_primitive_type_dchar,
  nr_d_primitive_types
};

/* Class representing the D language.  */

class d_language : public language_defn
{
public:
  d_language ()
    : language_defn (language_d)
  { /* Nothing.  */ }

  /* See language.h.  */

  const char *name () const override
  { return "d"; }

  /* See language.h.  */

  const char *natural_name () const override
  { return "D"; }

  /* See language.h.  */

  const std::vector<const char *> &filename_extensions () const override
  {
    static const std::vector<const char *> extensions = { ".d" };
    return extensions;
  }

  /* See language.h.  */
  void language_arch_info (struct gdbarch *gdbarch,
			   struct language_arch_info *lai) const override
  {
    const struct builtin_d_type *builtin = builtin_d_type (gdbarch);

    lai->string_char_type = builtin->builtin_char;
    lai->primitive_type_vector
      = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1,
				struct type *);

    lai->primitive_type_vector [d_primitive_type_void]
      = builtin->builtin_void;
    lai->primitive_type_vector [d_primitive_type_bool]
      = builtin->builtin_bool;
    lai->primitive_type_vector [d_primitive_type_byte]
      = builtin->builtin_byte;
    lai->primitive_type_vector [d_primitive_type_ubyte]
      = builtin->builtin_ubyte;
    lai->primitive_type_vector [d_primitive_type_short]
      = builtin->builtin_short;
    lai->primitive_type_vector [d_primitive_type_ushort]
      = builtin->builtin_ushort;
    lai->primitive_type_vector [d_primitive_type_int]
      = builtin->builtin_int;
    lai->primitive_type_vector [d_primitive_type_uint]
      = builtin->builtin_uint;
    lai->primitive_type_vector [d_primitive_type_long]
      = builtin->builtin_long;
    lai->primitive_type_vector [d_primitive_type_ulong]
      = builtin->builtin_ulong;
    lai->primitive_type_vector [d_primitive_type_cent]
      = builtin->builtin_cent;
    lai->primitive_type_vector [d_primitive_type_ucent]
      = builtin->builtin_ucent;
    lai->primitive_type_vector [d_primitive_type_float]
      = builtin->builtin_float;
    lai->primitive_type_vector [d_primitive_type_double]
      = builtin->builtin_double;
    lai->primitive_type_vector [d_primitive_type_real]
      = builtin->builtin_real;
    lai->primitive_type_vector [d_primitive_type_ifloat]
      = builtin->builtin_ifloat;
    lai->primitive_type_vector [d_primitive_type_idouble]
      = builtin->builtin_idouble;
    lai->primitive_type_vector [d_primitive_type_ireal]
      = builtin->builtin_ireal;
    lai->primitive_type_vector [d_primitive_type_cfloat]
      = builtin->builtin_cfloat;
    lai->primitive_type_vector [d_primitive_type_cdouble]
      = builtin->builtin_cdouble;
    lai->primitive_type_vector [d_primitive_type_creal]
      = builtin->builtin_creal;
    lai->primitive_type_vector [d_primitive_type_char]
      = builtin->builtin_char;
    lai->primitive_type_vector [d_primitive_type_wchar]
      = builtin->builtin_wchar;
    lai->primitive_type_vector [d_primitive_type_dchar]
      = builtin->builtin_dchar;

    lai->bool_type_symbol = "bool";
    lai->bool_type_default = builtin->builtin_bool;
  }

  /* See language.h.  */
  bool sniff_from_mangled_name (const char *mangled,
				char **demangled) const override
  {
    *demangled = d_demangle (mangled, 0);
    return *demangled != NULL;
  }

  /* See language.h.  */

  char *demangle (const char *mangled, int options) const override
  {
    return d_demangle (mangled, options);
  }

  /* See language.h.  */

  void print_type (struct type *type, const char *varstring,
		   struct ui_file *stream, int show, int level,
		   const struct type_print_options *flags) const override
  {
    c_print_type (type, varstring, stream, show, level, flags);
  }

  /* See language.h.  */

  void value_print_inner
	(struct value *val, struct ui_file *stream, int recurse,
	 const struct value_print_options *options) const override
  {
    return d_value_print_inner (val, stream, recurse, options);
  }

  /* See language.h.  */

  struct block_symbol lookup_symbol_nonlocal
	(const char *name, const struct block *block,
	 const domain_enum domain) const override
  {
    return d_lookup_symbol_nonlocal (this, name, block, domain);
  }

  /* See language.h.  */

  int parser (struct parser_state *ps) const override
  {
    return d_parse (ps);
  }

  /* See language.h.  */

  const char *name_of_this () const override
  { return "this"; }

  /* See language.h.  */

  const struct exp_descriptor *expression_ops () const override
  { return &exp_descriptor_c; }

  /* See language.h.  */

  const struct op_print *opcode_print_table () const override
  { return d_op_print_tab; }
};

/* Single instance of the D language class.  */

static d_language d_language_defn;

/* Build all D language types for the specified architecture.  */

static void *
build_d_types (struct gdbarch *gdbarch)
{
  struct builtin_d_type *builtin_d_type
    = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);

  /* Basic types.  */
  builtin_d_type->builtin_void
    = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
  builtin_d_type->builtin_bool
    = arch_boolean_type (gdbarch, 8, 1, "bool");
  builtin_d_type->builtin_byte
    = arch_integer_type (gdbarch, 8, 0, "byte");
  builtin_d_type->builtin_ubyte
    = arch_integer_type (gdbarch, 8, 1, "ubyte");
  builtin_d_type->builtin_short
    = arch_integer_type (gdbarch, 16, 0, "short");
  builtin_d_type->builtin_ushort
    = arch_integer_type (gdbarch, 16, 1, "ushort");
  builtin_d_type->builtin_int
    = arch_integer_type (gdbarch, 32, 0, "int");
  builtin_d_type->builtin_uint
    = arch_integer_type (gdbarch, 32, 1, "uint");
  builtin_d_type->builtin_long
    = arch_integer_type (gdbarch, 64, 0, "long");
  builtin_d_type->builtin_ulong
    = arch_integer_type (gdbarch, 64, 1, "ulong");
  builtin_d_type->builtin_cent
    = arch_integer_type (gdbarch, 128, 0, "cent");
  builtin_d_type->builtin_ucent
    = arch_integer_type (gdbarch, 128, 1, "ucent");
  builtin_d_type->builtin_float
    = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
		       "float", gdbarch_float_format (gdbarch));
  builtin_d_type->builtin_double
    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
		       "double", gdbarch_double_format (gdbarch));
  builtin_d_type->builtin_real
    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
		       "real", gdbarch_long_double_format (gdbarch));

  builtin_d_type->builtin_byte->set_instance_flags
    (builtin_d_type->builtin_byte->instance_flags ()
     | TYPE_INSTANCE_FLAG_NOTTEXT);

  builtin_d_type->builtin_ubyte->set_instance_flags
    (builtin_d_type->builtin_ubyte->instance_flags ()
     | TYPE_INSTANCE_FLAG_NOTTEXT);

  /* Imaginary and complex types.  */
  builtin_d_type->builtin_ifloat
    = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
		       "ifloat", gdbarch_float_format (gdbarch));
  builtin_d_type->builtin_idouble
    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
		       "idouble", gdbarch_double_format (gdbarch));
  builtin_d_type->builtin_ireal
    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
		       "ireal", gdbarch_long_double_format (gdbarch));
  builtin_d_type->builtin_cfloat
    = init_complex_type ("cfloat", builtin_d_type->builtin_float);
  builtin_d_type->builtin_cdouble
    = init_complex_type ("cdouble", builtin_d_type->builtin_double);
  builtin_d_type->builtin_creal
    = init_complex_type ("creal", builtin_d_type->builtin_real);

  /* Character types.  */
  builtin_d_type->builtin_char
    = arch_character_type (gdbarch, 8, 1, "char");
  builtin_d_type->builtin_wchar
    = arch_character_type (gdbarch, 16, 1, "wchar");
  builtin_d_type->builtin_dchar
    = arch_character_type (gdbarch, 32, 1, "dchar");

  return builtin_d_type;
}

static struct gdbarch_data *d_type_data;

/* Return the D type table for the specified architecture.  */

const struct builtin_d_type *
builtin_d_type (struct gdbarch *gdbarch)
{
  return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
}

void _initialize_d_language ();
void
_initialize_d_language ()
{
  d_type_data = gdbarch_data_register_post_init (build_d_types);
}
Commit	Line	Data
6aecb9c2 JB	1	/* D language support routines for GDB, the GNU debugger.
6aecb9c2 JB	2
b811d2c2	3	Copyright (C) 2005-2020 Free Software Foundation, Inc.
6aecb9c2 JB	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
d55e5aa6	21	#include "symtab.h"
4de283e4	22	#include "language.h"
d55e5aa6	23	#include "varobj.h"
4de283e4 TT	24	#include "d-lang.h"
	25	#include "c-lang.h"
	26	#include "demangle.h"
	27	#include "cp-support.h"
0d12e84c	28	#include "gdbarch.h"
6aecb9c2	29
63778547 IB	30	/* The name of the symbol to use to get the name of the main subprogram. */
	31	static const char D_MAIN[] = "D main";
	32
	33	/* Function returning the special symbol name used by D for the main
	34	procedure in the main program if it is found in minimal symbol list.
	35	This function tries to find minimal symbols so that it finds them even
	36	if the program was compiled without debugging information. */
	37
	38	const char *
	39	d_main_name (void)
	40	{
3b7344d5	41	struct bound_minimal_symbol msym;
63778547 IB	42
63778547 IB	43	msym = lookup_minimal_symbol (D_MAIN, NULL, NULL);
3b7344d5	44	if (msym.minsym != NULL)
63778547 IB	45	return D_MAIN;
	46
	47	/* No known entry procedure found, the main program is probably not D. */
	48	return NULL;
	49	}
	50
6aecb9c2	51	/* Implements the la_demangle language_defn routine for language D. */
ec9f644a	52
6aecb9c2 JB	53	char *
	54	d_demangle (const char *symbol, int options)
	55	{
35a49624	56	return gdb_demangle (symbol, options \| DMGL_DLANG);
6aecb9c2 JB	57	}
	58
	59	/* Table mapping opcodes into strings for printing operators
	60	and precedences of the operators. */
	61	static const struct op_print d_op_print_tab[] =
	62	{
	63	{",", BINOP_COMMA, PREC_COMMA, 0},
	64	{"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
	65	{"\|\|", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
	66	{"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
	67	{"\|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
	68	{"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
	69	{"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
3ed9baed IB	70	{"==", BINOP_EQUAL, PREC_ORDER, 0},
3ed9baed IB	71	{"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
6aecb9c2 JB	72	{"<=", BINOP_LEQ, PREC_ORDER, 0},
	73	{">=", BINOP_GEQ, PREC_ORDER, 0},
	74	{">", BINOP_GTR, PREC_ORDER, 0},
	75	{"<", BINOP_LESS, PREC_ORDER, 0},
	76	{">>", BINOP_RSH, PREC_SHIFT, 0},
	77	{"<<", BINOP_LSH, PREC_SHIFT, 0},
	78	{"+", BINOP_ADD, PREC_ADD, 0},
	79	{"-", BINOP_SUB, PREC_ADD, 0},
3ed9baed	80	{"~", BINOP_CONCAT, PREC_ADD, 0},
6aecb9c2 JB	81	{"*", BINOP_MUL, PREC_MUL, 0},
	82	{"/", BINOP_DIV, PREC_MUL, 0},
	83	{"%", BINOP_REM, PREC_MUL, 0},
3ed9baed	84	{"^^", BINOP_EXP, PREC_REPEAT, 0},
6aecb9c2 JB	85	{"@", BINOP_REPEAT, PREC_REPEAT, 0},
	86	{"-", UNOP_NEG, PREC_PREFIX, 0},
	87	{"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
	88	{"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
	89	{"*", UNOP_IND, PREC_PREFIX, 0},
	90	{"&", UNOP_ADDR, PREC_PREFIX, 0},
	91	{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
	92	{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
	93	{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
f486487f	94	{NULL, OP_NULL, PREC_PREFIX, 0}
6aecb9c2 JB	95	};
6aecb9c2 JB	96
94b1b47e IB	97	/* Mapping of all D basic data types into the language vector. */
	98
	99	enum d_primitive_types {
	100	d_primitive_type_void,
	101	d_primitive_type_bool,
	102	d_primitive_type_byte,
	103	d_primitive_type_ubyte,
	104	d_primitive_type_short,
	105	d_primitive_type_ushort,
	106	d_primitive_type_int,
	107	d_primitive_type_uint,
	108	d_primitive_type_long,
	109	d_primitive_type_ulong,
	110	d_primitive_type_cent, /* Signed 128 bit integer. */
	111	d_primitive_type_ucent, /* Unsigned 128 bit integer. */
	112	d_primitive_type_float,
	113	d_primitive_type_double,
	114	d_primitive_type_real,
	115	d_primitive_type_ifloat, /* Imaginary float types. */
	116	d_primitive_type_idouble,
	117	d_primitive_type_ireal,
	118	d_primitive_type_cfloat, /* Complex number of two float values. */
	119	d_primitive_type_cdouble,
	120	d_primitive_type_creal,
	121	d_primitive_type_char, /* Unsigned character types. */
	122	d_primitive_type_wchar,
	123	d_primitive_type_dchar,
	124	nr_d_primitive_types
	125	};
	126
0874fd07 AB	127	/* Class representing the D language. */
	128
	129	class d_language : public language_defn
	130	{
	131	public:
	132	d_language ()
0e25e767	133	: language_defn (language_d)
0874fd07	134	{ /* Nothing. */ }
1fb314aa	135
6f7664a9 AB	136	/* See language.h. */
	137
	138	const char *name () const override
	139	{ return "d"; }
	140
	141	/* See language.h. */
	142
	143	const char *natural_name () const override
	144	{ return "D"; }
	145
e171d6f1 AB	146	/* See language.h. */
	147
	148	const std::vector<const char *> &filename_extensions () const override
	149	{
	150	static const std::vector<const char *> extensions = { ".d" };
	151	return extensions;
	152	}
	153
1fb314aa AB	154	/* See language.h. */
	155	void language_arch_info (struct gdbarch *gdbarch,
	156	struct language_arch_info *lai) const override
	157	{
	158	const struct builtin_d_type *builtin = builtin_d_type (gdbarch);
	159
	160	lai->string_char_type = builtin->builtin_char;
	161	lai->primitive_type_vector
	162	= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1,
	163	struct type *);
	164
	165	lai->primitive_type_vector [d_primitive_type_void]
	166	= builtin->builtin_void;
	167	lai->primitive_type_vector [d_primitive_type_bool]
	168	= builtin->builtin_bool;
	169	lai->primitive_type_vector [d_primitive_type_byte]
	170	= builtin->builtin_byte;
	171	lai->primitive_type_vector [d_primitive_type_ubyte]
	172	= builtin->builtin_ubyte;
	173	lai->primitive_type_vector [d_primitive_type_short]
	174	= builtin->builtin_short;
	175	lai->primitive_type_vector [d_primitive_type_ushort]
	176	= builtin->builtin_ushort;
	177	lai->primitive_type_vector [d_primitive_type_int]
	178	= builtin->builtin_int;
	179	lai->primitive_type_vector [d_primitive_type_uint]
	180	= builtin->builtin_uint;
	181	lai->primitive_type_vector [d_primitive_type_long]
	182	= builtin->builtin_long;
	183	lai->primitive_type_vector [d_primitive_type_ulong]
	184	= builtin->builtin_ulong;
	185	lai->primitive_type_vector [d_primitive_type_cent]
	186	= builtin->builtin_cent;
	187	lai->primitive_type_vector [d_primitive_type_ucent]
	188	= builtin->builtin_ucent;
	189	lai->primitive_type_vector [d_primitive_type_float]
	190	= builtin->builtin_float;
	191	lai->primitive_type_vector [d_primitive_type_double]
	192	= builtin->builtin_double;
	193	lai->primitive_type_vector [d_primitive_type_real]
	194	= builtin->builtin_real;
	195	lai->primitive_type_vector [d_primitive_type_ifloat]
	196	= builtin->builtin_ifloat;
	197	lai->primitive_type_vector [d_primitive_type_idouble]
	198	= builtin->builtin_idouble;
	199	lai->primitive_type_vector [d_primitive_type_ireal]
	200	= builtin->builtin_ireal;
	201	lai->primitive_type_vector [d_primitive_type_cfloat]
	202	= builtin->builtin_cfloat;
	203	lai->primitive_type_vector [d_primitive_type_cdouble]
	204	= builtin->builtin_cdouble;
	205	lai->primitive_type_vector [d_primitive_type_creal]
	206	= builtin->builtin_creal;
	207	lai->primitive_type_vector [d_primitive_type_char]
	208	= builtin->builtin_char;
	209	lai->primitive_type_vector [d_primitive_type_wchar]
	210	= builtin->builtin_wchar;
	211	lai->primitive_type_vector [d_primitive_type_dchar]
	212	= builtin->builtin_dchar;
	213
	214	lai->bool_type_symbol = "bool";
	215	lai->bool_type_default = builtin->builtin_bool;
	216	}
6f827019 AB	217
	218	/* See language.h. */
	219	bool sniff_from_mangled_name (const char *mangled,
	220	char **demangled) const override
	221	{
	222	*demangled = d_demangle (mangled, 0);
	223	return *demangled != NULL;
	224	}
fbfb0a46 AB	225
	226	/* See language.h. */
	227
0a50df5d AB	228	char demangle (const char mangled, int options) const override
	229	{
	230	return d_demangle (mangled, options);
	231	}
	232
	233	/* See language.h. */
	234
fbfb0a46 AB	235	void print_type (struct type type, const char varstring,
	236	struct ui_file *stream, int show, int level,
	237	const struct type_print_options *flags) const override
	238	{
	239	c_print_type (type, varstring, stream, show, level, flags);
	240	}
ebe2334e AB	241
	242	/* See language.h. */
	243
	244	void value_print_inner
	245	(struct value val, struct ui_file stream, int recurse,
	246	const struct value_print_options *options) const override
	247	{
	248	return d_value_print_inner (val, stream, recurse, options);
	249	}
a78a19b1 AB	250
	251	/* See language.h. */
	252
	253	struct block_symbol lookup_symbol_nonlocal
	254	(const char name, const struct block block,
	255	const domain_enum domain) const override
	256	{
	257	return d_lookup_symbol_nonlocal (this, name, block, domain);
	258	}
87afa652 AB	259
	260	/* See language.h. */
	261
	262	int parser (struct parser_state *ps) const override
	263	{
	264	return d_parse (ps);
	265	}
5bae7c4e AB	266
	267	/* See language.h. */
	268
	269	const char *name_of_this () const override
	270	{ return "this"; }
5aba6ebe AB	271
	272	/* See language.h. */
	273
	274	const struct exp_descriptor *expression_ops () const override
	275	{ return &exp_descriptor_c; }
b7c6e27d AB	276
	277	/* See language.h. */
	278
	279	const struct op_print *opcode_print_table () const override
	280	{ return d_op_print_tab; }
0874fd07 AB	281	};
	282
	283	/* Single instance of the D language class. */
	284
	285	static d_language d_language_defn;
	286
94b1b47e IB	287	/* Build all D language types for the specified architecture. */
	288
	289	static void *
	290	build_d_types (struct gdbarch *gdbarch)
	291	{
	292	struct builtin_d_type *builtin_d_type
	293	= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
	294
	295	/* Basic types. */
	296	builtin_d_type->builtin_void
77b7c781	297	= arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
94b1b47e IB	298	builtin_d_type->builtin_bool
	299	= arch_boolean_type (gdbarch, 8, 1, "bool");
	300	builtin_d_type->builtin_byte
	301	= arch_integer_type (gdbarch, 8, 0, "byte");
	302	builtin_d_type->builtin_ubyte
	303	= arch_integer_type (gdbarch, 8, 1, "ubyte");
	304	builtin_d_type->builtin_short
	305	= arch_integer_type (gdbarch, 16, 0, "short");
	306	builtin_d_type->builtin_ushort
	307	= arch_integer_type (gdbarch, 16, 1, "ushort");
	308	builtin_d_type->builtin_int
	309	= arch_integer_type (gdbarch, 32, 0, "int");
	310	builtin_d_type->builtin_uint
	311	= arch_integer_type (gdbarch, 32, 1, "uint");
	312	builtin_d_type->builtin_long
	313	= arch_integer_type (gdbarch, 64, 0, "long");
	314	builtin_d_type->builtin_ulong
	315	= arch_integer_type (gdbarch, 64, 1, "ulong");
	316	builtin_d_type->builtin_cent
	317	= arch_integer_type (gdbarch, 128, 0, "cent");
	318	builtin_d_type->builtin_ucent
	319	= arch_integer_type (gdbarch, 128, 1, "ucent");
	320	builtin_d_type->builtin_float
	321	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	322	"float", gdbarch_float_format (gdbarch));
94b1b47e IB	323	builtin_d_type->builtin_double
94b1b47e IB	324	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	325	"double", gdbarch_double_format (gdbarch));
94b1b47e IB	326	builtin_d_type->builtin_real
94b1b47e IB	327	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	328	"real", gdbarch_long_double_format (gdbarch));
94b1b47e	329
314ad88d PA	330	builtin_d_type->builtin_byte->set_instance_flags
	331	(builtin_d_type->builtin_byte->instance_flags ()
	332	\| TYPE_INSTANCE_FLAG_NOTTEXT);
	333
	334	builtin_d_type->builtin_ubyte->set_instance_flags
	335	(builtin_d_type->builtin_ubyte->instance_flags ()
	336	\| TYPE_INSTANCE_FLAG_NOTTEXT);
94b1b47e IB	337
	338	/* Imaginary and complex types. */
	339	builtin_d_type->builtin_ifloat
	340	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	341	"ifloat", gdbarch_float_format (gdbarch));
94b1b47e IB	342	builtin_d_type->builtin_idouble
94b1b47e IB	343	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	344	"idouble", gdbarch_double_format (gdbarch));
94b1b47e IB	345	builtin_d_type->builtin_ireal
94b1b47e IB	346	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	347	"ireal", gdbarch_long_double_format (gdbarch));
94b1b47e	348	builtin_d_type->builtin_cfloat
5b930b45	349	= init_complex_type ("cfloat", builtin_d_type->builtin_float);
94b1b47e	350	builtin_d_type->builtin_cdouble
5b930b45	351	= init_complex_type ("cdouble", builtin_d_type->builtin_double);
94b1b47e	352	builtin_d_type->builtin_creal
5b930b45	353	= init_complex_type ("creal", builtin_d_type->builtin_real);
94b1b47e IB	354
	355	/* Character types. */
	356	builtin_d_type->builtin_char
	357	= arch_character_type (gdbarch, 8, 1, "char");
	358	builtin_d_type->builtin_wchar
	359	= arch_character_type (gdbarch, 16, 1, "wchar");
	360	builtin_d_type->builtin_dchar
	361	= arch_character_type (gdbarch, 32, 1, "dchar");
	362
	363	return builtin_d_type;
	364	}
	365
	366	static struct gdbarch_data *d_type_data;
	367
	368	/* Return the D type table for the specified architecture. */
	369
	370	const struct builtin_d_type *
	371	builtin_d_type (struct gdbarch *gdbarch)
	372	{
9a3c8263	373	return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
94b1b47e IB	374	}
94b1b47e IB	375
6c265988	376	void _initialize_d_language ();
6aecb9c2	377	void
6c265988	378	_initialize_d_language ()
6aecb9c2	379	{
94b1b47e	380	d_type_data = gdbarch_data_register_post_init (build_d_types);
6aecb9c2	381	}