iodine 0.4.8 → 0.4.10

data/ext/iodine/fiobj_alloc.c

@@ -0,0 +1,81 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+/* *****************************************************************************
+This file handles deallocation concerns.
+
+Since Hash and Array objects will need to deallocate their children, the logic
+regareding object type recorgnition and deallocation was centrelized here.
+***************************************************************************** */
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+Object Deallocation
+***************************************************************************** */
+
+void fiobj_dealloc(fiobj_s *obj) {
+  if (!obj)
+    return;
+  if (OBJ2HEAD(obj).ref == 0) {
+    fprintf(stderr,
+            "ERROR: attempting to free an object that isn't a fiobj or already "
+            "freed (%p)\n",
+            (void *)obj);
+    kill(0, SIGABRT);
+  }
+  if (spn_sub(&OBJ2HEAD(obj).ref, 1))
+    return;
+  OBJ2HEAD(obj).vtable->free(obj);
+}
+
+/* *****************************************************************************
+Deep Allocation (`fiobj_dup`)
+***************************************************************************** */
+
+/* simply increrase the reference count for each object. */
+static int dup_task_callback(fiobj_s *obj, void *arg) {
+  if (!obj)
+    return 0;
+  spn_add(&OBJ2HEAD(obj).ref, 1);
+  // if (obj->type == FIOBJ_T_COUPLET)
+  //   spn_add(&OBJ2HEAD(obj2couplet(obj)->obj).ref, 1);
+  return 0;
+  (void)arg;
+}
+
+/** Increases an object's reference count. */
+fiobj_s *fiobj_dup(fiobj_s *obj) {
+  fiobj_each2(obj, dup_task_callback, NULL);
+  return obj;
+}
+
+/* *****************************************************************************
+Deep Deallocation (`fiobj_free`)
+***************************************************************************** */
+
+static int dealloc_task_callback(fiobj_s *obj, void *arg) {
+  // if (!obj)
+  //   return 0;
+  // if (obj->type == FIOBJ_T_COUPLET)
+  //   fiobj_dealloc(obj2couplet(obj)->obj);
+  fiobj_dealloc(obj);
+  return 0;
+  (void)arg;
+}
+/**
+ * Decreases an object's reference count, releasing memory and
+ * resources.
+ *
+ * This function affects nested objects, meaning that when an Array or
+ * a Hashe object is passed along, it's children (nested objects) are
+ * also freed.
+ */
+void fiobj_free(fiobj_s *obj) {
+  if (!obj)
+    return;
+  fiobj_each2(obj, dealloc_task_callback, NULL);
+}

data/ext/iodine/fiobj_ary.c

