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

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

   Copyright (C) 2005-2019 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"

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

extern const struct language_defn d_language_defn =
{
  "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_val_print,			/* Print a value using appropriate syntax.  */
  c_value_print,		/* Print a top-level value.  */
  default_read_var_value,	/* la_read_var_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,
  default_print_array_index,
  default_pass_by_reference,
  c_get_string,
  c_watch_location_expression,
  NULL,				/* la_get_symbol_name_matcher */
  iterate_over_symbols,
  default_search_name_hash,
  &default_varobj_ops,
  NULL,
  NULL,
  LANG_MAGIC
};

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