iodine 0.4.14 → 0.4.15

data/ext/iodine/fiobj_json.h

@@ -0,0 +1,43 @@
+#ifndef H_FIOBJ_JSON_H
+#define H_FIOBJ_JSON_H
+
+/*
+Copyright: Boaz Segev, 2017
+License: MIT
+*/
+
+#include "fiobj_ary.h"
+#include "fiobj_hash.h"
+#include "fiobj_numbers.h"
+#include "fiobj_primitives.h"
+#include "fiobj_str.h"
+#include "fiobj_sym.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* *****************************************************************************
+JSON API
+***************************************************************************** */
+
+/** Limit JSON nesting, we can handle more, but this is mostly for security.  */
+#ifndef JSON_MAX_DEPTH
+#define JSON_MAX_DEPTH 24
+#endif
+
+/**
+ * Parses JSON, setting `pobj` to point to the new Object.
+ *
+ * Returns the number of bytes consumed. On Error, 0 is returned and no data is
+ * consumed.
+ */
+size_t fiobj_json2obj(fiobj_s **pobj, const void *data, size_t len);
+/* Formats an object into a JSON string. Remember to `fiobj_free`. */
+fiobj_s *fiobj_obj2json(fiobj_s *, uint8_t pretty);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/ext/iodine/fiobj_numbers.c

@@ -1,11 +1,26 @@
 /*
-Copyright: Boaz segev, 2017
+Copyright: Boaz Segev, 2017
 License: MIT
-
-Feel free to copy, use and enjoy according to the license provided.
 */
 
