iodine 0.6.5 → 0.7.0

data/ext/iodine/fiobj_str.h

@@ -5,7 +5,7 @@ License: MIT
 */
 #define H_FIOBJ_STR_H
 
-#include "fiobject.h"
+#include <fiobject.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -20,37 +20,33 @@ API: Creating a String Object
 /** Creates a String object. Remember to use `fiobj_free`. */
 FIOBJ fiobj_str_new(const char *str, size_t len);
 
-/** Creates a buffer String object. capa includes NUL.
- *
- * Remember to use `fiobj_free`.
- */
-FIOBJ fiobj_str_buf(size_t capa);
-
 /**
- * Creates a static String object from a static C string. Remember `fiobj_free`.
- *
- * This variation avoids allocating memory for an existing static String.
+ * Creates a String object with pre-allocation for Strings up to `capa` long.
  *
- * The object still needs to be frees, but the string isn't copied and isn't
- * freed.
+ * If `capa` is zero, a whole memory page will be allocated.
  *
- * NOTICE: static strings can't be written to.
+ * Remember to use `fiobj_free`.
  */
-FIOBJ fiobj_str_static(const char *str, size_t len);
+FIOBJ fiobj_str_buf(size_t capa);
 
 /** Creates a copy from an existing String. Remember to use `fiobj_free`. */
 static inline __attribute__((unused)) FIOBJ fiobj_str_copy(FIOBJ src) {
-  fio_cstr_s s = fiobj_obj2cstr(src);
+  fio_str_info_s s = fiobj_obj2cstr(src);
   return fiobj_str_new(s.data, s.len);
 }
 
 /**
  * Creates a String object. Remember to use `fiobj_free`.
  *
- * The ownership of the memory indicated by `str` will now "move" to the object.
+ * It's possible to wrap a previosly allocated memory block in a FIOBJ String
+ * object, as long as it was allocated using `fio_malloc`.
+ *
+ * The ownership of the memory indicated by `str` will "move" to the object and
+ * will be freed (using `fio_free`) once the object's reference count drops to
+ * zero.
  *
- * The original memory MUST be allocated using `fio_malloc` (NOT the system's
- * `malloc`) and it will be freed by the `fiobj` library using `fio_free`.
+ * Note: The original memory MUST be allocated using `fio_malloc` (NOT the
+ *       system's `malloc`) and it will be freed using `fio_free`.
  */
 FIOBJ fiobj_str_move(char *str, size_t len, size_t capacity);
 
@@ -60,29 +56,6 @@ FIOBJ fiobj_str_move(char *str, size_t len, size_t capacity);
  */
 FIOBJ fiobj_str_tmp(void);
 
-/** Creates a String object using a printf like interface. */
-__attribute__((format(printf, 1, 0))) FIOBJ fiobj_strvprintf(const char *format,
-                                                             va_list argv);
-
-/** Creates a String object using a printf like interface. */
-__attribute__((format(printf, 1, 2))) FIOBJ fiobj_strprintf(const char *format,
-                                                            ...);
-
-/** 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 out of
- * bounds (i.e., beyond the EOF position), FIOBJ_INVALID is returned.
- *
- * If `start_at` is negative, it will be computed from the end of the file.
- *
- * Remember to use `fiobj_free`.
- *
- * NOTE: Requires a UNIX system, otherwise always returns FIOBJ_INVALID.
- */
-FIOBJ fiobj_str_readfile(const char *filename, intptr_t start_at,
-                         intptr_t limit);
-
 /* *****************************************************************************
 API: Editing a String
 ***************************************************************************** */
