iodine 0.4.8 → 0.4.10

data/ext/iodine/defer.c

@@ -201,6 +201,7 @@ void defer_thread_throttle(unsigned long microsec) { return; }
 
 #endif /* DEBUG || pthread default */
 
+/* thread pool data container */
 struct defer_pool {
   unsigned int flag;
   unsigned int count;
@@ -352,8 +353,10 @@ int defer_perform_in_fork(unsigned int process_count,
     goto finish;
   };
 
-  /* setup zomie reaping */
+/* setup zomie reaping */
+#if !defined(NO_CHILD_REAPER) || NO_CHILD_REAPER == 0
   reap_children();
+#endif
 
   if (!process_count)
     process_count = 1;
@@ -469,6 +472,18 @@ void defer_test(void) {
   time_t start, end;
   fprintf(stderr, "Starting defer testing\n");
 
+  spn_lock(&i_lock);
+  i_count = 0;
+  spn_unlock(&i_lock);
+  start = clock();
+  for (size_t i = 0; i < (1024 * 1024); i++) {
+    sample_task(NULL, NULL);
+  }
+  end = clock();
+  fprintf(stderr,
+          "Deferless (direct call) counter: %lu cycles with i_count = %lu\n",
+          end - start, i_count);
+
   spn_lock(&i_lock);
   i_count = 0;
   spn_unlock(&i_lock);

data/ext/iodine/defer.h

@@ -19,6 +19,11 @@ forked process.
 #define LIB_DEFER_VERSION_MINOR 1
 #define LIB_DEFER_VERSION_PATCH 2
 
+/* child process reaping is enabled by default */
+#ifndef NO_CHILD_REAPER
+#define NO_CHILD_REAPER 0
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -108,6 +113,11 @@ int defer_fork_is_active(void);
 /** Returns the process number for the current working proceess. 0 == parent. */
 int defer_fork_pid(void);
 
+#ifdef DEBUG
+/** minor testing facilities */
+void defer_test(void);
+#endif
+
 #ifdef __cplusplus
 } /* closing brace for extern "C" */
 #endif

data/ext/iodine/evio.c

@@ -15,12 +15,6 @@ Feel free to copy, use and enjoy according to the license provided.
 #error This library currently supports only Unix based systems (i.e. Linux and BSD)
 #endif
 
-#if !defined(__linux__) && !defined(__CYGWIN__)
-#include <sys/event.h>
-#else
-#include <sys/epoll.h>
-#include <sys/timerfd.h>
-#endif
 #include <assert.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -66,6 +60,7 @@ static int evio_fd = -1;
 void evio_close() {
   if (evio_fd != -1)
     close(evio_fd);
+  evio_fd = -1;
 }
 
 /**
@@ -73,10 +68,13 @@ returns true if the evio is available for adding or removing file descriptors.
 */
 int evio_isactive(void) { return evio_fd >= 0; }
 
+#if defined(__linux__) || defined(__CYGWIN__)
 /* *****************************************************************************
 Linux `epoll` implementation
 ***************************************************************************** */
-#if defined(__linux__) || defined(__CYGWIN__)
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+
 /**
 Creates the `epoll` or `kqueue` object.
 */
@@ -105,7 +103,30 @@ int evio_add(int fd, void *callback_arg) {
 Creates a timer file descriptor, system dependent.
 */
 intptr_t evio_open_timer(void) {
-  return timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
+#ifndef TFD_NONBLOCK
+  intptr_t fd = timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
+  if (fd != -1) { /* make sure it's a non-blocking timer. */
+#if defined(O_NONBLOCK)
+    /* Fixme: O_NONBLOCK is defined but broken on SunOS 4.1.x and AIX 3.2.5. */
+    int flags;
+    if (-1 == (flags = fcntl(fd, F_GETFL, 0)))
+      flags = 0;
+    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
+      goto error;
+#else
+    /* no O_NONBLOCK, use the old way of doing it */
+    static int flags = 1;
+    if (ioctl(fd, FIOBIO, &flags) == -1)
+      goto error;
+#endif
+  }
+  return fd;
+error:
+  close(fd);
+  return -1;
+#else
+  return timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+#endif
 }
 
 /**
@@ -113,16 +134,16 @@ Adds a timer file descriptor, so that callbacks will be called for it's events.
 */
 intptr_t evio_add_timer(int fd, void *callback_arg,
                         unsigned long milliseconds) {
-  struct epoll_event chevent;
-  chevent.data.ptr = (void *)callback_arg;
-  chevent.events =
-      EPOLLOUT | EPOLLIN | EPOLLET | EPOLLERR | EPOLLRDHUP | EPOLLHUP;
+  struct epoll_event chevent = {.data.ptr = (void *)callback_arg,
+                                .events = (EPOLLOUT | EPOLLIN | EPOLLET |
+                                           EPOLLERR | EPOLLRDHUP | EPOLLHUP)};
   struct itimerspec new_t_data;
   new_t_data.it_value.tv_sec = new_t_data.it_interval.tv_sec =
       milliseconds / 1000;
   new_t_data.it_value.tv_nsec = new_t_data.it_interval.tv_nsec =
       (milliseconds % 1000) * 1000000;
-  timerfd_settime(fd, 0, &new_t_data, NULL);
+  if (timerfd_settime(fd, 0, &new_t_data, NULL) == -1)
+    return -1;
   return epoll_ctl(evio_fd, EPOLL_CTL_ADD, fd, &chevent);
 }
 
@@ -168,6 +189,7 @@ int evio_review(const int timeout_millisec) {
 /* *****************************************************************************
 BSD `kqueue` implementation
 ***************************************************************************** */
+#include <sys/event.h>
 
 /**
 Creates the `epoll` or `kqueue` object.

data/ext/iodine/extconf.rb

@@ -33,7 +33,7 @@ else
   puts 'using an unknown (old?) compiler... who knows if this will work out... we hope.'
 end
 
-$CFLAGS = '-std=c11 -O3 -Wall -DSERVER_DELAY_IO=1'
+$CFLAGS = '-std=c11 -O3 -Wall -DSERVER_DELAY_IO=1 -DNO_CHILD_REAPER=1'
 RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
 RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
 

data/ext/iodine/facil.c

@@ -578,6 +578,11 @@ static void timer_on_close(intptr_t uuid, protocol_s *protocol) {
   (void)uuid;
 }
 
+static void timer_ping(intptr_t uuid, protocol_s *protocol) {
+  sock_touch(uuid);
+  (void)protocol;
+}
+
 static inline timer_protocol_s *timer_alloc(void (*task)(void *), void *arg,
                                             size_t milliseconds,
                                             size_t repetitions,
@@ -590,6 +595,7 @@ static inline timer_protocol_s *timer_alloc(void (*task)(void *), void *arg,
         .protocol.service = timer_protocol_name,
         .protocol.on_data = timer_on_data,
         .protocol.on_close = timer_on_close,
+        .protocol.ping = timer_ping,
         .arg = arg,
         .task = task,
         .on_finish = on_finish,
@@ -613,12 +619,14 @@ inline static void timer_on_server_start(int fd) {
  * will repeat forever.
  *
  * Returns -1 on error or the new file descriptor on succeess.
+ *
+ * The `on_finish` handler is always called (even on error).
  */
 int facil_run_every(size_t milliseconds, size_t repetitions,
                     void (*task)(void *), void *arg,
                     void (*on_finish)(void *)) {
   if (task == NULL)
-    return -1;
+    goto error_fin;
   timer_protocol_s *protocol = NULL;
   intptr_t uuid = -1;
   int fd = evio_open_timer();
@@ -641,6 +649,9 @@ error:
     sock_close(uuid);
   else if (fd != -1)
     close(fd);
+error_fin:
+  if (on_finish)
+    on_finish(arg);
   return -1;
 }
 

data/ext/iodine/facil.h

@@ -11,7 +11,7 @@ Feel free to copy, use and enjoy according to the license provided.
 #define H_FACIL_H
 #define FACIL_VERSION_MAJOR 0
 #define FACIL_VERSION_MINOR 5
-#define FACIL_VERSION_PATCH 2
+#define FACIL_VERSION_PATCH 3
 
 #ifndef FACIL_PRINT_STATE
 /**
@@ -349,6 +349,8 @@ size_t facil_count(void *service);
  * will repeat forever.
  *
  * Returns -1 on error or the new file descriptor on succeess.
+ *
+ * The `on_finish` handler is always called (even on error).
  */
 int facil_run_every(size_t milliseconds, size_t repetitions,
                     void (*task)(void *), void *arg, void (*on_finish)(void *));

data/ext/iodine/fio2resp.c

@@ -0,0 +1,71 @@
+/*
+Copyright: Boaz Segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+
+Copyright refers to the parser, not the protocol.
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "fio2resp.h"
+#include "fiobj.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static int resp_fioformat_task(fiobj_s *obj, void *s_) {
+  fiobj_s *str = s_;
+
+  switch (obj->type) {
+  case FIOBJ_T_FALSE:
+    fiobj_str_write(str, "false\r\n", 7);
+    break;
+  case FIOBJ_T_TRUE:
+    fiobj_str_write(str, "true\r\n", 6);
+    break;
+  case FIOBJ_T_STRING:
+  case FIOBJ_T_SYMBOL: {
+    /* use this opportunity to optimize memory allocation to page boundries */
+    fio_cstr_s s = fiobj_obj2cstr(str);
+    if (fiobj_str_capa(str) <= s.len + 128 + fiobj_obj2cstr(obj).len) {
+      fiobj_str_resize(str, (((fiobj_str_capa(str) >> 12) + 1) << 12) - 1);
+      fiobj_str_resize(str, s.len);
+    }
+  }
+  /* fallthrough */
+  case FIOBJ_T_NUMBER:
+  case FIOBJ_T_FLOAT:
+    fiobj_str_join(str, obj);
+    fiobj_str_write(str, "\r\n", 2);
+    break;
+  case FIOBJ_T_IO:
+  case FIOBJ_T_NULL:
+    fiobj_str_write(str, "$-1\r\n", 4);
+    return 0;
+  case FIOBJ_T_ARRAY:
+    fiobj_str_write2(str, "*%lu\r\n", (unsigned long)fiobj_ary_count(obj));
+    break;
+  case FIOBJ_T_HASH:
+    fiobj_str_write2(str, "*%lu\r\n", (unsigned long)fiobj_hash_count(obj));
+    break;
+  case FIOBJ_T_COUPLET:
+    resp_fioformat_task(fiobj_couplet2key(obj), s_);
+    resp_fioformat_task(fiobj_couplet2obj(obj), s_);
+    return 0;
+  }
+  return 0;
+}
+#undef safe_write_eol
+#undef safe_write1
+#undef safe_write2
+#undef safe_write_i
+
+fiobj_pt resp_fioformat(fiobj_pt obj) {
+  fiobj_pt str = fiobj_str_buf(4096);
+  fiobj_each2(obj, resp_fioformat_task, str);
+  return str;
+}

