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

/* C language support routines for GDB, the GNU debugger.
   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
   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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "parser-defs.h"
#include "language.h"
#include "c-lang.h"
#include "valprint.h"

extern void _initialize_c_language (void);
static void c_emit_char (int c, struct ui_file * stream, int quoter);

/* Print the character C on STREAM as part of the contents of a literal
   string whose delimiter is QUOTER.  Note that that format for printing
   characters and strings is language specific. */

static void
c_emit_char (register int c, struct ui_file *stream, int quoter)
{
  c &= 0xFF;			/* Avoid sign bit follies */

  if (PRINT_LITERAL_FORM (c))
    {
      if (c == '\\' || c == quoter)
	{
	  fputs_filtered ("\\", stream);
	}
      fprintf_filtered (stream, "%c", c);
    }
  else
    {
      switch (c)
	{
	case '\n':
	  fputs_filtered ("\\n", stream);
	  break;
	case '\b':
	  fputs_filtered ("\\b", stream);
	  break;
	case '\t':
	  fputs_filtered ("\\t", stream);
	  break;
	case '\f':
	  fputs_filtered ("\\f", stream);
	  break;
	case '\r':
	  fputs_filtered ("\\r", stream);
	  break;
	case '\033':
	  fputs_filtered ("\\e", stream);
	  break;
	case '\007':
	  fputs_filtered ("\\a", stream);
	  break;
	default:
	  fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
	  break;
	}
    }
}

void
c_printchar (int c, struct ui_file *stream)
{
  fputc_filtered ('\'', stream);
  LA_EMIT_CHAR (c, stream, '\'');
  fputc_filtered ('\'', stream);
}

/* Print the character string STRING, printing at most LENGTH characters.
   LENGTH is -1 if the string is nul terminated.  Each character is WIDTH bytes
   long.  Printing stops early if the number hits print_max; repeat counts are
   printed as appropriate.  Print ellipses at the end if we had to stop before
   printing LENGTH characters, or if FORCE_ELLIPSES.  */

void
c_printstr (struct ui_file *stream, char *string, unsigned int length,
	    int width, int force_ellipses)
{
  register unsigned int i;
  unsigned int things_printed = 0;
  int in_quotes = 0;
  int need_comma = 0;
  extern int inspect_it;

  /* If the string was not truncated due to `set print elements', and
     the last byte of it is a null, we don't print that, in traditional C
     style.  */
  if (!force_ellipses
      && length > 0
  && extract_unsigned_integer (string + (length - 1) * width, width) == '\0')
    length--;

  if (length == 0)
    {
      fputs_filtered ("\"\"", stream);
      return;
    }

  for (i = 0; i < length && things_printed < print_max; ++i)
    {
      /* Position of the character we are examining
         to see whether it is repeated.  */
      unsigned int rep1;
      /* Number of repetitions we have detected so far.  */
      unsigned int reps;
      unsigned long current_char;

      QUIT;

      if (need_comma)
	{
	  fputs_filtered (", ", stream);
	  need_comma = 0;
	}

      current_char = extract_unsigned_integer (string + i * width, width);

      rep1 = i + 1;
      reps = 1;
      while (rep1 < length
	     && extract_unsigned_integer (string + rep1 * width, width)
	     == current_char)
	{
	  ++rep1;
	  ++reps;
	}

      if (reps > repeat_count_threshold)
	{
	  if (in_quotes)
	    {
	      if (inspect_it)
		fputs_filtered ("\\\", ", stream);
	      else
		fputs_filtered ("\", ", stream);
	      in_quotes = 0;
	    }
	  LA_PRINT_CHAR (current_char, stream);
	  fprintf_filtered (stream, " <repeats %u times>", reps);
	  i = rep1 - 1;
	  things_printed += repeat_count_threshold;
	  need_comma = 1;
	}
      else
	{
	  if (!in_quotes)
	    {
	      if (inspect_it)
		fputs_filtered ("\\\"", stream);
	      else
		fputs_filtered ("\"", stream);
	      in_quotes = 1;
	    }
	  LA_EMIT_CHAR (current_char, stream, '"');
	  ++things_printed;
	}
    }

  /* Terminate the quotes if necessary.  */
  if (in_quotes)
    {
      if (inspect_it)
	fputs_filtered ("\\\"", stream);
      else
	fputs_filtered ("\"", stream);
    }

  if (force_ellipses || i < length)
    fputs_filtered ("...", stream);
}

