iodine 0.4.14 → 0.4.15

data/ext/iodine/fiobj_alloc.c

@@ -1,81 +0,0 @@
-/*
-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_generic.c

@@ -1,260 +0,0 @@
-/*
-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;
-}

data/ext/iodine/fiobj_io.c

@@ -1,58 +0,0 @@
-/*
-Copyright: Boaz segev, 2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#include "fiobj_types.h"
-
-/* *****************************************************************************
-IO VTable
-***************************************************************************** */
-
-static int64_t fio_io2i(fiobj_s *io) { return (int64_t)obj2io(io)->fd; }
-
-static int fiobj_io_is_eq(fiobj_s *self, fiobj_s *other) {
-  if (!other || other->type != self->type ||
-      obj2io(self)->fd != obj2io(other)->fd)
-    return 0;
-  return 1;
-}
-
-static struct fiobj_vtable_s FIOBJ_VTABLE_IO = {
-    .free = fiobj_simple_dealloc,
-    .to_i = fio_io2i,
-    .to_f = fiobj_noop_f,
-    .to_str = fiobj_noop_str,
-    .is_eq = fiobj_io_is_eq,
-    .count = fiobj_noop_count,
-    .each1 = fiobj_noop_each1,
-};
-
-/* *****************************************************************************
-IO API
-***************************************************************************** */
-
-/** Wrapps a file descriptor in an IO object. Use `fiobj_free` to close. */
-fiobj_s *fio_io_wrap(intptr_t fd) {
-  fiobj_head_s *head;
-  head = malloc(sizeof(*head) + sizeof(fio_io_s));
-  if (!head)
-    perror("ERROR: fiobj IO couldn't allocate memory"), exit(errno);
-  *head = (fiobj_head_s){
-      .ref = 1, .vtable = &FIOBJ_VTABLE_IO,
-  };
-  *obj2io(HEAD2OBJ(head)) = (fio_io_s){.type = FIOBJ_T_IO, .fd = fd};
-  return HEAD2OBJ(head);
-}
-
-/**
- * Return an IO's fd.
- *
- * A type error results in -1.
- */
-intptr_t fiobj_io_fd(fiobj_s *obj) {
-  if (obj->type != FIOBJ_T_IO)
-    return -1;
-  return ((fio_io_s *)obj)->fd;
-}

data/ext/iodine/fiobj_misc.c

