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 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
/* FIXME -- do this from the list, with HELP. */
if (!language || !language[0]) {
- printf_filtered ("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");
+ printf ("chill Use the Chill language\n");
+ 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;
}
}
int from_tty;
{
if (type_check != current_language->la_type_check)
- printf_filtered(
+ printf(
"Warning: the current type check setting does not match the language.\n");
}
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();
{
if (range_check != current_language->la_range_check)
- printf_filtered(
+ printf(
"Warning: the current range check setting does not match the language.\n");
}
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();
/* Print out the current language settings: language, range and
type checking. If QUIETLY, print only what has changed. */
+
void
language_info (quietly)
int quietly;
{
- /* FIXME: quietly is ignored at the moment. */
- printf_filtered("Current Language: %s\n",language);
- show_language_command((char *)0, 1);
- printf_filtered("Type checking: %s\n",type);
- show_type_command((char *)0, 1);
- printf_filtered("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. */
not needed. */
return l1 > l2 ? VALUE_TYPE(v1) : VALUE_TYPE(v2);
break;
+ case language_chill:
+ error ("Missing Chill support in function binop_result_check.");/*FIXME*/
}
abort();
return (struct type *)0; /* For lint */
{
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;
+ case language_chill:
+ error ("Missing Chill support in function integral_type."); /*FIXME*/
default:
error ("Language not supported.");
}
{
switch(current_language->la_language)
{
+ case language_chill:
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_CHAR ? 0 : 1;
}
}
+/* Returns non-zero if the value is a string type */
+int
+string_type (type)
+ struct type *type;
+{
+ switch(current_language->la_language)
+ {
+ case language_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);
+ }
+}
+
/* Returns non-zero if the value is a boolean type */
int
boolean_type (type)
{
switch(current_language->la_language)
{
+ case language_chill:
case language_m2:
return TYPE_CODE(type) != TYPE_CODE_BOOL ? 0 : 1;
return (TYPE_CODE(type) == TYPE_CODE_STRUCT) ||
(TYPE_CODE(type) == TYPE_CODE_SET) ||
(TYPE_CODE(type) == TYPE_CODE_ARRAY);
+ case language_chill:
+ error ("Missing Chill support in function structured_type."); /*FIXME*/
default:
return (0);
}
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;
+ case language_chill:
+ error ("Missing Chill support in function value_type."); /*FIXME*/
+
default:
error ("Language not supported.");
}
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;
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 ("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;
break;
}
#endif
+
+#ifdef _LANG_chill
+ case language_chill:
+ error ("Missing Chill support in function binop_type_check.");/*FIXME*/
+#endif
+
}
}
}
char *string;
if (type_check==type_check_warn)
- fprintf_filtered(stderr,warning_pre_print);
+ fprintf(stderr,warning_pre_print);
else
target_terminal_ours();
va_start (args);
string = va_arg (args, char *);
- vfprintf_filtered (stderr, string, args);
- fprintf_filtered (stderr, "\n");
+ vfprintf (stderr, string, args);
+ fprintf (stderr, "\n");
va_end (args);
if (type_check==type_check_on)
- return_to_top_level();
+ return_to_top_level (RETURN_ERROR);
}
void
char *string;
if (range_check==range_check_warn)
- fprintf_filtered(stderr,warning_pre_print);
+ fprintf(stderr,warning_pre_print);
else
target_terminal_ours();
va_start (args);
string = va_arg (args, char *);
- vfprintf_filtered (stderr, string, args);
- fprintf_filtered (stderr, "\n");
+ vfprintf (stderr, string, args);
+ fprintf (stderr, "\n");
va_end (args);
if (range_check==range_check_on)
- return_to_top_level();
+ return_to_top_level (RETURN_ERROR);
}
\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)
char *ignore;
int from_tty;
{
- printf_filtered(
+ printf(
"\"set check\" must be followed by the name of a check subcommand.\n");
help_list(setchecklist, "set check ", -1, stdout);
}
{
if (lang->la_magic != LANG_MAGIC)
{
- fprintf_filtered(stderr, "Magic number of %s language struct wrong\n",
+ fprintf(stderr, "Magic number of %s language struct wrong\n",
lang->la_name);
abort();
}
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
};
projects / deliverable / binutils-gdb.git / blobdiff