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

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

   Copyright (C) 2005-2015 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);
}

/* 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 struct language_defn d_language_defn =
{
  "d",
  "D",
  language_d,
  range_check_off,
  case_sensitive_on,
  array_row_major,
  macro_expansion_no,
  &exp_descriptor_c,
  d_parse,
  d_error,
  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",
  basic_lookup_symbol_nonlocal, 
  basic_lookup_transparent_type,
  d_demangle,			/* Language specific symbol demangler.  */
  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_make_symbol_completion_list,
  d_language_arch_info,
  default_print_array_index,
  default_pass_by_reference,
  c_get_string,
  NULL,				/* la_get_symbol_name_cmp */
  iterate_over_symbols,
  &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, 1, "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", NULL);
  builtin_d_type->builtin_double
    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
		       "double", NULL);
  builtin_d_type->builtin_real
    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
		       "real", NULL);

  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", NULL);
  builtin_d_type->builtin_idouble
    = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
		       "idouble", NULL);
  builtin_d_type->builtin_ireal
    = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
		       "ireal", NULL);
  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 gdbarch_data (gdbarch, d_type_data);
}

/* Provide a prototype to silence -Wmissing-prototypes.  */
extern initialize_file_ftype _initialize_d_language;

void
_initialize_d_language (void)
{
  d_type_data = gdbarch_data_register_post_init (build_d_types);

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