Preface symbols with file prefix

1 files changed, 31 insertions, 26 deletions

diff --git a/enums.c b/enums.c
index ff0c09fc..9917d2ca 100644
--- a/enums.c
+++ b/enums.c
@@ -15,11 +15,12 @@
 static CORD compile_str_method(env_t *env, ast_t *ast)
 {
     auto def = Match(ast, EnumDef);
-    CORD str_func = CORD_all("static CORD ", def->name, "$as_text(", def->name, "_t *obj, bool use_color) {\n"
+    CORD full_name = CORD_cat(env->file_prefix, 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");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
-        str_func = CORD_all(str_func, "\tcase $tag$", def->name, "$", tag->name, ": return CORD_all(use_color ? \"\\x1b[36;1m",
+        str_func = CORD_all(str_func, "\tcase $tag$", full_name, "$", tag->name, ": return CORD_all(use_color ? \"\\x1b[36;1m",
                      def->name, ".", tag->name, "\\x1b[m(\" : \"", def->name, ".", tag->name, "(\"");
 
         if (tag->secret) {
@@ -42,15 +43,16 @@ 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 cmp_func = CORD_all("static int ", def->name, "$compare(const ", def->name, "_t *x, const ", def->name,
+    CORD full_name = CORD_cat(env->file_prefix, 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"
                              "int diff = x->$tag - y->$tag;\n"
                              "if (diff) return diff;\n"
                              "switch (x->$tag) {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
-        type_t *tag_type = Table_str_get(*env->types, heap_strf("%s$%s", def->name, tag->name));
-        cmp_func = CORD_all(cmp_func, "\tcase $tag$", def->name, "$", tag->name, ": "
+        type_t *tag_type = Table_str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
+        cmp_func = CORD_all(cmp_func, "\tcase $tag$", full_name, "$", tag->name, ": "
                             "return generic_compare(&x->", tag->name, ", &y->", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
     }
     cmp_func = CORD_all(cmp_func, "default: return 0;\n}\n}\n");
@@ -60,14 +62,15 @@ 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 eq_func = CORD_all("static bool ", def->name, "$equal(const ", def->name, "_t *x, const ", def->name,
+    CORD full_name = CORD_cat(env->file_prefix, 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"
                              "if (x->$tag != y->$tag) return no;\n"
                              "switch (x->$tag) {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
-        type_t *tag_type = Table_str_get(*env->types, heap_strf("%s$%s", def->name, tag->name));
-        eq_func = CORD_all(eq_func, "\tcase $tag$", def->name, "$", tag->name, ": "
+        type_t *tag_type = Table_str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
+        eq_func = CORD_all(eq_func, "\tcase $tag$", full_name, "$", tag->name, ": "
                             "return generic_equal(&x->", tag->name, ", &y->", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
     }
     eq_func = CORD_all(eq_func, "default: return 0;\n}\n}\n");
@@ -77,13 +80,14 @@ 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 hash_func = CORD_all("static uint32_t ", def->name, "$hash(const ", def->name, "_t *obj, const TypeInfo *info) {\n"
+    CORD full_name = CORD_cat(env->file_prefix, 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 hashes[2] = {(uint32_t)obj->$tag};\n"
                               "switch (obj->$tag) {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
-        type_t *tag_type = Table_str_get(*env->types, heap_strf("%s$%s", def->name, tag->name));
-        hash_func = CORD_all(hash_func, "\tcase $tag$", def->name, "$", tag->name, ": "
+        type_t *tag_type = Table_str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
+        hash_func = CORD_all(hash_func, "\tcase $tag$", full_name, "$", tag->name, ": "
                              "hashes[1] = generic_hash(&obj->", tag->name, ", ", compile_type_info(env, tag_type), ");\n"
                              "break;\n");
     }
@@ -97,32 +101,33 @@ 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_appendf(&env->code->typedefs, "typedef struct %s_s %s_t;\n", def->name, def->name);
-    CORD_appendf(&env->code->typedefs, "extern const TypeInfo %s;\n", def->name);
-    CORD enum_def = CORD_all("struct ", def->name, "_s {\n"
+    CORD full_name = CORD_cat(env->file_prefix, def->name);
+    CORD_appendf(&env->code->typedefs, "typedef struct %r_s %r_t;\n", full_name, full_name);
+    CORD_appendf(&env->code->typedefs, "extern const TypeInfo %r;\n", full_name);
+    CORD enum_def = CORD_all("struct ", full_name, "_s {\n"
                              "\tenum {");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
-        CORD_appendf(&enum_def, "$tag$%s$%s = %ld", def->name, tag->name, tag->value);
+        CORD_appendf(&enum_def, "$tag$%r$%s = %ld", full_name, tag->name, tag->value);
         if (tag->next) enum_def = CORD_cat(enum_def, ", ");
     }
     enum_def = CORD_cat(enum_def, "} $tag;\n"
                         "union {\n");
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
-        compile_struct_def(env, WrapAST(ast, StructDef, .name=heap_strf("%s$%s", def->name, tag->name), .fields=tag->fields));
-        enum_def = CORD_all(enum_def, def->name, "$", tag->name, "_t ", tag->name, ";\n");
+        compile_struct_def(env, WrapAST(ast, StructDef, .name=CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)), .fields=tag->fields));
+        enum_def = CORD_all(enum_def, full_name, "$", tag->name, "_t ", tag->name, ";\n");
         // Constructor:
         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, field->name));
+            arg_sig = CORD_all(arg_sig, compile_declaration(env, field_t, field->name));
             if (field->next) arg_sig = CORD_cat(arg_sig, ", ");
         }
         if (arg_sig == CORD_EMPTY) arg_sig = "void";
-        CORD constructor_def = CORD_all(def->name, "_t ", def->name, "$tagged$", tag->name, "(", arg_sig, ");\n");
+        CORD constructor_def = CORD_all(full_name, "_t ", full_name, "$tagged$", tag->name, "(", arg_sig, ");\n");
         env->code->fndefs = CORD_cat(env->code->fndefs, constructor_def);
 
-        CORD constructor_impl = CORD_all("public inline ", def->name, "_t ", def->name, "$tagged$", tag->name, "(", arg_sig, ") { return (",
-                                         def->name, "_t){.$tag=$tag$", def->name, "$", tag->name, ", .", tag->name, "={");
+        CORD constructor_impl = CORD_all("public inline ", full_name, "_t ", full_name, "$tagged$", tag->name, "(", arg_sig, ") { return (",
+                                         full_name, "_t){.$tag=$tag$", full_name, "$", 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, ", ");
@@ -135,7 +140,7 @@ void compile_enum_def(env_t *env, ast_t *ast)
 
     type_t *t = Table_str_get(*env->types, def->name);
     CORD typeinfo = CORD_asprintf("public const TypeInfo %s = {%zu, %zu, {.tag=CustomInfo, .CustomInfo={",
-                                  def->name, type_size(t), type_align(t));
+                                  full_name, type_size(t), type_align(t));
 
     env->code->funcs = CORD_all(
         env->code->funcs,
@@ -144,10 +149,10 @@ void compile_enum_def(env_t *env, ast_t *ast)
         compile_hash_method(env, ast));
     typeinfo = CORD_all(
         typeinfo,
-        ".as_text=(void*)", def->name, "$as_text, "
-        ".equal=(void*)", def->name, "$equal, "
-        ".hash=(void*)", def->name, "$hash, "
-        ".compare=(void*)", def->name, "$compare");
+        ".as_text=(void*)", full_name, "$as_text, "
+        ".equal=(void*)", full_name, "$equal, "
+        ".hash=(void*)", full_name, "$hash, "
+        ".compare=(void*)", full_name, "$compare");
     typeinfo = CORD_cat(typeinfo, "}}};\n");
     env->code->typeinfos = CORD_all(env->code->typeinfos, typeinfo);