iodine 0.6.5 → 0.7.0

data/ext/iodine/fio_cli.h

@@ -5,47 +5,6 @@ License: MIT
 Feel free to copy, use and enjoy according to the license provided.
 */
 #ifndef H_FIO_CLI_HELPER_H
-/**
-
-This is a customized version for command line interface (CLI) arguments. All
-arguments are converted into a key-value paired Hash.
-
-The CLI helper automatically provides `-?`, `-h` and `-help` support that
-prints a short explanation for every option and exits.
-
-The CLI will parse arguments in the form `-arg value` as well as `-arg=value`
-and `-argvalue`
-
-NOTICE:
-
-This interface is NOT thread-safe, since normally the command line arguments are
-parsed before new threads are spawned.
-
-It's important to set all the requirement before requesting any results,
-otherwise, parsing errors might occure - i.e., allowed parameters would be
-parsed as errors, since they hadn't been declared yet.
-
-EXAMPLE:
-
-    // initialize the CLI helper.
-    fio_cli_start(argc, argv, "App description or NULL");
-
-    // setup possible command line arguments.
-    fio_cli_accept_num("port p", "the port to listen to, defaults to 3000.");
-    fio_cli_accept_bool("log v", "enable logging");
-
-    // read command line arguments and copy results.
-    uint8_t logging = fio_cli_get_int("v");
-    const char *port = fio_cli_get_str("port");
-    if (!port)
-      port = "3000";
-    // use parsed information.
-    // ...
-    // cleanup
-    fio_cli_end();
-
-
-*/
 #define H_FIO_CLI_HELPER_H
 
 /* support C++ */
