ref: add type/classname result for each gen_* function

include/compiler/internals/gen.h

@@ -13,6 +13,13 @@
 #include <stddef.h>
 #include <stdio.h>
 
+typedef struct
+{
+  bool error;
+  fzl_type_t type;
+  char *classname;
+} gen_res_t;
+
 extern char *null_name;
 extern fzl_extern_type_t type_buf;
 
@@ -28,34 +35,34 @@ fzl_gen_ctx_t *gen_ctx(fzl_gen_t *gen, fzl_gen_ctx_type_t type,
                        fzl_node_t *node);
 fzl_gen_ctx_t *gen_fin_ctx(fzl_gen_t *gen);
 
-bool gen_common(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_extern(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_reference(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_struct(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_alias(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_handle(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_typedef(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_break(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_loop(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_class(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_construct(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_field(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_fn(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_return(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_not(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_compare(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_logical(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_unary_logical(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_condition(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_unary_math(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_declaration(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_identifier(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_block(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_call(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_literal(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_math(fzl_gen_t *gen, fzl_node_t *node);
-bool gen_assign(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_common(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_extern(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_reference(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_alias(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_handle(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_typedef(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_break(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_construct(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_fn(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_return(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_not(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_compare(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_logical(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_unary_logical(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_condition(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_unary_math(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_declaration(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_identifier(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_block(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_call(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_literal(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_math(fzl_gen_t *gen, fzl_node_t *node);
+gen_res_t gen_assign(fzl_gen_t *gen, fzl_node_t *node);
 
 #endif // FZL_INTERNALS_GEN_H

src/compiler/generator/gen_alias.c

@@ -5,10 +5,10 @@
 #include <string.h>
 
 // Type aliasing
-bool gen_alias(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_alias(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   fzl_type_t type;
   char typecn[256];
@@ -16,7 +16,7 @@ bool gen_alias(fzl_gen_t *gen, fzl_node_t *node)
 
   bool resolved = gen_resolve_type(gen, node->token, &type, typecn);
   if (!resolved)
-    return false;
+    return (gen_res_t){.error = true};
 
   ssize_t slot = gen_resolve_extern_type(gen, typecn);
   if (slot == -1)
@@ -26,5 +26,5 @@ bool gen_alias(fzl_gen_t *gen, fzl_node_t *node)
     type_buf.alias_target =
         (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_break.c

@@ -1,13 +1,14 @@
+#include <common/fzl_types.h>
 #include <compiler/fzl_gen.h>
 #include <compiler/internals/gen.h>
 #include <stdbool.h>
 #include <stdio.h>
 
 // Break keyword
-bool gen_break(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_break(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   fzl_gen_ctx_t *ctx = gen->ctx;
   while (ctx != NULL)
@@ -19,7 +20,7 @@ bool gen_break(fzl_gen_t *gen, fzl_node_t *node)
   }
 
   if (!ctx || ctx->type != FZL_GEN_CTX_TYPE_LOOP)
-    return false;
+    return (gen_res_t){.error = true};
 
   for (size_t i = gen->syms_top - 1; i > ctx->level + 1; i--)
     gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
@@ -28,5 +29,5 @@ bool gen_break(fzl_gen_t *gen, fzl_node_t *node)
   ctx->loop.breaks[ctx->loop.breaks_count++] = gen->ops_count;
   gen_word(gen, 0);
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_class.c

@@ -6,14 +6,14 @@
 #include <string.h>
 
 // Class definition
-bool gen_class(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_CLASS, node);
   if (!ctx)
-    return false;
+    return (gen_res_t){.error = true};
 
   gen->classes[gen->classes_count] = fzl_mkctable(node->class.name->value);
   fzl_ctable_t *class              = gen->classes[gen->classes_count++];
@@ -37,7 +37,7 @@ bool gen_class(fzl_gen_t *gen, fzl_node_t *node)
     if (!resolved)
     {
       free(class->fields);
-      return false;
+      return (gen_res_t){.error = true};
     }
 
     class->fields[class->fields_count] = (fzl_ctable_field_t){
@@ -63,10 +63,10 @@ bool gen_class(fzl_gen_t *gen, fzl_node_t *node)
       free(fn->fn.name->value);
 
     fn->fn.name->value = method_name;
-    if (!gen_common(gen, fn))
+    if (gen_common(gen, fn).error)
     {
       free(class->fields);
-      return false;
+      return (gen_res_t){.error = true};
     }
   }
 
@@ -74,8 +74,8 @@ bool gen_class(fzl_gen_t *gen, fzl_node_t *node)
   if (!ctx)
   {
     free(class->fields);
-    return false;
+    return (gen_res_t){.error = true};
   }
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_common.c

@@ -4,13 +4,13 @@
 #include <stdbool.h>
 #include <stdio.h>
 
-typedef bool (*gen_handle_fn)(fzl_gen_t *, fzl_node_t *);
+typedef gen_res_t (*gen_handle_fn)(fzl_gen_t *, fzl_node_t *);
 
 // Common generator entry point
-bool gen_common(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_common(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   gen_handle_fn res = NULL;
   switch (node->type)
@@ -137,7 +137,7 @@ bool gen_common(fzl_gen_t *gen, fzl_node_t *node)
   }
 
   if (!res)
-    return false;
+    return (gen_res_t){.error = true};
 
   return res(gen, node);
 }

src/compiler/generator/gen_construct.c

@@ -0,0 +1,30 @@
+#include <common/fzl_types.h>
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <string.h>
+
+// Object constructing
+gen_res_t gen_construct(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return (gen_res_t){.error = true};
+
+  fzl_node_t *classname = node->construct.name;
+  fzl_ctable_t *ct      = NULL;
+  for (size_t i = 0; i < gen->classes_count; i++)
+  {
+    if (strcmp((char *)classname->token->value, gen->classes[i]->name) == 0)
+    {
+      ct = gen->classes[i];
+      break;
+    }
+  }
+  if (!ct)
+    return (gen_res_t){.error = true};
+
+  gen_op(gen, FZL_OPCODE_ALLOC_OBJECT);
+  gen_word(gen, ct->fields_count);
+
+  return (gen_res_t){
+      .error = false, .type = FZL_TYPE_OBJECT, .classname = ct->name};
+}

src/compiler/generator/gen_extern.c

@@ -1,24 +1,26 @@
 #include <common/fzl_extern.h>
+#include <common/fzl_types.h>
 #include <compiler/fzl_gen.h>
 #include <compiler/internals/gen.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 // Extern block
-bool gen_extern(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_extern(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   gen->extern_libs[gen->extern_libs_count++] =
       (fzl_extern_lib_t){.name = (char *)node->ext.libname};
 
   for (size_t i = 0; i < node->ext.typedefs_count; i++)
-    if (!gen_common(gen, node->ext.typedefs[i]))
-      return false;
+    if (gen_common(gen, node->ext.typedefs[i]).error)
+      return (gen_res_t){.error = true};
 
   for (size_t i = 0; i < node->ext.fns_count; i++)
-    if (!gen_common(gen, node->ext.fns[i]))
-      return false;
+    if (gen_common(gen, node->ext.fns[i]).error)
+      return (gen_res_t){.error = true};
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_externfn.c

@@ -11,26 +11,26 @@
 #include <string.h>
 
 // External function definition
-bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_FUNCTION, node);
   if (!ctx)
-    return false;
+    return (gen_res_t){.error = true};
 
   size_t args_remainder  = 2;
   size_t args_count      = 0;
   fzl_extern_arg_t *args = malloc(args_remainder * sizeof(fzl_extern_arg_t));
   if (!args)
-    return false;
+    return (gen_res_t){.error = true};
 
   for (size_t i = 0; i < node->ext_fn.args_count; i++)
   {
     fzl_node_t *argnode = node->ext_fn.args[i];
     if (!gen_common(gen, argnode))
-      return false;
+      return (gen_res_t){.error = true};
 
     if (args_count >= args_remainder)
     {
@@ -40,7 +40,7 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
       if (!newargs)
       {
         free(args);
-        return false;
+        return (gen_res_t){.error = true};
       }
 
       args = newargs;
@@ -49,7 +49,7 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
     if (argnode->type != FZL_NODETYPE_DECLARATION)
     {
       free(args);
-      return false;
+      return (gen_res_t){.error = true};
     }
 
     fzl_extern_arg_t *arg = &args[args_count++];
@@ -62,7 +62,7 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
     if (!resolved)
     {
       free(args);
-      return false;
+      return (gen_res_t){.error = true};
     }
 
     ssize_t slot = gen_resolve_extern_type(gen, argcn);
@@ -81,7 +81,7 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
   if (!ctx)
   {
     free(args);
-    return false;
+    return (gen_res_t){.error = true};
   }
 
   fzl_type_t ret;
@@ -92,7 +92,7 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
   if (!resolved)
   {
     free(args);
-    return false;
+    return (gen_res_t){.error = true};
   }
 
   fzl_symtable_res_t res = fzl_symt_put(gen->syms[0], node, node->ext_fn.name,
@@ -100,7 +100,7 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
   if (res != FZL_SYMTABLE_RESULT_OK)
   {
     free(args);
-    return false;
+    return (gen_res_t){.error = true};
   }
 
   fzl_extern_fn_t *result = &gen->extern_fns[gen->extern_fns_count++];
@@ -120,5 +120,5 @@ bool gen_externfn(fzl_gen_t *gen, fzl_node_t *node)
   result->used_name   = node->ext_fn.name;
   result->symbol_name = node->ext_fn.original_name;
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_field.c

@@ -0,0 +1,49 @@
+#include <compiler/internals/gen.h>
+#include <stdbool.h>
+#include <string.h>
+
+// Field access
+gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node)
+{
+  if (!gen || !node)
+    return (gen_res_t){.error = true};
+
+  gen_res_t parent_res = gen_common(gen, node->memb.parent);
+  if (parent_res.error)
+    return (gen_res_t){.error = true};
+
+  fzl_ctable_t *ct = NULL;
+  for (size_t i = 0; i < gen->classes_count; i++)
+  {
+    if (strcmp(parent_res.classname, gen->classes[i]->name) == 0)
+    {
+      ct = gen->classes[i];
+      break;
+    }
+  }
+
+  if (!ct)
+    return (gen_res_t){.error = true};
+
+  fzl_token_t *ftok = node->memb.field->token;
+  fzl_ctable_field_t ctf;
+  bool field_exists = false;
+  for (size_t i = 0; i < ct->fields_count; i++)
+  {
+    if (strcmp(ftok->value, ct->fields[i].name) == 0)
+    {
+      field_exists = true;
+      ctf          = ct->fields[i];
+      break;
+    }
+  }
+
+  if (!field_exists)
+    return (gen_res_t){.error = true};
+
+  gen_op(gen, FZL_OPCODE_GET_FIELD);
+  gen_word(gen, ctf.slot_index);
+
+  return (gen_res_t){
+      .error = false, .type = ctf.type, .classname = parent_res.classname};
+}

src/compiler/generator/gen_fmtstr.c

@@ -1,18 +1,21 @@
+#include <common/fzl_types.h>
 #include <compiler/internals/gen.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 // Format string
-bool gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   for (size_t i = 0; i < node->list.entry_count; i++)
-    if (!gen_common(gen, node->list.entries[i]))
-      return false;
+    if (gen_common(gen, node->list.entries[i]).error)
+      return (gen_res_t){.error = true};
 
   gen_op(gen, FZL_OPCODE_BUILD_STR);
   gen_word(gen, node->list.entry_count);
 
-  return true;
+  return (gen_res_t){
+      .error = false, .type = FZL_TYPE_STRING, .classname = NULL};
 }

src/compiler/generator/gen_handle.c

@@ -3,11 +3,11 @@
 #include <stdbool.h>
 
 // Opaque pointer
-bool gen_handle(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_handle(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   type_buf.kind = FZL_EXTERN_KIND_HANDLE;
-  return true;
+  return (gen_res_t){.error = false};
 }

src/compiler/generator/gen_loop.c

@@ -1,28 +1,30 @@
+#include <common/fzl_types.h>
 #include <compiler/fzl_gen.h>
 #include <compiler/internals/gen.h>
 #include <stdbool.h>
+#include <stdio.h>
 
 // While or for loops
-bool gen_loop(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_LOOP, node);
   if (!ctx)
-    return false;
+    return (gen_res_t){.error = true};
 
   gen_op(gen, FZL_OPCODE_MK_ENVTABLE);
 
   if (node->loop.init)
-    if (!gen_common(gen, node->loop.init))
-      return false;
+    if (gen_common(gen, node->loop.init).error)
+      return (gen_res_t){.error = true};
 
   size_t start_ip = gen->ops_count;
   if (node->loop.cond)
   {
-    if (!gen_common(gen, node->loop.cond))
-      return false;
+    if (gen_common(gen, node->loop.cond).error)
+      return (gen_res_t){.error = true};
   }
   else
   {
@@ -34,12 +36,12 @@ bool gen_loop(fzl_gen_t *gen, fzl_node_t *node)
   ctx->loop.breaks[ctx->loop.breaks_count++] = gen->ops_count;
   gen_word(gen, 0);
 
-  if (!gen_common(gen, node->loop.body))
-    return false;
+  if (gen_common(gen, node->loop.body).error)
+    return (gen_res_t){.error = true};
 
   if (node->loop.step)
-    if (!gen_common(gen, node->loop.step))
-      return false;
+    if (gen_common(gen, node->loop.step).error)
+      return (gen_res_t){.error = true};
 
   gen_op(gen, FZL_OPCODE_JMP);
   gen_word(gen, start_ip);
@@ -55,7 +57,7 @@ bool gen_loop(fzl_gen_t *gen, fzl_node_t *node)
 
   ctx = gen_fin_ctx(gen);
   if (!ctx)
-    return false;
+    return (gen_res_t){.error = true};
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_reference.c

@@ -1,23 +1,24 @@
 #include <common/fzl_extern.h>
+#include <common/fzl_types.h>
 #include <compiler/fzl_token.h>
 #include <compiler/internals/gen.h>
 #include <stdbool.h>
 #include <stdio.h>
 
 // Type reference (convert T => T*)
-bool gen_reference(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_reference(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   char *refname = (char *)node->token->value;
   ssize_t slot  = gen_resolve_extern_type(gen, refname);
   if (slot == -1)
-    return false;
+    return (gen_res_t){.error = true};
 
   type_buf.kind = FZL_EXTERN_KIND_REF;
   type_buf.ref_target =
       (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot};
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_struct.c

@@ -10,22 +10,22 @@
 #include <string.h>
 
 // Structure
-bool gen_struct(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   type_buf.kind      = FZL_EXTERN_KIND_STRUCT;
   fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_UNECCESSARY, node);
   if (!ctx)
-    return false;
+    return (gen_res_t){.error = true};
 
   size_t remainder = 2;
   size_t count     = 0;
   fzl_extern_struct_field_t *fields =
       malloc(remainder * sizeof(fzl_extern_struct_field_t));
   if (!fields)
-    return false;
+    return (gen_res_t){.error = true};
 
   for (size_t i = 0; i < node->structure.entries_count; i++)
   {
@@ -33,7 +33,7 @@ bool gen_struct(fzl_gen_t *gen, fzl_node_t *node)
     if (!gen_common(gen, fnode))
     {
       free(fields);
-      return false;
+      return (gen_res_t){.error = true};
     }
 
     if (count >= remainder)
@@ -44,7 +44,7 @@ bool gen_struct(fzl_gen_t *gen, fzl_node_t *node)
       if (!newfields)
       {
         free(fields);
-        return false;
+        return (gen_res_t){.error = true};
       }
       fields = newfields;
     }
@@ -63,7 +63,7 @@ bool gen_struct(fzl_gen_t *gen, fzl_node_t *node)
       if (!resolved)
       {
         free(fields);
-        return false;
+        return (gen_res_t){.error = true};
       }
 
       ssize_t slot = gen_resolve_extern_type(gen, typecn);
@@ -82,7 +82,7 @@ bool gen_struct(fzl_gen_t *gen, fzl_node_t *node)
       if (slot == -1)
       {
         free(fields);
-        return false;
+        return (gen_res_t){.error = true};
       }
       else
         field->type =
@@ -91,12 +91,12 @@ bool gen_struct(fzl_gen_t *gen, fzl_node_t *node)
     else
     {
       free(fields);
-      return false;
+      return (gen_res_t){.error = true};
     }
   }
 
   type_buf.structure.fields       = fields;
   type_buf.structure.fields_count = count;
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }

src/compiler/generator/gen_typedef.c

@@ -1,4 +1,5 @@
 #include <common/fzl_extern.h>
+#include <common/fzl_types.h>
 #include <compiler/fzl_parser.h>
 #include <compiler/internals/gen.h>
 #include <stdbool.h>
@@ -7,14 +8,14 @@
 fzl_extern_type_t type_buf;
 
 // Type definition
-bool gen_typedef(fzl_gen_t *gen, fzl_node_t *node)
+gen_res_t gen_typedef(fzl_gen_t *gen, fzl_node_t *node)
 {
   if (!gen || !node)
-    return false;
+    return (gen_res_t){.error = true};
 
   memset(&type_buf, 0, sizeof(type_buf));
-  if (!gen_common(gen, node->typedefinition.type))
-    return false;
+  if (gen_common(gen, node->typedefinition.type).error)
+    return (gen_res_t){.error = true};
 
   fzl_extern_type_t *newtype = &gen->extern_types[gen->extern_types_count++];
   newtype->lib_slot          = gen->extern_libs_count - 1;
@@ -41,5 +42,5 @@ bool gen_typedef(fzl_gen_t *gen, fzl_node_t *node)
       break;
   }
 
-  return true;
+  return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL};
 }