iodine 0.4.19 → 0.5.0

data/ext/iodine/fiobj_numbers.h

@@ -1,7 +1,7 @@
 #ifndef H_FIOBJ_NUMBERS_H
 #define H_FIOBJ_NUMBERS_H
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
@@ -15,33 +15,109 @@ extern "C" {
 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);
+FIO_INLINE FIOBJ fiobj_num_new(intptr_t num);
 
-/** Mutates a Number object's value. Effects every object's reference! */
-void fiobj_num_set(fiobj_s *target, int64_t num);
+/** Creates a temporary Number object. Avoid using `fiobj_free`. */
+FIOBJ fiobj_num_tmp(intptr_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);
+FIOBJ 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);
+void fiobj_float_set(FIOBJ obj, double num);
+
+/** Creates a temporary Float object. Avoid using `fiobj_free`. */
+FIOBJ fiobj_float_tmp(double num);
+
+/* *****************************************************************************
+Numerical Helpers: not FIOBJ specific, but included as part of the library
+***************************************************************************** */
+
+/**
+ * A helper function that converts between String data to a signed int64_t.
+ *
+ * Numbers are assumed to be in base 10.
+ *
+ * The `0x##` (or `x##`) and `0b##` (or `b##`) are recognized as base 16 and
+ * base 2 (binary MSB first) respectively.
+ *
+ * The pointer will be updated to point to the first byte after the number.
+ */
+intptr_t fio_atol(char **pstr);
+
+/** A helper function that convers between String data to a signed double. */
+double fio_atof(char **pstr);
+
+/**
+ * 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);
+
+/**
+ * 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);
+
+/** Converts a number to a temporary, thread safe, C string object */
+fio_cstr_s fio_ltocstr(long);
+
+/** Converts a float to a temporary, thread safe, C string object */
+fio_cstr_s fio_ftocstr(double);
 
 /* *****************************************************************************
 Pointer Wrapping Helper MACROs (uses integers)
 ***************************************************************************** */
 
-#define fiobj_ptr_wrap(ptr) fiobj_num_new((int64_t)(ptr))
+#define fiobj_ptr_wrap(ptr) fiobj_num_new((uintptr_t)(ptr))
 #define fiobj_ptr_unwrap(obj) ((void *)fiobj_obj2num((obj)))
 
+/* *****************************************************************************
+Inline Number Initialization
+***************************************************************************** */
+
+FIOBJ fiobj_num_new_bignum(intptr_t num);
+
+/** Creates a Number object. Remember to use `fiobj_free`. */
+FIO_INLINE FIOBJ fiobj_num_new(intptr_t num) {
+  if ((((uintptr_t)num &
+        (FIOBJ_NUMBER_SIGN_BIT | FIOBJ_NUMBER_SIGN_EXCLUDE_BIT)) == 0) ||
+      (((uintptr_t)num &
+        (FIOBJ_NUMBER_SIGN_BIT | FIOBJ_NUMBER_SIGN_EXCLUDE_BIT)) ==
+       (FIOBJ_NUMBER_SIGN_BIT | FIOBJ_NUMBER_SIGN_EXCLUDE_BIT))) {
+    const uintptr_t num_abs = (uintptr_t)num & FIOBJ_NUMBER_SIGN_MASK;
+    const uintptr_t num_sign = (uintptr_t)num & FIOBJ_NUMBER_SIGN_BIT;
+    return ((num_abs << 1) | num_sign | FIOBJECT_NUMBER_FLAG);
+  }
+  return fiobj_num_new_bignum(num);
+}
+
+#if DEBUG
+void fiobj_test_numbers(void);
+#endif
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

data/ext/iodine/fiobj_str.c

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz Segev, 2017
+Copyright: Boaz Segev, 2017-2018
 License: MIT
 */
 
@@ -10,16 +10,30 @@ License: MIT
 #include <unistd.h>
 #endif
 
-#include "fiobj_internal.h"
+#ifdef _SC_PAGESIZE
+#define PAGE_SIZE sysconf(_SC_PAGESIZE)
+#else
+#define PAGE_SIZE 4096
+#endif
+
+#include "fiobject.h"
+
+#include "fio_siphash.h"
+#include "fiobj_numbers.h"
 #include "fiobj_str.h"
 