@@ -0,0 +1,290 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+Array memory management
+***************************************************************************** */
+
+/* This funcation manages the Array's memory. */
+static void fiobj_ary_getmem(fiobj_s *ary, int64_t needed) {
+  /* we have enough memory, but we need to re-organize it. */
+  if (needed == -1) {
+    if (obj2ary(ary)->end < obj2ary(ary)->capa) {
+      /* since allocation can be cheaper than memmove (depending on size),
+       * we'll just shove everything to the end...
+       */
+      uint64_t len = obj2ary(ary)->end - obj2ary(ary)->start;
+      memmove(obj2ary(ary)->arry + (obj2ary(ary)->capa - len),
+              obj2ary(ary)->arry + obj2ary(ary)->start,
+              len * sizeof(*obj2ary(ary)->arry));
+      obj2ary(ary)->start = obj2ary(ary)->capa - len;
+      obj2ary(ary)->end = obj2ary(ary)->capa;
+
+      return;
+    }
+    /* add some breathing room for future `unshift`s */
+    needed =
+        0 - ((obj2ary(ary)->capa <= 1024) ? (obj2ary(ary)->capa >> 1) : 1024);
+  }
+
+  /* FIFO support optimizes smaller FIFO ranges over bloating allocations. */
+  if (needed == 1 && obj2ary(ary)->start >= (obj2ary(ary)->capa >> 1)) {
+    uint64_t len = obj2ary(ary)->end - obj2ary(ary)->start;
+    memmove(obj2ary(ary)->arry + 2, obj2ary(ary)->arry + obj2ary(ary)->start,
+            len * sizeof(*obj2ary(ary)->arry));
+    obj2ary(ary)->start = 2;
+    obj2ary(ary)->end = len + 2;
+
+    return;
+  }
+
+  /* alocate using exponential growth, up to single page size. */
+  uint64_t updated_capa = obj2ary(ary)->capa;
+  uint64_t minimum =
+      obj2ary(ary)->capa + ((needed < 0) ? (0 - needed) : needed);
+  while (updated_capa <= minimum)
+    updated_capa =
+        (updated_capa <= 4096) ? (updated_capa << 1) : (updated_capa + 4096);
+
+  /* we assume memory allocation works. it's better to crash than to continue
+   * living without memory... besides, malloc is optimistic these days. */
+  obj2ary(ary)->arry =
+      realloc(obj2ary(ary)->arry, updated_capa * sizeof(*obj2ary(ary)->arry));
+  obj2ary(ary)->capa = updated_capa;
+  if (!obj2ary(ary)->arry)
+    perror("ERROR: fiobj array couldn't be reallocated"), exit(errno);
+
+  if (needed >= 0) /* we're done, realloc grows the top of the address space*/
+    return;
+
+  /* move everything to the max, since  memmove could get expensive  */
+  uint64_t len = obj2ary(ary)->end - obj2ary(ary)->start;
+  needed = obj2ary(ary)->capa - len;
+  memmove(obj2ary(ary)->arry + needed, obj2ary(ary)->arry + obj2ary(ary)->start,
+          len * sizeof(*obj2ary(ary)->arry));
+  obj2ary(ary)->end = needed + len;
+  obj2ary(ary)->start = needed;
+}
+
+/* *****************************************************************************
+VTable
+***************************************************************************** */
+
+static void fiobj_ary_dealloc(fiobj_s *a) {
+  free(obj2ary(a)->arry);
+  free(&OBJ2HEAD(a));
+}
+
+static size_t fiobj_ary_each1(fiobj_s *o, size_t start_at,
+                              int (*task)(fiobj_s *obj, void *arg), void *arg) {
+  const uint64_t start_pos = obj2ary(o)->start;
+  start_at += start_pos;
+  while (start_at < obj2ary(o)->end &&
+         task(obj2ary(o)->arry[start_at++], arg) != -1)
+    ;
+  return start_at - start_pos;
+}
+
+static int fiobj_ary_is_eq(fiobj_s *self, fiobj_s *other) {
+  return (other && other->type == FIOBJ_T_ARRAY &&
+          obj2ary(self)->end - obj2ary(self)->start ==
+              obj2ary(other)->end - obj2ary(other)->start);
+}
+
+/** Returns the number of elements in the Array. */
+static size_t fiobj_ary_count_items(fiobj_s *ary) {
+  return (obj2ary(ary)->end - obj2ary(ary)->start);
+}
+
+static struct fiobj_vtable_s FIOBJ_VTABLE_ARRAY = {
+    .free = fiobj_ary_dealloc,
+    .to_i = fiobj_noop_i,
+    .to_f = fiobj_noop_f,
+    .to_str = fiobj_noop_str,
+    .is_eq = fiobj_ary_is_eq,
+    .count = fiobj_ary_count_items,
+    .each1 = fiobj_ary_each1,
+};
+/* *****************************************************************************
+Allocation
+***************************************************************************** */
+
+static fiobj_s *fiobj_ary_alloc(size_t capa, size_t start_at) {
+  fiobj_head_s *head;
+  head = malloc(sizeof(*head) + sizeof(fio_ary_s));
+  if (!head)
+    perror("ERROR: fiobj array couldn't allocate memory"), exit(errno);
+  *head = (fiobj_head_s){
+      .ref = 1, .vtable = &FIOBJ_VTABLE_ARRAY,
+  };
+  *((fio_ary_s *)HEAD2OBJ(head)) =
+      (fio_ary_s){.start = start_at,
+                  .end = start_at,
+                  .capa = capa,
+                  .arry = malloc(sizeof(fiobj_s *) * capa),
+                  .type = FIOBJ_T_ARRAY};
+  return HEAD2OBJ(head);
+}
+
+/** Creates a mutable empty Array object. Use `fiobj_free` when done. */
+fiobj_s *fiobj_ary_new(void) { return fiobj_ary_alloc(32, 8); }
+/** Creates a mutable empty Array object with the requested capacity. */
+fiobj_s *fiobj_ary_new2(size_t capa) { return fiobj_ary_alloc(capa, 0); }
+
+/** Returns the number of elements in the Array. */
+size_t fiobj_ary_count(fiobj_s *ary) {
+  if (!ary)
+    return 0;
+  return (obj2ary(ary)->end - obj2ary(ary)->start);
+}
+
+/* *****************************************************************************
+Array direct entry access API
+***************************************************************************** */
+
+/**
+ * Returns a temporary object owned by the Array.
+ *
+ * Negative values are retrived from the end of the array. i.e., `-1`
+ * is the last item.
+ */
+fiobj_s *fiobj_ary_entry(fiobj_s *ary, int64_t pos) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY)
+    return NULL;
+  /* position is relative to `start`*/
+  if (pos >= 0) {
+    pos = pos + obj2ary(ary)->start;
+    if ((uint64_t)pos >= obj2ary(ary)->end)
+      return NULL;
+    return obj2ary(ary)->arry[pos];
+  }
+  /* position is relative to `end`*/
+  pos = (int64_t)obj2ary(ary)->end + pos;
+  if (pos < 0)
+    return NULL;
+  if ((uint64_t)pos < obj2ary(ary)->start)
+    return NULL;
+  return obj2ary(ary)->arry[pos];
+}
+
+/**
+ * Sets an object at the requested position.
+ */
+void fiobj_ary_set(fiobj_s *ary, fiobj_s *obj, int64_t pos) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY) {
+    /* function takes ownership of memory even if an error occurs. */
+    fiobj_free(obj);
+    return;
+  }
+
+  /* test for memory and request memory if missing, promises valid bounds. */
+  if (pos >= 0) {
+    if ((uint64_t)pos + obj2ary(ary)->start >= obj2ary(ary)->capa)
+      fiobj_ary_getmem(ary, (((uint64_t)pos + obj2ary(ary)->start) -
+                             (obj2ary(ary)->capa - 1)));
+  } else if (pos + (int64_t)obj2ary(ary)->end < 0)
+    fiobj_ary_getmem(ary, pos + obj2ary(ary)->end);
+
+  if (pos >= 0) {
+    /* position relative to start */
+    pos = pos + obj2ary(ary)->start;
+    /* initialize empty spaces, if any, setting new boundries */
+    while ((uint64_t)pos >= obj2ary(ary)->end)
+      obj2ary(ary)->arry[(obj2ary(ary)->end)++] = NULL;
+  } else {
+    /* position relative to end */
+    pos = pos + (int64_t)obj2ary(ary)->end;
+    /* initialize empty spaces, if any, setting new boundries */
+    while (obj2ary(ary)->start > (uint64_t)pos)
+      obj2ary(ary)->arry[--(obj2ary(ary)->start)] = NULL;
+  }
+
+  /* check for an existing object and set new objects */
+  if (obj2ary(ary)->arry[pos])
+    fiobj_free(obj2ary(ary)->arry[pos]);
+  obj2ary(ary)->arry[pos] = obj;
+}
+
+/* *****************************************************************************
+Array push / shift API
+***************************************************************************** */
+
+/**
+ * Pushes an object to the end of the Array.
+ */
+void fiobj_ary_push(fiobj_s *ary, fiobj_s *obj) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY) {
+    /* function takes ownership of memory even if an error occurs. */
+    fiobj_free(obj);
+    return;
+  }
+  if (obj2ary(ary)->capa <= obj2ary(ary)->end)
+    fiobj_ary_getmem(ary, 1);
+  obj2ary(ary)->arry[(obj2ary(ary)->end)++] = obj;
+}
+
+/** Pops an object from the end of the Array. */
+fiobj_s *fiobj_ary_pop(fiobj_s *ary) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY ||
+      obj2ary(ary)->start == obj2ary(ary)->end)
+    return NULL;
+  fiobj_s *ret = obj2ary(ary)->arry[--(obj2ary(ary)->end)];
+  return ret;
+}
+
+/**
+ * Unshifts an object to the begining of the Array. This could be
+ * expensive.
+ */
+void fiobj_ary_unshift(fiobj_s *ary, fiobj_s *obj) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY) {
+    /* function takes ownership of memory even if an error occurs. */
+    fiobj_free(obj);
+    return;
+  }
+  if (obj2ary(ary)->start == 0)
+    fiobj_ary_getmem(ary, -1);
+  obj2ary(ary)->arry[--(obj2ary(ary)->start)] = obj;
+}
+
+/** Shifts an object from the beginning of the Array. */
+fiobj_s *fiobj_ary_shift(fiobj_s *ary) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY)
+    return NULL;
+  if (obj2ary(ary)->start == obj2ary(ary)->end)
+    return NULL;
+  fiobj_s *ret = obj2ary(ary)->arry[(obj2ary(ary)->start)++];
+  return ret;
+}
+
+/* *****************************************************************************
+Array compacting (untested)
+***************************************************************************** */
+
+/**
+ * Removes any NULL *pointers* from an Array, keeping all Objects (including
+ * explicit NULL objects) in the array.
+ *
+ * This action is O(n) where n in the length of the array.
+ * It could get expensive.
+ */
+void fiobj_ary_compact(fiobj_s *ary) {
+  if (!ary || ary->type != FIOBJ_T_ARRAY)
+    return;
+  fiobj_s **reader = obj2ary(ary)->arry + obj2ary(ary)->start;
+  fiobj_s **writer = obj2ary(ary)->arry + obj2ary(ary)->start;
+  while (reader < (obj2ary(ary)->arry + obj2ary(ary)->end)) {
+    if (*reader == NULL) {
+      reader++;
+      continue;
+    }
+    *(writer++) = *(reader++);
+  }
+  obj2ary(ary)->end = (uint64_t)(writer - obj2ary(ary)->arry);
+}

