Bruce/tomo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Restructure compile_file() so it moves a bit more towards less usage of

Browse Source 
side effects
This commit is contained in:
Bruce Hill 2025-02-19 16:30:19 -05:00
parent c4479e4bd6
commit b89291957a
8 changed files with 319 additions and 321 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

549
compile.c
View File

@ -1146,173 +1146,15 @@ static CORD _compile_statement(env_t *env, ast_t *ast)
}
}
case StructDef: {
compile_struct_def(env, ast);
return CORD_EMPTY;
}
case EnumDef: {
compile_enum_def(env, ast);
return CORD_EMPTY;
}
case LangDef: {
auto def = Match(ast, LangDef);
CORD_appendf(&env->code->typeinfos, "public const TypeInfo_t %r%s = {%zu, %zu, .metamethods=Text$metamethods, .tag=TextInfo, .TextInfo={%r}};\n",
namespace_prefix(env, env->namespace), def->name, sizeof(Text_t), __alignof__(Text_t),
CORD_quoted(def->name));
compile_namespace(env, def->name, def->namespace);
return CORD_EMPTY;
}
case FunctionDef: {
auto fndef = Match(ast, FunctionDef);
bool is_private = Match(fndef->name, Var)->name[0] == '_';
CORD name = compile(env, fndef->name);
type_t *ret_t = fndef->ret_type ? parse_type_ast(env, fndef->ret_type) : Type(VoidType);
CORD arg_signature = "(";
Table_t used_names = {};
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
arg_signature = CORD_cat(arg_signature, compile_declaration(arg_type, CORD_cat("_$", arg->name)));
if (arg->next) arg_signature = CORD_cat(arg_signature, ", ");
if (Table$str_get(used_names, arg->name))
code_err(ast, "The argument name '%s' is used more than once", arg->name);
Table$str_set(&used_names, arg->name, arg->name);
}
arg_signature = CORD_cat(arg_signature, ")");
CORD ret_type_code = compile_type(ret_t);
if (is_private)
env->code->staticdefs = CORD_all(env->code->staticdefs, "static ", ret_type_code, " ", name, arg_signature, ";\n");
CORD code;
if (fndef->cache) {
code = CORD_all("static ", ret_type_code, " ", name, "$uncached", arg_signature);
} else {
code = CORD_all(ret_type_code, " ", name, arg_signature);
if (fndef->is_inline)
code = CORD_cat("INLINE ", code);
if (!is_private)
code = CORD_cat("public ", code);
}
env_t *body_scope = fresh_scope(env);
body_scope->deferred = NULL;
body_scope->namespace = NULL;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
set_binding(body_scope, arg->name, arg_type, CORD_cat("_$", arg->name));
}
body_scope->fn_ret = ret_t;
type_t *body_type = get_type(body_scope, fndef->body);
if (ret_t->tag != VoidType && ret_t->tag != AbortType && body_type->tag != AbortType && body_type->tag != ReturnType)
code_err(ast, "This function can reach the end without returning a %T value!", ret_t);
CORD body = compile_statement(body_scope, fndef->body);
if (streq(Match(fndef->name, Var)->name, "main"))
body = CORD_all("_$", env->namespace->name, "$$initialize();\n", body);
if (CORD_fetch(body, 0) != '{')
body = CORD_asprintf("{\n%r\n}", body);
env->code->funcs = CORD_all(env->code->funcs, with_source_info(ast, CORD_all(code, " ", body, "\n")));
if (fndef->cache && fndef->args == NULL) { // no-args cache just uses a static var
CORD wrapper = CORD_all(
is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, "(void) {\n"
"static ", compile_declaration(ret_t, "cached_result"), ";\n",
"static bool initialized = false;\n",
"if (!initialized) {\n"
"\tcached_result = ", name, "$uncached();\n",
"\tinitialized = true;\n",
"}\n",
"return cached_result;\n"
"}\n");
env->code->funcs = CORD_cat(env->code->funcs, wrapper);
} else if (fndef->cache && fndef->cache->tag == Int) {
assert(fndef->args);
OptionalInt64_t cache_size = Int64$parse(Text$from_str(Match(fndef->cache, Int)->str));
CORD pop_code = CORD_EMPTY;
if (fndef->cache->tag == Int && !cache_size.is_none && cache_size.i > 0) {
pop_code = CORD_all("if (cache.entries.length > ", CORD_asprintf("%ld", cache_size.i),
") Table$remove(&cache, cache.entries.data + cache.entries.stride*RNG$int64(default_rng, 0, cache.entries.length-1), table_type);\n");
}
if (!fndef->args->next) {
// Single-argument functions have simplified caching logic
type_t *arg_type = get_arg_ast_type(env, fndef->args);
CORD wrapper = CORD_all(
is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, arg_signature, "{\n"
"static Table_t cache = {};\n",
"const TypeInfo_t *table_type = Table$info(", compile_type_info(env, arg_type), ", ", compile_type_info(env, ret_t), ");\n",
compile_declaration(Type(PointerType, .pointed=ret_t), "cached"), " = Table$get_raw(cache, &_$", fndef->args->name, ", table_type);\n"
"if (cached) return *cached;\n",
compile_declaration(ret_t, "ret"), " = ", name, "$uncached(_$", fndef->args->name, ");\n",
pop_code,
"Table$set(&cache, &_$", fndef->args->name, ", &ret, table_type);\n"
"return ret;\n"
"}\n");
env->code->funcs = CORD_cat(env->code->funcs, wrapper);
} else {
// Multi-argument functions use a custom struct type (only defined internally) as a cache key:
arg_t *fields = NULL;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next)
fields = new(arg_t, .name=arg->name, .type=get_arg_ast_type(env, arg), .next=fields);
REVERSE_LIST(fields);
type_t *t = Type(StructType, .name=heap_strf("%s$args", fndef->name), .fields=fields, .env=env);
int64_t num_fields = used_names.entries.length;
const char *short_name = Match(fndef->name, Var)->name;
const char *metamethods = is_packed_data(t) ? "PackedData$metamethods" : "Struct$metamethods";
CORD args_typeinfo = CORD_asprintf("((TypeInfo_t[1]){{.size=%zu, .align=%zu, .metamethods=%s, "
".tag=StructInfo, .StructInfo.name=\"%s\", "
".StructInfo.num_fields=%ld, .StructInfo.fields=(NamedType_t[%ld]){",
type_size(t), type_align(t), metamethods, short_name,
num_fields, num_fields);
CORD args_type = "struct { ";
for (arg_t *f = fields; f; f = f->next) {
args_typeinfo = CORD_all(args_typeinfo, "{\"", f->name, "\", ", compile_type_info(env, f->type), "}");
args_type = CORD_all(args_type, compile_declaration(f->type, f->name), "; ");
if (f->next) args_typeinfo = CORD_all(args_typeinfo, ", ");
}
args_type = CORD_all(args_type, "}");
args_typeinfo = CORD_all(args_typeinfo, "}}})");
CORD all_args = CORD_EMPTY;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next)
all_args = CORD_all(all_args, "_$", arg->name, arg->next ? ", " : CORD_EMPTY);
CORD wrapper = CORD_all(
is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, arg_signature, "{\n"
"static Table_t cache = {};\n",
args_type, " args = {", all_args, "};\n"
"const TypeInfo_t *table_type = Table$info(", args_typeinfo, ", ", compile_type_info(env, ret_t), ");\n",
compile_declaration(Type(PointerType, .pointed=ret_t), "cached"), " = Table$get_raw(cache, &args, table_type);\n"
"if (cached) return *cached;\n",
compile_declaration(ret_t, "ret"), " = ", name, "$uncached(", all_args, ");\n",
pop_code,
"Table$set(&cache, &args, &ret, table_type);\n"
"return ret;\n"
"}\n");
env->code->funcs = CORD_cat(env->code->funcs, wrapper);
}
}
CORD text = CORD_all("func ", Match(fndef->name, Var)->name, "(");
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
text = CORD_cat(text, type_to_cord(get_arg_ast_type(env, arg)));
if (arg->next) text = CORD_cat(text, ", ");
}
if (ret_t && ret_t->tag != VoidType)
text = CORD_all(text, ")->", type_to_cord(ret_t));
else
text = CORD_all(text, ")");
if (!fndef->is_inline) {
env->code->function_naming = CORD_all(
env->code->function_naming,
CORD_asprintf("register_function(%r, Text(%r \" [%s.tm:%ld]\"));\n",
name, CORD_quoted(text), file_base_name(ast->file->filename), get_line_number(ast->file, ast->start)));
}
return CORD_EMPTY;
}
case Skip: {
@ -1896,26 +1738,26 @@ static CORD _compile_statement(env_t *env, ast_t *ast)
auto use = Match(ast, Use);
if (use->what == USE_LOCAL) {
CORD name = file_base_id(Match(ast, Use)->path);
env->code->variable_initializers = CORD_all(env->code->variable_initializers,
with_source_info(ast, CORD_all("_$", name, "$$initialize();\n")));
} else if (use->what == USE_C_CODE) {
return CORD_all("#include \"", use->path, "\"\n");
return with_source_info(ast, CORD_all("_$", name, "$$initialize();\n"));
} else if (use->what == USE_MODULE) {
glob_t tm_files;
if (glob(heap_strf("~/.local/share/tomo/installed/%s/[!._0-9]*.tm", use->path), GLOB_TILDE, NULL, &tm_files) != 0)
code_err(ast, "Could not find library");
CORD initialization = CORD_EMPTY;
const char *lib_id = Text$as_c_string(
Text$replace(Text$from_str(use->path), Pattern("{1+ !alphanumeric}"), Text("_"), Pattern(""), false));
for (size_t i = 0; i < tm_files.gl_pathc; i++) {
const char *filename = tm_files.gl_pathv[i];
env->code->variable_initializers = CORD_all(
env->code->variable_initializers,
initialization = CORD_all(
initialization,
with_source_info(ast, CORD_all("_$", lib_id, "$", file_base_id(filename), "$$initialize();\n")));
}
globfree(&tm_files);
return initialization;
} else {
return CORD_EMPTY;
}
return CORD_EMPTY;
}
default:
if (!is_discardable(env, ast))
@ -3192,7 +3034,7 @@ CORD compile(env_t *env, ast_t *ast)
if ((ret_t->tag == VoidType || ret_t->tag == AbortType) && body_scope->deferred)
body = CORD_all(body, compile_statement(body_scope, FakeAST(Return)), "\n");
env->code->funcs = CORD_all(env->code->funcs, code, " {\n", body, "\n}\n");
env->code->lambdas = CORD_all(env->code->lambdas, code, " {\n", body, "\n}\n");
return CORD_all("((Closure_t){", name, ", ", userdata, "})");
}
case MethodCall: {
@ -4053,81 +3895,6 @@ CORD compile(env_t *env, ast_t *ast)
}
}
void compile_namespace(env_t *env, const char *ns_name, ast_t *block)
{
env_t *ns_env = namespace_env(env, ns_name);
CORD prefix = namespace_prefix(ns_env, ns_env->namespace);
// First prepare variable initializers to prevent unitialized access:
for (ast_list_t *stmt = block ? Match(block, Block)->statements : NULL; stmt; stmt = stmt->next) {
if (stmt->ast->tag == Declare) {
auto decl = Match(stmt->ast, Declare);
type_t *t = get_type(ns_env, decl->value);
if (t->tag == AbortType || t->tag == VoidType || t->tag == ReturnType)
code_err(stmt->ast, "You can't declare a variable with a %T value", t);
CORD name_code = CORD_all(prefix, Match(decl->var, Var)->name);
if (!is_constant(env, decl->value)) {
env->code->variable_initializers = CORD_all(
env->code->variable_initializers,
with_source_info(
stmt->ast,
CORD_all(name_code, " = ", compile_maybe_incref(ns_env, decl->value, t), ",\n",
name_code, "$initialized = true;\n")));
CORD checked_access = CORD_all("check_initialized(", name_code, ", \"", Match(decl->var, Var)->name, "\")");
set_binding(ns_env, Match(decl->var, Var)->name, t, checked_access);
}
}
}
for (ast_list_t *stmt = block ? Match(block, Block)->statements : NULL; stmt; stmt = stmt->next) {
ast_t *ast = stmt->ast;
switch (ast->tag) {
case FunctionDef: {
CORD code = compile_statement(ns_env, ast);
env->code->funcs = CORD_cat(env->code->funcs, code);
break;
}
case Declare: {
auto decl = Match(ast, Declare);
type_t *t = get_type(ns_env, decl->value);
if (t->tag == FunctionType)
t = Type(ClosureType, t);
bool is_private = (Match(decl->var, Var)->name[0] == '_');
CORD name_code = CORD_all(prefix, Match(decl->var, Var)->name);
if (!is_constant(env, decl->value)) {
if (t->tag == FunctionType)
t = Type(ClosureType, t);
env->code->staticdefs = CORD_all(
env->code->staticdefs,
"static bool ", name_code, "$initialized = false;\n",
is_private ? "static " : CORD_EMPTY,
compile_declaration(t, name_code), ";\n");
} else {
CORD val_code = compile_maybe_incref(ns_env, decl->value, t);
if (t->tag == FunctionType) {
assert(promote(env, decl->value, &val_code, t, Type(ClosureType, t)));
t = Type(ClosureType, t);
}
env->code->staticdefs = CORD_all(
env->code->staticdefs,
is_private ? "static " : CORD_EMPTY,
compile_declaration(t, name_code), " = ", val_code, ";\n");
}
break;
}
default: {
CORD code = compile_statement(ns_env, ast);
assert(!code);
break;
}
}
}
}
CORD compile_type_info(env_t *env, type_t *t)
{
if (t == THREAD_TYPE) return "&Thread$info";
@ -4310,24 +4077,260 @@ CORD compile_cli_arg_call(env_t *env, CORD fn_name, type_t *fn_type)
return code;
}
CORD compile_function(env_t *env, ast_t *ast, CORD *staticdefs)
{
auto fndef = Match(ast, FunctionDef);
bool is_private = Match(fndef->name, Var)->name[0] == '_';
CORD name = compile(env, fndef->name);
type_t *ret_t = fndef->ret_type ? parse_type_ast(env, fndef->ret_type) : Type(VoidType);
CORD arg_signature = "(";
Table_t used_names = {};
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
arg_signature = CORD_cat(arg_signature, compile_declaration(arg_type, CORD_cat("_$", arg->name)));
if (arg->next) arg_signature = CORD_cat(arg_signature, ", ");
if (Table$str_get(used_names, arg->name))
code_err(ast, "The argument name '%s' is used more than once", arg->name);
Table$str_set(&used_names, arg->name, arg->name);
}
arg_signature = CORD_cat(arg_signature, ")");
CORD ret_type_code = compile_type(ret_t);
if (is_private)
*staticdefs = CORD_all(*staticdefs, "static ", ret_type_code, " ", name, arg_signature, ";\n");
CORD code;
if (fndef->cache) {
code = CORD_all("static ", ret_type_code, " ", name, "$uncached", arg_signature);
} else {
code = CORD_all(ret_type_code, " ", name, arg_signature);
if (fndef->is_inline)
code = CORD_cat("INLINE ", code);
if (!is_private)
code = CORD_cat("public ", code);
}
env_t *body_scope = fresh_scope(env);
body_scope->deferred = NULL;
body_scope->namespace = NULL;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
type_t *arg_type = get_arg_ast_type(env, arg);
set_binding(body_scope, arg->name, arg_type, CORD_cat("_$", arg->name));
}
body_scope->fn_ret = ret_t;
type_t *body_type = get_type(body_scope, fndef->body);
if (ret_t->tag != VoidType && ret_t->tag != AbortType && body_type->tag != AbortType && body_type->tag != ReturnType)
code_err(ast, "This function can reach the end without returning a %T value!", ret_t);
CORD body = compile_statement(body_scope, fndef->body);
if (streq(Match(fndef->name, Var)->name, "main"))
body = CORD_all("_$", env->namespace->name, "$$initialize();\n", body);
if (CORD_fetch(body, 0) != '{')
body = CORD_asprintf("{\n%r\n}", body);
CORD definition = with_source_info(ast, CORD_all(code, " ", body, "\n"));
if (fndef->cache && fndef->args == NULL) { // no-args cache just uses a static var
CORD wrapper = CORD_all(
is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, "(void) {\n"
"static ", compile_declaration(ret_t, "cached_result"), ";\n",
"static bool initialized = false;\n",
"if (!initialized) {\n"
"\tcached_result = ", name, "$uncached();\n",
"\tinitialized = true;\n",
"}\n",
"return cached_result;\n"
"}\n");
definition = CORD_cat(definition, wrapper);
} else if (fndef->cache && fndef->cache->tag == Int) {
assert(fndef->args);
OptionalInt64_t cache_size = Int64$parse(Text$from_str(Match(fndef->cache, Int)->str));
CORD pop_code = CORD_EMPTY;
if (fndef->cache->tag == Int && !cache_size.is_none && cache_size.i > 0) {
pop_code = CORD_all("if (cache.entries.length > ", CORD_asprintf("%ld", cache_size.i),
") Table$remove(&cache, cache.entries.data + cache.entries.stride*RNG$int64(default_rng, 0, cache.entries.length-1), table_type);\n");
}
if (!fndef->args->next) {
// Single-argument functions have simplified caching logic
type_t *arg_type = get_arg_ast_type(env, fndef->args);
CORD wrapper = CORD_all(
is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, arg_signature, "{\n"
"static Table_t cache = {};\n",
"const TypeInfo_t *table_type = Table$info(", compile_type_info(env, arg_type), ", ", compile_type_info(env, ret_t), ");\n",
compile_declaration(Type(PointerType, .pointed=ret_t), "cached"), " = Table$get_raw(cache, &_$", fndef->args->name, ", table_type);\n"
"if (cached) return *cached;\n",
compile_declaration(ret_t, "ret"), " = ", name, "$uncached(_$", fndef->args->name, ");\n",
pop_code,
"Table$set(&cache, &_$", fndef->args->name, ", &ret, table_type);\n"
"return ret;\n"
"}\n");
definition = CORD_cat(definition, wrapper);
} else {
// Multi-argument functions use a custom struct type (only defined internally) as a cache key:
arg_t *fields = NULL;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next)
fields = new(arg_t, .name=arg->name, .type=get_arg_ast_type(env, arg), .next=fields);
REVERSE_LIST(fields);
type_t *t = Type(StructType, .name=heap_strf("%s$args", fndef->name), .fields=fields, .env=env);
int64_t num_fields = used_names.entries.length;
const char *short_name = Match(fndef->name, Var)->name;
const char *metamethods = is_packed_data(t) ? "PackedData$metamethods" : "Struct$metamethods";
CORD args_typeinfo = CORD_asprintf("((TypeInfo_t[1]){{.size=%zu, .align=%zu, .metamethods=%s, "
".tag=StructInfo, .StructInfo.name=\"%s\", "
".StructInfo.num_fields=%ld, .StructInfo.fields=(NamedType_t[%ld]){",
type_size(t), type_align(t), metamethods, short_name,
num_fields, num_fields);
CORD args_type = "struct { ";
for (arg_t *f = fields; f; f = f->next) {
args_typeinfo = CORD_all(args_typeinfo, "{\"", f->name, "\", ", compile_type_info(env, f->type), "}");
args_type = CORD_all(args_type, compile_declaration(f->type, f->name), "; ");
if (f->next) args_typeinfo = CORD_all(args_typeinfo, ", ");
}
args_type = CORD_all(args_type, "}");
args_typeinfo = CORD_all(args_typeinfo, "}}})");
CORD all_args = CORD_EMPTY;
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next)
all_args = CORD_all(all_args, "_$", arg->name, arg->next ? ", " : CORD_EMPTY);
CORD wrapper = CORD_all(
is_private ? CORD_EMPTY : "public ", ret_type_code, " ", name, arg_signature, "{\n"
"static Table_t cache = {};\n",
args_type, " args = {", all_args, "};\n"
"const TypeInfo_t *table_type = Table$info(", args_typeinfo, ", ", compile_type_info(env, ret_t), ");\n",
compile_declaration(Type(PointerType, .pointed=ret_t), "cached"), " = Table$get_raw(cache, &args, table_type);\n"
"if (cached) return *cached;\n",
compile_declaration(ret_t, "ret"), " = ", name, "$uncached(", all_args, ");\n",
pop_code,
"Table$set(&cache, &args, &ret, table_type);\n"
"return ret;\n"
"}\n");
definition = CORD_cat(definition, wrapper);
}
}
CORD text = CORD_all("func ", Match(fndef->name, Var)->name, "(");
for (arg_ast_t *arg = fndef->args; arg; arg = arg->next) {
text = CORD_cat(text, type_to_cord(get_arg_ast_type(env, arg)));
if (arg->next) text = CORD_cat(text, ", ");
}
if (ret_t && ret_t->tag != VoidType)
text = CORD_all(text, ")->", type_to_cord(ret_t));
else
text = CORD_all(text, ")");
if (!fndef->is_inline) {
env->code->function_naming = CORD_all(
env->code->function_naming,
CORD_asprintf("register_function(%r, Text(%r \" [%s.tm:%ld]\"));\n",
name, CORD_quoted(text), file_base_name(ast->file->filename), get_line_number(ast->file, ast->start)));
}
return definition;
}
CORD compile_top_level_code(env_t *env, ast_t *ast)
{
if (!ast) return CORD_EMPTY;
switch (ast->tag) {
case Declare: {
auto decl = Match(ast, Declare);
const char *decl_name = Match(decl->var, Var)->name;
CORD full_name = CORD_all(namespace_prefix(env, env->namespace), decl_name);
type_t *t = get_type(env, decl->value);
if (t->tag == AbortType || t->tag == VoidType || t->tag == ReturnType)
code_err(ast, "You can't declare a variable with a %T value", t);
CORD val_code = compile_maybe_incref(env, decl->value, t);
if (t->tag == FunctionType) {
assert(promote(env, decl->value, &val_code, t, Type(ClosureType, t)));
t = Type(ClosureType, t);
}
bool is_private = decl_name[0] == '_';
if (is_constant(env, decl->value)) {
set_binding(env, decl_name, t, full_name);
return CORD_all(
is_private ? "static " : CORD_EMPTY,
compile_declaration(t, full_name), " = ", val_code, ";\n");
} else {
CORD checked_access = CORD_all("check_initialized(", full_name, ", \"", decl_name, "\")");
set_binding(env, decl_name, t, checked_access);
return CORD_all(
"static bool ", full_name, "$initialized = false;\n",
is_private ? "static " : CORD_EMPTY,
compile_declaration(t, full_name), ";\n");
}
}
case FunctionDef: {
return compile_function(env, ast, &env->code->staticdefs);
}
case StructDef: {
auto def = Match(ast, StructDef);
CORD code = compile_struct_typeinfo(env, ast);
env_t *ns_env = namespace_env(env, def->name);
return CORD_all(code, def->namespace ? compile_top_level_code(ns_env, def->namespace) : CORD_EMPTY);
}
case EnumDef: {
auto def = Match(ast, EnumDef);
CORD code = compile_enum_typeinfo(env, ast);
code = CORD_all(code, compile_enum_constructors(env, ast));
env_t *ns_env = namespace_env(env, def->name);
return CORD_all(code, def->namespace ? compile_top_level_code(ns_env, def->namespace) : CORD_EMPTY);
}
case LangDef: {
auto def = Match(ast, LangDef);
CORD code = CORD_asprintf("public const TypeInfo_t %r%s = {%zu, %zu, .metamethods=Text$metamethods, .tag=TextInfo, .TextInfo={%r}};\n",
namespace_prefix(env, env->namespace), def->name, sizeof(Text_t), __alignof__(Text_t),
CORD_quoted(def->name));
env_t *ns_env = namespace_env(env, def->name);
return CORD_all(code, def->namespace ? compile_top_level_code(ns_env, def->namespace) : CORD_EMPTY);
}
case Block: {
CORD code = CORD_EMPTY;
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
code = CORD_all(code, compile_top_level_code(env, stmt->ast));
}
return code;
}
default: return CORD_EMPTY;
}
}
CORD compile_file(env_t *env, ast_t *ast)
{
CORD top_level_code = compile_top_level_code(env, ast);
CORD use_imports = CORD_EMPTY;
// First prepare variable initializers to prevent unitialized access:
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
if (stmt->ast->tag == Declare) {
if (stmt->ast->tag == InlineCCode) {
CORD code = compile_statement(env, stmt->ast);
env->code->staticdefs = CORD_all(env->code->staticdefs, code, "\n");
} else if (stmt->ast->tag == Use) {
use_imports = CORD_all(use_imports, compile_statement(env, stmt->ast));
} else if (stmt->ast->tag == Declare) {
auto decl = Match(stmt->ast, Declare);
const char *decl_name = Match(decl->var, Var)->name;
CORD full_name = CORD_all(namespace_prefix(env, env->namespace), decl_name);
type_t *t = get_type(env, decl->value);
if (t->tag == AbortType || t->tag == VoidType || t->tag == ReturnType)
code_err(stmt->ast, "You can't declare a variable with a %T value", t);
if (!is_constant(env, decl->value)) {
CORD val_code = compile_maybe_incref(env, decl->value, t);
if (t->tag == FunctionType) {
assert(promote(env, decl->value, &val_code, t, Type(ClosureType, t)));
t = Type(ClosureType, t);
}
CORD val_code = compile_maybe_incref(env, decl->value, t);
if (t->tag == FunctionType) {
assert(promote(env, decl->value, &val_code, t, Type(ClosureType, t)));
t = Type(ClosureType, t);
}
if (!is_constant(env, decl->value)) {
env->code->variable_initializers = CORD_all(
env->code->variable_initializers,
with_source_info(
@ -4335,51 +4338,10 @@ CORD compile_file(env_t *env, ast_t *ast)
CORD_all(
full_name, " = ", val_code, ",\n",
full_name, "$initialized = true;\n")));
CORD checked_access = CORD_all("check_initialized(", full_name, ", \"", decl_name, "\")");
set_binding(env, decl_name, t, checked_access);
}
}
}
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
if (stmt->ast->tag == Declare) {
auto decl = Match(stmt->ast, Declare);
const char *decl_name = Match(decl->var, Var)->name;
CORD full_name = CORD_all(namespace_prefix(env, env->namespace), decl_name);
bool is_private = (decl_name[0] == '_');
type_t *t = get_type(env, decl->value);
if (!is_constant(env, decl->value)) {
env->code->staticdefs = CORD_all(
env->code->staticdefs,
with_source_info(
stmt->ast,
CORD_all(
"static bool ", full_name, "$initialized = false;\n",
is_private ? "static " : CORD_EMPTY,
compile_declaration(t, full_name), ";\n")));
} else {
CORD val_code = compile_maybe_incref(env, decl->value, t);
if (t->tag == FunctionType) {
assert(promote(env, decl->value, &val_code, t, Type(ClosureType, t)));
t = Type(ClosureType, t);
}
env->code->staticdefs = CORD_all(
env->code->staticdefs,
with_source_info(
stmt->ast,
CORD_all(is_private ? "static " : CORD_EMPTY,
compile_declaration(t, full_name), " = ", val_code, ";\n")));
}
} else if (stmt->ast->tag == InlineCCode) {
CORD code = compile_statement(env, stmt->ast);
env->code->staticdefs = CORD_all(env->code->staticdefs, code, "\n");
} else if (stmt->ast->tag == Use) {
CORD code = compile_statement(env, stmt->ast);
if (code)
env->code->staticdefs = CORD_all(env->code->staticdefs, code);
} else {
CORD code = compile_statement(env, stmt->ast);
if (code) code_err(stmt->ast, "I did not expect this to generate code");
assert(!code);
}
}
@ -4391,13 +4353,14 @@ CORD compile_file(env_t *env, ast_t *ast)
"#include <tomo/tomo.h>\n"
"#include \"", name, ".tm.h\"\n\n",
env->code->local_typedefs, "\n",
env->code->typeinfos, "\n",
env->code->lambdas, "\n",
env->code->staticdefs, "\n",
env->code->funcs, "\n",
top_level_code,
"public void _$", env->namespace->name, "$$initialize(void) {\n",
"static bool initialized = false;\n",
"if (initialized) return;\n",
"initialized = true;\n",
use_imports,
env->code->variable_initializers,
env->code->function_naming,
"}\n");
@ -4419,6 +4382,8 @@ CORD compile_statement_type_header(env_t *env, ast_t *ast)
return CORD_all("#include ", use->path, "\n");
else
return CORD_all("#include \"", use->path, "\"\n");
case USE_C_CODE:
return CORD_all("#include \"", use->path, "\"\n");
default:
return CORD_EMPTY;
}

