fix: missing freeing and type (in CIF prepare)

- Feat: finish FFI CIF prepare

CMakeLists.txt

@@ -128,6 +128,11 @@ if (NOT FZL_SKIP_C)
 		src/compiler/reader/rd_number.c
 		src/compiler/reader/rd_string_literal.c
 		src/compiler/reader/utility.c
+		src/compiler/writer/wr_consts.c
+		src/compiler/writer/wr_extern_fns.c
+		src/compiler/writer/wr_extern_libs.c
+		src/compiler/writer/wr_extern_types.c
+		src/compiler/writer/wr_ops.c
 		src/compiler/fzl_analyzer.c
 		src/compiler/fzl_debug.c
 		src/compiler/fzl_gen.c
@@ -154,8 +159,18 @@ if (NOT FZL_SKIP_VM)
 		src/vm/handlers/group_str.c
 		src/vm/handlers/group_strcmp.c
 		src/vm/handlers/master.c
+		src/vm/reader/utility.c
+		src/vm/reader/vm_rd_consts.c
+		src/vm/reader/vm_rd_extern_fns.c
+		src/vm/reader/vm_rd_extern_libs.c
+		src/vm/reader/vm_rd_extern_types.c
+		src/vm/reader/vm_rd_header.c
+		src/vm/reader/vm_rd_ops.c
+		src/vm/reader/vm_rd_sections_sz.c
 		src/vm/fzl_vm.c
 		src/vm/fzl_vm_env.c
+		src/vm/fzl_vm_extern.c
+		src/vm/fzl_vm_reader.c
 		src/vm/fzl_vm_debug.c
 		src/vm/main.c)
 
@@ -181,6 +196,12 @@ endif ()
 if (FZL_TESTS)
 	enable_testing()
 
+	file(GLOB TEST_LIBS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "tests/libs/*.c")
+	foreach (TEST_LIB IN LISTS TEST_LIBS)
+		get_filename_component(LIB_NAME "${TEST_LIB}" NAME_WE)
+		add_library("${LIB_NAME}" ${TEST_LIB})
+	endforeach ()
+
 	file(GLOB TEST_PROGS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "tests/programs/*.fzs")
 	foreach (TEST_FILE IN LISTS TEST_PROGS)
 		get_filename_component(TEST_NAME "${TEST_FILE}" NAME_WE)

include/compiler/internals/writer.h

@@ -0,0 +1,16 @@
+#ifndef INTERNALS_WRITER_H
+#define INTERNALS_WRITER_H
+
+#include <common/fzl_extern.h>
+#include <compiler/utils/fzl_const_pool.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+bool wr_consts(FILE *fd, fzl_const_hash_pool_t *consts);
+bool wr_extern_libs(FILE *fd, fzl_extern_lib_t *libs, size_t libs_count);
+bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count);
+bool wr_extern_fns(FILE *fd, fzl_extern_fn_t *fns, size_t fns_count);
+bool wr_ops(FILE *fd, size_t *ops, size_t ops_count);
+
+#endif // INTERNALS_WRITER_H

include/vm/fzl_vm.h

@@ -1,26 +1,18 @@
 #ifndef FZL_VM_H
 #define FZL_VM_H
 
-#include <common/fzl_value.h>
-#include <compiler/utils/fzl_const_pool.h> // NOTE: move outside compiler scope to common
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <vm/fzl_vm_env.h>
 #include <vm/fzl_vm_extern.h>
-#include <vm/fzl_vm_object.h>
+#include <vm/fzl_vm_reader.h>
 
 // VM descriptor
 typedef struct
 {
-  fzl_const_t *consts;
-  size_t consts_count;
-
-  fzl_vm_extern_t *externs;
-  size_t externs_count;
-
-  uint64_t *ops;
-  size_t ops_count;
+  fzl_vm_reader_t *reader;
+  fzl_vm_extern_t *prep_fns;
 
   size_t ip;
 
@@ -41,7 +33,7 @@ typedef struct
 } fzl_vm_t;
 
 // Allocate FZL VM
-fzl_vm_t *fzl_mkvm(const char *filepath);
+fzl_vm_t *fzl_mkvm(fzl_vm_reader_t *reader);
 
 // Load and run code
 int fzl_vm_run(fzl_vm_t *vm);

include/vm/fzl_vm_extern.h

@@ -2,6 +2,8 @@
 #define FZL_VM_EXTERN_H
 
 #include <ffi.h>
+#include <stddef.h>
+#include <vm/fzl_vm_reader.h>
 
 // Loaded extern function definition
 typedef struct
@@ -9,6 +11,25 @@ typedef struct
   void *func_ptr;
   ffi_cif cif;
   ffi_type **arg_types;
+} fzl_vm_sym_t;
+
+// Extern object descriptor
+typedef struct
+{
+  void **libs;
+  size_t libs_loaded;
+
+  fzl_vm_sym_t *syms;
+  size_t syms_loaded;
 } fzl_vm_extern_t;
 
+// Load externs
+fzl_vm_extern_t *fzl_vm_init_externs(fzl_vm_reader_t *reader);
+
+// Get last error from externs loader
+char *fzl_vm_externs_geterror();
+
+// Close and free externs
+void fzl_vm_free_externs(fzl_vm_extern_t *ex);
+
 #endif // FZL_VM_EXTERN_H

include/vm/fzl_vm_reader.h

@@ -0,0 +1,43 @@
+#ifndef FZL_VM_READER_H
+#define FZL_VM_READER_H
+
+#include <common/fzl_extern.h>
+#include <common/fzl_value.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+// Binary file reader descriptor
+typedef struct
+{
+  char *filepath;
+
+  fzl_value_t *consts;
+  uint16_t consts_count;
+
+  size_t *ops;
+  size_t ops_count;
+
+  char **extern_libs;
+  uint16_t extern_libs_count;
+
+  fzl_extern_type_t *extern_types;
+  uint16_t extern_types_count;
+
+  fzl_extern_fn_t *extern_fns;
+  uint16_t extern_fns_count;
+} fzl_vm_reader_t;
+
+// Allocate binary file reader
+fzl_vm_reader_t *fzl_vm_mkreader(char *filepath);
+
+// Read the file
+bool fzl_vm_read(fzl_vm_reader_t *reader);
+
+// Get last error message from the reader
+char *fzl_vm_getreadererror();
+
+// Free file reader
+void fzl_vm_freereader(fzl_vm_reader_t *reader);
+
+#endif // FZL_VM_READER_H

include/vm/internals/opcode.h

@@ -7,7 +7,7 @@
 // Opcode handler descriptor
 typedef int (*opcode_handler)(fzl_vm_t *);
 
-extern char last_err[256];
+extern char last_err[512];
 extern size_t last_jmp_ip;
 extern size_t total_jmp_on_same;
 

include/vm/internals/reader.h

@@ -0,0 +1,24 @@
+#ifndef INTERNALS_VM_READER_H
+#define INTERNALS_VM_READER_H
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <vm/fzl_vm_reader.h>
+
+extern char internal_error[256];
+
+bool vm_rd_char(FILE *fd, size_t count, char *outbuf);
+bool vm_rd_u16(FILE *fd, size_t count, uint16_t *outbuf);
+bool vm_rd_word(FILE *fd, size_t count, size_t *outbuf);
+
+bool vm_rd_header(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_sections_sz(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_consts(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_extern_libs(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_extern_types(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_extern_fns(fzl_vm_reader_t *reader, FILE *fd);
+bool vm_rd_ops(fzl_vm_reader_t *reader, FILE *fd);
+
+#endif // INTERNALS_VM_READER_H

src/compiler/analyzer/an_call.c

@@ -131,7 +131,8 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
     return (fzl_an_res_t){.error = true};
   }
 
-  if (sym.node->type != FZL_NODETYPE_FUNCTION)
+  if (sym.node->type != FZL_NODETYPE_FUNCTION &&
+      sym.node->type != FZL_NODETYPE_EXTERN_FN)
   {
     snprintf(an_problem, sizeof(an_problem), "'%s' is not callable",
              callee_name);
@@ -146,22 +147,24 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
     return (fzl_an_res_t){.error = true};
   }
 
-  size_t offset = is_method ? 1 : 0;
-  if ((sym.node->fn.args_count - offset) != call_node->call.args_count)
+  size_t offset     = is_method ? 1 : 0;
+  size_t args_count = sym.node->type == FZL_NODETYPE_EXTERN_FN
+                          ? sym.node->ext_fn.args_count
+                          : sym.node->fn.args_count;
+  if ((args_count - offset) != call_node->call.args_count)
   {
     if (is_method)
     {
       snprintf(an_problem, sizeof(an_problem),
                "method '%s.%s' is expecting %zu argument(s), got %zu",
-               tmp_classname, tmp_fnname, sym.node->fn.args_count,
+               tmp_classname, tmp_fnname, args_count,
                call_node->call.args_count - offset);
     }
     else
     {
       snprintf(an_problem, sizeof(an_problem),
                "function '%s' is expecting %zu argument(s), got %zu",
-               callee_name, sym.node->fn.args_count,
-               call_node->call.args_count - offset);
+               callee_name, args_count, call_node->call.args_count - offset);
     }
     an_push_error(analyzer, call_node->token, an_problem);
 
@@ -174,9 +177,12 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
     return (fzl_an_res_t){.error = true};
   }
 
+  fzl_node_t **args = sym.node->type == FZL_NODETYPE_EXTERN_FN
+                          ? sym.node->ext_fn.args
+                          : sym.node->fn.args;
   for (size_t i = offset; i < sym.node->fn.args_count; i++)
   {
-    fzl_node_t *arg     = sym.node->fn.args[i];
+    fzl_node_t *arg     = args[i];
     bool found          = false;
     fzl_type_t req_type = an_toktotype(analyzer, arg->var.type, &found);
     char *req_classname = NULL;
@@ -237,14 +243,28 @@ fzl_an_res_t analyze_call(fzl_analyzer_t *analyzer, fzl_node_t *call_node)
   }
 
   bool type_found = false;
-  fzl_type_t type = an_toktotype(analyzer, sym.node->fn.type, &type_found);
+  fzl_token_t *ret_tok = NULL;
+  void        *ret_name = NULL;
+
+  if (sym.node->type == FZL_NODETYPE_EXTERN_FN)
+  {
+    ret_tok = sym.node->ext_fn.type;
+    ret_name = sym.node->ext_fn.name;
+  }
+  else
+  {
+    ret_tok = sym.node->fn.type;
+    ret_name = sym.node->fn.name;
+  }
+
+  fzl_type_t type = an_toktotype(analyzer, ret_tok, &type_found);
   char *classname = sym.classname;
 
   if (!type_found)
   {
     snprintf(an_problem, sizeof(an_problem), "symbol '%s' not found",
-             (char *)sym.node->fn.type->value);
-    an_push_error(analyzer, sym.node->fn.type, an_problem);
+             (char *)ret_name);
+    an_push_error(analyzer, ret_tok, an_problem);
     return (fzl_an_res_t){.error = true};
   }
 

src/compiler/fzl_gen.c

@@ -61,6 +61,8 @@ bool fzl_gen_run(fzl_gen_t *gen)
     current = current->next;
   }
 
+  gen_op(gen, FZL_OPCODE_RM_ENVTABLE);
+
   return true;
 }
 