@@ -90,29 +63,35 @@ API: Editing a String
 /**
  * Prevents the String object from being changed.
  *
- * When a String is used as a key for a Hash, it is automatically frozenn to
+ * When a String is used as a key for a Hash, it is automatically frozen to
  * prevent the Hash from becoming broken.
- *
- * A call to `fiobj_str_hash` or `fiobj_obj2hash` will automactically freeze the
- * String.
  */
 void fiobj_str_freeze(FIOBJ str);
 
 /**
- * Confirms the requested capacity is available and allocates as required.
+ * Confirms the String allows for the requested capacity (counting used space as
+ * well as free space).
  *
  * Returns updated capacity.
  */
 size_t fiobj_str_capa_assert(FIOBJ str, size_t size);
 
-/** Return's a String's capacity, if any. This should include the NUL byte. */
+/** Returns a String's capacity, if any. This should include the NUL byte. */
 size_t fiobj_str_capa(FIOBJ str);
 
 /** Resizes a String object, allocating more memory if required. */
 void fiobj_str_resize(FIOBJ str, size_t size);
 
-/** Deallocates any unnecessary memory (if supported by OS). */
-void fiobj_str_minimize(FIOBJ str);
+/**
+ * Performs a best attempt at minimizing memory consumption.
+ *
+ * Actual effects depend on the underlying memory allocator and it's
+ * implementation. Not all allocators will free any memory.
+ */
+void fiobj_str_compact(FIOBJ str);
+
+/** Alias for `fiobj_str_compact`. */
+#define fiobj_str_minimize(str) fiobj_str_compact((str))
 
 /** Empties a String's data. */
 void fiobj_str_clear(FIOBJ str);
@@ -124,11 +103,27 @@ void fiobj_str_clear(FIOBJ str);
 size_t fiobj_str_write(FIOBJ dest, const char *data, size_t len);
 
 /**
- * Writes data at the end of the string, resizing the string as required.
+ * Writes a number at the end of the String using normal base 10 notation.
+ *
  * Returns the new length of the String
  */
+size_t fiobj_str_write_i(FIOBJ dest, int64_t num);
+
+/**
+ * Writes data at the end of the string using a printf like interface, resizing
+ * the string as required. Returns the new length of the String
+ */
 __attribute__((format(printf, 2, 3))) size_t
-fiobj_str_write2(FIOBJ dest, const char *format, ...);
+fiobj_str_printf(FIOBJ dest, const char *format, ...);
+
+/**
+ * Writes data at the end of the string using a vprintf like interface, resizing
+ * the string as required.
+ *
+ * Returns the new length of the String
+ */
+__attribute__((format(printf, 2, 0))) size_t
+fiobj_str_vprintf(FIOBJ dest, const char *format, va_list argv);
 
 /**
  * Writes data at the end of the string, resizing the string as required.
@@ -137,7 +132,25 @@ fiobj_str_write2(FIOBJ dest, const char *format, ...);
  *
  * Returns the new length of the String.
  */
-size_t fiobj_str_join(FIOBJ dest, FIOBJ source);
+size_t fiobj_str_concat(FIOBJ dest, FIOBJ source);
+#define fiobj_str_join(dest, src) fiobj_str_concat((dest), (src))
+
+/**
+ * Dumps the `filename` file's contents at the end of the 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 out of
+ * bounds (i.e., beyond the EOF position), FIOBJ_INVALID is returned.
+ *
+ * If `start_at` is negative, it will be computed from the end of the file.
+ *
+ * Remember to use `fiobj_free`.
+ *
+ * NOTE: Requires a UNIX system, otherwise always returns FIOBJ_INVALID.
+ */
+size_t fiobj_str_readfile(FIOBJ dest, const char *filename, intptr_t start_at,
+                          intptr_t limit);
 
 /* *****************************************************************************
 API: String Values
@@ -145,9 +158,6 @@ API: String Values
 
 /**
  * Calculates a String's SipHash value for possible use as a HashMap key.
- *
- * Hashing the String's value automatically freezes the string, preventing
- * future changes.
  */
 uint64_t fiobj_str_hash(FIOBJ o);
 

data/ext/iodine/fiobject.c