@@ -53,102 +12,122 @@ EXAMPLE:
 extern "C" {
 #endif
 
-/** Initialize the CLI helper and adds the `info` string to the help section. */
-void fio_cli_start(int argc, const char **argv, const char *info);
+/* *****************************************************************************
+CLI API
+***************************************************************************** */
 
-/** Tells the CLI helper to ignore unrecognized command line arguments. */
-void fio_cli_ignore_unknown(void);
-
-/** Clears the memory and resources related to the CLI helper. */
-void fio_cli_end(void);
+/** Indicates the previous CLI argument should be a String (default). */
+#define FIO_CLI_TYPE_STRING ((char *)0x1)
+/** Indicates the previous CLI argument is a Boolean value. */
+#define FIO_CLI_TYPE_BOOL ((char *)0x2)
+/** Indicates the previous CLI argument should be an Integer (numerical). */
+#define FIO_CLI_TYPE_INT ((char *)0x3)
 
 /**
- * Sets a CLI acceptable argument of type Number (both `int` and `float`).
+ * This function parses the Command Line Interface (CLI), creating a temporary
+ * "dictionary" that allows easy access to the CLI using their names or aliases.
  *
- * The `aliases` string sets aliases for the same argument. i.e. "string s".
- * Notice that collisions will prefer new information quitely.
+ * Command line arguments may be typed. If an optional type requirement is
+ * provided and the provided arument fails to match the required type, execution
+ * will end and an error message will be printed along with a short "help".
  *
- * The first alias will be the name available for `fio_cli_get_*` functions.
+ * The following optional type requirements are:
  *
- * The `desc` string will be printed if `-?`, `-h` of `-help` are used.
+ * * FIO_CLI_TYPE_STRING - (default) string argument.
+ * * FIO_CLI_TYPE_BOOL   - boolean argument (no value).
+ * * FIO_CLI_TYPE_INT    - integer argument ('-', '+', '0'-'9' chars accepted).
  *
- * The function will crash the application on failure, printing an error
- * message.
- */
-void fio_cli_accept_num(const char *aliases, const char *desc);
-
-/**
- * Sets a CLI acceptable argument of type String.
+ * Argument names MUST start with the '-' character. The first word starting
+ * without the '-' character will begin the description for the CLI argument.
  *
- * The `aliases` string sets aliases for the same argument. i.e. "string s".
+ * The arguments "-?", "-h", "-help" and "--help" are automatically handled
+ * unless overridden.
  *
- * The first alias will be the name used
+ * Example use:
  *
- * The `desc` string will be printed if `-?`, `-h` of `-help` are used.
+ *    fio_cli_start(argc, argv, 0, "this example accepts the following:",
+ *                  "-t -thread number of threads to run.", FIO_CLI_TYPE_INT,
+ *                  "-w -workers number of workers to run.", FIO_CLI_TYPE_INT,
+ *                  "-b, -address the address to bind to.",
+ *                  "-p,-port the port to bind to.", FIO_CLI_TYPE_INT,
+ *                  "-v -log enable logging.", FIO_CLI_TYPE_BOOL);
  *
- * The function will crash the application on failure, printing an error
- * message.
- */
-void fio_cli_accept_str(const char *aliases, const char *desc);
-
-/**
- * Sets a CLI acceptable argument of type Bool (true if exists).
  *
- * The `aliases` string sets aliases for the same argument. i.e. "string s".
+ * This would allow access to the named arguments:
  *
- * The first alias will be the name available for `fio_cli_get_*` functions.
+ *      fio_cli_get("-b") == fio_cli_get("-address");
  *
- * The `desc` string will be printed if `-?`, `-h` of `-help` are used.
  *
- * The function will crash the application on failure, printing an error
- * message.
- */
-void fio_cli_accept_bool(const char *aliases, const char *desc);
-
-/**
- * Returns a C String containing the value of the received argument, or NULL if
- * none.
+ * Once all the data was accessed, free the parsed data dictionary using:
+ *
+ *      fio_cli_end();
  *
- * Boolean that were set to TRUE have the string "1".
+ * It should be noted, arguments will be recognized in a number of forms, i.e.:
+ *
+ *      app -t=1 -p3000 -a localhost
+ *
+ * This function is NOT thread safe.
  */
-const char *fio_cli_get_str(const char *opt);
-
+#define fio_cli_start(argc, argv, allow_unknown, description, ...)             \
+  fio_cli_start((argc), (argv), (allow_unknown), (description),                \
+                (char const *[]){__VA_ARGS__, NULL})
+#define FIO_CLI_IGNORE
 /**
- * Returns an Integer containing the parsed value of the argument.
- *
- * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ * Never use the function directly, always use the MACRO, because the macro
+ * attaches a NULL marker at the end of the `names` argument collection.
  */
-int fio_cli_get_int(const char *opt);
-
+void fio_cli_start FIO_CLI_IGNORE(int argc, char const *argv[],
+                                  int allow_unknown, char const *description,
+                                  char const **names);
 /**
- * Returns a Float containing the parsed value of the argument.
+ * Clears the memory used by the CLI dictionary, removing all parsed data.
  *
- * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ * This function is NOT thread safe.
  */
-double fio_cli_get_float(const char *opt);
+void fio_cli_end(void);
+
+/** Returns the argument's value as a NUL terminated C String. */
+char const *fio_cli_get(char const *name);
+
+/** Returns the argument's value as an integer. */
+int fio_cli_get_i(char const *name);
+
+/** This MACRO returns the argument's value as a boolean. */
+#define fio_cli_get_bool(name) (fio_cli_get((name)) != NULL)
+
+/** Returns the number of unrecognized argument. */
+unsigned int fio_cli_unknown_count(void);
+
+/** Returns the unrecognized argument using a 0 based `index`. */
+char const *fio_cli_unknown(unsigned int index);
 
 /**
- * Overrides the existing value of the argument with the requested C String.
+ * Sets the argument's value as a NUL terminated C String (no copy!).
  *
- * The String isn't copied, it's only referenced.
+ * CAREFUL: This does not automatically detect aliases or type violations! it
+ * will only effect the specific name given, even if invalid. i.e.:
  *
- * Boolean that were set to TRUE have the string "1".
- */
-void fio_cli_set_str(const char *opt, const char *value);
-
-/**
- * Overrides the existing value of the argument with the requested Integer.
+ *     fio_cli_start(argc, argv,
+ *                  "this is example accepts the following options:",
+ *                  "-p -port the port to bind to", FIO_CLI_TYPE_INT;
+ *
+ *     fio_cli_set("-p", "hello"); // fio_cli_get("-p") != fio_cli_get("-port");
  *
- * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ * Note: this does NOT copy the C strings to memory. Memory should be kept alive
+ * until `fio_cli_end` is called.
  */
-void fio_cli_set_int(const char *opt, int value);
+void fio_cli_set(char const *name, char const *value);
 
 /**
- * Overrides the existing value of the argument with the requested Float.
+ * This MACRO is the same as:
  *
- * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ *     if(!fio_cli_get(name)) {
+ *       fio_cli_set(name, value)
+ *     }
  */
-void fio_cli_set_float(const char *opt, double value);
+#define fio_cli_set_default(name, value)                                       \
+  if (!fio_cli_get((name)))                                                    \
+    fio_cli_set(name, value);
 
 #ifdef __cplusplus
 } /* extern "C" */