src/compiler/fzl_writer.c

@@ -1,5 +1,6 @@
 #include <compiler/fzl_gen.h>
 #include <compiler/fzl_writer.h>
+#include <compiler/internals/writer.h>
 #include <compiler/utils/fzl_const_pool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -12,11 +13,11 @@ char wrlast_err[256];
 fzl_writer_t *fzl_mkwriter(const char *filepath)
 {
   if (strlen(filepath) < 1)
-    return NULL;
+    return nullptr;
 
   fzl_writer_t *writer = malloc(sizeof(fzl_writer_t));
   if (!writer)
-    return NULL;
+    return nullptr;
 
   writer->filepath = filepath;
 
@@ -28,41 +29,66 @@ int fzl_write(fzl_writer_t *writer, fzl_gen_t *gen)
   if (!writer || !gen)
     return -1;
 
-  FILE *fp = fopen(writer->filepath, "wb");
-  if (!fp)
+  FILE *fd = fopen(writer->filepath, "wb");
+  if (!fd)
   {
     snprintf(wrlast_err, sizeof(wrlast_err), "failed to open '%s' to write",
              writer->filepath);
     return -1;
   }
 
-  const char hdr[5] = {'F', 'Z', 'L', 0x0, 0x1};
-  fwrite(hdr, sizeof(char), 5, fp);
-  fwrite(&gen->consts->size, sizeof(size_t), 1, fp);
-  fwrite(&gen->extern_libs_count, sizeof(size_t), 1, fp);
-  fwrite(&gen->extern_types_count, sizeof(size_t), 1, fp);
-  fwrite(&gen->extern_fns_count, sizeof(size_t), 1, fp);
-  fwrite(&gen->ops_count, sizeof(size_t), 1, fp);
+  constexpr char hdr[5] = {'F', 'Z', 'L', 0x0, 0x2};
+  fwrite(hdr, sizeof(char), 5, fd);
+  fwrite(&gen->consts->size, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->extern_libs_count, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->extern_types_count, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->extern_fns_count, sizeof(uint16_t), 1, fd);
+  fwrite(&gen->ops_count, sizeof(size_t), 1, fd);
 
-  for (size_t i = 0; i < gen->consts->size; i++)
+  bool result = wr_consts(fd, gen->consts);
+  if (!result)
   {
-    fzl_const_t c = gen->consts->array[i];
-    fwrite(&c.type, sizeof(fzl_consttype_t), 1, fp);
-
-    if (c.type == FZL_CONSTTYPE_STRING)
-    {
-      size_t strlen = c.as.string.length;
-      fwrite(&c.as.string.length, sizeof(size_t), 1, fp);
-      fwrite(c.as.string.chars, sizeof(char), strlen, fp);
-    }
+    snprintf(wrlast_err, sizeof(wrlast_err), "failed to write constants table");
+    fclose(fd);
+    return -1;
   }
 
-  // TODO: write libs, types and functions
+  result = wr_extern_libs(fd, gen->extern_libs, gen->extern_libs_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err),
+             "failed to write external lib names");
+    fclose(fd);
+    return -1;
+  }
 
-  if (gen->ops_count > 0)
-    fwrite(gen->ops, sizeof(uint64_t), gen->ops_count, fp);
+  result = wr_extern_types(fd, gen->extern_types, gen->extern_types_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err),
+             "failed to write extern lib types");
+    fclose(fd);
+    return -1;
+  }
 
-  fclose(fp);
+  result = wr_extern_fns(fd, gen->extern_fns, gen->extern_fns_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err),
+             "failed to write extern lib functions");
+    fclose(fd);
+    return -1;
+  }
+
+  result = wr_ops(fd, gen->ops, gen->ops_count);
+  if (!result)
+  {
+    snprintf(wrlast_err, sizeof(wrlast_err), "failed to write opcodes");
+    fclose(fd);
+    return -1;
+  }
+
+  fclose(fd);
 
   return 0;
 }

src/compiler/writer/wr_consts.c

@@ -0,0 +1,20 @@
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+// Write constants table
+bool wr_consts(FILE *fd, fzl_const_hash_pool_t *consts)
+{
+  if (!fd || !consts)
+    return false;
+
+  for (size_t i = 0; i < consts->size; i++)
+  {
+    fzl_const_t c = consts->array[i];
+    size_t strlen = c.as.string.length;
+    fwrite(&c.as.string.length, sizeof(uint16_t), 1, fd);
+    fwrite(c.as.string.chars, sizeof(char), strlen, fd);
+  }
+
+  return true;
+}

src/compiler/writer/wr_extern_fns.c

@@ -0,0 +1,68 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+// Write arguments
+bool write_args(FILE *fd, fzl_extern_arg_t *args, size_t args_count)
+{
+  for (size_t i = 0; i < args_count; i++)
+  {
+    fzl_extern_arg_t *arg = &args[i];
+    fwrite(&arg->is_out, sizeof(uint8_t), 1, fd);
+    fwrite(&arg->type.is_primitive, sizeof(uint8_t), 1, fd);
+    if (arg->type.is_primitive)
+      fwrite(&arg->type.primitive, sizeof(uint8_t), 1, fd);
+    else
+      fwrite(&arg->type.type_slot, sizeof(uint16_t), 1, fd);
+  }
+
+  return true;
+}
+
+// Write external function references
+bool wr_extern_fns(FILE *fd, fzl_extern_fn_t *fns, size_t fns_count)
+{
+  if (!fd || !fns)
+    return false;
+
+  for (size_t i = 0; i < fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &fns[i];
+    fwrite(&fn->lib_slot, sizeof(uint16_t), 1, fd);
+
+    size_t used_name_sz  = strlen(fn->used_name);
+    bool has_symbol_name = fn->symbol_name != NULL;
+
+    fwrite(&used_name_sz, sizeof(uint16_t), 1, fd);
+    fwrite(fn->used_name, sizeof(char), used_name_sz, fd);
+    fwrite(&has_symbol_name, sizeof(uint8_t), 1, fd);
+
+    if (has_symbol_name)
+    {
+      size_t symbol_name_sz = strlen(fn->symbol_name);
+      fwrite(&symbol_name_sz, sizeof(uint16_t), 1, fd);
+      fwrite(fn->symbol_name, sizeof(char), symbol_name_sz, fd);
+    }
+
+    fwrite(&fn->has_return, sizeof(uint8_t), 1, fd);
+    if (fn->has_return)
+    {
+      fwrite(&fn->ret_type.is_primitive, sizeof(uint8_t), 1, fd);
+      if (fn->ret_type.is_primitive)
+        fwrite(&fn->ret_type.primitive, sizeof(uint8_t), 1, fd);
+      else
+        fwrite(&fn->ret_type.type_slot, sizeof(uint16_t), 1, fd);
+    }
+
+    fwrite(&fn->args_count, sizeof(uint16_t), 1, fd);
+    if (fn->args_count > 0)
+      if (!write_args(fd, fn->args, fn->args_count))
+        return false;
+  }
+
+  return true;
+}

