mirrors/Odin
1
0
Fork 0
mirror of https://github.com/odin-lang/Odin.git synced 2026-01-04 12:07:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

Massive Refactor and If statements

Browse Source
This commit is contained in:
gingerBill
2016-08-02 01:08:36 +01:00
parent e5665a190d
commit bf3283c889
12 changed files with 1229 additions and 1102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
examples/test.c
View File

@@ -1,6 +1,11 @@
int main() {
float a = 0.5;
float b = 1.5;
int c = a < b;
int x = 15;
int y = 4;
x = x & (~y);
if (x > 0) {
x = 123;
} else {
x = 321;
}
return 0;
}

13
examples/test.ll
View File

@@ -1,4 +1,17 @@
define void @main() {
entry:
%0 = alloca i64, align 8 ; x
store i64 zeroinitializer, i64* %0
store i64 15, i64* %0
%1 = load i64, i64* %0
%2 = icmp sgt i64 %1, 0
br i1 %2, label %if-then, label %if-else
if-then:
store i64 123, i64* %0
br label %if-end
if-else:
store i64 321, i64* %0
br label %if-end
if-end:
ret void
}

6
examples/test.odin
View File

@@ -1,2 +1,8 @@
main :: proc() {
x : int = 15;
if x > 0 {
x = 123;
} else {
x = 321;
}
}

4
run.bat
View File

@@ -5,5 +5,5 @@ rem del "..\examples\test.bc"
call ..\bin\odin.exe ..\examples/test.odin
call lli ..\examples/test.ll
rem call opt -mem2reg ..\examples/test.ll > ..\examples/test.bc
rem call llvm-dis ..\examples/test.bc -o..\examples/test.ll
rem call clang ..\examples/test.c -O1 -S -emit-llvm -o ..\examples/test-c.ll
rem call llvm-dis ..\examples/test.bc -o ..\examples/test.ll
call clang ..\examples/test.c -O0 -S -emit-llvm -o ..\examples/test-c.ll

62
src/checker/checker.cpp
View File