data/ext/iodine/fio2resp.h

@@ -0,0 +1,50 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT except for any non-public-domain algorithms (none that I'm aware
+of), which might be subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef H_FIO2RESP_FORMAT_H
+/**
+This is a neive implementation of the RESP protocol for Redis.
+*/
+#define H_FIO2RESP_FORMAT_H
+
+#include "resp.h"
+
+/* support C++ */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* *****************************************************************************
+`fiobj_s` => RESP (formatting): implemented seperately; can be safely removed.
+***************************************************************************** */
+typedef struct fiobj_s *fiobj_pt;
+/**
+ * Returns a **new** String object containing a RESP representation of `obj`.
+ *
+ * Returns NULL on failur.
+ *
+ * Obviously, RESP objects and `fiobj_s` objects aren't fully compatible,
+ * meaning that the RESP_OK and RESP_ERR aren't implemented.
+ *
+ * Also, `FIOBJ_T_HASH` objects are rendered as a flattened Array of `[key,
+ * value, key, value, ...]`, any `FIOBJ_T_FLOAT` will be converted to an Integet
+ * (the decimal information discarded) and any other object is converted to a
+ * String. `FIOBJ_T_IO` and `FIOBJ_T_FILE` are ignored.
+ *
+ * No `parser` argument is provided and extensions aren't supported for this
+ * format.
+ *
+ * To write a RESP OK or Error don;t use this function. Instead, simply ctreate
+ * a new String "OK" or "-error message".
+ */
+fiobj_pt resp_fioformat(fiobj_pt obj);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

