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

#import "" as namespace

Browse Source
This commit is contained in:
Ginger Bill
2016-09-14 19:35:13 +01:00
parent bb109b47d6
commit 79f575ae8e
12 changed files with 322 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
code/demo.odin
View File

@@ -1,4 +1,4 @@
#import "print.odin"
#import "print.odin" as _
test_proc :: proc() {
println("Hello?")

106
code/file.odin
View File

@@ -1,106 +0,0 @@
#import "win32.odin"
File :: type struct {
Handle :: type HANDLE
handle: Handle
}
file_open :: proc(name: string) -> (File, bool) {
buf: [300]byte
_ = copy(buf[:], name as []byte)
f := File{CreateFileA(^buf[0], FILE_GENERIC_READ, FILE_SHARE_READ, null, OPEN_EXISTING, 0, null)}
success := f.handle != INVALID_HANDLE_VALUE as File.Handle
return f, success
}
file_create :: proc(name: string) -> (File, bool) {
buf: [300]byte
_ = copy(buf[:], name as []byte)
f := File{
handle = CreateFileA(^buf[0], FILE_GENERIC_WRITE, FILE_SHARE_READ, null, CREATE_ALWAYS, 0, null),
}
success := f.handle != INVALID_HANDLE_VALUE as File.Handle
return f, success
}
file_close :: proc(f: ^File) {
CloseHandle(f.handle)
}
file_write :: proc(f: ^File, buf: []byte) -> bool {
bytes_written: i32
return WriteFile(f.handle, ^buf[0], buf.count as i32, ^bytes_written, null) != 0
}
File_Standard :: type enum {
INPUT,
OUTPUT,
ERROR,
COUNT,
}
__std_files := __set_file_standards();
__set_file_standards :: proc() -> [File_Standard.COUNT as int]File {
return [File_Standard.COUNT as int]File{
File{handle = GetStdHandle(STD_INPUT_HANDLE)},
File{handle = GetStdHandle(STD_OUTPUT_HANDLE)},
File{handle = GetStdHandle(STD_ERROR_HANDLE)},
}
}
file_get_standard :: proc(std: File_Standard) -> ^File {
return ^__std_files[std]
}
read_entire_file :: proc(name: string) -> (string, bool) {
buf: [300]byte
_ = copy(buf[:], name as []byte)
c_string := ^buf[0]
f, file_ok := file_open(name)
if !file_ok {
return "", false
}
defer file_close(^f)
length: i64
file_size_ok := GetFileSizeEx(f.handle as HANDLE, ^length) != 0
if !file_size_ok {
return "", false
}
data := new_slice(u8, length)
if ^data[0] == null {
return "", false
}
single_read_length: i32
total_read: i64
for total_read < length {
remaining := length - total_read
to_read: u32
MAX :: 0x7fffffff
if remaining <= MAX {
to_read = remaining as u32
} else {
to_read = MAX
}
ReadFile(f.handle as HANDLE, ^data[total_read], to_read, ^single_read_length, null)
if single_read_length <= 0 {
free(^data[0])
return "", false
}
total_read += single_read_length as i64
}
return data as string, true
}

21
code/print.odin
View File

@@ -1,6 +1,5 @@
#import "runtime.odin"
#import "win32.odin"
#import "file.odin"
#import "runtime.odin" as _
#import "os.odin" as os
print_byte_buffer :: proc(buf: ^[]byte, b: []byte) {
if buf.count < buf.capacity {
@@ -555,31 +554,31 @@ print_to_buffer :: proc(buf: ^[]byte, fmt: string, args: ..any) {
PRINT_BUF_SIZE :: 1<<12
print_to_file :: proc(f: ^File, fmt: string, args: ..any) {
print_to_file :: proc(f: ^os.File, fmt: string, args: ..any) {
data: [PRINT_BUF_SIZE]byte
buf := data[:0]
print_to_buffer(^buf, fmt, ..args)
file_write(f, buf)
os.write(f, buf)
}
println_to_file :: proc(f: ^File, fmt: string, args: ..any) {
println_to_file :: proc(f: ^os.File, fmt: string, args: ..any) {
data: [PRINT_BUF_SIZE]byte
buf := data[:0]
print_to_buffer(^buf, fmt, ..args)
print_nl_to_buffer(^buf)
file_write(f, buf)
os.write(f, buf)
}
print :: proc(fmt: string, args: ..any) {
print_to_file(file_get_standard(File_Standard.OUTPUT), fmt, ..args)
print_to_file(os.file_get_standard(os.File_Standard.OUTPUT), fmt, ..args)
}
print_err :: proc(fmt: string, args: ..any) {
print_to_file(file_get_standard(File_Standard.ERROR), fmt, ..args)
print_to_file(os.file_get_standard(os.File_Standard.ERROR), fmt, ..args)
}
println :: proc(fmt: string, args: ..any) {
println_to_file(file_get_standard(File_Standard.OUTPUT), fmt, ..args)
println_to_file(os.file_get_standard(os.File_Standard.OUTPUT), fmt, ..args)
}
println_err :: proc(fmt: string, args: ..any) {
println_to_file(file_get_standard(File_Standard.ERROR), fmt, ..args)
println_to_file(os.file_get_standard(os.File_Standard.ERROR), fmt, ..args)
}

14
code/runtime.odin
View File

@@ -1,9 +1,9 @@
#global_scope
// TODO(bill): Remove #import in runtime.odin
#import "win32.odin"
#import "file.odin"
#import "print.odin"
#import "win32.odin" as win32
#import "os.odin" as os
#import "print.odin" as _
// IMPORTANT NOTE(bill): Do not change the order of any of this data
// The compiler relies upon this _exact_ order
@@ -84,15 +84,15 @@ fmuladd_f32 :: proc(a, b, c: f32) -> f32 #foreign "llvm.fmuladd.f32"
fmuladd_f64 :: proc(a, b, c: f64) -> f64 #foreign "llvm.fmuladd.f64"
heap_alloc :: proc(len: int) -> rawptr {
return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len)
return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, len)
}
heap_free :: proc(ptr: rawptr) {
_ = HeapFree(GetProcessHeap(), 0, ptr)
_ = win32.HeapFree(win32.GetProcessHeap(), 0, ptr)
}
current_thread_id :: proc() -> int {
id := GetCurrentThreadId()
id := win32.GetCurrentThreadId()
return id as int
}
@@ -171,7 +171,7 @@ __string_ge :: proc(a, b : string) -> bool #inline { return __string_cmp(a, b) >
__assert :: proc(msg: string) {
file_write(file_get_standard(File_Standard.ERROR), msg as []byte)
os.write(os.file_get_standard(os.File_Standard.ERROR), msg as []byte)
__debug_trap()
}

52
src/checker/checker.cpp
View File

@@ -315,7 +315,7 @@ void check_close_scope(Checker *c) {
c->context.scope = c->context.scope->parent;
}
void scope_lookup_parent_entity(Checker *c, Scope *scope, String name, Scope **scope_, Entity **entity_) {
void scope_lookup_parent_entity(Scope *scope, String name, Scope **scope_, Entity **entity_) {
b32 gone_thru_proc = false;
HashKey key = hash_string(name);
for (Scope *s = scope; s != NULL; s = s->parent) {
@@ -366,9 +366,9 @@ void scope_lookup_parent_entity(Checker *c, Scope *scope, String name, Scope **s
if (scope_) *scope_ = NULL;
}
Entity *scope_lookup_entity(Checker *c, Scope *s, String name) {
Entity *scope_lookup_entity(Scope *s, String name) {
Entity *entity = NULL;
scope_lookup_parent_entity(c, s, name, NULL, &entity);
scope_lookup_parent_entity(s, name, NULL, &entity);
return entity;
}
@@ -949,33 +949,41 @@ void check_parsed_files(Checker *c) {
gb_for_array(decl_index, f->decls) {
AstNode *decl = f->decls[decl_index];
switch (decl->kind) {
case_ast_node(id, ImportDecl, decl);
HashKey key = hash_string(id->fullpath);
auto found = map_get(&file_scopes, key);
GB_ASSERT_MSG(found != NULL, "Unable to find scope for file: %.*s", LIT(id->fullpath));
Scope *scope = *found;
b32 previously_added = false;
gb_for_array(import_index, file_scope->imported) {
Scope *prev = file_scope->imported[import_index];
if (prev == scope) {
previously_added = true;
break;
}
}
if (!previously_added) {
gb_array_append(file_scope->imported, scope);
}
if (decl->kind != AstNode_ImportDecl) {
continue;
}
ast_node(id, ImportDecl, decl);
HashKey key = hash_string(id->fullpath);
auto found = map_get(&file_scopes, key);
GB_ASSERT_MSG(found != NULL, "Unable to find scope for file: %.*s", LIT(id->fullpath));
Scope *scope = *found;
b32 previously_added = false;
gb_for_array(import_index, file_scope->imported) {
Scope *prev = file_scope->imported[import_index];
if (prev == scope) {
previously_added = true;
break;
}
}
if (!previously_added) {
gb_array_append(file_scope->imported, scope);
}
if (are_strings_equal(id->import_name.string, make_string("_"))) {
// NOTE(bill): Add imported entities to this file's scope
gb_for_array(elem_index, scope->elements.entries) {
Entity *e = scope->elements.entries[elem_index].value;
// NOTE(bill): Do not add other imported entities
if (e->scope == scope) {
if (e->scope == scope && e->kind != Entity_ImportName) {
add_entity(c, file_scope, NULL, e);
}
}
case_end;
} else {
Entity *e = make_entity_import_name(c->allocator, file_scope, id->import_name, t_invalid,
id->fullpath, id->import_name.string,
scope);
add_entity(c, file_scope, NULL, e);
}
}
}

20
src/checker/entity.cpp
View File

@@ -9,6 +9,7 @@ enum BuiltinProcId;
ENTITY_KIND(TypeName), \
ENTITY_KIND(Procedure), \
ENTITY_KIND(Builtin), \
ENTITY_KIND(ImportName), \
ENTITY_KIND(Count),
@@ -49,11 +50,19 @@ struct Entity {
i32 field_index; // Order in source
b8 is_field; // Is struct field
} Variable;
struct {} TypeName;
struct {
struct DeclInfo *decl; // Usually NULL
} TypeName;
struct {
b8 pure;
} Procedure;
struct { BuiltinProcId id; } Builtin;
struct {
String path;
String name;
Scope *scope;
b32 used;
} ImportName;
};
};
@@ -124,6 +133,15 @@ Entity *make_entity_builtin(gbAllocator a, Scope *scope, Token token, Type *type
return entity;
}
Entity *make_entity_import_name(gbAllocator a, Scope *scope, Token token, Type *type,
String path, String name, Scope *import_scope) {
Entity *entity = alloc_entity(a, Entity_ImportName, scope, token, type);
entity->ImportName.path = path;
entity->ImportName.name = name;
entity->ImportName.scope = import_scope;
return entity;
}
Entity *make_entity_dummy_variable(gbAllocator a, Scope *file_scope, Token token) {
token.string = make_string("_");
return make_entity_variable(a, file_scope, token, NULL);

179
src/checker/expr.cpp
View File

@@ -286,8 +286,9 @@ void check_fields(Checker *c, AstNode *node, AstNodeArray decls,
Token name_token = td->name->Ident;
Entity *e = make_entity_type_name(c->allocator, c->context.scope, name_token, NULL);
check_type_decl(c, e, td->type, NULL, NULL);
add_entity(c, c->context.scope, td->name, e);
gb_printf("%.*s\n", LIT(e->token.string));
check_type_decl(c, e, td->type, NULL, NULL);
HashKey key = hash_string(name_token.string);
if (map_get(&entity_map, key) != NULL) {
@@ -728,10 +729,14 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type, Cycl
GB_ASSERT(n->kind == AstNode_Ident);
o->mode = Addressing_Invalid;
o->expr = n;
Entity *e = scope_lookup_entity(c, c->context.scope, n->Ident.string);
Entity *e = scope_lookup_entity(c->context.scope, n->Ident.string);
if (e == NULL) {
error(&c->error_collector, n->Ident,
"Undeclared type or identifier `%.*s`", LIT(n->Ident.string));
if (are_strings_equal(n->Ident.string, make_string("_"))) {
error(&c->error_collector, n->Ident, "`_` cannot be used as a value type");
} else {
error(&c->error_collector, n->Ident,
"Undeclared named: `%.*s`", LIT(n->Ident.string));
}
return;
}
add_entity_use(&c->info, n, e);
@@ -744,14 +749,7 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type, Cycl
gb_array_free(local_cycle_checker.path);
});
if (e->type == NULL) {
auto *found = map_get(&c->info.entities, hash_pointer(e));
if (found != NULL) {
check_entity_decl(c, e, *found, named_type, cycle_checker);
} else {
GB_PANIC("Internal Compiler Error: DeclInfo not found!");
}
}
check_entity_decl(c, e, NULL, named_type, cycle_checker);
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.string));
@@ -808,6 +806,10 @@ void check_identifier(Checker *c, Operand *o, AstNode *n, Type *named_type, Cycl
o->mode = Addressing_Builtin;
break;
case Entity_ImportName:
error(&c->error_collector, ast_node_token(n), "Use of import `%.*s` not in selector", LIT(e->ImportName.name));
return;
default:
GB_PANIC("Compiler error: Unknown EntityKind");
break;
@@ -875,18 +877,30 @@ Type *check_type(Checker *c, AstNode *e, Type *named_type, CycleChecker *cycle_c
case_ast_node(se, SelectorExpr, e);
Operand o = {};
o.mode = Addressing_Type;
o.type = check_type(c, se->expr, named_type, cycle_checker);
// gb_printf_err("mode: %.*s\n", LIT(addressing_mode_strings[o.mode]));
check_selector(c, &o, e);
// gb_printf_err("%s.%s\n", expr_to_string(se->expr), expr_to_string(se->selector));
// gb_printf_err("%s\n", type_to_string(o.type));
// gb_printf_err("mode: %.*s\n", LIT(addressing_mode_strings[o.mode]));
if (o.mode == Addressing_Type) {
switch (o.mode) {
case Addressing_Type:
GB_ASSERT(o.type != NULL);
set_base_type(type, o.type);
o.type->flags |= e->type_flags;
return o.type;
case Addressing_Invalid:
break;
case Addressing_NoValue: {
gbString err = expr_to_string(e);
defer (gb_string_free(err));
error(&c->error_collector, ast_node_token(e), "`%s` used as a type", err);
} break;
default: {
gbString err = expr_to_string(e);
defer (gb_string_free(err));
error(&c->error_collector, ast_node_token(e), "`%s` is not a type", err);
} break;
}
if (o.mode == Addressing_Type) {
}
case_end;
@@ -1959,54 +1973,90 @@ b32 check_index_value(Checker *c, AstNode *index_value, i64 max_count, i64 *valu
}
Entity *check_selector(Checker *c, Operand *operand, AstNode *node) {
GB_ASSERT(node->kind == AstNode_SelectorExpr);
ast_node(se, SelectorExpr, node);
b32 check_op_expr = true;
Entity *entity = NULL;
AstNode *op_expr = se->expr;
AstNode *selector = se->selector;
if (selector) {
Entity *entity = lookup_field(operand->type, selector->Ident.string, operand->mode == Addressing_Type).entity;
if (entity == NULL) {
gbString op_str = expr_to_string(op_expr);
gbString type_str = type_to_string(operand->type);
gbString sel_str = expr_to_string(selector);
defer (gb_string_free(op_str));
defer (gb_string_free(type_str));
defer (gb_string_free(sel_str));
error(&c->error_collector, ast_node_token(op_expr), "`%s` (`%s`) has no field `%s`", op_str, type_str, sel_str);
operand->mode = Addressing_Invalid;
operand->expr = node;
return NULL;
}
add_entity_use(&c->info, selector, entity);
operand->type = entity->type;
operand->expr = node;
switch (entity->kind) {
case Entity_Constant:
operand->mode = Addressing_Constant;
operand->value = entity->Constant.value;
break;
case Entity_Variable:
operand->mode = Addressing_Variable;
break;
case Entity_TypeName:
operand->mode = Addressing_Type;
break;
case Entity_Procedure:
operand->mode = Addressing_Value;
break;
case Entity_Builtin:
operand->mode = Addressing_Builtin;
operand->builtin_id = entity->Builtin.id;
break;
}
return entity;
} else {
operand->mode = Addressing_Invalid;
operand->expr = node;
AstNode *selector = unparen_expr(se->selector);
if (selector == NULL) {
goto error;
}
GB_ASSERT(selector->kind == AstNode_Ident);
if (op_expr->kind == AstNode_Ident) {
String name = op_expr->Ident.string;
Entity *e = scope_lookup_entity(c->context.scope, name);
add_entity_use(&c->info, op_expr, e);
if (e != NULL && e->kind == Entity_ImportName) {
check_op_expr = false;
entity = scope_lookup_entity(e->ImportName.scope, selector->Ident.string);
add_entity_use(&c->info, selector, entity);
if (entity == NULL) {
gbString sel_str = expr_to_string(selector);
defer (gb_string_free(sel_str));
error(&c->error_collector, ast_node_token(op_expr), "`%s` is not declared in `%.*s`", sel_str, LIT(name));
goto error;
}
if (entity->type == NULL) { // Not setup yet
check_entity_decl(c, entity, NULL, NULL);
}
GB_ASSERT(entity->type != NULL);
}
}
if (check_op_expr) {
check_expr_base(c, operand, op_expr);
if (operand->mode == Addressing_Invalid) {
goto error;
}
}
if (entity == NULL) {
entity = lookup_field(operand->type, selector->Ident.string, operand->mode == Addressing_Type).entity;
}
if (entity == NULL) {
gbString op_str = expr_to_string(op_expr);
gbString type_str = type_to_string(operand->type);
gbString sel_str = expr_to_string(selector);
defer (gb_string_free(op_str));
defer (gb_string_free(type_str));
defer (gb_string_free(sel_str));
error(&c->error_collector, ast_node_token(op_expr), "`%s` (`%s`) has no field `%s`", op_str, type_str, sel_str);
goto error;
}
add_entity_use(&c->info, selector, entity);
operand->type = entity->type;
operand->expr = node;
switch (entity->kind) {
case Entity_Constant:
operand->mode = Addressing_Constant;
operand->value = entity->Constant.value;
break;
case Entity_Variable:
operand->mode = Addressing_Variable;
break;
case Entity_TypeName:
operand->mode = Addressing_Type;
break;
case Entity_Procedure:
operand->mode = Addressing_Value;
break;
case Entity_Builtin:
operand->mode = Addressing_Builtin;
operand->builtin_id = entity->Builtin.id;
break;
}
return entity;
error:
operand->mode = Addressing_Invalid;
operand->expr = node;
return NULL;
}
@@ -3202,7 +3252,6 @@ ExprKind check__expr_base(Checker *c, Operand *o, AstNode *node, Type *type_hint
case_ast_node(se, SelectorExpr, node);
check_expr_base(c, o, se->expr);
check_selector(c, o, node);
case_end;

50
src/checker/stmt.cpp
View File

@@ -171,7 +171,7 @@ Type *check_assignment_variable(Checker *c, Operand *op_a, AstNode *lhs) {
b32 used = false;
if (node->kind == AstNode_Ident) {
ast_node(i, Ident, node);
e = scope_lookup_entity(c, c->context.scope, i->string);
e = scope_lookup_entity(c->context.scope, i->string);
if (e != NULL && e->kind == Entity_Variable) {
used = e->Variable.used; // TODO(bill): Make backup just in case
}
@@ -374,9 +374,8 @@ void check_type_decl(Checker *c, Entity *e, AstNode *type_expr, Type *def, Cycle
gb_array_free(local_cycle_checker.path);
});
check_type(c, type_expr, named, cycle_checker_add(cycle_checker, e));
Type *base_type = check_type(c, type_expr, named, cycle_checker_add(cycle_checker, e));
named->Named.base = base_type;
named->Named.base = get_base_type(named->Named.base);
if (named->Named.base == t_invalid) {
// gb_printf("check_type_decl: %s\n", type_to_string(named));
@@ -562,22 +561,41 @@ void check_var_decl(Checker *c, Entity *e, Entity **entities, isize entity_count
void check_entity_decl(Checker *c, Entity *e, DeclInfo *d, Type *named_type, CycleChecker *cycle_checker) {
if (e->type != NULL)
return;
if (e->type != NULL) {
if (e->type->kind == Type_Named && e->type->Named.base == NULL) {
// NOTE(bill): Some weird declaration error from Entity_ImportName
} else {
return;
}
}
if (d == NULL) {
DeclInfo **found = map_get(&c->info.entities, hash_pointer(e));
if (found) {
d = *found;
} else {
GB_PANIC("`%.*s` should been declared!", LIT(e->token.string));
}
}
switch (e->kind) {
case Entity_Constant: {
Scope *prev = c->context.scope;
c->context.scope = d->scope;
defer (c->context.scope = prev);
c->context.decl = d;
check_const_decl(c, e, d->type_expr, d->init_expr);
c->context.scope = prev;
} break;
case Entity_Variable: {
Scope *prev = c->context.scope;
c->context.scope = d->scope;
defer (c->context.scope = prev);
c->context.decl = d;
check_var_decl(c, e, d->entities, d->entity_count, d->type_expr, d->init_expr);
c->context.scope = prev;
} break;
case Entity_TypeName: {
CycleChecker local_cycle_checker = {};
@@ -1234,7 +1252,7 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
AstNode *expr = unparen_expr(es->expr);
if (expr->kind == AstNode_Ident) {
String name = expr->Ident.string;
e = scope_lookup_entity(c, c->context.scope, name);
e = scope_lookup_entity(c->context.scope, name);
} else if (expr->kind == AstNode_SelectorExpr) {
Operand o = {};
check_expr_base(c, &o, expr->SelectorExpr.expr);
@@ -1285,6 +1303,18 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
}
} break;
case Entity_ImportName: {
Scope *scope = e->ImportName.scope;
gb_for_array(i, scope->elements.entries) {
Entity *decl = scope->elements.entries[i].value;
Entity *found = scope_insert_entity(c->context.scope, decl);
if (found != NULL) {
error(&c->error_collector, us->token, "Namespace collision while `using` `%s` of: %.*s", expr_str, LIT(found->token.string));
return;
}
}
} break;
case Entity_Constant:
error(&c->error_collector, us->token, "`using` cannot be applied to a constant");
break;
@@ -1334,7 +1364,7 @@ void check_stmt(Checker *c, AstNode *node, u32 flags) {
AstNode *item = vd->names[name_index];
ast_node(i, Ident, item);
String name = i->string;
Entity *e = scope_lookup_entity(c, c->context.scope, name);
Entity *e = scope_lookup_entity(c->context.scope, name);
Type *t = get_base_type(type_deref(e->type));
if (is_type_struct(t) || is_type_raw_union(t)) {
Scope **found = map_get(&c->info.scopes, hash_pointer(t->Record.node));

1
src/codegen/codegen.cpp
View File

@@ -84,6 +84,7 @@ void ssa_gen_tree(ssaGen *s) {
if (str[i] == '\\') {
str[i] = '/';
}
}
char const *base = gb_path_base_name(str);
char const *ext = gb_path_extension(base);

87
src/codegen/print_llvm.cpp
View File

@@ -744,7 +744,7 @@ void ssa_print_instr(ssaFileBuffer *f, ssaModule *m, ssaValue *value) {
void ssa_print_proc(ssaFileBuffer *f, ssaModule *m, ssaProcedure *proc) {
if (proc->body == NULL) {
ssa_fprintf(f, "\ndeclare ");
ssa_fprintf(f, "declare ");
} else {
ssa_fprintf(f, "\ndefine ");
}
@@ -844,47 +844,64 @@ void ssa_print_llvm_ir(ssaFileBuffer *f, ssaModule *m) {
gb_for_array(member_index, m->members.entries) {
auto *entry = &m->members.entries[member_index];
ssaValue *v = entry->value;
switch (v->kind) {
case ssaValue_TypeName:
ssa_print_type_name(f, m, v);
break;
if (v->kind != ssaValue_TypeName) {
continue;
}
ssa_print_type_name(f, m, v);
}
gb_for_array(member_index, m->members.entries) {
auto *entry = &m->members.entries[member_index];
ssaValue *v = entry->value;
if (v->kind != ssaValue_Proc) {
continue;
}
if (v->Proc.body == NULL) {
ssa_print_proc(f, m, &v->Proc);
}
}
gb_for_array(member_index, m->members.entries) {
auto *entry = &m->members.entries[member_index];
ssaValue *v = entry->value;
switch (v->kind) {
case ssaValue_Global: {
auto *g = &v->Global;
ssa_print_encoded_global(f, g->entity->token.string);
ssa_fprintf(f, " = ");
if (g->is_thread_local) {
ssa_fprintf(f, "thread_local ");
}
if (g->is_constant) {
if (g->is_private) {
ssa_fprintf(f, "private ");
}
ssa_fprintf(f, "constant ");
} else {
ssa_fprintf(f, "global ");
}
ssa_print_type(f, m->sizes, g->entity->type);
ssa_fprintf(f, " ");
if (g->value != NULL) {
ssa_print_value(f, m, g->value, g->entity->type);
} else {
ssa_fprintf(f, "zeroinitializer");
}
ssa_fprintf(f, "\n");
} break;
case ssaValue_Proc: {
if (v->kind != ssaValue_Proc) {
continue;
}
if (v->Proc.body != NULL) {
ssa_print_proc(f, m, &v->Proc);
} break;
}
}
gb_for_array(member_index, m->members.entries) {
auto *entry = &m->members.entries[member_index];
ssaValue *v = entry->value;
if (v->kind != ssaValue_Global) {
continue;
}
auto *g = &v->Global;
ssa_print_encoded_global(f, g->entity->token.string);
ssa_fprintf(f, " = ");
if (g->is_thread_local) {
ssa_fprintf(f, "thread_local ");
}
if (g->is_constant) {
if (g->is_private) {
ssa_fprintf(f, "private ");
}
ssa_fprintf(f, "constant ");
} else {
ssa_fprintf(f, "global ");
}
ssa_print_type(f, m->sizes, g->entity->type);
ssa_fprintf(f, " ");
if (g->value != NULL) {
ssa_print_value(f, m, g->value, g->entity->type);
} else {
ssa_fprintf(f, "zeroinitializer");
}
ssa_fprintf(f, "\n");
}
}

24
src/codegen/ssa.cpp
View File

@@ -927,6 +927,11 @@ ssaValue *ssa_lvalue_load(ssaProcedure *proc, ssaAddr lval) {
ssaValue *v = ssa_emit_load(proc, lval.addr);
return ssa_emit(proc, ssa_make_instr_extract_element(proc, v, lval.index));
}
// HACK(bill): Imported procedures don't require a load
Type *t = get_base_type(ssa_type(lval.addr));
if (t->kind == Type_Proc) {
return lval.addr;
}
return ssa_emit_load(proc, lval.addr);
}
GB_PANIC("Illegal lvalue load");
@@ -2519,13 +2524,20 @@ ssaAddr ssa_build_addr(ssaProcedure *proc, AstNode *expr) {
case_ast_node(se, SelectorExpr, expr);
ssa_emit_comment(proc, make_string("SelectorExpr"));
Type *type = get_base_type(type_of_expr(proc->module->info, se->expr));
String selector = unparen_expr(se->selector)->Ident.string;
if (type == t_invalid) {
Entity *imp = entity_of_ident(proc->module->info, se->expr);
GB_ASSERT(imp->kind == Entity_ImportName);
// Entity *e = scope_lookup_entity(e->ImportName.scope, selector);
return ssa_build_addr(proc, unparen_expr(se->selector));
} else {
Selection sel = lookup_field(type, selector, false);
GB_ASSERT(sel.entity != NULL);
Selection sel = lookup_field(type, unparen_expr(se->selector)->Ident.string, false);
GB_ASSERT(sel.entity != NULL);
ssaValue *e = ssa_build_addr(proc, se->expr).addr;
e = ssa_emit_deep_field_gep(proc, type, e, sel);
return ssa_make_addr(e, expr);
ssaValue *e = ssa_build_addr(proc, se->expr).addr;
e = ssa_emit_deep_field_gep(proc, type, e, sel);
return ssa_make_addr(e, expr);
}
case_end;
case_ast_node(ue, UnaryExpr, expr);

41
src/parser.cpp
View File

@@ -43,11 +43,15 @@ struct AstFile {
TokenPos fix_prev_pos;
};
struct ImportedFile {
String path;
TokenPos pos; // #import
};
struct Parser {
String init_fullpath;
gbArray(AstFile) files;
gbArray(String) imports;
gbArray(ImportedFile) imports;
gbArray(String) libraries;
gbArray(String) system_libraries;
isize load_index;
@@ -232,7 +236,8 @@ AST_NODE_KIND(_DeclBegin, "", struct{}) \
AST_NODE_KIND(TypeDecl, "type declaration", struct { Token token; AstNode *name, *type; }) \
AST_NODE_KIND(ImportDecl, "import declaration", struct { \
Token token, relpath; \
String fullpath; \
String fullpath; \
Token import_name; \
}) \
AST_NODE_KIND(ForeignSystemLibrary, "foreign system library", struct { Token token, filepath; }) \
AST_NODE_KIND(_DeclEnd, "", struct{}) \
@@ -883,10 +888,11 @@ gb_inline AstNode *make_type_decl(AstFile *f, Token token, AstNode *name, AstNod
return result;
}
gb_inline AstNode *make_import_decl(AstFile *f, Token token, Token relpath) {
gb_inline AstNode *make_import_decl(AstFile *f, Token token, Token relpath, Token import_name) {
AstNode *result = make_node(f, AstNode_ImportDecl);
result->ImportDecl.token = token;
result->ImportDecl.relpath = relpath;
result->ImportDecl.import_name = import_name;
return result;
}
@@ -2541,9 +2547,13 @@ AstNode *parse_stmt(AstFile *f) {
ast_file_err(f, token, "You cannot use #global_scope within a procedure. This must be done at the file scope.");
return make_bad_decl(f, token, f->cursor[0]);
} else if (are_strings_equal(tag, make_string("import"))) {
// TODO(bill): better error messages
Token file_path = expect_token(f, Token_String);
Token as = expect_token(f, Token_as);
Token import_name = expect_token(f, Token_Identifier);
if (f->curr_proc == NULL) {
return make_import_decl(f, s->TagStmt.token, file_path);
return make_import_decl(f, s->TagStmt.token, file_path, import_name);
}
ast_file_err(f, token, "You cannot use #import within a procedure. This must be done at the file scope.");
return make_bad_decl(f, token, file_path);
@@ -2695,15 +2705,18 @@ void destroy_parser(Parser *p) {
}
// NOTE(bill): Returns true if it's added
b32 try_add_import_path(Parser *p, String import_file, AstNode *node) {
b32 try_add_import_path(Parser *p, String path, TokenPos pos) {
gb_for_array(i, p->imports) {
String import = p->imports[i];
if (are_strings_equal(import, import_file)) {
String import = p->imports[i].path;
if (are_strings_equal(import, path)) {
return false;
}
}
gb_array_append(p->imports, import_file);
ImportedFile item;
item.path = path;
item.pos = pos;
gb_array_append(p->imports, item);
return true;
}
@@ -2799,7 +2812,7 @@ void parse_file(Parser *p, AstFile *f) {
String import_file = make_string(path_str);
id->fullpath = import_file;
if (!try_add_import_path(p, import_file, node)) {
if (!try_add_import_path(p, import_file, ast_node_token(node).pos)) {
// gb_free(gb_heap_allocator(), import_file.text);
}
} else if (node->kind == AstNode_ForeignSystemLibrary) {
@@ -2821,14 +2834,20 @@ void parse_file(Parser *p, AstFile *f) {
ParseFileError parse_files(Parser *p, char *init_filename) {
char *fullpath_str = gb_path_get_full_name(gb_heap_allocator(), init_filename);
String init_fullpath = make_string(fullpath_str);
gb_array_append(p->imports, init_fullpath);
TokenPos init_pos = {};
ImportedFile init_imported_file = {init_fullpath, init_pos};
gb_array_append(p->imports, init_imported_file);
p->init_fullpath = init_fullpath;
gb_for_array(i, p->imports) {
String import_path = p->imports[i];
String import_path = p->imports[i].path;
TokenPos pos = p->imports[i].pos;
AstFile file = {};
ParseFileError err = init_ast_file(&file, import_path);
if (err != ParseFile_None) {
if (pos.line != 0) {
gb_printf_err("%.*s(%td:%td) ", LIT(pos.file), pos.line, pos.column);
}
gb_printf_err("Failed to parse file: %.*s\n", LIT(import_path));
switch (err) {
case ParseFile_WrongExtension: