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

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

   Copyright (C) 2005-2014 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 "parser-defs.h"
#include "gdb_obstack.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)
{
  struct obstack tempbuf;
  char *result;

  if ((symbol == NULL) || (*symbol == '\0'))
    return NULL;
  else if (strcmp (symbol, "_Dmain") == 0)
    return xstrdup ("D main");

  obstack_init (&tempbuf);

  if (strncmp (symbol, "_D", 2) == 0)
    symbol += 2;
  else
    {
      obstack_free (&tempbuf, NULL);
      return NULL;
    }

  if (d_parse_symbol (&tempbuf, symbol) != NULL)
    {
      obstack_grow_str0 (&tempbuf, "");
      result = xstrdup (obstack_finish (&tempbuf));
      obstack_free (&tempbuf, NULL);
    }
  else
    {
      obstack_free (&tempbuf, NULL);
      return NULL;
    }

  return result;
}

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