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

/* Chill language support routines for GDB, the GNU debugger.
   Copyright 1992 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 "ch-lang.h"

static void
chill_printchar (c, stream)
     register int c;
     FILE *stream;
{
  c &= 0xFF;			/* Avoid sign bit follies */

  if (PRINT_LITERAL_FORM (c))
    {
      fprintf_filtered (stream, "'%c'", c);
    }
  else
    {
      fprintf_filtered (stream, "C'%.2x'", (unsigned int) c);
    }
}

/* 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.
   Note that gdb maintains the length of strings without counting the
   terminating null byte, while chill strings are typically written with
   an explicit null byte.  So we always assume an implied null byte
   until gdb is able to maintain non-null terminated strings as well
   as null terminated strings (FIXME).
  */

static void
chill_printstr (stream, string, length, force_ellipses)
     FILE *stream;
     char *string;
     unsigned int length;
     int force_ellipses;
{
  register unsigned int i;
  unsigned int things_printed = 0;
  int in_literal_form = 0;
  int in_control_form = 0;
  int need_slashslash = 0;
  unsigned int c;
  extern int repeat_count_threshold;
  extern int print_max;

  if (length == 0)
    {
      chill_printchar ('\0', 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_slashslash)
	{
	  fputs_filtered ("//", stream);
	  need_slashslash = 0;
	}

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

      c = string[i];
      if (reps > repeat_count_threshold)
	{
	  if (in_control_form || in_literal_form)
	    {
	      fputs_filtered ("'//", stream);
	      in_control_form = in_literal_form = 0;
	    }
	  chill_printchar (c, stream);
	  fprintf_filtered (stream, "<repeats %u times>", reps);
	  i = rep1 - 1;
	  things_printed += repeat_count_threshold;
	  need_slashslash = 1;
	}
      else
	{
	  if (PRINT_LITERAL_FORM (c))
	    {
	      if (!in_literal_form)
		{
		  if (in_control_form)
		    {
		      fputs_filtered ("'//", stream);
		      in_control_form = 0;
		    }
		  fputs_filtered ("'", stream);
		  in_literal_form = 1;
		}
	      fprintf_filtered (stream, "%c", c);
	    }
	  else
	    {
	      if (!in_control_form)
		{
		  if (in_literal_form)
		    {
		      fputs_filtered ("'//", stream);
		      in_literal_form = 0;
		    }
		  fputs_filtered ("c'", stream);
		  in_control_form = 1;
		}
	      fprintf_filtered (stream, "%.2x", c);
	    }
	  ++things_printed;
	}
    }

  /* Terminate the quotes if necessary.  */
  if (in_literal_form || in_control_form)
    {
      fputs_filtered ("'", stream);
    }
  if (force_ellipses || (i < length))
    {
      fputs_filtered ("...", stream);
    }
}

static struct type *
chill_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, 2, 0, "<?type?>", objfile);
        warning ("internal error: no chill fundamental type %d", typeid);
	break;
      case FT_VOID:
	/* FIXME:  Currently the GNU Chill compiler emits some DWARF entries for
	   typedefs, unrelated to anything directly in the code being compiled,
	   that have some FT_VOID types.  Just fake it for now. */
	type = init_type (TYPE_CODE_VOID, 0, 0, "<?VOID?>", objfile);
	break;
      case FT_BOOLEAN:
	type = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED, "BOOL", objfile);
	break;
      case FT_CHAR:
	type = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED, "CHAR", objfile);
	break;
      case FT_SIGNED_CHAR:
	type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_SIGNED, "BYTE", objfile);
	break;
      case FT_UNSIGNED_CHAR:
	type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, "UBYTE", objfile);
	break;
      case FT_SHORT:			/* Chill ints are 2 bytes */
	type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_SIGNED, "INT", objfile);
	break;
      case FT_UNSIGNED_SHORT:		/* Chill ints are 2 bytes */
	type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, "UINT", objfile);
	break;
      case FT_INTEGER:			/* Chill longs are 4 bytes */
	type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_SIGNED, "LONG", objfile);
	break;
      case FT_UNSIGNED_INTEGER:		/* Chill longs are 4 bytes */
	type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, "ULONG", objfile);
	break;
      case FT_FLOAT:
	type = init_type (TYPE_CODE_FLT, 4, 0, "REAL", objfile);
	break;
      case FT_DBL_PREC_FLOAT:
	type = init_type (TYPE_CODE_FLT, 8, 0, "LONG_REAL", objfile);
	break;
      }
  return (type);
}

\f
/* Table of operators and their precedences for printing expressions.  */

