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

/* C language support routines for GDB, the GNU debugger.
   Copyright 1992, 1993, 1994 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

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

/* 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
emit_char (c, stream, quoter)
     register int c;
     GDB_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;
	}
    }
}

static void
c_printchar (c, stream)
     int c;
     GDB_FILE *stream;
{
  fputs_filtered ("'", stream);
  emit_char (c, stream, '\'');
  fputs_filtered ("'", stream);
}

/* Print the character string STRING, printing at most LENGTH characters.
   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.  */

static void
c_printstr (stream, string, length, force_ellipses)
     GDB_FILE *stream;
     char *string;
     unsigned int length;
     int force_ellipses;
{
  register unsigned int i;
  unsigned int things_printed = 0;
  int in_quotes = 0;
  int need_comma = 0;
  extern int inspect_it;
  extern int repeat_count_threshold;
  extern int print_max;

  /* 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 && string[length-1] == '\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;

      QUIT;

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

      rep1 = i + 1;
      reps = 1;
      while (rep1 < length && string[rep1] == string[i])
	{
	  ++rep1;
	  ++reps;
	}

      if (reps > repeat_count_threshold)
	{
	  if (in_quotes)
	    {
	      if (inspect_it)
		fputs_filtered ("\\\", ", stream);
	      else
		fputs_filtered ("\", ", stream);
	      in_quotes = 0;
	    }
	  c_printchar (string[i], 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;
	    }
	  emit_char (string[i], 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] */

static struct type *
c_create_fundamental_type (objfile, typeid)
     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_CHAR:
	type = init_type (TYPE_CODE_INT,
			  TARGET_CHAR_BIT / TARGET_CHAR_BIT,
			  0, "char", objfile);
	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;
      }
  return (type);
}

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

static 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},
    /* C++  */
    {"::", BINOP_SCOPE, PREC_PREFIX, 0},
    {NULL, 0, 0, 0}
};
\f
struct type ** const (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,
  c_parse,
  c_error,
  c_printchar,			/* Print a character constant */
  c_printstr,			/* Function to print string constant */
  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 */
  LANG_MAGIC
};

const struct language_defn cplus_language_defn = {
  "c++",				/* Language name */
  language_cplus,
  c_builtin_types,
  range_check_off,
  type_check_off,
  c_parse,
  c_error,
  c_printchar,			/* Print a character constant */
  c_printstr,			/* Function to print string constant */
  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 */
  LANG_MAGIC
};

const struct language_defn asm_language_defn = {
  "asm",			/* Language name */
  language_asm,
  c_builtin_types,
  range_check_off,
  type_check_off,
  c_parse,
  c_error,
  c_printchar,			/* Print a character constant */
  c_printstr,			/* Function to print string constant */
  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 */
  LANG_MAGIC
};

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