aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--compile.c84
-rw-r--r--enums.c14
-rw-r--r--environment.c12
-rw-r--r--environment.h6
-rw-r--r--stdlib/optionals.c2
-rw-r--r--stdlib/ranges.c2
-rw-r--r--stdlib/ranges.h2
-rw-r--r--stdlib/threads.c17
-rw-r--r--stdlib/threads.h14
-rw-r--r--structs.c14
-rw-r--r--tomo.c9
-rw-r--r--typecheck.c19
12 files changed, 108 insertions, 87 deletions
diff --git a/compile.c b/compile.c
index ccc6412a..17fe2011 100644
--- a/compile.c
+++ b/compile.c
@@ -200,6 +200,9 @@ CORD compile_declaration(type_t *t, CORD name)
CORD compile_type(type_t *t)
{
+ if (t == THREAD_TYPE) return "Thread_t";
+ else if (t == RANGE_TYPE) return "Range_t";
+
switch (t->tag) {
case ReturnType: errx(1, "Shouldn't be compiling ReturnType to a type");
case AbortType: return "void";
@@ -213,7 +216,16 @@ CORD compile_type(type_t *t)
case NumType: return Match(t, NumType)->bits == TYPE_NBITS64 ? "Num_t" : CORD_asprintf("Num%ld_t", Match(t, NumType)->bits);
case TextType: {
auto text = Match(t, TextType);
- return text->lang ? CORD_all(namespace_prefix(text->env->libname, text->env->namespace->parent), text->lang, "_t") : "Text_t";
+ if (!text->lang || streq(text->lang, "Text"))
+ return "Text_t";
+ else if (streq(text->lang, "Pattern"))
+ return "Pattern_t";
+ else if (streq(text->lang, "Path"))
+ return "Path_t";
+ else if (streq(text->lang, "Shell"))
+ return "Shell_t";
+ else
+ return CORD_all(namespace_prefix(text->env, text->env->namespace->parent), text->lang, "_t");
}
case ArrayType: return "Array_t";
case SetType: return "Table_t";
@@ -231,14 +243,12 @@ CORD compile_type(type_t *t)
case ClosureType: return "Closure_t";
case PointerType: return CORD_cat(compile_type(Match(t, PointerType)->pointed), "*");
case StructType: {
- if (t == THREAD_TYPE)
- return "pthread_t*";
auto s = Match(t, StructType);
- return CORD_all("struct ", namespace_prefix(s->env->libname, s->env->namespace->parent), s->name, "_s");
+ return CORD_all("struct ", namespace_prefix(s->env, s->env->namespace->parent), s->name, "_s");
}
case EnumType: {
auto e = Match(t, EnumType);
- return CORD_all(namespace_prefix(e->env->libname, e->env->namespace->parent), e->name, "_t");
+ return CORD_all(namespace_prefix(e->env, e->env->namespace->parent), e->name, "_t");
}
case OptionalType: {
type_t *nonnull = Match(t, OptionalType)->type;
@@ -253,9 +263,9 @@ CORD compile_type(type_t *t)
return CORD_all("Optional", compile_type(nonnull));
case StructType: {
if (nonnull == THREAD_TYPE)
- return "pthread_t*";
+ return "Thread_t";
auto s = Match(nonnull, StructType);
- return CORD_all(namespace_prefix(s->env->libname, s->env->namespace->parent), "$Optional", s->name, "_t");
+ return CORD_all(namespace_prefix(s->env, s->env->namespace->parent), "$Optional", s->name, "_t");
}
default:
compiler_err(NULL, NULL, NULL, "Optional types are not supported for: %T", t);
@@ -395,7 +405,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 ", namespace_prefix(enum_t->env->libname, enum_t->env->namespace), "tag$", clause_tag_name, ": {\n");
+ code = CORD_all(code, "case ", namespace_prefix(enum_t->env, enum_t->env->namespace), "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)) {
@@ -739,7 +749,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",
- namespace_prefix(env->libname, env->namespace), def->name, sizeof(Text_t), __alignof__(Text_t),
+ 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;
@@ -796,7 +806,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
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);
+ 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, code, " ", body, "\n");
@@ -1370,7 +1380,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
auto use = Match(ast, Use);
if (use->what == USE_LOCAL) {
CORD name = file_base_name(Match(ast, Use)->path);
- env->code->variable_initializers = CORD_all(env->code->variable_initializers, name, "$$initialize();\n");
+ env->code->variable_initializers = CORD_all(env->code->variable_initializers, "$", name, "$$initialize();\n");
} else if (use->what == USE_C_CODE) {
return CORD_all("#include \"", use->path, "\"\n");
} else if (use->what == USE_MODULE) {
@@ -1383,7 +1393,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
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, lib_id, "$", file_base_name(filename), "$$initialize();\n");
+ env->code->variable_initializers, "$", lib_id, "$", file_base_name(filename), "$$initialize();\n");
}
globfree(&tm_files);
}
@@ -1783,7 +1793,7 @@ CORD compile_null(type_t *t)
case StructType: return CORD_all("((", compile_type(Type(OptionalType, .type=t)), "){.is_null=true})");
case EnumType: {
env_t *enum_env = Match(t, EnumType)->env;
- return CORD_all("((", compile_type(t), "){", namespace_prefix(enum_env->libname, enum_env->namespace), "null})");
+ return CORD_all("((", compile_type(t), "){", namespace_prefix(enum_env, enum_env->namespace), "null})");
}
default: compiler_err(NULL, NULL, NULL, "Null isn't implemented for this type: %T", t);
}
@@ -2146,8 +2156,13 @@ CORD compile(env_t *env, ast_t *ast)
if (!text_t || text_t->tag != TextType)
code_err(ast, "%s is not a valid text language name", lang);
- CORD lang_constructor = !lang ? "Text"
- : CORD_all(namespace_prefix(Match(text_t, TextType)->env->libname, Match(text_t, TextType)->env->namespace->parent), lang);
+ CORD lang_constructor;
+ if (!lang || streq(lang, "Text"))
+ lang_constructor = "Text";
+ else if (streq(lang, "Pattern") || streq(lang, "Path") || streq(lang, "Shell"))
+ lang_constructor = lang;
+ else
+ lang_constructor = CORD_all(namespace_prefix(Match(text_t, TextType)->env, Match(text_t, TextType)->env->namespace->parent), lang);
ast_list_t *chunks = Match(ast, TextJoin)->children;
if (!chunks) {
@@ -2441,7 +2456,7 @@ CORD compile(env_t *env, ast_t *ast)
}
case Lambda: {
auto lambda = Match(ast, Lambda);
- CORD name = CORD_asprintf("%rlambda$%ld", namespace_prefix(env->libname, env->namespace), lambda->id);
+ CORD name = CORD_asprintf("%rlambda$%ld", namespace_prefix(env, env->namespace), lambda->id);
env->code->function_naming = CORD_all(
env->code->function_naming,
@@ -3158,7 +3173,7 @@ CORD compile(env_t *env, ast_t *ast)
auto e = Match(value_t, EnumType);
for (tag_t *tag = e->tags; tag; tag = tag->next) {
if (streq(f->field, tag->name)) {
- CORD prefix = namespace_prefix(e->env->libname, e->env->namespace);
+ CORD prefix = namespace_prefix(e->env, e->env->namespace);
if (fielded_t->tag == PointerType) {
CORD fielded = compile_to_pointer_depth(env, f->fielded, 1, false);
return CORD_all("((", fielded, ")->tag == ", prefix, "tag$", tag->name, ")");
@@ -3275,7 +3290,7 @@ 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->libname, ns_env->namespace);
+ 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) {
@@ -3357,6 +3372,9 @@ CORD compile_namespace_header(env_t *env, const char *ns_name, ast_t *block)
CORD compile_type_info(env_t *env, type_t *t)
{
+ if (t == THREAD_TYPE) return "&Thread$info";
+ else if (t == RANGE_TYPE) return "&Range$info";
+
switch (t->tag) {
case BoolType: case ByteType: case IntType: case BigIntType: case NumType: case CStringType:
return CORD_all("&", type_to_cord(t), "$info");
@@ -3370,15 +3388,15 @@ CORD compile_type_info(env_t *env, type_t *t)
return "&Shell$info";
else if (streq(text->lang, "Path"))
return "&Path$info";
- return CORD_all("(&", namespace_prefix(text->env->libname, text->env->namespace->parent), text->lang, ")");
+ return CORD_all("(&", namespace_prefix(text->env, text->env->namespace->parent), text->lang, ")");
}
case StructType: {
auto s = Match(t, StructType);
- return CORD_all("(&", namespace_prefix(s->env->libname, s->env->namespace->parent), s->name, ")");
+ return CORD_all("(&", namespace_prefix(s->env, s->env->namespace->parent), s->name, ")");
}
case EnumType: {
auto e = Match(t, EnumType);
- return CORD_all("(&", namespace_prefix(e->env->libname, e->env->namespace->parent), e->name, ")");
+ return CORD_all("(&", namespace_prefix(e->env, e->env->namespace->parent), e->name, ")");
}
case ArrayType: {
type_t *item_t = Match(t, ArrayType)->item_type;
@@ -3706,7 +3724,7 @@ CORD compile_file(env_t *env, ast_t *ast)
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->libname, env->namespace), decl_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);
@@ -3732,7 +3750,7 @@ CORD compile_file(env_t *env, ast_t *ast)
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->libname, env->namespace), decl_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 (decl->value->tag == Use) {
@@ -3777,7 +3795,7 @@ CORD compile_file(env_t *env, ast_t *ast)
env->code->staticdefs, "\n",
env->code->funcs, "\n",
env->code->typeinfos, "\n",
- "public void ", env->namespace->name, "$$initialize(void) {\n",
+ "public void $", env->namespace->name, "$$initialize(void) {\n",
"static bool initialized = false;\n",
"if (initialized) return;\n",
"initialized = true;\n",
@@ -3808,7 +3826,7 @@ CORD compile_statement_header(env_t *env, ast_t *ast)
return CORD_all(
compile_statement_header(env, decl->value),
- "extern ", compile_declaration(t, CORD_cat(namespace_prefix(env->libname, env->namespace), decl_name)), ";\n");
+ "extern ", compile_declaration(t, CORD_cat(namespace_prefix(env, env->namespace), decl_name)), ";\n");
}
case Use: {
auto use = Match(ast, Use);
@@ -3835,14 +3853,14 @@ CORD compile_statement_header(env_t *env, ast_t *ast)
}
case LangDef: {
auto def = Match(ast, LangDef);
- CORD full_name = CORD_cat(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
return CORD_all(
- "typedef Text_t ", namespace_prefix(env->libname, env->namespace), def->name, "_t;\n"
+ "typedef Text_t ", namespace_prefix(env, env->namespace), def->name, "_t;\n"
// Constructor macro:
- "#define ", namespace_prefix(env->libname, env->namespace), def->name,
- "(text) ((", namespace_prefix(env->libname, env->namespace), def->name, "_t){.length=sizeof(text)-1, .tag=TEXT_ASCII, .ascii=\"\" text})\n"
- "#define ", namespace_prefix(env->libname, env->namespace), def->name,
- "s(...) ((", namespace_prefix(env->libname, env->namespace), def->name, "_t)Texts(__VA_ARGS__))\n"
+ "#define ", namespace_prefix(env, env->namespace), def->name,
+ "(text) ((", namespace_prefix(env, env->namespace), def->name, "_t){.length=sizeof(text)-1, .tag=TEXT_ASCII, .ascii=\"\" text})\n"
+ "#define ", namespace_prefix(env, env->namespace), def->name,
+ "s(...) ((", namespace_prefix(env, env->namespace), def->name, "_t)Texts(__VA_ARGS__))\n"
"extern const TypeInfo ", full_name, ";\n",
compile_namespace_header(env, def->name, def->namespace)
);
@@ -3862,7 +3880,7 @@ 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(ret_t);
- return CORD_all(ret_type_code, " ", namespace_prefix(env->libname, env->namespace), decl_name, arg_signature, ";\n");
+ return CORD_all(ret_type_code, " ", namespace_prefix(env, env->namespace), decl_name, arg_signature, ";\n");
}
case Extern: {
auto ext = Match(ast, Extern);
@@ -3907,7 +3925,7 @@ CORD compile_file_header(env_t *env, ast_t *ast)
compile_typedef_info_t info = {.env=env, .header=&header};
visit_topologically(Match(ast, Block)->statements, (Closure_t){.fn=(void*)_visit_statement, &info});
- header = CORD_all(header, "void ", env->namespace->name, "$$initialize(void);\n");
+ header = CORD_all(header, "void $", env->namespace->name, "$$initialize(void);\n");
return header;
}
diff --git a/enums.c b/enums.c
index ab993786..558065fd 100644
--- a/enums.c
+++ b/enums.c
@@ -24,7 +24,7 @@ PUREFUNC 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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
CORD str_func = CORD_all("static Text_t ", full_name, "$as_text(", full_name, "_t *obj, bool use_color) {\n"
"\tif (!obj) return Text(\"", def->name, "\");\n"
"switch (obj->tag) {\n");
@@ -64,7 +64,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, 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,
@@ -95,7 +95,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, 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,
@@ -125,7 +125,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, 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 uint64_t ", full_name, "$hash(const ", full_name, "_t *obj, const TypeInfo *info) {\n"
@@ -155,7 +155,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, 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:
@@ -206,7 +206,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_all(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_all(namespace_prefix(env, env->namespace), def->name);
CORD all_defs = CORD_all("typedef struct ", full_name, "_s ", full_name, "_t;\n");
CORD enum_def = CORD_all("struct ", full_name, "_s {\n"
"\tenum { ", full_name, "$null=0, ");
@@ -228,7 +228,7 @@ CORD compile_enum_header(env_t *env, ast_t *ast)
all_defs = CORD_all(all_defs, "extern const TypeInfo ", full_name, ";\n");
for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
all_defs = CORD_all(all_defs,
- "extern const TypeInfo ", namespace_prefix(env->libname, env->namespace), def->name, "$", tag->name, ";\n");
+ "extern const TypeInfo ", namespace_prefix(env, env->namespace), def->name, "$", tag->name, ";\n");
if (tag->fields) { // Constructor macros:
CORD arg_sig = CORD_EMPTY;
for (arg_ast_t *field = tag->fields; field; field = field->next) {
diff --git a/environment.c b/environment.c
index 0232781d..050fac29 100644
--- a/environment.c
+++ b/environment.c
@@ -15,7 +15,7 @@ type_t *TEXT_TYPE = NULL;
type_t *RANGE_TYPE = NULL;
public type_t *THREAD_TYPE = NULL;
-env_t *new_compilation_unit(CORD *libname)
+env_t *new_compilation_unit(CORD libname)
{
env_t *env = new(env_t);
env->code = new(compilation_unit_t);
@@ -338,7 +338,7 @@ env_t *new_compilation_unit(CORD *libname)
{"utf32_codepoints", "Text$utf32_codepoints", "func(text:Text)->[Int32]"},
{"utf8_bytes", "Text$utf8_bytes", "func(text:Text)->[Byte]"},
)},
- {"Thread", THREAD_TYPE, "pthread_t*", "Thread", TypedArray(ns_entry_t,
+ {"Thread", THREAD_TYPE, "Thread_t", "Thread", TypedArray(ns_entry_t,
{"new", "Thread$new", "func(fn:func())->Thread"},
{"cancel", "Thread$cancel", "func(thread:Thread)"},
{"join", "Thread$join", "func(thread:Thread)"},
@@ -402,13 +402,15 @@ env_t *new_compilation_unit(CORD *libname)
return lib_env;
}
-CORD namespace_prefix(CORD *libname, namespace_t *ns)
+CORD namespace_prefix(env_t *env, namespace_t *ns)
{
CORD prefix = CORD_EMPTY;
for (; ns; ns = ns->parent)
prefix = CORD_all(ns->name, "$", prefix);
- if (libname && *libname)
- prefix = CORD_all(*libname, "$", prefix);
+ if (env->libname)
+ prefix = CORD_all("$", env->libname, "$", prefix);
+ else
+ prefix = CORD_all("$", prefix);
return prefix;
}
diff --git a/environment.h b/environment.h
index e5f17536..2fc07711 100644
--- a/environment.h
+++ b/environment.h
@@ -52,7 +52,7 @@ typedef struct env_s {
fn_ctx_t *fn_ctx;
loop_ctx_t *loop_ctx;
deferral_t *deferred;
- CORD *libname; // Pointer to currently compiling library name (if any)
+ CORD libname; // Currently compiling library name (if any)
namespace_t *namespace;
Closure_t *comprehension_action;
} env_t;
@@ -65,9 +65,9 @@ typedef struct {
};
} binding_t;
-env_t *new_compilation_unit(CORD *libname);
+env_t *new_compilation_unit(CORD libname);
env_t *load_module_env(env_t *env, ast_t *ast);
-CORD namespace_prefix(CORD *libname, namespace_t *ns);
+CORD namespace_prefix(env_t *env, namespace_t *ns);
env_t *namespace_scope(env_t *env);
env_t *fresh_scope(env_t *env);
env_t *for_scope(env_t *env, ast_t *ast);
diff --git a/stdlib/optionals.c b/stdlib/optionals.c
index e21be507..1dc770a7 100644
--- a/stdlib/optionals.c
+++ b/stdlib/optionals.c
@@ -36,7 +36,7 @@ public PUREFUNC bool is_null(const void *obj, const TypeInfo *non_optional_type)
return ((OptionalInt8_t*)obj)->is_null;
else if (non_optional_type == &Byte$info)
return ((OptionalByte_t*)obj)->is_null;
- else if (non_optional_type == &Thread)
+ else if (non_optional_type == &Thread$info)
return *(pthread_t**)obj == NULL;
switch (non_optional_type->tag) {
diff --git a/stdlib/ranges.c b/stdlib/ranges.c
index 9dfd1efe..6c81c15e 100644
--- a/stdlib/ranges.c
+++ b/stdlib/ranges.c
@@ -54,7 +54,7 @@ PUREFUNC public Range_t Range$by(Range_t r, Int_t step)
return (Range_t){r.first, r.last, Int$times(step, r.step)};
}
-public const TypeInfo Range = {sizeof(Range_t), __alignof(Range_t), {.tag=CustomInfo, .CustomInfo={
+public const TypeInfo Range$info = {sizeof(Range_t), __alignof(Range_t), {.tag=CustomInfo, .CustomInfo={
.as_text=(void*)Range$as_text,
.compare=(void*)Range$compare,
.equal=(void*)Range$equal,
diff --git a/stdlib/ranges.h b/stdlib/ranges.h
index 2a4f1d68..933b9aee 100644
--- a/stdlib/ranges.h
+++ b/stdlib/ranges.h
@@ -5,6 +5,6 @@
PUREFUNC Range_t Range$reversed(Range_t r);
PUREFUNC Range_t Range$by(Range_t r, Int_t step);
-extern const TypeInfo Range;
+extern const TypeInfo Range$info;
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1
diff --git a/stdlib/threads.c b/stdlib/threads.c
index 74e73832..59e98dd7 100644
--- a/stdlib/threads.c
+++ b/stdlib/threads.c
@@ -12,32 +12,33 @@
#include "arrays.h"
#include "text.h"
+#include "threads.h"
#include "types.h"
#include "util.h"
-public pthread_t *Thread$new(Closure_t fn)
+public Thread_t Thread$new(Closure_t fn)
{
- pthread_t *thread = new(pthread_t);
+ Thread_t thread = new(pthread_t);
pthread_create(thread, NULL, fn.fn, fn.userdata);
return thread;
}
-public void Thread$join(pthread_t *thread)
+public void Thread$join(Thread_t thread)
{
pthread_join(*thread, NULL);
}
-public void Thread$cancel(pthread_t *thread)
+public void Thread$cancel(Thread_t thread)
{
pthread_cancel(*thread);
}
-public void Thread$detach(pthread_t *thread)
+public void Thread$detach(Thread_t thread)
{
pthread_detach(*thread);
}
-Text_t Thread$as_text(const pthread_t **thread, bool colorize, const TypeInfo *type)
+Text_t Thread$as_text(const Thread_t *thread, bool colorize, const TypeInfo *type)
{
(void)type;
if (!thread) {
@@ -46,8 +47,8 @@ Text_t Thread$as_text(const pthread_t **thread, bool colorize, const TypeInfo *t
return Text$format(colorize ? "\x1b[34;1mThread(%p)\x1b[m" : "Thread(%p)", *thread);
}
-public const TypeInfo Thread = {
- .size=sizeof(pthread_t*), .align=__alignof(pthread_t*),
+public const TypeInfo Thread$info = {
+ .size=sizeof(Thread_t), .align=__alignof(Thread_t),
.tag=CustomInfo,
.CustomInfo={.as_text=(void*)Thread$as_text},
};
diff --git a/stdlib/threads.h b/stdlib/threads.h
index 52091677..f46840b3 100644
--- a/stdlib/threads.h
+++ b/stdlib/threads.h
@@ -9,12 +9,14 @@
#include "types.h"
#include "util.h"
-pthread_t *Thread$new(Closure_t fn);
-void Thread$cancel(pthread_t *thread);
-void Thread$join(pthread_t *thread);
-void Thread$detach(pthread_t *thread);
-Text_t Thread$as_text(const pthread_t **thread, bool colorize, const TypeInfo *type);
+#define Thread_t pthread_t*
-extern TypeInfo Thread;
+Thread_t Thread$new(Closure_t fn);
+void Thread$cancel(Thread_t thread);
+void Thread$join(Thread_t thread);
+void Thread$detach(Thread_t thread);
+Text_t Thread$as_text(const Thread_t *thread, bool colorize, const TypeInfo *type);
+
+extern const TypeInfo Thread$info;
// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0
diff --git a/structs.c b/structs.c
index 48fce6dd..1c294213 100644
--- a/structs.c
+++ b/structs.c
@@ -15,7 +15,7 @@
static CORD compile_str_method(env_t *env, ast_t *ast)
{
auto def = Match(ast, StructDef);
- CORD full_name = CORD_cat(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
const char *name = def->name;
const char *dollar = strrchr(name, '$');
if (dollar) name = dollar + 1;
@@ -45,7 +45,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, 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",
@@ -73,7 +73,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, 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");
@@ -102,7 +102,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
CORD hash_func = CORD_all("static uint64_t ", full_name, "$hash(const ", full_name, "_t *obj, const TypeInfo *info) {\n"
"(void)info;\n"
"uint64_t field_hashes[] = {");
@@ -121,7 +121,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
type_t *t = Table$str_get(*env->types, def->name);
assert(t && t->tag == StructType);
@@ -174,7 +174,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(namespace_prefix(env->libname, env->namespace), def->name);
+ CORD full_name = CORD_cat(namespace_prefix(env, env->namespace), def->name);
CORD fields = CORD_EMPTY;
for (arg_ast_t *field = def->fields; field; field = field->next) {
@@ -192,7 +192,7 @@ CORD compile_struct_header(env_t *env, ast_t *ast)
"typedef struct {\n",
full_name, "_t value;\n"
"Bool_t is_null:1;\n"
- "} ", namespace_prefix(env->libname, env->namespace), "$Optional", def->name, "_t;\n"
+ "} ", namespace_prefix(env, env->namespace), "$Optional", def->name, "_t;\n"
"extern const TypeInfo ", full_name, ";\n",
compile_namespace_header(env, def->name, def->namespace));
}
diff --git a/tomo.c b/tomo.c
index e39e14ac..4f26f663 100644
--- a/tomo.c
+++ b/tomo.c
@@ -232,7 +232,7 @@ static void _compile_file_header_for_library(env_t *env, const char *filename, T
visit_topologically(
Match(file_ast, Block)->statements, (Closure_t){.fn=(void*)_compile_statement_header_for_library, &info});
- CORD_fprintf(output, "void %r$initialize(void);\n", namespace_prefix(module_env->libname, module_env->namespace));
+ CORD_fprintf(output, "void %r$initialize(void);\n", namespace_prefix(module_env, module_env->namespace));
}
void build_library(const char *lib_dir_name)
@@ -247,8 +247,7 @@ void build_library(const char *lib_dir_name)
// Library name replaces all stretchs of non-alphanumeric chars with an underscore
// So e.g. https://github.com/foo/baz --> https_github_com_foo_baz
- const char *lib_id = escape_lib_name(lib_dir_name);
- env->libname = &lib_id;
+ env->libname = escape_lib_name(lib_dir_name);
// Build a "whatever.h" header that loads all the headers:
FILE *header_prog = CORD_RUN(autofmt ? autofmt : "cat", " 2>/dev/null >'", lib_dir_name, ".h'");
@@ -269,7 +268,7 @@ void build_library(const char *lib_dir_name)
FILE *prog;
for (size_t i = 0; i < tm_files.gl_pathc; i++) {
const char *filename = tm_files.gl_pathv[i];
- prog = CORD_RUN("nm -Ug -fjust-symbols ", filename, ".o | sed 's/.*/\\0 ", lib_id, "$\\0/' >>symbol_renames.txt");
+ prog = CORD_RUN("nm -Ug -fjust-symbols ", filename, ".o | sed 's/.*/\\0 $", env->libname, "\\0/' >>symbol_renames.txt");
int status = pclose(prog);
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
errx(WEXITSTATUS(status), "Failed to create symbol rename table with `nm` and `sed`");
@@ -523,7 +522,7 @@ void transpile_code(env_t *base_env, const char *filename, bool force_retranspil
CORD_put(CORD_all(
"int ", main_binding->code, "$parse_and_run(int argc, char *argv[]) {\n"
"tomo_init();\n",
- module_env->namespace->name, "$$initialize();\n"
+ "$", module_env->namespace->name, "$$initialize();\n"
"\n",
compile_cli_arg_call(module_env, main_binding->code, main_binding->type),
"return 0;\n"
diff --git a/typecheck.c b/typecheck.c
index afeac420..f993604b 100644
--- a/typecheck.c
+++ b/typecheck.c
@@ -161,8 +161,7 @@ static env_t *load_module(env_t *env, ast_t *module_ast)
Table$str_set(env->imports, use->path, module_env);
char *libname_id = Text$as_c_string(
Text$replace(Text$from_str(use->path), Pattern("{1+ !alphanumeric}"), Text("_"), Pattern(""), false));
- module_env->libname = new(CORD);
- *module_env->libname = (CORD)libname_id;
+ module_env->libname = libname_id;
for (size_t i = 0; i < tm_files.gl_pathc; i++) {
const char *filename = tm_files.gl_pathv[i];
ast_t *ast = parse_file(filename, NULL);
@@ -205,7 +204,7 @@ void prebind_statement(env_t *env, ast_t *statement)
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(namespace_prefix(env->libname, env->namespace), def->name)));
+ .code=CORD_all(namespace_prefix(env, 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;
@@ -219,7 +218,7 @@ void prebind_statement(env_t *env, ast_t *statement)
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(namespace_prefix(env->libname, env->namespace), def->name)));
+ .code=CORD_all(namespace_prefix(env, 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 +232,7 @@ void prebind_statement(env_t *env, ast_t *statement)
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(namespace_prefix(env->libname, env->namespace), def->name)));
+ .code=CORD_all(namespace_prefix(env, 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;
@@ -266,7 +265,7 @@ void bind_statement(env_t *env, ast_t *statement)
code_err(decl->value, "I couldn't figure out the type of this value");
if (type->tag == FunctionType)
type = Type(ClosureType, type);
- CORD prefix = namespace_prefix(env->libname, env->namespace);
+ CORD prefix = namespace_prefix(env, env->namespace);
CORD code = CORD_cat(prefix ? prefix : "$", name);
set_binding(env, name, new(binding_t, .type=type, .code=code));
break;
@@ -277,7 +276,7 @@ void bind_statement(env_t *env, ast_t *statement)
if (get_binding(env, name))
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);
- CORD code = CORD_all(namespace_prefix(env->libname, env->namespace), name);
+ CORD code = CORD_all(namespace_prefix(env, env->namespace), name);
set_binding(env, name, new(binding_t, .type=type, .code=code));
break;
}
@@ -346,9 +345,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(namespace_prefix(env->libname, env->namespace), def->name, "$tagged$", tag->name)));
+ set_binding(ns_env, tag->name, new(binding_t, .type=constructor_t, .code=CORD_all(namespace_prefix(env, env->namespace), def->name, "$tagged$", tag->name)));
} else { // Empty singleton value:
- CORD code = CORD_all("(", namespace_prefix(env->libname, env->namespace), def->name, "_t){", namespace_prefix(env->libname, env->namespace), def->name, "$tag$", tag->name, "}");
+ CORD code = CORD_all("(", namespace_prefix(env, env->namespace), def->name, "_t){", namespace_prefix(env, 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);
@@ -367,7 +366,7 @@ void bind_statement(env_t *env, ast_t *statement)
set_binding(ns_env, "without_escaping",
new(binding_t, .type=Type(FunctionType, .args=new(arg_t, .name="text", .type=TEXT_TYPE), .ret=type),
- .code=CORD_all("(", namespace_prefix(env->libname, env->namespace), def->name, "_t)")));
+ .code=CORD_all("(", namespace_prefix(env, env->namespace), def->name, "_t)")));
for (ast_list_t *stmt = def->namespace ? Match(def->namespace, Block)->statements : NULL; stmt; stmt = stmt->next)
bind_statement(ns_env, stmt->ast);
generated by cgit v1.2.3 (git 2.25.1) at 2026-03-01 11:36:34 +0000