src/compiler/writer/wr_extern_libs.c

@@ -0,0 +1,30 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+// Writer external lib names
+bool wr_extern_libs(FILE *fd, fzl_extern_lib_t *libs, size_t libs_count)
+{
+  if (!fd || !libs)
+    return false;
+
+  for (size_t i = 0; i < libs_count; i++)
+  {
+    fzl_extern_lib_t *lib = &libs[i];
+
+    if (!lib || !lib->name)
+      return false;
+
+    size_t len = strlen(lib->name);
+    if (len < 1)
+      return false;
+
+    fwrite(&len, sizeof(size_t), 1, fd);
+    fwrite(lib->name, sizeof(char), len, fd);
+  }
+
+  return true;
+}

src/compiler/writer/wr_extern_types.c

@@ -0,0 +1,80 @@
+#include <common/fzl_extern.h>
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+// Write structure
+bool write_struct(FILE *fd, fzl_extern_type_t *st)
+{
+  fwrite(&st->structure.fields_count, sizeof(uint16_t), 1, fd);
+
+  for (size_t i = 0; i < st->structure.fields_count; i++)
+  {
+    fzl_extern_struct_field_t *field = &st->structure.fields[i];
+
+    bool has_name = field->name != NULL;
+    fwrite(&has_name, sizeof(uint8_t), 1, fd);
+    if (field->name)
+    {
+      size_t name_sz = strlen(field->name);
+      if (name_sz < 1)
+        return false;
+
+      fwrite(&name_sz, sizeof(uint16_t), 1, fd);
+      fwrite(field->name, sizeof(char), name_sz, fd);
+    }
+
+    fwrite(&field->type.is_primitive, sizeof(uint8_t), 1, fd);
+    if (field->type.is_primitive)
+      fwrite(&field->type.primitive, sizeof(uint8_t), 1, fd);
+    else
+      fwrite(&field->type.type_slot, sizeof(uint16_t), 1, fd);
+  }
+
+  return true;
+}
+
+// Write external libs type definitions
+bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count)
+{
+  if (!fd || !types)
+    return false;
+
+  for (size_t i = 0; i < types_count; i++)
+  {
+    fzl_extern_type_t *type = &types[i];
+    fwrite(&type->lib_slot, sizeof(uint16_t), 1, fd);
+    fwrite(&type->kind, sizeof(uint8_t), 1, fd);
+
+    uint16_t name_sz = strlen(type->name);
+    fwrite(&name_sz, sizeof(uint16_t), 1, fd);
+    fwrite(type->name, sizeof(char), name_sz, fd);
+
+    if (type->kind == FZL_EXTERN_KIND_STRUCT)
+    {
+      if (!write_struct(fd, type))
+        return false;
+    }
+    else if (type->kind == FZL_EXTERN_KIND_REF)
+    {
+      fwrite(&type->ref_target.is_primitive, sizeof(uint8_t), 1, fd);
+      if (type->ref_target.is_primitive)
+        fwrite(&type->ref_target.primitive, sizeof(uint8_t), 1, fd);
+      else
+        fwrite(&type->ref_target.type_slot, sizeof(uint16_t), 1, fd);
+    }
+    else if (type->kind == FZL_EXTERN_KIND_ALIAS)
+    {
+      fwrite(&type->alias_target.is_primitive, sizeof(uint8_t), 1, fd);
+      if (type->alias_target.is_primitive)
+        fwrite(&type->alias_target.primitive, sizeof(uint8_t), 1, fd);
+      else
+        fwrite(&type->alias_target.type_slot, sizeof(uint16_t), 1, fd);
+    }
+  }
+
+  return true;
+}

src/compiler/writer/wr_ops.c

@@ -0,0 +1,14 @@
+#include <compiler/internals/writer.h>
+#include <stdbool.h>
+
+// Write opcodes
+bool wr_ops(FILE *fd, size_t *ops, size_t ops_count)
+{
+  if (!fd || !ops)
+    return false;
+
+  if (ops_count > 0)
+    fwrite(ops, sizeof(uint64_t), ops_count, fd);
+
+  return true;
+}

src/vm/fzl_vm.c

@@ -1,27 +1,31 @@
-#include <common/fzl_builtins.h>
 #include <common/fzl_opcodes.h>
 #include <common/fzl_types.h>
 #include <common/fzl_value.h>
 #include <compiler/utils/fzl_const_pool.h>
-#include <stdbool.h>
 #include <stddef.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
 #include <vm/fzl_vm_env.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/fzl_vm_object.h>
+#include <vm/fzl_vm_reader.h>
 #include <vm/internals/opcode.h>
 
-char last_err[256];
+char last_err[512];
+char internal_error[256];
 size_t last_jmp_ip       = 0;
 size_t total_jmp_on_same = 0;
 
-static char *expect_hdr = "FZL\0\1";
-
-fzl_vm_t *fzl_mkvm(const char *filepath)
+fzl_vm_t *fzl_mkvm(fzl_vm_reader_t *reader)
 {
+  if (!reader)
+  {
+    snprintf(last_err, sizeof(last_err), "reader is not provided");
+    return NULL;
+  }
+
   fzl_vm_t *vm = malloc(sizeof(fzl_vm_t));
   if (!vm)
   {
@@ -30,86 +34,7 @@ fzl_vm_t *fzl_mkvm(const char *filepath)
   }
 
   memset(vm, 0, sizeof(fzl_vm_t));
-
-  FILE *fd = fopen(filepath, "rb");
-  if (!fd)
-  {
-    snprintf(last_err, sizeof(last_err), "failed to open file '%s'", filepath);
-    free(vm);
-    return NULL;
-  }
-
-  char hdr[5];
-  fread(hdr, sizeof(char), 5,
-        fd); // NOTE: add red bytes check (also for freads below)
-  if (memcmp(hdr, expect_hdr, 5) != 0)
-  {
-    snprintf(last_err, sizeof(last_err), "magic check error");
-    fclose(fd);
-    free(vm);
-    return NULL;
-  }
-
-  size_t consts_count, ops_count;
-  fread(&consts_count, sizeof(size_t), 1, fd);
-  fread(&ops_count, sizeof(size_t), 1, fd);
-  // TODO: read externs count
-
-  if (ops_count < 1)
-  {
-    snprintf(last_err, sizeof(last_err), "there is nothing to do (0 ops)");
-    fclose(fd);
-    free(vm);
-    return NULL;
-  }
-
-  if (consts_count > 0)
-  {
-    vm->consts_count = consts_count;
-    vm->consts       = malloc(consts_count * sizeof(fzl_value_t));
-
-    for (size_t i = 0; i < consts_count; i++)
-    {
-      fzl_consttype_t type;
-      fread(&type, sizeof(fzl_consttype_t), 1, fd);
-
-      if (type == FZL_CONSTTYPE_STRING)
-      {
-        size_t length;
-        char *chars;
-
-        fread(&length, sizeof(size_t), 1, fd);
-
-        chars = malloc(length * sizeof(char) + 1);
-        fread(chars, sizeof(char), length, fd);
-        chars[length] = 0;
-
-        vm->consts[i] = (fzl_const_t){
-            .type = type, .as.string.length = length, .as.string.chars = chars};
-      }
-      else
-      {
-        fclose(fd);
-        free(vm->consts);
-        free(vm);
-        snprintf(last_err, sizeof(last_err), "unknown const type at index %ld",
-                 i);
-        return NULL;
-      }
-    }
-  }
-
-  vm->ops_count = ops_count;
-  vm->ops       = malloc(ops_count * sizeof(uint64_t));
-  for (size_t i = 0; i < ops_count; i++)
-  {
-    uint64_t op;
-    fread(&op, sizeof(uint64_t), 1, fd);
-    vm->ops[i] = op;
-  }
-
-  // TODO: read externs
-  fclose(fd);
+  vm->reader = reader;
 
   return vm;
 }
@@ -229,9 +154,9 @@ int fzl_vm_run(fzl_vm_t *vm)
 
   vm->ip     = 0;
   int result = 0;
-  while (vm->ip < vm->ops_count)
+  while (vm->ip < vm->reader->ops_count)
   {
-    fzl_opcode_t opcode = vm->ops[vm->ip];
+    fzl_opcode_t opcode = vm->reader->ops[vm->ip];
     size_t op_group     = (opcode >> 16) & 0xFF;
     size_t op_fnnum     = (opcode & 0xFF);
 
@@ -265,13 +190,5 @@ void fzl_freevm(fzl_vm_t *vm)
   while (vm->etop > 0)
     fzl_freeenv(vm->estack[--vm->etop]);
 
-  for (size_t i = 0; i < vm->consts_count; i++)
-  {
-    if (vm->consts[i].type == FZL_CONSTTYPE_STRING)
-      free((void *)vm->consts[i].as.string.chars);
-  }
-
-  free(vm->consts);
-  free(vm->ops);
   free(vm);
 }

src/vm/fzl_vm_debug.c

@@ -1,5 +1,8 @@
 #include <common/fzl_opcodes.h>
+#include <common/fzl_value.h>
 #include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <vm/fzl_vm.h>
 
@@ -8,36 +11,44 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
   if (!vm)
     return;
 
