X-Git-Url: https://deadsoftware.ru/gitweb?p=dsw-obn.git;a=blobdiff_plain;f=src%2Foberon.c;h=08543355c92b9e421854e751081df3e6827c8d17;hp=9738056b94124b347e771b1bb541364e83859ae6;hb=95acec6c3ae8d3c324c84b001a680aa49320790b;hpb=496b7b4a5162004e33dfd3328aee7d155342f09f diff --git a/src/oberon.c b/src/oberon.c index 9738056..0854335 100644 --- a/src/oberon.c +++ b/src/oberon.c @@ -6,99 +6,21 @@ #include #include #include +#include #include "../include/oberon.h" #include "oberon-internals.h" +#include "oberon-type-compat.h" +#include "oberon-common.h" #include "generator.h" -enum { - EOF_ = 0, - IDENT, - MODULE, - SEMICOLON, - END, - DOT, - VAR, - COLON, - BEGIN, - ASSIGN, - INTEGER, - LPAREN, - RPAREN, - EQUAL, - NEQ, - LESS, - LEQ, - GREAT, - GEQ, - IN, - IS, - PLUS, - MINUS, - OR, - STAR, - SLASH, - DIV, - MOD, - AND, - NOT, - PROCEDURE, - COMMA, - RETURN, - CONST, - TYPE, - ARRAY, - OF, - LBRACK, - RBRACK, - RECORD, - POINTER, - TO, - UPARROW, - NIL, - IMPORT, - REAL, - CHAR, - STRING, - IF, - THEN, - ELSE, - ELSIF, - WHILE, - DO, - REPEAT, - UNTIL, - FOR, - BY, - LOOP, - EXIT, - LBRACE, - RBRACE, - DOTDOT, - CASE, - BAR, - WITH -}; - // ======================================================================= // UTILS // ======================================================================= static void -oberon_error(oberon_context_t * ctx, const char * fmt, ...) -{ - va_list ptr; - va_start(ptr, fmt); - fprintf(stderr, "error: "); - vfprintf(stderr, fmt, ptr); - fprintf(stderr, "\n"); - fprintf(stderr, " code_index = %i\n", ctx -> code_index); - fprintf(stderr, " c = %c\n", ctx -> c); - fprintf(stderr, " token = %i\n", ctx -> token); - va_end(ptr); - exit(1); -} +oberon_make_copy_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args); static oberon_type_t * oberon_new_type_ptr(int class) @@ -162,6 +84,129 @@ oberon_new_type_set(int size) return x; } +static oberon_expr_t * +oberon_new_operator(int op, oberon_type_t * result, oberon_expr_t * left, oberon_expr_t * right) +{ + oberon_oper_t * operator; + operator = malloc(sizeof *operator); + memset(operator, 0, sizeof *operator); + + operator -> is_item = 0; + operator -> result = result; + operator -> read_only = 1; + operator -> op = op; + operator -> left = left; + operator -> right = right; + + return (oberon_expr_t *) operator; +} + +static oberon_expr_t * +oberon_new_item(int mode, oberon_type_t * result, int read_only) +{ + oberon_item_t * item; + item = malloc(sizeof *item); + memset(item, 0, sizeof *item); + + item -> is_item = 1; + item -> result = result; + item -> read_only = read_only; + item -> mode = mode; + + return (oberon_expr_t *)item; +} + +static oberon_type_t * +oberon_get_type_of_int_value(oberon_context_t * ctx, int64_t i) +{ + if(i >= -128 && i <= 127) + { + return ctx -> byte_type; + } + else if(i >= -32768 && i <= 32767) + { + return ctx -> shortint_type; + } + else if(i >= -2147483648 && i <= 2147483647) + { + return ctx -> int_type; + } + else + { + return ctx -> longint_type; + } +} + +static oberon_expr_t * +oberon_make_integer(oberon_context_t * ctx, int64_t i) +{ + oberon_expr_t * expr; + oberon_type_t * result; + result = oberon_get_type_of_int_value(ctx, i); + expr = oberon_new_item(MODE_INTEGER, result, true); + expr -> item.integer = i; + expr -> item.real = i; + return expr; +} + +static oberon_expr_t * +oberon_make_char(oberon_context_t * ctx, int64_t i) +{ + oberon_expr_t * expr; + expr = oberon_new_item(MODE_CHAR, ctx -> char_type, true); + expr -> item.integer = i; + expr -> item.real = i; + return expr; +} + +static oberon_expr_t * +oberon_make_real_typed(oberon_context_t * ctx, double r, oberon_type_t * result) +{ + oberon_expr_t * expr; + expr = oberon_new_item(MODE_REAL, result, true); + expr -> item.integer = r; + expr -> item.real = r; + return expr; +} + +static oberon_expr_t * +oberon_make_real(oberon_context_t * ctx, double r, bool longmode) +{ + oberon_type_t * result; + result = (longmode) ? (ctx -> longreal_type) : (ctx -> real_type); + return oberon_make_real_typed(ctx, r, result); +} + +static oberon_expr_t * +oberon_make_boolean(oberon_context_t * ctx, bool cond) +{ + oberon_expr_t * expr; + expr = oberon_new_item(MODE_BOOLEAN, ctx -> bool_type, true); + expr -> item.integer = cond; + expr -> item.real = cond; + return expr; +} + +static oberon_expr_t * +oberon_make_set(oberon_context_t * ctx, int64_t i) +{ + oberon_expr_t * expr; + expr = oberon_new_item(MODE_SET, ctx -> set_type, true); + expr -> item.integer = i; + expr -> item.real = i; + return expr; +} + +static oberon_expr_t * +oberon_make_set_range(oberon_context_t * ctx, int64_t x, int64_t y) +{ + oberon_expr_t * expr; + expr = oberon_new_item(MODE_SET, ctx -> set_type, true); + expr -> item.integer = (x <= y) ? ((2 << y) - (1 << x)) : (0); + expr -> item.real = expr -> item.integer; + return expr; +} + // ======================================================================= // TABLE // ======================================================================= @@ -603,6 +648,7 @@ oberon_read_number(oberon_context_t * ctx) case 2: case 3: sscanf(ident, "%lf", &real); + integer = real; ctx -> token = REAL; break; case 4: @@ -690,6 +736,7 @@ static void oberon_read_string(oberon_context_t * ctx) ctx -> token = STRING; ctx -> string = string; + ctx -> integer = string[0]; } static void oberon_read_token(oberon_context_t * ctx); @@ -865,38 +912,7 @@ static char * oberon_assert_ident(oberon_context_t * ctx); static void oberon_type(oberon_context_t * ctx, oberon_type_t ** type); static oberon_item_t * oberon_const_expr(oberon_context_t * ctx); static oberon_expr_t * oberno_make_dereferencing(oberon_context_t * ctx, oberon_expr_t * expr); - -static oberon_expr_t * -oberon_new_operator(int op, oberon_type_t * result, oberon_expr_t * left, oberon_expr_t * right) -{ - oberon_oper_t * operator; - operator = malloc(sizeof *operator); - memset(operator, 0, sizeof *operator); - - operator -> is_item = 0; - operator -> result = result; - operator -> read_only = 1; - operator -> op = op; - operator -> left = left; - operator -> right = right; - - return (oberon_expr_t *) operator; -} - -static oberon_expr_t * -oberon_new_item(int mode, oberon_type_t * result, int read_only) -{ - oberon_item_t * item; - item = malloc(sizeof *item); - memset(item, 0, sizeof *item); - - item -> is_item = 1; - item -> result = result; - item -> read_only = read_only; - item -> mode = mode; - - return (oberon_expr_t *)item; -} +static bool oberon_is_const(oberon_expr_t * expr); static oberon_expr_t * oberon_make_unary_op(oberon_context_t * ctx, int token, oberon_expr_t * a) @@ -910,11 +926,36 @@ oberon_make_unary_op(oberon_context_t * ctx, int token, oberon_expr_t * a) { if(result -> class == OBERON_TYPE_SET) { - expr = oberon_new_operator(OP_COMPLEMENTATION, result, a, NULL); + if(oberon_is_const(a)) + { + expr = oberon_make_set(ctx, ~(a -> item.integer)); + } + else + { + expr = oberon_new_operator(OP_COMPLEMENTATION, result, a, NULL); + } } else if(result -> class == OBERON_TYPE_INTEGER) { - expr = oberon_new_operator(OP_UNARY_MINUS, result, a, NULL); + if(oberon_is_const(a)) + { + expr = oberon_make_integer(ctx, -(a -> item.integer)); + } + else + { + expr = oberon_new_operator(OP_UNARY_MINUS, result, a, NULL); + } + } + else if(result -> class == OBERON_TYPE_REAL) + { + if(oberon_is_const(a)) + { + expr = oberon_make_real_typed(ctx, -(a -> item.real), result); + } + else + { + expr = oberon_new_operator(OP_UNARY_MINUS, result, a, NULL); + } } else { @@ -928,7 +969,14 @@ oberon_make_unary_op(oberon_context_t * ctx, int token, oberon_expr_t * a) oberon_error(ctx, "incompatible operator type"); } - expr = oberon_new_operator(OP_LOGIC_NOT, result, a, NULL); + if(oberon_is_const(a)) + { + expr = oberon_make_boolean(ctx, !(a -> item.integer)); + } + else + { + expr = oberon_new_operator(OP_LOGIC_NOT, result, a, NULL); + } } else { @@ -975,86 +1023,30 @@ oberon_expr_list(oberon_context_t * ctx, int * num_expr, oberon_expr_t ** first, static oberon_expr_t * oberon_cast_expr(oberon_context_t * ctx, oberon_expr_t * expr, oberon_type_t * pref) { - return oberon_new_operator(OP_CAST, pref, expr, NULL); -} - -static oberon_expr_t * -oberno_make_record_cast(oberon_context_t * ctx, oberon_expr_t * expr, oberon_type_t * rec) -{ - oberon_type_t * from = expr -> result; - oberon_type_t * to = rec; - - if(from -> class == OBERON_TYPE_POINTER && to -> class == OBERON_TYPE_POINTER) - { - from = from -> base; - to = to -> base; - } - - if(from -> class != OBERON_TYPE_RECORD || to -> class != OBERON_TYPE_RECORD) - { - oberon_error(ctx, "must be record type"); - } - - return oberon_cast_expr(ctx, expr, rec); -} + oberon_expr_t * cast; -static oberon_type_t * -oberon_get_equal_expr_type(oberon_context_t * ctx, oberon_type_t * a, oberon_type_t * b) -{ - oberon_type_t * result; - if(a -> class == OBERON_TYPE_REAL && b -> class == OBERON_TYPE_INTEGER) - { - result = a; - } - else if(b -> class == OBERON_TYPE_REAL && a -> class == OBERON_TYPE_INTEGER) - { - result = b; - } - else if(a -> class != b -> class) + if((oberon_is_char_type(pref) && oberon_is_const_string(expr) && strlen(expr -> item.string) == 1)) { - oberon_error(ctx, "oberon_get_equal_expr_type: incompatible types"); - } - else if(a -> size > b -> size) - { - result = a; + /* Автоматически преобразуем строку единичного размера в символ */ + cast = oberon_new_item(MODE_CHAR, ctx -> char_type, true); + cast -> item.integer = expr -> item.string[0]; } else { - result = b; + cast = oberon_new_operator(OP_CAST, pref, expr, NULL); } - return result; + return cast; } static void -oberon_check_record_compatibility(oberon_context_t * ctx, oberon_type_t * from, oberon_type_t * to) +oberon_check_dst(oberon_context_t * ctx, oberon_expr_t * dst) { - if(from -> class == OBERON_TYPE_POINTER && to -> class == OBERON_TYPE_POINTER) - { - from = from -> base; - to = to -> base; - } - - if(from -> class != OBERON_TYPE_RECORD || to -> class != OBERON_TYPE_RECORD) - { - oberon_error(ctx, "not a record"); - } - - oberon_type_t * t = from; - while(t != NULL && t != to) - { - t = t -> base; - } - - if(t == NULL) + if(dst -> read_only) { - oberon_error(ctx, "incompatible record types"); + oberon_error(ctx, "read-only destination"); } -} -static void -oberon_check_dst(oberon_context_t * ctx, oberon_expr_t * dst) -{ if(dst -> is_item == false) { oberon_error(ctx, "not variable"); @@ -1088,132 +1080,6 @@ oberon_check_src(oberon_context_t * ctx, oberon_expr_t * src) } } -static oberon_expr_t * -oberon_autocast_to(oberon_context_t * ctx, oberon_expr_t * expr, oberon_type_t * pref) -{ - // Допускается: - // Если классы типов равны - // Если INTEGER переводится в REAL - // Если STRING переводится в CHAR - // Если STRING переводится в ARRAY OF CHAR - // Если NIL переводится в POINTER - // Если NIL переводится в PROCEDURE - - oberon_check_src(ctx, expr); - - bool error = false; - if(pref -> class != expr -> result -> class) - { - if(expr -> result -> class == OBERON_TYPE_NIL) - { - if(pref -> class != OBERON_TYPE_POINTER - && pref -> class != OBERON_TYPE_PROCEDURE) - { - error = true; - } - } - else if(expr -> result -> class == OBERON_TYPE_STRING) - { - if(pref -> class == OBERON_TYPE_CHAR) - { - if(expr -> is_item && expr -> item.mode == MODE_STRING) - { - if(strlen(expr -> item.string) != 1) - { - error = true; - } - } - else - { - error = true; - } - } - else if(pref -> class == OBERON_TYPE_ARRAY) - { - if(pref -> base -> class != OBERON_TYPE_CHAR) - { - error = true; - } - } - else - { - error = true; - } - } - else if(expr -> result -> class == OBERON_TYPE_INTEGER) - { - if(pref -> class != OBERON_TYPE_REAL) - { - error = true; - } - } - else - { - error = true; - } - } - - if(error) - { - oberon_error(ctx, "oberon_autocast_to: incompatible types"); - } - - if(pref -> class == OBERON_TYPE_CHAR) - { - if(expr -> result -> class == OBERON_TYPE_STRING) - { - int c = expr -> item.string[0]; - expr = oberon_new_item(MODE_CHAR, ctx -> char_type, true); - expr -> item.integer = c; - } - } - else if(pref -> class == OBERON_TYPE_INTEGER || pref -> class == OBERON_TYPE_REAL) - { - if(expr -> result -> size > pref -> size) - { - oberon_error(ctx, "incompatible size"); - } - else - { - expr = oberon_cast_expr(ctx, expr, pref); - } - } - else if(pref -> class == OBERON_TYPE_RECORD) - { - oberon_check_record_compatibility(ctx, expr -> result, pref); - expr = oberno_make_record_cast(ctx, expr, pref); - } - else if(pref -> class == OBERON_TYPE_POINTER) - { - assert(pref -> base); - if(expr -> result -> class == OBERON_TYPE_NIL) - { - // do nothing - } - else if(expr -> result -> base -> class == OBERON_TYPE_RECORD) - { - oberon_check_record_compatibility(ctx, expr -> result, pref); - expr = oberno_make_record_cast(ctx, expr, pref); - } - else if(expr -> result -> base != pref -> base) - { - oberon_error(ctx, "incompatible pointer types"); - } - } - - return expr; -} - -static void -oberon_autocast_binary_op(oberon_context_t * ctx, oberon_expr_t ** ea, oberon_expr_t ** eb) -{ - oberon_type_t * a = (*ea) -> result; - oberon_type_t * b = (*eb) -> result; - oberon_type_t * preq = oberon_get_equal_expr_type(ctx, a, b); - *ea = oberon_autocast_to(ctx, *ea, preq); - *eb = oberon_autocast_to(ctx, *eb, preq); -} - static void oberon_autocast_call(oberon_context_t * ctx, oberon_item_t * desig) { @@ -1243,19 +1109,21 @@ oberon_autocast_call(oberon_context_t * ctx, oberon_item_t * desig) { if(param -> class == OBERON_CLASS_VAR_PARAM) { - if(arg -> result != param -> type) - { - oberon_error(ctx, "incompatible type"); - } - if(arg -> read_only) + oberon_check_dst(ctx, arg); + if(!oberon_is_compatible_arrays(param, arg)) { - oberon_error(ctx, "assign to read-only var"); + oberon_check_compatible_var_param(ctx, param -> type, arg -> result); } - casted[i] = arg; + casted[i] = oberon_cast_expr(ctx, arg, param -> type); } else { - casted[i] = oberon_autocast_to(ctx, arg, param -> type); + oberon_check_src(ctx, arg); + if(!oberon_is_compatible_arrays(param, arg)) + { + oberon_check_assignment_compatible(ctx, arg, param -> type); + } + casted[i] = oberon_cast_expr(ctx, arg, param -> type); } arg = arg -> next; @@ -1573,47 +1441,6 @@ oberon_qualident_expr(oberon_context_t * ctx) return expr; } -static void -oberon_check_type_guard(oberon_context_t * ctx, oberon_expr_t * expr, oberon_type_t * type) -{ - /* Охрана типа применима, если */ - /* 1. v - параметр-переменная типа запись, или v - указатель, и если */ - /* 2. T - расширение статического типа v */ - - if(expr -> is_item - && expr -> item.mode == MODE_VAR - && expr -> item.var -> class == OBERON_CLASS_VAR_PARAM) - { - // accept - } - else if(expr -> result -> class == OBERON_TYPE_POINTER - || expr -> result -> class == OBERON_TYPE_RECORD) - { - // accept - } - else - { - oberon_error(ctx, "guard type used only with var-param or pointers"); - } - - oberon_check_record_compatibility(ctx, type, expr -> result); -} - -static oberon_expr_t * -oberon_make_type_guard(oberon_context_t * ctx, oberon_expr_t * expr, oberon_object_t * objtype) -{ - oberon_type_t * type; - - if(objtype -> class != OBERON_CLASS_TYPE) - { - oberon_error(ctx, "must be type"); - } - type = objtype -> type; - - oberon_check_type_guard(ctx, expr, type); - return oberno_make_record_cast(ctx, expr, objtype -> type); -} - static oberon_expr_t * oberon_designator(oberon_context_t * ctx) { @@ -1653,7 +1480,8 @@ oberon_designator(oberon_context_t * ctx) oberon_assert_token(ctx, LPAREN); objtype = oberon_qualident(ctx, NULL, true); oberon_assert_token(ctx, RPAREN); - expr = oberon_make_type_guard(ctx, expr, objtype); + oberon_check_extension_of(ctx, expr -> result, objtype -> type); + expr = oberon_cast_expr(ctx, expr, objtype -> type); break; default: oberon_error(ctx, "oberon_designator: wat"); @@ -1713,38 +1541,6 @@ oberon_opt_proc_parens(oberon_context_t * ctx, oberon_expr_t * expr) oberon_make_call_proc(ctx, (oberon_item_t *) expr, num_args, arguments); } -static oberon_type_t * -oberon_get_type_of_int_value(oberon_context_t * ctx, int64_t i) -{ - if(i >= -128 && i <= 127) - { - return ctx -> byte_type; - } - else if(i >= -32768 && i <= 32767) - { - return ctx -> shortint_type; - } - else if(i >= -2147483648 && i <= 2147483647) - { - return ctx -> int_type; - } - else - { - return ctx -> longint_type; - } -} - -static oberon_expr_t * -oberon_integer_item(oberon_context_t * ctx, int64_t i) -{ - oberon_expr_t * expr; - oberon_type_t * result; - result = oberon_get_type_of_int_value(ctx, i); - expr = oberon_new_item(MODE_INTEGER, result, true); - expr -> item.integer = i; - return expr; -} - static oberon_expr_t * oberon_element(oberon_context_t * ctx) { @@ -1752,6 +1548,7 @@ oberon_element(oberon_context_t * ctx) oberon_expr_t * e2; e1 = oberon_expr(ctx); + oberon_check_src(ctx, e1); if(e1 -> result -> class != OBERON_TYPE_INTEGER) { oberon_error(ctx, "expected integer"); @@ -1762,6 +1559,7 @@ oberon_element(oberon_context_t * ctx) { oberon_assert_token(ctx, DOTDOT); e2 = oberon_expr(ctx); + oberon_check_src(ctx, e2); if(e2 -> result -> class != OBERON_TYPE_INTEGER) { oberon_error(ctx, "expected integer"); @@ -1769,28 +1567,51 @@ oberon_element(oberon_context_t * ctx) } oberon_expr_t * set; - set = oberon_new_operator(OP_RANGE, ctx -> set_type, e1, e2); + if(e2 == NULL && oberon_is_const(e1)) + { + set = oberon_make_set(ctx, e1 -> item.integer); + } + else if(e2 != NULL && oberon_is_const(e1) && oberon_is_const(e2)) + { + set = oberon_make_set_range(ctx, e1 -> item.integer, e2 -> item.integer); + } + else + { + set = oberon_new_operator(OP_RANGE, ctx -> set_type, e1, e2); + } return set; } +static oberon_expr_t * +oberon_make_set_union(oberon_context_t * ctx, oberon_expr_t * a, oberon_expr_t * b) +{ + if(oberon_is_const(a) && oberon_is_const(b)) + { + return oberon_make_set(ctx, (a -> item.integer | b -> item.integer)); + } + else + { + return oberon_new_operator(OP_UNION, ctx -> set_type, a, b); + } +} + static oberon_expr_t * oberon_set(oberon_context_t * ctx) { oberon_expr_t * set; oberon_expr_t * elements; - set = oberon_new_item(MODE_SET, ctx -> set_type, true); - set -> item.integer = 0; + set = oberon_make_set(ctx, 0); oberon_assert_token(ctx, LBRACE); if(ISEXPR(ctx -> token)) { elements = oberon_element(ctx); - set = oberon_new_operator(OP_UNION, ctx -> set_type, set, elements); + set = oberon_make_set_union(ctx, set, elements); while(ctx -> token == COMMA) { oberon_assert_token(ctx, COMMA); elements = oberon_element(ctx); - set = oberon_new_operator(OP_UNION, ctx -> set_type, set, elements); + set = oberon_make_set_union(ctx, set, elements); } } oberon_assert_token(ctx, RBRACE); @@ -1798,15 +1619,6 @@ oberon_set(oberon_context_t * ctx) return set; } -static oberon_expr_t * -oberon_make_boolean(oberon_context_t * ctx, bool cond) -{ - oberon_expr_t * expr; - expr = oberon_new_item(MODE_BOOLEAN, ctx -> bool_type, true); - expr -> item.integer = cond; - return expr; -} - static oberon_expr_t * oberon_factor(oberon_context_t * ctx) { @@ -1820,7 +1632,7 @@ oberon_factor(oberon_context_t * ctx) expr = oberon_opt_func_parens(ctx, expr); break; case INTEGER: - expr = oberon_integer_item(ctx, ctx -> integer); + expr = oberon_make_integer(ctx, ctx -> integer); oberon_assert_token(ctx, INTEGER); break; case CHAR: @@ -1836,9 +1648,7 @@ oberon_factor(oberon_context_t * ctx) oberon_assert_token(ctx, STRING); break; case REAL: - result = (ctx -> longmode) ? (ctx -> longreal_type) : (ctx -> real_type); - expr = oberon_new_item(MODE_REAL, result, 1); - expr -> item.real = ctx -> real; + expr = oberon_make_real(ctx, ctx -> real, ctx -> longmode); oberon_assert_token(ctx, REAL); break; case LBRACE: @@ -1865,295 +1675,233 @@ oberon_factor(oberon_context_t * ctx) return expr; } -static void -oberon_autocast_to_real(oberon_context_t * ctx, oberon_expr_t ** e) -{ - oberon_expr_t * expr = *e; - if(expr -> result -> class == OBERON_TYPE_INTEGER) - { - if(expr -> result -> size <= ctx -> real_type -> size) - { - *e = oberon_cast_expr(ctx, expr, ctx -> real_type); - } - else - { - *e = oberon_cast_expr(ctx, expr, ctx -> longreal_type); - } - } - else if(expr -> result -> class != OBERON_TYPE_REAL) - { - oberon_error(ctx, "required numeric type"); - } -} - -static bool -oberon_is_numeric_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_INTEGER) || (t -> class == OBERON_TYPE_REAL); -} - -static bool -oberon_is_char_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_CHAR); -} - -static bool -oberon_is_string_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_STRING) - || (t -> class == OBERON_TYPE_ARRAY && t -> base -> class == OBERON_TYPE_CHAR); -} - -static bool -oberon_is_boolean_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_BOOLEAN); -} - -static bool -oberon_is_set_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_SET); -} - -static bool -oberon_is_pointer_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_POINTER) || (t -> class == OBERON_TYPE_NIL); -} - -static bool -oberon_is_procedure_type(oberon_type_t * t) -{ - return (t -> class == OBERON_TYPE_POINTER) || (t -> class == OBERON_TYPE_NIL); -} - static oberon_expr_t * oberon_make_bin_op(oberon_context_t * ctx, int token, oberon_expr_t * a, oberon_expr_t * b) { oberon_expr_t * expr; oberon_type_t * result; - bool error = false; + oberon_check_compatible_bin_expr_types(ctx, token, a -> result, b -> result); + oberon_check_src(ctx, a); + if(token != IS) + { + oberon_check_src(ctx, b); + } + if(token == IN) { - if(a -> result -> class != OBERON_TYPE_INTEGER) + if(oberon_is_const(a) && oberon_is_const(b)) { - oberon_error(ctx, "must be integer"); + expr = oberon_make_boolean(ctx, (1 << a -> item.integer) & b -> item.integer); } - - if(b -> result -> class != OBERON_TYPE_SET) + else { - oberon_error(ctx, "must be set"); + expr = oberon_new_operator(OP_IN, ctx -> bool_type, a, b); } - - result = ctx -> bool_type; - expr = oberon_new_operator(OP_IN, result, a, b); } else if(token == IS) { - if(b -> is_item == false || b -> item.mode != MODE_TYPE) - { - oberon_error(ctx, "requires type"); - } - - result = ctx -> bool_type; - oberon_check_type_guard(ctx, a, b -> result); - expr = oberon_new_operator(OP_IS, result, a, b); + oberon_check_type_expr(ctx, b); + expr = oberon_new_operator(OP_IS, ctx -> bool_type, a, b); } else if((token >= EQUAL && token <= GEQ) || token == OR || token == AND) { - if(token >= LESS && token <= GEQ) - { - if(oberon_is_numeric_type(a -> result) && oberon_is_numeric_type(b -> result)) - { - // accept - } - else if(oberon_is_char_type(a -> result) && oberon_is_char_type(b -> result)) - { - // accept - } - else if(oberon_is_string_type(a -> result) && oberon_is_string_type(b -> result)) - { - // accept - } - else - { - oberon_error(ctx, "invalid comparation"); - } - } - else if(token == EQUAL || token == NEQ) + result = oberon_get_longer_type(ctx, a -> result, b -> result); + + if(oberon_is_const(a) && oberon_is_const(b) + && (oberon_is_real_type(result) || oberon_is_integer_type(result))) { - if(oberon_is_numeric_type(a -> result) && oberon_is_numeric_type(b -> result)) - { - // accept - } - else if(oberon_is_char_type(a -> result) && oberon_is_char_type(b -> result)) - { - // accept - } - else if(oberon_is_string_type(a -> result) && oberon_is_string_type(b -> result)) - { - // accept - } - else if(oberon_is_boolean_type(a -> result) && oberon_is_boolean_type(b -> result)) + if(oberon_is_real_type(result)) { - // accept - } - else if(oberon_is_set_type(a -> result) && oberon_is_set_type(b -> result)) - { - // accept - } - else if(oberon_is_pointer_type(a -> result) && oberon_is_pointer_type(b -> result)) - { - // accept + double x = a -> item.real; + double y = b -> item.real; + switch(token) + { + case EQUAL: expr = oberon_make_boolean(ctx, x == y); break; + case NEQ: expr = oberon_make_boolean(ctx, x != y); break; + case LESS: expr = oberon_make_boolean(ctx, x < y); break; + case LEQ: expr = oberon_make_boolean(ctx, x <= y); break; + case GREAT: expr = oberon_make_boolean(ctx, x > y); break; + case GEQ: expr = oberon_make_boolean(ctx, x >= y); break; + case OR: expr = oberon_make_boolean(ctx, x || y); break; + case AND: expr = oberon_make_boolean(ctx, x && y); break; + default: assert(0); break; + } } - else if(oberon_is_procedure_type(a -> result) && oberon_is_procedure_type(b -> result)) + else if(oberon_is_integer_type(result)) { - // accept + int64_t x = a -> item.integer; + int64_t y = b -> item.integer; + switch(token) + { + case EQUAL: expr = oberon_make_boolean(ctx, x == y); break; + case NEQ: expr = oberon_make_boolean(ctx, x != y); break; + case LESS: expr = oberon_make_boolean(ctx, x < y); break; + case LEQ: expr = oberon_make_boolean(ctx, x <= y); break; + case GREAT: expr = oberon_make_boolean(ctx, x > y); break; + case GEQ: expr = oberon_make_boolean(ctx, x >= y); break; + case OR: expr = oberon_make_boolean(ctx, x || y); break; + case AND: expr = oberon_make_boolean(ctx, x && y); break; + default: assert(0); break; + } } else { - oberon_error(ctx, "invalid comparation"); + assert(0); } } - else if(token == AND || token == OR) - { - if(!oberon_is_boolean_type(a -> result) || !oberon_is_boolean_type(b -> result)) - { - oberon_error(ctx, "invalid comparation"); - } - } - else - { - oberon_error(ctx, "wat"); - } - - oberon_autocast_binary_op(ctx, &a, &b); - result = ctx -> bool_type; - - if(token == EQUAL) - { - expr = oberon_new_operator(OP_EQ, result, a, b); - } - else if(token == NEQ) - { - expr = oberon_new_operator(OP_NEQ, result, a, b); - } - else if(token == LESS) - { - expr = oberon_new_operator(OP_LSS, result, a, b); - } - else if(token == LEQ) - { - expr = oberon_new_operator(OP_LEQ, result, a, b); - } - else if(token == GREAT) - { - expr = oberon_new_operator(OP_GRT, result, a, b); - } - else if(token == GEQ) - { - expr = oberon_new_operator(OP_GEQ, result, a, b); - } - else if(token == OR) - { - expr = oberon_new_operator(OP_LOGIC_OR, result, a, b); - } - else if(token == AND) - { - expr = oberon_new_operator(OP_LOGIC_AND, result, a, b); - } else { - oberon_error(ctx, "oberon_make_bin_op: bool wat"); + a = oberon_cast_expr(ctx, a, result); + b = oberon_cast_expr(ctx, b, result); + result = ctx -> bool_type; + switch(token) + { + case EQUAL: expr = oberon_new_operator(OP_EQ, result, a, b); break; + case NEQ: expr = oberon_new_operator(OP_NEQ, result, a, b); break; + case LESS: expr = oberon_new_operator(OP_LSS, result, a, b); break; + case LEQ: expr = oberon_new_operator(OP_LEQ, result, a, b); break; + case GREAT: expr = oberon_new_operator(OP_GRT, result, a, b); break; + case GEQ: expr = oberon_new_operator(OP_GEQ, result, a, b); break; + case OR: expr = oberon_new_operator(OP_LOGIC_OR, result, a, b); break; + case AND: expr = oberon_new_operator(OP_LOGIC_AND, result, a, b); break; + default: assert(0); break; + } } } else if(token == SLASH) { - if(a -> result -> class == OBERON_TYPE_SET - || b -> result -> class == OBERON_TYPE_SET) + if(oberon_is_set_type(a -> result) && oberon_is_set_type(b -> result)) { - oberon_autocast_binary_op(ctx, &a, &b); - result = a -> result; - expr = oberon_new_operator(OP_SYM_DIFFERENCE, result, a, b); + if(oberon_is_const(a) && oberon_is_const(b)) + { + int64_t x = a -> item.integer; + int64_t y = b -> item.integer; + expr = oberon_make_set(ctx, x ^ y); + } + else + { + result = oberon_get_longer_type(ctx, a -> result, b -> result); + a = oberon_cast_expr(ctx, a, result); + b = oberon_cast_expr(ctx, b, result); + expr = oberon_new_operator(OP_SYM_DIFFERENCE, result, a, b); + } } else { - oberon_autocast_to_real(ctx, &a); - oberon_autocast_to_real(ctx, &b); - oberon_autocast_binary_op(ctx, &a, &b); - result = a -> result; - expr = oberon_new_operator(OP_DIV, result, a, b); - } - } - else if(token == DIV) - { - if(a -> result -> class != OBERON_TYPE_INTEGER - || b -> result -> class != OBERON_TYPE_INTEGER) - { - oberon_error(ctx, "operator DIV requires integer type"); + result = oberon_get_longer_real_type(ctx, a -> result, b -> result); + if(oberon_is_const(a) && oberon_is_const(b)) + { + double x = a -> item.real; + double y = b -> item.real; + expr = oberon_make_real_typed(ctx, x / y, result); + } + else + { + a = oberon_cast_expr(ctx, a, result); + b = oberon_cast_expr(ctx, b, result); + expr = oberon_new_operator(OP_DIV, result, a, b); + } } - - oberon_autocast_binary_op(ctx, &a, &b); - expr = oberon_new_operator(OP_DIV, a -> result, a, b); } else { - oberon_autocast_binary_op(ctx, &a, &b); - result = a -> result; - if(result -> class == OBERON_TYPE_SET) + result = oberon_get_longer_type(ctx, a -> result, b -> result); + + if(oberon_is_const(a) && oberon_is_const(b)) { - switch(token) + if(oberon_is_set_type(result)) { - case PLUS: - expr = oberon_new_operator(OP_UNION, result, a, b); - break; - case MINUS: - expr = oberon_new_operator(OP_DIFFERENCE, result, a, b); - break; - case STAR: - expr = oberon_new_operator(OP_INTERSECTION, result, a, b); - break; - default: - error = true; - break; + int64_t x = a -> item.integer; + int64_t y = b -> item.integer; + switch(token) + { + case PLUS: expr = oberon_make_set(ctx, x | y); break; + case MINUS: expr = oberon_make_set(ctx, x & ~y); break; + case STAR: expr = oberon_make_set(ctx, x & y); break; + default: assert(0); break; + } } - } - else if(result -> class == OBERON_TYPE_INTEGER - || result -> class == OBERON_TYPE_REAL) - { - switch(token) + if(oberon_is_real_type(result)) + { + double x = a -> item.real; + double y = b -> item.real; + switch(token) + { + case PLUS: expr = oberon_make_real_typed(ctx, x + y, result); break; + case MINUS: expr = oberon_make_real_typed(ctx, x - y, result); break; + case STAR: expr = oberon_make_real_typed(ctx, x * y, result); break; + default: assert(0); break; + } + } + else if(oberon_is_integer_type(result)) + { + int64_t x = a -> item.integer; + int64_t y = b -> item.integer; + switch(token) + { + case PLUS: expr = oberon_make_integer(ctx, x + y); break; + case MINUS: expr = oberon_make_integer(ctx, x - y); break; + case STAR: expr = oberon_make_integer(ctx, x * y); break; + case DIV: expr = oberon_make_integer(ctx, x / y); break; + case MOD: expr = oberon_make_integer(ctx, x % y); break; + default: assert(0); break; + } + } + else { - case PLUS: - expr = oberon_new_operator(OP_ADD, result, a, b); - break; - case MINUS: - expr = oberon_new_operator(OP_SUB, result, a, b); - break; - case STAR: - expr = oberon_new_operator(OP_MUL, result, a, b); - break; - case MOD: - expr = oberon_new_operator(OP_MOD, result, a, b); - break; - default: - error = true; - break; + assert(0); } } else { - error = true; + a = oberon_cast_expr(ctx, a, result); + b = oberon_cast_expr(ctx, b, result); + + + if(oberon_is_set_type(result)) + { + switch(token) + { + case PLUS: + expr = oberon_new_operator(OP_UNION, result, a, b); + break; + case MINUS: + expr = oberon_new_operator(OP_DIFFERENCE, result, a, b); + break; + case STAR: + expr = oberon_new_operator(OP_INTERSECTION, result, a, b); + break; + default: + assert(0); + break; + } + } + else if(oberon_is_number_type(result)) + { + switch(token) + { + case PLUS: + expr = oberon_new_operator(OP_ADD, result, a, b); + break; + case MINUS: + expr = oberon_new_operator(OP_SUB, result, a, b); + break; + case STAR: + expr = oberon_new_operator(OP_MUL, result, a, b); + break; + default: + assert(0); + break; + } + } + else + { + assert(0); + } } } - if(error) - { - oberon_error(ctx, "invalid operation"); - } - return expr; } @@ -2238,12 +1986,12 @@ oberon_expr(oberon_context_t * ctx) return expr; } -static void -oberon_check_const(oberon_context_t * ctx, oberon_expr_t * expr) +static bool +oberon_is_const(oberon_expr_t * expr) { - if(expr -> is_item == 0) + if(expr -> is_item == false) { - oberon_error(ctx, "const expression are required"); + return false; } switch(expr -> item.mode) @@ -2254,13 +2002,25 @@ oberon_check_const(oberon_context_t * ctx, oberon_expr_t * expr) case MODE_REAL: case MODE_CHAR: case MODE_STRING: + case MODE_SET: case MODE_TYPE: - /* accept */ + return true; break; default: - oberon_error(ctx, "const expression are required"); + return false; break; } + + return false; +} + +static void +oberon_check_const(oberon_context_t * ctx, oberon_expr_t * expr) +{ + if(!oberon_is_const(expr)) + { + oberon_error(ctx, "const expression are required"); + } } static oberon_item_t * @@ -2436,6 +2196,11 @@ oberon_formal_pars(oberon_context_t * ctx, oberon_type_t * signature) { oberon_error(ctx, "function result is not type"); } + if(typeobj -> type -> class == OBERON_TYPE_RECORD + || typeobj -> type -> class == OBERON_TYPE_ARRAY) + { + oberon_error(ctx, "records or arrays could not be result of function"); + } signature -> base = typeobj -> type; } } @@ -2504,7 +2269,9 @@ oberon_make_return(oberon_context_t * ctx, oberon_expr_t * expr) oberon_error(ctx, "procedure requires expression on result"); } - expr = oberon_autocast_to(ctx, expr, result_type); + oberon_check_src(ctx, expr); + oberon_check_assignment_compatible(ctx, expr, result_type); + expr = oberon_cast_expr(ctx, expr, result_type); } proc -> has_return = 1; @@ -3314,14 +3081,20 @@ oberon_statement_seq(oberon_context_t * ctx); static void oberon_assign(oberon_context_t * ctx, oberon_expr_t * src, oberon_expr_t * dst) { - if(dst -> read_only) + oberon_check_dst(ctx, dst); + oberon_check_assignment_compatible(ctx, src, dst -> result); + + if(oberon_is_array_of_char_type(dst -> result) + && oberon_is_string_type(src -> result)) { - oberon_error(ctx, "read-only destination"); + src -> next = dst; + oberon_make_copy_call(ctx, 2, src); + } + else + { + src = oberon_cast_expr(ctx, src, dst -> result); + oberon_generate_assign(ctx, src, dst); } - - oberon_check_dst(ctx, dst); - src = oberon_autocast_to(ctx, src, dst -> result); - oberon_generate_assign(ctx, src, dst); } static oberon_expr_t * @@ -3333,14 +3106,12 @@ oberon_case_labels(oberon_context_t * ctx, oberon_expr_t * val) oberon_expr_t * cond2; e1 = (oberon_expr_t *) oberon_const_expr(ctx); - oberon_autocast_to(ctx, e1, val -> result); e2 = NULL; if(ctx -> token == DOTDOT) { oberon_assert_token(ctx, DOTDOT); e2 = (oberon_expr_t *) oberon_const_expr(ctx); - oberon_autocast_to(ctx, e2, val -> result); } if(e2 == NULL) @@ -3414,6 +3185,10 @@ oberon_case_statement(oberon_context_t * ctx) oberon_assert_token(ctx, ELSE); oberon_statement_seq(ctx); } + else + { + oberon_generate_trap(ctx, -1); + } oberon_generate_label(ctx, end); oberon_assert_token(ctx, END); @@ -3443,7 +3218,8 @@ oberon_with_guard_do(oberon_context_t * ctx, gen_label_t * end) /* Сохраняем ссылку во временной переменной */ val = oberon_make_temp_var_item(ctx, type -> result); - cast = oberno_make_record_cast(ctx, var, type -> result); + //cast = oberno_make_record_cast(ctx, var, type -> result); + cast = oberon_cast_expr(ctx, var, type -> result); oberon_assign(ctx, cast, val); /* Подменяем тип у оригинальной переменной */ old_type = var -> item.var -> type; @@ -3480,6 +3256,10 @@ oberon_with_statement(oberon_context_t * ctx) oberon_assert_token(ctx, ELSE); oberon_statement_seq(ctx); } + else + { + oberon_generate_trap(ctx, -2); + } oberon_generate_label(ctx, end); oberon_assert_token(ctx, END); @@ -3620,11 +3400,11 @@ oberon_statement(oberon_context_t * ctx) index = oberon_ident_item(ctx, iname); oberon_assert_token(ctx, ASSIGN); from = oberon_expr(ctx); - oberon_assign(ctx, from, index); oberon_assert_token(ctx, TO); bound = oberon_make_temp_var_item(ctx, index -> result); to = oberon_expr(ctx); - oberon_assign(ctx, to, bound); + oberon_assign(ctx, to, bound); // сначала temp + oberon_assign(ctx, from, index); // потом i if(ctx -> token == BY) { oberon_assert_token(ctx, BY); @@ -3632,7 +3412,7 @@ oberon_statement(oberon_context_t * ctx) } else { - by = oberon_integer_item(ctx, 1); + by = oberon_make_integer(ctx, 1); } if(by -> result -> class != OBERON_TYPE_INTEGER) @@ -3901,7 +3681,7 @@ oberon_make_min_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ oberon_expr_t * arg; arg = list_args; - if(!arg -> is_item || arg -> item.mode != MODE_TYPE) + if(!oberon_is_type_expr(arg)) { oberon_error(ctx, "MIN accept only type"); } @@ -3911,10 +3691,19 @@ oberon_make_min_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ switch(arg -> result -> class) { case OBERON_TYPE_INTEGER: - expr = oberon_integer_item(ctx, -powl(2, bits - 1)); + expr = oberon_make_integer(ctx, -powl(2, bits - 1)); + break; + case OBERON_TYPE_BOOLEAN: + expr = oberon_make_boolean(ctx, false); + break; + case OBERON_TYPE_CHAR: + expr = oberon_make_char(ctx, 0); + break; + case OBERON_TYPE_REAL: + expr = oberon_make_real_typed(ctx, (bits <= 32) ? (-FLT_MAX) : (-DBL_MAX), arg -> result); break; case OBERON_TYPE_SET: - expr = oberon_integer_item(ctx, 0); + expr = oberon_make_integer(ctx, 0); break; default: oberon_error(ctx, "allowed only basic types"); @@ -3940,7 +3729,7 @@ oberon_make_max_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ oberon_expr_t * arg; arg = list_args; - if(!arg -> is_item || arg -> item.mode != MODE_TYPE) + if(!oberon_is_type_expr(arg)) { oberon_error(ctx, "MAX accept only type"); } @@ -3950,10 +3739,19 @@ oberon_make_max_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ switch(arg -> result -> class) { case OBERON_TYPE_INTEGER: - expr = oberon_integer_item(ctx, powl(2, bits - 1) - 1); + expr = oberon_make_integer(ctx, powl(2, bits - 1) - 1); + break; + case OBERON_TYPE_BOOLEAN: + expr = oberon_make_boolean(ctx, true); + break; + case OBERON_TYPE_CHAR: + expr = oberon_make_char(ctx, powl(2, bits) - 1); + break; + case OBERON_TYPE_REAL: + expr = oberon_make_real_typed(ctx, (bits <= 32) ? (FLT_MAX) : (DBL_MAX), arg -> result); break; case OBERON_TYPE_SET: - expr = oberon_integer_item(ctx, bits); + expr = oberon_make_integer(ctx, bits); break; default: oberon_error(ctx, "allowed only basic types"); @@ -3978,8 +3776,7 @@ oberon_make_size_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list oberon_expr_t * arg; arg = list_args; - - if(!arg -> is_item || arg -> item.mode != MODE_TYPE) + if(!oberon_is_type_expr(arg)) { oberon_error(ctx, "SIZE accept only type"); } @@ -4001,7 +3798,7 @@ oberon_make_size_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list break; } - expr = oberon_integer_item(ctx, size); + expr = oberon_make_integer(ctx, size); return expr; } @@ -4022,16 +3819,29 @@ oberon_make_abs_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ arg = list_args; oberon_check_src(ctx, arg); - oberon_type_t * result_type; - result_type = arg -> result; - - if(result_type -> class != OBERON_TYPE_INTEGER) + if(oberon_is_number_type(arg -> result)) { - oberon_error(ctx, "ABS accepts only integers"); + oberon_error(ctx, "ABS accepts only numbers"); } oberon_expr_t * expr; - expr = oberon_new_operator(OP_ABS, result_type, arg, NULL); + if(oberon_is_const(arg)) + { + if(oberon_is_real_type(arg -> result)) + { + double x = arg -> item.real; + expr = oberon_make_real(ctx, fabsl(x), arg -> result); + } + else + { + int64_t x = arg -> item.integer; + expr = oberon_make_integer(ctx, llabs(x)); + } + } + else + { + expr = oberon_new_operator(OP_ABS, arg -> result, arg, NULL); + } return expr; } @@ -4043,7 +3853,6 @@ oberon_make_new_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ oberon_error(ctx, "too few arguments"); } - oberon_expr_t * dst; dst = list_args; oberon_check_dst(ctx, dst); @@ -4119,6 +3928,217 @@ oberon_make_new_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_ oberon_assign(ctx, src, dst); } +static void +oberon_make_copy_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args) +{ + if(num_args < 2) + { + oberon_error(ctx, "too few arguments"); + } + + if(num_args > 2) + { + oberon_error(ctx, "too mach arguments"); + } + + oberon_expr_t * src; + src = list_args; + oberon_check_src(ctx, src); + + oberon_expr_t * dst; + dst = list_args -> next; + oberon_check_dst(ctx, dst); + + if(!oberon_is_string_type(src -> result) && !oberon_is_array_of_char_type(src -> result)) + { + oberon_error(ctx, "source must be string or array of char"); + } + + if(!oberon_is_array_of_char_type(dst -> result)) + { + oberon_error(ctx, "dst must be array of char"); + } + + oberon_generate_copy(ctx, src, dst); +} + +static void +oberon_make_assert_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args) +{ + if(num_args < 1) + { + oberon_error(ctx, "too few arguments"); + } + + if(num_args > 2) + { + oberon_error(ctx, "too mach arguments"); + } + + oberon_expr_t * cond; + cond = list_args; + oberon_check_src(ctx, cond); + + if(!oberon_is_boolean_type(cond -> result)) + { + oberon_error(ctx, "expected boolean"); + } + + if(num_args == 1) + { + oberon_generate_assert(ctx, cond); + } + else + { + oberon_expr_t * num; + num = list_args -> next; + oberon_check_src(ctx, num); + + if(!oberon_is_integer_type(num -> result)) + { + oberon_error(ctx, "expected integer"); + } + + oberon_check_const(ctx, num); + + oberon_generate_assert_n(ctx, cond, num -> item.integer); + } +} + +static void +oberon_make_halt_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args) +{ + if(num_args < 1) + { + oberon_error(ctx, "too few arguments"); + } + + if(num_args > 1) + { + oberon_error(ctx, "too mach arguments"); + } + + oberon_expr_t * num; + num = list_args; + oberon_check_src(ctx, num); + + if(num -> result -> class != OBERON_TYPE_INTEGER) + { + oberon_error(ctx, "expected integer"); + } + + oberon_check_const(ctx, num); + + oberon_generate_halt(ctx, num -> item.integer); +} + +static oberon_expr_t * +oberon_make_ash_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args) +{ + if(num_args < 2) + { + oberon_error(ctx, "too few arguments"); + } + + if(num_args > 2) + { + oberon_error(ctx, "too mach arguments"); + } + + oberon_expr_t * arg1; + arg1 = list_args; + oberon_check_src(ctx, arg1); + if(arg1 -> result -> class != OBERON_TYPE_INTEGER) + { + oberon_error(ctx, "expected integer"); + } + + oberon_expr_t * arg2; + arg2 = list_args -> next; + oberon_check_src(ctx, arg2); + if(arg2 -> result -> class != OBERON_TYPE_INTEGER) + { + oberon_error(ctx, "expected integer"); + } + + oberon_expr_t * expr; + if(oberon_is_const(arg1) && oberon_is_const(arg2)) + { + int64_t x = arg1 -> item.integer; + int64_t y = arg2 -> item.integer; + expr = oberon_make_integer(ctx, x * powl(2, y)); + } + else + { + expr = oberon_new_operator(OP_ASH, arg1 -> result, arg1, arg2); + } + + return expr; +} + +static oberon_expr_t * +oberon_make_cap_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args) +{ + if(num_args < 1) + { + oberon_error(ctx, "too few arguments"); + } + + if(num_args > 1) + { + oberon_error(ctx, "too mach arguments"); + } + + oberon_expr_t * arg; + arg = list_args; + oberon_check_src(ctx, arg); + + if(!oberon_is_char_type(arg -> result)) + { + oberon_error(ctx, "expected char"); + } + + oberon_expr_t * expr; + if(oberon_is_const(arg)) + { + expr = oberon_make_char(ctx, toupper(arg -> item.integer)); + } + else + { + expr = oberon_new_operator(OP_CAP, arg -> result, arg, NULL); + } + + return expr; +} + +static oberon_expr_t * +oberon_make_odd_call(oberon_context_t * ctx, int num_args, oberon_expr_t * list_args) +{ + if(num_args < 1) + { + oberon_error(ctx, "too few arguments"); + } + + if(num_args > 1) + { + oberon_error(ctx, "too mach arguments"); + } + + oberon_expr_t * arg; + arg = list_args; + oberon_check_src(ctx, arg); + + if(!oberon_is_integer_type(arg -> result)) + { + oberon_error(ctx, "expected integer"); + } + + oberon_expr_t * expr; + expr = oberon_make_bin_op(ctx, MOD, arg, oberon_make_integer(ctx, 2)); + expr = oberon_make_bin_op(ctx, EQUAL, expr, oberon_make_integer(ctx, 1)); + return expr; +} + static void oberon_new_const(oberon_context_t * ctx, char * name, oberon_expr_t * expr) { @@ -4149,12 +4169,18 @@ oberon_create_context(ModuleImportCallback import_module) /* Functions */ oberon_new_intrinsic(ctx, "ABS", oberon_make_abs_call, NULL); + oberon_new_intrinsic(ctx, "ASH", oberon_make_ash_call, NULL); + oberon_new_intrinsic(ctx, "CAP", oberon_make_cap_call, NULL); oberon_new_intrinsic(ctx, "MIN", oberon_make_min_call, NULL); oberon_new_intrinsic(ctx, "MAX", oberon_make_max_call, NULL); + oberon_new_intrinsic(ctx, "ODD", oberon_make_odd_call, NULL); oberon_new_intrinsic(ctx, "SIZE", oberon_make_size_call, NULL); /* Procedures */ oberon_new_intrinsic(ctx, "NEW", NULL, oberon_make_new_call); + oberon_new_intrinsic(ctx, "COPY", NULL, oberon_make_copy_call); + oberon_new_intrinsic(ctx, "ASSERT", NULL, oberon_make_assert_call); + oberon_new_intrinsic(ctx, "HALT", NULL, oberon_make_halt_call); return ctx; }