mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2025-12-30 09:54:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Closed range ... (both inclusive); Type comparisons with == and !=

Browse Source
This commit is contained in:
Ginger Bill
2017-01-19 11:29:15 +00:00
parent 2af9fb79dc
commit 4603d2525e
7 changed files with 129 additions and 267 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
code/demo.odin
View File

@@ -10,46 +10,45 @@
#import "utf8.odin";
main :: proc() {
foo :: proc(x: ^i32) -> (int, int) {
fmt.println("^int");
return 123, int(x^);
}
foo :: proc(x: rawptr) {
fmt.println("rawptr");
}
// foo :: proc(x: ^i32) -> (int, int) {
// fmt.println("^int");
// return 123, int(x^);
// }
// foo :: proc(x: rawptr) {
// fmt.println("rawptr");
// }
// THINGI :: 14451;
// THINGF :: 14451.1;
THINGI :: 14451;
THINGF :: 14451.1;
// a: i32 = 111111;
// b: f32;
// c: rawptr;
// fmt.println(foo(^a));
// foo(^b);
// foo(c);
// // foo(nil);
// atomic.store(^a, 1);
a: i32 = 111111;
b: f32;
c: rawptr;
fmt.println(foo(^a));
foo(^b);
foo(c);
// foo(nil);
atomic.store(^a, 1);
// foo :: proc() {
// fmt.printf("Zero args\n");
// }
// foo :: proc(i: int) {
// fmt.printf("int arg, i=%d\n", i);
// }
// foo :: proc(f: f64) {
// i := int(f);
// fmt.printf("f64 arg, f=%d\n", i);
// }
foo :: proc() {
fmt.printf("Zero args\n");
}
foo :: proc(i: int) {
fmt.printf("int arg, i=%d\n", i);
}
foo :: proc(f: f64) {
i := int(f);
fmt.printf("f64 arg, f=%d\n", i);
}
// foo();
// // foo(THINGI);
// foo(THINGF);
// foo(int(THINGI));
// fmt.println(THINGI);
// fmt.println(THINGF);
foo();
foo(int(THINGI));
// foo(THINGI);
foo(THINGF);
fmt.println(THINGI);
fmt.println(THINGF);
f: proc();
f = foo;
f();
// f: proc();
// f = foo;
// f();
}

2
core/fmt.odin
View File

