From 181458ecdaa6b063bdd6b7837efdae116f70d6b1 Mon Sep 17 00:00:00 2001 From: samsonium Date: Wed, 4 Nov 2026 22:52:40 +0300 Subject: [PATCH] feat: add prepared error/null ok returns from gen_* functions --- include/compiler/internals/gen.h | 5 +- src/compiler/generator/gen_alias.c | 6 +- src/compiler/generator/gen_break.c | 6 +- src/compiler/generator/gen_class.c | 12 ++-- src/compiler/generator/gen_common.c | 9 ++- src/compiler/generator/gen_construct.c | 4 +- src/compiler/generator/gen_extern.c | 8 +-- src/compiler/generator/gen_externfn.c | 33 ++++++----- src/compiler/generator/gen_field.c | 8 +-- src/compiler/generator/gen_fmtstr.c | 4 +- src/compiler/generator/gen_fn.c | 66 ++++++++++++++++++++++ src/compiler/generator/gen_handle.c | 4 +- src/compiler/generator/gen_loop.c | 16 +++--- src/compiler/generator/gen_reference.c | 6 +- src/compiler/generator/gen_return.c | 64 +++++++++++++++++++++ src/compiler/generator/gen_struct.c | 18 +++--- src/compiler/generator/gen_typedef.c | 6 +- src/compiler/generator/gen_unary_logical.c | 23 ++++++++ 18 files changed, 232 insertions(+), 66 deletions(-) create mode 100644 src/compiler/generator/gen_fn.c create mode 100644 src/compiler/generator/gen_return.c create mode 100644 src/compiler/generator/gen_unary_logical.c diff --git a/include/compiler/internals/gen.h b/include/compiler/internals/gen.h index 95cb374..4ccf287 100644 --- a/include/compiler/internals/gen.h +++ b/include/compiler/internals/gen.h @@ -20,6 +20,8 @@ typedef struct char *classname; } gen_res_t; +extern gen_res_t gen_error; +extern gen_res_t gen_ok_null; extern char *null_name; extern fzl_extern_type_t type_buf; @@ -51,10 +53,9 @@ 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_unary_logical(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); diff --git a/src/compiler/generator/gen_alias.c b/src/compiler/generator/gen_alias.c index e6722db..9c01294 100644 --- a/src/compiler/generator/gen_alias.c +++ b/src/compiler/generator/gen_alias.c @@ -8,7 +8,7 @@ gen_res_t gen_alias(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; fzl_type_t type; char typecn[256]; @@ -16,7 +16,7 @@ gen_res_t gen_alias(fzl_gen_t *gen, fzl_node_t *node) bool resolved = gen_resolve_type(gen, node->token, &type, typecn); if (!resolved) - return (gen_res_t){.error = true}; + return gen_error; ssize_t slot = gen_resolve_extern_type(gen, typecn); if (slot == -1) @@ -26,5 +26,5 @@ gen_res_t 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 (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_break.c b/src/compiler/generator/gen_break.c index 9390e3d..c2ba4b6 100644 --- a/src/compiler/generator/gen_break.c +++ b/src/compiler/generator/gen_break.c @@ -8,7 +8,7 @@ gen_res_t gen_break(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; fzl_gen_ctx_t *ctx = gen->ctx; while (ctx != NULL) @@ -20,7 +20,7 @@ gen_res_t gen_break(fzl_gen_t *gen, fzl_node_t *node) } if (!ctx || ctx->type != FZL_GEN_CTX_TYPE_LOOP) - return (gen_res_t){.error = true}; + return gen_error; for (size_t i = gen->syms_top - 1; i > ctx->level + 1; i--) gen_op(gen, FZL_OPCODE_RM_ENVTABLE); @@ -29,5 +29,5 @@ gen_res_t 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 (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_class.c b/src/compiler/generator/gen_class.c index 5aedbe9..96dbf25 100644 --- a/src/compiler/generator/gen_class.c +++ b/src/compiler/generator/gen_class.c @@ -9,11 +9,11 @@ gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_CLASS, node); if (!ctx) - return (gen_res_t){.error = true}; + return gen_error; gen->classes[gen->classes_count] = fzl_mkctable(node->class.name->value); fzl_ctable_t *class = gen->classes[gen->classes_count++]; @@ -37,7 +37,7 @@ gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node) if (!resolved) { free(class->fields); - return (gen_res_t){.error = true}; + return gen_error; } class->fields[class->fields_count] = (fzl_ctable_field_t){ @@ -66,7 +66,7 @@ gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node) if (gen_common(gen, fn).error) { free(class->fields); - return (gen_res_t){.error = true}; + return gen_error; } } @@ -74,8 +74,8 @@ gen_res_t gen_class(fzl_gen_t *gen, fzl_node_t *node) if (!ctx) { free(class->fields); - return (gen_res_t){.error = true}; + return gen_error; } - return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_common.c b/src/compiler/generator/gen_common.c index f813f0b..2b28519 100644 --- a/src/compiler/generator/gen_common.c +++ b/src/compiler/generator/gen_common.c @@ -1,3 +1,4 @@ +#include #include #include #include @@ -6,11 +7,15 @@ typedef gen_res_t (*gen_handle_fn)(fzl_gen_t *, fzl_node_t *); +gen_res_t gen_error = (gen_res_t){.error = true}; +gen_res_t gen_ok_null = + (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + // Common generator entry point gen_res_t gen_common(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; gen_handle_fn res = NULL; switch (node->type) @@ -137,7 +142,7 @@ gen_res_t gen_common(fzl_gen_t *gen, fzl_node_t *node) } if (!res) - return (gen_res_t){.error = true}; + return gen_error; return res(gen, node); } diff --git a/src/compiler/generator/gen_construct.c b/src/compiler/generator/gen_construct.c index 30aed83..2adc5db 100644 --- a/src/compiler/generator/gen_construct.c +++ b/src/compiler/generator/gen_construct.c @@ -7,7 +7,7 @@ gen_res_t gen_construct(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; fzl_node_t *classname = node->construct.name; fzl_ctable_t *ct = NULL; @@ -20,7 +20,7 @@ gen_res_t gen_construct(fzl_gen_t *gen, fzl_node_t *node) } } if (!ct) - return (gen_res_t){.error = true}; + return gen_error; gen_op(gen, FZL_OPCODE_ALLOC_OBJECT); gen_word(gen, ct->fields_count); diff --git a/src/compiler/generator/gen_extern.c b/src/compiler/generator/gen_extern.c index 508be40..a9f0b15 100644 --- a/src/compiler/generator/gen_extern.c +++ b/src/compiler/generator/gen_extern.c @@ -9,18 +9,18 @@ gen_res_t gen_extern(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; 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]).error) - return (gen_res_t){.error = true}; + return gen_error; for (size_t i = 0; i < node->ext.fns_count; i++) if (gen_common(gen, node->ext.fns[i]).error) - return (gen_res_t){.error = true}; + return gen_error; - return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_externfn.c b/src/compiler/generator/gen_externfn.c index aea5ba6..ae3049e 100644 --- a/src/compiler/generator/gen_externfn.c +++ b/src/compiler/generator/gen_externfn.c @@ -14,23 +14,23 @@ gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_FUNCTION, node); if (!ctx) - return (gen_res_t){.error = true}; + return gen_error; 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 (gen_res_t){.error = true}; + return gen_error; 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 (gen_res_t){.error = true}; + return gen_error; if (args_count >= args_remainder) { @@ -40,7 +40,7 @@ gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node) if (!newargs) { free(args); - return (gen_res_t){.error = true}; + return gen_error; } args = newargs; @@ -49,7 +49,7 @@ gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node) if (argnode->type != FZL_NODETYPE_DECLARATION) { free(args); - return (gen_res_t){.error = true}; + return gen_error; } fzl_extern_arg_t *arg = &args[args_count++]; @@ -62,7 +62,7 @@ gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node) if (!resolved) { free(args); - return (gen_res_t){.error = true}; + return gen_error; } ssize_t slot = gen_resolve_extern_type(gen, argcn); @@ -81,7 +81,7 @@ gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node) if (!ctx) { free(args); - return (gen_res_t){.error = true}; + return gen_error; } fzl_type_t ret; @@ -92,15 +92,22 @@ gen_res_t gen_externfn(fzl_gen_t *gen, fzl_node_t *node) if (!resolved) { free(args); - return (gen_res_t){.error = true}; + return gen_error; } - fzl_symtable_res_t res = fzl_symt_put(gen->syms[0], node, node->ext_fn.name, - FZL_TYPE_EXTERN_FN, 0); + fzl_symtable_res_t res = + fzl_symt_put(gen->syms[0], node, node->ext_fn.name, ret, 0); if (res != FZL_SYMTABLE_RESULT_OK) { free(args); - return (gen_res_t){.error = true}; + return gen_error; + } + + res = fzl_symt_setobjclass(gen->syms[0], node->ext_fn.name, retname); + if (res != FZL_SYMTABLE_RESULT_OK) + { + free(args); + return gen_error; } fzl_extern_fn_t *result = &gen->extern_fns[gen->extern_fns_count++]; @@ -120,5 +127,5 @@ gen_res_t 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 (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_field.c b/src/compiler/generator/gen_field.c index 09c27e5..be76e4f 100644 --- a/src/compiler/generator/gen_field.c +++ b/src/compiler/generator/gen_field.c @@ -6,11 +6,11 @@ gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; gen_res_t parent_res = gen_common(gen, node->memb.parent); if (parent_res.error) - return (gen_res_t){.error = true}; + return gen_error; fzl_ctable_t *ct = NULL; for (size_t i = 0; i < gen->classes_count; i++) @@ -23,7 +23,7 @@ gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node) } if (!ct) - return (gen_res_t){.error = true}; + return gen_error; fzl_token_t *ftok = node->memb.field->token; fzl_ctable_field_t ctf; @@ -39,7 +39,7 @@ gen_res_t gen_field(fzl_gen_t *gen, fzl_node_t *node) } if (!field_exists) - return (gen_res_t){.error = true}; + return gen_error; gen_op(gen, FZL_OPCODE_GET_FIELD); gen_word(gen, ctf.slot_index); diff --git a/src/compiler/generator/gen_fmtstr.c b/src/compiler/generator/gen_fmtstr.c index 82257e3..dd55615 100644 --- a/src/compiler/generator/gen_fmtstr.c +++ b/src/compiler/generator/gen_fmtstr.c @@ -7,11 +7,11 @@ gen_res_t gen_fmtstr(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; for (size_t i = 0; i < node->list.entry_count; i++) if (gen_common(gen, node->list.entries[i]).error) - return (gen_res_t){.error = true}; + return gen_error; gen_op(gen, FZL_OPCODE_BUILD_STR); gen_word(gen, node->list.entry_count); diff --git a/src/compiler/generator/gen_fn.c b/src/compiler/generator/gen_fn.c new file mode 100644 index 0000000..5b17f36 --- /dev/null +++ b/src/compiler/generator/gen_fn.c @@ -0,0 +1,66 @@ +#include +#include +#include +#include +#include + +// Function definition +gen_res_t gen_fn(fzl_gen_t *gen, fzl_node_t *node) +{ + if (!gen || !node) + return gen_error; + + gen_op(gen, FZL_OPCODE_JMP); + size_t skip_ip = gen->ops_count; + gen_word(gen, (uint64_t)0); + + fzl_type_t fntype; + char fntypcn[256]; + memset(fntypcn, 0, sizeof(fntypcn)); + + bool resolved = gen_resolve_type(gen, node->fn.type, &fntype, fntypcn); + if (!resolved) + return gen_error; + + fzl_symtable_res_t putres = + fzl_symt_put(gen->syms[gen->syms_top - 1], node, node->fn.name->value, + fntype, gen->ops_count); + + if (putres != FZL_SYMTABLE_RESULT_OK) + return gen_error; + + if (fntype == FZL_TYPE_OBJECT) + { + fzl_symtable_res_t updres = fzl_symt_setobjclass( + gen->syms[gen->syms_top - 1], node->fn.name->value, fntypcn); + if (updres != FZL_SYMTABLE_RESULT_OK) + return gen_error; + } + + fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_FUNCTION, node); + if (!ctx) + return gen_error; + + gen_op(gen, FZL_OPCODE_MK_ENVTABLE); + + for (ssize_t i = node->fn.args_count - 1; i >= 0; i--) + { + if (gen_common(gen, node->fn.args[i]).error) + return gen_error; + + gen_op(gen, FZL_OPCODE_WRITE); + } + + if (gen_common(gen, node->fn.body).error) + return gen_error; + + gen_op(gen, FZL_OPCODE_RM_ENVTABLE); + gen_op(gen, FZL_OPCODE_RET); + gen->ops[skip_ip] = gen->ops_count; + + ctx = gen_fin_ctx(gen); + if (!ctx) + return gen_error; + + return (gen_res_t){.error = false, .type = fntype, .classname = fntypcn}; +} diff --git a/src/compiler/generator/gen_handle.c b/src/compiler/generator/gen_handle.c index 40223a6..e374a80 100644 --- a/src/compiler/generator/gen_handle.c +++ b/src/compiler/generator/gen_handle.c @@ -6,8 +6,8 @@ gen_res_t gen_handle(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; type_buf.kind = FZL_EXTERN_KIND_HANDLE; - return (gen_res_t){.error = false}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_loop.c b/src/compiler/generator/gen_loop.c index 3e070c2..cc24cbf 100644 --- a/src/compiler/generator/gen_loop.c +++ b/src/compiler/generator/gen_loop.c @@ -8,23 +8,23 @@ gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_LOOP, node); if (!ctx) - return (gen_res_t){.error = true}; + return gen_error; gen_op(gen, FZL_OPCODE_MK_ENVTABLE); if (node->loop.init) if (gen_common(gen, node->loop.init).error) - return (gen_res_t){.error = true}; + return gen_error; size_t start_ip = gen->ops_count; if (node->loop.cond) { if (gen_common(gen, node->loop.cond).error) - return (gen_res_t){.error = true}; + return gen_error; } else { @@ -37,11 +37,11 @@ gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node) gen_word(gen, 0); if (gen_common(gen, node->loop.body).error) - return (gen_res_t){.error = true}; + return gen_error; if (node->loop.step) if (gen_common(gen, node->loop.step).error) - return (gen_res_t){.error = true}; + return gen_error; gen_op(gen, FZL_OPCODE_JMP); gen_word(gen, start_ip); @@ -57,7 +57,7 @@ gen_res_t gen_loop(fzl_gen_t *gen, fzl_node_t *node) ctx = gen_fin_ctx(gen); if (!ctx) - return (gen_res_t){.error = true}; + return gen_error; - return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_reference.c b/src/compiler/generator/gen_reference.c index 0e104f7..d3f12a5 100644 --- a/src/compiler/generator/gen_reference.c +++ b/src/compiler/generator/gen_reference.c @@ -9,16 +9,16 @@ gen_res_t gen_reference(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; char *refname = (char *)node->token->value; ssize_t slot = gen_resolve_extern_type(gen, refname); if (slot == -1) - return (gen_res_t){.error = true}; + return gen_error; type_buf.kind = FZL_EXTERN_KIND_REF; type_buf.ref_target = (fzl_extern_type_ref_t){.is_primitive = false, .type_slot = slot}; - return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_return.c b/src/compiler/generator/gen_return.c new file mode 100644 index 0000000..394d514 --- /dev/null +++ b/src/compiler/generator/gen_return.c @@ -0,0 +1,64 @@ +#include +#include +#include +#include +#include +#include + +// Return keyword +gen_res_t gen_return(fzl_gen_t *gen, fzl_node_t *node) +{ + if (!gen || !node) + return gen_error; + + fzl_gen_ctx_t *ctx = gen->ctx; + while (ctx != NULL) + { + if (ctx && ctx->type == FZL_GEN_CTX_TYPE_FUNCTION) + break; + + ctx = ctx->parent; + } + + if (!ctx || ctx->type != FZL_GEN_CTX_TYPE_FUNCTION) + return gen_error; + + gen_res_t result; + bool returning_object = false; + if (node->ret.value) + { + gen_res_t retres = gen_common(gen, node->ret.value); + if (retres.error) + return gen_error; + + fzl_node_t *fn_node = gen->ctx->function; + fzl_type_t fntype; + char fntypecn[256]; + memset(fntypecn, 0, sizeof(fntypecn)); + + bool resolved = gen_resolve_type(gen, fn_node->fn.type, &fntype, fntypecn); + if (!resolved) + return gen_error; + + if (!gen_is_types_compatible(retres.type, fntype, retres.classname, + fntypecn)) + return gen_error; + + if (retres.type == FZL_TYPE_OBJECT) + returning_object = true; + + result = retres; + } + else + result = gen_ok_null; + + for (size_t i = 0; i < (gen->syms_top - gen->ctx->level); i++) + { + if (returning_object) + gen_op(gen, FZL_OPCODE_ESCAPE_OBJECT); + gen_op(gen, FZL_OPCODE_RM_ENVTABLE); + } + gen_op(gen, FZL_OPCODE_RET); + + return result; +} diff --git a/src/compiler/generator/gen_struct.c b/src/compiler/generator/gen_struct.c index 5aa3e2f..635ca3f 100644 --- a/src/compiler/generator/gen_struct.c +++ b/src/compiler/generator/gen_struct.c @@ -13,19 +13,19 @@ gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; type_buf.kind = FZL_EXTERN_KIND_STRUCT; fzl_gen_ctx_t *ctx = gen_ctx(gen, FZL_GEN_CTX_TYPE_UNECCESSARY, node); if (!ctx) - return (gen_res_t){.error = true}; + return gen_error; 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 (gen_res_t){.error = true}; + return gen_error; for (size_t i = 0; i < node->structure.entries_count; i++) { @@ -33,7 +33,7 @@ gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node) if (!gen_common(gen, fnode)) { free(fields); - return (gen_res_t){.error = true}; + return gen_error; } if (count >= remainder) @@ -44,7 +44,7 @@ gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node) if (!newfields) { free(fields); - return (gen_res_t){.error = true}; + return gen_error; } fields = newfields; } @@ -63,7 +63,7 @@ gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node) if (!resolved) { free(fields); - return (gen_res_t){.error = true}; + return gen_error; } ssize_t slot = gen_resolve_extern_type(gen, typecn); @@ -82,7 +82,7 @@ gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node) if (slot == -1) { free(fields); - return (gen_res_t){.error = true}; + return gen_error; } else field->type = @@ -91,12 +91,12 @@ gen_res_t gen_struct(fzl_gen_t *gen, fzl_node_t *node) else { free(fields); - return (gen_res_t){.error = true}; + return gen_error; } } type_buf.structure.fields = fields; type_buf.structure.fields_count = count; - return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_typedef.c b/src/compiler/generator/gen_typedef.c index 98a48d2..9cc641c 100644 --- a/src/compiler/generator/gen_typedef.c +++ b/src/compiler/generator/gen_typedef.c @@ -11,11 +11,11 @@ fzl_extern_type_t type_buf; gen_res_t gen_typedef(fzl_gen_t *gen, fzl_node_t *node) { if (!gen || !node) - return (gen_res_t){.error = true}; + return gen_error; memset(&type_buf, 0, sizeof(type_buf)); if (gen_common(gen, node->typedefinition.type).error) - return (gen_res_t){.error = true}; + return gen_error; fzl_extern_type_t *newtype = &gen->extern_types[gen->extern_types_count++]; newtype->lib_slot = gen->extern_libs_count - 1; @@ -42,5 +42,5 @@ gen_res_t gen_typedef(fzl_gen_t *gen, fzl_node_t *node) break; } - return (gen_res_t){.error = false, .type = FZL_TYPE_NULL, .classname = NULL}; + return gen_ok_null; } diff --git a/src/compiler/generator/gen_unary_logical.c b/src/compiler/generator/gen_unary_logical.c new file mode 100644 index 0000000..f4c26d2 --- /dev/null +++ b/src/compiler/generator/gen_unary_logical.c @@ -0,0 +1,23 @@ +#include +#include +#include +#include +#include + +// Currently, only NOT operator +gen_res_t gen_unary_logical(fzl_gen_t *gen, fzl_node_t *node) +{ + if (!gen || !node) + return gen_error; + + gen_res_t operand_res = gen_common(gen, node->unary_op.operand); + if (operand_res.error) + return gen_error; + + if (node->type == FZL_NODETYPE_NOT) + gen_op(gen, FZL_OPCODE_NOT); + else + return gen_error; + + return (gen_res_t){.error = false, .type = FZL_TYPE_BOOL, .classname = NULL}; +}