-  if (vm->ops_count < 1)
+  if (vm->reader->ops_count < 1)
   {
     printf("no opcodes\n");
     return;
   }
 
-  for (size_t i = 0; i < vm->ops_count; i++)
+  for (size_t i = 0; i < vm->reader->ops_count; i++)
   {
     printf("%04ld: ", i);
 
-    switch (vm->ops[i])
+    switch (vm->reader->ops[i])
     {
+      case FZL_OPCODE_CALL_EXTERN:
+      {
+        size_t fn_n = vm->reader->ops[++i];
+        printf("CALL_EXTERN FN=#%zu (%s)\n", fn_n,
+               vm->reader->extern_fns[fn_n].used_name);
+        break;
+      }
+
       case FZL_OPCODE_STORE_LOCAL:
       {
-        size_t depth = vm->ops[++i];
-        size_t slot  = vm->ops[++i];
+        size_t depth = vm->reader->ops[++i];
+        size_t slot  = vm->reader->ops[++i];
         printf("STORE_LOCAL D=%zu S=%zu\n", depth, slot);
         break;
       }
 
       case FZL_OPCODE_LOAD_LOCAL:
       {
-        size_t depth = vm->ops[++i];
-        size_t slot  = vm->ops[++i];
+        size_t depth = vm->reader->ops[++i];
+        size_t slot  = vm->reader->ops[++i];
         printf("LOAD_LOCAL D=%zu S=%zu\n", depth, slot);
         break;
       }
 
       case FZL_OPCODE_BUILD_STR:
-        printf("BUILD_STR %zu\n", vm->ops[++i]);
+        printf("BUILD_STR %zu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_DEREFERENCE:
@@ -65,20 +76,20 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
         break;
 
       case FZL_OPCODE_ALLOC_OBJECT:
-        printf("ALLOC_OBJECT: %lu fields\n", vm->ops[++i]);
+        printf("ALLOC_OBJECT: %lu fields\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_GET_FIELD:
-        printf("GET_FIELD #%lu\n", vm->ops[++i]);
+        printf("GET_FIELD #%lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_SET_FIELD:
-        printf("SET_FIELD #%lu\n", vm->ops[++i]);
+        printf("SET_FIELD #%lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_CALL:
       {
-        size_t ip = vm->ops[++i];
+        size_t ip = vm->reader->ops[++i];
         printf("CALL IP: %lu\n", ip);
         break;
       }
@@ -89,22 +100,22 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
 
       case FZL_OPCODE_LOADCONST:
       {
-        size_t const_n = vm->ops[++i];
-        fzl_const_t c  = vm->consts[const_n];
-        printf("LOADCONST #%lu ('%s')\n", const_n, c.as.string.chars);
+        size_t const_n = vm->reader->ops[++i];
+        fzl_value_t c  = vm->reader->consts[const_n];
+        printf("LOADCONST #%lu ('%s')\n", const_n, c.as.s.value);
         break;
       }
 
       case FZL_OPCODE_CALL_BUILTIN:
-        printf("CALL_BUILTIN #%lu\n", vm->ops[++i]);
+        printf("CALL_BUILTIN #%lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_PUSHNUM:
-        printf("PUSHNUM %lu\n", vm->ops[++i]);
+        printf("PUSHNUM %lu\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_PUSHBOOL:
-        printf("PUSHBOOL %s\n", vm->ops[++i] ? "true" : "false");
+        printf("PUSHBOOL %s\n", vm->reader->ops[++i] ? "true" : "false");
         break;
 
       case FZL_OPCODE_MK_ENVTABLE:
@@ -177,11 +188,11 @@ void fzl_vm_print_ops(fzl_vm_t *vm)
         break;
 
       case FZL_OPCODE_JZ:
-        printf("JZ IP: %ld\n", vm->ops[++i]);
+        printf("JZ IP: %ld\n", vm->reader->ops[++i]);
         break;
 
       case FZL_OPCODE_JMP:
-        printf("JMP IP: %ld\n", vm->ops[++i]);
+        printf("JMP IP: %ld\n", vm->reader->ops[++i]);
         break;
     }
   }

src/vm/fzl_vm_extern.c

@@ -0,0 +1,271 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <dlfcn.h>
+#include <ffi.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_extern.h>
+#include <vm/fzl_vm_reader.h>
+
+char ex_err[256];
+
+// Resolve specified type reference
+ffi_type *resolve_type(fzl_vm_reader_t *reader, fzl_extern_type_ref_t *ref)
+{
+  if (ref->is_primitive)
+  {
+    switch (ref->primitive)
+    {
+      case FZL_TYPE_INT8:
+        return &ffi_type_sint8;
+
+      case FZL_TYPE_INT16:
+        return &ffi_type_sint16;
+
+      case FZL_TYPE_INT32:
+        return &ffi_type_sint32;
+
+      case FZL_TYPE_INT64:
+        return &ffi_type_sint64;
+
+      case FZL_TYPE_UINT8:
+      case FZL_TYPE_BOOL:
+        return &ffi_type_uint8;
+
+      case FZL_TYPE_UINT16:
+        return &ffi_type_uint16;
+
+      case FZL_TYPE_UINT32:
+        return &ffi_type_uint32;
+
+      case FZL_TYPE_UINT64:
+        return &ffi_type_uint64;
+
+      case FZL_TYPE_INT:
+        return &ffi_type_sint;
+
+      case FZL_TYPE_UINT:
+        return &ffi_type_uint;
+
+      case FZL_TYPE_CHAR:
+        return &ffi_type_schar;
+
+      case FZL_TYPE_STRING:
+      case FZL_TYPE_HANDLE:
+      case FZL_TYPE_STRUCT:
+        return &ffi_type_pointer;
+
+      default:
+        return &ffi_type_void;
+    }
+  }
+  else
+  {
+    fzl_extern_type_t *t = &reader->extern_types[ref->type_slot];
+    if (!t)
+      return &ffi_type_void;
+
+    switch (t->kind)
+    {
+      case FZL_EXTERN_KIND_STRUCT:
+      case FZL_EXTERN_KIND_HANDLE:
+      case FZL_EXTERN_KIND_REF:
+        return &ffi_type_pointer;
+
+      case FZL_EXTERN_KIND_ALIAS:
+        return resolve_type(reader, &t->alias_target);
+    }
+  }
+}
+
+// Preapre sym, put result in out and return operation result
+bool prepare_sym(fzl_vm_reader_t *reader, void *sym, fzl_extern_fn_t *fn,
+                 fzl_vm_sym_t *out)
+{
+  if (!reader || !fn || !sym || !out)
+  {
+    snprintf(ex_err, sizeof(ex_err),
+             "cannot prepare sym: function def, symbol handle or outvar is not "
+             "specified");
+    return false;
+  }
+  memset(out, 0, sizeof(fzl_vm_sym_t));
+
+  out->func_ptr  = sym;
+  out->arg_types = malloc(sizeof(ffi_type *) * fn->args_count);
+  if (!out->arg_types)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    return false;
+  }
+
+  memset(out->arg_types, 0, sizeof(ffi_type *) * fn->args_count);
+  for (size_t i = 0; i < fn->args_count; i++)
+  {
+    fzl_extern_arg_t *arg = &fn->args[i];
+    if (arg->is_out)
+      out->arg_types[i] = &ffi_type_pointer;
+    else
+      out->arg_types[i] = resolve_type(reader, &arg->type);
+  }
+
+  ffi_type *ret =
+      fn->has_return ? resolve_type(reader, &fn->ret_type) : &ffi_type_void;
+  ffi_status res = ffi_prep_cif(&out->cif, FFI_DEFAULT_ABI, fn->args_count, ret,
+                                out->arg_types);
+  if (res != FFI_OK)
+  {
+    snprintf(ex_err, sizeof(ex_err), "failed to prepare FFI");
+    return false;
+  }
+
+  return true;
+}
+
+fzl_vm_extern_t *fzl_vm_init_externs(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+  {
+    snprintf(ex_err, sizeof(ex_err), "reader is not provided");
+    return NULL;
+  }
+
+  fzl_vm_extern_t *ex = malloc(sizeof(fzl_vm_extern_t));
+  if (!ex)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    return NULL;
+  }
+
+  memset(ex, 0, sizeof(fzl_vm_extern_t));
+
+  if (reader->extern_libs_count < 1 || reader->extern_fns_count < 1)
+    return ex;
+
+  ex->libs = malloc(sizeof(void *) * reader->extern_libs_count);
+  if (!ex->libs)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+    free(ex);
+    return NULL;
+  }
+
+  memset(ex->libs, 0, sizeof(void *) * reader->extern_libs_count);
+  for (uint16_t i = 0; i < reader->extern_libs_count; i++)
+  {
+    void *lib = dlopen(reader->extern_libs[i], RTLD_NOW);
+    if (!lib)
+    {
+      snprintf(ex_err, sizeof(ex_err), "cannot open library '%s'",
+               reader->extern_libs[i]);
+
+      if (i > 0)
+      {
+        for (size_t j = 0; j < ex->libs_loaded; j++)
+          if (ex->libs[j])
+            dlclose(ex->libs[j]);
+      }
+
+      free(ex->libs);
+      free(ex);
+      return NULL;
+    }
+
+    ex->libs[ex->libs_loaded++] = lib;
+  }
+
+  ex->syms = malloc(sizeof(fzl_vm_sym_t) * reader->extern_fns_count);
+  if (!ex->syms)
+  {
+    snprintf(ex_err, sizeof(ex_err), "out of memory");
+
+    for (size_t i = 0; i < ex->libs_loaded; i++)
+      if (ex->libs[i])
+        dlclose(ex->libs[i]);
+
+    free(ex->libs);
+    free(ex);
+    return NULL;
+  }
+
+  memset(ex->syms, 0, sizeof(fzl_vm_sym_t) * reader->extern_fns_count);
+  for (uint16_t i = 0; i < reader->extern_fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &reader->extern_fns[i];
+    char *fnname = fn->symbol_name != NULL ? fn->symbol_name : fn->used_name;
+
+    void *sym = dlsym(ex->libs[fn->lib_slot], fnname);
+    if (!sym)
+    {
+      snprintf(ex_err, sizeof(ex_err), "couldn't find symbol '%s' in lib '%s'",
+               fnname, reader->extern_libs[fn->lib_slot]);
+
+      for (size_t j = 0; j < ex->libs_loaded; j++)
+        if (ex->libs[j])
+          dlclose(ex->libs[j]);
+
+      free(ex->libs);
+
+      for (size_t j = 0; j < ex->syms_loaded; j++)
+      {
+        if (ex->syms->arg_types)
+          free(ex->syms->arg_types);
+      }
+
+      free(ex->syms);
+      free(ex);
+      return NULL;
+    }
+
+    if (!prepare_sym(reader, sym, fn, &ex->syms[ex->syms_loaded++]))
+    {
+      if (!ex_err[0])
+      {
+        snprintf(ex_err, sizeof(ex_err),
+                 "failed to preapre FFI structure for sym '%s'", fnname);
+      }
+
+      for (size_t j = 0; j < ex->libs_loaded; j++)
+        if (ex->libs[j])
+          dlclose(ex->libs[j]);
+
+      free(ex->libs);
+      free(ex->syms);
+      free(ex);
+      return NULL;
+    }
+  }
+
+  return ex;
+}
+
+char *fzl_vm_externs_geterror() { return ex_err; }
+
+void fzl_vm_free_externs(fzl_vm_extern_t *ex)
+{
+  if (!ex)
+    return;
+
+  if (ex->libs)
+  {
+    for (size_t i = 0; i < ex->libs_loaded; i++)
+      if (ex->libs[i])
+        dlclose(ex->libs[i]);
+
+    free(ex->libs);
+  }
+
+  if (ex->syms)
+  {
+    for (size_t i = 0; i < ex->syms_loaded; i++)
+      free(ex->syms[i].arg_types);
+
+    free(ex->syms);
+  }
+
+  free(ex);
+}

src/vm/fzl_vm_reader.c

@@ -0,0 +1,194 @@
+#include <common/fzl_extern.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_reader.h>
+#include <vm/internals/reader.h>
+
+char reader_err[512];
+
+fzl_vm_reader_t *fzl_vm_mkreader(char *filepath)
+{
+  if (!filepath)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - filepath is not defined");
+    return NULL;
+  }
+
+  fzl_vm_reader_t *reader = malloc(sizeof(fzl_vm_reader_t));
+  if (!reader)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - couldn't allocate memory for reader");
+    return NULL;
+  }
+
+  memset(reader, 0, sizeof(fzl_vm_reader_t));
+  reader->filepath = filepath;
+
+  return reader;
+}
+
+void wr_validation_err(char *section)
+{
+  if (internal_error[0])
+    snprintf(reader_err, sizeof(reader_err), "init error - section '%s': %s",
+             section, internal_error);
+  else
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - section '%s' is not valid", section);
+}
+
+bool fzl_vm_read(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - reader is not provided");
+    return false;
+  }
+
+  FILE *fd = fopen(reader->filepath, "rb");
+  if (!fd)
+  {
+    snprintf(reader_err, sizeof(reader_err),
+             "init error - couldn't open file '%s'", reader->filepath);
+    return false;
+  }
+
+  bool result = vm_rd_header(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("header");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_sections_sz(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("sizes");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_consts(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("constants table");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_extern_libs(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("extern libs");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_extern_types(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("extern types");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_extern_fns(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("extern functions");
+    fclose(fd);
+    return false;
+  }
+
+  result = vm_rd_ops(reader, fd);
+  if (!result)
+  {
+    wr_validation_err("opcodes");
+    fclose(fd);
+    return false;
+  }
+
+  fclose(fd);
+
+  return true;
+}
+
+char *fzl_vm_getreadererror() { return reader_err; }
+
+void fzl_vm_freereader(fzl_vm_reader_t *reader)
+{
+  if (!reader)
+    return;
+
+  if (reader->consts)
+  {
+    for (uint16_t i = 0; i < reader->consts_count; i++)
+      if (reader->consts[i].as.s.value)
+        free((void *)reader->consts[i].as.s.value);
+
+    free(reader->consts);
+  }
+
+  if (reader->extern_libs)
+  {
+    for (uint16_t i = 0; i < reader->extern_libs_count; i++)
+      free(reader->extern_libs[i]);
+
+    free(reader->extern_libs);
+  }
+
+  if (reader->extern_types)
+  {
+    for (uint16_t i = 0; i < reader->extern_types_count; i++)
+    {
+      free(reader->extern_types[i].name);
+
+      if (reader->extern_types[i].kind == FZL_EXTERN_KIND_STRUCT)
+      {
+        fzl_extern_struct_field_t *fields =
+            reader->extern_types[i].structure.fields;
+        for (uint16_t j = 0; j < reader->extern_types[i].structure.fields_count;
+             j++)
+        {
+          if (fields[j].name)
+            free(fields[j].name);
+        }
+
+        free(fields);
+      }
+    }
+
+    free(reader->extern_types);
+  }
+
+  if (reader->extern_fns)
+  {
+    for (uint16_t i = 0; i < reader->extern_fns_count; i++)
+    {
+      fzl_extern_fn_t *fn = &reader->extern_fns[i];
+      if (fn->used_name)
+        free(fn->used_name);
+
+      if (fn->symbol_name)
+        free(fn->symbol_name);
+
+      if (fn->args_count > 0)
+        free(fn->args);
+    }
+
+    free(reader->extern_fns);
+  }
+
+  if (reader->ops)
+    free(reader->ops);
+
+  free(reader);
+}

src/vm/handlers/group_and_or.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_cmp.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_ctx.c

@@ -132,8 +132,8 @@ int op_write(fzl_vm_t *vm)
 
 int op_load_local(fzl_vm_t *vm)
 {
-  size_t depth = vm->ops[++vm->ip];
-  size_t slot  = vm->ops[++vm->ip];
+  size_t depth = vm->reader->ops[++vm->ip];
+  size_t slot  = vm->reader->ops[++vm->ip];
 
   if (depth >= vm->etop)
   {
@@ -168,8 +168,8 @@ int op_store_local(fzl_vm_t *vm)
 
   fzl_value_t value = vm->dstack[--vm->dtop];
 
-  size_t depth = vm->ops[++vm->ip];
-  size_t slot  = vm->ops[++vm->ip];
+  size_t depth = vm->reader->ops[++vm->ip];
+  size_t slot  = vm->reader->ops[++vm->ip];
 
   if (depth >= vm->etop)
   {

src/vm/handlers/group_flow.c

@@ -1,16 +1,17 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 
 // Jump at specified address
 int op_jmp(fzl_vm_t *vm)
 {
-  if (vm->ops_count <= vm->ip)
+  if (vm->reader->ops_count <= vm->ip)
   {
     snprintf(last_err, sizeof(last_err), "runtime error - expected JMP addr");
     return -1;
   }
 
-  uint64_t jmp_ip = vm->ops[++vm->ip];
+  uint64_t jmp_ip = vm->reader->ops[++vm->ip];
   if (!vm->allow_infinite)
   {
     if (jmp_ip == last_jmp_ip)
@@ -46,7 +47,7 @@ int op_jz(fzl_vm_t *vm)
   }
 
   fzl_value_t jzval = vm->dstack[--vm->dtop];
-  uint64_t jzip     = vm->ops[++vm->ip] - 1;
+  uint64_t jzip     = vm->reader->ops[++vm->ip] - 1;
   if (jzval.as.b == 0)
     vm->ip = jzip;
 

src/vm/handlers/group_fn.c

@@ -1,10 +1,14 @@
+#include <common/fzl_value.h>
+#include <stddef.h>
+#include <stdio.h>
 #include <vm/fzl_vm.h>
+#include <vm/fzl_vm_extern.h>
 #include <vm/internals/opcode.h>
 
 // Call function (store return address and jump into function init)
 int op_call(fzl_vm_t *vm)
 {
-  uint64_t ip            = vm->ops[++vm->ip];
+  uint64_t ip            = vm->reader->ops[++vm->ip];
   vm->cstack[vm->ctop++] = vm->ip;
   vm->ip                 = ip - 1;
   return 0;
@@ -27,7 +31,31 @@ int op_ret(fzl_vm_t *vm)
 // Call externally defined function
 int op_call_extern(fzl_vm_t *vm)
 {
-  (void)vm;
-  // TODO: implement
+  size_t fn_n = vm->reader->ops[++vm->ip];
+  if (fn_n >= vm->reader->extern_fns_count)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - unknown external function");
+    print_err_data(vm);
+    return -1;
+  }
+
+  fzl_vm_sym_t *fn = &vm->prep_fns->syms[fn_n];
+  if (!fn)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - failed to load extern function");
+    print_err_data(vm);
+    return -1;
+  }
+
+  if (vm->dtop < fn->cif.nargs)
+  {
+    snprintf(last_err, sizeof(last_err),
+             "runtime error - expected %u valued on dstack", fn->cif.nargs);
+    print_err_data(vm);
+    return -1;
+  }
+
   return 0;
 }

src/vm/handlers/group_math.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_not.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_obj.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
@@ -57,7 +58,7 @@ void escape_recursive(fzl_vm_env_t *current, fzl_vm_env_t *parent,
 // Allocate specified count of fields and create object
 int op_alloc_object(fzl_vm_t *vm)
 {
-  uint64_t values_count = vm->ops[++vm->ip];
+  uint64_t values_count = vm->reader->ops[++vm->ip];
   fzl_vm_object_t *obj  = malloc(sizeof(fzl_vm_object_t));
 
   if (values_count < 1)
@@ -94,7 +95,7 @@ int op_get_field(fzl_vm_t *vm)
     return -1;
   }
 
-  uint64_t field_slot = vm->ops[++vm->ip];
+  uint64_t field_slot = vm->reader->ops[++vm->ip];
   fzl_value_t val     = vm->dstack[--vm->dtop];
   if (val.type != FZL_TYPE_OBJECT)
   {
@@ -130,7 +131,7 @@ int op_set_field(fzl_vm_t *vm)
     return -1;
   }
 
-  uint64_t field_slot = vm->ops[++vm->ip];
+  uint64_t field_slot = vm->reader->ops[++vm->ip];
   fzl_value_t objval  = vm->dstack[--vm->dtop];
   fzl_value_t wrval   = vm->dstack[--vm->dtop];
   if (objval.type != FZL_TYPE_OBJECT)

src/vm/handlers/group_objcmp.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 

src/vm/handlers/group_stack.c

@@ -1,21 +1,20 @@
 #include <common/fzl_builtins.h>
+#include <common/fzl_value.h>
+#include <stdio.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>
 
 // Load constant onto stack
 int op_loadconst(fzl_vm_t *vm)
 {
-  uint64_t cn = vm->ops[++vm->ip];
-  if (vm->consts_count <= cn)
+  uint64_t cn = vm->reader->ops[++vm->ip];
+  if (vm->reader->consts_count <= cn)
   {
     snprintf(last_err, sizeof(last_err), "runtime error - unknown const");
     print_err_data(vm);
     return -1;
   }
-  fzl_const_t c          = vm->consts[cn];
-  vm->dstack[vm->dtop++] = (fzl_value_t){.type        = FZL_TYPE_STRING,
-                                         .as.s.length = c.as.string.length,
-                                         .as.s.value  = c.as.string.chars};
+  vm->dstack[vm->dtop++] = vm->reader->consts[cn];
 
   return 0;
 }
@@ -23,7 +22,7 @@ int op_loadconst(fzl_vm_t *vm)
 // Call builtin function
 int op_call_builtin(fzl_vm_t *vm)
 {
-  uint64_t fn_id = vm->ops[++vm->ip];
+  uint64_t fn_id = vm->reader->ops[++vm->ip];
   if (fn_id == FZL_BUILTIN_PRINTLINE)
   {
     fzl_value_t arg = vm->dstack[--vm->dtop];
@@ -64,7 +63,7 @@ int op_call_builtin(fzl_vm_t *vm)
 // Push number onto stack
 int op_pushnum(fzl_vm_t *vm)
 {
-  uint64_t push_n        = vm->ops[++vm->ip];
+  uint64_t push_n        = vm->reader->ops[++vm->ip];
   vm->dstack[vm->dtop++] = (fzl_value_t){.type = FZL_TYPE_UINT, .as.u = push_n};
   return 0;
 }
@@ -72,7 +71,7 @@ int op_pushnum(fzl_vm_t *vm)
 // Push boolean onto stack
 int op_pushbool(fzl_vm_t *vm)
 {
-  uint64_t push_b        = vm->ops[++vm->ip];
+  uint64_t push_b        = vm->reader->ops[++vm->ip];
   vm->dstack[vm->dtop++] = (fzl_value_t){.type = FZL_TYPE_BOOL, .as.b = push_b};
   return 0;
 }

src/vm/handlers/group_str.c

@@ -1,3 +1,5 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
 #include <stdio.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
@@ -8,7 +10,7 @@ char build_result[512];
 // Build string from specified count using stack values
 int op_build_str(fzl_vm_t *vm)
 {
-  uint64_t n = vm->ops[++vm->ip];
+  uint64_t n = vm->reader->ops[++vm->ip];
   if (vm->dtop < n)
   {
     snprintf(last_err, sizeof(last_err),
@@ -34,6 +36,19 @@ int op_build_str(fzl_vm_t *vm)
 
     switch (val.type)
     {
+      case FZL_TYPE_HANDLE:
+        snprintf(temp, sizeof(temp), "pointer<%p>", val.as.obj);
+        strcpy(build_result + gi, temp);
+        gi += strlen(temp);
+        break;
+
+      case FZL_TYPE_STRUCT:
+        snprintf(temp, sizeof(temp), "field(values: %zu)",
+                 ((fzl_extern_type_t *)val.as.obj)->structure.fields_count);
+        strcpy(build_result + gi, temp);
+        gi += strlen(temp);
+        break;
+
       case FZL_TYPE_UINT:
         snprintf(temp, sizeof(temp), "%zu", val.as.u);
         strcpy(build_result + gi, temp);

src/vm/handlers/group_strcmp.c

@@ -1,3 +1,4 @@
+#include <stdio.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
 #include <vm/internals/opcode.h>

src/vm/main.c

@@ -6,6 +6,8 @@
 #include <stdlib.h>
 #include <string.h>
 #include <vm/fzl_vm.h>
+#include <vm/fzl_vm_extern.h>
+#include <vm/fzl_vm_reader.h>
 
 typedef struct
 {
@@ -113,14 +115,44 @@ int main(int argc, char **argv)
     return 0;
   }
 
-  fzl_vm_t *vm = fzl_mkvm(args->filepath);
+  fzl_vm_reader_t *reader = fzl_vm_mkreader(args->filepath);
+  if (!reader)
+  {
+    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_vm_getreadererror());
+    free(args);
+    return -1;
+  }
+
+  bool result = fzl_vm_read(reader);
+  if (!result)
+  {
+    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_vm_getreadererror());
+    fzl_vm_freereader(reader);
+    free(args);
+    return -1;
+  }
+
+  fzl_vm_t *vm = fzl_mkvm(reader);
   if (!vm)
   {
     printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_vm_geterror());
+    fzl_vm_freereader(reader);
     free(args);
     return -1;
   }
 
+  vm->prep_fns = fzl_vm_init_externs(reader);
+  if (!vm->prep_fns)
+  {
+    printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, fzl_vm_externs_geterror());
+
+    free(args);
+    fzl_vm_free_externs(vm->prep_fns);
+    fzl_vm_freereader(reader);
+    fzl_freevm(vm);
+    return -1;
+  }
+
   vm->allow_infinite = args->allow_infinite;
   vm->max_iter       = args->max_iter;
 
@@ -136,12 +168,16 @@ int main(int argc, char **argv)
         printf("%sError%s: %s\n", FZL_CERROR, FZL_CRST, err);
 
       free(args);
+      fzl_vm_free_externs(vm->prep_fns);
+      fzl_vm_freereader(reader);
       fzl_freevm(vm);
       return -1;
     }
   }
 
   free(args);
+  fzl_vm_free_externs(vm->prep_fns);
+  fzl_vm_freereader(reader);
   fzl_freevm(vm);
 
   return 0;

src/vm/reader/utility.c

@@ -0,0 +1,32 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <vm/internals/reader.h>
+
+// Read characters with red bytes check
+bool vm_rd_char(FILE *fd, size_t count, char *o)
+{
+  if (!fd || !o)
+    return false;
+
+  return fread(o, sizeof(char), count, fd) == count;
+}
+
+// Read 16-byte uints with red bytes check
+bool vm_rd_u16(FILE *fd, size_t count, uint16_t *o)
+{
+  if (!fd || !o)
+    return false;
+
+  return fread(o, sizeof(uint16_t), count, fd) == count;
+}
+
+// Read machine word-size uints with red bytes check
+bool vm_rd_word(FILE *fd, size_t count, size_t *o)
+{
+  if (!fd || !o)
+    return false;
+
+  return fread(o, sizeof(size_t), count, fd) == count;
+}

src/vm/reader/vm_rd_consts.c

@@ -0,0 +1,69 @@
+#include <common/fzl_types.h>
+#include <common/fzl_value.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/internals/reader.h>
+
+// Read constants table
+bool vm_rd_consts(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  size_t consts_count = reader->consts_count;
+  if (!consts_count)
+    return true;
+
+  reader->consts = malloc(sizeof(fzl_value_t) * consts_count);
+  if (!reader->consts)
+  {
+    snprintf(internal_error, sizeof(internal_error), "out of memory");
+    return false;
+  }
+
+  memset(reader->consts, 0, sizeof(fzl_value_t) * consts_count);
+
+  bool ok = false;
+  uint16_t const_size;
+  char contents[512];
+  for (uint16_t i = 0; i < reader->consts_count; i++)
+  {
+    memset(contents, 0, sizeof(contents));
+
+    ok = vm_rd_u16(fd, 1, &const_size);
+    if (!ok)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read size of const #%u", i);
+      return false;
+    }
+
+    ok = vm_rd_char(fd, const_size, contents);
+    if (!ok)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read const #%u", i);
+      return false;
+    }
+
+    char *val = malloc(sizeof(char) * const_size + 1);
+    if (!val)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "out of memory on const #%u allocation", i);
+      return false;
+    }
+
+    memset(val, 0, sizeof(char) * const_size + 1);
+    memcpy(val, contents, sizeof(char) * const_size);
+
+    reader->consts[i] = (fzl_value_t){
+        .type = FZL_TYPE_STRING, .as.s.value = val, .as.s.length = const_size};
+  }
+
+  return true;
+}

src/vm/reader/vm_rd_extern_fns.c

@@ -0,0 +1,234 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_reader.h>
+#include <vm/internals/reader.h>
+
+// Read external functions definitions
+bool vm_rd_extern_fns(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  uint16_t fns_count = reader->extern_fns_count;
+  if (!fns_count)
+    return true;
+
+  reader->extern_fns = malloc(sizeof(fzl_extern_fn_t) * fns_count);
+  if (!reader->extern_fns)
+  {
+    snprintf(internal_error, sizeof(internal_error), "out of memory");
+    return false;
+  }
+
+  memset(reader->extern_fns, 0, sizeof(fzl_extern_fn_t) * fns_count);
+
+  for (uint16_t i = 0; i < fns_count; i++)
+  {
+    fzl_extern_fn_t *fn = &reader->extern_fns[i];
+
+    uint16_t lib_slot;
+    if (!vm_rd_u16(fd, 1, &lib_slot))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read fn #%u lib slot", i);
+      return false;
+    }
+
+    fn->lib_slot = lib_slot;
+
+    uint16_t used_name_sz;
+    if (!vm_rd_u16(fd, 1, &used_name_sz))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read fn #%u used name size", i);
+      return false;
+    }
+
+    char used_name_buf[256];
+    memset(used_name_buf, 0, sizeof(used_name_buf));
+    if (!vm_rd_char(fd, used_name_sz, used_name_buf))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read fn #%u used name", i);
+      return false;
+    }
+
+    char *val = malloc(sizeof(char) * used_name_sz + 1);
+    if (!val)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "out of memory on fn #%u used name allocation", i);
+      return false;
+    }
+
+    memset(val, 0, sizeof(char) * used_name_sz + 1);
+    memcpy(val, used_name_buf, sizeof(char) * used_name_sz);
+    fn->used_name = val;
+
+    char has_symbol_name;
+    if (!vm_rd_char(fd, 1, &has_symbol_name))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read fn #%u symbol name existing flag", i);
+      return false;
+    }
+
+    if ((bool)has_symbol_name)
+    {
+      if (!vm_rd_u16(fd, 1, &used_name_sz))
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "failed to read fn #%u symbol name size", i);
+        return false;
+      }
+
+      if (!vm_rd_char(fd, used_name_sz, used_name_buf))
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "failed to read fn #%u symbol name", i);
+        return false;
+      }
+
+      char *symval = malloc(sizeof(char) * used_name_sz + 1);
+      if (!symval)
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "out of memory on fn #%u symbol name allocation", i);
+        return false;
+      }
+
+      memset(symval, 0, sizeof(char) * used_name_sz + 1);
+      memcpy(symval, used_name_buf, sizeof(char) * used_name_sz);
+      fn->symbol_name = symval;
+    }
+
+    char has_return;
+    if (!vm_rd_char(fd, 1, &has_return))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read fn #%u return existing flag", i);
+      return false;
+    }
+
+    fn->has_return = (bool)has_return;
+    if ((bool)has_return)
+    {
+      char is_primitive;
+      if (!vm_rd_char(fd, 1, &is_primitive))
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "failed to read fn #%u return type primitivity flag", i);
+        return false;
+      }
+
+      fn->ret_type.is_primitive = (bool)is_primitive;
+
+      if (is_primitive)
+      {
+        char primitive;
+        if (!vm_rd_char(fd, 1, &primitive))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read fn #%u return primitive", i);
+          return false;
+        }
+
+        fn->ret_type.primitive = (fzl_type_t)primitive;
+      }
+      else
+      {
+        uint16_t type_slot;
+        if (!vm_rd_u16(fd, 1, &type_slot))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read fn #%u return type slot", i);
+          return false;
+        }
+
+        fn->ret_type.type_slot = (size_t)type_slot;
+      }
+    }
+
+    uint16_t args_count;
+    if (!vm_rd_u16(fd, 1, &args_count))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read fn #%u arguments count", i);
+      return false;
+    }
+
+    fn->args_count = (size_t)args_count;
+    if (args_count > 0)
+    {
+      fzl_extern_arg_t *args = malloc(sizeof(fzl_extern_arg_t) * args_count);
+      if (!args)
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "out of memory on fn #%u arguments array allocation", i);
+        return false;
+      }
+
+      memset(args, 0, sizeof(fzl_extern_arg_t) * args_count);
+      fn->args = args;
+
+      for (uint16_t j = 0; j < args_count; j++)
+      {
+        fzl_extern_arg_t *arg = &args[j];
+
+        char arg_is_out;
+        if (!vm_rd_char(fd, 1, &arg_is_out))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read fn #%u arg #%u out flag", i, j);
+          return false;
+        }
+
+        arg->is_out = (bool)arg_is_out;
+
+        char arg_is_primitive;
+        if (!vm_rd_char(fd, 1, &arg_is_primitive))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read fn #%u arg #%u return type primitivity flag",
+                   i, j);
+          return false;
+        }
+
+        arg->type.is_primitive = (bool)arg_is_primitive;
+
+        if (arg_is_primitive)
+        {
+          char primitive;
+          if (!vm_rd_char(fd, 1, &primitive))
+          {
+            snprintf(internal_error, sizeof(internal_error),
+                     "failed to read fn #%u #%u return primitive", i, j);
+            return false;
+          }
+
+          arg->type.primitive = (fzl_type_t)primitive;
+        }
+        else
+        {
+          uint16_t type_slot;
+          if (!vm_rd_u16(fd, 1, &type_slot))
+          {
+            snprintf(internal_error, sizeof(internal_error),
+                     "failed to read fn #%u #%u return type slot", i, j);
+            return false;
+          }
+
+          arg->type.type_slot = (size_t)type_slot;
+        }
+      }
+    }
+  }
+
+  return true;
+}