data/ext/iodine/fio_hashmap.h

@@ -5,8 +5,11 @@ License: MIT
 */
 
 /**
- * A simple ordered Hash Table implementation, with a minimal API and zero hash
- * collision protection.
+ * A simple ordered Hash Table implementation, with a minimal API.
+ *
+ * Keys types are adjustable using macros. A single C file is limited to a
+ * single key type. Keys can be strings, integers, anything. By default, keys
+ * are uint64_t.
  *
  * Unique keys are required. Full key collisions aren't handled, instead the old
  * value is replaced and returned.
@@ -150,6 +153,11 @@ FIO_FUNC inline size_t fio_hash_count(const fio_hash_s *hash);
  */
 FIO_FUNC inline size_t fio_hash_capa(const fio_hash_s *hash);
 
+/**
+ * Returns non-zero if the hash is fragmented (more than 50% holes).
+ */
+FIO_FUNC inline size_t fio_hash_is_fragmented(const fio_hash_s *hash);
+
 /**
  * Attempts to minimize memory usage by removing empty spaces caused by deleted
  * items and rehashing the Hash Map.
@@ -324,20 +332,21 @@ FIO_FUNC inline uintptr_t fio_hash_map_cuckoo_steps(uintptr_t step) {
 /* seeks the hash's position in the map */
 FIO_FUNC fio_hash_data_s *fio_hash_seek_pos_(fio_hash_s *hash,
                                              FIO_HASH_KEY_TYPE key) {
+  const uint64_t hashed_key = FIO_HASH_KEY2UINT(key);
   /* TODO: consider implementing Robing Hood reordering during seek? */
-  fio_hash_data_s *pos = hash->map + (FIO_HASH_KEY2UINT(key) & hash->mask);
+  fio_hash_data_s *pos = hash->map + (hashed_key & hash->mask);
   uintptr_t i = 0;
   const uintptr_t limit = hash->capa > FIO_HASH_MAX_MAP_SEEK
                               ? FIO_HASH_MAX_MAP_SEEK
                               : ((hash->capa >> 1) | 1);
   while (i < limit) {
     if (FIO_HASH_KEY_ISINVALID(pos->key) ||
-        (FIO_HASH_KEY2UINT(pos->key) == FIO_HASH_KEY2UINT(key) &&
+        (FIO_HASH_KEY2UINT(pos->key) == hashed_key &&
          FIO_HASH_COMPARE_KEYS(pos->key, key)))
       return pos;
-    pos = hash->map + (((FIO_HASH_KEY2UINT(key) & hash->mask) +
-                        fio_hash_map_cuckoo_steps(i++)) &
-                       hash->mask);
+    pos = hash->map +
+          (((hashed_key & hash->mask) + fio_hash_map_cuckoo_steps(i++)) &
+           hash->mask);
   }
   return NULL;
 }
@@ -357,9 +366,14 @@ FIO_FUNC inline void *fio_hash_find(fio_hash_s *hash, FIO_HASH_KEY_TYPE key) {
  */
 FIO_FUNC void *fio_hash_insert(fio_hash_s *hash, FIO_HASH_KEY_TYPE key,
                                void *obj) {
+  /* nothing to do if there's nothing to do. */
+  if (!obj && !hash->count) {
+    return NULL;
+  }
   /* ensure some space */
-  if (obj && hash->pos >= hash->capa)
+  if (obj && hash->pos >= hash->capa) {
     fio_hash_rehash(hash);
+  }
 
   /* find where the object belongs in the map */
   fio_hash_data_s *info = fio_hash_seek_pos_(hash, key);
@@ -603,7 +617,7 @@ FIO_FUNC inline size_t fio_hash_count(const fio_hash_s *hash) {
 
 /**
  * Returns a temporary theoretical Hash map capacity.
- * This could be used for testig performance and memory consumption.
+ * This could be used for testing performance and memory consumption.
  */
 FIO_FUNC inline size_t fio_hash_capa(const fio_hash_s *hash) {
   if (!hash)
@@ -611,6 +625,13 @@ FIO_FUNC inline size_t fio_hash_capa(const fio_hash_s *hash) {
   return hash->capa;
 }
 
+/**
+ * Returns non-zero if the hash is fragmented (more than 50% holes).
+ */
+FIO_FUNC inline size_t fio_hash_is_fragmented(const fio_hash_s *hash) {
+  return (hash->pos > (hash->count << 1));
+}
+
 /**
  * Attempts to minimize memory usage by removing empty spaces caused by deleted
  * items and rehashing the Hash Map.
@@ -656,7 +677,7 @@ FIO_FUNC void fio_hash_test(void) {
 #define TEST_ASSERT(cond, ...)                                                 \
   if (!(cond)) {                                                               \
     fprintf(stderr, "* " __VA_ARGS__);                                         \
-    fprintf(stderr, "Testing failed.\n");                                      \
+    fprintf(stderr, "\n !!! Testing failed !!!\n");                            \
     exit(-1);                                                                  \
   }
   fio_hash_s h = {.capa = 0};
@@ -693,13 +714,13 @@ FIO_FUNC void fio_hash_test(void) {
     fio_hash_insert(&h, 1, (void *)1);
     TEST_ASSERT(
         count + 1 == h.count,
-        "Readding a removed item should increase count by 1 (%zu + 1 != %zu).",
+        "Re-adding a removed item should increase count by 1 (%zu + 1 != %zu).",
         count, (size_t)h.count);
     TEST_ASSERT(
         pos == h.pos,
-        "Readding a removed item shouldn't change the position marker!");
+        "Re-adding a removed item shouldn't change the position marker!");
     TEST_ASSERT(fio_hash_find(&h, 1) == (void *)1,
-                "Readding a removed item should update the item (%p != 1)!",
+                "Re-adding a removed item should update the item (%p != 1)!",
                 fio_hash_find(&h, 1));
     fio_hash_insert(&h, 1, NULL);
     TEST_ASSERT(count == h.count,
@@ -738,7 +759,7 @@ FIO_FUNC void fio_hash_test(void) {
   fprintf(stderr, "* Compacting Hash to %lu\n", FIO_HASHMAP_TEXT_COUNT >> 1);
   fio_hash_compact(&h);
   {
-    fprintf(stderr, "* Testing that %lu items are continues\n",
+    fprintf(stderr, "* Testing that %lu items are continuous\n",
             FIO_HASHMAP_TEXT_COUNT >> 1);
     uintptr_t i = 0;
     FIO_HASH_FOR_LOOP(&h, pos) {
@@ -748,12 +769,45 @@ FIO_FUNC void fio_hash_test(void) {
     }
     TEST_ASSERT(i == h.count, "count error (%lu != %lu).", i, h.count);
   }
+
+  fio_hash_free(&h);
+  TEST_ASSERT(!h.map && !h.ordered && !h.pos && !h.capa,
+              "Hash not re-initialized after fio_hash_free");
+
+  fio_hash_new2(&h, FIO_HASHMAP_TEXT_COUNT);
+  for (unsigned long i = 1; i < FIO_HASHMAP_TEXT_COUNT; ++i) {
+    fio_hash_insert(&h, i, (void *)i);
+    TEST_ASSERT((i == (uintptr_t)fio_hash_find(&h, i)),
+                "insertion (2nd round) != find");
+  }
+  for (unsigned long i = 1; i < FIO_HASHMAP_TEXT_COUNT; i += 2) {
+    uintptr_t old = (uintptr_t)fio_hash_insert(&h, i, NULL);
+    TEST_ASSERT(old == i, "Removal didn't return old value.");
+    TEST_ASSERT(!(fio_hash_find(&h, i)), "Removal failed (still exists).");
+  }
+  fio_hash_rehash(&h);
+  {
+    fprintf(stderr,
+            "* Testing that %lu items are continuous (after rehashing)\n",
+            FIO_HASHMAP_TEXT_COUNT >> 1);
+    uintptr_t i = 0;
+    FIO_HASH_FOR_LOOP(&h, pos) {
+      TEST_ASSERT(pos->obj, "Found a hole after compact.");
+      TEST_ASSERT(pos->key == (uintptr_t)pos->obj, "Key and value mismatch.");
+      ++i;
+    }
+    TEST_ASSERT(i == h.count, "count error (%lu != %lu) post rehash.", i,
+                h.count);
+  }
   fio_hash_free(&h);
-  fprintf(stderr, "* passed... without testing that FIO_HASH_KEY_DESTROY is "
-                  "called only once.\n");
 }
+
+#undef TEST_ASSERT
 #endif /* DEBUG Testing */
 
+#undef FIO_HASH_REALLOC
+#undef FIO_HASH_CALLOC
+#undef FIO_HASH_FREE
 #undef FIO_FUNC
 
 #endif /* H_FIO_SIMPLE_HASH_H */

data/ext/iodine/fio_json_parser.h

@@ -26,6 +26,16 @@
 #include <stdio.h>
 #endif
 
+#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
+
 /* *****************************************************************************
 JSON API
 ***************************************************************************** */
@@ -192,36 +202,37 @@ static inline int seek2marker(uint8_t **buffer,
   /* too short for this mess */
   if ((uintptr_t)limit <= 8 + ((uintptr_t)*buffer & (~(uintptr_t)7)))
     goto finish;
-
   /* align memory */
-  {
-    const uint8_t *alignment =
-        (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
-    if (limit >= alignment) {
-      while (*buffer < alignment) {
-        if (string_seek_stop[**buffer])
-          return 1;
-        *buffer += 1;
+  if (1) {
+    {
+      const uint8_t *alignment =
+          (uint8_t *)(((uintptr_t)(*buffer) & (~(uintptr_t)7)) + 8);
+      if (limit >= alignment) {
+        while (*buffer < alignment) {
+          if (string_seek_stop[**buffer])
+            return 1;
+          *buffer += 1;
+        }
       }
     }
-  }
-  const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
+    const uint8_t *limit64 = (uint8_t *)((uintptr_t)limit & (~(uintptr_t)7));
 #else
   const uint8_t *limit64 = (uint8_t *)limit - 7;
 #endif
-  uint64_t wanted1 = 0x0101010101010101ULL * '"';
-  uint64_t wanted2 = 0x0101010101010101ULL * '\\';
-  for (; *buffer < limit64; *buffer += 8) {
-    const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
-    const uint64_t t1 =
-        ((eq1 & 0x7f7f7f7f7f7f7f7fULL) + 0x0101010101010101ULL) &
-        (eq1 & 0x8080808080808080ULL);
-    const uint64_t eq2 = ~((*((uint64_t *)*buffer)) ^ wanted2);
-    const uint64_t t2 =
-        ((eq2 & 0x7f7f7f7f7f7f7f7fULL) + 0x0101010101010101ULL) &
-        (eq2 & 0x8080808080808080ULL);
-    if ((t1 | t2)) {
-      break;
+    uint64_t wanted1 = 0x0101010101010101ULL * '"';
+    uint64_t wanted2 = 0x0101010101010101ULL * '\\';
+    for (; *buffer < limit64; *buffer += 8) {
+      const uint64_t eq1 = ~((*((uint64_t *)*buffer)) ^ wanted1);
+      const uint64_t t1 =
+          ((eq1 & 0x7f7f7f7f7f7f7f7fULL) + 0x0101010101010101ULL) &
+          (eq1 & 0x8080808080808080ULL);
+      const uint64_t eq2 = ~((*((uint64_t *)*buffer)) ^ wanted2);
+      const uint64_t t2 =
+          ((eq2 & 0x7f7f7f7f7f7f7f7fULL) + 0x0101010101010101ULL) &
+          (eq2 & 0x8080808080808080ULL);
+      if ((t1 | t2)) {
+        break;
+      }
     }
   }
 #if !ALLOW_UNALIGNED_MEMORY_ACCESS || (!__x86_64__ && !__aarch64__)