wip: working on extern in VM

- Feat: add writer externs writing fns
- Feat: add VM reader functions

CMakeLists.txt

@@ -159,6 +159,13 @@ 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_sections_sz.c
 		src/vm/fzl_vm.c
 		src/vm/fzl_vm_env.c
 		src/vm/fzl_vm_debug.c
@@ -186,6 +193,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/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/reader.h

@@ -0,0 +1,22 @@
+#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>
+
+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/fzl_writer.c

@@ -40,10 +40,10 @@ int fzl_write(fzl_writer_t *writer, fzl_gen_t *gen)
 
   const char hdr[5] = {'F', 'Z', 'L', 0x0, 0x2};
   fwrite(hdr, sizeof(char), 5, fd);
-  fwrite(&gen->consts->size, sizeof(size_t), 1, fd);
-  fwrite(&gen->extern_libs_count, sizeof(size_t), 1, fd);
-  fwrite(&gen->extern_types_count, sizeof(size_t), 1, fd);
-  fwrite(&gen->extern_fns_count, sizeof(size_t), 1, 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);
 
   bool result = wr_consts(fd, gen->consts);

src/compiler/writer/wr_consts.c

@@ -11,14 +11,9 @@ bool wr_consts(FILE *fd, fzl_const_hash_pool_t *consts)
   for (size_t i = 0; i < consts->size; i++)
   {
     fzl_const_t c = consts->array[i];
-    fwrite(&c.type, sizeof(fzl_consttype_t), 1, fd);
-
-    if (c.type == FZL_CONSTTYPE_STRING)
-    {
-      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);
-    }
+    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

@@ -32,6 +32,7 @@ bool wr_extern_fns(FILE *fd, fzl_extern_fn_t *fns, size_t fns_count)
   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;

src/compiler/writer/wr_extern_types.c

@@ -46,9 +46,10 @@ bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count)
   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);
 
-    size_t name_sz = strlen(type->name);
+    uint16_t name_sz = strlen(type->name);
     fwrite(&name_sz, sizeof(uint16_t), 1, fd);
     fwrite(type->name, sizeof(char), name_sz, fd);
 
@@ -57,8 +58,7 @@ bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count)
       if (!write_struct(fd, type))
         return false;
     }
-    else if (type->kind == FZL_EXTERN_KIND_REF ||
-             type->kind == FZL_EXTERN_KIND_ALIAS)
+    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)
@@ -66,6 +66,14 @@ bool wr_extern_types(FILE *fd, fzl_extern_type_t *types, size_t types_count)
       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/vm/fzl_vm.c

@@ -18,7 +18,7 @@ char last_err[256];
 size_t last_jmp_ip       = 0;
 size_t total_jmp_on_same = 0;
 
-static char *expect_hdr = "FZL\0\1";
+static char *expect_hdr = "FZL\0\2";
 
 fzl_vm_t *fzl_mkvm(const char *filepath)
 {

src/vm/fzl_vm_reader.c

@@ -0,0 +1,147 @@
+#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[256];
+
+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)
+{
+  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;
+  }
+
+  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)
+    free(reader->extern_libs);
+
+  if (reader->extern_types)
+    free(reader->extern_types);
+
+  if (reader->extern_fns)
+    free(reader->extern_fns);
+
+  if (reader->ops)
+    free(reader->ops);
+
+  free(reader);
+}

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) == (sizeof(char) * 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) == (sizeof(uint16_t) * 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) == (sizeof(size_t) * count);
+}

src/vm/reader/vm_rd_consts.c

@@ -0,0 +1,52 @@
+#include <common/fzl_types.h>
+#include <common/fzl_value.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.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)
+    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 || const_size < 1)
+      return false;
+
+    ok = vm_rd_char(fd, const_size, contents);
+    if (!ok)
+      return false;
+
+    char *val = malloc(sizeof(char) * const_size);
+    if (!val)
+      return false;
+
+    memset(val, 0, sizeof(char) * const_size);
+    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,20 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.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;
+
+  // TODO: fuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuck
+
+  return true;
+}

src/vm/reader/vm_rd_extern_libs.c