@@ -63,7 +63,8 @@ b32 has_init(DeclInfo *d) {
if (d->init_expr != NULL)
return true;
if (d->proc_decl != NULL) {
if (d->proc_decl->proc_decl.body != NULL)
ast_node(pd, ProcDecl, d->proc_decl);
if (pd->body != NULL)
return true;
}
@@ -466,7 +467,7 @@ void add_entity_use(CheckerInfo *i, AstNode *identifier, Entity *entity) {
void add_file_entity(Checker *c, AstNode *identifier, Entity *e, DeclInfo *d) {
GB_ASSERT(are_strings_equal(identifier->ident.token.string, e->token.string));
GB_ASSERT(are_strings_equal(identifier->Ident.token.string, e->token.string));
add_entity(c, c->global_scope, identifier, e);
map_set(&c->info.entities, hash_pointer(e), d);
@@ -537,20 +538,18 @@ void check_parsed_files(Checker *c) {
continue;
switch (decl->kind) {
case AstNode_BadDecl:
break;
case AstNode_VarDecl: {
auto *vd = &decl->var_decl;
case_ast_node(bd, BadDecl, decl);
case_end;
case_ast_node(vd, VarDecl, decl);
switch (vd->kind) {
case Declaration_Immutable: {
for (AstNode *name = vd->name_list, *value = vd->value_list;
name != NULL && value != NULL;
name = name->next, value = value->next) {
GB_ASSERT(name->kind == AstNode_Ident);
ast_node(n, Ident, name);
ExactValue v = {ExactValue_Invalid};
Entity *e = make_entity_constant(c->allocator, c->context.scope, name->ident.token, NULL, v);
Entity *e = make_entity_constant(c->allocator, c->context.scope, n->token, NULL, v);
DeclInfo *di = make_declaration_info(c->allocator, c->global_scope);
di->type_expr = vd->type;
di->init_expr = value;
@@ -582,7 +581,8 @@ void check_parsed_files(Checker *c) {
AstNode *value = vd->value_list;
for (AstNode *name = vd->name_list; name != NULL; name = name->next) {
Entity *e = make_entity_variable(c->allocator, c->global_scope, name->ident.token, NULL);
ast_node(n, Ident, name);
Entity *e = make_entity_variable(c->allocator, c->global_scope, n->token, NULL);
entities[entity_index++] = e;
DeclInfo *d = di;
@@ -600,41 +600,39 @@ void check_parsed_files(Checker *c) {
}
} break;
}
case_end;
} break;
case AstNode_TypeDecl: {
AstNode *identifier = decl->type_decl.name;
Entity *e = make_entity_type_name(c->allocator, c->global_scope, identifier->ident.token, NULL);
case_ast_node(td, TypeDecl, decl);
ast_node(n, Ident, td->name);
Entity *e = make_entity_type_name(c->allocator, c->global_scope, n->token, NULL);
DeclInfo *d = make_declaration_info(c->allocator, e->parent);
d->type_expr = decl->type_decl.type;
add_file_entity(c, identifier, e, d);
} break;
d->type_expr = td->type;
add_file_entity(c, td->name, e, d);
case_end;
case AstNode_AliasDecl: {
AstNode *identifier = decl->alias_decl.name;
Entity *e = make_entity_alias_name(c->allocator, c->global_scope, identifier->ident.token, NULL);
case_ast_node(ad, AliasDecl, decl);
ast_node(n, Ident, ad->name);
Entity *e = make_entity_alias_name(c->allocator, c->global_scope, n->token, NULL);
DeclInfo *d = make_declaration_info(c->allocator, e->parent);
d->type_expr = decl->alias_decl.type;
add_file_entity(c, identifier, e, d);
} break;
d->type_expr = ad->type;
add_file_entity(c, ad->name, e, d);
case_end;
case AstNode_ProcDecl: {
AstNode *identifier = decl->proc_decl.name;
Token token = identifier->ident.token;
case_ast_node(pd, ProcDecl, decl);
ast_node(n, Ident, pd->name);
Token token = n->token;
Entity *e = make_entity_procedure(c->allocator, c->global_scope, token, NULL);
add_entity(c, c->global_scope, identifier, e);
add_entity(c, c->global_scope, pd->name, e);
DeclInfo *d = make_declaration_info(c->allocator, e->parent);
d->proc_decl = decl;
map_set(&c->info.entities, hash_pointer(e), d);
e->order = gb_array_count(c->info.entities.entries);
} break;
case_end;
case AstNode_ImportDecl:
case_ast_node(id, ImportDecl, decl);
// NOTE(bill): ignore
break;
case_end;
default:
error(&c->error_collector, ast_node_token(decl), "Only declarations are allowed at file scope");

411
src/checker/expression.cpp
View File

@@ -16,7 +16,7 @@ void check_proc_body (Checker *c, Token token, DeclInfo *decl, Type
void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
GB_ASSERT(node->kind == AstNode_StructType);
GB_ASSERT(struct_type->kind == Type_Structure);
auto *st = &node->struct_type;
ast_node(st, StructType, node);
if (st->field_count == 0) {
error(&c->error_collector, ast_node_token(node), "Empty struct{} definition");
return;
@@ -28,7 +28,7 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
isize field_count = 0;
for (AstNode *field = st->field_list; field != NULL; field = field->next) {
for (AstNode *name = field->field.name_list; name != NULL; name = name->next) {
for (AstNode *name = field->Field.name_list; name != NULL; name = name->next) {
GB_ASSERT(name->kind == AstNode_Ident);
field_count++;
}
@@ -37,10 +37,11 @@ void check_struct_type(Checker *c, Type *struct_type, AstNode *node) {
Entity **fields = gb_alloc_array(c->allocator, Entity *, st->field_count);
isize field_index = 0;
for (AstNode *field = st->field_list; field != NULL; field = field->next) {
Type *type = check_type(c, field->field.type);
for (AstNode *name = field->field.name_list; name != NULL; name = name->next) {
GB_ASSERT(name->kind == AstNode_Ident);
Token name_token = name->ident.token;
ast_node(f, Field, field);
Type *type = check_type(c, f->type);
for (AstNode *name = f->name_list; name != NULL; name = name->next) {
ast_node(i, Ident, name);
Token name_token = i->token;
// TODO(bill): is the curr_scope correct?
Entity *e = make_entity_field(c->allocator, c->context.scope, name_token, type);
u64 key = hash_string(name_token.string);
@@ -67,13 +68,14 @@ Type *check_get_params(Checker *c, Scope *scope, AstNode *field_list, isize fiel
Entity **variables = gb_alloc_array(c->allocator, Entity *, field_count);
isize variable_index = 0;
for (AstNode *field = field_list; field != NULL; field = field->next) {
GB_ASSERT(field->kind == AstNode_Field);
AstNode *type_expr = field->field.type;
ast_node(f, Field, field);
AstNode *type_expr = f->type;
if (type_expr) {
Type *type = check_type(c, type_expr);
for (AstNode *name = field->field.name_list; name != NULL; name = name->next) {
for (AstNode *name = f->name_list; name != NULL; name = name->next) {
if (name->kind == AstNode_Ident) {
Entity *param = make_entity_param(c->allocator, scope, name->ident.token, type);
ast_node(i, Ident, name);
Entity *param = make_entity_param(c->allocator, scope, i->token, type);
add_entity(c, scope, name, param);
variables[variable_index++] = param;
} else {
@@ -117,19 +119,21 @@ Type *check_get_results(Checker *c, Scope *scope, AstNode *list, isize list_coun
void check_procedure_type(Checker *c, Type *type, AstNode *proc_type_node) {
isize param_count = proc_type_node->proc_type.param_count;
isize result_count = proc_type_node->proc_type.result_count;
ast_node(pt, ProcType, proc_type_node);
isize param_count = pt->param_count;
isize result_count = pt->result_count;
// gb_printf("%td -> %td\n", param_count, result_count);
Type *params = check_get_params(c, c->context.scope, proc_type_node->proc_type.param_list, param_count);
Type *results = check_get_results(c, c->context.scope, proc_type_node->proc_type.result_list, result_count);
Type *params = check_get_params(c, c->context.scope, pt->param_list, param_count);
Type *results = check_get_results(c, c->context.scope, pt->result_list, result_count);
type->procedure.scope = c->context.scope;
type->procedure.params = params;
type->procedure.param_count = proc_type_node->proc_type.param_count;
type->procedure.param_count = pt->param_count;
type->procedure.results = results;
type->procedure.result_count = proc_type_node->proc_type.result_count;
type->procedure.result_count = pt->result_count;
}
@@ -137,10 +141,11 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type) {
GB_ASSERT(n->kind == AstNode_Ident);
o->mode = Addressing_Invalid;
o->expr = n;
Entity *e = scope_lookup_entity(c->context.scope, n->ident.token.string);
ast_node(i, Ident, n);
Entity *e = scope_lookup_entity(c->context.scope, i->token.string);
if (e == NULL) {
error(&c->error_collector, n->ident.token,
"Undeclared type or identifier `%.*s`", LIT(n->ident.token.string));
error(&c->error_collector, i->token,
"Undeclared type or identifier `%.*s`", LIT(i->token.string));
return;
}
add_entity_use(&c->info, n, e);
@@ -155,7 +160,7 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type) {
}
if (e->type == NULL) {
GB_PANIC("Compiler error: How did this happen? type: %s; identifier: %.*s\n", type_to_string(e->type), LIT(n->ident.token.string));
GB_PANIC("Compiler error: How did this happen? type: %s; identifier: %.*s\n", type_to_string(e->type), LIT(i->token.string));
return;
}
@@ -230,7 +235,7 @@ Type *check_type_expr_extra(Checker *c, AstNode *e, Type *named_type) {
defer (gb_string_free(err_str));
switch (e->kind) {
case AstNode_Ident: {
case_ast_node(i, Ident, e);
Operand o = {};
check_identifier(c, &o, e, named_type);
switch (o.mode) {
@@ -252,46 +257,48 @@ Type *check_type_expr_extra(Checker *c, AstNode *e, Type *named_type) {
error(&c->error_collector, ast_node_token(e), "`%s` used as a type when not a type", err_str);
break;
}
} break;
case_end;
case AstNode_ParenExpr:
return check_type(c, e->paren_expr.expr, named_type);
case_ast_node(pe, ParenExpr, e);
return check_type(c, pe->expr, named_type);
case_end;
case AstNode_ArrayType:
if (e->array_type.count != NULL) {
case_ast_node(at, ArrayType, e);
if (at->count != NULL) {
Type *t = make_type_array(c->allocator,
check_type(c, e->array_type.elem),
check_array_count(c, e->array_type.count));
check_type(c, at->elem),
check_array_count(c, at->count));
set_base_type(named_type, t);
return t;
} else {
Type *t = make_type_slice(c->allocator, check_type(c, e->array_type.elem));
Type *t = make_type_slice(c->allocator, check_type(c, at->elem));
set_base_type(named_type, t);
return t;
}
break;
case_end;
case AstNode_StructType: {
case_ast_node(st, StructType, e);
Type *t = make_type_structure(c->allocator);
set_base_type(named_type, t);
check_struct_type(c, t, e);
return t;
} break;
case_end;
case AstNode_PointerType: {
Type *t = make_type_pointer(c->allocator, check_type(c, e->pointer_type.type));
case_ast_node(pt, PointerType, e);
Type *t = make_type_pointer(c->allocator, check_type(c, pt->type));
set_base_type(named_type, t);
return t;
} break;
case_end;
case AstNode_ProcType: {
case_ast_node(pt, ProcType, e);
Type *t = alloc_type(c->allocator, Type_Procedure);
set_base_type(named_type, t);
check_open_scope(c, e);
check_procedure_type(c, t, e);
check_close_scope(c);
return t;
} break;
case_end;
default:
err_str = expr_to_string(e);
@@ -312,7 +319,7 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) {
defer (gb_string_free(err_str));
switch (e->kind) {
case AstNode_Ident: {
case_ast_node(i, Ident, e);
Operand operand = {};
check_identifier(c, &operand, e, named_type);
switch (operand.mode) {
@@ -334,9 +341,9 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) {
error(&c->error_collector, ast_node_token(e), "`%s` used as a type when not a type", err_str);
break;
}
} break;
case_end;
case AstNode_SelectorExpr: {
case_ast_node(se, SelectorExpr, e);
Operand o = {};
check_selector(c, &o, e);
@@ -344,43 +351,44 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type) {
set_base_type(type, o.type);
return o.type;
}
} break;
case_end;
case AstNode_ParenExpr:
return check_type(c, e->paren_expr.expr, named_type);
case_ast_node(pe, ParenExpr, e);
return check_type(c, pe->expr, named_type);
case_end;
case AstNode_ArrayType: {
if (e->array_type.count != NULL) {
case_ast_node(at, ArrayType, e);
if (at->count != NULL) {
type = make_type_array(c->allocator,
check_type(c, e->array_type.elem),
check_array_count(c, e->array_type.count));
check_type(c, at->elem),
check_array_count(c, at->count));
set_base_type(named_type, type);
} else {
type = make_type_slice(c->allocator, check_type(c, e->array_type.elem));
type = make_type_slice(c->allocator, check_type(c, at->elem));
set_base_type(named_type, type);
}
goto end;
} break;
case_end;
case AstNode_StructType: {
case_ast_node(st, StructType, e);
type = make_type_structure(c->allocator);
set_base_type(named_type, type);
check_struct_type(c, type, e);
goto end;
} break;
case_end;
case AstNode_PointerType: {
type = make_type_pointer(c->allocator, check_type(c, e->pointer_type.type));
case_ast_node(pt, PointerType, e);
type = make_type_pointer(c->allocator, check_type(c, pt->type));
set_base_type(named_type, type);
goto end;
} break;
case_end;
case AstNode_ProcType: {
case_ast_node(pt, ProcType, e);
type = alloc_type(c->allocator, Type_Procedure);
set_base_type(named_type, type);
check_procedure_type(c, type, e);
goto end;
} break;
case_end;
default:
err_str = expr_to_string(e);
@@ -581,7 +589,8 @@ void check_is_expressible(Checker *c, Operand *o, Type *type) {
void check_unary_expr(Checker *c, Operand *o, Token op, AstNode *node) {
if (op.kind == Token_Pointer) { // Pointer address
if (o->mode != Addressing_Variable) {
gbString str = expr_to_string(node->unary_expr.expr);
ast_node(ue, UnaryExpr, node);
gbString str = expr_to_string(ue->expr);
defer (gb_string_free(str));
error(&c->error_collector, op, "Cannot take the pointer address of `%s`", str);
o->mode = Addressing_Invalid;
@@ -672,8 +681,10 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
gbString err_str = NULL;
defer (gb_string_free(err_str));
check_expr(c, x, node->binary_expr.left);
check_expr(c, y, node->binary_expr.right);
ast_node(be, BinaryExpr, node);
check_expr(c, x, be->left);
check_expr(c, y, be->right);
if (x->mode == Addressing_Invalid) return;
if (y->mode == Addressing_Invalid) {
x->mode = Addressing_Invalid;
@@ -689,7 +700,7 @@ void check_binary_expr(Checker *c, Operand *x, AstNode *node) {
return;
}
Token op = node->binary_expr.op;
Token op = be->op;
if (token_is_comparison(op)) {
check_comparison(c, x, y, op);
return;
@@ -770,19 +781,21 @@ void update_expr_type(Checker *c, AstNode *e, Type *type) {
return;
switch (e->kind) {
case AstNode_UnaryExpr:
case_ast_node(ue, UnaryExpr, e);
if (found->value.kind != ExactValue_Invalid)
break;
update_expr_type(c, e->unary_expr.expr, type);
update_expr_type(c, ue->expr, type);
break;
case_end;
case AstNode_BinaryExpr:
case_ast_node(be, BinaryExpr, e);
if (found->value.kind != ExactValue_Invalid)
break;
if (!token_is_comparison(e->binary_expr.op)) {
update_expr_type(c, e->binary_expr.left, type);
update_expr_type(c, e->binary_expr.right, type);
if (!token_is_comparison(be->op)) {
update_expr_type(c, be->left, type);
update_expr_type(c, be->right, type);
}
case_end;
}
if (is_type_untyped(type)) {
@@ -946,7 +959,8 @@ Entity *lookup_field(Type *type, AstNode *field_node, isize *index = NULL) {
if (type->kind == Type_Pointer)
type = get_base_type(type->pointer.element);
String field_str = field_node->ident.token.string;
ast_node(i, Ident, field_node);
String field_str = i->token.string;
switch (type->kind) {
case Type_Structure:
for (isize i = 0; i < type->structure.field_count; i++) {
@@ -970,8 +984,9 @@ Entity *lookup_field(Type *type, AstNode *field_node, isize *index = NULL) {
void check_selector(Checker *c, Operand *operand, AstNode *node) {
GB_ASSERT(node->kind == AstNode_SelectorExpr);
AstNode *op_expr = node->selector_expr.expr;
AstNode *selector = node->selector_expr.selector;
ast_node(se, SelectorExpr, node);
AstNode *op_expr = se->expr;
AstNode *selector = se->selector;
if (selector) {
Entity *entity = lookup_field(operand->type, selector);
if (entity == NULL) {
@@ -999,7 +1014,7 @@ void check_selector(Checker *c, Operand *operand, AstNode *node) {
b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id) {
GB_ASSERT(call->kind == AstNode_CallExpr);
auto *ce = &call->call_expr;
ast_node(ce, CallExpr, call);
BuiltinProcedure *bp = &builtin_procedures[id];
{
char *err = NULL;
@@ -1008,8 +1023,9 @@ b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id)
if (ce->arg_list_count > bp->arg_count && !bp->variadic)
err = "Too many";
if (err) {
ast_node(proc, Ident, ce->proc);
error(&c->error_collector, ce->close, "`%s` arguments for `%.*s`, expected %td, got %td",
err, LIT(call->call_expr.proc->ident.token.string),
err, LIT(proc->token.string),
bp->arg_count, ce->arg_list_count);
return false;
}
@@ -1093,9 +1109,10 @@ b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id)
isize index = 0;
Entity *entity = lookup_field(type, field_arg, &index);
if (entity == NULL) {
ast_node(arg, Ident, field_arg);
gbString type_str = type_to_string(type);
error(&c->error_collector, ast_node_token(ce->arg_list),
"`%s` has no field named `%.*s`", type_str, LIT(field_arg->ident.token.string));
"`%s` has no field named `%.*s`", type_str, LIT(arg->token.string));
return false;
}
@@ -1112,7 +1129,7 @@ b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id)
error(&c->error_collector, ast_node_token(arg), "`%s` is not a selector expression", str);
return false;
}
auto *s = &arg->selector_expr;
ast_node(s, SelectorExpr, arg);
check_expr(c, operand, s->expr);
if (operand->mode == Addressing_Invalid)
@@ -1128,9 +1145,10 @@ b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id)
isize index = 0;
Entity *entity = lookup_field(type, s->selector, &index);
if (entity == NULL) {
ast_node(i, Ident, s->selector);
gbString type_str = type_to_string(type);
error(&c->error_collector, ast_node_token(arg),
"`%s` has no field named `%.*s`", type_str, LIT(s->selector->ident.token.string));
"`%s` has no field named `%.*s`", type_str, LIT(i->token.string));
return false;
}
@@ -1267,7 +1285,7 @@ b32 check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id)
void check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNode *call) {
GB_ASSERT(call->kind == AstNode_CallExpr);
GB_ASSERT(proc_type->kind == Type_Procedure);
auto *ce = &call->call_expr;
ast_node(ce, CallExpr, call);
isize error_code = 0;
isize param_index = 0;
isize param_count = 0;
@@ -1341,7 +1359,7 @@ void check_call_arguments(Checker *c, Operand *operand, Type *proc_type, AstNode
ExpressionKind check_call_expr(Checker *c, Operand *operand, AstNode *call) {
GB_ASSERT(call->kind == AstNode_CallExpr);
auto *ce = &call->call_expr;
ast_node(ce, CallExpr, call);
check_expr_or_type(c, operand, ce->proc);
if (operand->mode == Addressing_Invalid) {
@@ -1492,16 +1510,17 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
o->type = &basic_types[Basic_Invalid];
switch (node->kind) {
case AstNode_BadExpr:
case_ast_node(be, BadExpr, node)
goto error;
case_end;
case AstNode_Ident:
case_ast_node(i, Ident, node);
check_identifier(c, o, node, type_hint);
break;
case AstNode_BasicLit: {
case_end;
case_ast_node(bl, BasicLit, node);
BasicKind basic_kind = Basic_Invalid;
Token lit = node->basic_lit;
switch (lit.kind) {
switch (bl->kind) {
case Token_Integer: basic_kind = Basic_UntypedInteger; break;
case Token_Float: basic_kind = Basic_UntypedFloat; break;
case Token_String: basic_kind = Basic_UntypedString; break;
@@ -1510,14 +1529,14 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
}
o->mode = Addressing_Constant;
o->type = &basic_types[basic_kind];
o->value = make_exact_value_from_basic_literal(lit);
} break;
o->value = make_exact_value_from_basic_literal(*bl);
case_end;
case AstNode_ProcLit: {
case_ast_node(pl, ProcLit, node);
Scope *origin_curr_scope = c->context.scope;
Type *proc_type = check_type(c, node->proc_lit.type);
Type *proc_type = check_type(c, pl->type);
if (proc_type != NULL) {
check_proc_body(c, empty_token, c->context.decl, proc_type, node->proc_lit.body);
check_proc_body(c, empty_token, c->context.decl, proc_type, pl->body);
o->mode = Addressing_Value;
o->type = proc_type;
} else {
@@ -1526,10 +1545,9 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
gb_string_free(str);
goto error;
}
} break;
case_end;
case AstNode_CompoundLit: {
auto *cl = &node->compound_lit;
case_ast_node(cl, CompoundLit, node);
Type *type = type_hint;
if (cl->type != NULL) {
type = check_type(c, cl->type);
@@ -1562,7 +1580,7 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
check_assignment(c, o, field->type, make_string("structure literal"));
}
if (cl->elem_count < field_count) {
error(&c->error_collector, node->compound_lit.close, "Too few values in structure literal, expected %td, got %td", field_count, cl->elem_count);
error(&c->error_collector, cl->close, "Too few values in structure literal, expected %td, got %td", field_count, cl->elem_count);
}
}
@@ -1610,43 +1628,48 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
o->mode = Addressing_Value;
o->type = type;
} break;
case_end;
case AstNode_ParenExpr:
kind = check_expr_base(c, o, node->paren_expr.expr, type_hint);
case_ast_node(pe, ParenExpr, node);
kind = check_expr_base(c, o, pe->expr, type_hint);
o->expr = node;
break;
case_end;
case AstNode_TagExpr:
case_ast_node(te, TagExpr, node);
// TODO(bill): Tag expressions
error(&c->error_collector, ast_node_token(node), "Tag expressions are not supported yet");
kind = check_expr_base(c, o, node->tag_expr.expr, type_hint);
kind = check_expr_base(c, o, te->expr, type_hint);
o->expr = node;
break;
case_end;
case AstNode_UnaryExpr:
check_expr(c, o, node->unary_expr.expr);
case_ast_node(ue, UnaryExpr, node);
check_expr(c, o, ue->expr);
if (o->mode == Addressing_Invalid)
goto error;
check_unary_expr(c, o, node->unary_expr.op, node);
check_unary_expr(c, o, ue->op, node);
if (o->mode == Addressing_Invalid)
goto error;
break;
case_end;
case AstNode_BinaryExpr:
case_ast_node(be, BinaryExpr, node);
check_binary_expr(c, o, node);
if (o->mode == Addressing_Invalid)
goto error;
break;
case_end;
case AstNode_SelectorExpr:
check_expr_base(c, o, node->selector_expr.expr);
case_ast_node(se, SelectorExpr, node);
check_expr_base(c, o, se->expr);
check_selector(c, o, node);
break;
case_end;
case AstNode_IndexExpr: {
check_expr(c, o, node->index_expr.expr);
case_ast_node(ie, IndexExpr, node);
check_expr(c, o, ie->expr);
if (o->mode == Addressing_Invalid)
goto error;
@@ -1693,19 +1716,19 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
goto error;
}
if (node->index_expr.index == NULL) {
if (ie->index == NULL) {
gbString str = expr_to_string(o->expr);
error(&c->error_collector, ast_node_token(o->expr), "Missing index for `%s`", str);
gb_string_free(str);
goto error;
}
check_index_value(c, node->index_expr.index, max_count, NULL);
} break;
check_index_value(c, ie->index, max_count, NULL);
case_end;
case AstNode_SliceExpr: {
auto *se = &node->slice_expr;
case_ast_node(se, SliceExpr, node);
check_expr(c, o, se->expr);
if (o->mode == Addressing_Invalid)
goto error;
@@ -1784,21 +1807,24 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
}
}
} break;
case_end;
case AstNode_CastExpr: {
Type *cast_type = check_type(c, node->cast_expr.type);
check_expr_or_type(c, o, node->cast_expr.expr);
case_ast_node(ce, CastExpr, node);
Type *cast_type = check_type(c, ce->type);
check_expr_or_type(c, o, ce->expr);
if (o->mode != Addressing_Invalid)
check_cast_expr(c, o, cast_type);
} break;
case_end;
case AstNode_CallExpr:
case_ast_node(ce, CallExpr, node);
return check_call_expr(c, o, node);
case_end;
case AstNode_DerefExpr:
check_expr_or_type(c, o, node->deref_expr.expr);
case_ast_node(de, DerefExpr, node);
check_expr_or_type(c, o, de->expr);
if (o->mode == Addressing_Invalid) {
goto error;
} else {
@@ -1813,7 +1839,7 @@ ExpressionKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *typ
goto error;
}
}
break;
case_end;
case AstNode_ProcType:
case AstNode_PointerType:
@@ -1925,12 +1951,12 @@ gbString write_expr_to_string(gbString str, AstNode *node);
gbString write_field_list_to_string(gbString str, AstNode *field_list, char *sep) {
isize i = 0;
for (AstNode *field = field_list; field != NULL; field = field->next) {
GB_ASSERT(field->kind == AstNode_Field);
ast_node(f, Field, field);
if (i > 0)
str = gb_string_appendc(str, sep);
isize j = 0;
for (AstNode *name = field->field.name_list; name != NULL; name = name->next) {
for (AstNode *name = f->name_list; name != NULL; name = name->next) {
if (j > 0)
str = gb_string_appendc(str, ", ");
str = write_expr_to_string(str, name);
@@ -1938,7 +1964,7 @@ gbString write_field_list_to_string(gbString str, AstNode *field_list, char *sep
}
str = gb_string_appendc(str, ": ");
str = write_expr_to_string(str, field->field.type);
str = write_expr_to_string(str, f->type);
i++;
}
@@ -1959,115 +1985,118 @@ gbString write_expr_to_string(gbString str, AstNode *node) {
str = gb_string_appendc(str, "(bad expression)");
break;
case AstNode_Ident:
str = string_append_token(str, node->ident.token);
break;
case AstNode_BasicLit:
str = string_append_token(str, node->basic_lit);
break;
case AstNode_ProcLit:
str = write_expr_to_string(str, node->proc_lit.type);
break;
case AstNode_CompoundLit:
case_ast_node(i, Ident, node);
str = string_append_token(str, i->token);
case_end;
case_ast_node(bl, BasicLit, node);
str = string_append_token(str, *bl);
case_end;
case_ast_node(pl, ProcLit, node);
str = write_expr_to_string(str, pl->type);
case_end;
case_ast_node(cl, CompoundLit, node);
str = gb_string_appendc(str, "(");
str = write_expr_to_string(str, node->compound_lit.type);
str = write_expr_to_string(str, cl->type);
str = gb_string_appendc(str, " literal)");
break;
case_end;
case AstNode_TagExpr:
case_ast_node(te, TagExpr, node);
str = gb_string_appendc(str, "#");
str = string_append_token(str, node->tag_expr.name);
str = write_expr_to_string(str, node->tag_expr.expr);
break;
str = string_append_token(str, te->name);
str = write_expr_to_string(str, te->expr);
case_end;
case AstNode_UnaryExpr:
str = string_append_token(str, node->unary_expr.op);
str = write_expr_to_string(str, node->unary_expr.expr);
break;
case_ast_node(ue, UnaryExpr, node);
str = string_append_token(str, ue->op);
str = write_expr_to_string(str, ue->expr);
case_end;
case AstNode_BinaryExpr:
str = write_expr_to_string(str, node->binary_expr.left);
case_ast_node(be, BinaryExpr, node);
str = write_expr_to_string(str, be->left);
str = gb_string_appendc(str, " ");
str = string_append_token(str, node->binary_expr.op);
str = string_append_token(str, be->op);
str = gb_string_appendc(str, " ");
str = write_expr_to_string(str, node->binary_expr.right);
break;
str = write_expr_to_string(str, be->right);
case_end;
case AstNode_ParenExpr:
case_ast_node(pe, ParenExpr, node);
str = gb_string_appendc(str, "(");
str = write_expr_to_string(str, node->paren_expr.expr);
str = write_expr_to_string(str, pe->expr);
str = gb_string_appendc(str, ")");
break;
case_end;
case AstNode_SelectorExpr:
str = write_expr_to_string(str, node->selector_expr.expr);
case_ast_node(se, SelectorExpr, node);
str = write_expr_to_string(str, se->expr);
str = gb_string_appendc(str, ".");
str = write_expr_to_string(str, node->selector_expr.selector);
break;
str = write_expr_to_string(str, se->selector);
case_end;
case AstNode_IndexExpr:
str = write_expr_to_string(str, node->index_expr.expr);
case_ast_node(ie, IndexExpr, node);
str = write_expr_to_string(str, ie->expr);
str = gb_string_appendc(str, "[");
str = write_expr_to_string(str, node->index_expr.index);
str = write_expr_to_string(str, ie->index);
str = gb_string_appendc(str, "]");
break;
case_end;
case AstNode_SliceExpr:
str = write_expr_to_string(str, node->slice_expr.expr);
case_ast_node(se, SliceExpr, node);
str = write_expr_to_string(str, se->expr);
str = gb_string_appendc(str, "[");
str = write_expr_to_string(str, node->slice_expr.low);
str = write_expr_to_string(str, se->low);
str = gb_string_appendc(str, ":");
str = write_expr_to_string(str, node->slice_expr.high);
if (node->slice_expr.triple_indexed) {
str = write_expr_to_string(str, se->high);
if (se->triple_indexed) {
str = gb_string_appendc(str, ":");
str = write_expr_to_string(str, node->slice_expr.max);
str = write_expr_to_string(str, se->max);
}
str = gb_string_appendc(str, "]");
break;
case_end;
case AstNode_CastExpr:
case_ast_node(ce, CastExpr, node);
str = gb_string_appendc(str, "cast(");
str = write_expr_to_string(str, node->cast_expr.type);
str = write_expr_to_string(str, ce->type);
str = gb_string_appendc(str, ")");
str = write_expr_to_string(str, node->cast_expr.expr);
break;
str = write_expr_to_string(str, ce->expr);
case_end;
case AstNode_PointerType:
case_ast_node(pt, PointerType, node);
str = gb_string_appendc(str, "^");
str = write_expr_to_string(str, node->pointer_type.type);
break;
case AstNode_ArrayType:
str = write_expr_to_string(str, pt->type);
case_end;
case_ast_node(at, ArrayType, node);
str = gb_string_appendc(str, "[");
str = write_expr_to_string(str, node->array_type.count);
str = write_expr_to_string(str, at->count);
str = gb_string_appendc(str, "]");
str = write_expr_to_string(str, node->array_type.elem);
break;
str = write_expr_to_string(str, at->elem);
case_end;
case AstNode_CallExpr: {
str = write_expr_to_string(str, node->call_expr.proc);
case_ast_node(ce, CallExpr, node);
str = write_expr_to_string(str, ce->proc);
str = gb_string_appendc(str, "(");
isize i = 0;
for (AstNode *arg = node->call_expr.arg_list; arg != NULL; arg = arg->next) {
for (AstNode *arg = ce->arg_list; arg != NULL; arg = arg->next) {
if (i > 0) gb_string_appendc(str, ", ");
str = write_expr_to_string(str, arg);
i++;
}
str = gb_string_appendc(str, ")");
} break;
case_end;
case AstNode_ProcType:
case_ast_node(pt, ProcType, node);
str = gb_string_appendc(str, "proc(");
str = write_field_list_to_string(str, node->proc_type.param_list, ", ");
str = write_field_list_to_string(str, pt->param_list, ", ");
str = gb_string_appendc(str, ")");
case_end;
break;
case AstNode_StructType:
case_ast_node(st, StructType, node);
str = gb_string_appendc(str, "struct{");
str = write_field_list_to_string(str, st->field_list, ", ");
str = gb_string_appendc(str, "}");
break;
case_end;
}

250
src/checker/statements.cpp
View File

@@ -39,29 +39,32 @@ b32 check_is_terminating_list(Checker *c, AstNode *list) {
// TODO(bill): Warn/err against code after `return` that it won't be executed
b32 check_is_terminating(Checker *c, AstNode *node) {
switch (node->kind) {
case AstNode_ReturnStmt:
case_ast_node(rs, ReturnStmt, node);
return true;
case_end;
case AstNode_BlockStmt:
return check_is_terminating_list(c, node->block_stmt.list);
case_ast_node(bs, BlockStmt, node);
return check_is_terminating_list(c, bs->list);
case_end;
case AstNode_ExprStmt:
return check_is_terminating(c, node->expr_stmt.expr);
case_ast_node(es, ExprStmt, node);
return check_is_terminating(c, es->expr);
case_end;
case AstNode_IfStmt:
if (node->if_stmt.else_stmt != NULL) {
if (check_is_terminating(c, node->if_stmt.body) &&
check_is_terminating(c, node->if_stmt.else_stmt)) {
case_ast_node(is, IfStmt, node);
if (is->else_stmt != NULL) {
if (check_is_terminating(c, is->body) &&
check_is_terminating(c, is->else_stmt)) {
return true;
}
}
break;
case_end;
case AstNode_ForStmt:
if (node->for_stmt.cond == NULL) {
case_ast_node(fs, ForStmt, node);
if (fs->cond == NULL) {
return true;
}
break;
case_end;
}
return false;
@@ -170,19 +173,22 @@ Type *check_assignment_variable(Checker *c, Operand *op_a, AstNode *lhs) {
AstNode *node = unparen_expr(lhs);
// NOTE(bill): Ignore assignments to `_`
if (node->kind == AstNode_Ident &&
are_strings_equal(node->ident.token.string, make_string("_"))) {
add_entity_definition(&c->info, node, NULL);
check_assignment(c, op_a, NULL, make_string("assignment to `_` identifier"));
if (op_a->mode == Addressing_Invalid)
return NULL;
return op_a->type;
}
if (node->kind == AstNode_Ident) {
ast_node(i, Ident, node);
if (are_strings_equal(i->token.string, make_string("_"))) {
add_entity_definition(&c->info, node, NULL);
check_assignment(c, op_a, NULL, make_string("assignment to `_` identifier"));
if (op_a->mode == Addressing_Invalid)
return NULL;
return op_a->type;
}
}
Entity *e = NULL;
b32 used = false;
if (node->kind == AstNode_Ident) {
e = scope_lookup_entity(c->context.scope, node->ident.token.string);
ast_node(i, Ident, node);
e = scope_lookup_entity(c->context.scope, i->token.string);
if (e != NULL && e->kind == Entity_Variable) {
used = e->variable.used; // TODO(bill): Make backup just in case
}
@@ -207,7 +213,8 @@ Type *check_assignment_variable(Checker *c, Operand *op_a, AstNode *lhs) {
if (op_b.expr->kind == AstNode_SelectorExpr) {
// NOTE(bill): Extra error checks
Operand op_c = {Addressing_Invalid};
check_expr(c, &op_c, op_b.expr->selector_expr.expr);
ast_node(se, SelectorExpr, op_b.expr);
check_expr(c, &op_c, se->expr);
}
gbString str = expr_to_string(op_b.expr);
@@ -379,10 +386,11 @@ void check_proc_body(Checker *c, Token token, DeclInfo *decl, Type *type, AstNod
c->context.decl = decl;
push_procedure(c, type);
check_stmt_list(c, body->block_stmt.list, 0);
ast_node(bs, BlockStmt, body);
check_stmt_list(c, bs->list, 0);
if (type->procedure.result_count > 0) {
if (!check_is_terminating(c, body)) {
error(&c->error_collector, body->block_stmt.close, "Missing return statement at the end of the procedure");
error(&c->error_collector, bs->close, "Missing return statement at the end of the procedure");
}
}
pop_procedure(c);
@@ -395,7 +403,7 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d, b32 check_body_later) {
Type *proc_type = make_type_procedure(c->allocator, e->parent, NULL, 0, NULL, 0);
e->type = proc_type;
auto *pd = &d->proc_decl->proc_decl;
ast_node(pd, ProcDecl, d->proc_decl);
#if 1
Scope *original_curr_scope = c->context.scope;
@@ -409,7 +417,8 @@ void check_proc_decl(Checker *c, Entity *e, DeclInfo *d, b32 check_body_later) {
for (AstNode *tag = pd->tag_list; tag != NULL; tag = tag->next) {
GB_ASSERT(tag->kind == AstNode_TagExpr);
String tag_name = tag->tag_expr.name.string;
ast_node(te, TagExpr, tag);
String tag_name = te->name.string;
if (are_strings_equal(tag_name, make_string("foreign"))) {
is_foreign = true;
} else if (are_strings_equal(tag_name, make_string("inline"))) {
@@ -516,13 +525,13 @@ void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type) {
void check_stmt(Checker *c, AstNode *node, u32 flags) {
switch (node->kind) {
case AstNode_EmptyStmt: break;
case AstNode_BadStmt: break;
case AstNode_BadDecl: break;
case_ast_node(_, EmptyStmt, node); case_end;
case_ast_node(_, BadStmt, node); case_end;
case_ast_node(_, BadDecl, node); case_end;
case AstNode_ExprStmt: {
case_ast_node(es, ExprStmt, node)
Operand operand = {Addressing_Invalid};
ExpressionKind kind = check_expr_base(c, &operand, node->expr_stmt.expr);
ExpressionKind kind = check_expr_base(c, &operand, es->expr);
switch (operand.mode) {
case Addressing_Type:
error(&c->error_collector, ast_node_token(node), "Is not an expression");
@@ -533,19 +542,18 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
error(&c->error_collector, ast_node_token(node), "Expression is not used");
break;
}
} break;
case_end;
case AstNode_TagStmt:
case_ast_node(ts, TagStmt, node);
// TODO(bill): Tag Statements
error(&c->error_collector, ast_node_token(node), "Tag statements are not supported yet");
check_stmt(c, node->tag_stmt.stmt, flags);
break;
check_stmt(c, ts->stmt, flags);
case_end;
case AstNode_IncDecStmt: {
case_ast_node(ids, IncDecStmt, node);
Token op = {};
auto *s = &node->inc_dec_stmt;
op = s->op;
switch (s->op.kind) {
op = ids->op;
switch (ids->op.kind) {
case Token_Increment:
op.kind = Token_Add;
op.string.len = 1;
@@ -555,44 +563,45 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
op.string.len = 1;
break;
default:
error(&c->error_collector, s->op, "Unknown inc/dec operation %.*s", LIT(s->op.string));
error(&c->error_collector, ids->op, "Unknown inc/dec operation %.*s", LIT(ids->op.string));
return;
}
Operand operand = {Addressing_Invalid};
check_expr(c, &operand, s->expr);
check_expr(c, &operand, ids->expr);
if (operand.mode == Addressing_Invalid)
return;
if (!is_type_numeric(operand.type)) {
error(&c->error_collector, s->op, "Non numeric type");
error(&c->error_collector, ids->op, "Non numeric type");
return;
}
AstNode basic_lit = {AstNode_BasicLit};
basic_lit.basic_lit = s->op;
basic_lit.basic_lit.kind = Token_Integer;
basic_lit.basic_lit.string = make_string("1");
ast_node(bl, BasicLit, &basic_lit);
*bl = ids->op;
bl->kind = Token_Integer;
bl->string = make_string("1");
AstNode be = {AstNode_BinaryExpr};
be.binary_expr.op = op;
be.binary_expr.left = s->expr;;
be.binary_expr.right = &basic_lit;
check_binary_expr(c, &operand, &be);
AstNode binary_expr = {AstNode_BinaryExpr};
ast_node(be, BinaryExpr, &binary_expr);
be->op = op;
be->left = ids->expr;
be->right = &basic_lit;
check_binary_expr(c, &operand, &binary_expr);
case_end;
} break;
case AstNode_AssignStmt:
switch (node->assign_stmt.op.kind) {
case_ast_node(as, AssignStmt, node);
switch (as->op.kind) {
case Token_Eq: {
// a, b, c = 1, 2, 3; // Multisided
if (node->assign_stmt.lhs_count == 0) {
error(&c->error_collector, node->assign_stmt.op, "Missing lhs in assignment statement");
if (as->lhs_count == 0) {
error(&c->error_collector, as->op, "Missing lhs in assignment statement");
return;
}
Operand operand = {};
AstNode *lhs = node->assign_stmt.lhs_list;
AstNode *rhs = node->assign_stmt.rhs_list;
AstNode *lhs = as->lhs_list;
AstNode *rhs = as->rhs_list;
isize i = 0;
for (;
lhs != NULL && rhs != NULL;
@@ -615,7 +624,7 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
}
}
if (i < node->assign_stmt.lhs_count && i < node->assign_stmt.rhs_count) {
if (i < as->lhs_count && i < as->rhs_count) {
if (lhs == NULL)
error(&c->error_collector, ast_node_token(lhs), "Too few values on the right hand side of the declaration");
} else if (rhs != NULL) {
@@ -625,9 +634,8 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
default: {
// a += 1; // Single-sided
Token op = node->assign_stmt.op;
if (node->assign_stmt.lhs_count != 1 ||
node->assign_stmt.rhs_count != 1) {
Token op = as->op;
if (as->lhs_count != 1 || as->rhs_count != 1) {
error(&c->error_collector, op, "Assignment operation `%.*s` requires single-valued expressions", LIT(op.string));
return;
}
@@ -637,61 +645,60 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
}
// TODO(bill): Check if valid assignment operator
Operand operand = {Addressing_Invalid};
AstNode be = {AstNode_BinaryExpr};
be.binary_expr.op = op;
AstNode binary_expr = {AstNode_BinaryExpr};
ast_node(be, BinaryExpr, &binary_expr);
be->op = op;
// NOTE(bill): Only use the first one will be used
be.binary_expr.left = node->assign_stmt.lhs_list;
be.binary_expr.right = node->assign_stmt.rhs_list;
be->left = as->lhs_list;
be->right = as->rhs_list;
check_binary_expr(c, &operand, &be);
check_binary_expr(c, &operand, &binary_expr);
if (operand.mode == Addressing_Invalid)
return;
// NOTE(bill): Only use the first one will be used
check_assignment_variable(c, &operand, node->assign_stmt.lhs_list);
check_assignment_variable(c, &operand, as->lhs_list);
} break;
}
break;
case_end;
case AstNode_BlockStmt:
case_ast_node(bs, BlockStmt, node);
check_open_scope(c, node);
check_stmt_list(c, node->block_stmt.list, flags);
check_stmt_list(c, bs->list, flags);
check_close_scope(c);
break;
case_end;
case AstNode_IfStmt: {
case_ast_node(is, IfStmt, node);
check_open_scope(c, node);
defer (check_close_scope(c));
auto *is = &node->if_stmt;
if (is->init != NULL)
check_stmt(c, is->init, 0);
Operand operand = {Addressing_Invalid};
check_expr(c, &operand, node->if_stmt.cond);
check_expr(c, &operand, is->cond);
if (operand.mode != Addressing_Invalid &&
!is_type_boolean(operand.type)) {
error(&c->error_collector, ast_node_token(node->if_stmt.cond),
error(&c->error_collector, ast_node_token(is->cond),
"Non-boolean condition in `if` statement");
}
check_stmt(c, node->if_stmt.body, flags);
check_stmt(c, is->body, flags);
if (node->if_stmt.else_stmt) {
switch (node->if_stmt.else_stmt->kind) {
if (is->else_stmt) {
switch (is->else_stmt->kind) {
case AstNode_IfStmt:
case AstNode_BlockStmt:
check_stmt(c, node->if_stmt.else_stmt, flags);
check_stmt(c, is->else_stmt, flags);
break;
default:
error(&c->error_collector, ast_node_token(node->if_stmt.else_stmt),
error(&c->error_collector, ast_node_token(is->else_stmt),
"Invalid `else` statement in `if` statement");
break;
}
}
} break;
case_end;
case AstNode_ReturnStmt: {
auto *rs = &node->return_stmt;
case_ast_node(rs, ReturnStmt, node);
GB_ASSERT(gb_array_count(c->procedure_stack) > 0);
if (c->in_defer) {
@@ -714,31 +721,30 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
check_init_variables(c, tuple->variables, tuple->variable_count,
rs->result_list, rs->result_count, make_string("return statement"));
}
} break;
case_end;
case AstNode_ForStmt: {
case_ast_node(fs, ForStmt, node);
flags |= Statement_BreakAllowed | Statement_ContinueAllowed;
check_open_scope(c, node);
defer (check_close_scope(c));
if (node->for_stmt.init != NULL)
check_stmt(c, node->for_stmt.init, 0);
if (node->for_stmt.cond) {
if (fs->init != NULL)
check_stmt(c, fs->init, 0);
if (fs->cond) {
Operand operand = {Addressing_Invalid};
check_expr(c, &operand, node->for_stmt.cond);
check_expr(c, &operand, fs->cond);
if (operand.mode != Addressing_Invalid &&
!is_type_boolean(operand.type)) {
error(&c->error_collector, ast_node_token(node->for_stmt.cond),
error(&c->error_collector, ast_node_token(fs->cond),
"Non-boolean condition in `for` statement");
}
}
if (node->for_stmt.end != NULL)
check_stmt(c, node->for_stmt.end, 0);
check_stmt(c, node->for_stmt.body, flags);
} break;
if (fs->end != NULL)
check_stmt(c, fs->end, 0);
check_stmt(c, fs->body, flags);
case_end;
case AstNode_DeferStmt: {
auto *ds = &node->defer_stmt;
case_ast_node(ds, DeferStmt, node);
if (is_ast_node_decl(ds->stmt)) {
error(&c->error_collector, ds->token, "You cannot defer a declaration");
} else {
@@ -747,10 +753,10 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
check_stmt(c, ds->stmt, 0);
c->in_defer = out_in_defer;
}
} break;
case_end;
case AstNode_BranchStmt: {
Token token = node->branch_stmt.token;
case_ast_node(bs, BranchStmt, node);
Token token = bs->token;
switch (token.kind) {
case Token_break:
if ((flags & Statement_BreakAllowed) == 0)
@@ -764,12 +770,11 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
error(&c->error_collector, token, "Invalid AST: Branch Statement `%.*s`", LIT(token.string));
break;
}
} break;
case_end;
// Declarations
case AstNode_VarDecl: {
auto *vd = &node->var_decl;
case_ast_node(vd, VarDecl, node);
isize entity_count = vd->name_count;
isize entity_index = 0;
Entity **entities = gb_alloc_array(c->allocator, Entity *, entity_count);
@@ -780,7 +785,7 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
for (AstNode *name = vd->name_list; name != NULL; name = name->next) {
Entity *entity = NULL;
Token token = name->ident.token;
Token token = name->Ident.token;
if (name->kind == AstNode_Ident) {
String str = token.string;
Entity *found = NULL;
@@ -841,7 +846,8 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
name = name->next, value = value->next) {
GB_ASSERT(name->kind == AstNode_Ident);
ExactValue v = {ExactValue_Invalid};
Entity *e = make_entity_constant(c->allocator, c->context.scope, name->ident.token, NULL, v);
ast_node(i, Ident, name);
Entity *e = make_entity_constant(c->allocator, c->context.scope, i->token, NULL, v);
entities[entity_index++] = e;
check_const_decl(c, e, vd->type, value);
}
@@ -866,11 +872,11 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
error(&c->error_collector, ast_node_token(node), "Unknown variable declaration kind. Probably an invalid AST.");
return;
}
} break;
case_end;
case AstNode_ProcDecl: {
auto *pd = &node->proc_decl;
Entity *e = make_entity_procedure(c->allocator, c->context.scope, pd->name->ident.token, NULL);
case_ast_node(pd, ProcDecl, node);
ast_node(name, Ident, pd->name);
Entity *e = make_entity_procedure(c->allocator, c->context.scope, name->token, NULL);
add_entity(c, c->context.scope, pd->name, e);
DeclInfo decl = {};
@@ -878,22 +884,20 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
decl.proc_decl = node;
check_proc_decl(c, e, &decl, false);
destroy_declaration_info(&decl);
} break;
case_end;
case AstNode_TypeDecl: {
auto *td = &node->type_decl;
AstNode *name = td->name;
Entity *e = make_entity_type_name(c->allocator, c->context.scope, name->ident.token, NULL);
add_entity(c, c->context.scope, name, e);
case_ast_node(td, TypeDecl, node);
ast_node(name, Ident, td->name);
Entity *e = make_entity_type_name(c->allocator, c->context.scope, name->token, NULL);
add_entity(c, c->context.scope, td->name, e);
check_type_decl(c, e, td->type, NULL);
} break;
case_end;
case AstNode_AliasDecl: {
auto *ad = &node->alias_decl;
AstNode *name = ad->name;
Entity *e = make_entity_alias_name(c->allocator, c->context.scope, name->ident.token, NULL);
add_entity(c, c->context.scope, name, e);
case_ast_node(ad, AliasDecl, node);
ast_node(name, Ident, ad->name);
Entity *e = make_entity_alias_name(c->allocator, c->context.scope, name->token, NULL);
add_entity(c, c->context.scope, ad->name, e);
check_alias_decl(c, e, ad->type, NULL);
} break;
case_end;
}
}

64
src/codegen/print.cpp
View File

@@ -215,24 +215,24 @@ void ssa_print_value(gbFile *f, ssaModule *m, ssaValue *value, Type *type_hint)
ssa_print_encoded_global(f, value->global.entity->token.string);
break;
case ssaValue_Procedure:
ssa_print_encoded_global(f, value->procedure.entity->token.string);
ssa_print_encoded_global(f, value->proc.entity->token.string);
break;
case ssaValue_Constant: {
ssa_print_exact_value(f, m, value->constant.value, type_hint);
} break;
case ssaValue_Instruction:
case ssaValue_Instr:
ssa_fprintf(f, "%%%d", value->id);
break;
}
}
void ssa_print_instruction(gbFile *f, ssaModule *m, ssaValue *value) {
GB_ASSERT(value->kind == ssaValue_Instruction);
ssaInstruction *instr = &value->instruction;
void ssa_print_instr(gbFile *f, ssaModule *m, ssaValue *value) {
GB_ASSERT(value->kind == ssaValue_Instr);
ssaInstr *instr = &value->instr;
ssa_fprintf(f, "\t");
switch (instr->kind) {
case ssaInstruction_Local: {
case ssaInstr_Local: {
Type *type = instr->local.entity->type;
ssa_fprintf(f, "%%%d = alloca ", value->id);
ssa_print_type(f, m->sizes, type);
@@ -246,7 +246,7 @@ void ssa_print_instruction(gbFile *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, "* %%%d\n", value->id);
} break;
case ssaInstruction_Store: {
case ssaInstr_Store: {
Type *type = ssa_value_type(instr->store.address);
ssa_fprintf(f, "store ");
ssa_print_type(f, m->sizes, type);
@@ -259,7 +259,7 @@ void ssa_print_instruction(gbFile *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, "\n");
} break;
case ssaInstruction_Load: {
case ssaInstr_Load: {
Type *type = instr->load.type;
ssa_fprintf(f, "%%%d = load ", value->id);
ssa_print_type(f, m->sizes, type);
@@ -270,8 +270,7 @@ void ssa_print_instruction(gbFile *f, ssaModule *m, ssaValue *value) {
ssa_fprintf(f, "\n");
} break;
case ssaInstruction_GetElementPtr: {
Type *rt = instr->get_element_ptr.result_type;
case ssaInstr_GetElementPtr: {
Type *et = instr->get_element_ptr.element_type;
Type *t_int = &basic_types[Basic_int];
ssa_fprintf(f, "%%%d = getelementptr ", value->id);
@@ -283,22 +282,35 @@ void ssa_print_instruction(gbFile *f, ssaModule *m, ssaValue *value) {
ssa_print_type(f, m->sizes, et);
ssa_fprintf(f, "* ");
ssa_print_value(f, m, instr->get_element_ptr.address, et);
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, t_int);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->get_element_ptr.indices[0], t_int);
if (instr->get_element_ptr.index_count == 2) {
for (isize i = 0; i < instr->get_element_ptr.index_count; i++) {
ssa_fprintf(f, ", ");
ssa_print_type(f, m->sizes, t_int);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->get_element_ptr.indices[1], t_int);
ssa_print_value(f, m, instr->get_element_ptr.indices[i], t_int);
}
ssa_fprintf(f, "\n");
} break;
case ssaInstr_Br: {
ssa_fprintf(f, "br ");
if (instr->br.cond != NULL) {
Type *t_bool = &basic_types[Basic_bool];
ssa_print_type(f, m->sizes, t_bool);
ssa_fprintf(f, " ");
ssa_print_value(f, m, instr->br.cond, t_bool);
ssa_fprintf(f, ", ", instr->br.cond->id);
}
ssa_fprintf(f, "label ");
ssa_print_encoded_local(f, instr->br.true_block->label);
if (instr->br.false_block != NULL) {
ssa_fprintf(f, ", label ");
ssa_print_encoded_local(f, instr->br.false_block->label);
}
ssa_fprintf(f, "\n");
} break;
case ssaInstruction_BinaryOp: {
auto *bo = &value->instruction.binary_op;
case ssaInstr_BinaryOp: {
auto *bo = &value->instr.binary_op;
Type *type = ssa_value_type(bo->left);
ssa_fprintf(f, "%%%d = ", value->id);
@@ -319,9 +331,9 @@ void ssa_print_instruction(gbFile *f, ssaModule *m, ssaValue *value) {
if (bo->op.kind != Token_CmpEq &&
bo->op.kind != Token_NotEq) {
if (is_type_unsigned(type)) {
ssa_fprintf(f, "s");
} else {
ssa_fprintf(f, "u");
} else {
ssa_fprintf(f, "s");
}
}
switch (bo->op.kind) {
@@ -401,7 +413,7 @@ void ssa_print_llvm_ir(gbFile *f, ssaModule *m) {
} break;
case ssaValue_Procedure: {
ssaProcedure *proc = &v->procedure;
ssaProcedure *proc = &v->proc;
if (proc->body == NULL) {
ssa_fprintf(f, "declare ");
} else {
@@ -438,12 +450,12 @@ void ssa_print_llvm_ir(gbFile *f, ssaModule *m) {
ssa_fprintf(f, "\n");
} else {
ssa_fprintf(f, "{\n");
gb_for_array(i, proc->blocks) {
ssaBlock *block = &proc->blocks[i]->block;
gb_for_array(i, proc->blocks.entries) {
ssaBlock *block = &proc->blocks.entries[i].value->block;
ssa_fprintf(f, "%.*s:\n", LIT(block->label));
gb_for_array(j, block->instructions) {
ssaValue *value = block->instructions[j];
ssa_print_instruction(f, m, value);
gb_for_array(j, block->instrs) {
ssaValue *value = block->instrs[j];
ssa_print_instr(f, m, value);
}
}

669
src/codegen/ssa.cpp
View File

File diff suppressed because it is too large Load Diff

706
src/parser.cpp
View File

File diff suppressed because it is too large Load Diff

128
src/printer.cpp
View File

@@ -12,24 +12,24 @@ void print_ast(AstNode *node, isize indent) {
switch (node->kind) {
case AstNode_BasicLit:
print_indent(indent);
print_token(node->basic_lit);
print_token(node->BasicLit);
break;
case AstNode_Ident:
print_indent(indent);
print_token(node->ident.token);
print_token(node->Ident.token);
break;
case AstNode_ProcLit:
print_indent(indent);
gb_printf("(proc lit)\n");
print_ast(node->proc_lit.type, indent+1);
print_ast(node->proc_lit.body, indent+1);
print_ast(node->ProcLit.type, indent+1);
print_ast(node->ProcLit.body, indent+1);
break;
case AstNode_CompoundLit:
print_indent(indent);
gb_printf("(compound lit)\n");
print_ast(node->compound_lit.type, indent+1);
print_ast(node->compound_lit.elem_list, indent+1);
print_ast(node->CompoundLit.type, indent+1);
print_ast(node->CompoundLit.elem_list, indent+1);
break;
@@ -37,168 +37,168 @@ void print_ast(AstNode *node, isize indent) {
print_indent(indent);
gb_printf("(tag)\n");
print_indent(indent+1);
print_token(node->tag_expr.name);
print_ast(node->tag_expr.expr, indent+1);
print_token(node->TagExpr.name);
print_ast(node->TagExpr.expr, indent+1);
break;
case AstNode_UnaryExpr:
print_indent(indent);
print_token(node->unary_expr.op);
print_ast(node->unary_expr.expr, indent+1);
print_token(node->UnaryExpr.op);
print_ast(node->UnaryExpr.expr, indent+1);
break;
case AstNode_BinaryExpr:
print_indent(indent);
print_token(node->binary_expr.op);
print_ast(node->binary_expr.left, indent+1);
print_ast(node->binary_expr.right, indent+1);
print_token(node->BinaryExpr.op);
print_ast(node->BinaryExpr.left, indent+1);
print_ast(node->BinaryExpr.right, indent+1);
break;
case AstNode_CallExpr:
print_indent(indent);
gb_printf("(call)\n");
print_ast(node->call_expr.proc, indent+1);
print_ast(node->call_expr.arg_list, indent+1);
print_ast(node->CallExpr.proc, indent+1);
print_ast(node->CallExpr.arg_list, indent+1);
break;
case AstNode_SelectorExpr:
print_indent(indent);
gb_printf(".\n");
print_ast(node->selector_expr.expr, indent+1);
print_ast(node->selector_expr.selector, indent+1);
print_ast(node->SelectorExpr.expr, indent+1);
print_ast(node->SelectorExpr.selector, indent+1);
break;
case AstNode_IndexExpr:
print_indent(indent);
gb_printf("([])\n");
print_ast(node->index_expr.expr, indent+1);
print_ast(node->index_expr.index, indent+1);
print_ast(node->IndexExpr.expr, indent+1);
print_ast(node->IndexExpr.index, indent+1);
break;
case AstNode_CastExpr:
print_indent(indent);
gb_printf("(cast)\n");
print_ast(node->cast_expr.type, indent+1);
print_ast(node->cast_expr.expr, indent+1);
print_ast(node->CastExpr.type, indent+1);
print_ast(node->CastExpr.expr, indent+1);
break;
case AstNode_DerefExpr:
print_indent(indent);
gb_printf("(deref)\n");
print_ast(node->deref_expr.expr, indent+1);
print_ast(node->DerefExpr.expr, indent+1);
break;
case AstNode_ExprStmt:
print_ast(node->expr_stmt.expr, indent);
print_ast(node->ExprStmt.expr, indent);
break;
case AstNode_IncDecStmt:
print_indent(indent);
print_token(node->inc_dec_stmt.op);
print_ast(node->inc_dec_stmt.expr, indent+1);
print_token(node->IncDecStmt.op);
print_ast(node->IncDecStmt.expr, indent+1);
break;
case AstNode_AssignStmt:
print_indent(indent);
print_token(node->assign_stmt.op);
print_ast(node->assign_stmt.lhs_list, indent+1);
print_ast(node->assign_stmt.rhs_list, indent+1);
print_token(node->AssignStmt.op);
print_ast(node->AssignStmt.lhs_list, indent+1);
print_ast(node->AssignStmt.rhs_list, indent+1);
break;
case AstNode_BlockStmt:
print_indent(indent);
gb_printf("(block)\n");
print_ast(node->block_stmt.list, indent+1);
print_ast(node->BlockStmt.list, indent+1);
break;
case AstNode_IfStmt:
print_indent(indent);
gb_printf("(if)\n");
print_ast(node->if_stmt.cond, indent+1);
print_ast(node->if_stmt.body, indent+1);
if (node->if_stmt.else_stmt) {
print_ast(node->IfStmt.cond, indent+1);
print_ast(node->IfStmt.body, indent+1);
if (node->IfStmt.else_stmt) {
print_indent(indent);
gb_printf("(else)\n");
print_ast(node->if_stmt.else_stmt, indent+1);
print_ast(node->IfStmt.else_stmt, indent+1);
}
break;
case AstNode_ReturnStmt:
print_indent(indent);
gb_printf("(return)\n");
print_ast(node->return_stmt.result_list, indent+1);
print_ast(node->ReturnStmt.result_list, indent+1);
break;
case AstNode_ForStmt:
print_indent(indent);
gb_printf("(for)\n");
print_ast(node->for_stmt.init, indent+1);
print_ast(node->for_stmt.cond, indent+1);
print_ast(node->for_stmt.end, indent+1);
print_ast(node->for_stmt.body, indent+1);
print_ast(node->ForStmt.init, indent+1);
print_ast(node->ForStmt.cond, indent+1);
print_ast(node->ForStmt.end, indent+1);
print_ast(node->ForStmt.body, indent+1);
break;
case AstNode_DeferStmt:
print_indent(indent);
gb_printf("(defer)\n");
print_ast(node->defer_stmt.stmt, indent+1);
print_ast(node->DeferStmt.stmt, indent+1);
break;
case AstNode_VarDecl:
print_indent(indent);
if (node->var_decl.kind == Declaration_Mutable)
if (node->VarDecl.kind == Declaration_Mutable)
gb_printf("(decl:var,mutable)\n");
else if (node->var_decl.kind == Declaration_Immutable)
else if (node->VarDecl.kind == Declaration_Immutable)
gb_printf("(decl:var,immutable)\n");
print_ast(node->var_decl.name_list, indent+1);
print_ast(node->var_decl.type, indent+1);
print_ast(node->var_decl.value_list, indent+1);
print_ast(node->VarDecl.name_list, indent+1);
print_ast(node->VarDecl.type, indent+1);
print_ast(node->VarDecl.value_list, indent+1);
break;
case AstNode_ProcDecl:
print_indent(indent);
if (node->proc_decl.kind == Declaration_Mutable)
if (node->ProcDecl.kind == Declaration_Mutable)
gb_printf("(decl:proc,mutable)\n");
else if (node->proc_decl.kind == Declaration_Immutable)
else if (node->ProcDecl.kind == Declaration_Immutable)
gb_printf("(decl:proc,immutable)\n");
print_ast(node->proc_decl.type, indent+1);
print_ast(node->proc_decl.body, indent+1);
print_ast(node->proc_decl.tag_list, indent+1);
print_ast(node->ProcDecl.type, indent+1);
print_ast(node->ProcDecl.body, indent+1);
print_ast(node->ProcDecl.tag_list, indent+1);
break;
case AstNode_TypeDecl:
print_indent(indent);
gb_printf("(type)\n");
print_ast(node->type_decl.name, indent+1);
print_ast(node->type_decl.type, indent+1);
print_ast(node->TypeDecl.name, indent+1);
print_ast(node->TypeDecl.type, indent+1);
break;
case AstNode_AliasDecl:
print_indent(indent);
gb_printf("(alias)\n");
print_ast(node->alias_decl.name, indent+1);
print_ast(node->alias_decl.type, indent+1);
print_ast(node->AliasDecl.name, indent+1);
print_ast(node->AliasDecl.type, indent+1);
break;
case AstNode_ProcType:
print_indent(indent);
gb_printf("(type:proc)(%td -> %td)\n", node->proc_type.param_count, node->proc_type.result_count);
print_ast(node->proc_type.param_list, indent+1);
if (node->proc_type.result_list) {
gb_printf("(type:proc)(%td -> %td)\n", node->ProcType.param_count, node->ProcType.result_count);
print_ast(node->ProcType.param_list, indent+1);
if (node->ProcType.result_list) {
print_indent(indent+1);
gb_printf("->\n");
print_ast(node->proc_type.result_list, indent+1);
print_ast(node->ProcType.result_list, indent+1);
}
break;
case AstNode_Field:
print_ast(node->field.name_list, indent);
print_ast(node->field.type, indent);
print_ast(node->Field.name_list, indent);
print_ast(node->Field.type, indent);
break;
case AstNode_PointerType:
print_indent(indent);
print_token(node->pointer_type.token);
print_ast(node->pointer_type.type, indent+1);
print_token(node->PointerType.token);
print_ast(node->PointerType.type, indent+1);
break;
case AstNode_ArrayType:
print_indent(indent);
gb_printf("[]\n");
print_ast(node->array_type.count, indent+1);
print_ast(node->array_type.elem, indent+1);
print_ast(node->ArrayType.count, indent+1);
print_ast(node->ArrayType.elem, indent+1);
break;
case AstNode_StructType:
print_indent(indent);
gb_printf("(struct)\n");
print_ast(node->struct_type.field_list, indent+1);
print_ast(node->StructType.field_list, indent+1);
break;
}

7
src/tokenizer.cpp
View File

@@ -705,7 +705,12 @@ Token tokenizer_get_token(Tokenizer *t) {
case '&':
token.kind = Token_And;
if (t->curr_rune == '~') {
token.kind = token_type_variant2(t, Token_AndNot, Token_AndNotEq);
token.kind = Token_AndNot;
advance_to_next_rune(t);
if (t->curr_rune == '=') {
token.kind = Token_AndNotEq;
advance_to_next_rune(t);
}
} else {
token.kind = token_type_variant3(t, Token_And, Token_AndEq, '&', Token_CmpAnd);
if (t->curr_rune == '=') {