@@ -7,18 +7,53 @@ License: MIT
 This facil.io core library provides wrappers around complex and (or) dynamic
 types, abstracting some complexity and making dynamic type related tasks easier.
 */
-#include "fiobject.h"
+#include <fiobject.h>
 
-#include "fio_ary.h"
-
-#define FIO_OVERRIDE_MALLOC 1
-#include "fio_mem.h"
+#include <fio_ary.h>
 
 #include <stdarg.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 
+/* *****************************************************************************
+Use the facil.io allocator when available
+***************************************************************************** */
+
+#pragma weak fio_malloc
+void *__attribute__((weak)) fio_malloc(size_t size) {
+  void *m = malloc(size);
+  if (m)
+    memset(m, 0, size);
+  return m;
+}
+
+#pragma weak fio_calloc
+void *__attribute__((weak)) fio_calloc(size_t size, size_t count) {
+  return calloc(size, count);
+}
+
+#pragma weak fio_free
+void __attribute__((weak)) fio_free(void *ptr) { free(ptr); }
+
+#pragma weak fio_realloc
+void *__attribute__((weak)) fio_realloc(void *ptr, size_t new_size) {
+  return realloc(ptr, new_size);
+}
+
+#pragma weak fio_realloc2
+void *__attribute__((weak))
+fio_realloc2(void *ptr, size_t new_size, size_t valid_len) {
+  return realloc(ptr, new_size);
+  (void)valid_len;
+}
+
+#pragma weak fio_mmap
+void *__attribute__((weak)) fio_mmap(size_t size) { return fio_malloc(size); }
+
+#define FIO_OVERRIDE_MALLOC 1
+#include <fiobj_mem.h>
+
 /* *****************************************************************************
 the `fiobj_each2` function
 ***************************************************************************** */