@@ -0,0 +1,49 @@
+#include <common/fzl_extern.h>
+#include <stdbool.h>
+#include <stdint.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)
+    return false;
+
+  memset(reader->extern_libs, 0, sizeof(char *) * libs_count);
+
+  bool ok          = false;
+  uint16_t name_sz = 0;
+  char name[256];
+  for (uint16_t i = 0; i < libs_count; i++)
+  {
+    memset(name, 0, sizeof(name));
+
+    ok = vm_rd_u16(fd, 1, &name_sz);
+    if (!ok || name_sz < 1)
+      return false;
+
+    ok = vm_rd_char(fd, name_sz, name);
+    if (!ok)
+      return false;
+
+    char *val = malloc(sizeof(char) * name_sz);
+    if (!val)
+      return false;
+
+    memset(val, 0, sizeof(char) * name_sz);
+    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,156 @@
+#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)
+    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))
+      return false;
+    type->lib_slot = lib_slot;
+
+    char kind;
+    if (!vm_rd_char(fd, 1, &kind))
+      return false;
+    type->kind = (fzl_extern_kind_t)kind;
+
+    uint16_t name_sz;
+    if (!vm_rd_u16(fd, 1, &name_sz) || name_sz < 1)
+      return false;
+
+    if (!vm_rd_char(fd, name_sz, namebuf))
+      return false;
+
+    char *val = malloc(sizeof(char) * name_sz);
+    if (!val)
+      return false;
+    type->name = val;
+
+    memset(val, 0, sizeof(char) * name_sz);
+    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))
+        return false;
+      typeref->is_primitive = (bool)is_primitive;
+
+      if ((bool)is_primitive)
+      {
+        char primitive;
+        if (!vm_rd_char(fd, 1, &primitive))
+          return false;
+        typeref->primitive = (fzl_type_t)primitive;
+      }
+      else
+      {
+        uint16_t slot;
+        if (!vm_rd_u16(fd, 1, &slot))
+          return false;
+        typeref->type_slot = slot;
+      }
+
+      continue;
+    }
+
+    if (type->kind != FZL_EXTERN_KIND_STRUCT)
+      return false;
+
+    uint16_t fields_count;
+    if (!vm_rd_u16(fd, 1, &fields_count))
+      return false;
+
+    fzl_extern_struct_field_t *fields =
+        malloc(sizeof(fzl_extern_struct_field_t) * fields_count);
+    if (!fields)
+      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[i];
+
+      char has_name;
+      if (!vm_rd_char(fd, 1, &has_name))
+        return false;
+
+      if (has_name)
+      {
+        memset(namebuf, 0, sizeof(namebuf));
+        if (!vm_rd_u16(fd, 1, &name_sz))
+          return false;
+
+        if (!vm_rd_char(fd, name_sz, namebuf))
+          return false;
+
+        char *fval = malloc(sizeof(char) * name_sz);
+        if (!fval)
+          return false;
+
+        memset(fval, 0, sizeof(char) * name_sz);
+        memcpy(fval, namebuf, sizeof(char) * name_sz);
+
+        f->name = fval;
+      }
+
+      char is_primitive;
+      if (!vm_rd_char(fd, 1, &is_primitive))
+        return false;
+      f->type.is_primitive = (bool)is_primitive;
+
+      if (f->type.is_primitive)
+      {
+        char ftype;
+        if (!vm_rd_char(fd, 1, &ftype))
+          return false;
+        f->type.primitive = (fzl_type_t)ftype;
+      }
+      else
+      {
+        uint16_t fslot;
+        if (!vm_rd_u16(fd, 1, &fslot))
+          return false;
+        f->type.type_slot = fslot;
+      }
+    }
+  }
+
+  return true;
+}

src/vm/reader/vm_rd_header.c

@@ -0,0 +1,24 @@
+#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];
+  bool ok = vm_rd_char(fd, 5, chkbuf);
+  if (!ok)
+    return false;
+
+  if (memcmp(chkbuf, hdr, hdr_size) != 0)
+    return false;
+
+  return true;
+}

src/vm/reader/vm_rd_sections_sz.c

@@ -0,0 +1,29 @@
+#include <stdbool.h>
+#include <stdint.h>
+#include <vm/internals/reader.h>
+
+// Reader sizes section
+bool vm_rd_sections_sz(fzl_vm_reader_t *reader, FILE *fd)
+{
+  if (!reader || !fd)
+    return false;
+
+  bool ok = vm_rd_u16(fd, 1, (uint16_t *)&reader->consts_count);
+  if (!ok)
+    return false;
+
+  ok = vm_rd_u16(fd, 1, &reader->extern_libs_count);
+  if (!ok)
+    return false;
+
+  ok = vm_rd_u16(fd, 1, &reader->extern_types_count);
+  if (!ok)
+    return false;
+
+  ok = vm_rd_u16(fd, 1, &reader->extern_fns_count);
+  if (!ok)
+    return false;
+
+  ok = vm_rd_word(fd, 1, &reader->ops_count);
+  return ok;
+}

tests/libs/math.c

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