-#include "fiobj_types.h"
+#include "fiobj_internal.h"
+
+/* *****************************************************************************
+Numbers Type
+***************************************************************************** */
+
+typedef struct {
+  struct fiobj_vtable_s *vtable;
+  uint64_t i;
+} fiobj_num_s;
+
+typedef struct {
+  struct fiobj_vtable_s *vtable;
+  double f;
+} fiobj_float_s;
+
+#define obj2num(o) ((fiobj_num_s *)(o))
+#define obj2float(o) ((fiobj_float_s *)(o))
 
 /* *****************************************************************************
 Numbers VTable
@@ -13,19 +28,22 @@ Numbers VTable
 
 static __thread char num_buffer[512];
 
-static int64_t fio_i2i(fiobj_s *o) { return obj2num(o)->i; }
-static int64_t fio_f2i(fiobj_s *o) {
-  return (int64_t)floorl(((fio_float_s *)o)->f);
+static int64_t fio_i2i(const fiobj_s *o) { return obj2num(o)->i; }
+static int64_t fio_f2i(const fiobj_s *o) {
+  return (int64_t)floorl(obj2float(o)->f);
 }
-static double fio_i2f(fiobj_s *o) { return (double)obj2num(o)->i; }
-static double fio_f2f(fiobj_s *o) { return obj2float(o)->f; }
+static double fio_i2f(const fiobj_s *o) { return (double)obj2num(o)->i; }
+static double fio_f2f(const fiobj_s *o) { return obj2float(o)->f; }
+
+static int fio_itrue(const fiobj_s *o) { return (obj2num(o)->i != 0); }
+static int fio_ftrue(const fiobj_s *o) { return (obj2float(o)->f != 0); }
 
-static fio_cstr_s fio_i2str(fiobj_s *o) {
+static fio_cstr_s fio_i2str(const fiobj_s *o) {
   return (fio_cstr_s){
       .buffer = num_buffer, .len = fio_ltoa(num_buffer, obj2num(o)->i, 10),
   };
 }
-static fio_cstr_s fio_f2str(fiobj_s *o) {
+static fio_cstr_s fio_f2str(const fiobj_s *o) {
   if (isnan(obj2float(o)->f))
     return (fio_cstr_s){.buffer = "NaN", .len = 3};
   else if (isinf(obj2float(o)->f)) {
@@ -39,54 +57,56 @@ static fio_cstr_s fio_f2str(fiobj_s *o) {
   };
 }
 
-static int fiobj_i_is_eq(fiobj_s *self, fiobj_s *other) {
-  if (!other || other->type != self->type ||
-      obj2num(self)->i != obj2num(other)->i)
-    return 0;
-  return 1;
+static int fiobj_i_is_eq(const fiobj_s *self, const fiobj_s *other) {
+  return self->type == other->type && obj2num(self)->i == obj2num(other)->i;
 }
-static int fiobj_f_is_eq(fiobj_s *self, fiobj_s *other) {
-  if (!other || other->type != self->type ||
-      obj2float(self)->f != obj2float(other)->f)
-    return 0;
-  return 1;
+static int fiobj_f_is_eq(const fiobj_s *self, const fiobj_s *other) {
+  return self->type == other->type && obj2float(self)->f == obj2float(other)->f;
 }
 
 static struct fiobj_vtable_s FIOBJ_VTABLE_INT = {
+    .name = "Number",
     .free = fiobj_simple_dealloc,
     .to_i = fio_i2i,
     .to_f = fio_i2f,
     .to_str = fio_i2str,
+    .is_true = fio_itrue,
     .is_eq = fiobj_i_is_eq,
     .count = fiobj_noop_count,
+    .unwrap = fiobj_noop_unwrap,
     .each1 = fiobj_noop_each1,
 };
 
+const uintptr_t FIOBJ_T_NUMBER = (uintptr_t)&FIOBJ_VTABLE_INT;
+
 static struct fiobj_vtable_s FIOBJ_VTABLE_FLOAT = {
+    .name = "Float",
     .free = fiobj_simple_dealloc,
     .to_i = fio_f2i,
     .to_f = fio_f2f,
+    .is_true = fio_ftrue,
     .to_str = fio_f2str,
     .is_eq = fiobj_f_is_eq,
     .count = fiobj_noop_count,
+    .unwrap = fiobj_noop_unwrap,
     .each1 = fiobj_noop_each1,
 };
 
+const uintptr_t FIOBJ_T_FLOAT = (uintptr_t)&FIOBJ_VTABLE_FLOAT;
+
 /* *****************************************************************************
 Number API
 ***************************************************************************** */
 
 /** Creates a Number object. Remember to use `fiobj_free`. */
 fiobj_s *fiobj_num_new(int64_t num) {
-  fiobj_head_s *head;
-  head = malloc(sizeof(*head) + sizeof(fio_num_s));
-  if (!head)
+  fiobj_num_s *o = (fiobj_num_s *)fiobj_alloc(sizeof(*o));
+  if (!o)
     perror("ERROR: fiobj number couldn't allocate memory"), exit(errno);
-  *head = (fiobj_head_s){
-      .ref = 1, .vtable = &FIOBJ_VTABLE_INT,
+  *o = (fiobj_num_s){
+      .vtable = &FIOBJ_VTABLE_INT, .i = num,
   };
-  *obj2num(HEAD2OBJ(head)) = (fio_num_s){.i = num, .type = FIOBJ_T_NUMBER};
-  return HEAD2OBJ(head);
+  return (fiobj_s *)o;
 }
 
 /** Mutates a Number object's value. Effects every object's reference! */
@@ -98,15 +118,13 @@ Float API
 
 /** Creates a Float object. Remember to use `fiobj_free`.  */
 fiobj_s *fiobj_float_new(double num) {
-  fiobj_head_s *head;
-  head = malloc(sizeof(*head) + sizeof(fio_float_s));
-  if (!head)
+  fiobj_float_s *o = (fiobj_float_s *)fiobj_alloc(sizeof(*o));
+  if (!o)
     perror("ERROR: fiobj float couldn't allocate memory"), exit(errno);
-  *head = (fiobj_head_s){
-      .ref = 1, .vtable = &FIOBJ_VTABLE_FLOAT,
+  *o = (fiobj_float_s){
+      .vtable = &FIOBJ_VTABLE_FLOAT, .f = num,
   };
-  *obj2float(HEAD2OBJ(head)) = (fio_float_s){.f = num, .type = FIOBJ_T_FLOAT};
-  return HEAD2OBJ(head);
+  return (fiobj_s *)o;
 }
 
 /** Mutates a Float object's value. Effects every object's reference!  */

data/ext/iodine/fiobj_numbers.h

@@ -0,0 +1,49 @@
+#ifndef H_FIOBJ_NUMBERS_H
+#define H_FIOBJ_NUMBERS_H
+/*
+Copyright: Boaz Segev, 2017
+License: MIT
+*/
+
+#include "fiobject.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* *****************************************************************************
+Numbers API (Integers)
+***************************************************************************** */
+
+extern const uintptr_t FIOBJ_T_NUMBER;
+
+/** Creates a Number object. Remember to use `fiobj_free`. */
+fiobj_s *fiobj_num_new(int64_t num);
+
+/** Mutates a Number object's value. Effects every object's reference! */
+void fiobj_num_set(fiobj_s *target, int64_t num);
+
+/* *****************************************************************************
+Float API (Double)
+***************************************************************************** */
+
+extern const uintptr_t FIOBJ_T_FLOAT;
+
+/** Creates a Float object. Remember to use `fiobj_free`.  */
+fiobj_s *fiobj_float_new(double num);
+
+/** Mutates a Float object's value. Effects every object's reference!  */
+void fiobj_float_set(fiobj_s *obj, double num);
+
+/* *****************************************************************************
+Pointer Wrapping Helper MACROs (uses integers)
+***************************************************************************** */
+
+#define fiobj_ptr_wrap(ptr) fiobj_num_new((int64_t)(ptr))
+#define fiobj_ptr_unwrap(obj) ((void *)fiobj_obj2num((obj)))
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/ext/iodine/fiobj_primitives.c

@@ -1,98 +1,131 @@
 /*
-Copyright: Boaz segev, 2017
+Copyright: Boaz Segev, 2017
 License: MIT
+*/
 
-Feel free to copy, use and enjoy according to the license provided.
+/**
+Herein are defined some primitive types for the facil.io dynamic object system.
 */
-#include "fiobj_types.h"
+#include "fiobj_primitives.h"
+#include "fiobj_internal.h"
 
 /* *****************************************************************************
-NULL, TRUE, FALSE VTable
+NULL
 ***************************************************************************** */
 
-static int fiobj_simple_is_eq(fiobj_s *self, fiobj_s *other) {
-  if (!other || other->type != self->type)
-    return 0;
-  return 1;
+static int fiobj_primitive_is_eq(const fiobj_s *self, const fiobj_s *other) {
+  return self == other;
 }
 
-static fio_cstr_s fio_true2str(fiobj_s *obj) {
-  return (fio_cstr_s){.buffer = "true", .len = 4};
-  (void)obj;
-}
-static fio_cstr_s fio_false2str(fiobj_s *obj) {
-  return (fio_cstr_s){.buffer = "false", .len = 5};
-  (void)obj;
-}
-static fio_cstr_s fio_null2str(fiobj_s *obj) {
-  return (fio_cstr_s){.buffer = "null", .len = 4};
-  (void)obj;
-}
-static int64_t fio_true2i(fiobj_s *obj) {
-  return 1;
-  (void)obj;
-}
-static double fio_true2f(fiobj_s *obj) {
-  return 1;
-  (void)obj;
-}
-
-static struct fiobj_vtable_s FIOBJ_VTABLE_NULL = {
-    .free = fiobj_simple_dealloc,
+static struct fiobj_vtable_s NULL_VTABLE = {
+    .name = "NULL",
+    /* deallocate an object */
+    .free = fiobj_noop_free,
+    /* object should evaluate as true/false? */
+    .is_true = fiobj_noop_false,
+    /* object value as String */
+    .to_str = fiobj_noop_str,
+    /* object value as Integer */
     .to_i = fiobj_noop_i,
+    /* object value as Float */
     .to_f = fiobj_noop_f,
-    .to_str = fio_null2str,
-    .is_eq = fiobj_simple_is_eq,
+    .is_eq = fiobj_primitive_is_eq,
+    /* return the number of nested object */
     .count = fiobj_noop_count,
+    /* return a wrapped object (if object wrapping exists, i.e. Hash couplet) */
+    .unwrap = fiobj_noop_unwrap,
+    /* perform a task for the object's children (-1 stops iteration)
+     * returns the number of items processed + `start_at`.
+     */
     .each1 = fiobj_noop_each1,
 };
-static struct fiobj_vtable_s FIOBJ_VTABLE_TRUE = {
-    .free = fiobj_simple_dealloc,
-    .to_i = fio_true2i,
-    .to_f = fio_true2f,
-    .to_str = fio_true2str,
-    .is_eq = fiobj_simple_is_eq,
-    .count = fiobj_noop_count,
-    .each1 = fiobj_noop_each1,
-};
-static struct fiobj_vtable_s FIOBJ_VTABLE_FALSE = {
-    .free = fiobj_simple_dealloc,
+
+/** Identifies the NULL type. */
+const uintptr_t FIOBJ_T_NULL = (uintptr_t)(&NULL_VTABLE);
+
+/** Returns a NULL object. */
+fiobj_s *fiobj_null(void) {
+  static struct {
+    fiobj_head_s head;
+    struct fiobj_vtable_s *vtable;
+  } null_obj = {.head = {.ref = 1}, .vtable = &NULL_VTABLE};
+  return (fiobj_s *)(&null_obj.vtable);
+}
+
+/* *****************************************************************************
+True
+***************************************************************************** */
+
+static struct fiobj_vtable_s TRUE_VTABLE = {
+    .name = "True",
+    /* deallocate an object */
+    .free = fiobj_noop_free,
+    /* object should evaluate as true/false? */
+    .is_true = fiobj_noop_true,
+    /* object value as String */
+    .to_str = fiobj_noop_str,
+    /* object value as Integer */
     .to_i = fiobj_noop_i,
+    /* object value as Float */
     .to_f = fiobj_noop_f,
-    .to_str = fio_false2str,
-    .is_eq = fiobj_simple_is_eq,
+    .is_eq = fiobj_primitive_is_eq,
+    /* return the number of nested object */
     .count = fiobj_noop_count,
+    /* return a wrapped object (if object wrapping exists, i.e. Hash couplet) */
+    .unwrap = fiobj_noop_unwrap,
+    /* perform a task for the object's children (-1 stops iteration)
+     * returns the number of items processed + `start_at`.
+     */
     .each1 = fiobj_noop_each1,
 };
 
+/** Identifies the TRUE type. */
+const uintptr_t FIOBJ_T_TRUE = (uintptr_t)(&TRUE_VTABLE);
+
+/** Returns a TRUE object. */
+fiobj_s *fiobj_true(void) {
+  static struct {
+    fiobj_head_s head;
+    struct fiobj_vtable_s *vtable;
+  } obj = {.head = {.ref = 1}, .vtable = &TRUE_VTABLE};
+  return (fiobj_s *)(&obj.vtable);
+}
+
 /* *****************************************************************************
-NULL, TRUE, FALSE API
+False
 ***************************************************************************** */
 
-inline static fiobj_s *fiobj_simple_alloc(fiobj_type_en t,
-                                          struct fiobj_vtable_s *vt) {
-  fiobj_head_s *head;
-  head = malloc(sizeof(*head) + sizeof(fiobj_s));
-  if (!head)
-    perror("ERROR: fiobj primitive couldn't allocate memory"), exit(errno);
-  *head = (fiobj_head_s){
-      .ref = 1, .vtable = vt,
-  };
-  HEAD2OBJ(head)->type = t;
-  return HEAD2OBJ(head);
-}
+static struct fiobj_vtable_s FALSE_VTABLE = {
+    .name = "False",
+    /* deallocate an object */
+    .free = fiobj_noop_free,
+    /* object should evaluate as true/false? */
+    .is_true = fiobj_noop_false,
+    /* object value as String */
+    .to_str = fiobj_noop_str,
+    /* object value as Integer */
+    .to_i = fiobj_noop_i,
+    /* object value as Float */
+    .to_f = fiobj_noop_f,
+    .is_eq = fiobj_primitive_is_eq,
+    /* return the number of nested object */
+    .count = fiobj_noop_count,
+    /* return a wrapped object (if object wrapping exists, i.e. Hash couplet) */
+    .unwrap = fiobj_noop_unwrap,
+    /* perform a task for the object's children (-1 stops iteration)
+     * returns the number of items processed + `start_at`.
+     */
+    .each1 = fiobj_noop_each1,
+};
 
-/** Retruns a NULL object. */
-fiobj_s *fiobj_null(void) {
-  return fiobj_simple_alloc(FIOBJ_T_NULL, &FIOBJ_VTABLE_NULL);
-}
+/** Identifies the FALSE type. */
+const uintptr_t FIOBJ_T_FALSE = (uintptr_t)(&FALSE_VTABLE);
 
-/** Retruns a FALSE object. */
+/** Returns a FALSE object. */
 fiobj_s *fiobj_false(void) {
-  return fiobj_simple_alloc(FIOBJ_T_FALSE, &FIOBJ_VTABLE_FALSE);
-}
-
-/** Retruns a TRUE object. */
-fiobj_s *fiobj_true(void) {
-  return fiobj_simple_alloc(FIOBJ_T_TRUE, &FIOBJ_VTABLE_TRUE);
+  static struct {
+    fiobj_head_s head;
+    struct fiobj_vtable_s *vtable;
+  } obj = {.head = {.ref = 1}, .vtable = &FALSE_VTABLE};
+  return (fiobj_s *)(&obj.vtable);
 }