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

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

   Copyright (C) 2005-2016 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 char *d_extensions[] =
{
  ".d", NULL
};

static 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,
  d_yyerror,
  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",
  d_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 (const struct builtin_d_type *) 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
618f726f	3	Copyright (C) 2005-2016 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
56618e20 TT	193	static const char *d_extensions[] =
	194	{
	195	".d", NULL
	196	};
	197
6aecb9c2 JB	198	static const struct language_defn d_language_defn =
	199	{
	200	"d",
6abde28f	201	"D",
6aecb9c2 JB	202	language_d,
6aecb9c2 JB	203	range_check_off,
6aecb9c2 JB	204	case_sensitive_on,
6aecb9c2 JB	205	array_row_major,
3271ba66	206	macro_expansion_no,
56618e20	207	d_extensions,
6aecb9c2	208	&exp_descriptor_c,
3ed9baed	209	d_parse,
b3f11165	210	d_yyerror,
6aecb9c2 JB	211	null_post_parser,
	212	c_printchar, /* Print a character constant. */
	213	c_printstr, /* Function to print string constant. */
	214	c_emit_char, /* Print a single char. */
	215	c_print_type, /* Print a type using appropriate syntax. */
0963b4bd MS	216	c_print_typedef, /* Print a typedef using appropriate
0963b4bd MS	217	syntax. */
6aecb9c2 JB	218	d_val_print, /* Print a value using appropriate syntax. */
6aecb9c2 JB	219	c_value_print, /* Print a top-level value. */
a5ee536b	220	default_read_var_value, /* la_read_var_value */
6aecb9c2 JB	221	NULL, /* Language specific skip_trampoline. */
6aecb9c2 JB	222	"this",
bc7c9fab	223	d_lookup_symbol_nonlocal,
6aecb9c2 JB	224	basic_lookup_transparent_type,
6aecb9c2 JB	225	d_demangle, /* Language specific symbol demangler. */
0963b4bd MS	226	NULL, /* Language specific
0963b4bd MS	227	class_name_from_physname. */
6aecb9c2 JB	228	d_op_print_tab, /* Expression operators for printing. */
	229	1, /* C-style arrays. */
	230	0, /* String lower bound. */
	231	default_word_break_characters,
	232	default_make_symbol_completion_list,
94b1b47e	233	d_language_arch_info,
6aecb9c2 JB	234	default_print_array_index,
	235	default_pass_by_reference,
	236	c_get_string,
1a119f36	237	NULL, /* la_get_symbol_name_cmp */
95cbceff	238	iterate_over_symbols,
a53b64ea	239	&default_varobj_ops,
bb2ec1b3 TT	240	NULL,
bb2ec1b3 TT	241	NULL,
6aecb9c2 JB	242	LANG_MAGIC
	243	};
	244
94b1b47e IB	245	/* Build all D language types for the specified architecture. */
	246
	247	static void *
	248	build_d_types (struct gdbarch *gdbarch)
	249	{
	250	struct builtin_d_type *builtin_d_type
	251	= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_d_type);
	252
	253	/* Basic types. */
	254	builtin_d_type->builtin_void
	255	= arch_type (gdbarch, TYPE_CODE_VOID, 1, "void");
	256	builtin_d_type->builtin_bool
	257	= arch_boolean_type (gdbarch, 8, 1, "bool");
	258	builtin_d_type->builtin_byte
	259	= arch_integer_type (gdbarch, 8, 0, "byte");
	260	builtin_d_type->builtin_ubyte
	261	= arch_integer_type (gdbarch, 8, 1, "ubyte");
	262	builtin_d_type->builtin_short
	263	= arch_integer_type (gdbarch, 16, 0, "short");
	264	builtin_d_type->builtin_ushort
	265	= arch_integer_type (gdbarch, 16, 1, "ushort");
	266	builtin_d_type->builtin_int
	267	= arch_integer_type (gdbarch, 32, 0, "int");
	268	builtin_d_type->builtin_uint
	269	= arch_integer_type (gdbarch, 32, 1, "uint");
	270	builtin_d_type->builtin_long
	271	= arch_integer_type (gdbarch, 64, 0, "long");
	272	builtin_d_type->builtin_ulong
	273	= arch_integer_type (gdbarch, 64, 1, "ulong");
	274	builtin_d_type->builtin_cent
	275	= arch_integer_type (gdbarch, 128, 0, "cent");
	276	builtin_d_type->builtin_ucent
	277	= arch_integer_type (gdbarch, 128, 1, "ucent");
	278	builtin_d_type->builtin_float
	279	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
	280	"float", NULL);
	281	builtin_d_type->builtin_double
	282	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
	283	"double", NULL);
	284	builtin_d_type->builtin_real
	285	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
	286	"real", NULL);
	287
	288	TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_byte)
	289	\|= TYPE_INSTANCE_FLAG_NOTTEXT;
	290	TYPE_INSTANCE_FLAGS (builtin_d_type->builtin_ubyte)
	291	\|= TYPE_INSTANCE_FLAG_NOTTEXT;
	292
	293	/* Imaginary and complex types. */
	294	builtin_d_type->builtin_ifloat
	295	= arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
	296	"ifloat", NULL);
	297	builtin_d_type->builtin_idouble
	298	= arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
	299	"idouble", NULL);
	300	builtin_d_type->builtin_ireal
	301	= arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
	302	"ireal", NULL);
	303	builtin_d_type->builtin_cfloat
	304	= arch_complex_type (gdbarch, "cfloat",
	305	builtin_d_type->builtin_float);
	306	builtin_d_type->builtin_cdouble
	307	= arch_complex_type (gdbarch, "cdouble",
	308	builtin_d_type->builtin_double);
309	builtin_d_type->builtin_creal
310	= arch_complex_type (gdbarch, "creal",
311	builtin_d_type->builtin_real);
312
313	/* Character types. */
314	builtin_d_type->builtin_char
315	= arch_character_type (gdbarch, 8, 1, "char");
316	builtin_d_type->builtin_wchar
317	= arch_character_type (gdbarch, 16, 1, "wchar");
318	builtin_d_type->builtin_dchar
319	= arch_character_type (gdbarch, 32, 1, "dchar");
320
321	return builtin_d_type;
322	}
323
324	static struct gdbarch_data *d_type_data;
325
326	/* Return the D type table for the specified architecture. */
327
328	const struct builtin_d_type *
329	builtin_d_type (struct gdbarch *gdbarch)
330	{
9a3c8263	331	return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
94b1b47e IB	332	}
94b1b47e IB	333
70221824 PA	334	/* Provide a prototype to silence -Wmissing-prototypes. */
	335	extern initialize_file_ftype _initialize_d_language;
	336
6aecb9c2 JB	337	void
	338	_initialize_d_language (void)
	339	{
94b1b47e IB	340	d_type_data = gdbarch_data_register_post_init (build_d_types);
94b1b47e IB	341
6aecb9c2 JB	342	add_language (&d_language_defn);
6aecb9c2 JB	343	}