krzosa/corelang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Modifying the class hierarchy and removing globals, allocators, simplifying

Browse Source
This commit is contained in:
Karol Krzosa (Nokia)
2022-12-31 20:10:11 +01:00
parent ffd6bc5d23
commit d75c54f61f
11 changed files with 153 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -9,6 +9,7 @@
*.c
*.lib
*.o
*.10x
*.sublime-*
tests/

24
base.cpp
View File

@@ -496,6 +496,18 @@ arena_push_size(Arena *a, size_t size){
return result;
}
CORE_Static Arena
push_arena(Allocator *allocator, size_t size, String debug_name) {
Arena result = {};
result.memory.data = (U8 *)allocate_size(allocator, size);
result.memory.reserve = size;
result.alignment = default_alignment;
result.debug_string = debug_name;
result.allocate = (Allocator::Allocate *)arena_push_size;
result.deallocate = (Allocator::Deallocate *)deallocate_stub;
return result;
}
CORE_Static void
arena_init(Arena *a, String debug_name){
a->memory = os_reserve(default_reserve_size);
@@ -634,7 +646,7 @@ struct Array{
*item = data[--len];
}
void init(Arena *a, S64 size = 16){
void init(Allocator *a, S64 size = 16){
allocator = a;
data = allocate_array(a, T, size);
cap = size;
@@ -686,7 +698,7 @@ struct Array{
template<class T>
CORE_Static Array<T>
array_make(Arena *a, S64 size = 16){
array_make(Allocator *a, S64 size = 16){
Array<T> result = {};
result.init(a, size);
return result;
@@ -774,7 +786,7 @@ map_grow(Map *map, S64 new_size){
}
CORE_Static Map
map_make(Arena *a, S64 size){
map_make(Allocator *a, S64 size){
Map result = {a};
map_grow(&result, size);
return result;
@@ -891,14 +903,14 @@ map_test(){
// String intern
//-----------------------------------------------------------------------------
struct Intern_Table{
Arena *string_allocator;
Allocator *string_allocator;
Map map;
U8 *first_keyword;
U8 *last_keyword;
};
CORE_Static Intern_Table
intern_table_make(Arena *string_allocator, Arena *map_allocator, S64 initial_size = 32){
intern_table_make(Allocator *string_allocator, Allocator *map_allocator, S64 initial_size = 32){
Intern_Table result = {};
result.map = map_make(map_allocator, initial_size);
result.string_allocator = string_allocator;
@@ -916,7 +928,7 @@ intern_string(Intern_Table *t, String string){
return result;
}
S64 *len_address = (S64 *)arena_push_size(t->string_allocator, string.len+1+sizeof(S64));
S64 *len_address = (S64 *)allocate_size(t->string_allocator, string.len+1+sizeof(S64), false);
*len_address = string.len;
U8 *string_address = (U8 *)(len_address + 1);

2
build.bat
View File

@@ -5,7 +5,7 @@ rem cl main.cpp -I.. user32.lib
clang core_main.cpp -O0 -Wall -Wno-unused-function -fno-exceptions -fdiagnostics-absolute-paths -g -o main.exe -Wl,user32.lib
rem ubuntu run clang core_main.cpp -O0 -Wall -Wno-unused-function -fno-exceptions -fdiagnostics-absolute-paths -g -o core.out
clang test.cpp
rem clang test.cpp
rem main.exe -testing
rem echo Building arms race

4
core_codegen_c_language.cpp
View File

@@ -771,7 +771,7 @@ gen_ast(Ast *ast){
CORE_Static String
compile_to_c_code(){
generating_time_begin = os_time();
pctx->generating_time_begin = os_time();
prefixed_string_type = string_fmt(pctx->perm, "%QString", symbol_prefix);
if(single_header_library_mode){
@@ -977,6 +977,6 @@ typedef struct String{
String string_result = string_flatten(pctx->perm, &pctx->gen);
generating_time_end = os_time();
pctx->generating_time_end = os_time();
return string_result;
}

189
core_compiler.cpp
View File

@@ -1,90 +1,87 @@
CORE_Static void
lex_init(Arena *token_string_arena, Arena *map_allocator, Lexer *l) {
l->arena = token_string_arena;
l->tokens = array_make<Token>(token_string_arena, 4096 * 4);
l->interns = intern_table_make(token_string_arena, map_allocator, 2048);
/*#import meta
for i in meta.keywords:
print(f'keyword_{i.lower()} = l->intern("{i}"_s);')
print(f'l->interns.first_keyword = keyword_{meta.keywords[0].lower()}.str;')
print(f'l->interns.last_keyword = keyword_{meta.keywords[-1].lower()}.str;')
for i in meta.interns:
print(f'intern_{i.lower()} = l->intern("{i}"_s);')
index = 0
for i in meta.token_simple_expr:
if i[1] != "SPECIAL":
print(f'op_info_table[{index}].op = l->intern("{i[1]}"_s);')
index += 1
*/
keyword_struct = l->intern("struct"_s);
keyword_union = l->intern("union"_s);
keyword_true = l->intern("true"_s);
keyword_default = l->intern("default"_s);
keyword_break = l->intern("break"_s);
keyword_false = l->intern("false"_s);
keyword_return = l->intern("return"_s);
keyword_switch = l->intern("switch"_s);
keyword_assert = l->intern("Assert"_s);
keyword_if = l->intern("if"_s);
keyword_elif = l->intern("elif"_s);
keyword_pass = l->intern("pass"_s);
keyword_else = l->intern("else"_s);
keyword_for = l->intern("for"_s);
keyword_enum = l->intern("enum"_s);
l->interns.first_keyword = keyword_struct.str;
l->interns.last_keyword = keyword_enum.str;
intern_typeof = l->intern("TypeOf"_s);
intern_sizeof = l->intern("SizeOf"_s);
intern_len = l->intern("Len"_s);
intern_alignof = l->intern("AlignOf"_s);
intern_foreign = l->intern("foreign"_s);
intern_strict = l->intern("strict"_s);
intern_void = l->intern("void"_s);
intern_flag = l->intern("flag"_s);
intern_it = l->intern("it"_s);
intern_load = l->intern("load"_s);
intern_import = l->intern("import"_s);
intern_link = l->intern("link"_s);
op_info_table[0].op = l->intern("*"_s);
op_info_table[1].op = l->intern("/"_s);
op_info_table[2].op = l->intern("%"_s);
op_info_table[3].op = l->intern("<<"_s);
op_info_table[4].op = l->intern(">>"_s);
op_info_table[5].op = l->intern("+"_s);
op_info_table[6].op = l->intern("-"_s);
op_info_table[7].op = l->intern("=="_s);
op_info_table[8].op = l->intern("<="_s);
op_info_table[9].op = l->intern(">="_s);
op_info_table[10].op = l->intern("<"_s);
op_info_table[11].op = l->intern(">"_s);
op_info_table[12].op = l->intern("!="_s);
op_info_table[13].op = l->intern("&"_s);
op_info_table[14].op = l->intern("|"_s);
op_info_table[15].op = l->intern("^"_s);
op_info_table[16].op = l->intern("&&"_s);
op_info_table[17].op = l->intern("||"_s);
op_info_table[18].op = l->intern("~"_s);
op_info_table[19].op = l->intern("!"_s);
/*END*/
}
CORE_Static void
parse_init(Parse_Ctx *ctx, Arena *perm_allocator) {
core_init_compiler(Parse_Ctx *ctx, Allocator *allocator) {
ctx->init_ctx_time_begin = os_time();
pctx = ctx;
ctx->perm = perm_allocator;
ctx->type_map = map_make(ctx->perm, 2048);
Allocator *heap_allocator = allocator;
ctx->perm = (Arena *)allocator;
ctx->type_map = map_make(heap_allocator, 2048);
ctx->gen = {ctx->perm};
ctx->helper_builder = {ctx->perm};
ctx->scope_ids = 1;
bigint_allocator = ctx->perm;
arena_init(&ctx->stage_arena, "Compiler stage arena"_s);
lex_init(ctx->perm, ctx->perm, ctx);
ctx->tokens = array_make<Token>(heap_allocator, 4096 * 4);
ctx->interns = intern_table_make(ctx->perm, heap_allocator, 2048);
/*#import meta
for i in meta.keywords:
print(f'keyword_{i.lower()} = ctx->intern("{i}"_s);')
print(f'ctx->interns.first_keyword = keyword_{meta.keywords[0].lower()}.str;')
print(f'ctx->interns.last_keyword = keyword_{meta.keywords[-1].lower()}.str;')
for i in meta.interns:
print(f'intern_{i.lower()} = ctx->intern("{i}"_s);')
index = 0
for i in meta.token_simple_expr:
if i[1] != "SPECIAL":
print(f'op_info_table[{index}].op = ctx->intern("{i[1]}"_s);')
index += 1
*/
keyword_struct = ctx->intern("struct"_s);
keyword_union = ctx->intern("union"_s);
keyword_true = ctx->intern("true"_s);
keyword_default = ctx->intern("default"_s);
keyword_break = ctx->intern("break"_s);
keyword_false = ctx->intern("false"_s);
keyword_return = ctx->intern("return"_s);
keyword_switch = ctx->intern("switch"_s);
keyword_assert = ctx->intern("Assert"_s);
keyword_if = ctx->intern("if"_s);
keyword_elif = ctx->intern("elif"_s);
keyword_pass = ctx->intern("pass"_s);
keyword_else = ctx->intern("else"_s);
keyword_for = ctx->intern("for"_s);
keyword_enum = ctx->intern("enum"_s);
ctx->interns.first_keyword = keyword_struct.str;
ctx->interns.last_keyword = keyword_enum.str;
intern_typeof = ctx->intern("TypeOf"_s);
intern_sizeof = ctx->intern("SizeOf"_s);
intern_len = ctx->intern("Len"_s);
intern_alignof = ctx->intern("AlignOf"_s);
intern_foreign = ctx->intern("foreign"_s);
intern_strict = ctx->intern("strict"_s);
intern_void = ctx->intern("void"_s);
intern_flag = ctx->intern("flag"_s);
intern_it = ctx->intern("it"_s);
intern_load = ctx->intern("load"_s);
intern_import = ctx->intern("import"_s);
intern_link = ctx->intern("link"_s);
op_info_table[0].op = ctx->intern("*"_s);
op_info_table[1].op = ctx->intern("/"_s);
op_info_table[2].op = ctx->intern("%"_s);
op_info_table[3].op = ctx->intern("<<"_s);
op_info_table[4].op = ctx->intern(">>"_s);
op_info_table[5].op = ctx->intern("+"_s);
op_info_table[6].op = ctx->intern("-"_s);
op_info_table[7].op = ctx->intern("=="_s);
op_info_table[8].op = ctx->intern("<="_s);
op_info_table[9].op = ctx->intern(">="_s);
op_info_table[10].op = ctx->intern("<"_s);
op_info_table[11].op = ctx->intern(">"_s);
op_info_table[12].op = ctx->intern("!="_s);
op_info_table[13].op = ctx->intern("&"_s);
op_info_table[14].op = ctx->intern("|"_s);
op_info_table[15].op = ctx->intern("^"_s);
op_info_table[16].op = ctx->intern("&&"_s);
op_info_table[17].op = ctx->intern("||"_s);
op_info_table[18].op = ctx->intern("~"_s);
op_info_table[19].op = ctx->intern("!"_s);
/*END*/
init_type();
// Init paths
@@ -93,20 +90,13 @@ parse_init(Parse_Ctx *ctx, Arena *perm_allocator) {
String main_module = string_fmt(ctx->perm, "%Q/modules", ctx->exe_folder);
add(ctx->perm, &ctx->module_folders, main_module);
ctx->init_ctx_time_end = os_time();
}
CORE_Static void
begin_compilation(Arena *allocator) {
init_ctx_time_begin = os_time();
core_bootstrap_compiler(Allocator *allocator) {
Parse_Ctx *ctx = allocate_struct(allocator, Parse_Ctx);
parse_init(ctx, allocator);
init_ctx_time_end = os_time();
}
CORE_Static void
destroy_compiler() {
arena_clear(pctx->perm);
arena_clear(&pctx->stage_arena);
core_init_compiler(ctx, allocator);
}
CORE_Static void
@@ -120,11 +110,9 @@ insert_builtin_type_into_scope(Ast_Scope *p, String name, Ast_Type *type) {
add(pctx->perm, &pctx->all_types, type);
}
global F64 parsing_time_begin;
global F64 parsing_time_end;
CORE_Static void
parse_all_modules() {
parsing_time_begin = os_time();
pctx->parsing_time_begin = os_time();
Iter_Named(&pctx->modules, mod_it) {
Ast_Module *module = mod_it.item[0];
@@ -142,7 +130,7 @@ parse_all_modules() {
module->state = MODULE_PARSED;
}
parsing_time_end = os_time();
pctx->parsing_time_end = os_time();
}
CORE_Static Ast_Module *
@@ -207,7 +195,7 @@ CORE_Static void
resolve_everything_in_module(Ast_Module *module) {
if (module->state == MODULE_RESOLVED)
return;
resolving_time_begin = os_time();
pctx->resolving_time_begin = os_time();
Iter_Named(&module->all_loaded_files, file) {
Iter(&file.item[0]->decls) {
Ast_Decl *decl = it.item[0];
@@ -219,13 +207,13 @@ resolve_everything_in_module(Ast_Module *module) {
}
}
module->state = MODULE_RESOLVED;
resolving_time_end = os_time();
pctx->resolving_time_end = os_time();
}
CORE_Static String
compile_file_to_string(Arena *arena, String filename) {
total_time = os_time();
begin_compilation(arena);
pctx->total_time = os_time();
core_bootstrap_compiler(arena);
{
Ast_Module *module = add_module(0, pctx->intern("Language.core"_s));
{
@@ -321,11 +309,11 @@ compile_file(Arena *arena, String filename, U32 compile_flags = COMPILE_NULL) {
F64 end = os_time();
if (is_flag_set(compile_flags, COMPILE_PRINT_STATS)) {
log_info("total = %f", os_time() - total_time);
log_info("total = %f", os_time() - pctx->total_time);
log_info("clang = %f", end - begin);
log_info("parsing = %f", parsing_time_end - parsing_time_begin);
log_info("resolving = %f", resolving_time_end - resolving_time_begin);
log_info("generatin = %f", generating_time_end - generating_time_begin);
log_info("parsing = %f", pctx->parsing_time_end - pctx->parsing_time_begin);
log_info("resolving = %f", pctx->resolving_time_end - pctx->resolving_time_begin);
log_info("generatin = %f", pctx->generating_time_end - pctx->generating_time_begin);
}
if (is_flag_set(compile_flags, COMPILE_PRINT_ALLOCATOR_STATS_BEFORE_DESTROY)) {
@@ -355,5 +343,4 @@ compile_file(Arena *arena, String filename, U32 compile_flags = COMPILE_NULL) {
log_info("");
}
destroy_compiler();
}

51
core_compiler.h
View File

@@ -1,4 +1,13 @@
/*
* Get rid of Scratch, move that concept onto the main context, create scratch memory from user allocator
* Simplify allocators, only should be derived from the user allocator
* Cleanup big int allocator
* Replace iterator interface
* Reset compiler
*/
struct Lex_Stream{
String stream;
@@ -11,31 +20,19 @@ struct Lex_Stream{
Array<Token *> indent_stack;
};
struct Lexer{
Arena *arena;
struct Parse_Ctx{
Arena *perm; // Stores: AST, tokens, interns
Arena stage_arena;
Arena scratch;
// Lexer stuff
Lex_Stream stream;
Array<Token> tokens;
Intern_Table interns;
S64 token_iter;
U32 token_debug_ids;
Intern_String intern(String string){
assert(string.len > 0);
return intern_string(&interns, string);
}
};
// Lexer::interns::map::allocator - array allocator, resizing
// Lexer::tokens - array allocator, resizing
//
// Parser::ast_arena - arena for asts
// Lexer::interns::string_allocator - arena for interns
//
struct Parse_Ctx:Lexer{
Arena *perm; // Stores: AST, tokens, interns
Arena stage_arena;
// Types
List<Ast_Type *> all_types;
S32 type_ids;
int lambda_ids;
@@ -63,10 +60,24 @@ struct Parse_Ctx:Lexer{
S64 indent;
String_Builder gen;
String_Builder helper_builder;
F64 generating_time_begin;
F64 generating_time_end;
F64 resolving_time_begin;
F64 resolving_time_end;
F64 total_time;
F64 init_ctx_time_begin;
F64 init_ctx_time_end;
F64 parsing_time_begin;
F64 parsing_time_end;
Intern_String intern(String string){
assert(string.len > 0);
return intern_string(&interns, string);
}
};
CORE_Static void init_type();
CORE_Static void lex_init(Arena *token_string_arena, Arena *map_allocator, Lexer *l);
CORE_Static String compile_to_c_code();
CORE_Static Ast_Module *ast_module(Token *pos, Intern_String filename);
CORE_Static void insert_builtin_types_into_scope(Ast_Scope *p);

1
core_compiler_interface.hpp
View File

@@ -65,7 +65,6 @@ struct List{
enum Token_Kind{
TK_End,
/*#
import meta
for i in meta.token_kinds:

13
core_globals.cpp
View File

@@ -3,10 +3,10 @@ global B32 emit_type_info = true;
global String symbol_prefix = ""_s;
global B32 single_header_library_mode = false;
global String single_header_library_name = ""_s;
global bool color_codes_enabled;
thread_local Parse_Ctx *pctx;
global bool color_codes_enabled;
Arena *bigint_allocator;
global S64 bigint_allocation_count;
@@ -108,13 +108,4 @@ global Ast_Type *untyped_bool = &type__untyped_bool;
global Ast_Type *untyped_int = &type__untyped_int;
global Ast_Type *untyped_float = &type__untyped_float;
//-----------------------------------------------------------------------------
// Time records
//-----------------------------------------------------------------------------
global F64 generating_time_begin;
global F64 generating_time_end;
global F64 resolving_time_begin;
global F64 resolving_time_end;
global F64 total_time;
global F64 init_ctx_time_begin;
global F64 init_ctx_time_end;

28
core_lexing.cpp
View File

@@ -56,7 +56,7 @@ lex_set_len(Lex_Stream *s, Token *token){
}
CORE_Static void
lex_set_keywords(Lexer *lexer, Array<String> keywords){
lex_set_keywords(Parse_Ctx *lexer, Array<String> keywords){
Intern_String keyword = {};
For(keywords){
keyword = intern_string(&lexer->interns, it);
@@ -79,7 +79,7 @@ token_error(Token *t, String error_val){
}
CORE_Static void
lex_parse_u64(Lexer *lexer, Token *t, S64 base){
lex_parse_u64(Parse_Ctx *lexer, Token *t, S64 base){
Scratch scratch;
Set_BigInt_Arena(scratch);
@@ -100,7 +100,7 @@ lex_parse_u64(Lexer *lexer, Token *t, S64 base){
m = bigint_mul(&m, &base_mul);
}
t->int_val = bigint_copy(lexer->arena, &result);
t->int_val = bigint_copy(lexer->perm, &result);
}
CORE_Static void
@@ -175,7 +175,7 @@ lex_parse_ident(Intern_Table *table, Lex_Stream *s, Token *t){
break
CORE_Static Token
token_make(Lexer *lexer, U8 *str, Intern_String file, int line, U8 *line_begin){
token_make(Parse_Ctx *lexer, U8 *str, Intern_String file, int line, U8 *line_begin){
Token t = {};
t.str = str;
t.file = file;
@@ -186,7 +186,7 @@ token_make(Lexer *lexer, U8 *str, Intern_String file, int line, U8 *line_begin){
}
CORE_Static Token
token_make(Lexer *lexer){
token_make(Parse_Ctx *lexer){
return token_make(lexer, lexcp(&lexer->stream), lexer->stream.file, lexer->stream.line, lexer->stream.line_begin);
}
@@ -228,7 +228,7 @@ lex_unwind_indent_stack(Token *t, Lex_Stream *s, Array<Token> *array){
}
CORE_Static void
lex__stream(Lexer *lexer){
lex__stream(Parse_Ctx *lexer){
Intern_Table *table = &lexer->interns;
Array<Token> *array = &lexer->tokens;
Lex_Stream *s = &lexer->stream;
@@ -585,15 +585,8 @@ lex__stream(Lexer *lexer){
#undef CASE3
}
CORE_Static Lexer
lex_make(Arena *token_string_arena, Arena *map_allocator){
Lexer result = {};
lex_init(token_string_arena, map_allocator, &result);
return result;
}
CORE_Static void
lex_restream(Lexer *lexer, String istream, String file){
lex_restream(Parse_Ctx *lexer, String istream, String file){
lexer->stream = {};
lexer->stream.stream = istream;
lexer->stream.line_begin = istream.str;
@@ -605,13 +598,6 @@ lex_restream(Lexer *lexer, String istream, String file){
lex__stream(lexer);
}
CORE_Static Lexer
lex_stream(Arena *token_string_arena, Arena *map_allocator, String istream, String file){
Lexer result = lex_make(token_string_arena, map_allocator);
lex_restream(&result, istream, file);
return result;
}
//-----------------------------------------------------------------------------
// Token metadata
//-----------------------------------------------------------------------------

2
core_typechecking.cpp
View File

@@ -1510,7 +1510,6 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str
Scratch scratch;
Array<Ast_Call_Item *> items = {scratch};
S64 was_name_indexed = false;
S64 default_iter = 0;
/*
@@ -1530,7 +1529,6 @@ resolve_expr(Ast_Expr *ast, Resolve_Flag flags, Ast_Type *compound_and_const_str
if(is_flag_set(it->call_flags, CALL_NAME)){
Ast_Atom *name = it->name;
assert(name->kind == AST_IDENT);
was_name_indexed = true;
if(name->intern_val.str == lambda_arg->name.str)
item = it;
}

2
core_typechecking.h
View File

@@ -11,7 +11,7 @@ union {
Ast_Decl *resolved_decl;
union {
bool bool_val;
F64 f64_val;
double f64_val;
Intern_String intern_val;
BigInt big_int_val;
Ast_Type *type_val;