/* Multiple source language support for GDB.
- Copyright 1991 Free Software Foundation, Inc.
+ Copyright 1991, 1992 Free Software Foundation, Inc.
Contributed by the Department of Computer Science at the State University
of New York at Buffalo.
return data out of a "language-specific" struct pointer that is set
whenever the working language changes. That would be a lot faster. */
-#include <stdio.h>
+#include "defs.h"
#include <string.h>
#include <varargs.h>
-#include "defs.h"
#include "symtab.h"
+#include "gdbtypes.h"
#include "value.h"
#include "gdbcmd.h"
#include "frame.h"
-#include "language.h"
#include "expression.h"
+#include "language.h"
#include "target.h"
#include "parser-defs.h"
-extern volatile void return_to_top_level ();
+static void
+show_language_command PARAMS ((char *, int));
-/* Forward function declarations */
-static void set_type_range ();
+static void
+set_language_command PARAMS ((char *, int));
-/* Forward declaration */
-extern struct language_defn unknown_language_defn;
+static void
+show_type_command PARAMS ((char *, int));
+static void
+set_type_command PARAMS ((char *, int));
+
+static void
+show_range_command PARAMS ((char *, int));
+
+static void
+set_range_command PARAMS ((char *, int));
+
+static void
+set_range_str PARAMS ((void));
+
+static void
+set_type_str PARAMS ((void));
+
+static void
+set_lang_str PARAMS ((void));
+
+static void
+unk_lang_error PARAMS ((char *));
+
+static int
+unk_lang_parser PARAMS ((void));
+
+static void
+show_check PARAMS ((char *, int));
+
+static void
+set_check PARAMS ((char *, int));
+
+static void
+set_type_range PARAMS ((void));
+
+/* Forward declaration */
+extern const struct language_defn unknown_language_defn;
+extern char *warning_pre_print;
+
/* The current (default at startup) state of type and range checking.
(If the modes are set to "auto", though, these are changed based
on the default language at startup, and then again based on the
/* The current language and language_mode (see language.h) */
-struct language_defn *current_language = &unknown_language_defn;
+const struct language_defn *current_language = &unknown_language_defn;
enum language_mode language_mode = language_mode_auto;
+/* The language that the user expects to be typing in (the language
+ of main(), or the last language we notified them about, or C). */
+
+const struct language_defn *expected_language;
+
/* The list of supported languages. The list itself is malloc'd. */
-static struct language_defn **languages;
+static const struct language_defn **languages;
static unsigned languages_size;
static unsigned languages_allocsize;
-#define DEFAULT_ALLOCSIZE 3
+#define DEFAULT_ALLOCSIZE 4
/* The "set language/type/range" commands all put stuff in these
buffers. This is to make them work as set/show commands. The
char lang_frame_mismatch_warn[] =
"Warning: the current language does not match this frame.";
-void set_lang_str();
-void set_type_str();
-void set_range_str();
\f
/* This page contains the functions corresponding to GDB commands
and their helpers. */
/* Show command. Display a warning if the language set
does not match the frame. */
-void
+static void
show_language_command (ignore, from_tty)
char *ignore;
int from_tty;
}
/* Set command. Change the current working language. */
-void
+static void
set_language_command (ignore, from_tty)
char *ignore;
int from_tty;
/* FIXME -- do this from the list, with HELP. */
if (!language || !language[0]) {
- printf("The currently understood settings are:\n\n\
-local or auto Automatic setting based on source file\n\
-c Use the C language\n\
-c++ Use the C++ language\n\
-modula-2 Use the Modula-2 language\n");
+ printf("The currently understood settings are:\n\n");
+ printf ("local or auto Automatic setting based on source file\n");
+ printf ("c Use the C language\n");
+ printf ("c++ Use the C++ language\n");
+ /* start-sanitize-chill */
+ printf ("chill Use the Chill language\n");
+ /* end-sanitize-chill */
+ printf ("modula-2 Use the Modula-2 language\n");
/* Restore the silly string. */
set_language(current_language->la_language);
return;
/* Search the list of languages for a match. */
for (i = 0; i < languages_size; i++) {
- if (!strcmp (languages[i]->la_name, language)) {
+ if (STREQ (languages[i]->la_name, language)) {
/* Found it! Go into manual mode, and use this language. */
if (languages[i]->la_language == language_auto) {
/* Enter auto mode. Set to the current frame's language, if known. */
flang = get_frame_language();
if (flang!=language_unknown)
set_language(flang);
+ expected_language = current_language;
return;
} else {
/* Enter manual mode. Set the specified language. */
current_language = languages[i];
set_type_range ();
set_lang_str();
+ expected_language = current_language;
return;
}
}
/* Show command. Display a warning if the type setting does
not match the current language. */
-void
+static void
show_type_command(ignore, from_tty)
char *ignore;
int from_tty;
}
/* Set command. Change the setting for type checking. */
-void
+static void
set_type_command(ignore, from_tty)
char *ignore;
int from_tty;
{
- if (!strcmp(type,"on"))
+ if (STREQ(type,"on"))
{
type_check = type_check_on;
type_mode = type_mode_manual;
}
- else if (!strcmp(type,"warn"))
+ else if (STREQ(type,"warn"))
{
type_check = type_check_warn;
type_mode = type_mode_manual;
}
- else if (!strcmp(type,"off"))
+ else if (STREQ(type,"off"))
{
type_check = type_check_off;
type_mode = type_mode_manual;
}
- else if (!strcmp(type,"auto"))
+ else if (STREQ(type,"auto"))
{
type_mode = type_mode_auto;
set_type_range();
/* Show command. Display a warning if the range setting does
not match the current language. */
-void
+static void
show_range_command(ignore, from_tty)
char *ignore;
int from_tty;
}
/* Set command. Change the setting for range checking. */
-void
+static void
set_range_command(ignore, from_tty)
char *ignore;
int from_tty;
{
- if (!strcmp(range,"on"))
+ if (STREQ(range,"on"))
{
range_check = range_check_on;
range_mode = range_mode_manual;
}
- else if (!strcmp(range,"warn"))
+ else if (STREQ(range,"warn"))
{
range_check = range_check_warn;
range_mode = range_mode_manual;
}
- else if (!strcmp(range,"off"))
+ else if (STREQ(range,"off"))
{
range_check = range_check_off;
range_mode = range_mode_manual;
}
- else if (!strcmp(range,"auto"))
+ else if (STREQ(range,"auto"))
{
range_mode = range_mode_auto;
set_type_range();
\f
/* This page contains functions that update the global vars
language, type and range. */
-void
+static void
set_lang_str()
{
char *prefix = "";
language = concat(prefix, current_language->la_name, NULL);
}
-void
+static void
set_type_str()
{
char *tmp, *prefix = "";
type = concat(prefix,tmp,NULL);
}
-void
+static void
set_range_str()
{
char *tmp, *pref = "";
/* Print out the current language settings: language, range and
- type checking. */
+ type checking. If QUIETLY, print only what has changed. */
+
void
-language_info ()
+language_info (quietly)
+ int quietly;
{
- printf("Current Language: %s\n",language);
- show_language_command((char *)0, 1);
- printf("Type checking: %s\n",type);
- show_type_command((char *)0, 1);
- printf("Range checking: %s\n",range);
- show_range_command((char *)0, 1);
+ if (quietly && expected_language == current_language)
+ return;
+
+ expected_language = current_language;
+ printf("Current language: %s\n",language);
+ show_language_command((char *)0, 1);
+
+ if (!quietly)
+ {
+ printf("Type checking: %s\n",type);
+ show_type_command((char *)0, 1);
+ printf("Range checking: %s\n",range);
+ show_range_command((char *)0, 1);
+ }
}
\f
/* Return the result of a binary operation. */
+
+#if 0 /* Currently unused */
+
struct type *
binop_result_type(v1,v2)
value v1,v2;
not needed. */
return l1 > l2 ? VALUE_TYPE(v1) : VALUE_TYPE(v2);
break;
+ /* start-sanitize-chill */
+ case language_chill:
+ error ("Missing Chill support in function binop_result_check.");/*FIXME*/
+ /* end-sanitize-chill */
}
abort();
return (struct type *)0; /* For lint */
}
+
+#endif /* 0 */
+
\f
/* This page contains functions that return format strings for
printf for printing out numbers in different formats */
{
static char form[50];
- strcpy (form, current_language->la_hex_format_pre);
+ strcpy (form, local_hex_format_prefix ());
+ strcat (form, "%");
strcat (form, pre);
- strcat (form, current_language->la_hex_format_suf);
+ strcat (form, local_hex_format_specifier ());
+ strcat (form, local_hex_format_suffix ());
return form;
}
{
static char res[50];
- sprintf (res, current_language->la_hex_format, num);
+ sprintf (res, local_hex_format(), num);
return res;
}
{
static char form[50];
- strcpy (form, current_language->la_octal_format_pre);
+ strcpy (form, local_octal_format_prefix ());
+ strcat (form, "%");
+ strcat (form, pre);
+ strcat (form, local_octal_format_specifier ());
+ strcat (form, local_octal_format_suffix ());
+ return form;
+}
+
+/* Returns the appropriate printf format for decimal numbers. */
+char *
+local_decimal_format_custom(pre)
+ char *pre;
+{
+ static char form[50];
+
+ strcpy (form, local_decimal_format_prefix ());
+ strcat (form, "%");
strcat (form, pre);
- strcat (form, current_language->la_octal_format_suf);
+ strcat (form, local_decimal_format_specifier ());
+ strcat (form, local_decimal_format_suffix ());
return form;
}
\f
}
}
-/* Returns non-zero if its argument is of an ordered type. */
+/* Returns non-zero if its argument is of an ordered type.
+ An ordered type is one in which the elements can be tested for the
+ properties of "greater than", "less than", etc, or for which the
+ operations "increment" or "decrement" make sense. */
int
ordered_type (type)
struct type *type;
(TYPE_CODE(type) != TYPE_CODE_ENUM) ? 0 : 1;
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_INT ? 0 : 1;
+ /* start-sanitize-chill */
+ case language_chill:
+ error ("Missing Chill support in function integral_type."); /*FIXME*/
+ /* end-sanitize-chill */
default:
error ("Language not supported.");
}
{
switch(current_language->la_language)
{
+ /* start-sanitize-chill */
+ case language_chill:
+ /* end-sanitize-chill */
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_CHAR ? 0 : 1;
return (TYPE_CODE(type) == TYPE_CODE_INT) &&
TYPE_LENGTH(type) == sizeof(char)
? 1 : 0;
+ default:
+ return (0);
+ }
+}
+
+/* Returns non-zero if the value is a string type */
+int
+string_type (type)
+ struct type *type;
+{
+ switch(current_language->la_language)
+ {
+ /* start-sanitize-chill */
+ case language_chill:
+ /* end-sanitize-chill */
+ case language_m2:
+ return TYPE_CODE(type) != TYPE_CODE_STRING ? 0 : 1;
+
+ case language_c:
+ case language_cplus:
+ /* C does not have distinct string type. */
+ return (0);
+ default:
+ return (0);
}
}
{
switch(current_language->la_language)
{
+ /* start-sanitize-chill */
+ case language_chill:
+ /* end-sanitize-chill */
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_BOOL ? 0 : 1;
case language_c:
case language_cplus:
return TYPE_CODE(type) != TYPE_CODE_INT ? 0 : 1;
+ default:
+ return (0);
}
}
return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
(TYPE_CODE(type) == TYPE_CODE_SET) ||
(TYPE_CODE(type) == TYPE_CODE_ARRAY);
+ /* start-sanitize-chill */
+ case language_chill:
+ error ("Missing Chill support in function structured_type."); /*FIXME*/
+ /* end-sanitize-chill */
+ default:
+ return (0);
}
}
\f
case language_c:
case language_cplus:
- return !value_zerop (val);
+ return !value_logical_not (val);
case language_m2:
type = VALUE_TYPE(val);
}
if (i >= len)
return 0; /* Not a valid BOOLEAN value */
- if (!strcmp ("TRUE", TYPE_FIELD_NAME(VALUE_TYPE(val), i)))
+ if (STREQ ("TRUE", TYPE_FIELD_NAME(VALUE_TYPE(val), i)))
return 1; /* BOOLEAN with value TRUE */
else
return 0; /* BOOLEAN with value FALSE */
break;
+ /* start-sanitize-chill */
+ case language_chill:
+ error ("Missing Chill support in function value_type."); /*FIXME*/
+ /* end-sanitize-chill */
+
default:
error ("Language not supported.");
}
\f
/* Returns non-zero if the operator OP is defined on
the values ARG1 and ARG2. */
+
+#if 0 /* Currently unused */
+
void
binop_type_check(arg1,arg2,op)
value arg1,arg2;
if ((numeric_type(t1) && pointer_type(t2)) ||
(pointer_type(t1) && numeric_type(t2)))
{
- printf("warning: combining pointer and integer.\n");
+ warning ("combining pointer and integer.\n");
break;
}
case BINOP_MUL:
type_op_error ("Arguments to %s must be of the same type.",op);
break;
- case BINOP_AND:
- case BINOP_OR:
+ case BINOP_LOGICAL_AND:
+ case BINOP_LOGICAL_OR:
if (!boolean_type(t1) || !boolean_type(t2))
type_op_error ("Arguments to %s must be of boolean type.",op);
break;
else if ((pointer_type(t1) && integral_type(t2)) ||
(integral_type(t1) && pointer_type(t2)))
{
- printf("warning: combining integer and pointer.\n");
+ warning ("combining integer and pointer.\n");
break;
}
else if (!simple_type(t1) || !simple_type(t2))
break;
case BINOP_REM:
+ case BINOP_MOD:
if (!integral_type(t1) || !integral_type(t2))
type_op_error ("Arguments to %s must be of integral type.",op);
break;
type_op_error ("A pointer can only be assigned an integer.",op);
else if (pointer_type(t1) && integral_type(t2))
{
- printf("warning: combining integer and pointer.");
+ warning ("combining integer and pointer.");
break;
}
else if (!simple_type(t1) || !simple_type(t2))
type_op_error ("Arguments to %s must be of the same type.",op);
break;
+ case BINOP_CONCAT:
+ /* FIXME: Needs to handle bitstrings as well. */
+ if (!(string_type(t1) || character_type(t1) || integral_type(t1))
+ || !(string_type(t2) || character_type(t2) || integral_type(t2)))
+ type_op_error ("Arguments to %s must be strings or characters.", op);
+ break;
+
/* Unary checks -- arg2 is null */
- case UNOP_ZEROP:
+ case UNOP_LOGICAL_NOT:
if (!boolean_type(t1))
type_op_error ("Argument to %s must be of boolean type.",op);
break;
case UNOP_IND:
if (integral_type(t1))
{
- printf("warning: combining pointer and integer.\n");
+ warning ("combining pointer and integer.\n");
break;
}
else if (!pointer_type(t1))
break;
}
#endif
+
+/* start-sanitize-chill */
+#ifdef _LANG_chill
+ case language_chill:
+ error ("Missing Chill support in function binop_type_check.");/*FIXME*/
+#endif
+/* end-sanitize-chill */
+
}
}
}
+
+#endif /* 0 */
+
\f
/* This page contains functions for the printing out of
error messages that occur during type- and range-
error (fmt,op_string(op));
else
{
- printf("warning: ");
- printf(fmt,op_string(op));
- printf("\n");
+ warning (fmt,op_string(op));
}
}
the rest of the arguments should be its arguments. If
[type|range]_check is [type|range]_check_on, then return_to_top_level()
is called in the style of error (). Otherwise, the message is prefixed
- by "warning: " and we do not return to the top level. */
+ by the value of warning_pre_print and we do not return to the top level. */
+
void
type_error (va_alist)
- va_dcl
+ va_dcl
{
va_list args;
char *string;
if (type_check==type_check_warn)
- fprintf(stderr,"warning: ");
+ fprintf(stderr,warning_pre_print);
else
target_terminal_ours();
void
range_error (va_alist)
- va_dcl
+ va_dcl
{
va_list args;
char *string;
if (range_check==range_check_warn)
- fprintf(stderr,"warning: ");
+ fprintf(stderr,warning_pre_print);
else
target_terminal_ours();
\f
/* This page contains miscellaneous functions */
+/* Return the language struct for a given language enum. */
+
+const struct language_defn *
+language_def(lang)
+ enum language lang;
+{
+ int i;
+
+ for (i = 0; i < languages_size; i++) {
+ if (languages[i]->la_language == lang) {
+ return languages[i];
+ }
+ }
+ return NULL;
+}
+
/* Return the language as a string */
char *
language_str(lang)
return "Unknown";
}
-struct cmd_list_element *setchecklist = NULL;
-struct cmd_list_element *showchecklist = NULL;
-
static void
set_check (ignore, from_tty)
char *ignore;
}
static void
-show_check (arg, from_tty)
- char *arg;
+show_check (ignore, from_tty)
+ char *ignore;
int from_tty;
{
cmd_show_list(showchecklist, from_tty, "");
void
add_language (lang)
- struct language_defn *lang;
+ const struct language_defn *lang;
{
if (lang->la_magic != LANG_MAGIC)
{
if (!languages)
{
languages_allocsize = DEFAULT_ALLOCSIZE;
- languages = (struct language_defn **) xmalloc
+ languages = (const struct language_defn **) xmalloc
(languages_allocsize * sizeof (*languages));
}
if (languages_size >= languages_allocsize)
{
languages_allocsize *= 2;
- languages = (struct language_defn **) xrealloc (languages,
+ languages = (const struct language_defn **) xrealloc ((char *) languages,
languages_allocsize * sizeof (*languages));
}
languages[languages_size++] = lang;
/* Define the language that is no language. */
-int
+static int
unk_lang_parser ()
{
return 1;
}
-void
-unk_lang_error ()
+static void
+unk_lang_error (msg)
+ char *msg;
{
error ("Attempted to parse an expression with unknown language");
}
+static void
+unk_lang_printchar (c, stream)
+ register int c;
+ FILE *stream;
+{
+ error ("internal error - unimplemented function unk_lang_printchar called.");
+}
+
+static void
+unk_lang_printstr (stream, string, length, force_ellipses)
+ FILE *stream;
+ char *string;
+ unsigned int length;
+ int force_ellipses;
+{
+ error ("internal error - unimplemented function unk_lang_printstr called.");
+}
+
+static struct type *
+unk_lang_create_fundamental_type (objfile, typeid)
+ struct objfile *objfile;
+ int typeid;
+{
+ error ("internal error - unimplemented function unk_lang_create_fundamental_type called.");
+}
+
+void
+unk_lang_print_type (type, varstring, stream, show, level)
+ struct type *type;
+ char *varstring;
+ FILE *stream;
+ int show;
+ int level;
+{
+ error ("internal error - unimplemented function unk_lang_print_type called.");
+}
+
+int
+unk_lang_val_print (type, valaddr, address, stream, format, deref_ref,
+ recurse, pretty)
+ struct type *type;
+ char *valaddr;
+ CORE_ADDR address;
+ FILE *stream;
+ int format;
+ int deref_ref;
+ int recurse;
+ enum val_prettyprint pretty;
+{
+ error ("internal error - unimplemented function unk_lang_val_print called.");
+}
+
static struct type ** const (unknown_builtin_types[]) = { 0 };
-static const struct op_print unk_op_print_tab[] = { 0 };
+static const struct op_print unk_op_print_tab[] = {
+ {NULL, OP_NULL, PREC_NULL, 0}
+};
const struct language_defn unknown_language_defn = {
"unknown",
type_check_off,
unk_lang_parser,
unk_lang_error,
+ unk_lang_printchar, /* Print character constant */
+ unk_lang_printstr,
+ unk_lang_create_fundamental_type,
+ unk_lang_print_type, /* Print a type using appropriate syntax */
+ unk_lang_val_print, /* Print a value using appropriate syntax */
&builtin_type_error, /* longest signed integral type */
&builtin_type_error, /* longest unsigned integral type */
&builtin_type_error, /* longest floating point type */
- "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
- "0%o", "0%", "o", /* Octal format, prefix, suffix */
+ {"", "", "", ""}, /* Binary format info */
+ {"0%o", "0", "o", ""}, /* Octal format info */
+ {"%d", "", "d", ""}, /* Decimal format info */
+ {"0x%x", "0x", "x", ""}, /* Hex format info */
unk_op_print_tab, /* expression operators for printing */
LANG_MAGIC
};
type_check_off,
unk_lang_parser,
unk_lang_error,
+ unk_lang_printchar, /* Print character constant */
+ unk_lang_printstr,
+ unk_lang_create_fundamental_type,
+ unk_lang_print_type, /* Print a type using appropriate syntax */
+ unk_lang_val_print, /* Print a value using appropriate syntax */
&builtin_type_error, /* longest signed integral type */
&builtin_type_error, /* longest unsigned integral type */
&builtin_type_error, /* longest floating point type */
- "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
- "0%o", "0%", "o", /* Octal format, prefix, suffix */
+ {"", "", "", ""}, /* Binary format info */
+ {"0%o", "0", "o", ""}, /* Octal format info */
+ {"%d", "", "d", ""}, /* Decimal format info */
+ {"0x%x", "0x", "x", ""}, /* Hex format info */
unk_op_print_tab, /* expression operators for printing */
LANG_MAGIC
};
type_check_off,
unk_lang_parser,
unk_lang_error,
+ unk_lang_printchar, /* Print character constant */
+ unk_lang_printstr,
+ unk_lang_create_fundamental_type,
+ unk_lang_print_type, /* Print a type using appropriate syntax */
+ unk_lang_val_print, /* Print a value using appropriate syntax */
&builtin_type_error, /* longest signed integral type */
&builtin_type_error, /* longest unsigned integral type */
&builtin_type_error, /* longest floating point type */
- "0x%x", "0x%", "x", /* Hex format, prefix, suffix */
- "0%o", "0%", "o", /* Octal format, prefix, suffix */
+ {"", "", "", ""}, /* Binary format info */
+ {"0%o", "0", "o", ""}, /* Octal format info */
+ {"%d", "", "d", ""}, /* Decimal format info */
+ {"0x%x", "0x", "x", ""}, /* Hex format info */
unk_op_print_tab, /* expression operators for printing */
LANG_MAGIC
};
"Set the current source language.",
&setlist);
show = add_show_from_set (set, &showlist);
- set->function = set_language_command;
- show->function = show_language_command;
+ set->function.cfunc = set_language_command;
+ show->function.cfunc = show_language_command;
add_prefix_cmd ("check", no_class, set_check,
"Set the status of the type/range checker",
"Set type checking. (on/warn/off/auto)",
&setchecklist);
show = add_show_from_set (set, &showchecklist);
- set->function = set_type_command;
- show->function = show_type_command;
+ set->function.cfunc = set_type_command;
+ show->function.cfunc = show_type_command;
set = add_set_cmd ("range", class_support, var_string_noescape,
(char *)&range,
"Set range checking. (on/warn/off/auto)",
&setchecklist);
show = add_show_from_set (set, &showchecklist);
- set->function = set_range_command;
- show->function = show_range_command;
+ set->function.cfunc = set_range_command;
+ show->function.cfunc = show_range_command;
add_language (&unknown_language_defn);
add_language (&local_language_defn);
projects / deliverable / binutils-gdb.git / blobdiff