iodine 0.4.19 → 0.5.0

data/ext/iodine/{base64.c → fio_base64.c}

@@ -1,5 +1,5 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2018
 License: MIT except for any non-public-domain algorithms (none that I'm aware
 of), which might be subject to their own licenses.
 
@@ -8,11 +8,13 @@ Feel free to copy, use and enjoy in accordance with to the license(s).
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
-#include "base64.h"
+#include "fio_base64.h"
 
-/* ***************************************************************************
+#include <stdint.h>
+#include <stdlib.h>
+/* ****************************************************************************
 Base64 encoding
-*/
+***************************************************************************** */
 
 /** the base64 encoding array */
 static char base64_encodes[] =
@@ -53,7 +55,7 @@ Returns the number of bytes actually written to the target buffer
 
 A NULL terminator char is NOT written to the target buffer.
 */
-int bscrypt_base64_encode(char *target, const char *data, int len) {
+int fio_base64_encode(char *target, const char *data, int len) {
   /* walk backwards, allowing fo inplace decoding (target == data) */
   int groups = len / 3;
   const int mod = len - (groups * 3);
@@ -110,7 +112,7 @@ be, at least, `base64_len/4*3 + 3` long.
 Returns the number of bytes actually written to the target buffer (excluding
 the NULL terminator byte).
 */
-int bscrypt_base64_decode(char *target, char *encoded, int base64_len) {
+int fio_base64_decode(char *target, char *encoded, int base64_len) {
   if (!target)
     target = encoded;
   if (base64_len <= 0) {
@@ -192,11 +194,15 @@ int bscrypt_base64_decode(char *target, char *encoded, int base64_len) {
   return written;
 }
 
-/*******************************************************************************
-Base64
-*/
+/* *****************************************************************************
+Base64 Testing
+***************************************************************************** */
 #if defined(DEBUG) && DEBUG == 1
-void bscrypt_test_base64(void) {
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+void fio_base64_test(void) {
   struct {
     char *str;
     char *base64;
@@ -226,12 +232,12 @@ void bscrypt_test_base64(void) {
   };
   int i = 0;
   char buffer[1024];
-  fprintf(stderr, "+ bscrypt");
+  fprintf(stderr, "+ fio");
   while (sets[i].str) {
-    bscrypt_base64_encode(buffer, sets[i].str, strlen(sets[i].str));
+    fio_base64_encode(buffer, sets[i].str, strlen(sets[i].str));
     if (strcmp(buffer, sets[i].base64)) {
       fprintf(stderr,
-              ":\n--- bscrypt Base64 Test FAILED!\nstring: %s\nlength: %lu\n "
+              ":\n--- fio Base64 Test FAILED!\nstring: %s\nlength: %lu\n "
               "expected: %s\ngot: %s\n\n",
               sets[i].str, strlen(sets[i].str), sets[i].base64, buffer);
       break;
@@ -242,12 +248,12 @@ void bscrypt_test_base64(void) {
     fprintf(stderr, " Base64 encode passed.\n");
 
   i = 0;
-  fprintf(stderr, "+ bscrypt");
+  fprintf(stderr, "+ fio");
   while (sets[i].str) {
-    bscrypt_base64_decode(buffer, sets[i].base64, strlen(sets[i].base64));
+    fio_base64_decode(buffer, sets[i].base64, strlen(sets[i].base64));
     if (strcmp(buffer, sets[i].str)) {
       fprintf(stderr,
-              ":\n--- bscrypt Base64 Test FAILED!\nbase64: %s\nexpected: "
+              ":\n--- fio Base64 Test FAILED!\nbase64: %s\nexpected: "
               "%s\ngot: %s\n\n",
               sets[i].base64, sets[i].str, buffer);
       return;
@@ -255,14 +261,17 @@ void bscrypt_test_base64(void) {
     i++;
   }
   fprintf(stderr, " Base64 decode passed.\n");
-  char buff_b64[] = "any carnal pleasure.";
-  size_t b64_len;
-  clock_t start = clock();
-  for (size_t i = 0; i < 100000; i++) {
-    b64_len = bscrypt_base64_encode(buffer, buff_b64, sizeof(buff_b64) - 1);
-    bscrypt_base64_decode(buff_b64, buffer, b64_len);
+  {
+    char buff_b64[] = "any carnal pleasure.";
+    clock_t start = clock();
+    for (i = 0; i < 100000; i++) {
+      size_t b64_len =
+          fio_base64_encode(buffer, buff_b64, sizeof(buff_b64) - 1);
+      fio_base64_decode(buff_b64, buffer, b64_len);
+    }
+    fprintf(stderr, "fio 100K Base64: %lf\n",
+            (double)(clock() - start) / CLOCKS_PER_SEC);
+    (void)buff_b64;
   }
-  fprintf(stderr, "bscrypt 100K Base64: %lf\n",
-          (double)(clock() - start) / CLOCKS_PER_SEC);
 }
 #endif

data/ext/iodine/{base64.h → fio_base64.h}

@@ -1,13 +1,12 @@
 /*
-Copyright: Boaz segev, 2016-2017
+Copyright: Boaz Segev, 2016-2018
 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 BSCRYPT_BASE64_H
-#define BSCRYPT_BASE64_H
-#include "bscrypt-common.h"
+#ifndef H_FIO_BASE64_H
+#define H_FIO_BASE64_H
 /* *****************************************************************************
 C++ extern
 */
@@ -35,7 +34,7 @@ Returns the number of bytes actually written to the target buffer
 
 A NULL terminator char is NOT written to the target buffer.
 */
-int bscrypt_base64_encode(char *target, const char *data, int len);
+int fio_base64_encode(char *target, const char *data, int len);
 
 /**
 This will decode a Base64 encoded string of a specified length (len) and
@@ -56,10 +55,10 @@ be, at least, `base64_len/4*3 + 3` long.
 Returns the number of bytes actually written to the target buffer (excluding
 the NULL terminator byte).
 */
-int bscrypt_base64_decode(char *target, char *encoded, int base64_len);
+int fio_base64_decode(char *target, char *encoded, int base64_len);
 
 #if defined(DEBUG) && DEBUG == 1
-void bscrypt_test_base64(void);
+void fio_base64_test(void);
 #endif
 
 /* *****************************************************************************

data/ext/iodine/{fio_cli_helper.c → fio_cli.c}

@@ -4,7 +4,7 @@ License: MIT
 
 Feel free to copy, use and enjoy according to the license provided.
 */
-#include "fio_cli_helper.h"
+#include "fio_cli.h"
 #include "fiobj.h"
 
 #include <string.h>
@@ -13,14 +13,15 @@ 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 FIO_CLI_ARGC;
+static const char **FIO_CLI_ARGV;
+static FIOBJ arg_aliases; /* a hash for translating aliases */
+static FIOBJ arg_type;    /* a with information about each argument */
+static FIOBJ parsed;      /* a with information about each argument */
+static FIOBJ help_str;    /* The CLI help string */
+static FIOBJ info_str;    /* The CLI information string */
 static int is_parsed;
+static int ignore_unknown;
 
 const char DEFAULT_CLI_INFO[] =
     "This application accepts any of the following possible arguments:";
@@ -28,7 +29,12 @@ const char DEFAULT_CLI_INFO[] =
 Error / Help handling - printing the information and exiting.
 ***************************************************************************** */
 
+/** Tells the CLI helper to ignore invalid command line arguments. */
+void fio_cli_ignore_unknown(void) { ignore_unknown = 1; }
+
 static void fio_cli_handle_error(void) {
+  if (ignore_unknown)
+    return;
   fio_cstr_s info = fiobj_obj2cstr(info_str);
   fio_cstr_s args = fiobj_obj2cstr(help_str);
   fprintf(stdout,
@@ -53,7 +59,7 @@ static void fio_cli_init(void) {
   /* if init is called after parsing, discard previous result */
   if (parsed) {
     fiobj_free(parsed);
-    parsed = NULL;
+    parsed = FIOBJ_INVALID;
   }
   /* avoid overwriting existing data */
   if (arg_aliases)
@@ -62,7 +68,7 @@ static void fio_cli_init(void) {
   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);
+    info_str = fiobj_str_new(DEFAULT_CLI_INFO, sizeof(DEFAULT_CLI_INFO) - 1);
 }
 
 /* *****************************************************************************
@@ -70,8 +76,9 @@ 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);
+static inline FIOBJ fio_cli_get_name(const char *str, size_t len) {
+  const uint64_t key = fio_siphash(str, len);
+  return fiobj_hash_get2(arg_aliases, key);
 }
 
 /* *****************************************************************************
@@ -81,8 +88,7 @@ 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;
+  FIOBJ arg_name = FIOBJ_INVALID;
 
   while (1) {
     /* get rid of any white space or commas */
@@ -91,41 +97,43 @@ static void fio_cli_set(const char *aliases, const char *desc, cli_type type) {
     /* we're done */
     if (!start[0])
       return;
-    len = 0;
+    size_t 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);
+      arg_name = fiobj_str_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_str_write2(help_str, "\t\x1B[1m-%s\x1B[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_str_write2(help_str,
+                         "\t\x1B[1m-%s\x1B[0m\x1B[2m ###\x1B[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_str_write2(help_str,
+                         "\t\x1B[1m-%s\x1B[0m\x1B[2m <val>\x1B[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);
+      FIOBJ tmp = fiobj_str_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_str_write2(help_str, "\t\t\x1B[1m-%s\x1B[0m\tsame as -%s\n",
                        fiobj_obj2cstr(tmp).data, fiobj_obj2cstr(arg_name).data);
       fiobj_free(tmp);
     }
@@ -138,7 +146,7 @@ parsing the arguments
 ***************************************************************************** */
 
 static void fio_cli_parse(void) {
-  if (!ARGC || !ARGV) {
+  if (!FIO_CLI_ARGC || !FIO_CLI_ARGV) {
     fprintf(
         stderr,
         "ERROR: (fio_cli) fio_cli_get_* "
@@ -153,35 +161,46 @@ static void fio_cli_parse(void) {
   if (parsed)
     return;
   parsed = fiobj_hash_new();
+  // {
+  //   FIOBJ json = fiobj_obj2json(arg_aliases, 1);
+  //   fprintf(stderr, "%s\n", fiobj_obj2cstr(json).data);
+  //   fiobj_free(json);
+  //   json = fiobj_obj2json(arg_type, 1);
+  //   fprintf(stderr, "%s\n", fiobj_obj2cstr(json).data);
+  //   fiobj_free(json);
+  // }
 
   const char *start;
-  size_t len;
-  fiobj_s *arg_name;
+  FIOBJ arg_name;
 
   /* ignore the first element, it's the program's name. */
-  for (int i = 1; i < ARGC; i++) {
+  for (int i = 1; i < FIO_CLI_ARGC; i++) {
     /* test for errors or help requests */
-    if (ARGV[i][0] != '-' || ARGV[i][1] == 0) {
-      start = ARGV[i];
+    if (FIO_CLI_ARGV[i][0] != '-' || FIO_CLI_ARGV[i][1] == 0) {
+      if (ignore_unknown)
+        continue;
+      start = FIO_CLI_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)))) {
+    if ((FIO_CLI_ARGV[i][1] == '?' && FIO_CLI_ARGV[i][2] == 0) ||
+        (FIO_CLI_ARGV[i][1] == 'h' &&
+         (FIO_CLI_ARGV[i][2] == 0 ||
+          (FIO_CLI_ARGV[i][2] == 'e' && FIO_CLI_ARGV[i][3] == 'l' &&
+           FIO_CLI_ARGV[i][4] == 'p' && FIO_CLI_ARGV[i][5] == 0)))) {
       fio_cli_handle_error();
+      continue;
     }
     /* we walk the name backwards, so `name` is tested before `n` */
-    start = ARGV[i] + 1;
-    len = strlen(start);
+    start = FIO_CLI_ARGV[i] + 1;
+    size_t len = strlen(start);
     while (len && !(arg_name = fio_cli_get_name(start, len))) {
-      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 (type->type == FIOBJ_T_NULL) {
+    FIOBJ type = fiobj_hash_get(arg_type, arg_name);
+    if (FIOBJ_TYPE_IS(type, FIOBJ_T_NULL)) {
       /* type is BOOL, no further processing required */
       start = "1";
       len = 1;
@@ -189,15 +208,15 @@ static void fio_cli_parse(void) {
     }
     if (start[len] == 0) {
       i++;
-      if (i == ARGC)
+      if (i == FIO_CLI_ARGC)
         goto error;
-      start = ARGV[i];
+      start = FIO_CLI_ARGV[i];
     } else if (start[len] == '=') {
       start = start + len + 1;
     } else
       start = start + len;
     len = 0;
-    if (type->type == FIOBJ_T_FALSE) /* no restrictions on data  */
+    if (FIOBJ_TYPE_IS(type, FIOBJ_T_FALSE)) /* no restrictions on data  */
       goto set_arg;
     /* test that the argument is numerical */
     if (start[len] == '-') /* negative number? */
@@ -211,10 +230,10 @@ static void fio_cli_parse(void) {
     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));
+    fiobj_hash_set(parsed, arg_name, fiobj_str_new(start, strlen(start)));
     continue;
   error:
-    fprintf(stderr, "\n*** Argument Error: %s\n", start);
+    fprintf(stderr, "\n\t*** Argument Error: %s ***\n", start);
     fio_cli_handle_error();
   }
 }
@@ -225,14 +244,14 @@ CLI API
 
 /** Initialize the CLI helper */
 void fio_cli_start(int argc, const char **argv, const char *info) {
-  ARGV = argv;
-  ARGC = argc;
+  FIO_CLI_ARGV = argv;
+  FIO_CLI_ARGC = argc;
   if (info_str)
     fiobj_free(info_str);
   if (info) {
-    info_str = fiobj_str_static(info, 0);
+    info_str = fiobj_str_new(info, strlen(info));
   } else {
-    info_str = fiobj_str_static(DEFAULT_CLI_INFO, sizeof(DEFAULT_CLI_INFO) - 1);
+    info_str = fiobj_str_new(DEFAULT_CLI_INFO, sizeof(DEFAULT_CLI_INFO) - 1);
   }
 }
 
@@ -241,7 +260,7 @@ void fio_cli_end(void) {
 #define free_and_reset(o)                                                      \
   do {                                                                         \
     fiobj_free((o));                                                           \
-    o = NULL;                                                                  \
+    o = FIOBJ_INVALID;                                                         \
   } while (0);
 
   free_and_reset(arg_aliases);
@@ -253,8 +272,8 @@ void fio_cli_end(void) {
 
 #undef free_and_reset
 
-  ARGC = 0;
-  ARGV = NULL;
+  FIO_CLI_ARGC = 0;
+  FIO_CLI_ARGV = NULL;
   is_parsed = 0;
 }
 
@@ -314,10 +333,10 @@ void fio_cli_accept_bool(const char *aliases, const char *desc) {
  */
 const char *fio_cli_get_str(const char *opt) {
   fio_cli_parse();
-  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  FIOBJ name = fio_cli_get_name(opt, strlen(opt));
   if (!name)
     return NULL;
-  fiobj_s *result = fiobj_hash_get(parsed, name);
+  FIOBJ result = fiobj_hash_get(parsed, name);
   if (!result)
     return NULL;
   return fiobj_obj2cstr(result).data;
@@ -330,10 +349,10 @@ const char *fio_cli_get_str(const char *opt) {
  */
 int fio_cli_get_int(const char *opt) {
   fio_cli_parse();
-  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  FIOBJ name = fio_cli_get_name(opt, strlen(opt));
   if (!name)
     return 0;
-  fiobj_s *result = fiobj_hash_get(parsed, name);
+  FIOBJ result = fiobj_hash_get(parsed, name);
   if (!result)
     return 0;
   return (int)fiobj_obj2num(result);
@@ -346,10 +365,10 @@ int fio_cli_get_int(const char *opt) {
  */
 double fio_cli_get_float(const char *opt) {
   fio_cli_parse();
-  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  FIOBJ name = fio_cli_get_name(opt, strlen(opt));
   if (!name)
     return 0;
-  fiobj_s *result = fiobj_hash_get(parsed, name);
+  FIOBJ result = fiobj_hash_get(parsed, name);
   if (!result)
     return 0;
   return fiobj_obj2float(result);
@@ -362,13 +381,13 @@ double fio_cli_get_float(const char *opt) {
  */
 void fio_cli_set_str(const char *opt, const char *value) {
   fio_cli_parse();
-  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  FIOBJ 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)));
+  fiobj_hash_set(parsed, name, fiobj_str_new(value, strlen(value)));
 }
 
 /**
@@ -378,7 +397,7 @@ void fio_cli_set_str(const char *opt, const char *value) {
  */
 void fio_cli_set_int(const char *opt, int value) {
   fio_cli_parse();
-  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  FIOBJ 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");
@@ -394,7 +413,7 @@ void fio_cli_set_int(const char *opt, int value) {
  */
 void fio_cli_set_float(const char *opt, double value) {
   fio_cli_parse();
-  fiobj_s *name = fio_cli_get_name(opt, strlen(opt));
+  FIOBJ 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");