1 // This file defines how to compile enums
4 #include "../environment.h"
6 #include "../stdlib/tables.h"
7 #include "../stdlib/text.h"
8 #include "../typecheck.h"
9 #include "compilation.h"
11 Text_t compile_enum_typeinfo(env_t *env, const char *name, tag_ast_t *tags) {
12 // Compile member types and constructors:
13 Text_t member_typeinfos = EMPTY_TEXT;
14 for (tag_ast_t *tag = tags; tag; tag = tag->next) {
15 const char *tag_name = String(name, "$", tag->name);
16 type_t *tag_type = Table$str_get(*env->types, tag_name);
17 assert(tag_type && tag_type->tag == StructType);
19 Texts(member_typeinfos, compile_struct_typeinfo(env, tag_type, tag_name, tag->fields, tag->secret, false));
23 for (tag_ast_t *t = tags; t; t = t->next)
26 type_t *t = Table$str_get(*env->types, name);
27 const char *metamethods = is_packed_data(t) ? "PackedDataEnum$metamethods" : "Enum$metamethods";
28 Text_t info = namespace_name(env, env->namespace, Texts(name, "$$info"));
30 Texts("public const TypeInfo_t ", info, " = {", (int64_t)type_size(t), "u, ", (int64_t)type_align(t),
31 "u, .metamethods=", metamethods, ", {.tag=EnumInfo, .EnumInfo={.name=\"", type_to_text(t),
34 (int64_t)num_tags, ", .tags=(NamedType_t[]){");
36 for (tag_ast_t *tag = tags; tag; tag = tag->next) {
37 const char *tag_type_name = String(name, "$", tag->name);
38 type_t *tag_type = Table$str_get(*env->types, tag_type_name);
39 typeinfo = Texts(typeinfo, "{\"", tag->name, "\", ", compile_type_info(tag_type), "}, ");
41 typeinfo = Texts(typeinfo, "}}}};\n");
42 return Texts(member_typeinfos, typeinfo);
45 Text_t compile_enum_constructors(env_t *env, const char *name, tag_ast_t *tags) {
46 Text_t constructors = EMPTY_TEXT;
47 for (tag_ast_t *tag = tags; tag; tag = tag->next) {
48 Text_t arg_sig = EMPTY_TEXT;
49 for (arg_ast_t *field = tag->fields; field; field = field->next) {
50 type_t *field_t = get_arg_ast_type(env, field);
51 arg_sig = Texts(arg_sig, compile_declaration(field_t, Texts("$", field->name)));
52 if (field->next) arg_sig = Texts(arg_sig, ", ");
54 if (arg_sig.length == 0) arg_sig = Text("void");
55 Text_t type_name = namespace_name(env, env->namespace, Texts(name, "$$type"));
56 Text_t tagged_name = namespace_name(env, env->namespace, Texts(name, "$tagged$", tag->name));
57 Text_t tag_name = namespace_name(env, env->namespace, Texts(name, "$tag$", tag->name));
58 Text_t constructor_impl = Texts("public inline ", type_name, " ", tagged_name, "(", arg_sig, ") { return (",
59 type_name, "){.$tag=", tag_name, ", .", valid_c_name(tag->name), "={");
60 for (arg_ast_t *field = tag->fields; field; field = field->next) {
61 constructor_impl = Texts(constructor_impl, "$", field->name);
62 if (field->next) constructor_impl = Texts(constructor_impl, ", ");
64 constructor_impl = Texts(constructor_impl, "}}; }\n");
65 constructors = Texts(constructors, constructor_impl);
70 Text_t compile_enum_header(env_t *env, const char *name, tag_ast_t *tags) {
71 Text_t all_defs = EMPTY_TEXT;
72 Text_t none_name = namespace_name(env, env->namespace, Texts(name, "$none"));
73 Text_t enum_tags = Texts("{ ", none_name, "=0, ");
74 assert(Table$str_get(*env->types, name));
76 for (tag_ast_t *tag = tags; tag; tag = tag->next) {
77 Text_t tag_name = namespace_name(env, env->namespace, Texts(name, "$tag$", tag->name));
78 enum_tags = Texts(enum_tags, tag_name);
79 if (tag->next) enum_tags = Texts(enum_tags, ", ");
81 enum_tags = Texts(enum_tags, " }");
83 Text_t struct_name = namespace_name(env, env->namespace, Texts(name, "$$struct"));
84 Text_t enum_def = Texts("struct ", struct_name,
90 for (tag_ast_t *tag = tags; tag; tag = tag->next) {
91 Text_t field_def = compile_struct_header(env, NewAST(tag->file, tag->start, tag->end, StructDef,
92 .name = Text$as_c_string(Texts(name, "$", tag->name)),
93 .fields = tag->fields));
94 all_defs = Texts(all_defs, field_def);
95 Text_t tag_type = namespace_name(env, env->namespace, Texts(name, "$", tag->name, "$$type"));
96 enum_def = Texts(enum_def, tag_type, " ", valid_c_name(tag->name), ";\n");
98 enum_def = Texts(enum_def, "};\n};\n");
99 all_defs = Texts(all_defs, enum_def);
101 Text_t info = namespace_name(env, env->namespace, Texts(name, "$$info"));
102 all_defs = Texts(all_defs, "extern const TypeInfo_t ", info, ";\n");
103 for (tag_ast_t *tag = tags; tag; tag = tag->next) {
104 Text_t arg_sig = EMPTY_TEXT;
105 for (arg_ast_t *field = tag->fields; field; field = field->next) {
106 type_t *field_t = get_arg_ast_type(env, field);
107 arg_sig = Texts(arg_sig, compile_declaration(field_t, Texts("$", field->name)));
108 if (field->next) arg_sig = Texts(arg_sig, ", ");
110 if (arg_sig.length == 0) arg_sig = Text("void");
111 Text_t enum_type = namespace_name(env, env->namespace, Texts(name, "$$type"));
112 Text_t tagged_name = namespace_name(env, env->namespace, Texts(name, "$tagged$", tag->name));
113 Text_t constructor_def = Texts(enum_type, " ", tagged_name, "(", arg_sig, ");\n");
114 all_defs = Texts(all_defs, constructor_def);
120 Text_t compile_empty_enum(type_t *t) {
121 DeclareMatch(enum_, t, EnumType);
122 tag_t *tag = enum_->tags;
125 return Texts("((", compile_type(t), "){.$tag=", tag->tag_value, ", .", tag->name, "=", compile_empty(tag->type),
130 Text_t compile_enum_field_access(env_t *env, ast_t *ast) {
131 DeclareMatch(f, ast, FieldAccess);
132 type_t *fielded_t = get_type(env, f->fielded);
133 type_t *value_t = value_type(fielded_t);
134 DeclareMatch(e, value_t, EnumType);
135 for (tag_t *tag = e->tags; tag; tag = tag->next) {
136 if (streq(f->field, tag->name)) {
137 Text_t tag_name = namespace_name(e->env, e->env->namespace, Texts("tag$", tag->name));
139 compile_maybe_incref(env, WrapLiteralCode(ast, Texts("_e.", tag->name), .type = tag->type), tag->type);
140 return Texts("({ ", compile_declaration(value_t, Text("_e")), " = ",
141 compile_to_pointer_depth(env, f->fielded, 0, false), "; ", "_e.$tag == ", tag_name, " ? ",
142 promote_to_optional(tag->type, member), " : ", compile_none(tag->type), "; })");
145 code_err(ast, "The field '", f->field, "' is not a valid tag name of ", type_to_text(value_t));