src/vm/reader/vm_rd_extern_libs.c

@@ -0,0 +1,66 @@
+#include <common/fzl_extern.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/internals/reader.h>
+
+// Read external lib names
+bool vm_rd_extern_libs(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  uint16_t libs_count = reader->extern_libs_count;
+  if (!libs_count)
+    return true;
+
+  reader->extern_libs = malloc(sizeof(char *) * libs_count);
+  if (!reader->extern_libs)
+  {
+    snprintf(internal_error, sizeof(internal_error), "out of memory");
+    return false;
+  }
+
+  memset(reader->extern_libs, 0, sizeof(char *) * libs_count);
+
+  bool ok        = false;
+  size_t name_sz = 0;
+  char name[256];
+  for (uint16_t i = 0; i < libs_count; i++)
+  {
+    memset(name, 0, sizeof(name));
+
+    ok = vm_rd_word(fd, 1, &name_sz);
+    if (!ok || name_sz < 1)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read lib #%u name size", i);
+      return false;
+    }
+
+    ok = vm_rd_char(fd, name_sz, name);
+    if (!ok)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read lib #%u name", i);
+      return false;
+    }
+
+    char *val = malloc(sizeof(char) * name_sz + 1);
+    if (!val)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "out of memory on lib #%u name allocation", i);
+      return false;
+    }
+
+    memset(val, 0, sizeof(char) * name_sz + 1);
+    memcpy(val, name, sizeof(char) * name_sz);
+    reader->extern_libs[i] = val;
+  }
+
+  return true;
+}