@@ -1,213 +0,0 @@
-/*
-Copyright: Boaz segev, 2017
-License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
-*/
-#include "fiobj_types.h"
-
-/* *****************************************************************************
-Number and Float Helpers
-***************************************************************************** */
-static const char hex_notation[] = {'0', '1', '2', '3', '4', '5', '6', '7',
-                                    '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
-
-/**
- * A helper function that converts between String data to a signed int64_t.
- *
- * Numbers are assumed to be in base 10. `0x##` (or `x##`) and `0b##` (or
- * `b##`) are recognized as base 16 and base 2 (binary MSB first)
- * respectively.
- */
-int64_t fio_atol(char **pstr) {
-  char *str = *pstr;
-  uint64_t result = 0;
-  uint8_t invert = 0;
-  while (str[0] == '0')
-    str++;
-  while (str[0] == '-') {
-    invert ^= 1;
-    str++;
-  }
-  while (str[0] == '0')
-    str++;
-  if (str[0] == 'b' || str[0] == 'B') {
-    /* base 2 */
-    str++;
-    while (str[0] == '0' || str[0] == '1') {
-      result = (result << 1) | (str[0] == '1');
-      str++;
-    }
-  } else if (str[0] == 'x' || str[0] == 'X') {
-    /* base 16 */
-    uint8_t tmp;
-    str++;
-    while (1) {
-      if (str[0] >= '0' && str[0] <= '9')
-        tmp = str[0] - '0';
-      else if (str[0] >= 'A' && str[0] <= 'F')
-        tmp = str[0] - ('A' - 10);
-      else if (str[0] >= 'a' && str[0] <= 'f')
-        tmp = str[0] - ('a' - 10);
-      else
-        goto finish;
-      result = (result << 4) | tmp;
-      str++;
-    }
-  } else {
-    /* base 10 */
-    const char *end = str;
-    while (end[0] >= '0' && end[0] <= '9' && (uintptr_t)(end - str) < 22)
-      end++;
-    if ((uintptr_t)(end - str) > 21) /* too large for a number */
-      return 0;
-
-    while (str < end) {
-      result = (result * 10) + (str[0] - '0');
-      str++;
-    }
-  }
-finish:
-  if (invert)
-    result = 0 - result;
-  *pstr = str;
-  return (int64_t)result;
-}
-
-/** A helper function that convers between String data to a signed double. */
-double fio_atof(char **pstr) { return strtold(*pstr, pstr); }
-
-/* *****************************************************************************
-String Helpers
-***************************************************************************** */
-
-/**
- * A helper function that convers between a signed int64_t to a string.
- *
- * No overflow guard is provided, make sure there's at least 66 bytes
- * available (for base 2).
- *
- * Supports base 2, base 10 and base 16. An unsupported base will silently
- * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
- * beginning of the string).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-size_t fio_ltoa(char *dest, int64_t num, uint8_t base) {
-  if (!num) {
-    *(dest++) = '0';
-    *(dest++) = 0;
-    return 1;
-  }
-
-  size_t len = 0;
-
-  if (base == 2) {
-    uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-    uint8_t i = 0;    /* counting bits */
-
-    while ((i < 64) && (n & 0x8000000000000000) == 0) {
-      n = n << 1;
-      i++;
-    }
-    /* make sure the Binary representation doesn't appear signed. */
-    if (i) {
-      dest[len++] = '0';
-    }
-    /* write to dest. */
-    while (i < 64) {
-      dest[len++] = ((n & 0x8000000000000000) ? '1' : '0');
-      n = n << 1;
-      i++;
-    }
-    dest[len] = 0;
-    return len;
-
-  } else if (base == 16) {
-    uint64_t n = num; /* avoid bit shifting inconsistencies with signed bit */
-    uint8_t i = 0;    /* counting bytes */
-    uint8_t tmp = 0;
-    while (i < 8 && (n & 0xFF00000000000000) == 0) {
-      n = n << 8;
-      i++;
-    }
-    /* make sure the Hex representation doesn't appear signed. */
-    if (i && (n & 0x8000000000000000)) {
-      dest[len++] = '0';
-      dest[len++] = '0';
-    }
-    /* write the damn thing */
-    while (i < 8) {
-      tmp = (n & 0xF000000000000000) >> 60;
-      dest[len++] = hex_notation[tmp];
-      tmp = (n & 0x0F00000000000000) >> 56;
-      dest[len++] = hex_notation[tmp];
-      i++;
-      n = n << 8;
-    }
-    dest[len] = 0;
-    return len;
-  }
-
-  /* fallback to base 10 */
-  uint64_t rem = 0;
-  uint64_t factor = 1;
-  if (num < 0) {
-    dest[len++] = '-';
-    num = 0 - num;
-  }
-
-  while (num / factor)
-    factor *= 10;
-
-  while (factor > 1) {
-    factor = factor / 10;
-    rem = (rem * 10);
-    dest[len++] = '0' + ((num / factor) - rem);
-    rem += ((num / factor) - rem);
-  }
-  dest[len] = 0;
-  return len;
-}
-
-/**
- * A helper function that convers between a double to a string.
- *
- * No overflow guard is provided, make sure there's at least 130 bytes
- * available (for base 2).
- *
- * Supports base 2, base 10 and base 16. An unsupported base will silently
- * default to base 10. Prefixes aren't added (i.e., no "0x" or "0b" at the
- * beginning of the string).
- *
- * Returns the number of bytes actually written (excluding the NUL
- * terminator).
- */
-size_t fio_ftoa(char *dest, double num, uint8_t base) {
-  if (base == 2 || base == 16) {
-    /* handle the binary / Hex representation the same as if it were an
-     * int64_t
-     */
-    int64_t *i = (void *)&num;
-    return fio_ltoa(dest, *i, base);
-  }
-
-  size_t written = sprintf(dest, "%g", num);
-  uint8_t need_zero = 1;
-  char *start = dest;
-  while (*start) {
-    if (*start == ',') // locale issues?
-      *start = '.';
-    if (*start == '.' || *start == 'e') {
-      need_zero = 0;
-      break;
-    }
-    start++;
-  }
-  if (need_zero) {
-    dest[written++] = '.';
-    dest[written++] = '0';
-  }
-  return written;
-}