1
compile.h
View File

@ -14,7 +14,6 @@ CORD compile_file_header(env_t *env, ast_t *ast);
CORD compile_declaration(type_t *t, const char *name);
CORD compile_type(type_t *t);
CORD compile(env_t *env, ast_t *ast);
void compile_namespace(env_t *env, const char *ns_name, ast_t *block);
CORD compile_namespace_header(env_t *env, const char *ns_name, ast_t *block);
CORD compile_statement(env_t *env, ast_t *ast);
CORD compile_statement_type_header(env_t *env, ast_t *ast);

52
enums.c
View File

@ -13,32 +13,19 @@
#include "typecheck.h"
#include "stdlib/util.h"
void compile_enum_def(env_t *env, ast_t *ast)
CORD compile_enum_typeinfo(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
// Compile member types and constructors:
CORD member_typeinfos = CORD_EMPTY;
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
if (!tag->fields) continue;
const char *tag_name = heap_strf("%s$%s", def->name, tag->name);
compile_struct_def(env, WrapAST(ast, StructDef, .name=tag_name, .fields=tag->fields, .secret=tag->secret));
CORD arg_sig = CORD_EMPTY;
for (arg_ast_t *field = tag->fields; field; field = field->next) {
type_t *field_t = get_arg_ast_type(env, field);
arg_sig = CORD_all(arg_sig, compile_declaration(field_t, CORD_all("$", field->name)));
if (field->next) arg_sig = CORD_cat(arg_sig, ", ");
}
if (arg_sig == CORD_EMPTY) arg_sig = "void";
CORD constructor_impl = CORD_all("public inline ", full_name, "_t ", full_name, "$tagged$", tag->name, "(", arg_sig, ") { return (",
full_name, "_t){.tag=", full_name, "$tag$", tag->name, ", .$", tag->name, "={");
for (arg_ast_t *field = tag->fields; field; field = field->next) {
constructor_impl = CORD_all(constructor_impl, "$", field->name);
if (field->next) constructor_impl = CORD_cat(constructor_impl, ", ");
}
constructor_impl = CORD_cat(constructor_impl, "}}; }\n");
env->code->funcs = CORD_cat(env->code->funcs, constructor_impl);
member_typeinfos = CORD_all(
member_typeinfos, compile_struct_typeinfo(env, WrapAST(ast, StructDef, .name=tag_name, .fields=tag->fields, .secret=tag->secret)));
}
int num_tags = 0;
@ -60,8 +47,35 @@ void compile_enum_def(env_t *env, ast_t *ast)
typeinfo = CORD_all(typeinfo, "{\"", tag->name, "\"}, ");
}
typeinfo = CORD_all(typeinfo, "}}}};\n");
env->code->typeinfos = CORD_all(env->code->typeinfos, typeinfo);
compile_namespace(env, def->name, def->namespace);
return CORD_all(member_typeinfos, typeinfo);
}
CORD compile_enum_constructors(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
CORD constructors = CORD_EMPTY;
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
if (!tag->fields) continue;
CORD arg_sig = CORD_EMPTY;
for (arg_ast_t *field = tag->fields; field; field = field->next) {
type_t *field_t = get_arg_ast_type(env, field);
arg_sig = CORD_all(arg_sig, compile_declaration(field_t, CORD_all("$", field->name)));
if (field->next) arg_sig = CORD_cat(arg_sig, ", ");
}
if (arg_sig == CORD_EMPTY) arg_sig = "void";
CORD constructor_impl = CORD_all("public inline ", full_name, "_t ", full_name, "$tagged$", tag->name, "(", arg_sig, ") { return (",
full_name, "_t){.tag=", full_name, "$tag$", tag->name, ", .$", tag->name, "={");
for (arg_ast_t *field = tag->fields; field; field = field->next) {
constructor_impl = CORD_all(constructor_impl, "$", field->name);
if (field->next) constructor_impl = CORD_cat(constructor_impl, ", ");
}
constructor_impl = CORD_cat(constructor_impl, "}}; }\n");
constructors = CORD_cat(constructors, constructor_impl);
}
return constructors;
}
CORD compile_enum_header(env_t *env, ast_t *ast)

