From 634d1ad756fca46e1e8aec93a265998232dd58a6 Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Sun, 24 Aug 2025 15:10:41 -0400 Subject: Move structs/enums into the right folder --- src/compile.c | 4 +- src/compile/enums.c | 143 ++++++++++++++++++++++++++++++++++++++++++++++++++ src/compile/enums.h | 13 +++++ src/compile/structs.c | 80 ++++++++++++++++++++++++++++ src/compile/structs.h | 12 +++++ src/enums.c | 143 -------------------------------------------------- src/enums.h | 13 ----- src/structs.c | 80 ---------------------------- src/structs.h | 12 ----- 9 files changed, 250 insertions(+), 250 deletions(-) create mode 100644 src/compile/enums.c create mode 100644 src/compile/enums.h create mode 100644 src/compile/structs.c create mode 100644 src/compile/structs.h delete mode 100644 src/enums.c delete mode 100644 src/enums.h delete mode 100644 src/structs.c delete mode 100644 src/structs.h (limited to 'src') diff --git a/src/compile.c b/src/compile.c index b5e22342..a81b74d5 100644 --- a/src/compile.c +++ b/src/compile.c @@ -8,9 +8,10 @@ #include "ast.h" #include "compile.h" +#include "compile/enums.h" #include "compile/list.h" +#include "compile/structs.h" #include "config.h" -#include "enums.h" #include "environment.h" #include "modules.h" #include "naming.h" @@ -20,7 +21,6 @@ #include "stdlib/tables.h" #include "stdlib/text.h" #include "stdlib/util.h" -#include "structs.h" #include "typecheck.h" typedef ast_t *(*comprehension_body_t)(ast_t *, ast_t *); diff --git a/src/compile/enums.c b/src/compile/enums.c new file mode 100644 index 00000000..3abe0307 --- /dev/null +++ b/src/compile/enums.c @@ -0,0 +1,143 @@ +// Logic for compiling tagged unions (enums) +#include +#include + +#include "../ast.h" +#include "../compile.h" +#include "../environment.h" +#include "../naming.h" +#include "../stdlib/tables.h" +#include "../stdlib/text.h" +#include "../typecheck.h" +#include "structs.h" + +Text_t compile_enum_typeinfo(env_t *env, ast_t *ast) { + DeclareMatch(def, ast, EnumDef); + + // Compile member types and constructors: + Text_t member_typeinfos = EMPTY_TEXT; + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + if (!tag->fields) continue; + + const char *tag_name = String(def->name, "$", tag->name); + type_t *tag_type = Table$str_get(*env->types, tag_name); + assert(tag_type && tag_type->tag == StructType); + member_typeinfos = + Texts(member_typeinfos, compile_struct_typeinfo(env, tag_type, tag_name, tag->fields, tag->secret, false)); + } + + int num_tags = 0; + for (tag_ast_t *t = def->tags; t; t = t->next) + num_tags += 1; + + type_t *t = Table$str_get(*env->types, def->name); + const char *metamethods = is_packed_data(t) ? "PackedDataEnum$metamethods" : "Enum$metamethods"; + Text_t info = namespace_name(env, env->namespace, Texts(def->name, "$$info")); + Text_t typeinfo = Texts("public const TypeInfo_t ", info, " = {", String((int64_t)type_size(t)), "u, ", + String((int64_t)type_align(t)), "u, .metamethods=", metamethods, + ", {.tag=EnumInfo, .EnumInfo={.name=\"", def->name, + "\", " + ".num_tags=", + String((int64_t)num_tags), ", .tags=(NamedType_t[]){"); + + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + const char *tag_type_name = String(def->name, "$", tag->name); + type_t *tag_type = Table$str_get(*env->types, tag_type_name); + if (tag_type && Match(tag_type, StructType)->fields) + typeinfo = Texts(typeinfo, "{\"", tag->name, "\", ", compile_type_info(tag_type), "}, "); + else typeinfo = Texts(typeinfo, "{\"", tag->name, "\"}, "); + } + typeinfo = Texts(typeinfo, "}}}};\n"); + return Texts(member_typeinfos, typeinfo); +} + +Text_t compile_enum_constructors(env_t *env, ast_t *ast) { + DeclareMatch(def, ast, EnumDef); + Text_t constructors = EMPTY_TEXT; + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + if (!tag->fields) continue; + + Text_t arg_sig = EMPTY_TEXT; + for (arg_ast_t *field = tag->fields; field; field = field->next) { + type_t *field_t = get_arg_ast_type(env, field); + arg_sig = Texts(arg_sig, compile_declaration(field_t, Texts("$", field->name))); + if (field->next) arg_sig = Texts(arg_sig, ", "); + } + if (arg_sig.length == 0) arg_sig = Text("void"); + Text_t type_name = namespace_name(env, env->namespace, Texts(def->name, "$$type")); + Text_t tagged_name = namespace_name(env, env->namespace, Texts(def->name, "$tagged$", tag->name)); + Text_t tag_name = namespace_name(env, env->namespace, Texts(def->name, "$tag$", tag->name)); + Text_t constructor_impl = Texts("public inline ", type_name, " ", tagged_name, "(", arg_sig, ") { return (", + type_name, "){.$tag=", tag_name, ", .", valid_c_name(tag->name), "={"); + for (arg_ast_t *field = tag->fields; field; field = field->next) { + constructor_impl = Texts(constructor_impl, "$", field->name); + if (field->next) constructor_impl = Texts(constructor_impl, ", "); + } + constructor_impl = Texts(constructor_impl, "}}; }\n"); + constructors = Texts(constructors, constructor_impl); + } + return constructors; +} + +Text_t compile_enum_header(env_t *env, ast_t *ast) { + DeclareMatch(def, ast, EnumDef); + Text_t all_defs = EMPTY_TEXT; + Text_t none_name = namespace_name(env, env->namespace, Texts(def->name, "$none")); + Text_t enum_name = namespace_name(env, env->namespace, Texts(def->name, "$$enum")); + Text_t enum_tags = Texts("{ ", none_name, "=0, "); + + bool has_any_tags_with_fields = false; + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + Text_t tag_name = namespace_name(env, env->namespace, Texts(def->name, "$tag$", tag->name)); + enum_tags = Texts(enum_tags, tag_name); + if (tag->next) enum_tags = Texts(enum_tags, ", "); + has_any_tags_with_fields = has_any_tags_with_fields || (tag->fields != NULL); + } + enum_tags = Texts(enum_tags, " }"); + + if (!has_any_tags_with_fields) { + Text_t enum_def = Texts("enum ", enum_name, " ", enum_tags, ";\n"); + Text_t info = namespace_name(env, env->namespace, Texts(def->name, "$$info")); + return Texts(enum_def, "extern const TypeInfo_t ", info, ";\n"); + } + + Text_t struct_name = namespace_name(env, env->namespace, Texts(def->name, "$$struct")); + Text_t enum_def = Texts("struct ", struct_name, + " {\n" + "enum ", + enum_tags, + " $tag;\n" + "union {\n"); + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + if (!tag->fields) continue; + Text_t field_def = compile_struct_header( + env, + WrapAST(ast, StructDef, .name = Text$as_c_string(Texts(def->name, "$", tag->name)), .fields = tag->fields)); + all_defs = Texts(all_defs, field_def); + Text_t tag_type = namespace_name(env, env->namespace, Texts(def->name, "$", tag->name, "$$type")); + enum_def = Texts(enum_def, tag_type, " ", valid_c_name(tag->name), ";\n"); + } + enum_def = Texts(enum_def, "};\n};\n"); + all_defs = Texts(all_defs, enum_def); + + Text_t info = namespace_name(env, env->namespace, Texts(def->name, "$$info")); + all_defs = Texts(all_defs, "extern const TypeInfo_t ", info, ";\n"); + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + if (!tag->fields) continue; + + Text_t arg_sig = EMPTY_TEXT; + for (arg_ast_t *field = tag->fields; field; field = field->next) { + type_t *field_t = get_arg_ast_type(env, field); + arg_sig = Texts(arg_sig, compile_declaration(field_t, Texts("$", field->name))); + if (field->next) arg_sig = Texts(arg_sig, ", "); + } + if (arg_sig.length == 0) arg_sig = Text("void"); + Text_t enum_type = namespace_name(env, env->namespace, Texts(def->name, "$$type")); + Text_t tagged_name = namespace_name(env, env->namespace, Texts(def->name, "$tagged$", tag->name)); + Text_t constructor_def = Texts(enum_type, " ", tagged_name, "(", arg_sig, ");\n"); + all_defs = Texts(all_defs, constructor_def); + } + return all_defs; +} + +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/compile/enums.h b/src/compile/enums.h new file mode 100644 index 00000000..6a42bece --- /dev/null +++ b/src/compile/enums.h @@ -0,0 +1,13 @@ +#pragma once + +// Compilation of tagged unions (enums) + +#include "../ast.h" +#include "../environment.h" +#include "../stdlib/datatypes.h" + +Text_t compile_enum_typeinfo(env_t *env, ast_t *ast); +Text_t compile_enum_constructors(env_t *env, ast_t *ast); +Text_t compile_enum_header(env_t *env, ast_t *ast); + +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/compile/structs.c b/src/compile/structs.c new file mode 100644 index 00000000..d4bb346c --- /dev/null +++ b/src/compile/structs.c @@ -0,0 +1,80 @@ +// Logic for compiling new struct types defined in code +#include + +#include "../ast.h" +#include "../compile.h" +#include "../environment.h" +#include "../naming.h" +#include "../stdlib/tables.h" +#include "../stdlib/text.h" +#include "../typecheck.h" + +Text_t compile_struct_typeinfo(env_t *env, type_t *t, const char *name, arg_ast_t *fields, bool is_secret, + bool is_opaque) { + Text_t typeinfo_name = namespace_name(env, env->namespace, Texts(name, "$$info")); + Text_t type_code = Match(t, StructType)->external + ? Text$from_str(name) + : Texts("struct ", namespace_name(env, env->namespace, Texts(name, "$$struct"))); + + int num_fields = 0; + for (arg_ast_t *f = fields; f; f = f->next) + num_fields += 1; + const char *short_name = name; + if (strchr(short_name, '$')) short_name = strrchr(short_name, '$') + 1; + + const char *metamethods = is_packed_data(t) ? "PackedData$metamethods" : "Struct$metamethods"; + Text_t typeinfo = Texts( + "public const TypeInfo_t ", typeinfo_name, " = {.size=sizeof(", type_code, "), .align=__alignof__(", type_code, + "), " + ".metamethods=", + metamethods, + ", " + ".tag=StructInfo, .StructInfo.name=\"", + short_name, "\"", is_secret ? Text(", .StructInfo.is_secret=true") : EMPTY_TEXT, + is_opaque ? Text(", .StructInfo.is_opaque=true") : EMPTY_TEXT, ", .StructInfo.num_fields=", String(num_fields)); + if (fields) { + typeinfo = Texts(typeinfo, ", .StructInfo.fields=(NamedType_t[", String(num_fields), "]){"); + for (arg_ast_t *f = fields; f; f = f->next) { + type_t *field_type = get_arg_ast_type(env, f); + typeinfo = Texts(typeinfo, "{\"", f->name, "\", ", compile_type_info(field_type), "}"); + if (f->next) typeinfo = Texts(typeinfo, ", "); + } + typeinfo = Texts(typeinfo, "}"); + } + return Texts(typeinfo, "};\n"); +} + +Text_t compile_struct_header(env_t *env, ast_t *ast) { + DeclareMatch(def, ast, StructDef); + Text_t typeinfo_name = namespace_name(env, env->namespace, Texts(def->name, "$$info")); + Text_t type_code = def->external + ? Text$from_str(def->name) + : Texts("struct ", namespace_name(env, env->namespace, Texts(def->name, "$$struct"))); + + Text_t fields = EMPTY_TEXT; + for (arg_ast_t *field = def->fields; field; field = field->next) { + type_t *field_t = get_arg_ast_type(env, field); + type_t *check_for_opaque = non_optional(field_t); + if (check_for_opaque->tag == StructType && Match(check_for_opaque, StructType)->opaque) { + if (field->type) + code_err(field->type, "This is an opaque type, so it can't be used as a struct field type"); + else if (field->value) + code_err(field->value, "This is an opaque type, so it can't be used as a struct field type"); + } + fields = Texts(fields, compile_declaration(field_t, valid_c_name(field->name)), + field_t->tag == BoolType ? Text(":1") : EMPTY_TEXT, ";\n"); + } + Text_t struct_code = def->external ? EMPTY_TEXT : Texts(type_code, " {\n", fields, "};\n"); + type_t *t = Table$str_get(*env->types, def->name); + + Text_t unpadded_size = + def->opaque ? Texts("sizeof(", type_code, ")") : Text$from_str(String((int64_t)unpadded_struct_size(t))); + Text_t typeinfo_code = Texts("extern const TypeInfo_t ", typeinfo_name, ";\n"); + Text_t optional_code = EMPTY_TEXT; + if (!def->opaque) { + optional_code = Texts("DEFINE_OPTIONAL_TYPE(", compile_type(t), ", ", unpadded_size, ", ", + namespace_name(env, env->namespace, Texts("$Optional", def->name, "$$type")), ");\n"); + } + return Texts(struct_code, optional_code, typeinfo_code); +} +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/compile/structs.h b/src/compile/structs.h new file mode 100644 index 00000000..f24ed15a --- /dev/null +++ b/src/compile/structs.h @@ -0,0 +1,12 @@ +#pragma once + +// Compilation of user-defined structs + +#include "../ast.h" +#include "../environment.h" + +Text_t compile_struct_typeinfo(env_t *env, type_t *t, const char *name, arg_ast_t *fields, bool is_secret, + bool is_opaque); +Text_t compile_struct_header(env_t *env, ast_t *ast); + +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/enums.c b/src/enums.c deleted file mode 100644 index 078600e0..00000000 --- a/src/enums.c +++ /dev/null @@ -1,143 +0,0 @@ -// Logic for compiling tagged unions (enums) -#include -#include - -#include "ast.h" -#include "compile.h" -#include "environment.h" -#include "naming.h" -#include "stdlib/tables.h" -#include "stdlib/text.h" -#include "structs.h" -#include "typecheck.h" - -Text_t compile_enum_typeinfo(env_t *env, ast_t *ast) { - DeclareMatch(def, ast, EnumDef); - - // Compile member types and constructors: - Text_t member_typeinfos = EMPTY_TEXT; - for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { - if (!tag->fields) continue; - - const char *tag_name = String(def->name, "$", tag->name); - type_t *tag_type = Table$str_get(*env->types, tag_name); - assert(tag_type && tag_type->tag == StructType); - member_typeinfos = - Texts(member_typeinfos, compile_struct_typeinfo(env, tag_type, tag_name, tag->fields, tag->secret, false)); - } - - int num_tags = 0; - for (tag_ast_t *t = def->tags; t; t = t->next) - num_tags += 1; - - type_t *t = Table$str_get(*env->types, def->name); - const char *metamethods = is_packed_data(t) ? "PackedDataEnum$metamethods" : "Enum$metamethods"; - Text_t info = namespace_name(env, env->namespace, Texts(def->name, "$$info")); - Text_t typeinfo = Texts("public const TypeInfo_t ", info, " = {", String((int64_t)type_size(t)), "u, ", - String((int64_t)type_align(t)), "u, .metamethods=", metamethods, - ", {.tag=EnumInfo, .EnumInfo={.name=\"", def->name, - "\", " - ".num_tags=", - String((int64_t)num_tags), ", .tags=(NamedType_t[]){"); - - for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { - const char *tag_type_name = String(def->name, "$", tag->name); - type_t *tag_type = Table$str_get(*env->types, tag_type_name); - if (tag_type && Match(tag_type, StructType)->fields) - typeinfo = Texts(typeinfo, "{\"", tag->name, "\", ", compile_type_info(tag_type), "}, "); - else typeinfo = Texts(typeinfo, "{\"", tag->name, "\"}, "); - } - typeinfo = Texts(typeinfo, "}}}};\n"); - return Texts(member_typeinfos, typeinfo); -} - -Text_t compile_enum_constructors(env_t *env, ast_t *ast) { - DeclareMatch(def, ast, EnumDef); - Text_t constructors = EMPTY_TEXT; - for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { - if (!tag->fields) continue; - - Text_t arg_sig = EMPTY_TEXT; - for (arg_ast_t *field = tag->fields; field; field = field->next) { - type_t *field_t = get_arg_ast_type(env, field); - arg_sig = Texts(arg_sig, compile_declaration(field_t, Texts("$", field->name))); - if (field->next) arg_sig = Texts(arg_sig, ", "); - } - if (arg_sig.length == 0) arg_sig = Text("void"); - Text_t type_name = namespace_name(env, env->namespace, Texts(def->name, "$$type")); - Text_t tagged_name = namespace_name(env, env->namespace, Texts(def->name, "$tagged$", tag->name)); - Text_t tag_name = namespace_name(env, env->namespace, Texts(def->name, "$tag$", tag->name)); - Text_t constructor_impl = Texts("public inline ", type_name, " ", tagged_name, "(", arg_sig, ") { return (", - type_name, "){.$tag=", tag_name, ", .", valid_c_name(tag->name), "={"); - for (arg_ast_t *field = tag->fields; field; field = field->next) { - constructor_impl = Texts(constructor_impl, "$", field->name); - if (field->next) constructor_impl = Texts(constructor_impl, ", "); - } - constructor_impl = Texts(constructor_impl, "}}; }\n"); - constructors = Texts(constructors, constructor_impl); - } - return constructors; -} - -Text_t compile_enum_header(env_t *env, ast_t *ast) { - DeclareMatch(def, ast, EnumDef); - Text_t all_defs = EMPTY_TEXT; - Text_t none_name = namespace_name(env, env->namespace, Texts(def->name, "$none")); - Text_t enum_name = namespace_name(env, env->namespace, Texts(def->name, "$$enum")); - Text_t enum_tags = Texts("{ ", none_name, "=0, "); - - bool has_any_tags_with_fields = false; - for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { - Text_t tag_name = namespace_name(env, env->namespace, Texts(def->name, "$tag$", tag->name)); - enum_tags = Texts(enum_tags, tag_name); - if (tag->next) enum_tags = Texts(enum_tags, ", "); - has_any_tags_with_fields = has_any_tags_with_fields || (tag->fields != NULL); - } - enum_tags = Texts(enum_tags, " }"); - - if (!has_any_tags_with_fields) { - Text_t enum_def = Texts("enum ", enum_name, " ", enum_tags, ";\n"); - Text_t info = namespace_name(env, env->namespace, Texts(def->name, "$$info")); - return Texts(enum_def, "extern const TypeInfo_t ", info, ";\n"); - } - - Text_t struct_name = namespace_name(env, env->namespace, Texts(def->name, "$$struct")); - Text_t enum_def = Texts("struct ", struct_name, - " {\n" - "enum ", - enum_tags, - " $tag;\n" - "union {\n"); - for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { - if (!tag->fields) continue; - Text_t field_def = compile_struct_header( - env, - WrapAST(ast, StructDef, .name = Text$as_c_string(Texts(def->name, "$", tag->name)), .fields = tag->fields)); - all_defs = Texts(all_defs, field_def); - Text_t tag_type = namespace_name(env, env->namespace, Texts(def->name, "$", tag->name, "$$type")); - enum_def = Texts(enum_def, tag_type, " ", valid_c_name(tag->name), ";\n"); - } - enum_def = Texts(enum_def, "};\n};\n"); - all_defs = Texts(all_defs, enum_def); - - Text_t info = namespace_name(env, env->namespace, Texts(def->name, "$$info")); - all_defs = Texts(all_defs, "extern const TypeInfo_t ", info, ";\n"); - for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { - if (!tag->fields) continue; - - Text_t arg_sig = EMPTY_TEXT; - for (arg_ast_t *field = tag->fields; field; field = field->next) { - type_t *field_t = get_arg_ast_type(env, field); - arg_sig = Texts(arg_sig, compile_declaration(field_t, Texts("$", field->name))); - if (field->next) arg_sig = Texts(arg_sig, ", "); - } - if (arg_sig.length == 0) arg_sig = Text("void"); - Text_t enum_type = namespace_name(env, env->namespace, Texts(def->name, "$$type")); - Text_t tagged_name = namespace_name(env, env->namespace, Texts(def->name, "$tagged$", tag->name)); - Text_t constructor_def = Texts(enum_type, " ", tagged_name, "(", arg_sig, ");\n"); - all_defs = Texts(all_defs, constructor_def); - } - return all_defs; -} - -// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/enums.h b/src/enums.h deleted file mode 100644 index 6f394a60..00000000 --- a/src/enums.h +++ /dev/null @@ -1,13 +0,0 @@ -#pragma once - -// Compilation of tagged unions (enums) - -#include "ast.h" -#include "environment.h" -#include "stdlib/datatypes.h" - -Text_t compile_enum_typeinfo(env_t *env, ast_t *ast); -Text_t compile_enum_constructors(env_t *env, ast_t *ast); -Text_t compile_enum_header(env_t *env, ast_t *ast); - -// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/structs.c b/src/structs.c deleted file mode 100644 index 9be38d1f..00000000 --- a/src/structs.c +++ /dev/null @@ -1,80 +0,0 @@ -// Logic for compiling new struct types defined in code -#include - -#include "ast.h" -#include "compile.h" -#include "environment.h" -#include "naming.h" -#include "stdlib/tables.h" -#include "stdlib/text.h" -#include "typecheck.h" - -Text_t compile_struct_typeinfo(env_t *env, type_t *t, const char *name, arg_ast_t *fields, bool is_secret, - bool is_opaque) { - Text_t typeinfo_name = namespace_name(env, env->namespace, Texts(name, "$$info")); - Text_t type_code = Match(t, StructType)->external - ? Text$from_str(name) - : Texts("struct ", namespace_name(env, env->namespace, Texts(name, "$$struct"))); - - int num_fields = 0; - for (arg_ast_t *f = fields; f; f = f->next) - num_fields += 1; - const char *short_name = name; - if (strchr(short_name, '$')) short_name = strrchr(short_name, '$') + 1; - - const char *metamethods = is_packed_data(t) ? "PackedData$metamethods" : "Struct$metamethods"; - Text_t typeinfo = Texts( - "public const TypeInfo_t ", typeinfo_name, " = {.size=sizeof(", type_code, "), .align=__alignof__(", type_code, - "), " - ".metamethods=", - metamethods, - ", " - ".tag=StructInfo, .StructInfo.name=\"", - short_name, "\"", is_secret ? Text(", .StructInfo.is_secret=true") : EMPTY_TEXT, - is_opaque ? Text(", .StructInfo.is_opaque=true") : EMPTY_TEXT, ", .StructInfo.num_fields=", String(num_fields)); - if (fields) { - typeinfo = Texts(typeinfo, ", .StructInfo.fields=(NamedType_t[", String(num_fields), "]){"); - for (arg_ast_t *f = fields; f; f = f->next) { - type_t *field_type = get_arg_ast_type(env, f); - typeinfo = Texts(typeinfo, "{\"", f->name, "\", ", compile_type_info(field_type), "}"); - if (f->next) typeinfo = Texts(typeinfo, ", "); - } - typeinfo = Texts(typeinfo, "}"); - } - return Texts(typeinfo, "};\n"); -} - -Text_t compile_struct_header(env_t *env, ast_t *ast) { - DeclareMatch(def, ast, StructDef); - Text_t typeinfo_name = namespace_name(env, env->namespace, Texts(def->name, "$$info")); - Text_t type_code = def->external - ? Text$from_str(def->name) - : Texts("struct ", namespace_name(env, env->namespace, Texts(def->name, "$$struct"))); - - Text_t fields = EMPTY_TEXT; - for (arg_ast_t *field = def->fields; field; field = field->next) { - type_t *field_t = get_arg_ast_type(env, field); - type_t *check_for_opaque = non_optional(field_t); - if (check_for_opaque->tag == StructType && Match(check_for_opaque, StructType)->opaque) { - if (field->type) - code_err(field->type, "This is an opaque type, so it can't be used as a struct field type"); - else if (field->value) - code_err(field->value, "This is an opaque type, so it can't be used as a struct field type"); - } - fields = Texts(fields, compile_declaration(field_t, valid_c_name(field->name)), - field_t->tag == BoolType ? Text(":1") : EMPTY_TEXT, ";\n"); - } - Text_t struct_code = def->external ? EMPTY_TEXT : Texts(type_code, " {\n", fields, "};\n"); - type_t *t = Table$str_get(*env->types, def->name); - - Text_t unpadded_size = - def->opaque ? Texts("sizeof(", type_code, ")") : Text$from_str(String((int64_t)unpadded_struct_size(t))); - Text_t typeinfo_code = Texts("extern const TypeInfo_t ", typeinfo_name, ";\n"); - Text_t optional_code = EMPTY_TEXT; - if (!def->opaque) { - optional_code = Texts("DEFINE_OPTIONAL_TYPE(", compile_type(t), ", ", unpadded_size, ", ", - namespace_name(env, env->namespace, Texts("$Optional", def->name, "$$type")), ");\n"); - } - return Texts(struct_code, optional_code, typeinfo_code); -} -// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/src/structs.h b/src/structs.h deleted file mode 100644 index 9a9d08e5..00000000 --- a/src/structs.h +++ /dev/null @@ -1,12 +0,0 @@ -#pragma once - -// Compilation of user-defined structs - -#include "ast.h" -#include "environment.h" - -Text_t compile_struct_typeinfo(env_t *env, type_t *t, const char *name, arg_ast_t *fields, bool is_secret, - bool is_opaque); -Text_t compile_struct_header(env_t *env, ast_t *ast); - -// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 -- cgit v1.2.3