iodine 0.4.8 → 0.4.10

data/ext/iodine/fiobj_misc.c

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

data/ext/iodine/fiobj_numbers.c

@@ -0,0 +1,113 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+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 double fio_i2f(fiobj_s *o) { return (double)obj2num(o)->i; }
+static double fio_f2f(fiobj_s *o) { return obj2float(o)->f; }
+
+static fio_cstr_s fio_i2str(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) {
+  if (isnan(obj2float(o)->f))
+    return (fio_cstr_s){.buffer = "NaN", .len = 3};
+  else if (isinf(obj2float(o)->f)) {
+    if (obj2float(o)->f > 0)
+      return (fio_cstr_s){.buffer = "Infinity", .len = 8};
+    else
+      return (fio_cstr_s){.buffer = "-Infinity", .len = 9};
+  }
+  return (fio_cstr_s){
+      .buffer = num_buffer, .len = fio_ftoa(num_buffer, obj2float(o)->f, 10),
+  };
+}
+
+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_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 struct fiobj_vtable_s FIOBJ_VTABLE_INT = {
+    .free = fiobj_simple_dealloc,
+    .to_i = fio_i2i,
+    .to_f = fio_i2f,
+    .to_str = fio_i2str,
+    .is_eq = fiobj_i_is_eq,
+    .count = fiobj_noop_count,
+    .each1 = fiobj_noop_each1,
+};
+
+static struct fiobj_vtable_s FIOBJ_VTABLE_FLOAT = {
+    .free = fiobj_simple_dealloc,
+    .to_i = fio_f2i,
+    .to_f = fio_f2f,
+    .to_str = fio_f2str,
+    .is_eq = fiobj_f_is_eq,
+    .count = fiobj_noop_count,
+    .each1 = fiobj_noop_each1,
+};
+
+/* *****************************************************************************
+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)
+    perror("ERROR: fiobj number couldn't allocate memory"), exit(errno);
+  *head = (fiobj_head_s){
+      .ref = 1, .vtable = &FIOBJ_VTABLE_INT,
+  };
+  *obj2num(HEAD2OBJ(head)) = (fio_num_s){.i = num, .type = FIOBJ_T_NUMBER};
+  return HEAD2OBJ(head);
+}
+
+/** Mutates a Number object's value. Effects every object's reference! */
+void fiobj_num_set(fiobj_s *target, int64_t num) { obj2num(target)->i = num; }
+
+/* *****************************************************************************
+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)
+    perror("ERROR: fiobj float couldn't allocate memory"), exit(errno);
+  *head = (fiobj_head_s){
+      .ref = 1, .vtable = &FIOBJ_VTABLE_FLOAT,
+  };
+  *obj2float(HEAD2OBJ(head)) = (fio_float_s){.f = num, .type = FIOBJ_T_FLOAT};
+  return HEAD2OBJ(head);
+}
+
+/** Mutates a Float object's value. Effects every object's reference!  */
+void fiobj_float_set(fiobj_s *obj, double num) { obj2float(obj)->f = num; }

data/ext/iodine/fiobj_primitives.c