3
enums.h
View File

@ -7,7 +7,8 @@
#include "ast.h"
#include "environment.h"
void compile_enum_def(env_t *env, ast_t *ast);
CORD compile_enum_typeinfo(env_t *env, ast_t *ast);
CORD compile_enum_constructors(env_t *env, ast_t *ast);
CORD compile_enum_header(env_t *env, ast_t *ast);
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

3
environment.h
View File

@ -9,9 +9,8 @@
typedef struct {
CORD local_typedefs;
CORD typeinfos;
CORD staticdefs;
CORD funcs;
CORD lambdas;
CORD variable_initializers;
CORD function_naming;
} compilation_unit_t;

7
structs.c
View File

@ -12,7 +12,7 @@
#include "typecheck.h"
#include "stdlib/util.h"
void compile_struct_def(env_t *env, ast_t *ast)
CORD compile_struct_typeinfo(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
@ -41,10 +41,7 @@ void compile_struct_def(env_t *env, ast_t *ast)
}
typeinfo = CORD_all(typeinfo, "}");
}
typeinfo = CORD_all(typeinfo, "};\n");
env->code->typeinfos = CORD_all(env->code->typeinfos, typeinfo);
compile_namespace(env, def->name, def->namespace);
return CORD_all(typeinfo, "};\n");
}
CORD compile_struct_header(env_t *env, ast_t *ast)