src/vm/reader/vm_rd_extern_types.c

@@ -0,0 +1,240 @@
+#include <common/fzl_extern.h>
+#include <common/fzl_types.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <vm/fzl_vm_reader.h>
+#include <vm/internals/reader.h>
+
+// Read external types
+bool vm_rd_extern_types(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  uint16_t types_count = reader->extern_types_count;
+  if (!types_count)
+    return true;
+
+  reader->extern_types = malloc(sizeof(fzl_extern_type_t) * types_count);
+  if (!reader->extern_types)
+  {
+    snprintf(internal_error, sizeof(internal_error), "out of memory");
+    return false;
+  }
+
+  memset(reader->extern_types, 0, sizeof(fzl_extern_type_t) * types_count);
+
+  char namebuf[256];
+  for (uint16_t i = 0; i < types_count; i++)
+  {
+    fzl_extern_type_t *type = &reader->extern_types[i];
+
+    uint16_t lib_slot;
+    if (!vm_rd_u16(fd, 1, &lib_slot))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read lib slot of type #%u", i);
+      return false;
+    }
+
+    type->lib_slot = lib_slot;
+
+    char kind;
+    if (!vm_rd_char(fd, 1, &kind))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read type #%u kind", i);
+      return false;
+    }
+
+    type->kind = (fzl_extern_kind_t)kind;
+
+    uint16_t name_sz;
+    if (!vm_rd_u16(fd, 1, &name_sz) || name_sz < 1)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read type #%u name size", i);
+      return false;
+    }
+
+    if (!vm_rd_char(fd, name_sz, namebuf))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read type #%u name", i);
+      return false;
+    }
+
+    char *val = malloc(sizeof(char) * name_sz + 1);
+    if (!val)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "out of memory on type #%u name allocation", i);
+      return false;
+    }
+
+    type->name = val;
+
+    memset(val, 0, sizeof(char) * name_sz + 1);
+    memcpy(val, namebuf, sizeof(char) * name_sz);
+
+    if (type->kind == FZL_EXTERN_KIND_HANDLE)
+      continue;
+
+    if (type->kind == FZL_EXTERN_KIND_ALIAS ||
+        type->kind == FZL_EXTERN_KIND_REF)
+    {
+      fzl_extern_type_ref_t *typeref = type->kind == FZL_EXTERN_KIND_ALIAS
+                                           ? &type->alias_target
+                                           : &type->ref_target;
+
+      char is_primitive;
+      if (!vm_rd_char(fd, 1, &is_primitive))
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "failed to read type #%u primitivity flag", i);
+        return false;
+      }
+
+      typeref->is_primitive = (bool)is_primitive;
+
+      if ((bool)is_primitive)
+      {
+        char primitive;
+        if (!vm_rd_char(fd, 1, &primitive))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read type #%u primitive", i);
+          return false;
+        }
+
+        typeref->primitive = (fzl_type_t)primitive;
+      }
+      else
+      {
+        uint16_t slot;
+        if (!vm_rd_u16(fd, 1, &slot))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read type #%u slot index", i);
+          return false;
+        }
+
+        typeref->type_slot = slot;
+      }
+
+      continue;
+    }
+
+    if (type->kind != FZL_EXTERN_KIND_STRUCT)
+    {
+      snprintf(internal_error, sizeof(internal_error), "unknown type #%u kind",
+               i);
+      return false;
+    }
+
+    uint16_t fields_count;
+    if (!vm_rd_u16(fd, 1, &fields_count))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read type #%u structure fields count", i);
+      return false;
+    }
+
+    fzl_extern_struct_field_t *fields =
+        malloc(sizeof(fzl_extern_struct_field_t) * fields_count);
+    if (!fields)
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "out of memory on type #%u structure fields allocation", i);
+      return false;
+    }
+
+    memset(fields, 0, sizeof(fzl_extern_struct_field_t) * fields_count);
+    type->structure.fields       = fields;
+    type->structure.fields_count = fields_count;
+
+    for (uint16_t j = 0; j < fields_count; j++)
+    {
+      fzl_extern_struct_field_t *f = &fields[j];
+
+      char has_name;
+      if (!vm_rd_char(fd, 1, &has_name))
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "failed to read type #%u field #%u name exists flag", i, j);
+        return false;
+      }
+
+      if (has_name)
+      {
+        memset(namebuf, 0, sizeof(namebuf));
+        if (!vm_rd_u16(fd, 1, &name_sz))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read type #%u field #%u name size", i, j);
+          return false;
+        }
+
+        if (!vm_rd_char(fd, name_sz, namebuf))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read type #%u field #%u name", i, j);
+          return false;
+        }
+
+        char *fval = malloc(sizeof(char) * name_sz + 1);
+        if (!fval)
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "out of memory on type #%u field #%u name allocation", i, j);
+          return false;
+        }
+
+        memset(fval, 0, sizeof(char) * name_sz + 1);
+        memcpy(fval, namebuf, sizeof(char) * name_sz);
+
+        f->name = fval;
+      }
+
+      char is_primitive;
+      if (!vm_rd_char(fd, 1, &is_primitive))
+      {
+        snprintf(internal_error, sizeof(internal_error),
+                 "failed to read type #%u flag #%u primitivity flag", i, j);
+        return false;
+      }
+
+      f->type.is_primitive = (bool)is_primitive;
+
+      if (f->type.is_primitive)
+      {
+        char ftype;
+        if (!vm_rd_char(fd, 1, &ftype))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read type #%u field #%u primitive", i, j);
+          return false;
+        }
+
+        f->type.primitive = (fzl_type_t)ftype;
+      }
+      else
+      {
+        uint16_t fslot;
+        if (!vm_rd_u16(fd, 1, &fslot))
+        {
+          snprintf(internal_error, sizeof(internal_error),
+                   "failed to read type #%u field #%u slot index", i, j);
+          return false;
+        }
+
+        f->type.type_slot = fslot;
+      }
+    }
+  }
+
+  return true;
+}

