[deliverable/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);
}

/* la_sniff_from_mangled_name implementation for D.  */

static int
d_sniff_from_mangled_name (const char *mangled, char **demangled)
{
  *demangled = d_demangle (mangled, 0);
  return *demangled != NULL;
}

/* 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
};

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

static void
d_language_arch_info (struct gdbarch *gdbarch,
		      struct language_arch_info *lai)
{
  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;
}

static const char *d_extensions[] =
{
  ".d", NULL
};

/* Constant data that describes the D language.  */

extern const struct language_data d_language_data =
{
  "d",
  "D",
  language_d,
  range_check_off,
  case_sensitive_on,
  array_row_major,
  macro_expansion_no,
  d_extensions,
  &exp_descriptor_c,
  d_parse,
  null_post_parser,
  c_printchar,			/* Print a character constant.  */
  c_printstr,			/* Function to print string constant.  */
  c_emit_char,			/* Print a single char.  */
  c_print_type,			/* Print a type using appropriate syntax.  */
  c_print_typedef,		/* Print a typedef using appropriate
				   syntax.  */
  d_value_print_inner,		/* la_value_print_inner */
  c_value_print,		/* Print a top-level value.  */
  NULL,				/* Language specific skip_trampoline.  */
  "this",
  false,			/* la_store_sym_names_in_linkage_form_p */
  d_lookup_symbol_nonlocal,
  basic_lookup_transparent_type,
  d_demangle,			/* Language specific symbol demangler.  */
  d_sniff_from_mangled_name,
  NULL,				/* Language specific
				   class_name_from_physname.  */
  d_op_print_tab,		/* Expression operators for printing.  */
  1,				/* C-style arrays.  */
  0,				/* String lower bound.  */
  default_word_break_characters,
  default_collect_symbol_completion_matches,
  d_language_arch_info,
  c_watch_location_expression,
  NULL,				/* la_get_symbol_name_matcher */
  iterate_over_symbols,
  default_search_name_hash,
  &default_varobj_ops,
  NULL,
  NULL,
  c_is_string_type_p,
  "{...}"			/* la_struct_too_deep_ellipsis */
};

/* Class representing the D language.  */

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

/* 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));

  TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
    |= TYPE_INSTANCE_FLAG_NOTTEXT;
  TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
    |= 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	}
6aecb9c2 JB	58
8b302db8 TT	59	/* la_sniff_from_mangled_name implementation for D. */
	60
	61	static int
	62	d_sniff_from_mangled_name (const char mangled, char *demangled)
	63	{
	64	*demangled = d_demangle (mangled, 0);
	65	return *demangled != NULL;
	66	}
	67