@@ -890,7 +890,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, verb: rune, prec, bit_size: int) ->
}
return buf[:0];
return buf[:i];
}
fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) {

264
src/check_expr.c
View File

@@ -26,6 +26,23 @@ gb_inline Type *check_type(Checker *c, AstNode *expression) {
}
void error_operand_not_expression(Operand *o) {
if (o->mode == Addressing_Type) {
gbString err = expr_to_string(o->expr);
error_node(o->expr, "`%s` is not an expression", err);
gb_string_free(err);
o->mode = Addressing_Invalid;
}
}
void error_operand_no_value(Operand *o) {
if (o->mode == Addressing_NoValue) {
gbString err = expr_to_string(o->expr);
error_node(o->expr, "`%s` used as value", err);
gb_string_free(err);
o->mode = Addressing_Invalid;
}
}
void check_scope_decls(Checker *c, AstNodeArray nodes, isize reserve_size) {
@@ -1547,8 +1564,19 @@ void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) {
}
void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) {
gbString err_str = NULL;
if (x->mode == Addressing_Type && y->mode == Addressing_Type) {
bool comp = are_types_identical(x->type, y->type);
switch (op) {
case Token_CmpEq: comp = comp; break;
case Token_NotEq: comp = !comp; break;
}
x->mode = Addressing_Constant;
x->type = t_untyped_bool;
x->value = make_exact_value_bool(comp);
return;
}
gbString err_str = NULL;
gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&c->tmp_arena);
if (check_is_assignable_to(c, x, y->type) ||
check_is_assignable_to(c, y, x->type)) {
@@ -1905,208 +1933,36 @@ void check_conversion(Checker *c, Operand *x, Type *type) {
x->type = type;
}
void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
GB_ASSERT(node->kind == AstNode_BinaryExpr);
Operand y_ = {0}, *y = &y_;
ast_node(be, BinaryExpr, node);
#if 0
switch (be->op.kind) {
case Token_as: {
check_expr(c, x, be->left);
Type *type = check_type(c, be->right);
if (x->mode == Addressing_Invalid) {
return;
Token op = be->op;
switch (op.kind) {
case Token_CmpEq:
case Token_NotEq: {
// NOTE(bill): Allow comparisons between types
check_expr_or_type(c, x, be->left);
check_expr_or_type(c, y, be->right);
bool xt = x->mode == Addressing_Type;
bool yt = y->mode == Addressing_Type;
// If only one is a type, this is an error
if (xt ^ yt) {
GB_ASSERT(xt != yt);
if (xt) error_operand_not_expression(x);
if (yt) error_operand_not_expression(y);
}
check_conversion(c, x, type);
return;
} break;
case Token_transmute: {
default:
check_expr(c, x, be->left);
Type *type = check_type(c, be->right);
if (x->mode == Addressing_Invalid) {
return;
}
if (x->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(x->expr);
error_node(x->expr, "Cannot transmute constant expression: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
if (is_type_untyped(x->type)) {
gbString expr_str = expr_to_string(x->expr);
error_node(x->expr, "Cannot transmute untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
i64 srcz = type_size_of(c->sizes, c->allocator, x->type);
i64 dstz = type_size_of(c->sizes, c->allocator, type);
if (srcz != dstz) {
gbString expr_str = expr_to_string(x->expr);
gbString type_str = type_to_string(type);
error_node(x->expr, "Cannot transmute `%s` to `%s`, %lld vs %lld bytes", expr_str, type_str, srcz, dstz);
gb_string_free(type_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
x->type = type;
return;
} break;
case Token_down_cast: {
check_expr(c, x, be->left);
Type *type = check_type(c, be->right);
if (x->mode == Addressing_Invalid) {
return;
}
if (x->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(node);
error_node(node, "Cannot `down_cast` a constant expression: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
if (is_type_untyped(x->type)) {
gbString expr_str = expr_to_string(node);
error_node(node, "Cannot `down_cast` an untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
if (!(is_type_pointer(x->type) && is_type_pointer(type))) {
gbString expr_str = expr_to_string(node);
error_node(node, "Can only `down_cast` pointers: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
Type *src = type_deref(x->type);
Type *dst = type_deref(type);
Type *bsrc = base_type(src);
Type *bdst = base_type(dst);
if (!(is_type_struct(bsrc) || is_type_raw_union(bsrc))) {
gbString expr_str = expr_to_string(node);
error_node(node, "Can only `down_cast` pointer from structs or unions: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
if (!(is_type_struct(bdst) || is_type_raw_union(bdst))) {
gbString expr_str = expr_to_string(node);
error_node(node, "Can only `down_cast` pointer to structs or unions: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
String param_name = check_down_cast_name(dst, src);
if (param_name.len == 0) {
gbString expr_str = expr_to_string(node);
error_node(node, "Illegal `down_cast`: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
x->mode = Addressing_Value;
x->type = type;
return;
} break;
case Token_union_cast: {
check_expr(c, x, be->left);
Type *type = check_type(c, be->right);
if (x->mode == Addressing_Invalid) {
return;
}
if (x->mode == Addressing_Constant) {
gbString expr_str = expr_to_string(node);
error_node(node, "Cannot `union_cast` a constant expression: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
if (is_type_untyped(x->type)) {
gbString expr_str = expr_to_string(node);
error_node(node, "Cannot `union_cast` an untyped expression: `%s`", expr_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
bool src_is_ptr = is_type_pointer(x->type);
bool dst_is_ptr = is_type_pointer(type);
Type *src = type_deref(x->type);
Type *dst = type_deref(type);
Type *bsrc = base_type(src);
Type *bdst = base_type(dst);
if (src_is_ptr != dst_is_ptr) {
gbString src_type_str = type_to_string(x->type);
gbString dst_type_str = type_to_string(type);
error_node(node, "Invalid `union_cast` types: `%s` and `%s`", src_type_str, dst_type_str);
gb_string_free(dst_type_str);
gb_string_free(src_type_str);
x->mode = Addressing_Invalid;
return;
}
if (!is_type_union(src)) {
error_node(node, "`union_cast` can only operate on unions");
x->mode = Addressing_Invalid;
return;
}
bool ok = false;
for (isize i = 1; i < bsrc->Record.field_count; i++) {
Entity *f = bsrc->Record.fields[i];
if (are_types_identical(f->type, dst)) {
ok = true;
break;
}
}
if (!ok) {
gbString expr_str = expr_to_string(node);
gbString dst_type_str = type_to_string(type);
error_node(node, "Cannot `union_cast` `%s` to `%s`", expr_str, dst_type_str);
gb_string_free(dst_type_str);
gb_string_free(expr_str);
x->mode = Addressing_Invalid;
return;
}
Entity **variables = gb_alloc_array(c->allocator, Entity *, 2);
variables[0] = make_entity_param(c->allocator, NULL, empty_token, type, false);
variables[1] = make_entity_param(c->allocator, NULL, empty_token, t_bool, false);
Type *tuple = make_type_tuple(c->allocator);
tuple->Tuple.variables = variables;
tuple->Tuple.variable_count = 2;
x->type = tuple;
x->mode = Addressing_Value;
return;
} break;
check_expr(c, y, be->right);
break;
}
#endif
check_expr(c, x, be->left);
check_expr(c, y, be->right);
if (x->mode == Addressing_Invalid) {
return;
}
@@ -2116,8 +1972,6 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
return;
}
Token op = be->op;
if (token_is_shift(op)) {
check_shift(c, x, y, node);
return;
@@ -2339,6 +2193,7 @@ void convert_untyped_error(Checker *c, Operand *operand, Type *target_type) {
void convert_to_typed(Checker *c, Operand *operand, Type *target_type, i32 level) {
GB_ASSERT_NOT_NULL(target_type);
if (operand->mode == Addressing_Invalid ||
operand->mode == Addressing_Type ||
is_type_typed(operand->type) ||
target_type == t_invalid) {
return;
@@ -2441,7 +2296,7 @@ bool check_index_value(Checker *c, AstNode *index_value, i64 max_count, i64 *val
}
if (operand.mode == Addressing_Constant &&
(c->context.stmt_state_flags & StmtStateFlag_bounds_check) != 0) {
(c->context.stmt_state_flags & StmtStateFlag_no_bounds_check) == 0) {
i64 i = exact_value_to_integer(operand.value).value_integer;
if (i < 0) {
gbString expr_str = expr_to_string(operand.expr);
@@ -4958,23 +4813,19 @@ ExprKind check_expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint)
}
void check_multi_expr(Checker *c, Operand *o, AstNode *e) {
gbString err_str = NULL;
check_expr_base(c, o, e, NULL);
switch (o->mode) {
default:
return; // NOTE(bill): Valid
case Addressing_NoValue:
err_str = expr_to_string(e);
error_node(e, "`%s` used as value", err_str);
error_operand_no_value(o);
break;
case Addressing_Type:
err_str = expr_to_string(e);
error_node(e, "`%s` is not an expression", err_str);
error_operand_not_expression(o);
break;
}
gb_string_free(err_str);
o->mode = Addressing_Invalid;
}
@@ -5000,12 +4851,7 @@ void check_expr(Checker *c, Operand *o, AstNode *e) {
void check_expr_or_type(Checker *c, Operand *o, AstNode *e) {
check_expr_base(c, o, e, NULL);
check_not_tuple(c, o);
if (o->mode == Addressing_NoValue) {
gbString str = expr_to_string(o->expr);
error_node(o->expr, "`%s` used as value or type", str);
gb_string_free(str);
o->mode = Addressing_Invalid;
}
error_operand_no_value(o);
}

15
src/check_stmt.c
View File

@@ -310,12 +310,13 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
u32 in = node->stmt_state_flags;
u32 out = c->context.stmt_state_flags;
if (in & StmtStateFlag_bounds_check) {
out |= StmtStateFlag_bounds_check;
out &= ~StmtStateFlag_no_bounds_check;
} else if (in & StmtStateFlag_no_bounds_check) {
if (in & StmtStateFlag_no_bounds_check) {
out |= StmtStateFlag_no_bounds_check;
out &= ~StmtStateFlag_bounds_check;
} else {
// if (in & StmtStateFlag_bounds_check) {
out |= StmtStateFlag_bounds_check;
out &= ~StmtStateFlag_no_bounds_check;
}
c->context.stmt_state_flags = out;
@@ -648,6 +649,12 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
GB_ASSERT(are_types_identical(x.type, y.type));
TokenKind op = Token_Lt;
switch (ie->op.kind) {
case Token_HalfOpenRange: op = Token_Lt; break;
case Token_Ellipsis: op = Token_LtEq; break;
default: error(ie->op, "Invalid range operator"); break;
}
bool ok = compare_exact_values(Token_Lt, a, b);
if (!ok) {
// TODO(bill): Better error message

8
src/ir.c
View File

@@ -4115,7 +4115,13 @@ void ir_build_range_interval(irProcedure *proc, AstNodeIntervalExpr *node, Type
upper = ir_build_expr(proc, node->right);
irValue *cond = ir_emit_comp(proc, Token_Lt, ir_emit_load(proc, value), upper);
TokenKind op = Token_Lt;
switch (node->op.kind) {
case Token_HalfOpenRange: op = Token_Lt; break;
case Token_Ellipsis: op = Token_LtEq; break;
default: GB_PANIC("Invalid interval operator"); break;
}
irValue *cond = ir_emit_comp(proc, op, ir_emit_load(proc, value), upper);
ir_emit_if(proc, cond, body, done);
proc->curr_block = body;

8
src/parser.c
View File

@@ -2848,10 +2848,14 @@ AstNode *parse_for_stmt(AstFile *f) {
isize prev_level = f->expr_level;
f->expr_level = -1;
AstNode *expr = parse_expr(f, false);
if (f->curr_token.kind == Token_Interval) {
Token op = expect_token(f, Token_Interval);
switch (f->curr_token.kind) {
case Token_HalfOpenRange:
case Token_Ellipsis: {
Token op = f->curr_token;
next_token(f);
AstNode *right = parse_expr(f, false);
expr = make_interval_expr(f, op, expr, right);
} break;
}
f->expr_level = prev_level;

26
src/tokenizer.c
View File

@@ -65,18 +65,18 @@ TOKEN_KIND(Token__ComparisonBegin, "_ComparisonBegin"), \
TOKEN_KIND(Token_GtEq, ">="), \
TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
\
TOKEN_KIND(Token_OpenParen, "("), \
TOKEN_KIND(Token_CloseParen, ")"), \
TOKEN_KIND(Token_OpenBracket, "["), \
TOKEN_KIND(Token_CloseBracket, "]"), \
TOKEN_KIND(Token_OpenBrace, "{"), \
TOKEN_KIND(Token_CloseBrace, "}"), \
TOKEN_KIND(Token_Colon, ":"), \
TOKEN_KIND(Token_Semicolon, ";"), \
TOKEN_KIND(Token_Period, "."), \
TOKEN_KIND(Token_Comma, ","), \
TOKEN_KIND(Token_Ellipsis, "..."), \
TOKEN_KIND(Token_Interval, "..<"), \
TOKEN_KIND(Token_OpenParen, "("), \
TOKEN_KIND(Token_CloseParen, ")"), \
TOKEN_KIND(Token_OpenBracket, "["), \
TOKEN_KIND(Token_CloseBracket, "]"), \
TOKEN_KIND(Token_OpenBrace, "{"), \
TOKEN_KIND(Token_CloseBrace, "}"), \
TOKEN_KIND(Token_Colon, ":"), \
TOKEN_KIND(Token_Semicolon, ";"), \
TOKEN_KIND(Token_Period, "."), \
TOKEN_KIND(Token_Comma, ","), \
TOKEN_KIND(Token_Ellipsis, "..."), \
TOKEN_KIND(Token_HalfOpenRange, "..<"), \
TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
\
TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
@@ -846,7 +846,7 @@ Token tokenizer_get_token(Tokenizer *t) {
token.kind = Token_Ellipsis;
} else if (t->curr_rune == '<') {
advance_to_next_rune(t);
token.kind = Token_Interval;
token.kind = Token_HalfOpenRange;
}
}
break;