@@ -77,7 +112,10 @@ size_t fiobj_each2(FIOBJ o, int (*task)(FIOBJ obj, void *arg), void *arg) {
   uintptr_t pos = 0;
   fio_ary_s stack = FIO_ARY_INIT;
   struct task_packet_s packet = {
-      .task = task, .arg = arg, .stack = &stack, .counter = 1,
+      .task = task,
+      .arg = arg,
+      .stack = &stack,
+      .counter = 1,
   };
   do {
     if (!pos)
@@ -142,7 +180,7 @@ void fiobj_free_complex_object(FIOBJ o) {
 /* *****************************************************************************
 Is Equal?
 ***************************************************************************** */
-#include "fiobj_hash.h"
+#include <fiobj_hash.h>
 
 static inline int fiobj_iseq_simple(const FIOBJ o, const FIOBJ o2) {
   if (o == o2)
@@ -228,9 +266,9 @@ size_t fiobject___noop_is_eq(const FIOBJ o1, const FIOBJ o2) {
   return 0;
 }
 
-fio_cstr_s fiobject___noop_to_str(const FIOBJ o) {
+fio_str_info_s fiobject___noop_to_str(const FIOBJ o) {
   (void)o;
-  return (fio_cstr_s){.len = 0, .data = NULL};
+  return (fio_str_info_s){.len = 0, .data = NULL};
 }
 intptr_t fiobject___noop_to_i(const FIOBJ o) {
   (void)o;
@@ -243,8 +281,8 @@ double fiobject___noop_to_f(const FIOBJ o) {
 
 #if DEBUG
 
-#include "fiobj_ary.h"
-#include "fiobj_numbers.h"
+#include <fiobj_ary.h>
+#include <fiobj_numbers.h>
 
 static int fiobject_test_task(FIOBJ o, void *arg) {
   ++((uintptr_t *)arg)[0];

data/ext/iodine/fiobject.h

@@ -21,10 +21,16 @@ types, abstracting some complexity and making dynamic type related tasks easier.
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "fio_siphash.h"
-
-#if !defined(__GNUC__)
-#define __attribute__(x) /* :-( */
+#include <fio_siphash.h>
+
+#if !defined(__GNUC__) && !defined(__clang__) && !defined(FIO_GNUC_BYPASS)
+#define __attribute__(...)
+#define __has_include(...) 0
+#define __has_builtin(...) 0
+#define FIO_GNUC_BYPASS 1
+#elif !defined(__clang__) && __GNUC__ < 5
+#define __has_builtin(...) 0
+#define FIO_GNUC_BYPASS 1
 #endif
 
 #ifdef __cplusplus
@@ -56,20 +62,15 @@ typedef uintptr_t FIOBJ;
 #define FIOBJ_IS_NULL(obj) (!obj || obj == (FIOBJ)FIOBJ_T_NULL)
 #define FIOBJ_INVALID 0
 
-/** A string information type, reports anformation about a C string. */
-typedef struct {
-  union {
-    size_t len;
-    size_t length;
-  };
-  union {
-    void *buffer;
-    uint8_t *bytes;
-    char *data;
-    char *value;
-    char *name;
-  };
-} fio_cstr_s;
+#ifndef FIO_STR_INFO_TYPE
+/** A String information type, reports information about a C string. */
+typedef struct fio_str_info_s {
+  size_t capa; /* Buffer capacity, if the string is writable. */
+  size_t len;  /* String length. */
+  char *data;  /* String's first byte. */
+} fio_str_info_s;
+#define FIO_STR_INFO_TYPE
+#endif
 
 /* *****************************************************************************
 Primitives
@@ -89,8 +90,10 @@ Generic Object API
 FIO_INLINE const char *fiobj_type_name(const FIOBJ obj);
 
 /**
- * Heruistic copy with a preference for copy reference(!) to minimize
- * allocations. reference count.
+ * Heuristic copy with a preference for copy reference(!) to minimize
+ * allocations.
+ *
+ * Always returns the value passed along.
  */
 FIO_INLINE FIOBJ fiobj_dup(FIOBJ);
 
@@ -136,7 +139,7 @@ FIO_INLINE intptr_t fiobj_obj2num(const FIOBJ obj);
 FIO_INLINE double fiobj_obj2float(const FIOBJ obj);
 
 /**
- * Returns a C String (NUL terminated) using the `fio_cstr_s` data type.
+ * Returns a C String (NUL terminated) using the `fio_str_info_s` data type.
  *
  * The Sting in binary safe and might contain NUL bytes in the middle as well as
  * a terminating NUL.
@@ -148,13 +151,13 @@ FIO_INLINE double fiobj_obj2float(const FIOBJ obj);
  *
  * A type error results in NULL (i.e. object isn't a String).
  */
-FIO_INLINE fio_cstr_s fiobj_obj2cstr(const FIOBJ obj);
+FIO_INLINE fio_str_info_s fiobj_obj2cstr(const FIOBJ obj);
 
 /**
  * Calculates an Objects's SipHash value for possible use as a HashMap key.
  *
  * The Object MUST answer to the fiobj_obj2cstr, or the result is unusable. In
- * other waords, Hash Objects and Arrays can NOT be used for Hash keys.
+ * other words, Hash Objects and Arrays can NOT be used for Hash keys.
  */
 FIO_INLINE uint64_t fiobj_obj2hash(const FIOBJ o);
 
@@ -167,10 +170,8 @@ FIO_INLINE uint64_t fiobj_obj2hash(const FIOBJ o);
  *
  * The callback task function must accept an object and an opaque user pointer.
  *
- * Hash objects pass along a `FIOBJ_T_COUPLET` object, containing
- * references for both the key and the object. Keys shouldn't be altered once
- * placed as a key (or the Hash will break). Collections (Arrays / Hashes) can't
- * be used as keeys.
+ * Hash objects pass along only the value object. The keys can be accessed using
+ * the `fiobj_hash_key_in_loop` function.
  *
  * If the callback returns -1, the loop is broken. Any other value is ignored.
  *
@@ -310,7 +311,7 @@ typedef struct {
   size_t (*const each)(FIOBJ, size_t start_at, int (*task)(FIOBJ, void *),
                        void *);
   /* object value as String */
-  fio_cstr_s (*const to_str)(const FIOBJ);
+  fio_str_info_s (*const to_str)(const FIOBJ);
   /* object value as Integer */
   intptr_t (*const to_i)(const FIOBJ);
   /* object value as Float */
@@ -487,13 +488,13 @@ FIO_INLINE intptr_t fiobj_obj2num(const FIOBJ o) {
 }
 
 /** Converts a number to a temporary, thread safe, C string object */
-fio_cstr_s fio_ltocstr(long);
+fio_str_info_s fio_ltocstr(long);
 
 /** Converts a float to a temporary, thread safe, C string object */
-fio_cstr_s fio_ftocstr(double);
+fio_str_info_s fio_ftocstr(double);
 
 /**
- * Returns a C String (NUL terminated) using the `fio_cstr_s` data type.
+ * Returns a C String (NUL terminated) using the `fio_str_info_s` data type.
  *
  * The Sting in binary safe and might contain NUL bytes in the middle as well as
  * a terminating NUL.
@@ -505,9 +506,9 @@ fio_cstr_s fio_ftocstr(double);
  *
  * A type error results in NULL (i.e. object isn't a String).
  */
-FIO_INLINE fio_cstr_s fiobj_obj2cstr(const FIOBJ o) {
+FIO_INLINE fio_str_info_s fiobj_obj2cstr(const FIOBJ o) {
   if (!o) {
-    fio_cstr_s ret = {{4}, {(void *)"null"}};
+    fio_str_info_s ret = {0, 4, (char *)"null"};
     return ret;
   }
   if (o & FIOBJECT_NUMBER_FLAG)
@@ -515,15 +516,15 @@ FIO_INLINE fio_cstr_s fiobj_obj2cstr(const FIOBJ o) {
   if ((o & FIOBJECT_PRIMITIVE_FLAG) == FIOBJECT_PRIMITIVE_FLAG) {
     switch ((fiobj_type_enum)o) {
     case FIOBJ_T_NULL: {
-      fio_cstr_s ret = {{4}, {(void *)"null"}};
+      fio_str_info_s ret = {0, 4, (char *)"null"};
       return ret;
     }
     case FIOBJ_T_FALSE: {
-      fio_cstr_s ret = {{5}, {(void *)"false"}};
+      fio_str_info_s ret = {0, 5, (char *)"false"};
       return ret;
     }
     case FIOBJ_T_TRUE: {
-      fio_cstr_s ret = {{4}, {(void *)"true"}};
+      fio_str_info_s ret = {0, 4, (char *)"true"};
       return ret;
     }
     default:
@@ -539,15 +540,15 @@ uint64_t fiobj_str_hash(FIOBJ o);
  * Calculates an Objects's SipHash value for possible use as a HashMap key.
  *
  * The Object MUST answer to the fiobj_obj2cstr, or the result is unusable. In
- * other waords, Hash Objects and Arrays can NOT be used for Hash keys.
+ * other words, Hash Objects and Arrays can NOT be used for Hash keys.
  */
 FIO_INLINE uint64_t fiobj_obj2hash(const FIOBJ o) {
   if (FIOBJ_TYPE_IS(o, FIOBJ_T_STRING))
     return fiobj_str_hash(o);
   if (!FIOBJ_IS_ALLOCATED(o))
     return (uint64_t)o;
-  fio_cstr_s s = fiobj_obj2cstr(o);
-  return fio_siphash(s.buffer, s.len);
+  fio_str_info_s s = fiobj_obj2cstr(o);
+  return fio_siphash(s.data, s.len);
 }
 
 /**