@@ -0,0 +1,98 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+NULL, TRUE, FALSE VTable
+***************************************************************************** */
+
+static int fiobj_simple_is_eq(fiobj_s *self, fiobj_s *other) {
+  if (!other || other->type != self->type)
+    return 0;
+  return 1;
+}
+
+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,
+    .to_i = fiobj_noop_i,
+    .to_f = fiobj_noop_f,
+    .to_str = fio_null2str,
+    .is_eq = fiobj_simple_is_eq,
+    .count = fiobj_noop_count,
+    .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,
+    .to_i = fiobj_noop_i,
+    .to_f = fiobj_noop_f,
+    .to_str = fio_false2str,
+    .is_eq = fiobj_simple_is_eq,
+    .count = fiobj_noop_count,
+    .each1 = fiobj_noop_each1,
+};
+
+/* *****************************************************************************
+NULL, TRUE, FALSE API
+***************************************************************************** */
+
+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);
+}
+
+/** Retruns a NULL object. */
+fiobj_s *fiobj_null(void) {
+  return fiobj_simple_alloc(FIOBJ_T_NULL, &FIOBJ_VTABLE_NULL);
+}
+
+/** Retruns 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);
+}

data/ext/iodine/fiobj_str.c

@@ -0,0 +1,261 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+
+#include "fiobj_types.h"
+
+/* *****************************************************************************
+String VTable
+***************************************************************************** */
+
+static void fiobj_str_dealloc(fiobj_s *o) {
+  free(obj2str(o)->str);
+  free(&OBJ2HEAD(o));
+}
+
+static void fiobj_str_dealloc_static(fiobj_s *o) { free(&OBJ2HEAD(o)); }
+
+static int fiobj_str_is_eq(fiobj_s *self, fiobj_s *other) {
+  if (!other || other->type != self->type ||
+      obj2str(self)->len != obj2str(other)->len)
+    return 0;
+  return self == other || obj2str(self)->str == obj2str(other)->str ||
+         !memcmp(obj2str(self)->str, obj2str(other)->str, obj2str(self)->len);
+}
+
+static fio_cstr_s fio_str2str(fiobj_s *o) {
+  return (fio_cstr_s){.buffer = obj2str(o)->str, .len = obj2str(o)->len};
+}
+static int64_t fio_str2i(fiobj_s *o) {
+  char *s = obj2str(o)->str;
+  return fio_atol(&s);
+}
+static double fio_str2f(fiobj_s *o) {
+  char *s = obj2str(o)->str;
+  return fio_atof(&s);
+}
+
+static struct fiobj_vtable_s FIOBJ_VTABLE_STRING = {
+    .free = fiobj_str_dealloc,
+    .to_i = fio_str2i,
+    .to_f = fio_str2f,
+    .to_str = fio_str2str,
+    .is_eq = fiobj_str_is_eq,
+    .count = fiobj_noop_count,
+    .each1 = fiobj_noop_each1,
+};
+
+static struct fiobj_vtable_s FIOBJ_VTABLE_STATIC_STRING = {
+    .free = fiobj_str_dealloc_static,
+    .to_i = fio_str2i,
+    .to_f = fio_str2f,
+    .to_str = fio_str2str,
+    .is_eq = fiobj_str_is_eq,
+    .count = fiobj_noop_count,
+    .each1 = fiobj_noop_each1,
+};
+
+/* *****************************************************************************
+String API
+***************************************************************************** */
+
+static inline fiobj_s *fiobj_str_alloc(size_t len) {
+  fiobj_head_s *head;
+  head = malloc(sizeof(*head) + sizeof(fio_str_s));
+  if (!head)
+    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
+  *head = (fiobj_head_s){
+      .ref = 1, .vtable = &FIOBJ_VTABLE_STRING,
+  };
+  *obj2str(HEAD2OBJ(head)) = (fio_str_s){
+      .type = FIOBJ_T_STRING, .len = len, .capa = len, .str = malloc(len + 1),
+  };
+  if (!obj2str(HEAD2OBJ(head))->str)
+    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
+  obj2str(HEAD2OBJ(head))->str[len] = 0;
+  return HEAD2OBJ(head);
+}
+
+/** Creates a String object. Remember to use `fiobj_free`. */
+fiobj_s *fiobj_str_new(const char *str, size_t len) {
+  fiobj_s *s = fiobj_str_alloc(len);
+  if (str)
+    memcpy(obj2str(s)->str, str, len);
+  return s;
+}
+
+/** Creates a buffer String object. Remember to use `fiobj_free`. */
+fiobj_s *fiobj_str_buf(size_t capa) {
+  if (capa)
+    capa = capa - 1;
+  else
+    capa = fiobj_memory_page_size();
+  fiobj_s *s = fiobj_str_alloc(capa);
+  fiobj_str_clear(s);
+  return s;
+}
+
+/**
+ * Creates a static String object from a static C string. Remember `fiobj_free`.
+ *
+ * This variation avoids allocating memory for an existing static String.
+ *
+ * The object still needs to be frees, but the string isn't copied and isn't
+ * freed.
+ *
+ * NOTICE: static strings can't be written to.
+ */
+fiobj_s *fiobj_str_static(const char *str, size_t len) {
+  fiobj_head_s *head;
+  head = malloc(sizeof(*head) + sizeof(fio_str_s));
+  if (!head)
+    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
+  *head = (fiobj_head_s){
+      .ref = 1, .vtable = &FIOBJ_VTABLE_STATIC_STRING,
+  };
+  *obj2str(HEAD2OBJ(head)) = (fio_str_s){
+      .type = FIOBJ_T_STRING,
+      .len = (len ? len : strlen(str)),
+      .capa = 0,
+      .str = (char *)str,
+      .is_static = 1,
+  };
+  return HEAD2OBJ(head);
+}
+
+/** Creates a copy from an existing String. Remember to use `fiobj_free`. */
+fiobj_s *fiobj_str_copy(fiobj_s *src) {
+  fio_cstr_s s = fiobj_obj2cstr(src);
+  return fiobj_str_new(s.data, s.len);
+}
+
+/** Creates a String object using a printf like interface. */
+__attribute__((format(printf, 1, 0))) fiobj_s *
+fiobj_strvprintf(const char *format, va_list argv) {
+  fiobj_s *str = NULL;
+  va_list argv_cpy;
+  va_copy(argv_cpy, argv);
+  int len = vsnprintf(NULL, 0, format, argv_cpy);
+  va_end(argv_cpy);
+  if (len == 0)
+    str = fiobj_str_new("", 0);
+  if (len <= 0)
+    return str;
+  str = fiobj_str_new(NULL, len);
+  vsnprintf(((fio_str_s *)(str))->str, len + 1, format, argv);
+  return str;
+}
+__attribute__((format(printf, 1, 2))) fiobj_s *
+fiobj_strprintf(const char *format, ...) {
+  va_list argv;
+  va_start(argv, format);
+  fiobj_s *str = fiobj_strvprintf(format, argv);
+  va_end(argv);
+  return str;
+}
+
+/** Confirms the requested capacity is available and allocates as required. */
+void fiobj_str_capa_assert(fiobj_s *str, size_t size) {
+  if (str->type != FIOBJ_T_STRING || ((fio_str_s *)str)->capa == 0 ||
+      ((fio_str_s *)str)->capa >= size + 1)
+    return;
+  /* it's better to crash than live without memory... */
+  ((fio_str_s *)str)->str = realloc(((fio_str_s *)str)->str, size + 1);
+  ((fio_str_s *)str)->capa = size + 1;
+  ((fio_str_s *)str)->str[size] = 0;
+  return;
+}
+
+/** Return's a String's capacity, if any. */
+size_t fiobj_str_capa(fiobj_s *str) {
+  if (str->type != FIOBJ_T_STRING)
+    return 0;
+  return ((fio_str_s *)str)->capa;
+}
+
+/** Resizes a String object, allocating more memory if required. */
+void fiobj_str_resize(fiobj_s *str, size_t size) {
+  if (str->type != FIOBJ_T_STRING)
+    return;
+  fiobj_str_capa_assert(str, size);
+  ((fio_str_s *)str)->len = size;
+  ((fio_str_s *)str)->str[size] = 0;
+  return;
+}
+
+/** Deallocates any unnecessary memory (if supported by OS). */
+void fiobj_str_minimize(fiobj_s *str) {
+  if (str->type != FIOBJ_T_STRING)
+    return;
+  ((fio_str_s *)str)->capa = ((fio_str_s *)str)->len + 1;
+  ((fio_str_s *)str)->str =
+      realloc(((fio_str_s *)str)->str, ((fio_str_s *)str)->capa);
+  return;
+}
+
+/** Empties a String's data. */
+void fiobj_str_clear(fiobj_s *str) {
+  if (str->type != FIOBJ_T_STRING)
+    return;
+  ((fio_str_s *)str)->str[0] = 0;
+  ((fio_str_s *)str)->len = 0;
+}
+
+/**
+ * Writes data at the end of the string, resizing the string as required.
+ * Returns the new length of the String
+ */
+size_t fiobj_str_write(fiobj_s *dest, const char *data, size_t len) {
+  if (dest->type != FIOBJ_T_STRING)
+    return 0;
+  fiobj_str_resize(dest, obj2str(dest)->len + len);
+  if (len < 8) {
+    size_t pos = obj2str(dest)->len;
+    while (len) {
+      len--;
+      pos--;
+      obj2str(dest)->str[pos] = data[len];
+    }
+  } else {
+    memcpy(((fio_str_s *)dest)->str + ((fio_str_s *)dest)->len - len, data,
+           len);
+  }
+  // ((fio_str_s *)dest)->str[((fio_str_s *)dest)->len] = 0; // see str_resize
+  return ((fio_str_s *)dest)->len;
+}
+/**
+ * Writes data at the end of the string, resizing the string as required.
+ * Returns the new length of the String
+ */
+size_t fiobj_str_write2(fiobj_s *dest, const char *format, ...) {
+  if (dest->type != FIOBJ_T_STRING)
+    return 0;
+  va_list argv;
+  va_start(argv, format);
+  int len = vsnprintf(NULL, 0, format, argv);
+  va_end(argv);
+  if (len <= 0)
+    return ((fio_str_s *)dest)->len;
+  fiobj_str_resize(dest, ((fio_str_s *)dest)->len + len);
+  va_start(argv, format);
+  vsnprintf(((fio_str_s *)(dest))->str + ((fio_str_s *)dest)->len - len,
+            len + 1, format, argv);
+  va_end(argv);
+  // ((fio_str_s *)dest)->str[((fio_str_s *)dest)->len] = 0; // see str_resize
+  return ((fio_str_s *)dest)->len;
+}
+/**
+ * Writes data at the end of the string, resizing the string as required.
+ * Returns the new length of the String
+ */
+size_t fiobj_str_join(fiobj_s *dest, fiobj_s *obj) {
+  if (dest->type != FIOBJ_T_STRING)
+    return 0;
+  fio_cstr_s o = fiobj_obj2cstr(obj);
+  if (o.len == 0)
+    return obj2str(dest)->len;
+  return fiobj_str_write(dest, o.data, o.len);
+}