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

Fix issue with type namespaces not getting properly prefixed by library

Browse Source 
namespace
This commit is contained in:
Bruce Hill 2024-06-16 15:12:00 -04:00
parent 729d856139
commit 7a53e10826
7 changed files with 115 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
compile.c
View File

@ -20,7 +20,7 @@ static env_t *with_enum_scope(env_t *env, type_t *t);
CORD compile_type_ast(env_t *env, type_ast_t *t)
{
switch (t->tag) {
case VarTypeAST: return CORD_all(env->file_prefix, Match(t, VarTypeAST)->name, "_t");
case VarTypeAST: return CORD_all(namespace_prefix(env->namespace), Match(t, VarTypeAST)->name, "_t");
case PointerTypeAST: return CORD_cat(compile_type_ast(env, Match(t, PointerTypeAST)->pointed), "*");
case TableTypeAST: return "table_t";
case ArrayTypeAST: return "array_t";
@ -126,7 +126,7 @@ CORD compile_type(env_t *env, type_t *t)
case NumType: return Match(t, NumType)->bits == 64 ? "Num_t" : CORD_asprintf("Num%ld_t", Match(t, NumType)->bits);
case TextType: {
auto text = Match(t, TextType);
return text->lang ? CORD_all(text->env->file_prefix, text->lang, "_t") : "Text_t";
return text->lang ? CORD_all(namespace_prefix(text->env->namespace->parent), text->lang, "_t") : "Text_t";
}
case ArrayType: return "array_t";
case TableType: return "table_t";
@ -143,11 +143,11 @@ CORD compile_type(env_t *env, type_t *t)
case PointerType: return CORD_cat(compile_type(env, Match(t, PointerType)->pointed), "*");
case StructType: {
auto s = Match(t, StructType);
return CORD_all("struct ", s->env->file_prefix, s->name, "_s");
return CORD_all("struct ", namespace_prefix(s->env->namespace->parent), s->name, "_s");
}
case EnumType: {
auto e = Match(t, EnumType);
return CORD_all(e->env->file_prefix, e->name, "_t");
return CORD_all(namespace_prefix(e->env->namespace->parent), e->name, "_t");
}
case TypeInfoType: return "TypeInfo";
default: compiler_err(NULL, NULL, NULL, "Compiling type is not implemented for type with tag %d", t->tag);
@ -232,7 +232,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
"switch (subject.$tag) {");
for (when_clause_t *clause = when->clauses; clause; clause = clause->next) {
const char *clause_tag_name = Match(clause->tag_name, Var)->name;
code = CORD_all(code, "case ", enum_t->env->file_prefix, enum_t->name, "$tag$", clause_tag_name, ": {\n");
code = CORD_all(code, "case ", namespace_prefix(enum_t->env->namespace), enum_t->name, "$tag$", clause_tag_name, ": {\n");
type_t *tag_type = NULL;
for (tag_t *tag = enum_t->tags; tag; tag = tag->next) {
if (streq(tag->name, clause_tag_name)) {
@ -515,7 +515,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
case LangDef: {
auto def = Match(ast, LangDef);
CORD_appendf(&env->code->typeinfos, "public const TypeInfo %r%s = {%zu, %zu, {.tag=TextInfo, .TextInfo={%r}}};\n",
env->file_prefix, def->name, sizeof(CORD), __alignof__(CORD),
namespace_prefix(env->namespace), def->name, sizeof(CORD), __alignof__(CORD),
Text$quoted(def->name, false));
compile_namespace(env, def->name, def->namespace);
return CORD_EMPTY;
@ -551,7 +551,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
}
env_t *body_scope = fresh_scope(env);
body_scope->scope_prefix = CORD_EMPTY;
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, new(binding_t, .type=arg_type, .code=CORD_cat("$", arg->name)));
@ -1497,7 +1497,7 @@ CORD compile(env_t *env, ast_t *ast)
}
case Lambda: {
auto lambda = Match(ast, Lambda);
CORD name = CORD_asprintf("%slambda$%ld", env->file_prefix, lambda->id);
CORD name = CORD_asprintf("%rlambda$%ld", namespace_prefix(env->namespace), lambda->id);
env_t *body_scope = fresh_scope(env);
for (arg_ast_t *arg = lambda->args; arg; arg = arg->next) {
@ -1976,15 +1976,15 @@ CORD compile_type_info(env_t *env, type_t *t)
return CORD_asprintf("&$%r", type_to_cord(t));
case TextType: {
auto text = Match(t, TextType);
return text->lang ? CORD_all("(&", text->env->file_prefix, text->lang, ")") : "&$Text";
return text->lang ? CORD_all("(&", namespace_prefix(text->env->namespace->parent), text->lang, ")") : "&$Text";
}
case StructType: {
auto s = Match(t, StructType);
return CORD_all("(&", s->env->file_prefix, s->name, ")");
return CORD_all("(&", namespace_prefix(s->env->namespace->parent), s->name, ")");
}
case EnumType: {
auto e = Match(t, EnumType);
return CORD_all("(&", e->env->file_prefix, e->name, ")");
return CORD_all("(&", namespace_prefix(e->env->namespace->parent), e->name, ")");
}
case ArrayType: {
type_t *item_t = Match(t, ArrayType)->item_type;
@ -2201,12 +2201,12 @@ CORD compile_file(env_t *env, ast_t *ast)
} else if (is_private) {
env->code->staticdefs = CORD_all(
env->code->staticdefs,
"static ", compile_type(env, t), " $", decl_name, " = ",
"static ", compile_type(env, t), " ", namespace_prefix(env->namespace), decl_name, " = ",
compile(env, decl->value), ";\n");
} else {
env->code->staticdefs = CORD_all(
env->code->staticdefs,
compile_type(env, t), " ", env->file_prefix, decl_name, " = ",
compile_type(env, t), " ", namespace_prefix(env->namespace), decl_name, " = ",
compile(env, decl->value), ";\n");
}
} else if (stmt->ast->tag == InlineCCode) {
@ -2256,7 +2256,7 @@ CORD compile_statement_header(env_t *env, ast_t *ast)
return code;
} else {
return CORD_all(
code, "\n" "extern ", compile_declaration(env, t, CORD_cat(env->file_prefix, decl_name)), ";\n");
code, "\n" "extern ", compile_declaration(env, t, CORD_cat(namespace_prefix(env->namespace), decl_name)), ";\n");
}
}
case StructDef: {
@ -2268,8 +2268,8 @@ CORD compile_statement_header(env_t *env, ast_t *ast)
case LangDef: {
auto def = Match(ast, LangDef);
return CORD_all(
"typedef CORD ", env->file_prefix, def->name, "_t;\n",
"extern const TypeInfo ", env->file_prefix, def->name, ";\n");
"typedef CORD ", namespace_prefix(env->namespace), def->name, "_t;\n",
"extern const TypeInfo ", namespace_prefix(env->namespace), def->name, ";\n");
compile_namespace(env, def->name, def->namespace);
return CORD_EMPTY;
}
@ -2288,12 +2288,12 @@ CORD compile_statement_header(env_t *env, ast_t *ast)
type_t *ret_t = fndef->ret_type ? parse_type_ast(env, fndef->ret_type) : Type(VoidType);
CORD ret_type_code = compile_type(env, ret_t);
CORD header = CORD_all(ret_type_code, " ", CORD_cat(env->file_prefix, decl_name), arg_signature, ";\n");
CORD header = CORD_all(ret_type_code, " ", CORD_cat(namespace_prefix(env->namespace), decl_name), arg_signature, ";\n");
return header;
}
case Lambda: {
auto lambda = Match(ast, Lambda);
CORD name = CORD_asprintf("%slambda$%ld", env->file_prefix, lambda->id);
CORD name = CORD_asprintf("%rlambda$%ld", namespace_prefix(env->namespace), lambda->id);
table_t *closed_vars = get_closed_vars(env, ast);
if (Table$length(*closed_vars) == 0) {
return CORD_EMPTY;

12
enums.c
View File

@ -23,7 +23,7 @@ static bool has_extra_data(tag_ast_t *tags)
static CORD compile_str_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
CORD str_func = CORD_all("static CORD ", full_name, "$as_text(", full_name, "_t *obj, bool use_color) {\n"
"\tif (!obj) return \"", def->name, "\";\n"
"switch (obj->$tag) {\n");
@ -57,7 +57,7 @@ static CORD compile_str_method(env_t *env, ast_t *ast)
static CORD compile_compare_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
if (!has_extra_data(def->tags)) {
// Comparisons are simpler if there is only a tag, no tagged data:
return CORD_all("static int ", full_name, "$compare(const ", full_name, "_t *x, const ", full_name,
@ -88,7 +88,7 @@ static CORD compile_compare_method(env_t *env, ast_t *ast)
static CORD compile_equals_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
if (!has_extra_data(def->tags)) {
// Equality is simpler if there is only a tag, no tagged data:
return CORD_all("static bool ", full_name, "$equal(const ", full_name, "_t *x, const ", full_name,
@ -118,7 +118,7 @@ static CORD compile_equals_method(env_t *env, ast_t *ast)
static CORD compile_hash_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
if (!has_extra_data(def->tags)) {
// Hashing is simpler if there is only a tag, no tagged data:
return CORD_all("static uint32_t ", full_name, "$hash(const ", full_name, "_t *obj, const TypeInfo *info) {\n"
@ -152,7 +152,7 @@ static CORD compile_hash_method(env_t *env, ast_t *ast)
void compile_enum_def(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
compile_struct_def(env, WrapAST(ast, StructDef, .name=CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)), .fields=tag->fields));
if (tag->fields) { // Constructor macros:
@ -203,7 +203,7 @@ void compile_enum_def(env_t *env, ast_t *ast)
CORD compile_enum_header(env_t *env, ast_t *ast)
{
auto def = Match(ast, EnumDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
CORD header = CORD_all("typedef struct ", full_name, "_s ", full_name, "_t;\n",
"extern const TypeInfo ", full_name, ";\n");
CORD enum_def = CORD_all("struct ", full_name, "_s {\n"

36
environment.c
View File

@ -235,28 +235,32 @@ env_t *new_compilation_unit(void)
return env;
}
env_t *load_module_env(env_t *env, const char *prefix, ast_t *ast)
CORD namespace_prefix(namespace_t *ns)
{
CORD prefix = CORD_EMPTY;
for (; ns; ns = ns->parent)
prefix = CORD_all(ns->name, "$", prefix);
return prefix;
}
env_t *load_module_env(env_t *env, ast_t *ast)
{
const char *name = file_base_name(ast->file->filename);
env_t *cached = Table$str_get(*env->imports, name);
if (cached) return cached;
env = fresh_scope(env);
env->code = new(compilation_unit_t);
env->file_prefix = prefix;
Table$str_set(env->imports, name, env);
env_t *module_env = fresh_scope(env);
module_env->code = new(compilation_unit_t);
module_env->namespace = new(namespace_t, .name=name, .parent=env->namespace),
Table$str_set(module_env->imports, name, module_env);
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next)
prebind_statement(env, stmt->ast);
prebind_statement(module_env, stmt->ast);
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
// Hack: make sure global variables are bound as foo$var:
if (stmt->ast->tag == Declare && Match(Match(stmt->ast, Declare)->var, Var)->name[0] != '_')
env->scope_prefix = prefix;
bind_statement(env, stmt->ast);
env->scope_prefix = NULL;
}
Table$str_set(env->imports, name, env);
return env;
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next)
bind_statement(module_env, stmt->ast);
Table$str_set(env->imports, name, module_env);
return module_env;
}
env_t *global_scope(env_t *env)
@ -334,7 +338,7 @@ env_t *namespace_env(env_t *env, const char *namespace_name)
env_t *ns_env = new(env_t);
*ns_env = *env;
ns_env->locals = new(table_t, .fallback=env->locals);
ns_env->scope_prefix = CORD_all(namespace_name, "$");
ns_env->namespace = new(namespace_t, .name=namespace_name, .parent=env->namespace);
return ns_env;
}

10
environment.h
View File

@ -26,13 +26,18 @@ typedef struct loop_ctx_s {
CORD skip_label, stop_label;
} loop_ctx_t;
typedef struct namespace_s {
const char *name;
struct namespace_s *parent;
} namespace_t;
typedef struct env_s {
table_t *types, *globals, *locals;
table_t *imports; // Map of 'use' name -> env_t*
compilation_unit_t *code;
fn_ctx_t *fn_ctx;
loop_ctx_t *loop_ctx;
CORD file_prefix, scope_prefix;
namespace_t *namespace;
const char *comprehension_var;
} env_t;
@ -45,7 +50,8 @@ typedef struct {
} binding_t;
env_t *new_compilation_unit(void);
env_t *load_module_env(env_t *env, const char *prefix, ast_t *ast);
env_t *load_module_env(env_t *env, ast_t *ast);
CORD namespace_prefix(namespace_t *ns);
env_t *global_scope(env_t *env);
env_t *fresh_scope(env_t *env);
env_t *for_scope(env_t *env, ast_t *ast);

12
structs.c
View File

@ -14,7 +14,7 @@
static CORD compile_str_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
const char *name = def->name;
const char *dollar = strrchr(name, '$');
if (dollar) name = dollar + 1;
@ -39,7 +39,7 @@ static CORD compile_str_method(env_t *env, ast_t *ast)
static CORD compile_compare_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
CORD cmp_func = CORD_all("static int ", full_name, "$compare(const ", full_name, "_t *x, const ", full_name,
"_t *y, const TypeInfo *info) {\n"
"(void)info;\n",
@ -67,7 +67,7 @@ static CORD compile_compare_method(env_t *env, ast_t *ast)
static CORD compile_equals_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
CORD eq_func = CORD_all("static bool ", full_name, "$equal(const ", full_name, "_t *x, const ", full_name,
"_t *y, const TypeInfo *info) {\n"
"(void)info;\n");
@ -96,7 +96,7 @@ static CORD compile_equals_method(env_t *env, ast_t *ast)
static CORD compile_hash_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
CORD hash_func = CORD_all("static uint32_t ", full_name, "$hash(const ", full_name, "_t *obj, const TypeInfo *info) {\n"
"(void)info;\n"
"uint32_t field_hashes[] = {");
@ -114,7 +114,7 @@ static CORD compile_hash_method(env_t *env, ast_t *ast)
void compile_struct_def(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
type_t *t = Table$str_get(*env->types, def->name);
assert(t && t->tag == StructType);
@ -165,7 +165,7 @@ void compile_struct_def(env_t *env, ast_t *ast)
CORD compile_struct_header(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
CORD full_name = CORD_cat(env->file_prefix, def->name);
CORD full_name = CORD_cat(namespace_prefix(env->namespace), def->name);
CORD header = CORD_all("typedef struct ", full_name, "_s ", full_name, "_t;\n");
CORD struct_code = CORD_all("struct ", full_name, "_s {\n");

35
tomo.c
View File

@ -188,6 +188,34 @@ int main(int argc, char *argv[])
*p = '_';
}
// Each type's namespace now exists within the library's namespace, on top of whatever
// other namespace it was already in:
namespace_t *lib_ns = new(namespace_t, .name=libname_id);
for (int64_t i = 1; i <= Table$length(*env->types); i++) {
struct {const char *name; type_t *type; } *entry = Table$entry(*env->types, i);
env_t *type_env = NULL;
switch (entry->type->tag) {
case TextType: type_env = Match(entry->type, TextType)->env; break;
case StructType: type_env = Match(entry->type, StructType)->env; break;
case EnumType: type_env = Match(entry->type, EnumType)->env; break;
case TypeInfoType: type_env = Match(entry->type, TypeInfoType)->env; break;
default: break;
}
if (type_env) {
// Find the topmost namespace, and if it's not already `lib_ns`, then
// set it to that:
for (namespace_t **ns = &type_env->namespace; ; ns = &((*ns)->parent)) {
if (*ns == lib_ns) {
break;
} else if (*ns == NULL) {
*ns = lib_ns;
break;
}
}
}
}
// Build a "libwhatever.h" header that loads all the headers:
const char *h_filename = heap_strf("lib%s.h", libname);
FILE *header_prog = CORD_RUN(autofmt ? autofmt : "cat", " 2>/dev/null >", h_filename);
@ -198,8 +226,7 @@ int main(int argc, char *argv[])
if (!f) errx(1, "No such file: %s", filename);
ast_t *ast = parse_file(f, NULL);
if (!ast) errx(1, "Could not parse %s", f);
env->file_prefix = heap_strf("%s$%s$", libname_id, file_base_name(filename));
env->namespace = new(namespace_t, .name=file_base_name(filename), .parent=lib_ns);
for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
if (stmt->ast->tag == Import || (stmt->ast->tag == Declare && Match(stmt->ast, Declare)->value->tag == Import))
continue;
@ -352,7 +379,7 @@ int transpile_header(env_t *base_env, const char *filename, bool force_retranspi
if (!ast)
errx(1, "Could not parse %s", f);
env_t *module_env = load_module_env(base_env, heap_strf("%s$", file_base_name(filename)), ast);
env_t *module_env = load_module_env(base_env, ast);
CORD h_code = compile_header(module_env, ast);
@ -396,7 +423,7 @@ int transpile_code(env_t *base_env, const char *filename, bool force_retranspile
if (!ast)
errx(1, "Could not parse %s", f);
env_t *module_env = load_module_env(base_env, heap_strf("%s$", file_base_name(filename)), ast);
env_t *module_env = load_module_env(base_env, ast);
CORD c_code = compile_file(module_env, ast);

44
typecheck.c
View File

@ -121,7 +121,7 @@ static env_t *load_module(env_t *env, ast_t *module_ast)
ast_t *ast = parse_file(f, NULL);
if (!ast) errx(1, "Could not compile!");
return load_module_env(env, heap_strf("%s$", name), ast);
return load_module_env(env, ast);
} else if (module_ast->tag == Use) {
const char *libname = Match(module_ast, Use)->name;
const char *files_filename = heap_strf("%s/lib%s.files", libname, libname);
@ -131,7 +131,13 @@ static env_t *load_module(env_t *env, ast_t *module_ast)
file_t *files_f = load_file(resolved_path);
if (!files_f) errx(1, "Couldn't open file: %s", resolved_path);
env_t *ret_env = fresh_scope(env);
env_t *module_env = fresh_scope(env);
char *libname_id = heap_str(libname);
for (char *c = libname_id; *c; c++) {
if (!isalnum(*c) && *c != '_')
*c = '_';
}
module_env->namespace = new(namespace_t, .name=libname_id);
for (int64_t i = 1; i <= files_f->num_lines; i++) {
const char *line = get_line(files_f, i);
line = heap_strn(line, strcspn(line, "\r\n"));
@ -144,23 +150,23 @@ static env_t *load_module(env_t *env, ast_t *module_ast)
ast_t *ast = parse_file(tm_f, NULL);
if (!ast) errx(1, "Could not compile!");
env_t *tmp_env = fresh_scope(env);
char *prefix = heap_strf("%s$%s$", libname, file_base_name(line));
for (char *p = prefix; *p; p++) {
env_t *module_file_env = fresh_scope(env);
char *file_prefix = heap_str(file_base_name(line));
for (char *p = file_prefix; *p; p++) {
if (!isalnum(*p) && *p != '_' && *p != '$')
*p = '_';
}
tmp_env->file_prefix = prefix;
tmp_env->imports = new(table_t);
env_t *subenv = load_module_env(tmp_env, prefix, ast);
module_file_env->namespace = new(namespace_t, .name=file_prefix, .parent=module_env->namespace);
module_file_env->imports = new(table_t);
env_t *subenv = load_module_env(module_file_env, ast);
for (int64_t j = 0; j < subenv->locals->entries.length; j++) {
struct {
const char *name; binding_t *binding;
} *entry = subenv->locals->entries.data + j*subenv->locals->entries.stride;
set_binding(ret_env, entry->name, entry->binding);
set_binding(module_env, entry->name, entry->binding);
}
}
return ret_env;
return module_env;
} else {
code_err(module_ast, "This is not a module import");
}
@ -181,7 +187,8 @@ void prebind_statement(env_t *env, ast_t *statement)
env_t *ns_env = namespace_env(env, def->name);
type_t *type = Type(StructType, .name=def->name, .opaque=true, .env=ns_env); // placeholder
Table$str_set(env->types, def->name, type);
set_binding(env, def->name, new(binding_t, .type=Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env), .code=CORD_all(env->file_prefix, def->name)));
set_binding(env, def->name, new(binding_t, .type=Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env),
.code=CORD_all(namespace_prefix(env->namespace), def->name)));
for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next)
prebind_statement(ns_env, stmt->ast);
break;
@ -194,7 +201,7 @@ void prebind_statement(env_t *env, ast_t *statement)
env_t *ns_env = namespace_env(env, def->name);
type_t *type = Type(EnumType, .name=def->name, .opaque=true, .env=ns_env); // placeholder
Table$str_set(env->types, def->name, type);
set_binding(env, def->name, new(binding_t, .type=Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env), .code=CORD_all(env->file_prefix, def->name)));
set_binding(env, def->name, new(binding_t, .type=Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env), .code=CORD_all(namespace_prefix(env->namespace), def->name)));
for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next)
prebind_statement(ns_env, stmt->ast);
break;
@ -207,7 +214,7 @@ void prebind_statement(env_t *env, ast_t *statement)
env_t *ns_env = namespace_env(env, def->name);
type_t *type = Type(TextType, .lang=def->name, .env=ns_env);
Table$str_set(env->types, def->name, type);
set_binding(env, def->name, new(binding_t, .type=Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env), .code=CORD_all(env->file_prefix, def->name)));
set_binding(env, def->name, new(binding_t, .type=Type(TypeInfoType, .name=def->name, .type=type, .env=ns_env), .code=CORD_all(namespace_prefix(env->namespace), def->name)));
for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next)
prebind_statement(ns_env, stmt->ast);
break;
@ -233,7 +240,8 @@ void bind_statement(env_t *env, ast_t *statement)
else
bind_statement(env, decl->value);
type_t *type = get_type(env, decl->value);
CORD code = CORD_cat(env->scope_prefix ? env->scope_prefix : "$", name);
CORD prefix = namespace_prefix(env->namespace);
CORD code = CORD_cat(prefix ? prefix : "$", name);
set_binding(env, name, new(binding_t, .type=type, .code=code));
break;
}
@ -244,7 +252,7 @@ void bind_statement(env_t *env, ast_t *statement)
code_err(def->name, "A %T called '%s' has already been defined", get_binding(env, name)->type, name);
type_t *type = get_function_def_type(env, statement);
bool is_private = (name[0] == '_');
CORD code = is_private ? CORD_cat("$", name) : CORD_all(env->file_prefix, env->scope_prefix, name);
CORD code = is_private ? CORD_cat("$", name) : CORD_all(namespace_prefix(env->namespace), name);
set_binding(env, name, new(binding_t, .type=type, .code=code));
break;
}
@ -310,9 +318,9 @@ void bind_statement(env_t *env, ast_t *statement)
for (tag_t *tag = tags; tag; tag = tag->next) {
if (Match(tag->type, StructType)->fields) { // Constructor:
type_t *constructor_t = Type(FunctionType, .args=Match(tag->type, StructType)->fields, .ret=type);
set_binding(ns_env, tag->name, new(binding_t, .type=constructor_t, .code=CORD_all(env->file_prefix, def->name, "$tagged$", tag->name)));
set_binding(ns_env, tag->name, new(binding_t, .type=constructor_t, .code=CORD_all(namespace_prefix(env->namespace), def->name, "$tagged$", tag->name)));
} else { // Empty singleton value:
CORD code = CORD_all("(", env->file_prefix, def->name, "_t){", env->file_prefix, def->name, "$tag$", tag->name, "}");
CORD code = CORD_all("(", namespace_prefix(env->namespace), def->name, "_t){", namespace_prefix(env->namespace), def->name, "$tag$", tag->name, "}");
set_binding(ns_env, tag->name, new(binding_t, .type=type, .code=code));
}
Table$str_set(env->types, heap_strf("%s$%s", def->name, tag->name), tag->type);
@ -331,7 +339,7 @@ void bind_statement(env_t *env, ast_t *statement)
set_binding(ns_env, "from_unsafe_text",
new(binding_t, .type=Type(FunctionType, .args=new(arg_t, .name="text", .type=TEXT_TYPE), .ret=type),
.code=CORD_all("(", env->file_prefix, def->name, "_t)")));
.code=CORD_all("(", namespace_prefix(env->namespace), def->name, "_t)")));
set_binding(ns_env, "text_content",
new(binding_t, .type=Type(FunctionType, .args=new(arg_t, .name="text", .type=TEXT_TYPE), .ret=type),
.code="(Text_t)"));