/* Create a fundamental C type using default reasonable for the current
   target machine.

   Some object/debugging file formats (DWARF version 1, COFF, etc) do not
   define fundamental types such as "int" or "double".  Others (stabs or
   DWARF version 2, etc) do define fundamental types.  For the formats which
   don't provide fundamental types, gdb can create such types using this
   function.

   FIXME:  Some compilers distinguish explicitly signed integral types
   (signed short, signed int, signed long) from "regular" integral types
   (short, int, long) in the debugging information.  There is some dis-
   agreement as to how useful this feature is.  In particular, gcc does
   not support this.  Also, only some debugging formats allow the
   distinction to be passed on to a debugger.  For now, we always just
   use "short", "int", or "long" as the type name, for both the implicit
   and explicitly signed types.  This also makes life easier for the
   gdb test suite since we don't have to account for the differences
   in output depending upon what the compiler and debugging format
   support.  We will probably have to re-examine the issue when gdb
   starts taking it's fundamental type information directly from the
   debugging information supplied by the compiler.  [email protected] */

struct type *
c_create_fundamental_type (struct objfile *objfile, int typeid)
{
  register struct type *type = NULL;

  switch (typeid)
    {
    default:
      /* FIXME:  For now, if we are asked to produce a type not in this
         language, create the equivalent of a C integer type with the
         name "<?type?>".  When all the dust settles from the type
         reconstruction work, this should probably become an error. */
      type = init_type (TYPE_CODE_INT,
			TARGET_INT_BIT / TARGET_CHAR_BIT,
			0, "<?type?>", objfile);
      warning ("internal error: no C/C++ fundamental type %d", typeid);
      break;
    case FT_VOID:
      type = init_type (TYPE_CODE_VOID,
			TARGET_CHAR_BIT / TARGET_CHAR_BIT,
			0, "void", objfile);
      break;
    case FT_BOOLEAN:
      type = init_type (TYPE_CODE_BOOL,
			TARGET_CHAR_BIT / TARGET_CHAR_BIT,
			0, "bool", objfile);

      break;
    case FT_CHAR:
      type = init_type (TYPE_CODE_INT,
			TARGET_CHAR_BIT / TARGET_CHAR_BIT,
			0, "char", objfile);
      TYPE_FLAGS (type) |= TYPE_FLAG_NOSIGN;
      break;
    case FT_SIGNED_CHAR:
      type = init_type (TYPE_CODE_INT,
			TARGET_CHAR_BIT / TARGET_CHAR_BIT,
			0, "signed char", objfile);
      break;
    case FT_UNSIGNED_CHAR:
      type = init_type (TYPE_CODE_INT,
			TARGET_CHAR_BIT / TARGET_CHAR_BIT,
			TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
      break;
    case FT_SHORT:
      type = init_type (TYPE_CODE_INT,
			TARGET_SHORT_BIT / TARGET_CHAR_BIT,
			0, "short", objfile);
      break;
    case FT_SIGNED_SHORT:
      type = init_type (TYPE_CODE_INT,
			TARGET_SHORT_BIT / TARGET_CHAR_BIT,
			0, "short", objfile);	/* FIXME-fnf */
      break;
    case FT_UNSIGNED_SHORT:
      type = init_type (TYPE_CODE_INT,
			TARGET_SHORT_BIT / TARGET_CHAR_BIT,
			TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
      break;
    case FT_INTEGER:
      type = init_type (TYPE_CODE_INT,
			TARGET_INT_BIT / TARGET_CHAR_BIT,
			0, "int", objfile);
      break;
    case FT_SIGNED_INTEGER:
      type = init_type (TYPE_CODE_INT,
			TARGET_INT_BIT / TARGET_CHAR_BIT,
			0, "int", objfile);	/* FIXME -fnf */
      break;
    case FT_UNSIGNED_INTEGER:
      type = init_type (TYPE_CODE_INT,
			TARGET_INT_BIT / TARGET_CHAR_BIT,
			TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
      break;
    case FT_LONG:
      type = init_type (TYPE_CODE_INT,
			TARGET_LONG_BIT / TARGET_CHAR_BIT,
			0, "long", objfile);
      break;
    case FT_SIGNED_LONG:
      type = init_type (TYPE_CODE_INT,
			TARGET_LONG_BIT / TARGET_CHAR_BIT,
			0, "long", objfile);	/* FIXME -fnf */
      break;
    case FT_UNSIGNED_LONG:
      type = init_type (TYPE_CODE_INT,
			TARGET_LONG_BIT / TARGET_CHAR_BIT,
			TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
      break;
    case FT_LONG_LONG:
      type = init_type (TYPE_CODE_INT,
			TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
			0, "long long", objfile);
      break;
    case FT_SIGNED_LONG_LONG:
      type = init_type (TYPE_CODE_INT,
			TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
			0, "signed long long", objfile);
      break;
    case FT_UNSIGNED_LONG_LONG:
      type = init_type (TYPE_CODE_INT,
			TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
			TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
      break;
    case FT_FLOAT:
      type = init_type (TYPE_CODE_FLT,
			TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
			0, "float", objfile);
      break;
    case FT_DBL_PREC_FLOAT:
      type = init_type (TYPE_CODE_FLT,
			TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
			0, "double", objfile);
      break;
    case FT_EXT_PREC_FLOAT:
      type = init_type (TYPE_CODE_FLT,
			TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
			0, "long double", objfile);
      break;
    case FT_TEMPLATE_ARG:
      type = init_type (TYPE_CODE_TEMPLATE_ARG,
			0,
			0, "<template arg>", objfile);

      break;
    }
  return (type);
}
\f

/* Table mapping opcodes into strings for printing operators
   and precedences of the operators.  */

const struct op_print c_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}
};
\f
struct type **CONST_PTR (c_builtin_types[]) =
{
  &builtin_type_int,
    &builtin_type_long,
    &builtin_type_short,
    &builtin_type_char,
    &builtin_type_float,
    &builtin_type_double,
    &builtin_type_void,
    &builtin_type_long_long,
    &builtin_type_signed_char,
    &builtin_type_unsigned_char,
    &builtin_type_unsigned_short,
    &builtin_type_unsigned_int,
    &builtin_type_unsigned_long,
    &builtin_type_unsigned_long_long,
    &builtin_type_long_double,
    &builtin_type_complex,
    &builtin_type_double_complex,
    0
};

const struct language_defn c_language_defn =
{
  "c",				/* Language name */
  language_c,
  c_builtin_types,
  range_check_off,
  type_check_off,
  case_sensitive_on,
  c_parse,
  c_error,
  evaluate_subexp_standard,
  c_printchar,			/* Print a character constant */
  c_printstr,			/* Function to print string constant */
  c_emit_char,			/* Print a single char */
  c_create_fundamental_type,	/* Create fundamental type in this language */
  c_print_type,			/* Print a type using appropriate syntax */
  c_val_print,			/* Print a value using appropriate syntax */
  c_value_print,		/* Print a top-level value */
  {"", "", "", ""},		/* Binary format info */
  {"0%lo", "0", "o", ""},	/* Octal format info */
  {"%ld", "", "d", ""},		/* Decimal format info */
  {"0x%lx", "0x", "x", ""},	/* Hex format info */
  c_op_print_tab,		/* expression operators for printing */
  1,				/* c-style arrays */
  0,				/* String lower bound */
  &builtin_type_char,		/* Type of string elements */
  LANG_MAGIC
};

struct type **const (cplus_builtin_types[]) =
{
  &builtin_type_int,
    &builtin_type_long,
    &builtin_type_short,
    &builtin_type_char,
    &builtin_type_float,
    &builtin_type_double,
    &builtin_type_void,
    &builtin_type_long_long,
    &builtin_type_signed_char,
    &builtin_type_unsigned_char,
    &builtin_type_unsigned_short,
    &builtin_type_unsigned_int,
    &builtin_type_unsigned_long,
    &builtin_type_unsigned_long_long,
    &builtin_type_long_double,
    &builtin_type_complex,
    &builtin_type_double_complex,
    &builtin_type_bool,
    0
};

const struct language_defn cplus_language_defn =
{
  "c++",			/* Language name */
  language_cplus,
  cplus_builtin_types,
  range_check_off,
  type_check_off,
  case_sensitive_on,
  c_parse,
  c_error,
  evaluate_subexp_standard,
  c_printchar,			/* Print a character constant */
  c_printstr,			/* Function to print string constant */
  c_emit_char,			/* Print a single char */
  c_create_fundamental_type,	/* Create fundamental type in this language */
  c_print_type,			/* Print a type using appropriate syntax */
  c_val_print,			/* Print a value using appropriate syntax */
  c_value_print,		/* Print a top-level value */
  {"", "", "", ""},		/* Binary format info */
  {"0%lo", "0", "o", ""},	/* Octal format info */
  {"%ld", "", "d", ""},		/* Decimal format info */
  {"0x%lx", "0x", "x", ""},	/* Hex format info */
  c_op_print_tab,		/* expression operators for printing */
  1,				/* c-style arrays */
  0,				/* String lower bound */
  &builtin_type_char,		/* Type of string elements */
  LANG_MAGIC
};

const struct language_defn asm_language_defn =
{
  "asm",			/* Language name */
  language_asm,
  c_builtin_types,
  range_check_off,
  type_check_off,
  case_sensitive_on,
  c_parse,
  c_error,
  evaluate_subexp_standard,
  c_printchar,			/* Print a character constant */
  c_printstr,			/* Function to print string constant */
  c_emit_char,			/* Print a single char */
  c_create_fundamental_type,	/* Create fundamental type in this language */
  c_print_type,			/* Print a type using appropriate syntax */
  c_val_print,			/* Print a value using appropriate syntax */
  c_value_print,		/* Print a top-level value */
  {"", "", "", ""},		/* Binary format info */
  {"0%lo", "0", "o", ""},	/* Octal format info */
  {"%ld", "", "d", ""},		/* Decimal format info */
  {"0x%lx", "0x", "x", ""},	/* Hex format info */
  c_op_print_tab,		/* expression operators for printing */
  1,				/* c-style arrays */
  0,				/* String lower bound */
  &builtin_type_char,		/* Type of string elements */
  LANG_MAGIC
};

void
_initialize_c_language (void)
{
  add_language (&c_language_defn);
  add_language (&cplus_language_defn);
  add_language (&asm_language_defn);
}
Commit	Line	Data
c906108c	1	/* C language support routines for GDB, the GNU debugger.
b6ba6518 KB	2	Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000
b6ba6518 KB	3	Free Software Foundation, Inc.
c906108c	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	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 2 of the License, or
	10	(at your option) any later version.
c906108c	11
c5aa993b JM	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.
c906108c	16
c5aa993b JM	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include "defs.h"
	23	#include "symtab.h"
	24	#include "gdbtypes.h"
	25	#include "expression.h"
	26	#include "parser-defs.h"
	27	#include "language.h"
	28	#include "c-lang.h"
745b8ca0	29	#include "valprint.h"
c906108c	30
a14ed312	31	extern void _initialize_c_language (void);
d9fcf2fb	32	static void c_emit_char (int c, struct ui_file * stream, int quoter);
c906108c SS	33
	34	/* Print the character C on STREAM as part of the contents of a literal
	35	string whose delimiter is QUOTER. Note that that format for printing
	36	characters and strings is language specific. */
	37
	38	static void
fba45db2	39	c_emit_char (register int c, struct ui_file *stream, int quoter)
c906108c SS	40	{
	41	c &= 0xFF; /* Avoid sign bit follies */
	42
	43	if (PRINT_LITERAL_FORM (c))
	44	{
	45	if (c == '\\' \|\| c == quoter)
	46	{
	47	fputs_filtered ("\\", stream);
	48	}
	49	fprintf_filtered (stream, "%c", c);
	50	}
	51	else
	52	{
	53	switch (c)
	54	{
	55	case '\n':
	56	fputs_filtered ("\\n", stream);
	57	break;
	58	case '\b':
	59	fputs_filtered ("\\b", stream);
	60	break;
	61	case '\t':
	62	fputs_filtered ("\\t", stream);
	63	break;
	64	case '\f':
	65	fputs_filtered ("\\f", stream);
	66	break;
	67	case '\r':
	68	fputs_filtered ("\\r", stream);
	69	break;
	70	case '\033':
	71	fputs_filtered ("\\e", stream);
	72	break;
	73	case '\007':
	74	fputs_filtered ("\\a", stream);
	75	break;
	76	default:
	77	fprintf_filtered (stream, "\\%.3o", (unsigned int) c);
	78	break;
	79	}
	80	}
	81	}
	82
	83	void
fba45db2	84	c_printchar (int c, struct ui_file *stream)
c906108c SS	85	{
	86	fputc_filtered ('\'', stream);
	87	LA_EMIT_CHAR (c, stream, '\'');
	88	fputc_filtered ('\'', stream);
	89	}
	90
	91	/* Print the character string STRING, printing at most LENGTH characters.
	92	LENGTH is -1 if the string is nul terminated. Each character is WIDTH bytes
	93	long. Printing stops early if the number hits print_max; repeat counts are
	94	printed as appropriate. Print ellipses at the end if we had to stop before
	95	printing LENGTH characters, or if FORCE_ELLIPSES. */
	96
	97	void
fba45db2 KB	98	c_printstr (struct ui_file stream, char string, unsigned int length,
fba45db2 KB	99	int width, int force_ellipses)
c906108c SS	100	{
	101	register unsigned int i;
	102	unsigned int things_printed = 0;
	103	int in_quotes = 0;
	104	int need_comma = 0;
	105	extern int inspect_it;
c906108c SS	106
	107	/* If the string was not truncated due to `set print elements', and
	108	the last byte of it is a null, we don't print that, in traditional C
	109	style. */
	110	if (!force_ellipses
	111	&& length > 0
c5aa993b	112	&& extract_unsigned_integer (string + (length - 1) * width, width) == '\0')
c906108c SS	113	length--;
	114
	115	if (length == 0)
	116	{
	117	fputs_filtered ("\"\"", stream);
	118	return;
	119	}
	120
	121	for (i = 0; i < length && things_printed < print_max; ++i)
	122	{
	123	/* Position of the character we are examining
c5aa993b	124	to see whether it is repeated. */
c906108c SS	125	unsigned int rep1;
	126	/* Number of repetitions we have detected so far. */
	127	unsigned int reps;
	128	unsigned long current_char;
	129
	130	QUIT;
	131
	132	if (need_comma)
	133	{
	134	fputs_filtered (", ", stream);
	135	need_comma = 0;
	136	}
	137
	138	current_char = extract_unsigned_integer (string + i * width, width);
	139
	140	rep1 = i + 1;
	141	reps = 1;
	142	while (rep1 < length
	143	&& extract_unsigned_integer (string + rep1 * width, width)
c5aa993b	144	== current_char)
c906108c SS	145	{
	146	++rep1;
	147	++reps;
	148	}
	149
	150	if (reps > repeat_count_threshold)
	151	{
	152	if (in_quotes)
	153	{
	154	if (inspect_it)
	155	fputs_filtered ("\\\", ", stream);
	156	else
	157	fputs_filtered ("\", ", stream);
	158	in_quotes = 0;
	159	}
	160	LA_PRINT_CHAR (current_char, stream);
	161	fprintf_filtered (stream, " <repeats %u times>", reps);
	162	i = rep1 - 1;
	163	things_printed += repeat_count_threshold;
	164	need_comma = 1;
	165	}
	166	else
	167	{
	168	if (!in_quotes)
	169	{
	170	if (inspect_it)
	171	fputs_filtered ("\\\"", stream);
	172	else
	173	fputs_filtered ("\"", stream);
	174	in_quotes = 1;
	175	}
	176	LA_EMIT_CHAR (current_char, stream, '"');
	177	++things_printed;
	178	}
	179	}
	180
	181	/* Terminate the quotes if necessary. */
	182	if (in_quotes)
	183	{
	184	if (inspect_it)
	185	fputs_filtered ("\\\"", stream);
	186	else
	187	fputs_filtered ("\"", stream);
	188	}
	189
	190	if (force_ellipses \|\| i < length)
	191	fputs_filtered ("...", stream);
	192	}
	193
	194	/* Create a fundamental C type using default reasonable for the current
	195	target machine.
	196
	197	Some object/debugging file formats (DWARF version 1, COFF, etc) do not
	198	define fundamental types such as "int" or "double". Others (stabs or
	199	DWARF version 2, etc) do define fundamental types. For the formats which
	200	don't provide fundamental types, gdb can create such types using this
	201	function.
	202
	203	FIXME: Some compilers distinguish explicitly signed integral types
	204	(signed short, signed int, signed long) from "regular" integral types
	205	(short, int, long) in the debugging information. There is some dis-
	206	agreement as to how useful this feature is. In particular, gcc does
	207	not support this. Also, only some debugging formats allow the
	208	distinction to be passed on to a debugger. For now, we always just
209	use "short", "int", or "long" as the type name, for both the implicit
210	and explicitly signed types. This also makes life easier for the
211	gdb test suite since we don't have to account for the differences
212	in output depending upon what the compiler and debugging format
213	support. We will probably have to re-examine the issue when gdb
214	starts taking it's fundamental type information directly from the
215	debugging information supplied by the compiler. [email protected] */
216
217	struct type *
fba45db2	218	c_create_fundamental_type (struct objfile *objfile, int typeid)
c906108c SS	219	{
	220	register struct type *type = NULL;
	221
	222	switch (typeid)
	223	{
c5aa993b JM	224	default:
	225	/* FIXME: For now, if we are asked to produce a type not in this
	226	language, create the equivalent of a C integer type with the
	227	name "<?type?>". When all the dust settles from the type
	228	reconstruction work, this should probably become an error. */
	229	type = init_type (TYPE_CODE_INT,
	230	TARGET_INT_BIT / TARGET_CHAR_BIT,
	231	0, "<?type?>", objfile);
	232	warning ("internal error: no C/C++ fundamental type %d", typeid);
	233	break;
	234	case FT_VOID:
	235	type = init_type (TYPE_CODE_VOID,
	236	TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	237	0, "void", objfile);
	238	break;
	239	case FT_BOOLEAN:
	240	type = init_type (TYPE_CODE_BOOL,
	241	TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	242	0, "bool", objfile);
	243
	244	break;
	245	case FT_CHAR:
	246	type = init_type (TYPE_CODE_INT,
	247	TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	248	0, "char", objfile);
	249	TYPE_FLAGS (type) \|= TYPE_FLAG_NOSIGN;
	250	break;
	251	case FT_SIGNED_CHAR:
	252	type = init_type (TYPE_CODE_INT,
	253	TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	254	0, "signed char", objfile);
	255	break;
	256	case FT_UNSIGNED_CHAR:
	257	type = init_type (TYPE_CODE_INT,
	258	TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	259	TYPE_FLAG_UNSIGNED, "unsigned char", objfile);
	260	break;
	261	case FT_SHORT:
	262	type = init_type (TYPE_CODE_INT,
	263	TARGET_SHORT_BIT / TARGET_CHAR_BIT,
	264	0, "short", objfile);
	265	break;
	266	case FT_SIGNED_SHORT:
	267	type = init_type (TYPE_CODE_INT,
	268	TARGET_SHORT_BIT / TARGET_CHAR_BIT,
	269	0, "short", objfile); /* FIXME-fnf */
	270	break;
	271	case FT_UNSIGNED_SHORT:
	272	type = init_type (TYPE_CODE_INT,
	273	TARGET_SHORT_BIT / TARGET_CHAR_BIT,
	274	TYPE_FLAG_UNSIGNED, "unsigned short", objfile);
	275	break;
	276	case FT_INTEGER:
	277	type = init_type (TYPE_CODE_INT,
	278	TARGET_INT_BIT / TARGET_CHAR_BIT,
	279	0, "int", objfile);
	280	break;
	281	case FT_SIGNED_INTEGER:
	282	type = init_type (TYPE_CODE_INT,
	283	TARGET_INT_BIT / TARGET_CHAR_BIT,
	284	0, "int", objfile); /* FIXME -fnf */
	285	break;
	286	case FT_UNSIGNED_INTEGER:
	287	type = init_type (TYPE_CODE_INT,
288	TARGET_INT_BIT / TARGET_CHAR_BIT,
289	TYPE_FLAG_UNSIGNED, "unsigned int", objfile);
290	break;
291	case FT_LONG:
292	type = init_type (TYPE_CODE_INT,
293	TARGET_LONG_BIT / TARGET_CHAR_BIT,
294	0, "long", objfile);
295	break;
296	case FT_SIGNED_LONG:
297	type = init_type (TYPE_CODE_INT,
298	TARGET_LONG_BIT / TARGET_CHAR_BIT,
299	0, "long", objfile); /* FIXME -fnf */
300	break;
301	case FT_UNSIGNED_LONG:
302	type = init_type (TYPE_CODE_INT,
303	TARGET_LONG_BIT / TARGET_CHAR_BIT,
304	TYPE_FLAG_UNSIGNED, "unsigned long", objfile);
305	break;
306	case FT_LONG_LONG:
307	type = init_type (TYPE_CODE_INT,
308	TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
309	0, "long long", objfile);
310	break;
311	case FT_SIGNED_LONG_LONG:
312	type = init_type (TYPE_CODE_INT,
313	TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
314	0, "signed long long", objfile);
315	break;
316	case FT_UNSIGNED_LONG_LONG:
317	type = init_type (TYPE_CODE_INT,
318	TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT,
319	TYPE_FLAG_UNSIGNED, "unsigned long long", objfile);
320	break;
321	case FT_FLOAT:
322	type = init_type (TYPE_CODE_FLT,
323	TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
324	0, "float", objfile);
325	break;
326	case FT_DBL_PREC_FLOAT:
327	type = init_type (TYPE_CODE_FLT,
328	TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
329	0, "double", objfile);
330	break;
331	case FT_EXT_PREC_FLOAT:
332	type = init_type (TYPE_CODE_FLT,
333	TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT,
334	0, "long double", objfile);
335	break;
336	case FT_TEMPLATE_ARG:
337	type = init_type (TYPE_CODE_TEMPLATE_ARG,
338	0,
339	0, "<template arg>", objfile);
340
341	break;
342	}
c906108c SS	343	return (type);
c906108c SS	344	}
c906108c	345	\f
c5aa993b	346
c906108c SS	347	/* Table mapping opcodes into strings for printing operators
	348	and precedences of the operators. */
	349
	350	const struct op_print c_op_print_tab[] =
c5aa993b JM	351	{
	352	{",", BINOP_COMMA, PREC_COMMA, 0},
	353	{"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
	354	{"\|\|", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
	355	{"&&", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
	356	{"\|", BINOP_BITWISE_IOR, PREC_BITWISE_IOR, 0},
	357	{"^", BINOP_BITWISE_XOR, PREC_BITWISE_XOR, 0},
	358	{"&", BINOP_BITWISE_AND, PREC_BITWISE_AND, 0},
	359	{"==", BINOP_EQUAL, PREC_EQUAL, 0},
	360	{"!=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
	361	{"<=", BINOP_LEQ, PREC_ORDER, 0},
	362	{">=", BINOP_GEQ, PREC_ORDER, 0},
	363	{">", BINOP_GTR, PREC_ORDER, 0},
	364	{"<", BINOP_LESS, PREC_ORDER, 0},
	365	{">>", BINOP_RSH, PREC_SHIFT, 0},
	366	{"<<", BINOP_LSH, PREC_SHIFT, 0},
	367	{"+", BINOP_ADD, PREC_ADD, 0},
	368	{"-", BINOP_SUB, PREC_ADD, 0},
	369	{"*", BINOP_MUL, PREC_MUL, 0},
	370	{"/", BINOP_DIV, PREC_MUL, 0},
	371	{"%", BINOP_REM, PREC_MUL, 0},
	372	{"@", BINOP_REPEAT, PREC_REPEAT, 0},
	373	{"-", UNOP_NEG, PREC_PREFIX, 0},
	374	{"!", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
	375	{"~", UNOP_COMPLEMENT, PREC_PREFIX, 0},
	376	{"*", UNOP_IND, PREC_PREFIX, 0},
	377	{"&", UNOP_ADDR, PREC_PREFIX, 0},
	378	{"sizeof ", UNOP_SIZEOF, PREC_PREFIX, 0},
	379	{"++", UNOP_PREINCREMENT, PREC_PREFIX, 0},
	380	{"--", UNOP_PREDECREMENT, PREC_PREFIX, 0},
c5aa993b	381	{NULL, 0, 0, 0}
c906108c SS	382	};
c906108c SS	383	\f
c5aa993b	384	struct type **CONST_PTR (c_builtin_types[]) =
c906108c SS	385	{
c906108c SS	386	&builtin_type_int,
c5aa993b JM	387	&builtin_type_long,
	388	&builtin_type_short,
	389	&builtin_type_char,
	390	&builtin_type_float,
	391	&builtin_type_double,
	392	&builtin_type_void,
	393	&builtin_type_long_long,
	394	&builtin_type_signed_char,
	395	&builtin_type_unsigned_char,
	396	&builtin_type_unsigned_short,
	397	&builtin_type_unsigned_int,
	398	&builtin_type_unsigned_long,
	399	&builtin_type_unsigned_long_long,
	400	&builtin_type_long_double,
	401	&builtin_type_complex,
	402	&builtin_type_double_complex,
	403	0
c906108c SS	404	};
c906108c SS	405
c5aa993b JM	406	const struct language_defn c_language_defn =
c5aa993b JM	407	{
c906108c SS	408	"c", /* Language name */
	409	language_c,
	410	c_builtin_types,
	411	range_check_off,
	412	type_check_off,
63872f9d	413	case_sensitive_on,
c906108c SS	414	c_parse,
	415	c_error,
	416	evaluate_subexp_standard,
	417	c_printchar, /* Print a character constant */
	418	c_printstr, /* Function to print string constant */
	419	c_emit_char, /* Print a single char */
	420	c_create_fundamental_type, /* Create fundamental type in this language */
	421	c_print_type, /* Print a type using appropriate syntax */
	422	c_val_print, /* Print a value using appropriate syntax */
	423	c_value_print, /* Print a top-level value */
c5aa993b JM	424	{"", "", "", ""}, /* Binary format info */
	425	{"0%lo", "0", "o", ""}, /* Octal format info */
	426	{"%ld", "", "d", ""}, /* Decimal format info */
	427	{"0x%lx", "0x", "x", ""}, /* Hex format info */
c906108c SS	428	c_op_print_tab, /* expression operators for printing */
	429	1, /* c-style arrays */
	430	0, /* String lower bound */
c5aa993b	431	&builtin_type_char, /* Type of string elements */
c906108c SS	432	LANG_MAGIC
	433	};
	434
c5aa993b	435	struct type **const (cplus_builtin_types[]) =
c906108c SS	436	{
c906108c SS	437	&builtin_type_int,
c5aa993b JM	438	&builtin_type_long,
	439	&builtin_type_short,
	440	&builtin_type_char,
	441	&builtin_type_float,
	442	&builtin_type_double,
	443	&builtin_type_void,
	444	&builtin_type_long_long,
	445	&builtin_type_signed_char,
	446	&builtin_type_unsigned_char,
	447	&builtin_type_unsigned_short,
	448	&builtin_type_unsigned_int,
	449	&builtin_type_unsigned_long,
	450	&builtin_type_unsigned_long_long,
	451	&builtin_type_long_double,
	452	&builtin_type_complex,
	453	&builtin_type_double_complex,
	454	&builtin_type_bool,
	455	0
c906108c SS	456	};
c906108c SS	457
c5aa993b JM	458	const struct language_defn cplus_language_defn =
	459	{
	460	"c++", /* Language name */
c906108c SS	461	language_cplus,
	462	cplus_builtin_types,
	463	range_check_off,
	464	type_check_off,
63872f9d	465	case_sensitive_on,
c906108c SS	466	c_parse,
	467	c_error,
	468	evaluate_subexp_standard,
	469	c_printchar, /* Print a character constant */
	470	c_printstr, /* Function to print string constant */
	471	c_emit_char, /* Print a single char */
	472	c_create_fundamental_type, /* Create fundamental type in this language */
	473	c_print_type, /* Print a type using appropriate syntax */
	474	c_val_print, /* Print a value using appropriate syntax */
	475	c_value_print, /* Print a top-level value */
c5aa993b JM	476	{"", "", "", ""}, /* Binary format info */
	477	{"0%lo", "0", "o", ""}, /* Octal format info */
	478	{"%ld", "", "d", ""}, /* Decimal format info */
	479	{"0x%lx", "0x", "x", ""}, /* Hex format info */
c906108c SS	480	c_op_print_tab, /* expression operators for printing */
	481	1, /* c-style arrays */
	482	0, /* String lower bound */
c5aa993b	483	&builtin_type_char, /* Type of string elements */
c906108c SS	484	LANG_MAGIC
	485	};
	486
c5aa993b JM	487	const struct language_defn asm_language_defn =
c5aa993b JM	488	{
c906108c SS	489	"asm", /* Language name */
	490	language_asm,
	491	c_builtin_types,
	492	range_check_off,
	493	type_check_off,
63872f9d	494	case_sensitive_on,
c906108c SS	495	c_parse,
	496	c_error,
	497	evaluate_subexp_standard,
	498	c_printchar, /* Print a character constant */
	499	c_printstr, /* Function to print string constant */
	500	c_emit_char, /* Print a single char */
	501	c_create_fundamental_type, /* Create fundamental type in this language */
	502	c_print_type, /* Print a type using appropriate syntax */
	503	c_val_print, /* Print a value using appropriate syntax */
	504	c_value_print, /* Print a top-level value */
c5aa993b JM	505	{"", "", "", ""}, /* Binary format info */
	506	{"0%lo", "0", "o", ""}, /* Octal format info */
	507	{"%ld", "", "d", ""}, /* Decimal format info */
	508	{"0x%lx", "0x", "x", ""}, /* Hex format info */
c906108c SS	509	c_op_print_tab, /* expression operators for printing */
	510	1, /* c-style arrays */
	511	0, /* String lower bound */
c5aa993b	512	&builtin_type_char, /* Type of string elements */
c906108c SS	513	LANG_MAGIC
	514	};
	515
	516	void
fba45db2	517	_initialize_c_language (void)
c906108c SS	518	{
	519	add_language (&c_language_defn);
	520	add_language (&cplus_language_defn);
	521	add_language (&asm_language_defn);
	522	}