compiler: initial support for enums

Simple way to create named values.

Enum member names and enum names have to be all uppercase.

This separates them from other type names like structs.

Author: pointbazaar

ast/ast.h

@@ -10,6 +10,7 @@
 #include "ast/ast_stmts.h"
 #include "ast/ast_const.h"
 #include "ast/ast_struct.h"
+#include "ast/ast_enum.h"
 #include "ast/ast_var.h"
 #include "ast/ast_expr.h"
 #include "ast/ast_subr.h"
@@ -39,6 +40,11 @@ struct Namespace {
 	uint16_t count_includes;
 	char** includes;
 
+	// enum declarations
+	struct EnumDecl** enums;
+	uint16_t count_enums;
+	size_t capacity_enums;
+
 	//structs must be declared before the subroutines
 	struct StructDecl** structs;
 	uint16_t count_structs;

ast/ast/ast_enum.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "../ast_declare.h"
+
+struct EnumDecl {
+	struct ASTNode super;
+
+	// must be all uppercase (underscores are ok)
+	char* name;
+
+	struct EnumMember** members;
+	uint16_t count_members;
+};
+
+struct EnumMember {
+	struct ASTNode super;
+
+	char* name;
+	struct ConstValue* value;
+};

ast/ast/ast_expr.h

@@ -78,6 +78,7 @@ enum TERM_KIND {
 	TERM_KIND_VAR,
 	TERM_KIND_STRINGCONST,
 	TERM_KIND_CONSTVALUE,
+	TERM_KIND_ENUM_VALUE,
 };
 
 struct Term {
@@ -92,6 +93,7 @@ struct Term {
 		struct Variable* var_term;
 		struct StringConst* stringconst_term;
 		struct ConstValue* constvalue_term;
+		char* enum_value_term;
 	} ptr;
 
 	enum TERM_KIND kind;

ast/ast_declare.h

@@ -11,6 +11,7 @@ struct AST;
 struct Namespace;
 struct Method;
 struct StructDecl;
+struct EnumDecl;
 struct MethodDecl;
 //---------------
 struct StmtBlock;

ast/util/free_ast.c

@@ -62,6 +62,10 @@ void free_namespace(struct Namespace* ns) {
 		free(ns->includes[i]);
 	}
 
+	for (int i = 0; i < ns->count_enums; i++) {
+		free_enum_decl(ns->enums[i]);
+	}
+
 	for (int i = 0; i < ns->count_methods; i++) {
 		free_method(ns->methods[i]);
 	}
@@ -101,6 +105,15 @@ void free_stmt_block(struct StmtBlock* block) {
 	free(block);
 }
 
+void free_enum_decl(struct EnumDecl* ed) {
+
+	for (int i = 0; i < ed->count_members; i++) {
+		free(ed->members[i]->name);
+		free(ed->members[i]);
+	}
+	free(ed);
+}
+
 void free_struct_decl(struct StructDecl* sd) {
 
 	free_simple_type(sd->type);
@@ -124,8 +137,9 @@ bool free_term(struct Term* t) {
 		case TERM_KIND_VAR: free_variable(t->ptr.var_term); break;
 		case TERM_KIND_STRINGCONST: free_string_const(t->ptr.stringconst_term); break;
 		case TERM_KIND_CONSTVALUE: free_const_value(t->ptr.constvalue_term); break;
+		case TERM_KIND_ENUM_VALUE: free(t->ptr.enum_value_term); break;
 		default:
-			fprintf(stderr, "Error in free_term(...)\n");
+			fprintf(stderr, "Error in free_term(...), unhandled case %d\n", t->kind);
 			free(t);
 			return false;
 	}

ast/util/free_ast.h

@@ -28,6 +28,9 @@ void free_namespace(struct Namespace* ns);
 void free_stmt_block(struct StmtBlock* block);
 void free_range(struct Range* range);
 
+// enum
+void free_enum_decl(struct EnumDecl* ed);
+
 //struct
 void free_struct_decl(struct StructDecl* sd);
 void free_struct_member(struct StructMember* sm);

ast/visitor/visitor.c

@@ -53,13 +53,18 @@ static bool visit_term(struct Term* t, VISITOR, ARG);
 //const
 static void visit_const_value(struct ConstValue* cv, VISITOR, ARG);
 static void visit_string_const(struct StringConst* s, VISITOR, ARG);
+static void visit_enum_value(char* s, VISITOR, ARG);
 
 //var
 // @returns false on error
 static bool visit_variable(struct Variable* v, VISITOR, ARG);
 // @returns false on error
 static bool visit_simple_var(struct SimpleVar* v, VISITOR, ARG);
 
+// enum
+static bool visit_enum_decl(struct EnumDecl* ed, VISITOR, ARG);
+static bool visit_enum_member(struct EnumMember* em, VISITOR, ARG);
+
 bool visit_ast(struct AST* ast, VISITOR, void* arg) {
 
 	for (int i = 0; i < ast->count_namespaces; i++) {
@@ -78,6 +83,10 @@ bool visit_namespace(struct Namespace* n, VISITOR, void* arg) {
 	//we do not visit the passthrough include declarations as they
 	//are just a workaround for now
 
+	for (int i = 0; i < n->count_enums; i++) {
+		visit_enum_decl(n->enums[i], visitor, arg);
+	}
+
 	for (int i = 0; i < n->count_structs; i++) {
 		visit_struct_decl(n->structs[i], visitor, arg);
 	}
@@ -91,6 +100,25 @@ bool visit_namespace(struct Namespace* n, VISITOR, void* arg) {
 	return true;
 }
 
+static bool visit_enum_decl(struct EnumDecl* ed, VISITOR, ARG) {
+
+	visitor(ed, NODE_ENUM_DECL, arg);
+
+	for (int i = 0; i < ed->count_members; i++) {
+		if (!visit_enum_member(ed->members[i], visitor, arg)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+static bool visit_enum_member(struct EnumMember* em, VISITOR, ARG) {
+
+	visitor(em, NODE_ENUM_MEMBER, arg);
+	return true;
+}
+
 void visit_struct_decl(struct StructDecl* s, VISITOR, void* arg) {
 
 	visitor(s, NODE_STRUCTDECL, arg);
@@ -346,6 +374,9 @@ static bool visit_term(struct Term* t, VISITOR, void* arg) {
 		case TERM_KIND_CONSTVALUE:
 			visit_const_value(t->ptr.constvalue_term, visitor, arg);
 			break;
+		case TERM_KIND_ENUM_VALUE:
+			visit_enum_value(t->ptr.enum_value_term, visitor, arg);
+			break;
 		default:
 			fprintf(stderr, "[Visitor][Error] Fatal(2)\n");
 			return false;
@@ -365,6 +396,11 @@ static void visit_string_const(struct StringConst* s, VISITOR, void* arg) {
 	visitor(s, NODE_STRINGCONST, arg);
 }
 
+static void visit_enum_value(char* s, VISITOR, ARG) {
+
+	visitor(s, NODE_ENUM_VALUE, arg);
+}
+
 static bool visit_variable(struct Variable* v, VISITOR, void* arg) {
 
 	visitor(v, NODE_VARIABLE, arg);

ast/visitor/visitor.h

@@ -24,6 +24,10 @@ enum NODE_TYPE {
 	NODE_AST,
 	NODE_NAMESPACE,
 
+	NODE_ENUM_DECL,
+	NODE_ENUM_MEMBER,
+	NODE_ENUM_VALUE,
+
 	NODE_STRUCTDECL,
 	NODE_STRUCTMEMBER,
 

compiler/main/compiler.c

@@ -116,7 +116,9 @@ bool compile(struct Flags* flags) {
 
 	struct Ctx* ctx = ctx_ctor(flags, st_ctor());
 
-	fill_tables(ast, ctx);
+	if (!fill_tables(ast, ctx)) {
+		return false;
+	}
 
 	struct TCError* errors = typecheck_ast(ast, ctx, true);
 

compiler/main/gen_tac/gen_tac.c

@@ -9,18 +9,6 @@
 #include "util/ctx.h"
 #include "tac/tacbuffer.h"
 
-int int_value_from_const(struct ConstValue* cv) {
-
-	switch (cv->kind) {
-		case 1: return (int)cv->ptr.m1_bool_const;
-		case 2: return (int)cv->ptr.m2_int_const;
-		case 3: return (int)cv->ptr.m3_char_const;
-		case 5: return (int)cv->ptr.m5_hex_const;
-		case 6: return (int)cv->ptr.m5_hex_const;
-	}
-	return -1;
-}
-
 void tac_method(struct TACBuffer* buffer, struct Method* m, struct Ctx* ctx) {
 
 	const uint32_t index = sst_index_of(ctx_tables(ctx)->sst, m->decl->name);