6aecb9c2 JB	68	/* Table mapping opcodes into strings for printing operators
	69	and precedences of the operators. */
	70	static const struct op_print d_op_print_tab[] =
	71	{
	72	{",", BINOP_COMMA, PREC_COMMA, 0},
	73	{"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
	74	{"\|\|", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
	75	{"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
	76	{"\|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
	77	{"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
	78	{"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
3ed9baed IB	79	{"==", BINOP_EQUAL, PREC_ORDER, 0},
3ed9baed IB	80	{"!=", BINOP_NOTEQUAL, PREC_ORDER, 0},
6aecb9c2 JB	81	{"<=", BINOP_LEQ, PREC_ORDER, 0},
	82	{">=", BINOP_GEQ, PREC_ORDER, 0},
	83	{">", BINOP_GTR, PREC_ORDER, 0},
	84	{"<", BINOP_LESS, PREC_ORDER, 0},
	85	{">>", BINOP_RSH, PREC_SHIFT, 0},
	86	{"<<", BINOP_LSH, PREC_SHIFT, 0},
	87	{"+", BINOP_ADD, PREC_ADD, 0},
	88	{"-", BINOP_SUB, PREC_ADD, 0},
3ed9baed	89	{"~", BINOP_CONCAT, PREC_ADD, 0},
6aecb9c2 JB	90	{"*", BINOP_MUL, PREC_MUL, 0},
	91	{"/", BINOP_DIV, PREC_MUL, 0},
	92	{"%", BINOP_REM, PREC_MUL, 0},
3ed9baed	93	{"^^", BINOP_EXP, PREC_REPEAT, 0},
6aecb9c2 JB	94	{"@", BINOP_REPEAT, PREC_REPEAT, 0},
	95	{"-", UNOP_NEG, PREC_PREFIX, 0},
	96	{"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
	97	{"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
	98	{"*", UNOP_IND, PREC_PREFIX, 0},
	99	{"&", UNOP_ADDR, PREC_PREFIX, 0},
	100	{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
	101	{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
	102	{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
f486487f	103	{NULL, OP_NULL, PREC_PREFIX, 0}
6aecb9c2 JB	104	};
6aecb9c2 JB	105
94b1b47e IB	106	/* Mapping of all D basic data types into the language vector. */
	107
	108	enum d_primitive_types {
	109	d_primitive_type_void,
	110	d_primitive_type_bool,
	111	d_primitive_type_byte,
	112	d_primitive_type_ubyte,
	113	d_primitive_type_short,
	114	d_primitive_type_ushort,
	115	d_primitive_type_int,
	116	d_primitive_type_uint,
	117	d_primitive_type_long,
	118	d_primitive_type_ulong,
	119	d_primitive_type_cent, /* Signed 128 bit integer. */
	120	d_primitive_type_ucent, /* Unsigned 128 bit integer. */
	121	d_primitive_type_float,
	122	d_primitive_type_double,
	123	d_primitive_type_real,
	124	d_primitive_type_ifloat, /* Imaginary float types. */
	125	d_primitive_type_idouble,
	126	d_primitive_type_ireal,
	127	d_primitive_type_cfloat, /* Complex number of two float values. */
	128	d_primitive_type_cdouble,
	129	d_primitive_type_creal,
	130	d_primitive_type_char, /* Unsigned character types. */
	131	d_primitive_type_wchar,
	132	d_primitive_type_dchar,
	133	nr_d_primitive_types
	134	};
	135
	136	/* Implements the la_language_arch_info language_defn routine
	137	for language D. */
	138
	139	static void
	140	d_language_arch_info (struct gdbarch *gdbarch,
	141	struct language_arch_info *lai)
	142	{
	143	const struct builtin_d_type *builtin = builtin_d_type (gdbarch);
	144
	145	lai->string_char_type = builtin->builtin_char;
	146	lai->primitive_type_vector
	147	= GDBARCH_OBSTACK_CALLOC (gdbarch, nr_d_primitive_types + 1,
	148	struct type *);
	149
	150	lai->primitive_type_vector [d_primitive_type_void]
	151	= builtin->builtin_void;
	152	lai->primitive_type_vector [d_primitive_type_bool]
	153	= builtin->builtin_bool;
	154	lai->primitive_type_vector [d_primitive_type_byte]
	155	= builtin->builtin_byte;
	156	lai->primitive_type_vector [d_primitive_type_ubyte]
	157	= builtin->builtin_ubyte;
	158	lai->primitive_type_vector [d_primitive_type_short]
	159	= builtin->builtin_short;
	160	lai->primitive_type_vector [d_primitive_type_ushort]
	161	= builtin->builtin_ushort;
	162	lai->primitive_type_vector [d_primitive_type_int]
	163	= builtin->builtin_int;
	164	lai->primitive_type_vector [d_primitive_type_uint]
	165	= builtin->builtin_uint;
	166	lai->primitive_type_vector [d_primitive_type_long]
	167	= builtin->builtin_long;
	168	lai->primitive_type_vector [d_primitive_type_ulong]
	169	= builtin->builtin_ulong;
170	lai->primitive_type_vector [d_primitive_type_cent]
171	= builtin->builtin_cent;
172	lai->primitive_type_vector [d_primitive_type_ucent]
173	= builtin->builtin_ucent;
174	lai->primitive_type_vector [d_primitive_type_float]
175	= builtin->builtin_float;
176	lai->primitive_type_vector [d_primitive_type_double]
177	= builtin->builtin_double;
178	lai->primitive_type_vector [d_primitive_type_real]
179	= builtin->builtin_real;
180	lai->primitive_type_vector [d_primitive_type_ifloat]
181	= builtin->builtin_ifloat;
182	lai->primitive_type_vector [d_primitive_type_idouble]
183	= builtin->builtin_idouble;
184	lai->primitive_type_vector [d_primitive_type_ireal]
185	= builtin->builtin_ireal;
186	lai->primitive_type_vector [d_primitive_type_cfloat]
187	= builtin->builtin_cfloat;
188	lai->primitive_type_vector [d_primitive_type_cdouble]
189	= builtin->builtin_cdouble;
190	lai->primitive_type_vector [d_primitive_type_creal]
191	= builtin->builtin_creal;
192	lai->primitive_type_vector [d_primitive_type_char]
193	= builtin->builtin_char;
194	lai->primitive_type_vector [d_primitive_type_wchar]
195	= builtin->builtin_wchar;
196	lai->primitive_type_vector [d_primitive_type_dchar]
197	= builtin->builtin_dchar;
198
199	lai->bool_type_symbol = "bool";
200	lai->bool_type_default = builtin->builtin_bool;
201	}
202
56618e20 TT	203	static const char *d_extensions[] =
	204	{
	205	".d", NULL
	206	};
	207
0874fd07 AB	208	/* Constant data that describes the D language. */
	209
	210	extern const struct language_data d_language_data =
6aecb9c2 JB	211	{
6aecb9c2 JB	212	"d",
6abde28f	213	"D",
6aecb9c2 JB	214	language_d,
6aecb9c2 JB	215	range_check_off,
6aecb9c2 JB	216	case_sensitive_on,
6aecb9c2 JB	217	array_row_major,
3271ba66	218	macro_expansion_no,
56618e20	219	d_extensions,
6aecb9c2	220	&exp_descriptor_c,
3ed9baed	221	d_parse,
6aecb9c2 JB	222	null_post_parser,
	223	c_printchar, /* Print a character constant. */
	224	c_printstr, /* Function to print string constant. */
	225	c_emit_char, /* Print a single char. */
	226	c_print_type, /* Print a type using appropriate syntax. */
0963b4bd MS	227	c_print_typedef, /* Print a typedef using appropriate
0963b4bd MS	228	syntax. */
d133c3e1	229	d_value_print_inner, /* la_value_print_inner */
6aecb9c2 JB	230	c_value_print, /* Print a top-level value. */
	231	NULL, /* Language specific skip_trampoline. */
	232	"this",
59cc4834	233	false, /* la_store_sym_names_in_linkage_form_p */
bc7c9fab	234	d_lookup_symbol_nonlocal,
6aecb9c2 JB	235	basic_lookup_transparent_type,
6aecb9c2 JB	236	d_demangle, /* Language specific symbol demangler. */
8b302db8	237	d_sniff_from_mangled_name,
0963b4bd MS	238	NULL, /* Language specific
0963b4bd MS	239	class_name_from_physname. */
6aecb9c2 JB	240	d_op_print_tab, /* Expression operators for printing. */
	241	1, /* C-style arrays. */
	242	0, /* String lower bound. */
	243	default_word_break_characters,
eb3ff9a5	244	default_collect_symbol_completion_matches,
94b1b47e	245	d_language_arch_info,
43cc5389	246	c_watch_location_expression,
b5ec771e	247	NULL, /* la_get_symbol_name_matcher */
95cbceff	248	iterate_over_symbols,
5ffa0793	249	default_search_name_hash,
a53b64ea	250	&default_varobj_ops,
bb2ec1b3	251	NULL,
721b08c6	252	NULL,
4be290b2	253	c_is_string_type_p,
721b08c6	254	"{...}" /* la_struct_too_deep_ellipsis */
6aecb9c2 JB	255	};
6aecb9c2 JB	256
0874fd07 AB	257	/* Class representing the D language. */
	258
	259	class d_language : public language_defn
	260	{
	261	public:
	262	d_language ()
	263	: language_defn (language_d, d_language_data)
	264	{ /* Nothing. */ }
	265	};
	266
	267	/* Single instance of the D language class. */
	268
	269	static d_language d_language_defn;
	270
94b1b47e IB	271	/* Build all D language types for the specified architecture. */
	272
	273	static void *
	274	build_d_types (struct gdbarch *gdbarch)
	275	{
	276	struct builtin_d_type *builtin_d_type
	277	= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
	278
	279	/* Basic types. */
	280	builtin_d_type->builtin_void
77b7c781	281	= arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "void");
94b1b47e IB	282	builtin_d_type->builtin_bool
	283	= arch_boolean_type (gdbarch, 8, 1, "bool");
	284	builtin_d_type->builtin_byte
	285	= arch_integer_type (gdbarch, 8, 0, "byte");
	286	builtin_d_type->builtin_ubyte
	287	= arch_integer_type (gdbarch, 8, 1, "ubyte");
	288	builtin_d_type->builtin_short
	289	= arch_integer_type (gdbarch, 16, 0, "short");
	290	builtin_d_type->builtin_ushort
	291	= arch_integer_type (gdbarch, 16, 1, "ushort");
	292	builtin_d_type->builtin_int
	293	= arch_integer_type (gdbarch, 32, 0, "int");
	294	builtin_d_type->builtin_uint
	295	= arch_integer_type (gdbarch, 32, 1, "uint");
	296	builtin_d_type->builtin_long
	297	= arch_integer_type (gdbarch, 64, 0, "long");
	298	builtin_d_type->builtin_ulong
	299	= arch_integer_type (gdbarch, 64, 1, "ulong");
	300	builtin_d_type->builtin_cent
	301	= arch_integer_type (gdbarch, 128, 0, "cent");
	302	builtin_d_type->builtin_ucent
	303	= arch_integer_type (gdbarch, 128, 1, "ucent");
	304	builtin_d_type->builtin_float
	305	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	306	"float", gdbarch_float_format (gdbarch));
94b1b47e IB	307	builtin_d_type->builtin_double
94b1b47e IB	308	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	309	"double", gdbarch_double_format (gdbarch));
94b1b47e IB	310	builtin_d_type->builtin_real
94b1b47e IB	311	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	312	"real", gdbarch_long_double_format (gdbarch));
94b1b47e IB	313
	314	TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
	315	\|= TYPE_INSTANCE_FLAG_NOTTEXT;
	316	TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
	317	\|= TYPE_INSTANCE_FLAG_NOTTEXT;
	318
	319	/* Imaginary and complex types. */
	320	builtin_d_type->builtin_ifloat
	321	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
49f190bc	322	"ifloat", gdbarch_float_format (gdbarch));
94b1b47e IB	323	builtin_d_type->builtin_idouble
94b1b47e IB	324	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
49f190bc	325	"idouble", gdbarch_double_format (gdbarch));
94b1b47e IB	326	builtin_d_type->builtin_ireal
94b1b47e IB	327	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
49f190bc	328	"ireal", gdbarch_long_double_format (gdbarch));
94b1b47e	329	builtin_d_type->builtin_cfloat
5b930b45	330	= init_complex_type ("cfloat", builtin_d_type->builtin_float);
94b1b47e	331	builtin_d_type->builtin_cdouble
5b930b45	332	= init_complex_type ("cdouble", builtin_d_type->builtin_double);
94b1b47e	333	builtin_d_type->builtin_creal
5b930b45	334	= init_complex_type ("creal", builtin_d_type->builtin_real);
94b1b47e IB	335
	336	/* Character types. */
	337	builtin_d_type->builtin_char
	338	= arch_character_type (gdbarch, 8, 1, "char");
	339	builtin_d_type->builtin_wchar
	340	= arch_character_type (gdbarch, 16, 1, "wchar");
	341	builtin_d_type->builtin_dchar
	342	= arch_character_type (gdbarch, 32, 1, "dchar");
	343
	344	return builtin_d_type;
	345	}
	346
	347	static struct gdbarch_data *d_type_data;
	348
	349	/* Return the D type table for the specified architecture. */
	350
	351	const struct builtin_d_type *
	352	builtin_d_type (struct gdbarch *gdbarch)
	353	{
9a3c8263	354	return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
94b1b47e IB	355	}
94b1b47e IB	356
6c265988	357	void _initialize_d_language ();
6aecb9c2	358	void
6c265988	359	_initialize_d_language ()
6aecb9c2	360	{
94b1b47e	361	d_type_data = gdbarch_data_register_post_init (build_d_types);
6aecb9c2	362	}