| /* Modula 2 language support routines for GDB, the GNU debugger. |
| |
| Copyright (C) 1992-2020 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 3 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, see <http://www.gnu.org/licenses/>. */ |
| |
| #include "defs.h" |
| #include "symtab.h" |
| #include "gdbtypes.h" |
| #include "expression.h" |
| #include "parser-defs.h" |
| #include "language.h" |
| #include "varobj.h" |
| #include "m2-lang.h" |
| #include "c-lang.h" |
| #include "valprint.h" |
| #include "gdbarch.h" |
| |
| static void m2_printchar (int, struct type *, struct ui_file *); |
| |
| /* FIXME: This is a copy of the same function from c-exp.y. It should |
| be replaced with a true Modula version. */ |
| |
| static void |
| m2_printchar (int c, struct type *type, struct ui_file *stream) |
| { |
| fputs_filtered ("'", stream); |
| LA_EMIT_CHAR (c, type, stream, '\''); |
| fputs_filtered ("'", stream); |
| } |
| |
| static struct value * |
| evaluate_subexp_modula2 (struct type *expect_type, struct expression *exp, |
| int *pos, enum noside noside) |
| { |
| enum exp_opcode op = exp->elts[*pos].opcode; |
| struct value *arg1; |
| struct value *arg2; |
| struct type *type; |
| |
| switch (op) |
| { |
| case UNOP_HIGH: |
| (*pos)++; |
| arg1 = evaluate_subexp_with_coercion (exp, pos, noside); |
| |
| if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS) |
| return arg1; |
| else |
| { |
| arg1 = coerce_ref (arg1); |
| type = check_typedef (value_type (arg1)); |
| |
| if (m2_is_unbounded_array (type)) |
| { |
| struct value *temp = arg1; |
| |
| type = type->field (1).type (); |
| /* i18n: Do not translate the "_m2_high" part! */ |
| arg1 = value_struct_elt (&temp, NULL, "_m2_high", NULL, |
| _("unbounded structure " |
| "missing _m2_high field")); |
| |
| if (value_type (arg1) != type) |
| arg1 = value_cast (type, arg1); |
| } |
| } |
| return arg1; |
| |
| case BINOP_SUBSCRIPT: |
| (*pos)++; |
| arg1 = evaluate_subexp_with_coercion (exp, pos, noside); |
| arg2 = evaluate_subexp_with_coercion (exp, pos, noside); |
| if (noside == EVAL_SKIP) |
| goto nosideret; |
| /* If the user attempts to subscript something that is not an |
| array or pointer type (like a plain int variable for example), |
| then report this as an error. */ |
| |
| arg1 = coerce_ref (arg1); |
| type = check_typedef (value_type (arg1)); |
| |
| if (m2_is_unbounded_array (type)) |
| { |
| struct value *temp = arg1; |
| type = type->field (0).type (); |
| if (type == NULL || (type->code () != TYPE_CODE_PTR)) |
| { |
| warning (_("internal error: unbounded " |
| "array structure is unknown")); |
| return evaluate_subexp_standard (expect_type, exp, pos, noside); |
| } |
| /* i18n: Do not translate the "_m2_contents" part! */ |
| arg1 = value_struct_elt (&temp, NULL, "_m2_contents", NULL, |
| _("unbounded structure " |
| "missing _m2_contents field")); |
| |
| if (value_type (arg1) != type) |
| arg1 = value_cast (type, arg1); |
| |
| check_typedef (value_type (arg1)); |
| return value_ind (value_ptradd (arg1, value_as_long (arg2))); |
| } |
| else |
| if (type->code () != TYPE_CODE_ARRAY) |
| { |
| if (type->name ()) |
| error (_("cannot subscript something of type `%s'"), |
| type->name ()); |
| else |
| error (_("cannot subscript requested type")); |
| } |
| |
| if (noside == EVAL_AVOID_SIDE_EFFECTS) |
| return value_zero (TYPE_TARGET_TYPE (type), VALUE_LVAL (arg1)); |
| else |
| return value_subscript (arg1, value_as_long (arg2)); |
| |
| default: |
| return evaluate_subexp_standard (expect_type, exp, pos, noside); |
| } |
| |
| nosideret: |
| return value_from_longest (builtin_type (exp->gdbarch)->builtin_int, 1); |
| } |
| |
| |
| /* Table of operators and their precedences for printing expressions. */ |
| |
| static const struct op_print m2_op_print_tab[] = |
| { |
| {"+", BINOP_ADD, PREC_ADD, 0}, |
| {"+", UNOP_PLUS, PREC_PREFIX, 0}, |
| {"-", BINOP_SUB, PREC_ADD, 0}, |
| {"-", UNOP_NEG, PREC_PREFIX, 0}, |
| {"*", BINOP_MUL, PREC_MUL, 0}, |
| {"/", BINOP_DIV, PREC_MUL, 0}, |
| {"DIV", BINOP_INTDIV, PREC_MUL, 0}, |
| {"MOD", BINOP_REM, PREC_MUL, 0}, |
| {":=", BINOP_ASSIGN, PREC_ASSIGN, 1}, |
| {"OR", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, |
| {"AND", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, |
| {"NOT", UNOP_LOGICAL_NOT, PREC_PREFIX, 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}, |
| {"^", UNOP_IND, PREC_PREFIX, 0}, |
| {"@", BINOP_REPEAT, PREC_REPEAT, 0}, |
| {"CAP", UNOP_CAP, PREC_BUILTIN_FUNCTION, 0}, |
| {"CHR", UNOP_CHR, PREC_BUILTIN_FUNCTION, 0}, |
| {"ORD", UNOP_ORD, PREC_BUILTIN_FUNCTION, 0}, |
| {"FLOAT", UNOP_FLOAT, PREC_BUILTIN_FUNCTION, 0}, |
| {"HIGH", UNOP_HIGH, PREC_BUILTIN_FUNCTION, 0}, |
| {"MAX", UNOP_MAX, PREC_BUILTIN_FUNCTION, 0}, |
| {"MIN", UNOP_MIN, PREC_BUILTIN_FUNCTION, 0}, |
| {"ODD", UNOP_ODD, PREC_BUILTIN_FUNCTION, 0}, |
| {"TRUNC", UNOP_TRUNC, PREC_BUILTIN_FUNCTION, 0}, |
| {NULL, OP_NULL, PREC_BUILTIN_FUNCTION, 0} |
| }; |
| |
| /* The built-in types of Modula-2. */ |
| |
| enum m2_primitive_types { |
| m2_primitive_type_char, |
| m2_primitive_type_int, |
| m2_primitive_type_card, |
| m2_primitive_type_real, |
| m2_primitive_type_bool, |
| nr_m2_primitive_types |
| }; |
| |
| const struct exp_descriptor exp_descriptor_modula2 = |
| { |
| print_subexp_standard, |
| operator_length_standard, |
| operator_check_standard, |
| op_name_standard, |
| dump_subexp_body_standard, |
| evaluate_subexp_modula2 |
| }; |
| |
| /* Class representing the M2 language. */ |
| |
| class m2_language : public language_defn |
| { |
| public: |
| m2_language () |
| : language_defn (language_m2) |
| { /* Nothing. */ } |
| |
| /* See language.h. */ |
| |
| const char *name () const override |
| { return "modula-2"; } |
| |
| /* See language.h. */ |
| |
| const char *natural_name () const override |
| { return "Modula-2"; } |
| |
| /* See language.h. */ |
| void language_arch_info (struct gdbarch *gdbarch, |
| struct language_arch_info *lai) const override |
| { |
| const struct builtin_m2_type *builtin = builtin_m2_type (gdbarch); |
| |
| lai->string_char_type = builtin->builtin_char; |
| lai->primitive_type_vector |
| = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_m2_primitive_types + 1, |
| struct type *); |
| |
| lai->primitive_type_vector [m2_primitive_type_char] |
| = builtin->builtin_char; |
| lai->primitive_type_vector [m2_primitive_type_int] |
| = builtin->builtin_int; |
| lai->primitive_type_vector [m2_primitive_type_card] |
| = builtin->builtin_card; |
| lai->primitive_type_vector [m2_primitive_type_real] |
| = builtin->builtin_real; |
| lai->primitive_type_vector [m2_primitive_type_bool] |
| = builtin->builtin_bool; |
| |
| lai->bool_type_symbol = "BOOLEAN"; |
| lai->bool_type_default = builtin->builtin_bool; |
| } |
| |
| /* See language.h. */ |
| |
| void print_type (struct type *type, const char *varstring, |
| struct ui_file *stream, int show, int level, |
| const struct type_print_options *flags) const override |
| { |
| m2_print_type (type, varstring, stream, show, level, flags); |
| } |
| |
| /* See language.h. */ |
| |
| void value_print_inner |
| (struct value *val, struct ui_file *stream, int recurse, |
| const struct value_print_options *options) const override |
| { |
| return m2_value_print_inner (val, stream, recurse, options); |
| } |
| |
| /* See language.h. */ |
| |
| int parser (struct parser_state *ps) const override |
| { |
| return m2_parse (ps); |
| } |
| |
| /* See language.h. */ |
| |
| void emitchar (int ch, struct type *chtype, |
| struct ui_file *stream, int quoter) const override |
| { |
| ch &= 0xFF; /* Avoid sign bit follies. */ |
| |
| if (PRINT_LITERAL_FORM (ch)) |
| { |
| if (ch == '\\' || ch == quoter) |
| fputs_filtered ("\\", stream); |
| fprintf_filtered (stream, "%c", ch); |
| } |
| else |
| { |
| switch (ch) |
| { |
| 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) ch); |
| break; |
| } |
| } |
| } |
| |
| /* See language.h. */ |
| |
| void printchar (int ch, struct type *chtype, |
| struct ui_file *stream) const override |
| { |
| m2_printchar (ch, chtype, stream); |
| } |
| |
| /* See language.h. */ |
| |
| void printstr (struct ui_file *stream, struct type *elttype, |
| const gdb_byte *string, unsigned int length, |
| const char *encoding, int force_ellipses, |
| const struct value_print_options *options) const override |
| { |
| unsigned int i; |
| unsigned int things_printed = 0; |
| int in_quotes = 0; |
| int need_comma = 0; |
| |
| if (length == 0) |
| { |
| fputs_filtered ("\"\"", gdb_stdout); |
| return; |
| } |
| |
| for (i = 0; i < length && things_printed < options->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 > options->repeat_count_threshold) |
| { |
| if (in_quotes) |
| { |
| fputs_filtered ("\", ", stream); |
| in_quotes = 0; |
| } |
| m2_printchar (string[i], elttype, stream); |
| fprintf_filtered (stream, " <repeats %u times>", reps); |
| i = rep1 - 1; |
| things_printed += options->repeat_count_threshold; |
| need_comma = 1; |
| } |
| else |
| { |
| if (!in_quotes) |
| { |
| fputs_filtered ("\"", stream); |
| in_quotes = 1; |
| } |
| LA_EMIT_CHAR (string[i], elttype, stream, '"'); |
| ++things_printed; |
| } |
| } |
| |
| /* Terminate the quotes if necessary. */ |
| if (in_quotes) |
| fputs_filtered ("\"", stream); |
| |
| if (force_ellipses || i < length) |
| fputs_filtered ("...", stream); |
| } |
| |
| /* See language.h. */ |
| |
| void print_typedef (struct type *type, struct symbol *new_symbol, |
| struct ui_file *stream) const override |
| { |
| m2_print_typedef (type, new_symbol, stream); |
| } |
| |
| /* See language.h. */ |
| |
| bool is_string_type_p (struct type *type) const override |
| { |
| type = check_typedef (type); |
| if (type->code () == TYPE_CODE_ARRAY |
| && TYPE_LENGTH (type) > 0 |
| && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) |
| { |
| struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type)); |
| |
| if (TYPE_LENGTH (elttype) == 1 |
| && (elttype->code () == TYPE_CODE_INT |
| || elttype->code () == TYPE_CODE_CHAR)) |
| return true; |
| } |
| |
| return false; |
| } |
| |
| /* See language.h. */ |
| |
| bool c_style_arrays_p () const override |
| { return false; } |
| |
| /* See language.h. Despite not having C-style arrays, Modula-2 uses 0 |
| for its string lower bounds. */ |
| |
| char string_lower_bound () const override |
| { return 0; } |
| |
| /* See language.h. */ |
| |
| bool range_checking_on_by_default () const override |
| { return true; } |
| |
| /* See language.h. */ |
| |
| const struct exp_descriptor *expression_ops () const override |
| { return &exp_descriptor_modula2; } |
| |
| /* See language.h. */ |
| |
| const struct op_print *opcode_print_table () const override |
| { return m2_op_print_tab; } |
| }; |
| |
| /* Single instance of the M2 language. */ |
| |
| static m2_language m2_language_defn; |
| |
| static void * |
| build_m2_types (struct gdbarch *gdbarch) |
| { |
| struct builtin_m2_type *builtin_m2_type |
| = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_m2_type); |
| |
| /* Modula-2 "pervasive" types. NOTE: these can be redefined!!! */ |
| builtin_m2_type->builtin_int |
| = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0, "INTEGER"); |
| builtin_m2_type->builtin_card |
| = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "CARDINAL"); |
| builtin_m2_type->builtin_real |
| = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch), "REAL", |
| gdbarch_float_format (gdbarch)); |
| builtin_m2_type->builtin_char |
| = arch_character_type (gdbarch, TARGET_CHAR_BIT, 1, "CHAR"); |
| builtin_m2_type->builtin_bool |
| = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1, "BOOLEAN"); |
| |
| return builtin_m2_type; |
| } |
| |
| static struct gdbarch_data *m2_type_data; |
| |
| const struct builtin_m2_type * |
| builtin_m2_type (struct gdbarch *gdbarch) |
| { |
| return (const struct builtin_m2_type *) gdbarch_data (gdbarch, m2_type_data); |
| } |
| |
| |
| /* Initialization for Modula-2 */ |
| |
| void _initialize_m2_language (); |
| void |
| _initialize_m2_language () |
| { |
| m2_type_data = gdbarch_data_register_post_init (build_m2_types); |
| } |