src/vm/reader/vm_rd_header.c

@@ -0,0 +1,23 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <string.h>
+#include <vm/internals/reader.h>
+
+size_t hdr_size = 5;
+char hdr[5]     = {'F', 'Z', 'L', 0, 2};
+
+// Reader file header
+bool vm_rd_header(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  char chkbuf[5];
+  if (!vm_rd_char(fd, 5, chkbuf))
+    return false;
+
+  if (memcmp(chkbuf, hdr, hdr_size) != 0)
+    return false;
+
+  return true;
+}

src/vm/reader/vm_rd_ops.c

@@ -0,0 +1,38 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <vm/internals/reader.h>
+
+// Read opcodes
+bool vm_rd_ops(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  size_t ops_count = reader->ops_count;
+  if (!ops_count)
+    return false;
+
+  reader->ops = malloc(sizeof(size_t) * ops_count);
+  if (!reader->ops)
+  {
+    snprintf(internal_error, sizeof(internal_error), "out of memory");
+    return false;
+  }
+
+  for (size_t i = 0; i < ops_count; i++)
+  {
+    size_t opcode = 0;
+    if (!vm_rd_word(fd, 1, &opcode))
+    {
+      snprintf(internal_error, sizeof(internal_error),
+               "failed to read opcode #%zu", i);
+      return false;
+    }
+
+    reader->ops[i] = opcode;
+  }
+
+  return true;
+}

