[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 minimal_symbol *msym;

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