data/ext/iodine/fio_cli_helper.c

@@ -0,0 +1,404 @@
+/*
+Copyright: Boaz segev, 2017
+License: MIT
+
+Feel free to copy, use and enjoy according to the license provided.
+*/
+#include "fio_cli_helper.h"
+#include "fiobj.h"
+
+#include <string.h>
+/* *****************************************************************************
+State (static data)
+***************************************************************************** */
+
+/* static variables are automatically initialized to 0, which is what we need.*/
+static int ARGC;
+static const char **ARGV;
+static fiobj_s *arg_aliases; /* a hash for translating aliases */
+static fiobj_s *arg_type;    /* a with information about each argument */
+static fiobj_s *parsed;      /* a with information about each argument */
+static fiobj_s *help_str;    /* The CLI help string */
+static fiobj_s *info_str;    /* The CLI information string */
+static int is_parsed;
+
+const char DEFAULT_CLI_INFO[] =
+    "This application accepts any of the following possible arguments:";
+/* *****************************************************************************
+Error / Help handling - printing the information and exiting.
+***************************************************************************** */
+
+static void fio_cli_handle_error(void) {
+  fio_cstr_s info = fiobj_obj2cstr(info_str);
+  fio_cstr_s args = fiobj_obj2cstr(help_str);
+  fprintf(stdout,
+          "\n"
+          "%s\n"
+          "%s\n"
+          "Use any of the following input formats:\n"
+          "\t-arg <value>\t-arg=<value>\t-arg<value>\n"
+          "\n"
+          "Use the -h, -help or -? to get this information again.\n"
+          "\n",
+          info.data, args.data);
+  fio_cli_end();
+  exit(0);
+}
+
+/* *****************************************************************************
+Initializing the CLI data
+***************************************************************************** */
+
+static void fio_cli_init(void) {
+  /* if init is called after parsing, discard previous result */
+  if (parsed) {
+    fiobj_free(parsed);
+    parsed = NULL;
+  }
+  /* avoid overwriting existing data */
+  if (arg_aliases)
+    return;
+  arg_aliases = fiobj_hash_new();
+  arg_type = fiobj_hash_new();
+  help_str = fiobj_str_buf(1024);
+  if (!info_str) /* might exist through `fio_cli_start` */
+    info_str = fiobj_str_static(DEFAULT_CLI_INFO, sizeof(DEFAULT_CLI_INFO) - 1);
+}
+
+/* *****************************************************************************
+Matching arguments to C string
+***************************************************************************** */
+
+/* returns the primamry symbol for the argument, of NULL (if none) */
+static inline fiobj_s *fio_cli_get_name(const char *str, size_t len) {
+  return fiobj_hash_get2(arg_aliases, str, len);
+}
+
+/* *****************************************************************************
+Setting an argument's type and alias.
+***************************************************************************** */
+typedef enum { CLI_BOOL, CLI_NUM, CLI_STR } cli_type;
+static void fio_cli_set(const char *aliases, const char *desc, cli_type type) {
+  fio_cli_init();
+  const char *start = aliases;
+  size_t len = 0;
+  fiobj_s *arg_name = NULL;
+
+  while (1) {
+    /* get rid of any white space or commas */
+    while (start[0] == ' ' || start[0] == ',')
+      start++;
+    /* we're done */
+    if (!start[0])
+      return;
+    len = 0;
+    /* find the length of the argument name */
+    while (start[len] != 0 && start[len] != ' ' && start[len] != ',')
+      len++;
+
+    if (!arg_name) {
+      /* this is the main identifier */
+      arg_name = fiobj_sym_new(start, len);
+      /* add to aliases hash */
+      fiobj_hash_set(arg_aliases, arg_name, arg_name);
+      /* add the help section and set type*/
+      switch (type) {
+      case CLI_BOOL:
+        fiobj_str_write2(help_str, "\t\e[1m-%s\e[0m\t\t%s\n",
+                         fiobj_obj2cstr(arg_name).data, desc);
+        fiobj_hash_set(arg_type, arg_name, fiobj_null());
+        break;
+      case CLI_NUM:
+        fiobj_str_write2(help_str, "\t\e[1m-%s\e[0m \e[2###\e[0m\t%s\n",
+                         fiobj_obj2cstr(arg_name).data, desc);
+        fiobj_hash_set(arg_type, arg_name, fiobj_true());
+        break;
+      case CLI_STR:
+        fiobj_str_write2(help_str, "\t\e[1m-%s\e[0m \e[2<val>\e[0m\t%s\n",
+                         fiobj_obj2cstr(arg_name).data, desc);
+        fiobj_hash_set(arg_type, arg_name, fiobj_false());
+        break;
+      }
+    } else {
+      /* this is an alias */
+      fiobj_s *tmp = fiobj_sym_new(start, len);
+      /* add to aliases hash */
+      fiobj_hash_set(arg_aliases, tmp, fiobj_dup(arg_name));
+      /* add to description + free it*/
+      fiobj_str_write2(help_str, "\t\t\e[1m-%s\e[0m\tsame as -%s\n",
+                       fiobj_obj2cstr(tmp).data, fiobj_obj2cstr(arg_name).data);
+      fiobj_free(tmp);
+    }
+    start += len;
+  }
+}
+
+/* *****************************************************************************
+parsing the arguments
+***************************************************************************** */
+
+static void fio_cli_parse(void) {
+  if (!ARGC || !ARGV) {
+    fprintf(
+        stderr,
+        "ERROR: (fio_cli) fio_cli_get_* "
+        "can only be called after `fio_cli_start` and before `fio_cli_end`\n");
+    exit(-1);
+  }
+  if (!arg_aliases) {
+    fprintf(stderr, "WARNING: (fio_cli) fio_cli_get_* "
+                    "should only be called after `fio_cli_accept_*`\n");
+    return;
+  }
+  if (parsed)
+    return;
+  parsed = fiobj_hash_new();
+
+  const char *start;
+  size_t len;
+  fiobj_s *arg_name;
+
+  /* ignore the first element, it's the program's name. */
+  for (int i = 1; i < ARGC; i++) {
+    /* test for errors or help requests */
+    if (ARGV[i][0] != '-' || ARGV[i][1] == 0) {
+      start = ARGV[i];
+      goto error;
+    }
+    if ((ARGV[i][1] == '?' && ARGV[i][2] == 0) ||
+        (ARGV[i][1] == 'h' &&
+         (ARGV[i][2] == 0 || (ARGV[i][2] == 'e' && ARGV[i][3] == 'l' &&
+                              ARGV[i][4] == 'p' && ARGV[i][5] == 0)))) {
+      fio_cli_handle_error();
+    }
+    /* we walk the name backwards, so `name` is tested before `n` */
+    start = ARGV[i] + 1;
+    len = strlen(start);
+    while (len && !(arg_name = fio_cli_get_name(start, len))) {
+      len--;
+    }
+    if (!len)
+      goto error;
+    /* at this point arg_name is a handle to the argument's Symbol */
+    fiobj_s *type = fiobj_hash_get(arg_type, arg_name);
+    if (FIOBJ_ISNULL(type)) {
+      /* type is BOOL, no further processing required */
+      start = "1";
+      len = 1;
+      goto set_arg;
+    }
+    if (start[len] == 0) {
+      i++;
+      if (i == ARGC)
+        goto error;
+      start = ARGV[i];
+    } else if (start[len] == '=') {
+      start = start + len + 1;
+    } else
+      start = start + len;
+    len = 0;
+    if (FIOBJ_FALSE(type)) /* no restrictions on data  */
+      goto set_arg;
+    /* test that the argument is numerical */
+    if (start[len] == '-') /* negative number? */
+      len++;
+    while (start[len] >= '0' && start[len] <= '9')
+      len++;
+    if (start[len] == '.') { /* float number? */
+      while (start[len] >= '0' && start[len] <= '9')
+        len++;
+    }
+    if (start[len]) /* if there's data left, this aint a number. */
+      goto error;
+  set_arg:
+    fiobj_hash_set(parsed, arg_name, fiobj_str_static(start, len));
+    continue;
+  error:
+    fprintf(stderr, "\n*** Argument Error: %s\n", start);
+    fio_cli_handle_error();
+  }
+}
+
+/* *****************************************************************************
+CLI API
+***************************************************************************** */
+
+/** Initialize the CLI helper */
+void fio_cli_start(int argc, const char **argv, const char *info) {
+  ARGV = argv;
+  ARGC = argc;
+  if (info_str)
+    fiobj_free(info_str);
+  if (info) {
+    info_str = fiobj_str_static(info, 0);
+  } else {
+    info_str = fiobj_str_static(DEFAULT_CLI_INFO, sizeof(DEFAULT_CLI_INFO) - 1);
+  }
+}
+
+/** Clears the memory and resources used by the CLI helper */
+void fio_cli_end(void) {
+#define free_and_reset(o)                                                      \
+  do {                                                                         \
+    fiobj_free((o));                                                           \
+    o = NULL;                                                                  \
+  } while (0);
+
+  free_and_reset(arg_aliases);
+  free_and_reset(arg_type);
+  free_and_reset(help_str);
+  free_and_reset(info_str);
+  if (parsed)
+    free_and_reset(parsed);
+
+#undef free_and_reset
+
+  ARGC = 0;
+  ARGV = NULL;
+  is_parsed = 0;
+}
+
+/**
+ * Sets a CLI acceptable argument of type Number (both `int` and `float`).
+ *
+ * The `aliases` string sets aliases for the same argument. i.e. "string
+ * s".
+ *
+ * The first alias will be the name available for `fio_cli_get_*`
+ * functions.
+ *
+ * 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_num(const char *aliases, const char *desc) {
+  fio_cli_set(aliases, desc, CLI_NUM);
+}
+
+/**
+ * Sets a CLI acceptable argument of type String.
+ *
+ * The `aliases` string sets aliases for the same argument. i.e. "string s".
+ *
+ * The first alias will be the name used
+ *
+ * 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_str(const char *aliases, const char *desc) {
+  fio_cli_set(aliases, desc, CLI_STR);
+}
+
+/**
+ * Sets a CLI acceptable argument of type Bool (true if exists).
+ *
+ * The `aliases` string sets aliases for the same argument. i.e. "string s".
+ *
+ * The first alias will be the name available for `fio_cli_get_*` functions.
+ *
+ * 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) {
+  fio_cli_set(aliases, desc, CLI_BOOL);
+}
+
+/**
+ * Returns a C String containing the value of the received argument, or NULL
+ * if none.
+ */
+const char *fio_cli_get_str(const char *opt) {
+  fio_cli_parse();
+  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  if (!name)
+    return NULL;
+  fiobj_s *result = fiobj_hash_get(parsed, name);
+  if (!result)
+    return NULL;
+  return fiobj_obj2cstr(result).data;
+}
+
+/**
+ * Returns an Integer containing the parsed value of the argument.
+ *
+ * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ */
+int fio_cli_get_int(const char *opt) {
+  fio_cli_parse();
+  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  if (!name)
+    return 0;
+  fiobj_s *result = fiobj_hash_get(parsed, name);
+  if (!result)
+    return 0;
+  return (int)fiobj_obj2num(result);
+}
+
+/**
+ * Returns a Float containing the parsed value of the argument.
+ *
+ * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ */
+double fio_cli_get_float(const char *opt) {
+  fio_cli_parse();
+  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  if (!name)
+    return 0;
+  fiobj_s *result = fiobj_hash_get(parsed, name);
+  if (!result)
+    return 0;
+  return fiobj_obj2float(result);
+}
+
+/**
+ * Overrides the existing value of the argument with the requested C String.
+ *
+ * Boolean that were set to TRUE have the string "1".
+ */
+void fio_cli_set_str(const char *opt, const char *value) {
+  fio_cli_parse();
+  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  if (!name) {
+    fprintf(stderr, "ERROR: facil.io's CLI helper can only override values for "
+                    "valid options\n");
+    exit(-1);
+  }
+  fiobj_hash_set(parsed, name, fiobj_str_static(value, strlen(value)));
+}
+
+/**
+ * Overrides the existing value of the argument with the requested Integer.
+ *
+ * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ */
+void fio_cli_set_int(const char *opt, int value) {
+  fio_cli_parse();
+  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  if (!name) {
+    fprintf(stderr, "ERROR: facil.io's CLI helper can only override values for "
+                    "valid options\n");
+    exit(-1);
+  }
+  fiobj_hash_set(parsed, name, fiobj_num_new(value));
+}
+
+/**
+ * Overrides the existing value of the argument with the requested Float.
+ *
+ * For boolean values, the value will be 0 for FALSE and 1 for TRUE.
+ */
+void fio_cli_set_float(const char *opt, double value) {
+  fio_cli_parse();
+  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  if (!name) {
+    fprintf(stderr, "ERROR: facil.io's CLI helper can only override values for "
+                    "valid options\n");
+    exit(-1);
+  }
+  fiobj_hash_set(parsed, name, fiobj_float_new(value));
+}