switch to cargs and remove honeysuckle

14 files changed, 733 insertions, 1060 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index c6cd35d..78e73ad 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,14 +17,8 @@ set(MD4C_SOURCES
   ${SRC_ROOT}/markdown/md4c-html.c
   ${SRC_ROOT}/markdown/entity.c)
 
-set(HONEYSUCKLE_SOURCES
-  ${SRC_ROOT}/honeysuckle/hs_create_table.c
-  ${SRC_ROOT}/honeysuckle/hs_parse_args.c
-  ${SRC_ROOT}/honeysuckle/hs_process_table.c
-  ${SRC_ROOT}/honeysuckle/hs_pushstring.c
-  ${SRC_ROOT}/honeysuckle/hs_throw_error.c
-  ${SRC_ROOT}/honeysuckle/hs_traceback.c
-  ${SRC_ROOT}/honeysuckle/hs_type_to_string.c)
+set(CARGS_SOURCES
+  ${SRC_ROOT}/cargs/cargs.c)
 
 add_executable(argent
   ${SRC_ROOT}/argent.c
@@ -32,6 +26,7 @@ add_executable(argent
   ${SRC_ROOT}/bindings.c
   ${SRC_ROOT}/logging.c
   ${MD4C_SOURCES}
+  ${CARGS_SOURCES}
   ${HONEYSUCKLE_SOURCES})
 set_target_properties(argent PROPERTIES
   C_STANDARD 99
diff --git a/src/argent.c b/src/argent.c
index fb0d37b..adf6230 100644
--- a/src/argent.c
+++ b/src/argent.c
@@ -2,8 +2,6 @@
 #include <lualib.h>
 #include <lauxlib.h>
 
-#include "honeysuckle.h"
-
 #include "options.h"
 #include "bindings.h"
 #include "logging.h"
@@ -25,6 +23,9 @@ struct settings {
    } while(0)
 
 
+int hs_call(lua_State *L, int nargs, int nret);
+
+
 int main(int argc, char **argv)
 {
    argent_log(DEBUG, "parse command-line options");
@@ -45,16 +46,16 @@ int main(int argc, char **argv)
    luaL_openlibs(L);
 
    argent_log(DEBUG, "create argent table");
-   hs_create_table
-      (L,
-       hs_str_cfunc("markdown", markdown),
-       hs_str_cfunc("currentWorkingDirectory", current_working_directory),
-       hs_str_cfunc("scanDirectory", scan_directory),
-       hs_str_cfunc("createDirectory", create_directory),
-       hs_str_cfunc("copyFile", copy_file),
-       hs_str_cfunc("log", argent_log_lua)
-       );
-   lua_setglobal(L, "argent");
+   luaL_Reg tbl[] = {
+       {"markdown", markdown},
+       {"currentWorkingDirectory", current_working_directory},
+       {"scanDirectory", scan_directory},
+       {"createDirectory", create_directory},
+       {"copyFile", copy_file},
+       {"log", argent_log_lua},
+       {NULL, NULL},
+   };
+   luaL_register(L, "argent", tbl);
 
    // load argent lua script
    argent_log(DEBUG, "load main lua script");
@@ -90,3 +91,40 @@ int main(int argc, char **argv)
    lua_close(L);
    return 0;
 }
+
+
+int hs_traceback(lua_State *L)
+{
+   if (!lua_isstring(L, 1))
+      /* 'message' is not a string, keep intact */
+      return 1;
+   
+   lua_getglobal(L, "debug");
+   if (!lua_istable(L, -1)) {
+      lua_pop(L, 1);
+      return 1;
+   }
+   
+   lua_getfield(L, -1, "traceback");
+   if (!lua_isfunction(L, -1)) {
+      lua_pop(L, 2);
+      return 1;
+   }
+   
+   lua_pushvalue(L, 1);
+   lua_pushinteger(L, 2);
+   lua_call(L, 2, 1);
+   return 1;
+}
+
+
+int hs_call(lua_State *L, int nargs, int nret)
+{
+   int traceback_pos = lua_gettop(L) - nargs;
+   lua_pushcfunction(L, hs_traceback);
+   lua_insert(L, traceback_pos);
+   
+   int result = lua_pcall(L, nargs, nret, traceback_pos);
+   lua_remove(L, traceback_pos);
+   return result;
+}
diff --git a/src/bindings.c b/src/bindings.c
index 1a73fb0..5813d68 100644
--- a/src/bindings.c
+++ b/src/bindings.c
@@ -1,6 +1,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <lua.h>
+#include <lauxlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
@@ -8,7 +9,6 @@
 #include <errno.h>
 #include <fcntl.h>
 
-#include "honeysuckle.h"
 #include "md4c-html.h"
 #include "bindings.h"
 #include "logging.h"
@@ -50,8 +50,7 @@ static void md_callback(const MD_CHAR *html, MD_SIZE size, void *data)
 int markdown(lua_State *L)
 {
    argent_log(TRACE, "begin markdown parsing");
-   char *markdown_buffer;
-   hs_parse_args(L, hs_str(markdown_buffer));
+   char *markdown_buffer = luaL_checkstring(L, 1);
    size_t len = strlen(markdown_buffer);
    argent_log(TRACE, "markdown input (%ld bytes): %s", len, markdown_buffer);
 
@@ -67,10 +66,10 @@ int markdown(lua_State *L)
    // fill out the buffer
    int error = md_html(markdown_buffer, len, md_callback, &data, md_flags, 0);
    if (error)
-      hs_throw_error(L, "markdown parsing failed!");
+      luaL_error(L, "markdown parsing failed!");
 
    if (data.ok == false)
-      hs_throw_error(L, "encountered error (re)allocating html buffer memory!");
+      luaL_error(L, "encountered error (re)allocating html buffer memory!");
 
    data.buf[data.index] = 0;
 
@@ -103,8 +102,7 @@ static struct dirent *read_dir(lua_State *L, DIR *directory);
 int scan_directory(lua_State *L)
 {
    argent_log(TRACE, "begin scan_directory()");
-   char *dir_name;
-   hs_parse_args(L, hs_str(dir_name));
+   char *dir_name = luaL_checkstring(L, 1);
 
    DIR *directory = opendir(dir_name);
    if (directory == NULL)
@@ -142,23 +140,23 @@ static void throw_directory_error(lua_State *L, char *dir_name)
    argent_log(ERROR, "failed to open directory: %d\n", errno);
    switch(errno) {
    case EACCES:
-      hs_throw_error(L, "read %s: permission denied", dir_name);
+      luaL_error(L, "read %s: permission denied", dir_name);
       break;
 
    case EMFILE:
-      hs_throw_error(L, "read %s: this process has too many open files", dir_name);
+      luaL_error(L, "read %s: this process has too many open files", dir_name);
       break;
 
    case ENFILE:
-      hs_throw_error(L, "read %s: this file system cannot support any more open files", dir_name);
+      luaL_error(L, "read %s: this file system cannot support any more open files", dir_name);
       break;
 
    case ENOMEM:
-      hs_throw_error(L, "read %s: Not enough memory", dir_name);
+      luaL_error(L, "read %s: Not enough memory", dir_name);
       break;
 
    default:
-      hs_throw_error(L, "read %s: unknown error", dir_name);
+      luaL_error(L, "read %s: unknown error", dir_name);
       break;
    }
 }
@@ -173,7 +171,7 @@ static struct dirent *read_dir(lua_State *L, DIR *directory)
    if (entry == NULL && errno != 0) {
       argent_log(ERROR, "attempted to read invalid dirstream");
       closedir(directory);
-      hs_throw_error(L, "attempted to read invalid dirstream");
+      luaL_error(L, "attempted to read invalid dirstream");
    }
 
    return entry;
@@ -207,8 +205,7 @@ static const char* mkdir_error_string()
 
 int create_directory(lua_State *L)
 {
-   char *dir_name;
-   hs_parse_args(L, hs_str(dir_name));
+   char *dir_name = luaL_checkstring(L, 1);
 
    mode_t mode = S_IRWXU | S_IRWXG | (S_IROTH | S_IXOTH); // u+rwx, g+rwx, a+rx
 
@@ -216,7 +213,7 @@ int create_directory(lua_State *L)
    if (error) {
       argent_log(ERROR, "failed to create directory '%s': %s",
 		 dir_name, mkdir_error_string());
-      hs_throw_error(L, "failed to create directory '%s': %s",
+      luaL_error(L, "failed to create directory '%s': %s",
 		     dir_name, mkdir_error_string());
    }
 
@@ -278,8 +275,8 @@ static const char* open_error_string()
 
 int copy_file(lua_State *L)
 {
-   char *source_name, *dest_name;
-   hs_parse_args(L, hs_str(source_name), hs_str(dest_name));
+   char *source_name = luaL_checkstring(L, 1);
+   char *dest_name = luaL_checkstring(L, 2);
 
    int source_fd, dest_fd;
 
@@ -287,7 +284,7 @@ int copy_file(lua_State *L)
    if (source_fd == -1) {
       argent_log(ERROR, "failed to open file '%s': %s",
 		 source_name, open_error_string());
-      hs_throw_error(L, "failed to open file '%s': %s",
+      luaL_error(L, "failed to open file '%s': %s",
 		     source_name, open_error_string());
    }
 
@@ -297,7 +294,7 @@ int copy_file(lua_State *L)
       close(source_fd);
       argent_log(ERROR, "failed to stat '%s': %s",
 		 source_name, open_error_string());
-      hs_throw_error(L, "failed to stat '%s': %s",
+      luaL_error(L, "failed to stat '%s': %s",
 		     source_name, open_error_string());
    }
    mode_t dest_mode = source_stat.st_mode;
@@ -306,7 +303,7 @@ int copy_file(lua_State *L)
       close(source_fd);
       argent_log(ERROR, "failed to open file '%s': %s",
 		 dest_name, open_error_string());
-      hs_throw_error(L, "failed to open file '%s': %s",
+      luaL_error(L, "failed to open file '%s': %s",
 		     dest_name, open_error_string());
    }
 
@@ -321,7 +318,7 @@ int copy_file(lua_State *L)
       argent_log(ERROR, "failed to write to file '%s'", dest_name);
       close(source_fd);
       close(dest_fd);
-      hs_throw_error(L, "failed to write to file '%s'", dest_name);
+      luaL_error(L, "failed to write to file '%s'", dest_name);
    }
    else {
       write(dest_fd, buffer, bytes_read);
@@ -338,8 +335,8 @@ int copy_file(lua_State *L)
 
 int argent_log_lua(lua_State *L)
 {
-   char *level_string, *message;
-   hs_parse_args(L, hs_str(level_string), hs_str(message));
+   char *level_string = luaL_checkstring(L, 1);
+   char *message = luaL_checkstring(L, 2);
 
    int level;
 
diff --git a/src/cargs/cargs.c b/src/cargs/cargs.c
new file mode 100644
index 0000000..9f0ff7f
--- /dev/null
+++ b/src/cargs/cargs.c
@@ -0,0 +1,437 @@
+#include <assert.h>

+#include "cargs.h"

+#include <memory.h>

+#include <stdio.h>

+#include <string.h>

+

+#define CAG_OPTION_PRINT_DISTANCE 4

+#define CAG_OPTION_PRINT_MIN_INDENTION 20

+

+static void cag_option_print_value(const cag_option *option,

+  size_t *accessor_length, FILE *destination)

+{

+  if (option->value_name != NULL) {

+    *accessor_length += fprintf(destination, "=%s", option->value_name);

+  }

+}

+

+static void cag_option_print_letters(const cag_option *option, bool *first,

+  size_t *accessor_length, FILE *destination)

+{

+  const char *access_letter;

+  access_letter = option->access_letters;

+  if (access_letter != NULL) {

+    while (*access_letter) {

+      if (*first) {

+        *accessor_length += fprintf(destination, "-%c", *access_letter);

+        *first = false;

+      } else {

+        *accessor_length += fprintf(destination, ", -%c", *access_letter);

+      }

+      ++access_letter;

+    }

+  }

+}

+

+static void cag_option_print_name(const cag_option *option, bool *first,

+  size_t *accessor_length, FILE *destination)

+{

+  if (option->access_name != NULL) {

+    if (*first) {

+      *accessor_length += fprintf(destination, "--%s", option->access_name);

+    } else {

+      *accessor_length += fprintf(destination, ", --%s", option->access_name);

+    }

+  }

+}

+

+static size_t cag_option_get_print_indention(const cag_option *options,

+  size_t option_count)

+{

+  size_t option_index, indention, result;

+  const cag_option *option;

+

+  result = CAG_OPTION_PRINT_MIN_INDENTION;

+

+  for (option_index = 0; option_index < option_count; ++option_index) {

+    indention = CAG_OPTION_PRINT_DISTANCE;

+    option = &options[option_index];

+    if (option->access_letters != NULL && *option->access_letters) {

+      indention += strlen(option->access_letters) * 4 - 2;

+      if (option->access_name != NULL) {

+        indention += strlen(option->access_name) + 4;

+      }

+    } else if (option->access_name != NULL) {

+      indention += strlen(option->access_name) + 2;

+    }

+

+    if (option->value_name != NULL) {

+      indention += strlen(option->value_name) + 1;

+    }

+

+    if (indention > result) {

+      result = indention;

+    }

+  }

+

+  return result;

+}

+

+void cag_option_print(const cag_option *options, size_t option_count,

+  FILE *destination)

+{

+  size_t option_index, indention, i, accessor_length;

+  const cag_option *option;

+  bool first;

+

+  indention = cag_option_get_print_indention(options, option_count);

+

+  for (option_index = 0; option_index < option_count; ++option_index) {

+    option = &options[option_index];

+    accessor_length = 0;

+    first = true;

+

+    fputs("  ", destination);

+

+    cag_option_print_letters(option, &first, &accessor_length, destination);

+    cag_option_print_name(option, &first, &accessor_length, destination);

+    cag_option_print_value(option, &accessor_length, destination);

+

+    for (i = accessor_length; i < indention; ++i) {

+      fputs(" ", destination);

+    }

+

+    fputs(" ", destination);

+    fputs(option->description, destination);

+

+    fprintf(destination, "\n");

+  }

+}

+

+void cag_option_prepare(cag_option_context *context, const cag_option *options,

+  size_t option_count, int argc, char **argv)

+{

+  // This just initialized the values to the beginning of all the arguments.

+  context->options = options;

+  context->option_count = option_count;

+  context->argc = argc;

+  context->argv = argv;

+  context->index = 1;

+  context->inner_index = 0;

+  context->forced_end = false;

+}

+

+static const cag_option *cag_option_find_by_name(cag_option_context *context,

+  char *name, size_t name_size)

+{

+  const cag_option *option;

+  size_t i;

+

+  // We loop over all the available options and stop as soon as we have found

+  // one. We don't use any hash map table, since there won't be that many

+  // arguments anyway.

+  for (i = 0; i < context->option_count; ++i) {

+    option = &context->options[i];

+

+    // The option might not have an item name, we can just skip those.

+    if (option->access_name == NULL) {

+      continue;

+    }

+

+    // Try to compare the name of the access name. We can use the name_size or

+    // this comparison, since we are guaranteed to have null-terminated access

+    // names.

+    if (strncmp(option->access_name, name, name_size) == 0) {

+      return option;

+    }

+  }

+

+  return NULL;

+}

+

+static const cag_option *cag_option_find_by_letter(cag_option_context *context,

+  char letter)

+{

+  const cag_option *option;

+  size_t i;

+

+  // We loop over all the available options and stop as soon as we have found

+  // one. We don't use any look up table, since there won't be that many

+  // arguments anyway.

+  for (i = 0; i < context->option_count; ++i) {

+    option = &context->options[i];

+

+    // If this option doesn't have any access letters we will skip them.

+    if (option->access_letters == NULL) {

+      continue;

+    }

+

+    // Verify whether this option has the access letter in it's access letter

+    // string. If it does, then this is our option.

+    if (strchr(option->access_letters, letter) != NULL) {

+      return option;

+    }

+  }

+

+  return NULL;

+}

+

+static void cag_option_parse_value(cag_option_context *context,

+  const cag_option *option, char **c)

+{

+  // And now let's check whether this option is supposed to have a value, which

+  // is the case if there is a value name set. The value can be either submitted

+  // with a '=' sign or a space, which means we would have to jump over to the

+  // next argv index. This is somewhat ugly, but we do it to behave the same as

+  // the other option parsers.

+  if (option->value_name != NULL) {

+    if (**c == '=') {

+      context->value = ++(*c);

+    } else {

+      // If the next index is larger or equal to the argument count, then the

+      // parameter for this option is missing. The user will know about this,

+      // since the value pointer of the context will be NULL because we don't

+      // set it here in that case.

+      if (context->argc > context->index + 1) {

+        // We consider this argv to be the value, no matter what the contents

+        // are.

+        ++context->index;

+        *c = context->argv[context->index];

+        context->value = *c;

+      }

+    }

+

+    // Move c to the end of the value, to not confuse the caller about our

+    // position.

+    while (**c) {

+      ++(*c);

+    }

+  }

+}

+

+static void cag_option_parse_access_name(cag_option_context *context, char **c)

+{

+  const cag_option *option;

+  char *n;

+

+  // Now we need to extract the access name, which is any symbol up to a '=' or

+  // a '\0'.

+  n = *c;

+  while (**c && **c != '=') {

+    ++*c;

+  }

+

+  // Now this will obviously always be true, but we are paranoid. Sometimes. It

+  // doesn't hurt to check.

+  assert(*c >= n);

+

+  // Figure out which option this name belongs to. This might return NULL if the

+  // name is not registered, which means the user supplied an unknown option. In

+  // that case we return true to indicate that we finished with this option. We

+  // have to skip the value parsing since we don't know whether the user thinks

+  // this option has one or not. Since we don't set any identifier specifically,

+  // it will remain '?' within the context.

+  option = cag_option_find_by_name(context, n, (size_t)(*c - n));

+  if (option == NULL) {

+    // Since this option is invalid, we will move on to the next index. There is

+    // nothing we can do about this.

+    ++context->index;

+    return;

+  }

+

+  // We found an option and now we can specify the identifier within the

+  // context.

+  context->identifier = option->identifier;

+

+  // And now we try to parse the value. This function will also check whether

+  // this option is actually supposed to have a value.

+  cag_option_parse_value(context, option, c);

+

+  // And finally we move on to the next index.

+  ++context->index;

+}

+

+static void cag_option_parse_access_letter(cag_option_context *context,

+  char **c)

+{

+  const cag_option *option;

+  char *n = *c;

+  char *v;

+

+  // Figure out which option this letter belongs to. This might return NULL if

+  // the letter is not registered, which means the user supplied an unknown

+  // option. In that case we return true to indicate that we finished with this

+  // option. We have to skip the value parsing since we don't know whether the

+  // user thinks this option has one or not. Since we don't set any identifier

+  // specifically, it will remain '?' within the context.

+  option = cag_option_find_by_letter(context, n[context->inner_index]);

+  if (option == NULL) {

+    ++context->index;

+    context->inner_index = 0;

+    return;

+  }

+

+  // We found an option and now we can specify the identifier within the

+  // context.

+  context->identifier = option->identifier;

+

+  // And now we try to parse the value. This function will also check whether

+  // this option is actually supposed to have a value.

+  v = &n[++context->inner_index];

+  cag_option_parse_value(context, option, &v);

+

+  // Check whether we reached the end of this option argument.

+  if (*v == '\0') {

+    ++context->index;

+    context->inner_index = 0;

+  }

+}

+

+static void cag_option_shift(cag_option_context *context, int start, int option,

+  int end)

+{

+  char *tmp;

+  int a_index, shift_index, shift_count, left_index, right_index;

+

+  shift_count = option - start;

+

+  // There is no shift is required if the start and the option have the same

+  // index.

+  if (shift_count == 0) {

+    return;

+  }

+

+  // Lets loop through the option strings first, which we will move towards the

+  // beginning.

+  for (a_index = option; a_index < end; ++a_index) {

+    // First remember the current option value, because we will have to save

+    // that later at the beginning.

+    tmp = context->argv[a_index];

+

+    // Let's loop over all option values and shift them one towards the end.

+    // This will override the option value we just stored temporarily.

+    for (shift_index = 0; shift_index < shift_count; ++shift_index) {

+      left_index = a_index - shift_index;

+      right_index = a_index - shift_index - 1;

+      context->argv[left_index] = context->argv[right_index];

+    }

+

+    // Now restore the saved option value at the beginning.

+    context->argv[a_index - shift_count] = tmp;

+  }

+

+  // The new index will be before all non-option values, in such a way that they

+  // all will be moved again in the next fetch call.

+  context->index = end - shift_count;

+}

+

+static bool cag_option_is_argument_string(const char *c)

+{

+  return *c == '-' && *(c + 1) != '\0';

+}

+

+static int cag_option_find_next(cag_option_context *context)

+{

+  int next_index, next_option_index;

+  char *c;

+

+  // Prepare to search the next option at the next index.

+  next_index = context->index;

+  next_option_index = next_index;

+

+  // Grab a pointer to the string and verify that it is not the end. If it is

+  // the end, we have to return false to indicate that we finished.

+  c = context->argv[next_option_index];

+  if (context->forced_end || c == NULL) {

+    return -1;

+  }

+

+  // Check whether it is a '-'. We need to find the next option - and an option

+  // always starts with a '-'. If there is a string "-\0", we don't consider it

+  // as an option neither.

+  while (!cag_option_is_argument_string(c)) {

+    c = context->argv[++next_option_index];

+    if (c == NULL) {

+      // We reached the end and did not find any argument anymore. Let's tell

+      // our caller that we reached the end.

+      return -1;

+    }

+  }

+

+  // Indicate that we found an option which can be processed. The index of the

+  // next option will be returned.

+  return next_option_index;

+}

+

+bool cag_option_fetch(cag_option_context *context)

+{

+  char *c;

+  int old_index, new_index;

+

+  // Reset our identifier to a question mark, which indicates an "unknown"

+  // option. The value is set to NULL, to make sure we are not carrying the

+  // parameter from the previous option to this one.

+  context->identifier = '?';

+  context->value = NULL;

+

+  // Check whether there are any options left to parse and remember the old

+  // index as well as the new index. In the end we will move the option junk to

+  // the beginning, so that non option arguments can be read.

+  old_index = context->index;

+  new_index = cag_option_find_next(context);

+  if (new_index >= 0) {

+    context->index = new_index;

+  } else {

+    return false;

+  }

+

+  // Grab a pointer to the beginning of the option. At this point, the next

+  // character must be a '-', since if it was not the prepare function would

+  // have returned false. We will skip that symbol and proceed.

+  c = context->argv[context->index];

+  assert(*c == '-');

+  ++c;

+

+  // Check whether this is a long option, starting with a double "--".

+  if (*c == '-') {

+    ++c;

+

+    // This might be a double "--" which indicates the end of options. If this

+    // is the case, we will not move to the next index. That ensures that

+    // another call to the fetch function will not skip the "--".

+    if (*c == '\0') {

+      context->forced_end = true;

+    } else {

+      // We parse now the access name. All information about it will be written

+      // to the context.

+      cag_option_parse_access_name(context, &c);

+    }

+  } else {

+    // This is no long option, so we can just parse an access letter.

+    cag_option_parse_access_letter(context, &c);

+  }

+

+  // Move the items so that the options come first followed by non-option

+  // arguments.

+  cag_option_shift(context, old_index, new_index, context->index);

+

+  return context->forced_end == false;

+}

+

+char cag_option_get(const cag_option_context *context)

+{

+  // We just return the identifier here.

+  return context->identifier;

+}

+

+const char *cag_option_get_value(const cag_option_context *context)

+{

+  // We just return the internal value pointer of the context.

+  return context->value;

+}

+

+int cag_option_get_index(const cag_option_context *context)

+{

+  // Either we point to a value item,

+  return context->index;

+}

diff --git a/src/cargs/cargs.h b/src/cargs/cargs.h
new file mode 100644
index 0000000..17cba0a
--- /dev/null
+++ b/src/cargs/cargs.h
@@ -0,0 +1,162 @@
+#pragma once

+

+/**

+ * This is a simple alternative cross-platform implementation of getopt, which

+ * is used to parse argument strings submitted to the executable (argc and argv

+ * which are received in the main function).

+ */

+

+#ifndef CAG_LIBRARY_H

+#define CAG_LIBRARY_H

+

+#include <stdbool.h>

+#include <stddef.h>

+#include <stdio.h>

+

+#if defined(_WIN32) || defined(__CYGWIN__)

+#define CAG_EXPORT __declspec(dllexport)

+#define CAG_IMPORT __declspec(dllimport)

+#elif __GNUC__ >= 4

+#define CAG_EXPORT __attribute__((visibility("default")))

+#define CAG_IMPORT __attribute__((visibility("default")))

+#else

+#define CAG_EXPORT

+#define CAG_IMPORT

+#endif

+

+#if defined(CAG_SHARED)

+#if defined(CAG_EXPORTS)

+#define CAG_PUBLIC CAG_EXPORT

+#else

+#define CAG_PUBLIC CAG_IMPORT

+#endif

+#else

+#define CAG_PUBLIC

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/**

+ * An option is used to describe a flag/argument option submitted when the

+ * program is run.

+ */

+typedef struct cag_option

+{

+  const char identifier;

+  const char *access_letters;

+  const char *access_name;

+  const char *value_name;

+  const char *description;

+} cag_option;

+

+/**

+ * A context is used to iterate over all options provided. It stores the parsing

+ * state.

+ */

+typedef struct cag_option_context

+{

+  const struct cag_option *options;

+  size_t option_count;

+  int argc;

+  char **argv;

+  int index;

+  int inner_index;

+  bool forced_end;

+  char identifier;

+  char *value;

+} cag_option_context;

+

+/**

+ * This is just a small macro which calculates the size of an array.

+ */

+#define CAG_ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

+

+/**

+ * @brief Prints all options to the terminal.

+ *

+ * This function prints all options to the terminal. This can be used to

+ * generate the output for a "--help" option.

+ *

+ * @param options The options which will be printed.

+ * @param option_count The option count which will be printed.

+ * @param destination The destination where the output will be printed.

+ */

+CAG_PUBLIC void cag_option_print(const cag_option *options, size_t option_count,

+  FILE *destination);

+

+/**

+ * @brief Prepare argument options context for parsing.

+ *

+ * This function prepares the context for iteration and initializes the context

+ * with the supplied options and arguments. After the context has been prepared,

+ * it can be used to fetch arguments from it.

+ *

+ * @param context The context which will be initialized.

+ * @param options The registered options which are available for the program.

+ * @param option_count The amount of options which are available for the

+ * program.

+ * @param argc The amount of arguments the user supplied in the main function.

+ * @param argv A pointer to the arguments of the main function.

+ */

+CAG_PUBLIC void cag_option_prepare(cag_option_context *context,

+  const cag_option *options, size_t option_count, int argc, char **argv);

+

+/**

+ * @brief Fetches an option from the argument list.

+ *

+ * This function fetches a single option from the argument list. The context

+ * will be moved to that item. Information can be extracted from the context

+ * after the item has been fetched.

+ * The arguments will be re-ordered, which means that non-option arguments will

+ * be moved to the end of the argument list. After all options have been

+ * fetched, all non-option arguments will be positioned after the index of

+ * the context.

+ *

+ * @param context The context from which we will fetch the option.

+ * @return Returns true if there was another option or false if the end is

+ * reached.

+ */

+CAG_PUBLIC bool cag_option_fetch(cag_option_context *context);

+

+/**

+ * @brief Gets the identifier of the option.

+ *

+ * This function gets the identifier of the option, which should be unique to

+ * this option and can be used to determine what kind of option this is.

+ *

+ * @param context The context from which the option was fetched.

+ * @return Returns the identifier of the option.

+ */

+CAG_PUBLIC char cag_option_get(const cag_option_context *context);

+

+/**

+ * @brief Gets the value from the option.

+ *

+ * This function gets the value from the option, if any. If the option does not

+ * contain a value, this function will return NULL.

+ *

+ * @param context The context from which the option was fetched.

+ * @return Returns a pointer to the value or NULL if there is no value.

+ */

+CAG_PUBLIC const char *cag_option_get_value(const cag_option_context *context);

+

+/**

+ * @brief Gets the current index of the context.

+ *

+ * This function gets the index within the argv arguments of the context. The

+ * context always points to the next item which it will inspect. This is

+ * particularly useful to inspect the original argument array, or to get

+ * non-option arguments after option fetching has finished.

+ *

+ * @param context The context from which the option was fetched.

+ * @return Returns the current index of the context.

+ */

+CAG_PUBLIC int cag_option_get_index(const cag_option_context *context);

+

+#ifdef __cplusplus

+} // extern "C"

+#endif

+

+#endif

diff --git a/src/honeysuckle/honeysuckle.h b/src/honeysuckle/honeysuckle.h
deleted file mode 100644
index 96243ba..0000000
--- a/src/honeysuckle/honeysuckle.h
+++ /dev/null
@@ -1,523 +0,0 @@
-#ifndef HONEYSUCKLE_H
-#define HONEYSUCKLE_H
-
-#include <stdbool.h>
-
-#include <lua.h>
-#include <lualib.h>
-#include <lauxlib.h>
-
-/* variadic macro argument counting */
-#ifndef VA_NARGS
-
-#define VA_NARGS(...) VA_NARGS_SHIFT_COUNT(__VA_ARGS__, VA_NARGS_COUNTS)
-
-#define VA_NARGS_COUNTS				\
-  255, 254, 253, 252, 251, 250, 249, 248,	\
-    247, 246, 245, 244, 243, 242, 241, 240,	\
-    239, 238, 237, 236, 235, 234, 233, 232,	\
-    231, 230, 229, 228, 227, 226, 225, 224,	\
-    223, 222, 221, 220, 219, 218, 217, 216,	\
-    215, 214, 213, 212, 211, 210, 209, 208,	\
-    207, 206, 205, 204, 203, 202, 201, 200,	\
-    199, 198, 197, 196, 195, 194, 193, 192,	\
-    191, 190, 189, 188, 187, 186, 185, 184,	\
-    183, 182, 181, 180, 179, 178, 177, 176,	\
-    175, 174, 173, 172, 171, 170, 169, 168,	\
-    167, 166, 165, 164, 163, 162, 161, 160,	\
-    159, 158, 157, 156, 155, 154, 153, 152,	\
-    151, 150, 149, 148, 147, 146, 145, 144,	\
-    143, 142, 141, 140, 139, 138, 137, 136,	\
-    135, 134, 133, 132, 131, 130, 129, 128,	\
-    127, 126, 125, 124, 123, 122, 121, 120,	\
-    119, 118, 117, 116, 115, 114, 113, 112,	\
-    111, 110, 109, 108, 107, 106, 105, 104,	\
-    103, 102, 101, 100, 99, 98, 97, 96,		\
-    95, 94, 93, 92, 91, 90, 89, 88,		\
-    87, 86, 85, 84, 83, 82, 81, 80,		\
-    79, 78, 77, 76, 75, 74, 73, 72,		\
-    71, 70, 69, 68, 67, 66, 65, 64,		\
-    63, 62, 61, 60, 59, 58, 57, 56,		\
-    55, 54, 53, 52, 51, 50, 49, 48,		\
-    47, 46, 45, 44, 43, 42, 41, 40,		\
-    39, 38, 37, 36, 35, 34, 33, 32,		\
-    31, 30, 29, 28, 27, 26, 25, 24,		\
-    23, 22, 21, 20, 19, 18, 17, 16,		\
-    15, 14, 13, 12, 11, 10, 9, 8,		\
-    7, 6, 5, 4, 3, 2, 1, 0
-
-#define VA_NARGS_GET_COUNT(					\
-		       _255, _254, _253, _252, _251, _250, _249, _248,	\
-		       _247, _246, _245, _244, _243, _242, _241, _240,	\
-		       _239, _238, _237, _236, _235, _234, _233, _232,	\
-		       _231, _230, _229, _228, _227, _226, _225, _224,	\
-		       _223, _222, _221, _220, _219, _218, _217, _216,	\
-		       _215, _214, _213, _212, _211, _210, _209, _208,	\
-		       _207, _206, _205, _204, _203, _202, _201, _200,	\
-		       _199, _198, _197, _196, _195, _194, _193, _192,	\
-		       _191, _190, _189, _188, _187, _186, _185, _184,	\
-		       _183, _182, _181, _180, _179, _178, _177, _176,	\
-		       _175, _174, _173, _172, _171, _170, _169, _168,	\
-		       _167, _166, _165, _164, _163, _162, _161, _160,	\
-		       _159, _158, _157, _156, _155, _154, _153, _152,	\
-		       _151, _150, _149, _148, _147, _146, _145, _144,	\
-		       _143, _142, _141, _140, _139, _138, _137, _136,	\
-		       _135, _134, _133, _132, _131, _130, _129, _128,	\
-		       _127, _126, _125, _124, _123, _122, _121, _120,	\
-		       _119, _118, _117, _116, _115, _114, _113, _112,	\
-		       _111, _110, _109, _108, _107, _106, _105, _104,	\
-		       _103, _102, _101, _100, _99, _98, _97, _96,	\
-		       _95, _94, _93, _92, _91, _90, _89, _88,		\
-		       _87, _86, _85, _84, _83, _82, _81, _80,		\
-		       _79, _78, _77, _76, _75, _74, _73, _72,		\
-		       _71, _70, _69, _68, _67, _66, _65, _64,		\
-		       _63, _62, _61, _60, _59, _58, _57, _56,		\
-		       _55, _54, _53, _52, _51, _50, _49, _48,		\
-		       _47, _46, _45, _44, _43, _42, _41, _40,		\
-		       _39, _38, _37, _36, _35, _34, _33, _32,		\
-		       _31, _30, _29, _28, _27, _26, _25, _24,		\
-		       _23, _22, _21, _20, _19, _18, _17, _16,		\
-		       _15, _14, _13, _12, _11, _10, _9, _8,		\
-		       _7, _6, _5, _4, _3, _2, _1, N, ...) N
-
-#define VA_NARGS_SHIFT_COUNT(...) VA_NARGS_GET_COUNT(__VA_ARGS__)
-
-#endif
-
-
-/* type constants */
-typedef enum
-  { HS_BOOL,
-    HS_INT,
-    HS_NUM,
-    HS_STR,
-    HS_TBL,
-    HS_FUNC,
-    HS_CFUNC,
-    HS_USER,
-    HS_LIGHT,
-    HS_NIL,
-    HS_ANY,
-  } hs_type;
-
-const char* hs_type_to_string(hs_type type);
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * hs_parse_args and hs_parse_overloaded
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-struct hs_arg {
-  hs_type type;
-  union {
-    bool *boolean;
-    lua_Integer *integer;
-    lua_Number *number;
-    char **string;
-    int *stack_index;
-    lua_CFunction *function;
-    void **userdata;
-  } ptr;
-};
-
-#define hs_bool(x)  { .type=HS_BOOL,  .ptr.boolean = &(x) }
-#define hs_int(x)   { .type=HS_INT,   .ptr.integer = &(x) }
-#define hs_num(x)   { .type=HS_NUM,   .ptr.number = &(x) }
-#define hs_str(x)   { .type=HS_STR,   .ptr.string = &(x) }
-#define hs_tbl(x)   { .type=HS_TBL,   .ptr.stack_index = &(x) }
-#define hs_func(x)  { .type=HS_FUNC,  .ptr.stack_index = &(x) }
-#define hs_cfunc(x) { .type=HS_CFUNC, .ptr.function = &(x) }
-#define hs_user(x)  { .type=HS_USER,  .ptr.userdata = &(x) }
-#define hs_light(x) { .type=HS_LIGHT, .ptr.userdata = &(x) }
-#define hs_nil(x)   { .type=HS_NIL,   .ptr.stack_index = &(x) }
-#define hs_any(x)   { .type=HS_ANY,   .ptr.stack_index = &(x) }
-
-void hs_parse_args_(lua_State *L, int n_args, struct hs_arg *arguments);
-
-#define hs_parse_args(L, ...)				\
-   hs_parse_args_(L,					\
-		  VA_NARGS(__VA_ARGS__)/2,		\
-		 (struct hs_arg[]) { __VA_ARGS__ })
-
-
-#define hs_overload(...) VA_NARGS(__VA_ARGS__)/2, (struct hs_arg[]) { __VA_ARGS__ }
-
-int hs_parse_overloaded_(lua_State *L, ...);
-
-#define hs_parse_overloaded(L, ...)		\
-   hs_parse_overloaded_(L, __VA_ARGS__, -1)
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * hs_create_table
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-typedef union {
-   bool boolean;
-   lua_Integer integer;
-   lua_Number number;
-   char *string;
-   int stack_index;
-   lua_CFunction function;
-   void *userdata;
-} hs_value;
-
-struct hs_tbl_entry {
-   hs_type key_type;
-   hs_value key;
-   hs_type value_type;
-   hs_value value;
-};
-
-#define hs_bool_bool(k, v)				\
-   { .key_type=HS_BOOL, .key.boolean=k,			\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_bool_int(k, v)			\
-   { .key_type=HS_BOOL, .key.boolean=k,		\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_bool_num(k, v)			\
-   { .key_type=HS_BOOL, .key.boolean=k,		\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_bool_str(k, v)			\
-   { .key_type=HS_BOOL, .key.boolean=k,		\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_bool_tbl(k, v)				\
-   { .key_type=HS_BOOL, .key.boolean=k,			\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_bool_func(k, v)				\
-   { .key_type=HS_BOOL, .key.boolean=k,			\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_bool_cfunc(k, v)				\
-   { .key_type=HS_BOOL, .key.boolean=k,			\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_bool_user(k, v)				\
-   { .key_type=HS_BOOL, .key.boolean=k,			\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_bool_light(k, v)				\
-   { .key_type=HS_BOOL, .key.boolean=k,			\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-
-#define hs_int_bool(k, v)				\
-   { .key_type=HS_INT, .key.integer=k,			\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_int_int(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_int_num(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_int_str(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_int_tbl(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_int_func(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_int_cfunc(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_int_user(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_int_light(k, v)			\
-   { .key_type=HS_INT, .key.integer=k,		\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-   
-#define hs_num_bool(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_num_int(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_num_num(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_num_str(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_num_tbl(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_num_func(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_num_cfunc(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_num_user(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_num_light(k, v)			\
-   { .key_type=HS_NUM, .key.number=k,		\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-
-#define hs_str_bool(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_str_int(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_str_num(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_str_str(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_str_tbl(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_str_func(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_str_cfunc(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_str_user(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_str_light(k, v)			\
-   { .key_type=HS_STR, .key.string=k,		\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-
-
-#define hs_tbl_bool(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_tbl_int(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_tbl_num(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_tbl_str(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_tbl_tbl(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_tbl_func(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_tbl_cfunc(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_tbl_user(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_tbl_light(k, v)			\
-   { .key_type=HS_TBL, .key.stack_index=k,	\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-
-#define hs_func_bool(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_func_int(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_func_num(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_func_str(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_func_tbl(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_func_func(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_func_cfunc(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_func_user(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_func_light(k, v)			\
-   { .key_type=HS_FUNC, .key.stack_index=k,	\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-
-#define hs_cfunc_bool(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_cfunc_int(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_cfunc_num(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_cfunc_str(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_cfunc_tbl(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_cfunc_func(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_cfunc_cfunc(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_cfunc_user(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_cfunc_light(k, v)			\
-   { .key_type=HS_CFUNC, .key.function=k,	\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-   
-#define hs_user_bool(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_user_int(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_user_num(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_user_str(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_user_tbl(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_user_func(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_user_cfunc(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_user_user(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_user_light(k, v)			\
-   { .key_type=HS_USER, .key.stack_index=k,	\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-
-#define hs_light_bool(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_BOOL, .value.boolean=v }
-#define hs_light_int(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_INT, .value.integer=v }
-#define hs_light_num(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_NUM, .value.number=v }
-#define hs_light_str(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_STR, .value.string=v }
-#define hs_light_tbl(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_TBL, .value.stack_index=v }
-#define hs_light_func(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_FUNC, .value.stack_index=v }
-#define hs_light_cfunc(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_CFUNC, .value.function=v }
-#define hs_light_user(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_USER, .value.stack_index=v }
-#define hs_light_light(k, v)			\
-   { .key_type=HS_LIGHT, .key.userdata=k,	\
-	 .value_type=HS_LIGHT, .value.userdata=v }
-   
-int hs_create_table_(lua_State *L, int n_elements, struct hs_tbl_entry *elements);
-
-#define hs_create_table(L, ...)					\
-   hs_create_table_(L,						\
-		    VA_NARGS(__VA_ARGS__)/4,			\
-		    (struct hs_tbl_entry[]) { __VA_ARGS__ })
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * hs_process_table
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-typedef void (*hs_pt_bool_callback)(bool, void *);
-typedef void (*hs_pt_int_callback)(lua_Integer, void *);
-typedef void (*hs_pt_num_callback)(lua_Number, void *);
-typedef void (*hs_pt_str_callback)(const char *, void *);
-
-
-// default processors
-void hs_pt_set_boolean(bool value, void *data);
-void hs_pt_set_integer(lua_Integer value, void *data);
-void hs_pt_set_number(lua_Number value, void *data);
-void hs_pt_set_string(const char *value, void *data);
-
-
-struct hs_table_processor {
-   const char *key;
-   hs_type type;
-   union {
-      hs_pt_bool_callback boolean;
-      hs_pt_int_callback integer;
-      hs_pt_num_callback number;
-      hs_pt_str_callback string;
-   } func;
-   void *data;
-};
-
-#define hs_process_bool(str, f, d)				\
-   { .key=(str), .type=HS_BOOL, .func.boolean=(f), .data=(d) }
-#define hs_process_int(str, f, d)				\
-   { .key=(str), .type=HS_INT, .func.integer=(f), .data=(d) }
-#define hs_process_num(str, f, d)				\
-   { .key=(str), .type=HS_NUM, .func.number=(f), .data=(d) }
-#define hs_process_str(str, f, d)				\
-   { .key=(str), .type=HS_STR, .func.string=(f), .data=(d) }
-
-void hs_process_table_(lua_State *L,
-		       int table_index,
-		       int n_processors,
-		       struct hs_table_processor *processors);
-
-#define hs_process_table(L, table_index, ...)	\
-   hs_process_table_(L, table_index, \
-		     VA_NARGS(__VA_ARGS__)/4, \
-		     (struct hs_table_processor[]) {__VA_ARGS__})
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * hs_pushstring
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-void hs_vpushstring(lua_State *L, const char *format_string, va_list args);
-void hs_pushstring(lua_State *L, const char *format_string, ...);
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * error creation and handling
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-void hs_throw_error(lua_State *L, const char *format_string, ...);
-int hs_traceback(lua_State *L);
-int hs_call(lua_State *L, int nargs, int nret);
-
-
-/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * registry operations
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-
-#define hs_rstore(L) luaL_ref(L, LUA_REGISTRYINDEX);
-#define hs_rload(L, ref) lua_rawgeti(L, LUA_REGISTRYINDEX, ref)
-#define hs_rdel(L, ref) luaL_unref(L, LUA_REGISTRYINDEX, ref)
-
-#endif
diff --git a/src/honeysuckle/hs_create_table.c b/src/honeysuckle/hs_create_table.c
deleted file mode 100644
index 422a480..0000000
--- a/src/honeysuckle/hs_create_table.c
+++ /dev/null
@@ -1,123 +0,0 @@
-#include <stdlib.h>
-
-#include "honeysuckle.h"
-
-static void push_value(lua_State *L, hs_type type, hs_value value)
-{
-   switch (type) {
-   case HS_BOOL:
-      lua_pushboolean(L, value.boolean);
-      break;
-
-   case HS_INT:
-      lua_pushinteger(L, value.integer);
-      break;
-
-   case HS_NUM:
-      lua_pushnumber(L, value.number);
-      break;
-
-   case HS_STR:
-      lua_pushstring(L, value.string);
-      break;
-
-   case HS_TBL:
-      lua_pushvalue(L, value.stack_index);
-      break;
-
-   case HS_FUNC:
-      lua_pushvalue(L, value.stack_index);
-      break;
-
-   case HS_CFUNC:
-      lua_pushcfunction(L, value.function);
-      break;
-
-   case HS_USER:
-      lua_pushvalue(L, value.stack_index);
-      break;
-
-   case HS_LIGHT:
-      lua_pushlightuserdata(L, value.userdata);
-      break;
-
-   default:
-      hs_throw_error(L, "attempted to push data of invalid type %d", type);
-      break;
-   }
-}
-
-
-static inline bool poppable(hs_type type)
-{
-   if (type == HS_TBL ||
-       type == HS_FUNC ||
-       type == HS_USER) {
-      return true;
-   }
-   return false;
-}
-
-
-static void print_stack(lua_State *L)
-{
-   printf("stack: %d [", lua_gettop(L));
-   for (int i=0; i<lua_gettop(L); i++) {
-      printf(" %s, ", lua_typename(L, lua_type(L, i+1)));
-   }
-   printf("]\n");
-}
-
-
-int descending(const void *a, const void *b)
-{
-   return (*(int*)b - *(int*)a);
-}
-
-int hs_create_table_(lua_State *L,
-		     int n_elements,
-		     struct hs_tbl_entry *elements)
-{
-   // printf("start\n");
-   
-   // print_stack(L);
-   lua_createtable(L, 0, n_elements);
-   int index = lua_gettop(L);
-   // print_stack(L);
-
-   for (int i=0; i<n_elements; i++) {
-      // printf("pushing element %d...\n", i);
-      struct hs_tbl_entry *e = elements + i;
-      push_value(L, e->key_type, e->key);
-      // print_stack(L);
-      push_value(L, e->value_type, e->value);
-      // print_stack(L);
-      lua_rawset(L, index);
-      // print_stack(L);
-   }
-
-   int n_poppable = 0;
-   int pop_indices[n_elements];
-   
-   for (int i=0; i<n_elements; i++) {
-      struct hs_tbl_entry *e = elements + i;
-      if (poppable(e->key_type))
-	 pop_indices[n_poppable++] = e->key.stack_index;
-      if (poppable(e->value_type))
-	 pop_indices[n_poppable++] = e->value.stack_index;
-   }
-
-   // printf("cleaning up\n");
-   
-   qsort(pop_indices, n_poppable, sizeof(int), descending);
-   for (int i=0; i<n_poppable; i++) {
-      lua_remove(L, pop_indices[i]);
-      index -= 1;
-      // print_stack(L);
-   }
-   
-
-   // printf("exit\n");
-   
-   return index;
-}
diff --git a/src/honeysuckle/hs_parse_args.c b/src/honeysuckle/hs_parse_args.c
deleted file mode 100644
index d6d3b3c..0000000
--- a/src/honeysuckle/hs_parse_args.c
+++ /dev/null
@@ -1,149 +0,0 @@
-#include <stdio.h>
-
-#include "honeysuckle.h"
-
-static bool check_parse(lua_State *L, int index, struct hs_arg *expected)
-{
-   switch(expected->type) {
-   case HS_BOOL:
-      if (!lua_isboolean(L, index))
-	 return false;
-      *(expected->ptr.boolean) = lua_toboolean(L, index);
-      return true;
-
-   case HS_INT:
-      if (!lua_isnumber(L, index))
-	 return false;
-      *(expected->ptr.integer) = lua_tointeger(L, index);
-      return true;
-
-   case HS_NUM:
-      if (!lua_isnumber(L, index))
-	 return false;
-      *(expected->ptr.number) = lua_tonumber(L, index);
-      return true;
-
-   case HS_STR:
-      if (!lua_isstring(L, index) || lua_isnumber(L, index))
-	 return false;
-      *(expected->ptr.string) = (char *) lua_tostring(L, index);
-      return true;
-
-   case HS_TBL:
-      if (!lua_istable(L, index))
-	 return false;
-      *(expected->ptr.stack_index) = index;
-      return true;
-
-   case HS_FUNC:
-      if (!lua_isfunction(L, index))
-	 return false;
-      *(expected->ptr.stack_index) = index;
-      return true;
-
-   case HS_CFUNC:
-      if (!lua_iscfunction(L, index))
-	 return false;
-      *(expected->ptr.function) = lua_tocfunction(L, index);
-      return true;
-
-   case HS_USER:
-      if (!lua_isuserdata(L, index))
-	 return false;
-      *(expected->ptr.userdata) = lua_touserdata(L, index);
-      return true;
-
-   case HS_LIGHT:
-      if (!lua_islightuserdata(L, index))
-	 return false;
-      *(expected->ptr.userdata) = lua_touserdata(L, index);
-      return true;
-
-   case HS_NIL:
-      if (!lua_isnil(L, index))
-	 return false;
-      *(expected->ptr.stack_index) = index;
-
-   case HS_ANY:
-      *(expected->ptr.stack_index) = index;
-      return true;
-
-   default:
-      return false;
-   }
-}
-
-
-static bool try_parse_args(lua_State *L, int n_args, struct hs_arg *arguments)
-{
-   int args_provided = lua_gettop(L);
-   if (args_provided != n_args)
-      return false;
-
-   for (int i=0; i<n_args; i++) {
-      bool success = check_parse(L, i+1, arguments + i);
-      if (!success)
-	 return false;
-   }
-   return true;
-}
-
-
-void hs_parse_args_(lua_State *L, int n_args, struct hs_arg *arguments)
-{
-   bool success = try_parse_args(L, n_args, arguments);
-   if (!success) {
-      lua_pushstring(L, "expected arguments of the form (");
-      for (int i=0; i<n_args; i++) {
-	 lua_pushstring(L, hs_type_to_string(arguments[i].type));
-	 lua_pushstring(L, ", ");
-      }
-      lua_pop(L, 1);
-      lua_pushstring(L, "); received (");
-      const int n_provided = lua_gettop(L);
-      for (int i=0; i<n_provided; i++) {
-	 lua_pushstring(L, lua_typename(L, lua_type(L, i+1)));
-	 lua_pushstring(L, ", ");
-      }
-      lua_pop(L, 1);
-      lua_pushstring(L, ") instead");
-      lua_concat(L, 1 + (2*n_args) + (2*n_provided));
-      lua_error(L);
-   }
-}
-
-
-// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-static void hs_overloaded_error(lua_State *L, va_list args)
-{
-   lua_pushstring(L, "hs_overloaded failed");
-   lua_error(L);
-}
-
-
-int hs_parse_overloaded_(lua_State *L, ...)
-{
-   va_list args, args_error;
-   va_start(args, L);
-   va_copy(args_error, args);
-
-   int choice = 0;
-
-   while(true) {
-      int n_args = va_arg(args, int);
-      if (n_args == -1)
-	 break;
-      else {
-	 struct hs_arg *arguments = va_arg(args, struct hs_arg *);
-	 if (try_parse_args(L, n_args, arguments))
-	    return choice;
-      }
-      choice++;
-   }
-
-   hs_overloaded_error(L, args_error);
-   
-   va_end(args);
-   va_end(args_error);
-}
diff --git a/src/honeysuckle/hs_process_table.c b/src/honeysuckle/hs_process_table.c
deleted file mode 100644
index d07d815..0000000
--- a/src/honeysuckle/hs_process_table.c
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "honeysuckle.h"
-
-void hs_pt_set_boolean(bool value, void *data)
-{
-   *(bool *) data = value;
-}
-
-void hs_pt_set_integer(lua_Integer value, void *data)
-{
-   *(lua_Integer *) data = value;
-}
-
-void hs_pt_set_number(lua_Number value, void *data)
-{
-   *(lua_Number *) data = value;
-}
-
-void hs_pt_set_string(const char *value, void *data)
-{
-   *(const char **) data = value;
-}
-
-
-static bool process_key(lua_State *L, struct hs_table_processor *p)
-{
-   switch (p->type) {
-   case HS_BOOL:
-      if (!lua_isboolean(L, -1))
-	 hs_throw_error(L,
-			"expected key '%s' to be of type boolean, "\
-			"but got type %s instead",
-			p->key,
-			lua_typename(L, lua_type(L, -1)));
-      p->func.boolean(lua_toboolean(L, -1), p->data);
-      break;
-
-   case HS_INT:
-      if (!lua_isnumber(L, -1))
-	 hs_throw_error(L,
-			"expected key '%s' to be of type integer, "\
-			"but got type %s instead",
-			p->key,
-			lua_typename(L, lua_type(L, -1)));
-      p->func.integer(lua_tointeger(L, -1), p->data);
-      break;
-
-   case HS_NUM:
-      if (!lua_isnumber(L, -1))
-	 hs_throw_error(L,
-			"expected key '%s' to be of type number, "\
-			"but got type %s instead",
-			p->key,
-			lua_typename(L, lua_type(L, -1)));
-      p->func.number(lua_tonumber(L, -1), p->data);
-      break;
-
-   case HS_STR:
-      if (!lua_isstring(L, -1))
-	 hs_throw_error(L,
-			"expected key '%s' to be of type string, "\
-			"but got type %s instead",
-			p->key,
-			lua_typename(L, lua_type(L, -1)));
-      p->func.string(lua_tostring(L, -1), p->data);
-      break;
-
-   default:
-      // bad type value, throw error
-      hs_throw_error(L, "bad expected type '%d' for key '%s'",
-		     p->type, p->key);
-      break;
-   }
-}
-
-void hs_process_table_(lua_State *L,
-		       int table_index,
-		       int n_processors,
-		       struct hs_table_processor *processors)
-{
-   for (int i=0; i<n_processors; i++) {
-      lua_getfield(L, table_index, processors[i].key);
-      if (!lua_isnil(L, -1))
-	 process_key(L, processors+i);
-      lua_pop(L, 1);
-   }
-}
diff --git a/src/honeysuckle/hs_pushstring.c b/src/honeysuckle/hs_pushstring.c
deleted file mode 100644
index f7da0d0..0000000
--- a/src/honeysuckle/hs_pushstring.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include <stdlib.h>
-
-#include "honeysuckle.h"
-
-void hs_vpushstring(lua_State *L, const char *format_string, va_list args)
-{
-   va_list args_;
-   va_copy(args_, args);
-
-   int string_size = vsnprintf(NULL, 0, format_string, args_);
-   va_end(args_);
-
-   char *string = malloc((string_size+1) * sizeof(char));
-   if (string == NULL) {
-      lua_pushstring(L, "there was an error allocating memory for a string");
-      lua_error(L);
-   }
-
-   vsnprintf(string, string_size+1, format_string, args);
-   lua_pushstring(L, string);
-   free(string);
-}
-
-
-void hs_pushstring(lua_State *L, const char *format_string, ...)
-{
-   va_list args;
-   va_start(args, format_string);
-   hs_vpushstring(L, format_string, args);
-   va_end(args);
-}
diff --git a/src/honeysuckle/hs_throw_error.c b/src/honeysuckle/hs_throw_error.c
deleted file mode 100644
index 20a4c6d..0000000
--- a/src/honeysuckle/hs_throw_error.c
+++ /dev/null
@@ -1,12 +0,0 @@
-#include <stdlib.h>
-
-#include "honeysuckle.h"
-
-void hs_throw_error(lua_State *L, const char *format_string, ...)
-{
-   va_list args;
-   va_start(args, format_string);
-   hs_vpushstring(L, format_string, args);
-   va_end(args);
-   lua_error(L);
-}
diff --git a/src/honeysuckle/hs_traceback.c b/src/honeysuckle/hs_traceback.c
deleted file mode 100644
index 1830721..0000000
--- a/src/honeysuckle/hs_traceback.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include "honeysuckle.h"
-
-int hs_traceback(lua_State *L)
-{
-   if (!lua_isstring(L, 1))
-      /* 'message' is not a string, keep intact */
-      return 1;
-
-   lua_getglobal(L, "debug");
-   if (!lua_istable(L, -1)) {
-      lua_pop(L, 1);
-      return 1;
-   }
-
-   lua_getfield(L, -1, "traceback");
-   if (!lua_isfunction(L, -1)) {
-      lua_pop(L, 2);
-      return 1;
-   }
-
-   lua_pushvalue(L, 1);
-   lua_pushinteger(L, 2);
-   lua_call(L, 2, 1);
-   return 1;
-}
-
-
-int hs_call(lua_State *L, int nargs, int nret)
-{
-   int traceback_pos = lua_gettop(L) - nargs;
-   lua_pushcfunction(L, hs_traceback);
-   lua_insert(L, traceback_pos);
-
-   int result = lua_pcall(L, nargs, nret, traceback_pos);
-   lua_remove(L, traceback_pos);
-   return result;
-}
diff --git a/src/honeysuckle/hs_type_to_string.c b/src/honeysuckle/hs_type_to_string.c
deleted file mode 100644
index d0a580c..0000000
--- a/src/honeysuckle/hs_type_to_string.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "honeysuckle.h"
-
-const char * hs_type_to_string(hs_type type)
-{
-   switch(type) {
-   case HS_BOOL:
-      return "boolean";
-   case HS_INT:
-      return "integer";
-   case HS_NUM:
-      return "number";
-   case HS_STR:
-      return "string";
-   case HS_TBL:
-      return "table";
-   case HS_FUNC:
-      return "function";
-   case HS_CFUNC:
-      return "C function";
-   case HS_USER:
-      return "userdata";
-   case HS_LIGHT:
-      return "light userdata";
-   case HS_NIL:
-      return "nil";
-   case HS_ANY:
-      return "any";
-   default:
-      return "(unknown)";
-   }
-}
diff --git a/src/options.c b/src/options.c
index fa6b999..61a74b6 100644
--- a/src/options.c
+++ b/src/options.c
@@ -1,18 +1,51 @@
 #include <stdio.h>
-#include <unistd.h>
+#include "cargs/cargs.h"
 
 #include "options.h"
 #include "logging.h"
 
+static struct cag_option options[] = {
+	{
+		.identifier = 'q',
+		.access_letters = "q",
+		.access_name = NULL,
+		.value_name = NULL,
+		.description = "Decrease output verbosity (-qqq suppresses even fatal errors)",
+	},
+	{
+		.identifier = 'v',
+		.access_letters = "v",
+		.access_name = NULL,
+		.value_name = NULL,
+		.description = "Increase output verbosity (-vvv displays every log message)",
+	},
+	{
+		.identifier = 'c',
+		.access_letters = "c",
+		.access_name = "config",
+		.value_name = "CONF_FILE",
+		.description = "Specify configuration file to read (default: config.lua)",
+	},
+	{
+		.identifier = 's',
+		.access_letters = "s",
+		.access_name = "script",
+		.value_name = "SCRIPT_FILE",
+		.description = "Override the built-in build script",
+	},
+	{
+		.identifier = 'h',
+		.access_letters = "h",
+		.access_name = "help",
+		.value_name = NULL,
+		.description = "Print this help message and exit",
+	},
+};
+
 static void print_usage(const char *progname)
 {
-   printf("Usage: %s [-c config_file] [-v[v[v]]] [-q[q[q]]] [-h] [-s script]\n"
-	  "  -v    Increase output verbosity (-vvv displays every log message)\n"
-	  "  -q    Decrease output verbosity (-qqq suppresses even fatal errors)\n"
-	  "  -c    Specify configuration file to read (default 'config.lua')\n"
-	  "  -s    Override the built-in Lua script\n"
-	  "  -h    Print this help message and exit\n",
-	  progname);	  
+   printf("Usage: %s [OPTIONS]\n", progname);
+   cag_option_print(options, CAG_ARRAY_SIZE(options), stdout);
 }
 
 int parse_options(struct argent_options *opts, int argc, char **argv)
@@ -21,32 +54,35 @@ int parse_options(struct argent_options *opts, int argc, char **argv)
    opts->conf_filename = "config.lua";
    opts->script_filename = NULL;
    
-   int opt;
-   while ((opt = getopt(argc, argv, "hqvc:s:")) != -1) {
+   char opt;
+   cag_option_context context;
+   cag_option_prepare(&context, options, CAG_ARRAY_SIZE(options), argc, argv);
+   while (cag_option_fetch(&context)) {
+      opt = cag_option_get(&context);
       switch (opt) {
       case 'q':
-	 opts->log_level -= 1;
-	 break;
-	 
+         opts->log_level -= 1;
+         break;
+    
       case 'v':
-	 opts->log_level += 1;
-	 break;
-	 
+         opts->log_level += 1;
+         break;
+    
       case 'c':
-	 opts->conf_filename = optarg;
-	 break;
+         opts->conf_filename = cag_option_get_value(&context);
+         break;
 
       case 's':
-	 opts->script_filename = optarg;
-	 break;
+         opts->script_filename = cag_option_get_value(&context);
+         break;
 
       case 'h':
-	 print_usage(argv[0]);
-	 return 2;
+         print_usage(argv[0]);
+         return 2;
 
       default:
-	 print_usage(argv[0]);
-	 return 1;
+         print_usage(argv[0]);
+         return 1;
       }
    }