+#include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <limits.h>
+#include <string.h>
 #include <sys/stat.h>
 
+#define FIO_OVERRIDE_MALLOC 1
+#include "fio_mem.h"
+
 #ifndef PATH_MAX
-#define PATH_MAX 2096
+#define PATH_MAX PAGE_SIZE
 #endif
 
 /* *****************************************************************************
@@ -27,137 +41,182 @@ String Type
 ***************************************************************************** */
 
 typedef struct {
-  struct fiobj_vtable_s *vtable;
-  uint64_t capa;
-  uint64_t len;
-  uint8_t is_static;
+  fiobj_object_header_s head;
+  uint64_t hash;
+  uint8_t is_small;
+  uint8_t frozen;
+  uint8_t slen;
+  intptr_t len;
+  uintptr_t capa;
   char *str;
 } fiobj_str_s;
 
-#define obj2str(o) ((fiobj_str_s *)(o))
+#define obj2str(o) ((fiobj_str_s *)(FIOBJ2PTR(o)))
+
+#define STR_INTENAL_OFFSET ((uintptr_t)(&(((fiobj_str_s *)0)->slen) + 1))
+#define STR_INTENAL_CAPA ((uintptr_t)(sizeof(fiobj_str_s) - STR_INTENAL_OFFSET))
+#define STR_INTENAL_STR(o)                                                     \
+  ((char *)((uintptr_t)FIOBJ2PTR(o) + STR_INTENAL_OFFSET))
+#define STR_INTENAL_LEN(o) (((fiobj_str_s *)FIOBJ2PTR(o))->slen)
+
+static inline char *fiobj_str_mem_addr(FIOBJ o) {
+  if (obj2str(o)->is_small)
+    return STR_INTENAL_STR(o);
+  return obj2str(o)->str;
+}
+static inline size_t fiobj_str_getlen(FIOBJ o) {
+  if (obj2str(o)->is_small)
+    return obj2str(o)->slen;
+  return obj2str(o)->len;
+}
+static inline size_t fiobj_str_getcapa(FIOBJ o) {
+  if (obj2str(o)->is_small)
+    return STR_INTENAL_CAPA;
+  return obj2str(o)->capa;
+}
+static inline void fiobj_str_setlen(FIOBJ o, size_t len) {
+  if (obj2str(o)->is_small) {
+    obj2str(o)->slen = len;
+    STR_INTENAL_STR(o)[len] = 0;
+  } else {
+    obj2str(o)->len = len;
+    obj2str(o)->str[len] = 0;
+    obj2str(o)->hash = 0;
+  }
+}
+static inline fio_cstr_s fiobj_str_get_cstr(const FIOBJ o) {
+  if (obj2str(o)->is_small)
+    return (fio_cstr_s){.buffer = STR_INTENAL_STR(o),
+                        .len = STR_INTENAL_LEN(o)};
+  ;
+  return (fio_cstr_s){.buffer = obj2str(o)->str, .len = obj2str(o)->len};
+}
 
 /* *****************************************************************************
-String VTable
+String VTables
 ***************************************************************************** */
 
-static void fiobj_str_dealloc(fiobj_s *o) {
-  free(obj2str(o)->str);
-  fiobj_dealloc(o);
-}
+static fio_cstr_s fio_str2str(const FIOBJ o) { return fiobj_str_get_cstr(o); }
 