data/ext/iodine/fiobj_generic.c

@@ -0,0 +1,260 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+No-op for vtable
+***************************************************************************** */
+
+fio_cstr_s fiobj_noop_str(fiobj_s *obj) {
+  return (fio_cstr_s){.data = NULL};
+  (void)obj;
+}
+int64_t fiobj_noop_i(fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+double fiobj_noop_f(fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+
+size_t fiobj_noop_count(fiobj_s *obj) {
+  return 0;
+  (void)obj;
+}
+
+size_t fiobj_noop_each1(fiobj_s *obj, size_t start_at,
+                        int (*task)(fiobj_s *obj, void *arg), void *arg) {
+  return 0;
+  (void)obj;
+  (void)start_at;
+  (void)task;
+  (void)arg;
+}
+
+void fiobj_simple_dealloc(fiobj_s *o) { free(&OBJ2HEAD(o)); }
+
+/* *****************************************************************************
+Generic Object API
+***************************************************************************** */
+
+/**
+ * Returns a Number's value.
+ *
+ * If a String or Symbol are passed to the function, they will be
+ * parsed assuming base 10 numerical data.
+ *
+ * A type error results in 0.
+ */
+int64_t fiobj_obj2num(fiobj_s *obj) {
+  if (!obj)
+    return 0;
+  return OBJ2HEAD(obj).vtable->to_i(obj);
+}
+
+/**
+ * Returns a Float's value.
+ *
+ * If a String or Symbol are passed to the function, they will be
+ * parsed assuming base 10 numerical data.
+ *
+ * A type error results in 0.
+ */
+double fiobj_obj2float(fiobj_s *obj) {
+  if (!obj)
+    return 0;
+  return OBJ2HEAD(obj).vtable->to_f(obj);
+}
+
+/**
+ * Returns a C String (NUL terminated) using the `fio_cstr_s` data type.
+ */
+fio_cstr_s fiobj_obj2cstr(fiobj_s *obj) {
+  if (!obj)
+    return (fio_cstr_s){.buffer = NULL, .len = 0};
+  return OBJ2HEAD(obj).vtable->to_str(obj);
+}
+
+/**
+ * Single layer iteration using a callback for each nested fio object.
+ */
+size_t fiobj_each1(fiobj_s *obj, size_t start_at,
+                   int (*task)(fiobj_s *obj, void *arg), void *arg) {
+  return OBJ2HEAD(obj).vtable->each1(obj, start_at, task, arg);
+}
+
+/* *****************************************************************************
+Object Iteration (`fiobj_each2`)
+***************************************************************************** */
+
+static __thread fiobj_s *fiobj_cyclic_protection = NULL;
+fiobj_s *fiobj_each_get_cyclic(void) { return fiobj_cyclic_protection; }
+
+static uint8_t already_processed(fiobj_s *nested, fiobj_s *obj) {
+#if FIOBJ_NESTING_PROTECTION
+  size_t end = obj2ary(nested)->end;
+  for (size_t i = obj2ary(nested)->start; i < end; i++) {
+    if (obj2ary(nested)->arry[i] == obj)
+      return 1;
+  }
+#endif
+  OBJREF_ADD(obj);
+  fiobj_ary_push(nested, obj);
+  return 0;
+}
+
+struct fiobj_each2_task_s {
+  fiobj_s *nested;
+  int (*task)(fiobj_s *obj, void *arg);
+  void *arg;
+  fiobj_s *child;
+};
+
+int fiobj_each2_task_wrapper(fiobj_s *obj, void *data_) {
+  struct fiobj_each2_task_s *data = data_;
+  if (!obj || !OBJ2HEAD(obj).vtable->count(obj))
+    return data->task(obj, data->arg);
+
+  data->child = obj->type == FIOBJ_T_COUPLET ? obj2couplet(obj)->obj : obj;
+  if (already_processed(data->nested, data->child)) {
+    data->child = NULL;
+    fiobj_cyclic_protection = obj;
+    int ret = data->task(NULL, data->arg);
+    fiobj_cyclic_protection = NULL;
+    return ret;
+  }
+  data->task(obj, data->arg);
+  return -1;
+}
+/**
+ * Deep itteration using a callback for each fio object, including the parent.
+ * If the callback returns -1, the loop is broken. Any other value is ignored.
+ */
+void fiobj_each2(fiobj_s *obj, int (*task)(fiobj_s *obj, void *arg),
+                 void *arg) {
+  /* optimize simple items */
+  if (!obj || OBJ2HEAD(obj).vtable->count(obj) == 0) {
+    task(obj, arg);
+    return;
+  }
+  /* Prepare for layerd iteration */
+  uintptr_t count = 0;
+  fiobj_s *nested = fiobj_ary_new2(64);
+  fiobj_s *state = fiobj_ary_new2(128);
+  struct fiobj_each2_task_s data = {.task = task, .arg = arg, .nested = nested};
+  OBJREF_ADD(obj);
+  fiobj_ary_push(nested, obj);
+  if (task(obj, arg) == -1)
+    goto finish;
+rebase:
+  /* resume ? */
+  data.child = NULL;
+  count =
+      OBJ2HEAD(obj).vtable->each1(obj, count, fiobj_each2_task_wrapper, &data);
+  if (data.child) {
+    fiobj_ary_push(state, obj);
+    fiobj_ary_push(state, (void *)count);
+    count = 0;
+    obj = data.child;
+    goto rebase;
+  }
+
+  /* any more nested layers left to handle? */
+  if (fiobj_ary_count(state)) {
+    count = (uintptr_t)fiobj_ary_pop(state);
+    obj = fiobj_ary_pop(state);
+    goto rebase;
+  }
+
+finish:
+  while ((obj = fiobj_ary_pop(nested)))
+    fiobj_dealloc(obj);
+  fiobj_dealloc(nested);
+  fiobj_dealloc(state);
+  return;
+}
+
+/* *****************************************************************************
+Object Comparison (`fiobj_iseq`)
+***************************************************************************** */
+
+static inline int fiobj_iseq_check(fiobj_s *obj1, fiobj_s *obj2) {
+  if (obj1 == obj2)
+    return 1;
+  if (!obj1 || !obj2)
+    return 0;
+  return OBJ2HEAD(obj1).vtable->is_eq(obj1, obj2);
+}
+
+struct fiobj_iseq_data_s {
+  fiobj_s *root;
+  fiobj_s *nested;
+  fiobj_s *parallel;
+  uintptr_t count;
+  uint8_t is_hash;
+  uint8_t err;
+};
+
+int fiobj_iseq_task(fiobj_s *obj, void *data_) {
+  struct fiobj_iseq_data_s *data = data_;
+  if (fiobj_cyclic_protection)
+    obj = fiobj_cyclic_protection;
+
+  if (data->root == obj)
+    return 0;
+
+  if (data->count >= OBJ2HEAD(data->root).vtable->count(data->root)) {
+    data->count = (uintptr_t)fiobj_ary_pop(data->nested);
+    data->parallel = fiobj_ary_pop(data->nested);
+    data->root = fiobj_ary_pop(data->nested);
+    data->is_hash = (data->root->type == FIOBJ_T_HASH);
+  }
+
+  fiobj_s *obj2;
+  if (data->is_hash) {
+    obj2 = fiobj_hash_get(data->parallel, fiobj_couplet2key(obj));
+    obj = fiobj_couplet2obj(obj);
+  } else {
+    obj2 = fiobj_ary_entry(data->parallel, data->count);
+  }
+  data->count++;
+  if (!fiobj_iseq_check(obj, obj2)) {
+    data->err = 1;
+    return -1;
+  }
+  if (!fiobj_cyclic_protection && OBJ2HEAD(obj).vtable->count(obj)) {
+    fiobj_ary_push(data->nested, data->root);
+    fiobj_ary_push(data->nested, data->parallel);
+    fiobj_ary_push(data->nested, (fiobj_s *)data->count);
+    data->count = 0;
+    data->root = obj;
+    data->parallel = obj2;
+    data->is_hash = (obj->type == FIOBJ_T_HASH);
+  }
+  return 0;
+}
+
+int fiobj_iseq(fiobj_s *obj1, fiobj_s *obj2) {
+  if (OBJ2HEAD(obj1).vtable->count(obj1) == 0)
+    return fiobj_iseq_check(obj1, obj2);
+  if (!fiobj_iseq_check(obj1, obj2))
+    return 0;
+  struct fiobj_iseq_data_s data = {
+      .root = obj1,
+      .nested = fiobj_ary_new2(128),
+      .is_hash = obj1->type == FIOBJ_T_HASH,
+      // .count = OBJ2HEAD(obj1).vtable->count(obj1),
+      .parallel = obj2,
+  };
+  // fiobj_ary_push(data.nested, obj2);
+  // fiobj_ary_push(data.nested, (fiobj_s *)OBJ2HEAD(obj1).vtable->count(obj1));
+  fiobj_each2(obj1, fiobj_iseq_task, &data);
+  fiobj_dealloc(data.nested);
+  return data.err == 0;
+}