iodine 0.4.19 → 0.5.0

data/ext/iodine/{fiobj_internal.c → fio_siphash.c}

@@ -2,97 +2,10 @@
 Copyright: Boaz Segev, 2017
 License: MIT
 */
-#include "fiobj_internal.h"
-
-#include <errno.h>
-#include <math.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-
-/* *****************************************************************************
-Internal API required across the board
-***************************************************************************** */
-
-void fiobj_simple_dealloc(fiobj_s *o) { fiobj_dealloc(o); }
-
-void fiobj_noop_free(fiobj_s *obj) { OBJ2HEAD(obj)->ref = (uintptr_t)-1; }
-
-int fiobj_noop_true(const fiobj_s *obj) {
-  return 1;
-  (void)obj;
-}
-int fiobj_noop_false(const fiobj_s *obj) {
-  return 0;
-  (void)obj;
-}
-fio_cstr_s fiobj_noop_str(const fiobj_s *obj) {
-  return (fio_cstr_s){.length = 0, .data = ""};
-  (void)obj;
-}
-int64_t fiobj_noop_i(const fiobj_s *obj) {
-  return 0;
-  (void)obj;
-}
-double fiobj_noop_f(const fiobj_s *obj) {
-  return 0;
-  (void)obj;
-}
-
-/** always 0. */
-int fiobj_noop_is_eq(const fiobj_s *self, const fiobj_s *other) {
-  return 0;
-  (void)self;
-  (void)other;
-}
-
-size_t fiobj_noop_count(const fiobj_s *obj) {
-  return 0;
-  (void)obj;
-}
-fiobj_s *fiobj_noop_unwrap(const fiobj_s *obj) {
-  return (fiobj_s *)obj;
-  (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;
-}
-
-/* *****************************************************************************
-Invalid Object VTable - unused, still considering...
-***************************************************************************** */
-
-// static void fiobj_noop_free_invalid(fiobj_s *obj) { (void)obj; }
-// static int64_t fiobj_noop_i_invalid(const fiobj_s *obj) {
-//   return ((int64_t)(obj) ^ 3);
-// }
-// struct fiobj_vtable_s FIOBJ_VTABLE_INVALID = {
-//     .name = "Invalid Class - not a facil.io Object",
-//     .free = fiobj_noop_free_invalid,
-//     .is_true = fiobj_noop_false,
-//     .to_str = fiobj_noop_str,
-//     .to_i = fiobj_noop_i_invalid,
-//     .to_f = fiobj_noop_f,
-//     .is_eq = fiobj_noop_is_eq,
-//     .count = fiobj_noop_count,
-//     .unwrap = fiobj_noop_unwrap,
-//     .each1 = fiobj_noop_each1,
-// };
-
-/* *****************************************************************************
-Internal API required across the board
-***************************************************************************** */
+#include "fio_siphash.h"
 
 /* *****************************************************************************
-Hashing (SipHash copy)
+Hashing (SipHash implementation)
 ***************************************************************************** */
 
 #if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) &&                 \
@@ -112,7 +25,7 @@ Hashing (SipHash copy)
 #define lrot64(i, bits)                                                        \
   (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
 
-uint64_t fiobj_sym_hash(const void *data, size_t len) {
+uint64_t fio_siphash(const void *data, size_t len) {
   /* initialize the 4 words */
   uint64_t v0 = (0x0706050403020100ULL ^ 0x736f6d6570736575ULL);
   uint64_t v1 = (0x0f0e0d0c0b0a0908ULL ^ 0x646f72616e646f6dULL);
@@ -155,16 +68,22 @@ uint64_t fiobj_sym_hash(const void *data, size_t len) {
   switch (len) { /* fallthrough is intentional */
   case 7:
     pos[6] = w8[6];
+    /* fallthrough */
   case 6:
     pos[5] = w8[5];
+    /* fallthrough */
   case 5:
     pos[4] = w8[4];
+    /* fallthrough */
   case 4:
     pos[3] = w8[3];
+    /* fallthrough */
   case 3:
     pos[2] = w8[2];
+    /* fallthrough */
   case 2:
     pos[1] = w8[1];
+    /* fallthrough */
   case 1:
     pos[0] = w8[0];
   }

data/ext/iodine/fio_siphash.h

@@ -0,0 +1,18 @@
+#ifndef H_FIO_SIPHASH_H
+#define H_FIO_SIPHASH_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdint.h>
+#include <sys/types.h>
+
+/**
+ * The Hashing function used by dynamic facil.io objects.
+ *
+ * Currently implemented using SipHash.
+ */
+uint64_t fio_siphash(const void *data, size_t len);
+
+#endif

data/ext/iodine/fio_tmpfile.h

@@ -0,0 +1,38 @@
+/*
+Copyright: Boaz Segev, 2018
+License: MIT
+*/
+#ifndef H_FIO_TMPFILE_H
+/** a simple helper to create temporary files and file names */
+#define H_FIO_TMPFILE_H
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+int fio_tmpfile(void) {
+  // create a temporary file to contain the data.
+  int fd = 0;
+#ifdef P_tmpdir
+  if (P_tmpdir[sizeof(P_tmpdir) - 1] == '/') {
+    char name_template[] = P_tmpdir "facil_io_tmpfile_XXXXXXXX";
+    fd = mkstemp(name_template);
+  } else {
+    char name_template[] = P_tmpdir "/facil_io_tmpfile_XXXXXXXX";
+    fd = mkstemp(name_template);
+  }
+#else
+  char name_template[] = "/tmp/facil_io_tmpfile_XXXXXXXX";
+  fd = mkstemp(name_template);
+#endif
+  return fd;
+}
+#endif

data/ext/iodine/fiobj.h

@@ -1,18 +1,35 @@
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
-#ifndef FIOBJ_H
-#define FIOBJ_H
-
-#include "fiobject.h"
+#ifndef H_FIOBJ_H
+#define H_FIOBJ_H
 
 #include "fiobj_ary.h"
+#include "fiobj_data.h"
 #include "fiobj_hash.h"
 #include "fiobj_json.h"
 #include "fiobj_numbers.h"
-#include "fiobj_primitives.h"
 #include "fiobj_str.h"
-#include "fiobj_sym.h"
+#include "fiobject.h"
 
+#include "fio_siphash.h"
+
+#if DEBUG
+FIO_INLINE void fiobj_test(void) {
+  fiobj_test_string();
+  fiobj_test_numbers();
+  fiobj_test_array();
+  fiobj_test_hash();
+  fiobj_test_core();
+  fiobj_data_test();
+  fiobj_test_json();
+}
+#else
+FIO_INLINE void fiobj_test(void) {
+  fprintf(stderr, "ERROR: tesing functions only defined with DEBUG=1\n");
+  exit(-1);
+}
+#endif
+#undef FIO_INLINE
 #endif

data/ext/iodine/fiobj4sock.h

@@ -0,0 +1,23 @@
+#ifndef H_FIOBJ4SOCK_H
+#define H_FIOBJ4SOCK_H
+/**
+ * Defines a helper for using fiobj with the sock library.
+ */
+
+#include "fiobj.h"
+#include "sock.h"
+
+static void fiobj4sock_dealloc(void *o) { fiobj_free((FIOBJ)o); }
+
+/** send a FIOBJ  object through a socket. */
+static inline __attribute__((unused)) ssize_t fiobj_send_free(intptr_t uuid,
+                                                              FIOBJ o) {
+  fio_cstr_s s = fiobj_obj2cstr(o);
+  return sock_write2(.uuid = uuid, .buffer = (void *)(o),
+                     .offset = (((intptr_t)s.data) - ((intptr_t)(o))),
+                     .length = s.length,
+                     .dealloc =
+                         fiobj4sock_dealloc); // (void (*)(void *))fiobj_free
+}
+
+#endif

data/ext/iodine/fiobj_ary.c

@@ -1,180 +1,120 @@
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
-#include "fiobj_internal.h"
+#include "fiobject.h"
+
+#define FIO_OVERRIDE_MALLOC 1
+#include "fio_mem.h"
+
+#include "fio_ary.h"
+#include <assert.h>
+
+#ifndef FIOBJ_ARRAY_DEFAULT_CAPA
+#define FIOBJ_ARRAY_DEFAULT_CAPA 8
+#endif
+#ifndef FIOBJ_ARRAY_DEFAULT_OFFSET
+#define FIOBJ_ARRAY_DEFAULT_OFFSET (FIOBJ_ARRAY_DEFAULT_CAPA >> 2)
+#endif
 
 /* *****************************************************************************
 Array Type
 ***************************************************************************** */
 
 typedef struct {
-  struct fiobj_vtable_s *vtable;
-  uint64_t start;
-  uint64_t end;
-  uint64_t capa;
-  fiobj_s **arry;
+  fiobj_object_header_s head;
+  fio_ary_s ary;
 } fiobj_ary_s;
 
 #define obj2ary(o) ((fiobj_ary_s *)(o))
 
-/* *****************************************************************************
-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
 ***************************************************************************** */
 
-const uintptr_t FIOBJ_T_ARRAY;
-
-static void fiobj_ary_dealloc(fiobj_s *a) {
-  free(obj2ary(a)->arry);
-  fiobj_dealloc(a);
+static void fiobj_ary_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) {
+  FIO_ARY_FOR(&obj2ary(o)->ary, i) { task((FIOBJ)i.obj, arg); }
+  fio_ary_free(&obj2ary(o)->ary);
+  free(FIOBJ2PTR(o));
 }
 
-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 size_t fiobj_ary_each1(FIOBJ o, size_t start_at,
+                              int (*task)(FIOBJ obj, void *arg), void *arg) {
+  return fio_ary_each(&obj2ary(o)->ary, start_at, (int (*)(void *, void *))task,
+                      arg);
 }
 
-static int fiobj_ary_is_eq(const fiobj_s *self, const fiobj_s *other) {
-  if (self == other)
-    return 1;
-  if (!other || other->type != FIOBJ_T_ARRAY ||
-      (obj2ary(self)->end - obj2ary(self)->start) !=
-          (obj2ary(other)->end - obj2ary(other)->start))
+static size_t fiobj_ary_is_eq(const FIOBJ self, const FIOBJ other) {
+  fio_ary_s *a = &obj2ary(self)->ary;
+  fio_ary_s *b = &obj2ary(other)->ary;
+  if (fio_ary_count(a) != fio_ary_count(b))
     return 0;
   return 1;
 }
 
 /** Returns the number of elements in the Array. */
-static size_t fiobj_ary_count_items(const fiobj_s *ary) {
-  return (obj2ary(ary)->end - obj2ary(ary)->start);
+size_t fiobj_ary_count(const FIOBJ ary) {
+  assert(FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  return fio_ary_count(&obj2ary(ary)->ary);
 }
 
-static struct fiobj_vtable_s FIOBJ_VTABLE_ARRAY = {
-    .name = "Array",
-    .free = fiobj_ary_dealloc,
-    .to_i = fiobj_noop_i,
-    .to_f = fiobj_noop_f,
-    .to_str = fiobj_noop_str,
+static size_t fiobj_ary_is_true(const FIOBJ ary) {
+  return fiobj_ary_count(ary) > 0;
+}
+
+fio_cstr_s fiobject___noop_to_str(const FIOBJ o);
+intptr_t fiobject___noop_to_i(const FIOBJ o);
+double fiobject___noop_to_f(const FIOBJ o);
+
+const fiobj_object_vtable_s FIOBJECT_VTABLE_ARRAY = {
+    .class_name = "Array",
+    .dealloc = fiobj_ary_dealloc,
     .is_eq = fiobj_ary_is_eq,
-    .count = fiobj_ary_count_items,
-    .unwrap = fiobj_noop_unwrap,
-    .each1 = fiobj_ary_each1,
+    .is_true = fiobj_ary_is_true,
+    .count = fiobj_ary_count,
+    .each = fiobj_ary_each1,
+    .to_i = fiobject___noop_to_i,
+    .to_f = fiobject___noop_to_f,
+    .to_str = fiobject___noop_to_str,
 };
 
-const uintptr_t FIOBJ_T_ARRAY = (uintptr_t)(&FIOBJ_VTABLE_ARRAY);
-
 /* *****************************************************************************
 Allocation
 ***************************************************************************** */
 
-static fiobj_s *fiobj_ary_alloc(size_t capa, size_t start_at) {
-  fiobj_s *ary = fiobj_alloc(sizeof(fiobj_ary_s));
-  if (!ary)
-    perror("ERROR: fiobj array couldn't allocate memory"), exit(errno);
-  *(obj2ary(ary)) = (fiobj_ary_s){
-      .vtable = &FIOBJ_VTABLE_ARRAY,
-      .start = start_at,
-      .end = start_at,
-      .capa = capa,
-      .arry = malloc(sizeof(fiobj_s *) * capa),
+static FIOBJ fiobj_ary_alloc(size_t capa, size_t start_at) {
+  fiobj_ary_s *ary = malloc(sizeof(*ary));
+  if (!ary) {
+    perror("ERROR: fiobj array couldn't allocate memory");
+    exit(errno);
+  }
+  *ary = (fiobj_ary_s){
+      .head =
+          {
+              .ref = 1, .type = FIOBJ_T_ARRAY,
+          },
   };
-  if (capa && !obj2ary(ary)->capa)
-    perror("ERROR: fiobj array couldn't allocate memory"), exit(errno);
-  return ary;
+  fio_ary_new(&ary->ary, capa);
+  ary->ary.start = ary->ary.end = start_at;
+  return (FIOBJ)ary;
 }
 
 /** Creates a mutable empty Array object. Use `fiobj_free` when done. */
-fiobj_s *fiobj_ary_new(void) { return fiobj_ary_alloc(32, 8); }
+FIOBJ fiobj_ary_new(void) {
+  return fiobj_ary_alloc(FIOBJ_ARRAY_DEFAULT_CAPA, FIOBJ_ARRAY_DEFAULT_OFFSET);
+}
 /** Creates a mutable empty Array object with the requested capacity. */
-fiobj_s *fiobj_ary_new2(size_t capa) { return fiobj_ary_alloc(capa, 0); }
+FIOBJ fiobj_ary_new2(size_t capa) { return fiobj_ary_alloc(capa, 0); }
 
 /* *****************************************************************************
 Array direct entry access API
 ***************************************************************************** */
 
-/** 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);
-}
-
 /** Returns the current, temporary, array capacity (it's dynamic). */
-size_t fiobj_ary_capa(fiobj_s *ary) {
-  if (!ary)
-    return 0;
-  return obj2ary(ary)->capa;
+size_t fiobj_ary_capa(FIOBJ ary) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  return fio_ary_capa(&obj2ary(ary)->ary);
 }
 
 /**
@@ -183,8 +123,9 @@ size_t fiobj_ary_capa(fiobj_s *ary) {
  * This pointer can be used for sorting and other direct access operations as
  * long as no other actions (insertion/deletion) are performed on the array.
  */
-fiobj_s **fiobj_ary2prt(fiobj_s *ary) {
-  return obj2ary(ary)->arry + obj2ary(ary)->start;
+FIOBJ *fiobj_ary2ptr(FIOBJ ary) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  return (FIOBJ *)(obj2ary(ary)->ary.arry + obj2ary(ary)->ary.start);
 }
 
 /**
@@ -193,61 +134,18 @@ fiobj_s **fiobj_ary2prt(fiobj_s *ary) {
  * Negative values are retrived from the end of the array. i.e., `-1`
  * is the last item.
  */
-fiobj_s *fiobj_ary_index(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];
+FIOBJ fiobj_ary_index(FIOBJ ary, int64_t pos) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  return (FIOBJ)fio_ary_index(&obj2ary(ary)->ary, 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;
+void fiobj_ary_set(FIOBJ ary, FIOBJ obj, int64_t pos) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  FIOBJ old = (FIOBJ)fio_ary_set(&obj2ary(ary)->ary, (void *)obj, pos);
+  fiobj_free(old);
 }
 
 /* *****************************************************************************
@@ -257,49 +155,30 @@ 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;
+void fiobj_ary_push(FIOBJ ary, FIOBJ obj) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  fio_ary_push(&obj2ary(ary)->ary, (void *)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;
+FIOBJ fiobj_ary_pop(FIOBJ ary) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  return (FIOBJ)fio_ary_pop(&obj2ary(ary)->ary);
 }
 
 /**
  * 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;
+void fiobj_ary_unshift(FIOBJ ary, FIOBJ obj) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  fio_ary_unshift(&obj2ary(ary)->ary, (void *)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;
+FIOBJ fiobj_ary_shift(FIOBJ ary) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  return (FIOBJ)fio_ary_shift(&obj2ary(ary)->ary);
 }
 
 /* *****************************************************************************
@@ -313,17 +192,55 @@ Array compacting (untested)
  * 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);
+void fiobj_ary_compact(FIOBJ ary) {
+  assert(ary && FIOBJ_TYPE_IS(ary, FIOBJ_T_ARRAY));
+  fio_ary_compact(&obj2ary(ary)->ary);
 }
+
+/* *****************************************************************************
+Simple Tests
+***************************************************************************** */
+
+#if DEBUG
+void fiobj_test_array(void) {
+  fprintf(stderr, "=== Testing Array\n");
+#define TEST_ASSERT(cond, ...)                                                 \
+  if (!(cond)) {                                                               \
+    fprintf(stderr, "* " __VA_ARGS__);                                         \
+    fprintf(stderr, "Testing failed.\n");                                      \
+    exit(-1);                                                                  \
+  }
+  FIOBJ a = fiobj_ary_new2(4);
+  TEST_ASSERT(FIOBJ_TYPE_IS(a, FIOBJ_T_ARRAY), "Array type isn't an array!\n");
+  TEST_ASSERT(fiobj_ary_capa(a) == 4, "Array capacity ignored!\n");
+  fiobj_ary_push(a, fiobj_null());
+  TEST_ASSERT(fiobj_ary2ptr(a)[0] == fiobj_null(),
+              "Array direct access failed!\n");
+  fiobj_ary_push(a, fiobj_true());
+  fiobj_ary_push(a, fiobj_false());
+  TEST_ASSERT(fiobj_ary_count(a) == 3, "Array count isn't 3\n");
+  fiobj_ary_set(a, fiobj_true(), 63);
+  TEST_ASSERT(fiobj_ary_count(a) == 64, "Array count isn't 64\n");
+  TEST_ASSERT(fiobj_ary_index(a, 0) == fiobj_null(),
+              "Array index retrival error for fiobj_null\n");
+  TEST_ASSERT(fiobj_ary_index(a, 1) == fiobj_true(),
+              "Array index retrival error for fiobj_true\n");
+  TEST_ASSERT(fiobj_ary_index(a, 2) == fiobj_false(),
+              "Array index retrival error for fiobj_false\n");
+  TEST_ASSERT(fiobj_ary_index(a, 3) == 0,
+              "Array index retrival error for NULL\n");
+  TEST_ASSERT(fiobj_ary_index(a, 63) == fiobj_true(),
+              "Array index retrival error for index 63\n");
+  TEST_ASSERT(fiobj_ary_index(a, -1) == fiobj_true(),
+              "Array index retrival error for index -1\n");
+  fiobj_ary_compact(a);
+  TEST_ASSERT(fiobj_ary_index(a, -1) == fiobj_true(),
+              "Array index retrival error for index -1\n");
+  TEST_ASSERT(fiobj_ary_count(a) == 4, "Array compact error\n");
+  fiobj_ary_unshift(a, fiobj_false());
+  TEST_ASSERT(fiobj_ary_count(a) == 5, "Array unshift error\n");
+  TEST_ASSERT(fiobj_ary_shift(a) == fiobj_false(), "Array shift value error\n");
+  fiobj_free(a);
+  fprintf(stderr, "* passed.\n");
+}
+#endif