-static int fiobj_str_is_eq(const fiobj_s *self, const fiobj_s *other) {
-  if (!other || (FIOBJ_IS_STRING(other)) ||
-      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 void fiobj_str_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) {
+  if (obj2str(o)->is_small == 0 && obj2str(o)->capa)
+    fio_free(obj2str(o)->str);
+  fio_free(FIOBJ2PTR(o));
+  (void)task;
+  (void)arg;
 }
 
-static fio_cstr_s fio_str2str(const fiobj_s *o) {
-  return (fio_cstr_s){.buffer = obj2str(o)->str, .len = obj2str(o)->len};
+static size_t fiobj_str_is_eq(const FIOBJ self, const FIOBJ other) {
+  fio_cstr_s o1 = fiobj_str_get_cstr(self);
+  fio_cstr_s o2 = fiobj_str_get_cstr(other);
+  return (o1.len == o2.len &&
+          (o1.data == o2.data || !memcmp(o1.data, o2.data, o1.len)));
 }
-static int64_t fio_str2i(const fiobj_s *o) {
-  char *s = obj2str(o)->str;
-  return fio_atol(&s);
+
+static intptr_t fio_str2i(const FIOBJ o) {
+  char *pos = fiobj_str_mem_addr(o);
+  return fio_atol(&pos);
 }
-static double fio_str2f(const fiobj_s *o) {
-  char *s = obj2str(o)->str;
-  return fio_atof(&s);
+static double fio_str2f(const FIOBJ o) {
+  char *pos = fiobj_str_mem_addr(o);
+  return fio_atof(&pos);
 }
 
-static int fio_str2bool(const fiobj_s *o) { return obj2str(o)->len != 0; }
-
-static struct fiobj_vtable_s FIOBJ_VTABLE_STRING = {
-    .name = "String",
-    .free = fiobj_str_dealloc,
-    .to_i = fio_str2i,
-    .to_f = fio_str2f,
-    .to_str = fio_str2str,
-    .is_eq = fiobj_str_is_eq,
-    .is_true = fio_str2bool,
-    .count = fiobj_noop_count,
-    .unwrap = fiobj_noop_unwrap,
-    .each1 = fiobj_noop_each1,
-};
+static size_t fio_str2bool(const FIOBJ o) { return fiobj_str_getlen(o) != 0; }
 
-const uintptr_t FIOBJ_T_STRING = (uintptr_t)(&FIOBJ_VTABLE_STRING);
+uintptr_t fiobject___noop_count(const FIOBJ o);
 
-static struct fiobj_vtable_s FIOBJ_VTABLE_STATIC_STRING = {
-    .name = "StaticString",
-    .free = fiobj_simple_dealloc,
+const fiobj_object_vtable_s FIOBJECT_VTABLE_STRING = {
+    .class_name = "String",
+    .dealloc = fiobj_str_dealloc,
     .to_i = fio_str2i,
     .to_f = fio_str2f,
     .to_str = fio_str2str,
     .is_eq = fiobj_str_is_eq,
     .is_true = fio_str2bool,
-    .count = fiobj_noop_count,
-    .unwrap = fiobj_noop_unwrap,
-    .each1 = fiobj_noop_each1,
+    .count = fiobject___noop_count,
 };
 
-const uintptr_t FIOBJ_T_STRING_STATIC =
-    (uintptr_t)(&FIOBJ_VTABLE_STATIC_STRING);
-
 /* *****************************************************************************
 String API
 ***************************************************************************** */
 
-static inline fiobj_s *fiobj_str_alloc(size_t len) {
-  fiobj_s *o = fiobj_alloc(sizeof(fiobj_str_s) + len + 1);
-  if (!o)
-    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
-  *obj2str(o) = (fiobj_str_s){
-      .vtable = &FIOBJ_VTABLE_STRING,
-      .len = len,
-      .capa = len + 1,
-      .str = malloc(len + 1),
-  };
-  if (!obj2str(o)->str)
-    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
-  obj2str(o)->str[len] = 0;
-  return o;
-}
-
-/** 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) {
+FIOBJ fiobj_str_buf(size_t capa) {
   if (capa)
-    capa = capa - 1;
+    capa = capa + 1;
   else
-    capa = fiobj_memory_page_size();
-  fiobj_s *s = fiobj_str_alloc(capa);
-  fiobj_str_clear(s);
+    capa = PAGE_SIZE;
+
+  fiobj_str_s *s = fio_malloc(sizeof(*s));
+  if (!s) {
+    perror("ERROR: fiobj string couldn't allocate memory");
+    exit(errno);
+  }
+
+  if (capa <= STR_INTENAL_CAPA) {
+    *s = (fiobj_str_s){
+        .head =
+            {
+                .ref = 1, .type = FIOBJ_T_STRING,
+            },
+        .is_small = 1,
+        .slen = 0,
+    };
+  } else {
+    *s = (fiobj_str_s){
+        .head =
+            {
+                .ref = 1, .type = FIOBJ_T_STRING,
+            },
+        .len = 0,
+        .capa = capa,
+        .str = fio_malloc(capa),
+    };
+    if (!s->str) {
+      perror("ERROR: fiobj string couldn't allocate buffer memory");
+      exit(errno);
+    }
+  }
+  return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
+}
+
+/** Creates a String object. Remember to use `fiobj_free`. */
+FIOBJ fiobj_str_new(const char *str, size_t len) {
+  FIOBJ s = fiobj_str_buf(len);
+  char *mem = fiobj_str_mem_addr(s);
+  memcpy(mem, str, len);
+  fiobj_str_setlen(s, len);
   return s;
 }
 
 /**
  * Creates a String object. Remember to use `fiobj_free`.
  *
- * The ownership of the memory indicated by `str` will now "move" to the object,
- * so `free` will be called for `str` by the `fiobj` library as needed.
+ * The ownership of the memory indicated by `str` will now "move" to the
+ * object, so `free` will be called by the `fiobj` library as needed.
  */
-fiobj_s *fiobj_str_move(char *str, size_t len, size_t capacity) {
-  fiobj_s *o = fiobj_alloc(sizeof(fiobj_str_s) + len + 1);
-  if (!o)
-    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
-  *obj2str(o) = (fiobj_str_s){
-      .vtable = &FIOBJ_VTABLE_STRING,
+FIOBJ fiobj_str_move(char *str, size_t len, size_t capacity) {
+  fiobj_str_s *s = fio_malloc(sizeof(*s));
+  if (!s) {
+    perror("ERROR: fiobj string couldn't allocate memory");
+    exit(errno);
+  }
+  *s = (fiobj_str_s){
+      .head =
+          {
+              .ref = 1, .type = FIOBJ_T_STRING,
+          },
       .len = len,
       .capa = (capacity < len ? len : capacity),
-      .str = (char *)str,
+      .str = str,
   };
-  return o;
+  return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
 }
 
 /**
- * Creates a static String object from a static C string. Remember `fiobj_free`.
+ * Creates a static String object from a static C string. Remember
+ * `fiobj_free`.
  *
  * This variation avoids allocating memory for an existing static String.
  *
@@ -166,31 +225,32 @@ fiobj_s *fiobj_str_move(char *str, size_t len, size_t capacity) {
  *
  * NOTICE: static strings can't be written to.
  */
-fiobj_s *fiobj_str_static(const char *str, size_t len) {
-  fiobj_s *o = fiobj_alloc(sizeof(fiobj_str_s) + len + 1);
-  if (!o)
-    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
-  *obj2str(o) = (fiobj_str_s){
-      .vtable = &FIOBJ_VTABLE_STATIC_STRING,
-      .len = (len ? len : strlen(str)),
+FIOBJ fiobj_str_static(const char *str, size_t len) {
+#if !FIOBJ_DONT_COPY_SMALL_STATIC_STRINGS
+  if (len < STR_INTENAL_CAPA)
+    return fiobj_str_new(str, len);
+#endif
+  fiobj_str_s *s = fio_malloc(sizeof(*s));
+  if (!s) {
+    perror("ERROR: fiobj string couldn't allocate memory");
+    exit(errno);
+  }
+  *s = (fiobj_str_s){
+      .head =
+          {
+              .ref = 1, .type = FIOBJ_T_STRING,
+          },
+      .len = len,
       .capa = 0,
       .str = (char *)str,
   };
-  if (!obj2str(o)->str)
-    perror("ERROR: fiobj string couldn't allocate memory"), exit(errno);
-  return o;
-}
-
-/** 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);
+  return ((uintptr_t)s | FIOBJECT_STRING_FLAG);
 }
 
 /** 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;
+__attribute__((format(printf, 1, 0))) FIOBJ fiobj_strvprintf(const char *format,
+                                                             va_list argv) {
+  FIOBJ str = 0;
   va_list argv_cpy;
   va_copy(argv_cpy, argv);
   int len = vsnprintf(NULL, 0, format, argv_cpy);
@@ -199,151 +259,224 @@ fiobj_strvprintf(const char *format, va_list argv) {
     str = fiobj_str_new("", 0);
   if (len <= 0)
     return str;
-  str = fiobj_str_new(NULL, len);
-  vsnprintf(obj2str(str)->str, len + 1, format, argv);
+  str = fiobj_str_buf(len);
+  char *mem = FIOBJECT2VTBL(str)->to_str(str).data;
+  vsnprintf(mem, len + 1, format, argv);
+  fiobj_str_setlen(str, len);
   return str;
 }
-__attribute__((format(printf, 1, 2))) fiobj_s *
-fiobj_strprintf(const char *format, ...) {
+__attribute__((format(printf, 1, 2))) FIOBJ fiobj_strprintf(const char *format,
+                                                            ...) {
   va_list argv;
   va_start(argv, format);
-  fiobj_s *str = fiobj_strvprintf(format, argv);
+  FIOBJ str = fiobj_strvprintf(format, argv);
   va_end(argv);
   return str;
 }
 
+/**
+ * Returns a thread-static temporary string. Avoid calling `fiobj_dup` or
+ * `fiobj_free`.
+ */
+FIOBJ fiobj_str_tmp(void) {
+  static __thread fiobj_str_s tmp = {
+      .head =
+          {
+              .ref = ((~(uint32_t)0) >> 4), .type = FIOBJ_T_STRING,
+          },
+      .is_small = 1,
+      .slen = 0,
+  };
+  tmp.len = 0;
+  tmp.slen = 0;
+  return ((uintptr_t)&tmp | FIOBJECT_STRING_FLAG);
+}
+
 /** Dumps the `filename` file's contents into a new String. If `limit == 0`,
  * than the data will be read until EOF.
  *
- * If the file can't be located, opened or read, or if `start_at` is beyond the
- * EOF position, NULL is returned.
+ * If the file can't be located, opened or read, or if `start_at` is beyond
+ * the EOF position, NULL is returned.
  *
  * Remember to use `fiobj_free`.
  */
-fiobj_s *fiobj_str_readfile(const char *filename, size_t start_at,
-                            size_t limit) {
+FIOBJ fiobj_str_readfile(const char *filename, intptr_t start_at,
+                         intptr_t limit) {
 #if defined(__unix__) || defined(__linux__) || defined(__APPLE__)
   /* POSIX implementations. */
   if (filename == NULL)
-    return NULL;
+    return FIOBJ_INVALID;
   struct stat f_data;
   int file = -1;
   size_t file_path_len = strlen(filename);
-  if (file_path_len == 0 || file_path_len > PATH_MAX)
-    return NULL;
+  if (file_path_len == 0 || file_path_len >= PATH_MAX)
+    return FIOBJ_INVALID;
 
-  char real_public_path[PATH_MAX + 1];
-  real_public_path[PATH_MAX] = 0;
+  char real_public_path[PATH_MAX];
+  real_public_path[PATH_MAX - 1] = 0;
 
-  if (filename[0] == '~' && getenv("HOME") && file_path_len <= PATH_MAX) {
+  if (filename[0] == '~' && getenv("HOME") && file_path_len < PATH_MAX) {
     strcpy(real_public_path, getenv("HOME"));
     memcpy(real_public_path + strlen(real_public_path), filename + 1,
            file_path_len);
     filename = real_public_path;
   }
 
-  if (stat(filename, &f_data) || f_data.st_size < 0)
-    return NULL;
+  if (stat(filename, &f_data) || f_data.st_size <= 0)
+    return FIOBJ_INVALID;
+
+  if (start_at < 0)
+    start_at = f_data.st_size + start_at;
+
+  if (start_at < 0 || start_at >= f_data.st_size)
+    return FIOBJ_INVALID;
 
-  if (limit <= 0 || (size_t)f_data.st_size < limit + start_at)
+  if (limit <= 0 || f_data.st_size < (limit + start_at))
     limit = f_data.st_size - start_at;
-  fiobj_s *str = fiobj_str_buf(limit + 1);
+  FIOBJ str = fiobj_str_buf(limit + 1);
   if (!str)
-    return NULL;
+    return FIOBJ_INVALID;
   file = open(filename, O_RDONLY);
   if (file < 0) {
-    fiobj_str_dealloc(str);
-    return NULL;
+    FIOBJECT2VTBL(str)->dealloc(str, NULL, NULL);
+    return FIOBJ_INVALID;
   }
-
-  if (pread(file, obj2str(str)->str, limit, start_at) != (ssize_t)limit) {
-    fiobj_str_dealloc(str);
+  if (pread(file, fiobj_str_mem_addr(str), limit, start_at) != (ssize_t)limit) {
+    FIOBJECT2VTBL(str)->dealloc(str, NULL, NULL);
     close(file);
-    return NULL;
+    return FIOBJ_INVALID;
   }
   close(file);
-  obj2str(str)->len = limit;
-  obj2str(str)->str[limit] = 0;
+  fiobj_str_setlen(str, limit);
   return str;
 #else
   /* TODO: consider adding non POSIX implementations. */
-  return NULL;
+  return FIOBJ_INVALID;
 #endif
 }
 
+/** Prevents the String object from being changed. */
+void fiobj_str_freeze(FIOBJ str) {
+  if (FIOBJ_TYPE_IS(str, FIOBJ_T_STRING))
+    obj2str(str)->frozen = 1;
+}
+
 /** Confirms the requested capacity is available and allocates as required. */
-size_t fiobj_str_capa_assert(fiobj_s *str, size_t size) {
-  if (str->type != FIOBJ_T_STRING || obj2str(str)->capa == 0 ||
-      obj2str(str)->capa >= size + 1)
+size_t fiobj_str_capa_assert(FIOBJ str, size_t size) {
+
+  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
+  if (obj2str(str)->frozen)
+    return 0;
+  size += 1;
+  if (obj2str(str)->is_small) {
+    if (size <= STR_INTENAL_CAPA)
+      return STR_INTENAL_CAPA;
+    if (size >> 12)
+      size = ((size >> 12) + 1) << 12;
+    char *mem = fio_malloc(size);
+    if (!mem) {
+      perror("FATAL ERROR: Couldn't allocate larger String memory");
+      exit(errno);
+    }
+    memcpy(mem, STR_INTENAL_STR(str), obj2str(str)->slen + 1);
+    *obj2str(str) = (fiobj_str_s){
+        .head =
+            {
+                .ref = obj2str(str)->head.ref, .type = FIOBJ_T_STRING,
+            },
+        .len = obj2str(str)->slen,
+        .capa = size,
+        .str = mem,
+    };
     return obj2str(str)->capa;
-  /* it's better to crash than live without memory... */
-  obj2str(str)->str = realloc(obj2str(str)->str, size + 1);
-  obj2str(str)->capa = size + 1;
-  obj2str(str)->str[size] = 0;
-  return obj2str(str)->capa;
+  }
+  if (obj2str(str)->capa >= size)
+    return obj2str(str)->capa;
+
+  /* large strings should increase memory by page size (assumes 4096 pages) */
+  if (size >> 12)
+    size = ((size >> 12) + 1) << 12;
+  else if (size < (obj2str(str)->capa << 1))
+    size = obj2str(str)->capa << 1; /* grow in steps */
+
+  if (obj2str(str)->capa == 0) {
+    /* a static string */
+    char *mem = fio_malloc(size);
+    if (!mem) {
+      perror("FATAL ERROR: Couldn't allocate new String memory");
+      exit(errno);
+    }
+    memcpy(mem, obj2str(str)->str, obj2str(str)->len + 1);
+    obj2str(str)->str = mem;
+  } else {
+    /* it's better to crash than live without memory... */
+    obj2str(str)->str =
+        fio_realloc2(obj2str(str)->str, size, obj2str(str)->len + 1);
+    if (!obj2str(str)->str) {
+      perror("FATAL ERROR: Couldn't (re)allocate String memory");
+      exit(errno);
+    }
+  }
+  obj2str(str)->capa = size;
+  return obj2str(str)->capa - 1;
 }
 
 /** Return's a String's capacity, if any. */
-size_t fiobj_str_capa(fiobj_s *str) {
-  if (str->type != FIOBJ_T_STRING)
+size_t fiobj_str_capa(FIOBJ str) {
+  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
+  if (obj2str(str)->frozen)
     return 0;
-  return obj2str(str)->capa;
+  return fiobj_str_getcapa(str) - 1;
 }
 
 /** 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)
+void fiobj_str_resize(FIOBJ str, size_t size) {
+  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
+  if (obj2str(str)->frozen)
     return;
   fiobj_str_capa_assert(str, size);
-  obj2str(str)->len = size;
-  obj2str(str)->str[size] = 0;
+  fiobj_str_setlen(str, size);
   return;
 }
 
 /** Deallocates any unnecessary memory (if supported by OS). */
-void fiobj_str_minimize(fiobj_s *str) {
-  if (str->type != FIOBJ_T_STRING)
+void fiobj_str_minimize(FIOBJ str) {
+  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
+  if (obj2str(str)->frozen || obj2str(str)->is_small || obj2str(str)->capa == 0)
     return;
   obj2str(str)->capa = obj2str(str)->len + 1;
-  obj2str(str)->str = realloc(obj2str(str)->str, obj2str(str)->capa);
+  obj2str(str)->str = fio_realloc(obj2str(str)->str, obj2str(str)->capa);
   return;
 }
 
 /** Empties a String's data. */
-void fiobj_str_clear(fiobj_s *str) {
-  if (str->type != FIOBJ_T_STRING)
+void fiobj_str_clear(FIOBJ str) {
+  assert(FIOBJ_TYPE_IS(str, FIOBJ_T_STRING));
+  if (obj2str(str)->frozen)
     return;
-  obj2str(str)->str[0] = 0;
-  obj2str(str)->len = 0;
+  fiobj_str_setlen(str, 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)
+size_t fiobj_str_write(FIOBJ dest, const char *data, size_t len) {
+  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
+  if (obj2str(dest)->frozen)
     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(obj2str(dest)->str + obj2str(dest)->len - len, data, len);
-  }
-  // ((fio_str_s *)dest)->str[((fio_str_s *)dest)->len] = 0; // see str_resize
-  return obj2str(dest)->len;
+  fiobj_str_resize(dest, fiobj_str_getlen(dest) + len);
+  fio_cstr_s s = fiobj_str_get_cstr(dest);
+  memcpy(s.data + s.len - len, data, len);
+  return s.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)
+size_t fiobj_str_write2(FIOBJ dest, const char *format, ...) {
+  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
+  if (obj2str(dest)->frozen)
     return 0;
   va_list argv;
   va_start(argv, format);
@@ -351,23 +484,129 @@ size_t fiobj_str_write2(fiobj_s *dest, const char *format, ...) {
   va_end(argv);
   if (len <= 0)
     return obj2str(dest)->len;
-  fiobj_str_resize(dest, obj2str(dest)->len + len);
+  fiobj_str_resize(dest, fiobj_str_getlen(dest) + len);
   va_start(argv, format);
-  vsnprintf(obj2str(dest)->str + obj2str(dest)->len - len, len + 1, format,
-            argv);
+  fio_cstr_s s = fiobj_str_get_cstr(dest);
+  vsnprintf(s.data + s.len - len, len + 1, format, argv);
   va_end(argv);
   // ((fio_str_s *)dest)->str[((fio_str_s *)dest)->len] = 0; // see str_resize
-  return obj2str(dest)->len;
+  return s.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)
+size_t fiobj_str_join(FIOBJ dest, FIOBJ obj) {
+  assert(FIOBJ_TYPE_IS(dest, FIOBJ_T_STRING));
+  if (obj2str(dest)->frozen)
     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);
 }
+
+/**
+ * Calculates a String's SipHash value for use as a HashMap key.
+ */
+uint64_t fiobj_str_hash(FIOBJ o) {
+  assert(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING));
+  // if (obj2str(o)->is_small) {
+  //   return fio_siphash(STR_INTENAL_STR(o), STR_INTENAL_LEN(o));
+  // } else
+  if (obj2str(o)->hash) {
+    return obj2str(o)->hash;
+  }
+  if (obj2str(o)->is_small) {
+    obj2str(o)->hash = fio_siphash(STR_INTENAL_STR(o), STR_INTENAL_LEN(o));
+  } else {
+    obj2str(o)->hash = fio_siphash(obj2str(o)->str, obj2str(o)->len);
+  }
+  return obj2str(o)->hash;
+}
+
+/* *****************************************************************************
+Tests
+***************************************************************************** */
+
+#if DEBUG
+void fiobj_test_string(void) {
+  fprintf(stderr, "=== Testing Strings\n");
+  fprintf(stderr, "* Internal String Capacity %u with offset, %u\n",
+          (unsigned int)STR_INTENAL_CAPA, (unsigned int)STR_INTENAL_OFFSET);
+#define TEST_ASSERT(cond, ...)                                                 \
+  if (!(cond)) {                                                               \
+    fprintf(stderr, "* " __VA_ARGS__);                                         \
+    fprintf(stderr, "Testing failed.\n");                                      \
+    exit(-1);                                                                  \
+  }
+#define STR_EQ(o, str)                                                         \
+  TEST_ASSERT((fiobj_str_getlen(o) == strlen(str) &&                           \
+               !memcmp(fiobj_str_mem_addr(o), str, strlen(str))),              \
+              "String not equal to " str)
+  FIOBJ o = fiobj_str_new("Hello", 5);
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING), "Small String isn't string!\n");
+  TEST_ASSERT(obj2str(o)->is_small, "Hello isn't small\n");
+  fiobj_str_write(o, " World", 6);
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING),
+              "Hello World String isn't string!\n");
+  TEST_ASSERT(obj2str(o)->is_small, "Hello World isn't small\n");
+  TEST_ASSERT(fiobj_obj2cstr(o).len == 11,
+              "Invalid small string length (%u != 11)!\n",
+              (unsigned int)fiobj_obj2cstr(o).len)
+  fiobj_str_write(o, " World, you crazy longer sleep loving person :-)", 48);
+  TEST_ASSERT(!obj2str(o)->is_small, "Crazier shouldn't be small\n");
+  fiobj_free(o);
+
+  o = fiobj_str_new(
+      "hello my dear friend, I hope that your are well and happy.", 58);
+  TEST_ASSERT(FIOBJ_TYPE_IS(o, FIOBJ_T_STRING), "Long String isn't string!\n");
+  TEST_ASSERT(!obj2str(o)->is_small,
+              "Long String is small! (capa: %lu, len: %lu)\n", obj2str(o)->capa,
+              obj2str(o)->len);
+  TEST_ASSERT(fiobj_obj2cstr(o).len == 58,
+              "Invalid long string length (%lu != 58)!\n",
+              fiobj_obj2cstr(o).len)
+  uint64_t hash = fiobj_str_hash(o);
+  TEST_ASSERT(!obj2str(o)->frozen, "String forzen when only hashing!\n");
+  fiobj_str_freeze(o);
+  TEST_ASSERT(obj2str(o)->frozen, "String not forzen!\n");
+  fiobj_str_write(o, " World", 6);
+  TEST_ASSERT(hash == fiobj_str_hash(o),
+              "String hash changed after hashing - not frozen?\n");
+  TEST_ASSERT(fiobj_obj2cstr(o).len == 58,
+              "String was edited after hashing - not frozen!\n (%lu): %s",
+              (unsigned long)fiobj_obj2cstr(o).len, fiobj_obj2cstr(o).data);
+  fiobj_free(o);
+
+  o = fiobj_str_static("Hello", 5);
+  TEST_ASSERT(obj2str(o)->is_small,
+              "Small Static should be converted to dynamic.\n");
+  fiobj_free(o);
+
+  o = fiobj_str_static(
+      "hello my dear friend, I hope that your are well and happy.", 58);
+  fiobj_str_write(o, " World", 6);
+  STR_EQ(o, "hello my dear friend, I hope that your are well and happy."
+            " World");
+  fiobj_free(o);
+
+  o = fiobj_strprintf("%u", 42);
+  TEST_ASSERT(fiobj_str_getlen(o) == 2, "fiobj_strprintf length error.\n");
+  TEST_ASSERT(fiobj_obj2num(o), "fiobj_strprintf integer error.\n");
+  TEST_ASSERT(!memcmp(fiobj_obj2cstr(o).data, "42", 2),
+              "fiobj_strprintf string error.\n");
+  fiobj_free(o);
+
+  o = fiobj_str_buf(4);
+  for (int i = 0; i < 16000; ++i) {
+    fiobj_str_write(o, "a", 1);
+  }
+  TEST_ASSERT(obj2str(o)->len == 16000, "16K fiobj_str_write not 16K.\n");
+  TEST_ASSERT(obj2str(o)->capa > 16001,
+              "16K fiobj_str_write capa not enough.\n");
+  fiobj_free(o);
+
+  fprintf(stderr, "* passed.\n");
+}
+#endif