ed/Odin
1
0
Fork 0
mirror of https://github.com/Ed94/Odin.git synced 2026-07-24 08:27:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Reorganize runtime package

Browse Source
This commit is contained in:
gingerBill
2018-05-27 21:22:25 +01:00
parent a5763d6fee
commit 5c52ffe24e
21 changed files with 908 additions and 856 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/build_settings.cpp
+3 -1
View File
@@ -351,6 +351,7 @@ String path_to_fullpath(gbAllocator a, String s) {
defer (gb_mutex_unlock(&string_buffer_mutex));
gbTempArenaMemory tmp = gb_temp_arena_memory_begin(&string_buffer_arena);
defer (gb_temp_arena_memory_end(tmp));
String16 string16 = string_to_string16(string_buffer_allocator, s);
DWORD len = GetFullPathNameW(&string16[0], 0, nullptr, nullptr);
@@ -359,8 +360,9 @@ String path_to_fullpath(gbAllocator a, String s) {
GetFullPathNameW(&string16[0], len, text, nullptr);
text[len] = 0;
result = string16_to_string(a, make_string16(text, len));
result = string_trim_whitespace(result);
}
gb_temp_arena_memory_end(tmp);
return result;
}
#elif defined(GB_SYSTEM_OSX) || defined(GB_SYSTEM_UNIX)
src/check_expr.cpp
+36 -36
View File
@@ -1565,25 +1565,25 @@ void check_comparison(Checker *c, Operand *x, Operand *y, TokenKind op) {
if (is_type_string(x->type) || is_type_string(y->type)) {
switch (op) {
case Token_CmpEq: add_preload_dependency(c, "__string_eq"); break;
case Token_NotEq: add_preload_dependency(c, "__string_ne"); break;
case Token_Lt: add_preload_dependency(c, "__string_lt"); break;
case Token_Gt: add_preload_dependency(c, "__string_gt"); break;
case Token_LtEq: add_preload_dependency(c, "__string_le"); break;
case Token_GtEq: add_preload_dependency(c, "__string_gt"); break;
case Token_CmpEq: add_package_dependency(c, "runtime", "__string_eq"); break;
case Token_NotEq: add_package_dependency(c, "runtime", "__string_ne"); break;
case Token_Lt: add_package_dependency(c, "runtime", "__string_lt"); break;
case Token_Gt: add_package_dependency(c, "runtime", "__string_gt"); break;
case Token_LtEq: add_package_dependency(c, "runtime", "__string_le"); break;
case Token_GtEq: add_package_dependency(c, "runtime", "__string_gt"); break;
}
} else if (is_type_complex(x->type) || is_type_complex(y->type)) {
switch (op) {
case Token_CmpEq:
switch (8*size) {
case 64: add_preload_dependency(c, "__complex64_eq"); break;
case 128: add_preload_dependency(c, "__complex128_eq"); break;
case 64: add_package_dependency(c, "runtime", "__complex64_eq"); break;
case 128: add_package_dependency(c, "runtime", "__complex128_eq"); break;
}
break;
case Token_NotEq:
switch (8*size) {
case 64: add_preload_dependency(c, "__complex64_ne"); break;
case 128: add_preload_dependency(c, "__complex128_ne"); break;
case 64: add_package_dependency(c, "runtime", "__complex64_ne"); break;
case 128: add_package_dependency(c, "runtime", "__complex128_ne"); break;
}
break;
}
@@ -1845,7 +1845,7 @@ bool check_is_castable_to(Checker *c, Operand *operand, Type *y) {
// cstring -> string
if (src == t_cstring && dst == t_string) {
if (operand->mode != Addressing_Constant) {
add_preload_dependency(c, "__cstring_to_string");
add_package_dependency(c, "runtime", "__cstring_to_string");
}
return true;
}
@@ -2949,7 +2949,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
} else {
mode = Addressing_Value;
if (is_type_cstring(op_type)) {
add_preload_dependency(c, "__cstring_len");
add_package_dependency(c, "runtime", "__cstring_len");
}
}
} else if (is_type_array(op_type)) {
@@ -3052,15 +3052,15 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
if (is_type_slice(type)) {
min_args = 2;
max_args = 2;
add_preload_dependency(c, "alloc");
add_package_dependency(c, "mem", "alloc");
} else if (is_type_map(type)) {
min_args = 1;
max_args = 2;
add_preload_dependency(c, "__dynamic_map_reserve");
add_package_dependency(c, "runtime", "__dynamic_map_reserve");
} else if (is_type_dynamic_array(type)) {
min_args = 1;
max_args = 3;
add_preload_dependency(c, "__dynamic_array_make");
add_package_dependency(c, "runtime", "__dynamic_array_make");
} else {
gbString str = type_to_string(type);
error(call, "Cannot 'make' %s; type must be a slice, map, or dynamic array", str);
@@ -3416,7 +3416,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
add_type_info_type(c, t);
if (is_operand_value(o) && is_type_typeid(t)) {
add_preload_dependency(c, "__type_info_of");
add_package_dependency(c, "runtime", "__type_info_of");
} else if (o.mode != Addressing_Type) {
error(expr, "Expected a type or typeid for 'type_info_of'");
return false;
@@ -3452,7 +3452,7 @@ bool check_builtin_procedure(Checker *c, Operand *operand, AstNode *call, i32 id
t = base_type(t);
if (is_operand_value(o) && are_types_identical(t, t_type_info_ptr)) {
add_preload_dependency(c, "__typeid_of");
add_package_dependency(c, "runtime", "__typeid_of");
} else if (o.mode != Addressing_Type) {
error(expr, "Expected a type or type info for 'typeid_of'");
return false;
@@ -3802,8 +3802,8 @@ break;
{
Type *bt = base_type(a.type);
if (bt == t_f32) add_preload_dependency(c, "__min_f32");
if (bt == t_f64) add_preload_dependency(c, "__min_f64");
if (bt == t_f32) add_package_dependency(c, "runtime", "__min_f32");
if (bt == t_f64) add_package_dependency(c, "runtime", "__min_f64");
}
}
@@ -3879,8 +3879,8 @@ break;
{
Type *bt = base_type(a.type);
if (bt == t_f32) add_preload_dependency(c, "__max_f32");
if (bt == t_f64) add_preload_dependency(c, "__max_f64");
if (bt == t_f32) add_package_dependency(c, "runtime", "__max_f32");
if (bt == t_f64) add_package_dependency(c, "runtime", "__max_f64");
}
}
@@ -3921,10 +3921,10 @@ break;
{
Type *bt = base_type(operand->type);
if (bt == t_f32) add_preload_dependency(c, "__abs_f32");
if (bt == t_f64) add_preload_dependency(c, "__abs_f64");
if (bt == t_complex64) add_preload_dependency(c, "__abs_complex64");
if (bt == t_complex128) add_preload_dependency(c, "__abs_complex128");
if (bt == t_f32) add_package_dependency(c, "runtime", "__abs_f32");
if (bt == t_f64) add_package_dependency(c, "runtime", "__abs_f64");
if (bt == t_complex64) add_package_dependency(c, "runtime", "__abs_complex64");
if (bt == t_complex128) add_package_dependency(c, "runtime", "__abs_complex128");
}
}
@@ -4025,12 +4025,12 @@ break;
{
Type *bt = base_type(x.type);
if (bt == t_f32) {
add_preload_dependency(c, "__min_f32");
add_preload_dependency(c, "__max_f32");
add_package_dependency(c, "runtime", "__min_f32");
add_package_dependency(c, "runtime", "__max_f32");
}
if (bt == t_f64) {
add_preload_dependency(c, "__min_f64");
add_preload_dependency(c, "__max_f64");
add_package_dependency(c, "runtime", "__min_f64");
add_package_dependency(c, "runtime", "__max_f64");
}
}
}
@@ -5643,8 +5643,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
context_name = str_lit("dynamic array literal");
is_constant = false;
add_preload_dependency(c, "__dynamic_array_reserve");
add_preload_dependency(c, "__dynamic_array_append");
add_package_dependency(c, "runtime", "__dynamic_array_reserve");
add_package_dependency(c, "runtime", "__dynamic_array_append");
} else {
GB_PANIC("unreachable");
}
@@ -5803,8 +5803,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
}
}
add_preload_dependency(c, "__dynamic_map_reserve");
add_preload_dependency(c, "__dynamic_map_set");
add_package_dependency(c, "runtime", "__dynamic_map_reserve");
add_package_dependency(c, "runtime", "__dynamic_map_set");
break;
}
@@ -5927,7 +5927,7 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
return kind;
}
add_preload_dependency(c, "__type_assertion_check");
add_package_dependency(c, "runtime", "__type_assertion_check");
case_end;
case_ast_node(tc, TypeCast, node);
@@ -6027,8 +6027,8 @@ ExprKind check_expr_base_internal(Checker *c, Operand *o, AstNode *node, Type *t
o->type = t->Map.value;
o->expr = node;
add_preload_dependency(c, "__dynamic_map_get");
add_preload_dependency(c, "__dynamic_map_set");
add_package_dependency(c, "runtime", "__dynamic_map_get");
add_package_dependency(c, "runtime", "__dynamic_map_set");
return Expr_Expr;
}
src/check_stmt.cpp
+1 -1
View File
@@ -1415,7 +1415,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
if (is_type_string(t)) {
val0 = t_rune;
val1 = t_int;
add_preload_dependency(c, "__string_decode_rune");
add_package_dependency(c, "runtime", "__string_decode_rune");
}
break;
case Type_Array:
src/check_type.cpp
+1 -1
View File
@@ -1733,7 +1733,7 @@ void check_map_type(Checker *c, Type *type, AstNode *node) {
type->Map.value = value;
if (is_type_string(key)) {
add_preload_dependency(c, "__default_hash_string");
add_package_dependency(c, "runtime", "__default_hash_string");
}
src/checker.cpp
+58 -36
View File
@@ -258,7 +258,7 @@ Scope *create_scope_from_package(Checker *c, AstPackage *p) {
s->is_init = p->kind == Package_Init;
}
if (p->kind == Package_Builtin) {
if (p->kind == Package_Runtime) {
s->is_global = true;
universal_scope->shared = s;
}
@@ -479,9 +479,21 @@ void add_type_info_dependency(DeclInfo *d, Type *type) {
ptr_set_add(&d->type_info_deps, type);
}
void add_preload_dependency(Checker *c, char *name) {
AstPackage *get_core_package(CheckerInfo *info, String name) {
gbAllocator a = heap_allocator();
String path = get_fullpath_core(a, name);
defer (gb_free(a, path.text));
HashKey key = hash_string(path);
auto found = map_get(&info->packages, key);
GB_ASSERT_MSG(found != nullptr, "Missing core package %.*s", LIT(name));
return *found;
}
void add_package_dependency(Checker *c, char *package_name, char *name) {
String n = make_string_c(name);
Entity *e = scope_lookup_entity(c->builtin_package->scope, n);
AstPackage *p = get_core_package(&c->info, make_string_c(package_name));
Entity *e = scope_lookup_entity(p->scope, n);
GB_ASSERT(e != nullptr);
ptr_set_add(&c->context.decl->deps, e);
// add_type_info_type(c, e->type);
@@ -913,6 +925,7 @@ void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclIn
GB_ASSERT(identifier->kind == AstNode_Ident);
GB_ASSERT(e != nullptr && d != nullptr);
GB_ASSERT(identifier->Ident.token.string == e->token.string);
if (e->scope != nullptr) {
Scope *scope = e->scope;
if (scope->is_file) {
@@ -924,22 +937,21 @@ void add_entity_and_decl_info(Checker *c, AstNode *identifier, Entity *e, DeclIn
default: {
AstPackage *p = scope->file->package;
GB_ASSERT(p->scope == scope->parent);
GB_ASSERT(c->context.package == p);
scope = p->scope;
if (e->package != nullptr) {
GB_ASSERT(e->package == p);
}
e->package = p;
break;
}
}
}
add_entity(c, scope, identifier, e);
}
add_entity_definition(&c->info, identifier, e);
GB_ASSERT(e->decl_info == nullptr);
e->decl_info = d;
array_add(&c->info.entities, e);
e->order_in_src = c->info.entities.count;
e->package = c->context.package;
}
@@ -1141,10 +1153,11 @@ void add_curr_ast_file(Checker *c, AstFile *file) {
if (file != nullptr) {
TokenPos zero_pos = {};
global_error_collector.prev = zero_pos;
c->curr_ast_file = file;
c->context.decl = file->package->decl_info;
c->context.scope = file->scope;
c->context.package_scope = file->package->scope;
c->curr_ast_file = file;
c->context.decl = file->package->decl_info;
c->context.scope = file->scope;
c->context.package = file->package;
c->context.package_scope = file->package->scope;
}
}
@@ -1331,14 +1344,14 @@ void add_dependency_to_set(Checker *c, Entity *entity) {
}
}
void generate_minimum_dependency_set(Checker *c, Entity *start) {
ptr_set_init(&c->info.minimum_dependency_set, heap_allocator());
ptr_set_init(&c->info.minimum_dependency_type_info_set, heap_allocator());
String required_entities[] = {
String required_builtin_entities[] = {
str_lit("__mem_zero"),
str_lit("__init_context"),
str_lit("default_allocator"),
str_lit("__args__"),
str_lit("__type_table"),
@@ -1348,8 +1361,16 @@ void generate_minimum_dependency_set(Checker *c, Entity *start) {
str_lit("Allocator"),
str_lit("Context"),
};
for (isize i = 0; i < gb_count_of(required_entities); i++) {
add_dependency_to_set(c, scope_lookup_entity(c->builtin_package->scope, required_entities[i]));
for (isize i = 0; i < gb_count_of(required_builtin_entities); i++) {
add_dependency_to_set(c, scope_lookup_entity(c->runtime_package->scope, required_builtin_entities[i]));
}
AstPackage *mem = get_core_package(&c->info, str_lit("mem"));
String required_mem_entities[] = {
str_lit("default_allocator"),
};
for (isize i = 0; i < gb_count_of(required_mem_entities); i++) {
add_dependency_to_set(c, scope_lookup_entity(mem->scope, required_mem_entities[i]));
}
if (!build_context.no_bounds_check) {
@@ -1359,7 +1380,7 @@ void generate_minimum_dependency_set(Checker *c, Entity *start) {
str_lit("__dynamic_array_expr_error"),
};
for (isize i = 0; i < gb_count_of(bounds_check_entities); i++) {
add_dependency_to_set(c, scope_lookup_entity(c->builtin_package->scope, bounds_check_entities[i]));
add_dependency_to_set(c, scope_lookup_entity(c->runtime_package->scope, bounds_check_entities[i]));
}
}
@@ -1479,7 +1500,7 @@ Array<EntityGraphNode *> generate_entity_dependency_graph(CheckerInfo *info) {
Entity *find_core_entity(Checker *c, String name) {
Entity *e = current_scope_lookup_entity(c->builtin_package->scope, name);
Entity *e = current_scope_lookup_entity(c->runtime_package->scope, name);
if (e == nullptr) {
compiler_error("Could not find type declaration for '%.*s'\n"
"Is '_preload.odin' missing from the 'core' directory relative to odin.exe?", LIT(name));
@@ -1489,7 +1510,7 @@ Entity *find_core_entity(Checker *c, String name) {
}
Type *find_core_type(Checker *c, String name) {
Entity *e = current_scope_lookup_entity(c->builtin_package->scope, name);
Entity *e = current_scope_lookup_entity(c->runtime_package->scope, name);
if (e == nullptr) {
compiler_error("Could not find type declaration for '%.*s'\n"
"Is '_preload.odin' missing from the 'core' directory relative to odin.exe?", LIT(name));
@@ -1605,7 +1626,8 @@ void init_preload(Checker *c) {
}
if (t_allocator == nullptr) {
Entity *e = find_core_entity(c, str_lit("Allocator"));
AstPackage *mem = get_core_package(&c->info, str_lit("mem"));
Entity *e = scope_lookup_entity(mem->scope, str_lit("Allocator"));
t_allocator = e->type;
t_allocator_ptr = alloc_type_pointer(t_allocator);
}
@@ -2118,6 +2140,8 @@ void check_add_foreign_block_decl(Checker *c, AstNode *decl) {
void check_collect_entities(Checker *c, Array<AstNode *> nodes) {
for_array(decl_index, nodes) {
AstNode *decl = nodes[decl_index];
if (c->context.scope->is_file) {
}
if (!is_ast_node_decl(decl) && !is_ast_node_when_stmt(decl)) {
if (c->context.scope->is_file && decl->kind == AstNode_ExprStmt) {
@@ -2204,7 +2228,6 @@ void check_all_global_entities(Checker *c) {
}
GB_ASSERT(d->scope->is_file);
AstFile *file = d->scope->file;
add_curr_ast_file(c, file);
@@ -2222,7 +2245,6 @@ void check_all_global_entities(Checker *c) {
}
}
CheckerContext prev_context = c->context;
c->context.decl = d;
c->context.scope = d->scope;
@@ -2394,8 +2416,8 @@ Array<ImportGraphNode *> generate_import_dependency_graph(Checker *c) {
// Calculate edges for graph M
for_array(i, c->parser->packages) {
AstPackage *p = c->parser->packages[i];
for_array(j, p->files.entries) {
AstFile *f = p->files.entries[j].value;
for_array(j, p->files) {
AstFile *f = p->files[j];
for_array(k, f->decls) {
AstNode *decl = f->decls[k];
add_import_dependency_node(c, decl, &M);
@@ -2441,8 +2463,8 @@ Array<ImportPathItem> find_import_path(Checker *c, Scope *start, Scope *end, Ptr
AstPackage *p = (*found)->package;
GB_ASSERT(p != nullptr);
for_array(i, p->files.entries) {
AstFile *f = p->files.entries[i].value;
for_array(i, p->files) {
AstFile *f = p->files[i];
for_array(j, f->imports) {
Scope *s = nullptr;
AstNode *decl = f->imports[j];
@@ -2707,8 +2729,8 @@ void check_import_entities(Checker *c) {
GB_ASSERT(node->scope->is_package);
AstPackage *p = node->scope->package;
for_array(i, p->files.entries) {
AstFile *f = p->files.entries[i].value;
for_array(i, p->files) {
AstFile *f = p->files[i];
CheckerContext prev_context = c->context;
defer (c->context = prev_context);
add_curr_ast_file(c, f);
@@ -2719,8 +2741,8 @@ void check_import_entities(Checker *c) {
}
}
for_array(i, p->files.entries) {
AstFile *f = p->files.entries[i].value;
for_array(i, p->files) {
AstFile *f = p->files[i];
CheckerContext prev_context = c->context;
defer (c->context = prev_context);
add_curr_ast_file(c, f);
@@ -2903,9 +2925,9 @@ void check_parsed_files(Checker *c) {
if (scope->is_init) {
c->info.init_scope = scope;
}
if (p->kind == Package_Builtin) {
GB_ASSERT(c->builtin_package == nullptr);
c->builtin_package = p;
if (p->kind == Package_Runtime) {
GB_ASSERT(c->runtime_package == nullptr);
c->runtime_package = p;
}
}
@@ -2914,8 +2936,8 @@ void check_parsed_files(Checker *c) {
for_array(i, c->parser->packages) {
AstPackage *p = c->parser->packages[i];
CheckerContext prev_context = c->context;
for_array(j, p->files.entries) {
AstFile *f = p->files.entries[j].value;
for_array(j, p->files) {
AstFile *f = p->files[j];
create_scope_from_file(c, f);
HashKey key = hash_string(f->fullpath);
map_set(&c->info.files, key, f);
@@ -3029,8 +3051,8 @@ void check_parsed_files(Checker *c) {
token.pos.file = s->package->fullpath;
token.pos.line = 1;
token.pos.column = 1;
if (s->package->files.entries.count > 0) {
AstFile *f = s->package->files.entries[0].value;
if (s->package->files.count > 0) {
AstFile *f = s->package->files[0];
if (f->tokens.count > 0) {
token = f->tokens[0];
}
src/checker.hpp
+11 -11
View File
@@ -274,15 +274,16 @@ struct ForeignContext {
typedef Array<Entity *> CheckerTypePath;
struct CheckerContext {
Scope * package_scope;
Scope * scope;
DeclInfo * decl;
u32 stmt_state_flags;
bool in_defer; // TODO(bill): Actually handle correctly
String proc_name;
Type * type_hint;
DeclInfo * curr_proc_decl;
Type * curr_proc_sig;
AstPackage * package;
Scope * package_scope;
Scope * scope;
DeclInfo * decl;
u32 stmt_state_flags;
bool in_defer; // TODO(bill): Actually handle correctly
String proc_name;
Type * type_hint;
DeclInfo * curr_proc_decl;
Type * curr_proc_sig;
ForeignContext foreign_context;
CheckerTypePath *type_path;
@@ -312,7 +313,6 @@ struct CheckerInfo {
Array<Type *> type_info_types;
Map<isize> type_info_map; // Key: Type *
Scope * init_scope;
Entity * entry_point;
PtrSet<Entity *> minimum_dependency_set;
@@ -326,7 +326,7 @@ struct Checker {
AstFile * curr_ast_file;
AstPackage * builtin_package;
AstPackage * runtime_package;
// NOTE(bill): Procedures to check
Array<ProcedureInfo> procs;
Map<Scope *> package_scopes; // Key: String (fullpath)
src/ir.cpp
+22 -6
View File
@@ -1532,7 +1532,9 @@ irDebugInfo *ir_add_debug_info_proc(irProcedure *proc, Entity *entity, String na
//
////////////////////////////////////////////////////////////////
irValue *ir_emit_global_call(irProcedure *proc, char const *name_, Array<irValue *> args, AstNode *expr = nullptr);
irValue *ir_emit_global_call (irProcedure *proc, char const *name_, Array<irValue *> args, AstNode *expr = nullptr);
irValue *ir_emit_package_call(irProcedure *proc, char const *package_name_, char const *name_, Array<irValue *> args, AstNode *expr = nullptr);
irValue *ir_emit_store(irProcedure *p, irValue *address, irValue *value) {
Type *a = type_deref(ir_type(address));
@@ -1632,7 +1634,7 @@ irValue *ir_find_or_generate_context_ptr(irProcedure *proc) {
irValue *ep = ir_emit_struct_ep(proc, c, 0);
Array<irValue *> args = {};
irValue *v = ir_emit_global_call(proc, "default_allocator", args);
irValue *v = ir_emit_package_call(proc, "mem", "default_allocator", args);
ir_emit_store(proc, ep, v);
return c;
@@ -1706,6 +1708,19 @@ irValue *ir_emit_global_call(irProcedure *proc, char const *name_, Array<irValue
ir_add_debug_location_to_value(proc, call, expr);
return call;
}
irValue *ir_emit_package_call(irProcedure *proc, char const *package_name_, char const *name_, Array<irValue *> args, AstNode *expr) {
String name = make_string_c(cast(char *)name_);
String package_name = make_string_c(cast(char *)package_name_);
AstPackage *p = get_core_package(proc->module->info, package_name);
Entity *e = current_scope_lookup_entity(p->scope, name);
irValue **found = map_get(&proc->module->values, hash_entity(e));
GB_ASSERT_MSG(found != nullptr, "%.*s", LIT(name));
irValue *gp = *found;
irValue *call = ir_emit_call(proc, gp, args);
ir_add_debug_location_to_value(proc, call, expr);
return call;
}
@@ -3755,9 +3770,10 @@ void ir_emit_dynamic_array_bounds_check(irProcedure *proc, Token token, irValue
//
////////////////////////////////////////////////////////////////
String ir_mangle_name(irGen *s, String path, Entity *e) {
String ir_mangle_name(irGen *s, Entity *e) {
// NOTE(bill): prefix names not in the init scope
// TODO(bill): make robust and not just rely on the file's name
String path = e->token.pos.file;
String name = e->token.string;
irModule *m = &s->module;
CheckerInfo *info = m->info;
@@ -4307,7 +4323,7 @@ irValue *ir_build_builtin_proc(irProcedure *proc, AstNode *expr, TypeAndValue tv
args[0] = slice_size;
args[1] = elem_align;
args[2] = ir_emit_source_code_location(proc, proc_name, pos);
irValue *call = ir_emit_global_call(proc, "alloc", args);
irValue *call = ir_emit_package_call(proc, "mem", "alloc", args);
irValue *ptr = ir_emit_conv(proc, call, elem_ptr_type);
irValue *slice = ir_add_local_generated(proc, type);
@@ -8318,7 +8334,7 @@ void ir_gen_tree(irGen *s) {
String name = e->token.string;
if (!no_name_mangle) {
name = ir_mangle_name(s, e->token.pos.file, e);
name = ir_mangle_name(s, e);
}
ir_add_entity_name(m, e, name);
@@ -8390,7 +8406,7 @@ void ir_gen_tree(irGen *s) {
} else if (e->kind == Entity_Procedure && e->Procedure.link_name.len > 0) {
// Handle later
} else {
name = ir_mangle_name(s, e->token.pos.file, e);
name = ir_mangle_name(s, e);
}
}
ir_add_entity_name(m, e, name);
src/main.cpp
+1 -1
View File
@@ -578,7 +578,7 @@ void show_timings(Checker *c, Timings *t) {
isize files = 0;
isize packages = p->packages.count;
for_array(i, p->packages) {
files += p->packages[i]->files.entries.count;
files += p->packages[i]->files.count;
}
{
src/parser.cpp
+55 -35
View File
@@ -60,6 +60,7 @@ Token ast_node_token(AstNode *node) {
case AstNode_Label: return node->Label.token;
case AstNode_ValueDecl: return ast_node_token(node->ValueDecl.names[0]);
case AstNode_PackageDecl: return node->PackageDecl.token;
case AstNode_ImportDecl: return node->ImportDecl.token;
case AstNode_ForeignImportDecl: return node->ForeignImportDecl.token;
@@ -998,6 +999,15 @@ AstNode *ast_value_decl(AstFile *f, Array<AstNode *> names, AstNode *type, Array
return result;
}
AstNode *ast_package_decl(AstFile *f, Token token, Token name, CommentGroup docs, CommentGroup comment) {
AstNode *result = make_ast_node(f, AstNode_PackageDecl);
result->PackageDecl.token = token;
result->PackageDecl.name = name;
result->PackageDecl.docs = docs;
result->PackageDecl.comment = comment;
return result;
}
AstNode *ast_import_decl(AstFile *f, Token token, bool is_using, Token relpath, Token import_name,
CommentGroup docs, CommentGroup comment) {
AstNode *result = make_ast_node(f, AstNode_ImportDecl);
@@ -1307,6 +1317,7 @@ bool is_semicolon_optional_for_node(AstFile *f, AstNode *s) {
case AstNode_ProcLit:
return s->ProcLit.body != nullptr;
case AstNode_PackageDecl:
case AstNode_ImportDecl:
case AstNode_ForeignImportDecl:
return true;
@@ -3887,10 +3898,10 @@ void destroy_parser(Parser *p) {
// TODO(bill): Fix memory leak
for_array(i, p->packages) {
AstPackage *package = p->packages[i];
for_array(j, package->files.entries) {
destroy_ast_file(package->files.entries[j].value);
for_array(j, package->files) {
destroy_ast_file(package->files[j]);
}
map_destroy(&package->files);
array_free(&package->files);
}
#if 0
for_array(i, p->imports) {
@@ -4101,12 +4112,12 @@ void parse_setup_file_decls(Parser *p, AstFile *f, String base_dir, Array<AstNod
}
}
void parse_file(Parser *p, AstFile *f) {
bool parse_file(Parser *p, AstFile *f) {
if (f->tokens.count == 0) {
return;
return true;
}
if (f->tokens.count > 0 && f->tokens[0].kind == Token_EOF) {
return;
return true;
}
String filepath = f->tokenizer.fullpath;
@@ -4121,23 +4132,30 @@ void parse_file(Parser *p, AstFile *f) {
comsume_comment_groups(f, f->prev_token);
CommentGroup docs = f->lead_comment;
f->package_token = expect_token(f, Token_package);
Token package_name = expect_token_after(f, Token_Ident, "package");
if (package_name.kind == Token_Ident) {
if (package_name.string == "_") {
error(package_name, "Invalid package name '_'");
} else if (f->package->kind != Package_Builtin && package_name.string == "builtin") {
} else if (f->package->kind != Package_Runtime && package_name.string == "runtime") {
error(package_name, "Use of reserved package name '%.*s'", LIT(package_name.string));
}
}
f->package_name = package_name.string;
AstNode *pd = ast_package_decl(f, f->package_token, package_name, docs, f->line_comment);
expect_semicolon(f, pd);
if (f->error_count > 0) {
return;
return false;
}
f->decls = parse_stmt_list(f);
parse_setup_file_decls(p, f, base_dir, f->decls);
return true;
}
@@ -4195,38 +4213,41 @@ ParseFileError parse_imported_file(Parser *p, AstPackage *package, FileInfo *fi,
skip:
parse_file(p, file);
if (parse_file(p, file)) {
gb_mutex_lock(&p->file_add_mutex);
array_add(&package->files, file);
gb_mutex_lock(&p->file_add_mutex);
HashKey key = hash_string(fi->fullpath);
map_set(&package->files, key, file);
if (package->name.len == 0) {
package->name = file->package_name;
} else if (file->tokens.count > 0 && package->name != file->package_name) {
error(file->package_token, "Different package name, expected '%.*s', got '%.*s'", LIT(package->name), LIT(file->package_name));
}
if (package->name.len == 0) {
package->name = file->package_name;
} else if (file->tokens.count > 0 && package->name != file->package_name) {
error(file->package_token, "Different package name, expected '%.*s', got '%.*s'", LIT(package->name), LIT(file->package_name));
p->total_line_count += file->tokenizer.line_count;
p->total_token_count += file->tokens.count;
gb_mutex_unlock(&p->file_add_mutex);
}
p->total_line_count += file->tokenizer.line_count;
p->total_token_count += file->tokens.count;
gb_mutex_unlock(&p->file_add_mutex);
return ParseFile_None;
}
void parser_add_package(Parser *p, AstPackage *package) {
package->id = p->packages.count+1;
array_add(&p->packages, package);
}
ParseFileError parse_import(Parser *p, ImportedPackage imported_package) {
String import_path = imported_package.path;
String import_rel_path = imported_package.rel_path;
TokenPos pos = imported_package.pos;
String const ext = str_lit(".odin");
String const file_ext = str_lit(".odin");
// NOTE(bill): Single file initial package
if (imported_package.kind == Package_Init && string_ends_with(import_path, ext)) {
if (imported_package.kind == Package_Init && string_ends_with(import_path, file_ext)) {
AstPackage *package = gb_alloc_item(heap_allocator(), AstPackage);
package->kind = imported_package.kind;
package->fullpath = import_path;
map_init(&package->files, heap_allocator());
array_init(&package->files, heap_allocator());
FileInfo fi = {};
fi.name = filename_from_path(import_path);
@@ -4239,12 +4260,12 @@ ParseFileError parse_import(Parser *p, ImportedPackage imported_package) {
return err;
}
package->id = p->packages.count+1;
array_add(&p->packages, package);
parser_add_package(p, package);
return ParseFile_None;
}
Array<FileInfo> list = {};
ReadDirectoryError rd_err = read_directory(import_path, &list);
defer (array_free(&list));
@@ -4253,6 +4274,7 @@ ParseFileError parse_import(Parser *p, ImportedPackage imported_package) {
GB_ASSERT(import_path != list[0].fullpath);
}
if (rd_err != ReadDirectory_None) {
if (pos.line != 0) {
gb_printf_err("%.*s(%td:%td) ", LIT(pos.file), pos.line, pos.column);
@@ -4291,13 +4313,13 @@ ParseFileError parse_import(Parser *p, ImportedPackage imported_package) {
AstPackage *package = gb_alloc_item(heap_allocator(), AstPackage);
package->kind = imported_package.kind;
package->fullpath = import_path;
map_init(&package->files, heap_allocator());
array_init(&package->files, heap_allocator());
// TODO(bill): Fix concurrency
for_array(i, list) {
FileInfo *fi = &list[i];
for_array(list_index, list) {
FileInfo *fi = &list[list_index];
String name = fi->name;
if (string_ends_with(name, ext)) {
if (string_ends_with(name, file_ext)) {
if (is_excluded_target_filename(name)) {
continue;
}
@@ -4308,9 +4330,7 @@ ParseFileError parse_import(Parser *p, ImportedPackage imported_package) {
}
}
package->id = p->packages.count+1;
array_add(&p->packages, package);
parser_add_package(p, package);
return ParseFile_None;
}
@@ -4348,8 +4368,8 @@ ParseFileError parse_packages(Parser *p, String init_filename) {
isize shared_package_count = 0;
if (!build_context.generate_docs) {
String s = get_fullpath_core(heap_allocator(), str_lit("builtin"));
try_add_import_path(p, s, s, init_pos, Package_Builtin);
String s = get_fullpath_core(heap_allocator(), str_lit("runtime"));
try_add_import_path(p, s, s, init_pos, Package_Runtime);
shared_package_count++;
}
src/parser.hpp
+12 -6
View File
@@ -27,7 +27,7 @@ struct CommentGroup {
enum PackageKind {
Package_Normal,
Package_Builtin,
Package_Runtime,
Package_Init,
};
@@ -85,11 +85,11 @@ struct AstFile {
struct AstPackage {
isize id;
PackageKind kind;
String name;
String fullpath;
Map<AstFile *> files; // Key: String (names)
isize id;
PackageKind kind;
String name;
String fullpath;
Array<AstFile *> files;
Scope * scope; // NOTE(bill): Created in checker
DeclInfo *decl_info; // NOTE(bill): Created in checker
@@ -356,6 +356,12 @@ AST_NODE_KIND(_DeclBegin, "", struct {}) \
bool is_mutable; \
bool been_handled; \
}) \
AST_NODE_KIND(PackageDecl, "package declaration", struct { \
Token token; \
Token name; \
CommentGroup docs; \
CommentGroup comment; \
}) \
AST_NODE_KIND(ImportDecl, "import declaration", struct { \
AstPackage *package; \
Token token; \