static const struct op_print chill_op_print_tab[] = {
    {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
    {"OR",  BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
    {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
    {"MOD", BINOP_REM, PREC_MUL, 0},
    {":=",  BINOP_ASSIGN, PREC_ASSIGN, 1},
    {"=",   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_ADD, PREC_ADD, 0},
    {"-",   BINOP_SUB, PREC_ADD, 0},
    {"*",   BINOP_MUL, PREC_MUL, 0},
    {"/",   BINOP_DIV, PREC_MUL, 0},
    {"-",   UNOP_NEG, PREC_PREFIX, 0},
    {NULL,  0, 0, 0}
};

\f
/* The built-in types of Chill.  */

struct type *builtin_type_chill_bool;
struct type *builtin_type_chill_char;
struct type *builtin_type_chill_long;
struct type *builtin_type_chill_ulong;
struct type *builtin_type_chill_real;

struct type ** const (chill_builtin_types[]) = 
{
  &builtin_type_chill_bool,
  &builtin_type_chill_char,
  &builtin_type_chill_long,
  &builtin_type_chill_ulong,
  &builtin_type_chill_real,
  0
};

const struct language_defn chill_language_defn = {
  "chill",
  language_chill,
  chill_builtin_types,
  range_check_on,
  type_check_on,
  chill_parse,			/* parser */
  chill_error,			/* parser error function */
  chill_printchar,		/* print a character constant */
  chill_printstr,		/* function to print a string constant */
  chill_create_fundamental_type,/* Create fundamental type in this language */
  chill_print_type,		/* Print a type using appropriate syntax */
  chill_val_print,		/* Print a value using appropriate syntax */
  &BUILTIN_TYPE_LONGEST,	/* longest signed   integral type */
  &BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
  &builtin_type_chill_real,	/* longest floating point type */
  {"",      "B'",  "",   ""},	/* Binary format info */
  {"O'%o",  "O'",  "o",  ""},	/* Octal format info */
  {"D'%d",  "D'",  "d",  ""},	/* Decimal format info */
  {"H'%x",  "H'",  "x",  ""},	/* Hex format info */
  chill_op_print_tab,		/* expression operators for printing */
  LANG_MAGIC
};

/* Initialization for Chill */

void
_initialize_chill_language ()
{
  builtin_type_chill_bool =
    init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	       TYPE_FLAG_UNSIGNED,
	       "BOOL", (struct objfile *) NULL);
  builtin_type_chill_char =
    init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	       TYPE_FLAG_UNSIGNED,
	       "CHAR", (struct objfile *) NULL);
  builtin_type_chill_long =
    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
	       0,
	       "LONG", (struct objfile *) NULL);
  builtin_type_chill_ulong =
    init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
	       TYPE_FLAG_UNSIGNED,
	       "ULONG", (struct objfile *) NULL);
  builtin_type_chill_real =
    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
	       0,
	       "LONG_REAL", (struct objfile *) NULL);

  add_language (&chill_language_defn);
}
Commit	Line	Data
22e39759 FF	1	/* Chill language support routines for GDB, the GNU debugger.
	2	Copyright 1992 Free Software Foundation, Inc.
	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 "ch-lang.h"
	27
	28	static void
	29	chill_printchar (c, stream)
	30	register int c;
	31	FILE *stream;
	32	{
	33	c &= 0xFF; /* Avoid sign bit follies */
	34
	35	if (PRINT_LITERAL_FORM (c))
	36	{
	37	fprintf_filtered (stream, "'%c'", c);
	38	}
	39	else
	40	{
	41	fprintf_filtered (stream, "C'%.2x'", (unsigned int) c);
	42	}
	43	}
	44
	45	/* Print the character string STRING, printing at most LENGTH characters.
	46	Printing stops early if the number hits print_max; repeat counts
	47	are printed as appropriate. Print ellipses at the end if we
	48	had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
	49	Note that gdb maintains the length of strings without counting the
	50	terminating null byte, while chill strings are typically written with
	51	an explicit null byte. So we always assume an implied null byte
	52	until gdb is able to maintain non-null terminated strings as well
	53	as null terminated strings (FIXME).
	54	*/
	55
	56	static void
	57	chill_printstr (stream, string, length, force_ellipses)
	58	FILE *stream;
	59	char *string;
	60	unsigned int length;
	61	int force_ellipses;
	62	{
	63	register unsigned int i;
	64	unsigned int things_printed = 0;
65	int in_literal_form = 0;
66	int in_control_form = 0;
67	int need_slashslash = 0;
68	unsigned int c;
69	extern int repeat_count_threshold;
70	extern int print_max;
71
72	if (length == 0)
73	{
74	chill_printchar ('\0', stream);
75	return;
76	}
77
78	for (i = 0; i < length && things_printed < print_max; ++i)
79	{
80	/* Position of the character we are examining
81	to see whether it is repeated. */
82	unsigned int rep1;
83	/* Number of repetitions we have detected so far. */
84	unsigned int reps;
85
86	QUIT;
87
88	if (need_slashslash)
89	{
90	fputs_filtered ("//", stream);
91	need_slashslash = 0;
92	}
93
94	rep1 = i + 1;
95	reps = 1;
96	while (rep1 < length && string[rep1] == string[i])
97	{
98	++rep1;
99	++reps;
100	}
101
102	c = string[i];
103	if (reps > repeat_count_threshold)
104	{
105	if (in_control_form \|\| in_literal_form)
106	{
107	fputs_filtered ("'//", stream);
108	in_control_form = in_literal_form = 0;
109	}
110	chill_printchar (c, stream);
111	fprintf_filtered (stream, "<repeats %u times>", reps);
112	i = rep1 - 1;
113	things_printed += repeat_count_threshold;
114	need_slashslash = 1;
115	}
116	else
117	{
118	if (PRINT_LITERAL_FORM (c))
119	{
120	if (!in_literal_form)
121	{
122	if (in_control_form)
123	{
124	fputs_filtered ("'//", stream);
125	in_control_form = 0;
126	}
127	fputs_filtered ("'", stream);
128	in_literal_form = 1;
129	}
130	fprintf_filtered (stream, "%c", c);
131	}
132	else
133	{
134	if (!in_control_form)
135	{
136	if (in_literal_form)
137	{
138	fputs_filtered ("'//", stream);
139	in_literal_form = 0;
140	}
141	fputs_filtered ("c'", stream);
142	in_control_form = 1;
143	}
144	fprintf_filtered (stream, "%.2x", c);
145	}
146	++things_printed;
147	}
148	}
149
150	/* Terminate the quotes if necessary. */
151	if (in_literal_form \|\| in_control_form)
152	{
153	fputs_filtered ("'", stream);
154	}
155	if (force_ellipses \|\| (i < length))
156	{
157	fputs_filtered ("...", stream);
158	}
159	}
160
161	static struct type *
162	chill_create_fundamental_type (objfile, typeid)
163	struct objfile *objfile;
164	int typeid;
165	{
166	register struct type *type = NULL;
22e39759 FF	167
	168	switch (typeid)
	169	{
	170	default:
	171	/* FIXME: For now, if we are asked to produce a type not in this
	172	language, create the equivalent of a C integer type with the
	173	name "<?type?>". When all the dust settles from the type
	174	reconstruction work, this should probably become an error. */
a8a69e63	175	type = init_type (TYPE_CODE_INT, 2, 0, "<?type?>", objfile);
22e39759 FF	176	warning ("internal error: no chill fundamental type %d", typeid);
22e39759 FF	177	break;
a8a69e63 FF	178	case FT_VOID:
	179	/* FIXME: Currently the GNU Chill compiler emits some DWARF entries for
	180	typedefs, unrelated to anything directly in the code being compiled,
	181	that have some FT_VOID types. Just fake it for now. */
	182	type = init_type (TYPE_CODE_VOID, 0, 0, "<?VOID?>", objfile);
	183	break;
22e39759 FF	184	case FT_BOOLEAN:
	185	type = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED, "BOOL", objfile);
	186	break;
	187	case FT_CHAR:
a8a69e63	188	type = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED, "CHAR", objfile);
22e39759 FF	189	break;
	190	case FT_SIGNED_CHAR:
	191	type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_SIGNED, "BYTE", objfile);
	192	break;
	193	case FT_UNSIGNED_CHAR:
	194	type = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, "UBYTE", objfile);
	195	break;
	196	case FT_SHORT: /* Chill ints are 2 bytes */
	197	type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_SIGNED, "INT", objfile);
	198	break;
	199	case FT_UNSIGNED_SHORT: /* Chill ints are 2 bytes */
	200	type = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, "UINT", objfile);
	201	break;
	202	case FT_INTEGER: /* Chill longs are 4 bytes */
	203	type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_SIGNED, "LONG", objfile);
	204	break;
	205	case FT_UNSIGNED_INTEGER: /* Chill longs are 4 bytes */
	206	type = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, "ULONG", objfile);
	207	break;
	208	case FT_FLOAT:
	209	type = init_type (TYPE_CODE_FLT, 4, 0, "REAL", objfile);
	210	break;
	211	case FT_DBL_PREC_FLOAT:
	212	type = init_type (TYPE_CODE_FLT, 8, 0, "LONG_REAL", objfile);
	213	break;
	214	}
	215	return (type);
	216	}
	217
	218	\f
	219	/* Table of operators and their precedences for printing expressions. */
	220
a8a69e63	221	static const struct op_print chill_op_print_tab[] = {
22e39759 FF	222	{"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
	223	{"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
	224	{"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
	225	{"MOD", BINOP_REM, PREC_MUL, 0},
	226	{":=", BINOP_ASSIGN, PREC_ASSIGN, 1},
	227	{"=", BINOP_EQUAL, PREC_EQUAL, 0},
	228	{"/=", BINOP_NOTEQUAL, PREC_EQUAL, 0},
	229	{"<=", BINOP_LEQ, PREC_ORDER, 0},
	230	{">=", BINOP_GEQ, PREC_ORDER, 0},
	231	{">", BINOP_GTR, PREC_ORDER, 0},
	232	{"<", BINOP_LESS, PREC_ORDER, 0},
	233	{"+", BINOP_ADD, PREC_ADD, 0},
	234	{"-", BINOP_SUB, PREC_ADD, 0},
	235	{"*", BINOP_MUL, PREC_MUL, 0},
	236	{"/", BINOP_DIV, PREC_MUL, 0},
	237	{"-", UNOP_NEG, PREC_PREFIX, 0},
	238	{NULL, 0, 0, 0}
	239	};
	240
	241	\f
	242	/* The built-in types of Chill. */
	243
	244	struct type *builtin_type_chill_bool;
	245	struct type *builtin_type_chill_char;
	246	struct type *builtin_type_chill_long;
	247	struct type *builtin_type_chill_ulong;
	248	struct type *builtin_type_chill_real;
	249
	250	struct type ** const (chill_builtin_types[]) =
	251	{
	252	&builtin_type_chill_bool,
	253	&builtin_type_chill_char,
	254	&builtin_type_chill_long,
	255	&builtin_type_chill_ulong,
	256	&builtin_type_chill_real,
	257	0
	258	};
	259
	260	const struct language_defn chill_language_defn = {
	261	"chill",
	262	language_chill,
	263	chill_builtin_types,
	264	range_check_on,
	265	type_check_on,
	266	chill_parse, /* parser */
	267	chill_error, /* parser error function */
	268	chill_printchar, /* print a character constant */
	269	chill_printstr, /* function to print a string constant */
	270	chill_create_fundamental_type,/* Create fundamental type in this language */
a8a69e63 FF	271	chill_print_type, /* Print a type using appropriate syntax */
a8a69e63 FF	272	chill_val_print, /* Print a value using appropriate syntax */
22e39759 FF	273	&BUILTIN_TYPE_LONGEST, /* longest signed integral type */
	274	&BUILTIN_TYPE_UNSIGNED_LONGEST,/* longest unsigned integral type */
	275	&builtin_type_chill_real, /* longest floating point type */
	276	{"", "B'", "", ""}, /* Binary format info */
	277	{"O'%o", "O'", "o", ""}, /* Octal format info */
	278	{"D'%d", "D'", "d", ""}, /* Decimal format info */
	279	{"H'%x", "H'", "x", ""}, /* Hex format info */
	280	chill_op_print_tab, /* expression operators for printing */
	281	LANG_MAGIC
	282	};
	283
	284	/* Initialization for Chill */
	285
	286	void
d62e7a20	287	_initialize_chill_language ()
22e39759 FF	288	{
	289	builtin_type_chill_bool =
	290	init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	291	TYPE_FLAG_UNSIGNED,
	292	"BOOL", (struct objfile *) NULL);
	293	builtin_type_chill_char =
	294	init_type (TYPE_CODE_CHAR, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
	295	TYPE_FLAG_UNSIGNED,
	296	"CHAR", (struct objfile *) NULL);
	297	builtin_type_chill_long =
	298	init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
	299	0,
	300	"LONG", (struct objfile *) NULL);
	301	builtin_type_chill_ulong =
	302	init_type (TYPE_CODE_INT, TARGET_LONG_BIT / TARGET_CHAR_BIT,
	303	TYPE_FLAG_UNSIGNED,
	304	"ULONG", (struct objfile *) NULL);
	305	builtin_type_chill_real =
	306	init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
	307	0,
	308	"LONG_REAL", (struct objfile *) NULL);
	309
	310	add_language (&chill_language_defn);
	311	}