src/vm/reader/vm_rd_sections_sz.c

@@ -0,0 +1,46 @@
+#include <vm/internals/reader.h>
+#include <wchar.h>
+
+// Reader sizes section
+bool vm_rd_sections_sz(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  if (!vm_rd_u16(fd, 1, &reader->consts_count))
+  {
+    snprintf(internal_error, sizeof(internal_error),
+             "failed to read constants table size");
+    return false;
+  }
+
+  if (!vm_rd_u16(fd, 1, &reader->extern_libs_count))
+  {
+    snprintf(internal_error, sizeof(internal_error),
+             "failed to read external libs count");
+    return false;
+  }
+
+  if (!vm_rd_u16(fd, 1, &reader->extern_types_count))
+  {
+    snprintf(internal_error, sizeof(internal_error),
+             "failed to read external types count");
+    return false;
+  }
+
+  if (!vm_rd_u16(fd, 1, &reader->extern_fns_count))
+  {
+    snprintf(internal_error, sizeof(internal_error),
+             "failed to read external functions count");
+    return false;
+  }
+
+  if (!vm_rd_word(fd, 1, &reader->ops_count))
+  {
+    snprintf(internal_error, sizeof(internal_error),
+             "failed to read opcodes count");
+    return false;
+  }
+
+  return true;
+}

tests/libs/math.c

@@ -0,0 +1 @@
+int double_num(int num) { return num * 2; }

tests/programs/negr_missing_lib.fzs

@@ -0,0 +1,10 @@
+extern "jopalib"
+{
+  type JopaLibType handle;
+
+  fn jopalib(int a, str b) JopaLibType;
+}
+
+JopaLibType a = jopalib(42, "jopa");
+printline(a);
+

tests/programs/pos_math_lib.fzs

@@ -0,0 +1,8 @@
+extern "libmath" {
+  fn double_num(int num) int;
+}
+
+int initial = 42;
+int result = double_num(initial);
+printline($"initial value: {initial}, result of external function: {result}");
+

tests/programs/pos_renamed_lib.fzs

@@ -0,0 +1,8 @@
+extern "math" {
+  fn dnum(int num) int = "double_num";
+}
+
+int initial = 42;
+int result = dnum(initial);
+printline($"initial value: {initial}, result of external function: {result}");
+