2
structs.h
View File

@ -7,7 +7,7 @@
#include "ast.h"
#include "environment.h"
void compile_struct_def(env_t *env, ast_t *ast);
CORD compile_struct_typeinfo(env_t *env, ast_t *ast);
CORD compile_struct_header(env_t *env, ast_t *ast);
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

23
tomo.c
View File

@ -218,6 +218,27 @@ static void _compile_statement_header_for_library(libheader_info_t *info, ast_t
}
}
static void _make_typedefs_for_library(libheader_info_t *info, ast_t *ast)
{
if (ast->tag == StructDef) {
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(namespace_prefix(info->env, info->env->namespace), def->name);
CORD_put(CORD_all("typedef struct ", full_name, "_s ", full_name, "_t;\n"), info->output);
} else if (ast->tag == EnumDef) {
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(namespace_prefix(info->env, info->env->namespace), def->name);
CORD_put(CORD_all("typedef struct ", full_name, "_s ", full_name, "_t;\n"), info->output);
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
if (!tag->fields) continue;
CORD_put(CORD_all("typedef struct ", full_name, "$", tag->name, "_s ", full_name, "$", tag->name, "_t;\n"), info->output);
}
} else if (ast->tag == LangDef) {
auto def = Match(ast, LangDef);
CORD_put(CORD_all("typedef Text_t ", namespace_prefix(info->env, info->env->namespace), def->name, "_t;\n"), info->output);
}
}
static void _compile_file_header_for_library(env_t *env, Text_t filename, Table_t *visited_files, Table_t *used_imports, FILE *output)
{
if (Table$get(*visited_files, &filename, Table$info(&Text$info, &Text$info)))
@ -249,6 +270,8 @@ static void _compile_file_header_for_library(env_t *env, Text_t filename, Table_
}
}
visit_topologically(
Match(file_ast, Block)->statements, (Closure_t){.fn=(void*)_make_typedefs_for_library, &info});
visit_topologically(
Match(file_ast, Block)->statements, (Closure_t){.fn=(void*)_compile_statement_header_for_library, &info});