zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/cli.c

@@ -0,0 +1,796 @@
+/*
+ * Copyright (C) 2021 Liquidaty and the zsv/lib contributors
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <zsv/utils/arg.h>
+#include <zsv/utils/dl.h>
+#include <zsv/utils/prop.h>
+#include <zsv/utils/string.h>
+#include <zsv/utils/dirs.h>
+#include <zsv/utils/signal.h>
+#ifdef ZSV_EXTRAS
+#include <zsv/utils/overwrite.h>
+#endif
+#include <zsv.h>
+#include <zsv/ext.h>
+#include "cli_internal.h"
+#include "cli_const.h"
+#include "cli_export.h"
+#ifdef ZSVSHEET_BUILD
+#include "sheet/sheet_internal.h"
+#include "sheet/handlers_internal.h"
+#include "sheet/transformation.h"
+#endif
+#include "sheet/procedure.h"
+#include "sheet/key-bindings.h"
+#include "sql_internal.h"
+
+struct cli_config {
+  struct zsv_ext *extensions;
+  char err_if_not_found;
+  char filepath[FILENAME_MAX];
+  char home_filepath[FILENAME_MAX];
+  const char *current_filepath; // path being currently parsed
+  char verbose;
+};
+
+static struct zsv_ext *zsv_ext_new(const char *dl_name, const char *id, char verbose);
+
+zsvsheet_status zsvsheet_ext_prompt(struct zsvsheet_proc_context *ctx, char *buffer, size_t bufsz, const char *fmt,
+                                    ...);
+
+#include "cli_ini.c"
+
+typedef int(cmd_main)(int argc, const char *argv[]);
+typedef int(zsv_cmd)(int argc, const char *argv[], struct zsv_opts *opts, struct zsv_prop_handler *custom_prop_handler);
+typedef int (*cmd_reserved)(void);
+
+struct builtin_cmd {
+  const char *name;
+  cmd_main *main;
+  zsv_cmd *cmd;
+};
+
+static int config_init(struct cli_config *c, char err_if_dl_not_found, char do_init, char verbose);
+static int config_init_2(struct cli_config *c, char err_if_dl_not_found, char do_init, char verbose, char global_only,
+                         char home_only);
+#include "zsv_main.h"
+
+#define CLI_BUILTIN_DECL(x) int main_##x(int argc, const char *argv[])
+
+#define CLI_BUILTIN_DECL_STATIC(x) static int main_##x(int argc, const char *argv[])
+
+CLI_BUILTIN_DECL_STATIC(version);
+CLI_BUILTIN_DECL_STATIC(help);
+CLI_BUILTIN_DECL_STATIC(thirdparty);
+
+#ifndef __EMSCRIPTEN__
+CLI_BUILTIN_DECL_STATIC(register);
+CLI_BUILTIN_DECL_STATIC(unregister);
+CLI_BUILTIN_DECL_STATIC(license);
+#endif
+
+ZSV_MAIN_DECL(select);
+ZSV_MAIN_DECL(count);
+ZSV_MAIN_DECL(paste);
+ZSV_MAIN_DECL(check);
+ZSV_MAIN_DECL(2json);
+ZSV_MAIN_DECL(2tsv);
+ZSV_MAIN_DECL(serialize);
+ZSV_MAIN_DECL(flatten);
+ZSV_MAIN_DECL(pretty);
+ZSV_MAIN_DECL(stack);
+ZSV_MAIN_DECL(desc);
+ZSV_MAIN_DECL(sql);
+ZSV_MAIN_DECL(2db);
+ZSV_MAIN_DECL(compare);
+#ifdef ZSVSHEET_BUILD
+ZSV_MAIN_DECL(sheet);
+#endif
+ZSV_MAIN_DECL(echo);
+#ifdef ZSV_EXTRAS
+ZSV_MAIN_DECL(overwrite);
+#endif
+ZSV_MAIN_NO_OPTIONS_DECL(prop);
+ZSV_MAIN_NO_OPTIONS_DECL(rm);
+ZSV_MAIN_NO_OPTIONS_DECL(mv);
+
+#ifdef USE_JQ
+ZSV_MAIN_NO_OPTIONS_DECL(jq);
+#endif
+
+// clang-format off
+
+#define CLI_BUILTIN_CMD(x) {.name = #x, .main = main_##x, .cmd = NULL}
+#define CLI_BUILTIN_COMMAND(x) {.name = #x, .main = NULL, .cmd = ZSV_MAIN_FUNC(x)}
+#define CLI_BUILTIN_COMMANDEXT(x) {.name = #x, .main = NULL, .cmd = ZSV_MAINEXT_FUNC(x)}
+#define CLI_BUILTIN_NO_OPTIONS_COMMAND(x) {.name = #x, .main = ZSV_MAIN_NO_OPTIONS_FUNC(x), .cmd = NULL}
+
+#ifdef ZSVSHEET_BUILD
+ZSV_MAINEXT_FUNC_DEFINE(sheet);
+#endif
+
+struct builtin_cmd builtin_cmds[] = {
+  CLI_BUILTIN_CMD(version),
+  CLI_BUILTIN_CMD(help),
+  CLI_BUILTIN_CMD(thirdparty),
+#ifndef __EMSCRIPTEN__
+  CLI_BUILTIN_CMD(register),
+  CLI_BUILTIN_CMD(unregister),
+  CLI_BUILTIN_CMD(license),
+#endif
+  CLI_BUILTIN_COMMAND(select),
+  CLI_BUILTIN_COMMAND(count),
+  CLI_BUILTIN_COMMAND(paste),
+  CLI_BUILTIN_COMMAND(check),
+  CLI_BUILTIN_COMMAND(2json),
+  CLI_BUILTIN_COMMAND(2tsv),
+  CLI_BUILTIN_COMMAND(serialize),
+  CLI_BUILTIN_COMMAND(flatten),
+  CLI_BUILTIN_COMMAND(pretty),
+  CLI_BUILTIN_COMMAND(stack),
+  CLI_BUILTIN_COMMAND(desc),
+  CLI_BUILTIN_COMMAND(sql),
+  CLI_BUILTIN_COMMAND(2db),
+  CLI_BUILTIN_COMMAND(compare),
+#ifdef ZSVSHEET_BUILD
+  CLI_BUILTIN_COMMANDEXT(sheet),
+#endif
+  CLI_BUILTIN_COMMAND(echo),
+#ifdef ZSV_EXTRAS
+  CLI_BUILTIN_COMMAND(overwrite),
+#endif
+  CLI_BUILTIN_NO_OPTIONS_COMMAND(prop),
+  CLI_BUILTIN_NO_OPTIONS_COMMAND(rm),
+  CLI_BUILTIN_NO_OPTIONS_COMMAND(mv),
+#ifdef USE_JQ
+  CLI_BUILTIN_NO_OPTIONS_COMMAND(jq),
+#endif
+};
+
+// clang-format on
+
+struct zsv_execution_data {
+  struct zsv_ext *ext;
+  zsv_parser parser;
+
+  int argc;
+  const char **argv;
+  void *custom_context; // user-defined
+  void *state;          // program state relevant to the handler, e.g. cursor
+                        // position in zsv sheet.
+};
+
+static struct zsv_opts ext_parser_opts(zsv_execution_context ctx) {
+  (void)(ctx);
+  return zsv_get_default_opts();
+}
+
+char **custom_cmd_names = NULL;
+
+static enum zsv_ext_status ext_init(struct zsv_ext *ext);
+
+static int config_init_2(struct cli_config *c, char err_if_dl_not_found, char do_init, char verbose, char global_only,
+                         char home_only) {
+  memset(c, 0, sizeof(*c));
+  if (!global_only) { // find local (home dir) zsv.ini
+    if (!get_ini_file(c->home_filepath, FILENAME_MAX, 0))
+      *c->home_filepath = '\0';
+  }
+  if (!home_only) {
+    if (!get_ini_file(c->filepath, FILENAME_MAX, 1))
+      *c->filepath = '\0';
+  }
+  if (*c->home_filepath == '\0' && *c->filepath == '\0') {
+    fprintf(stderr, "Unable to get config filepath!\n");
+    return 1;
+  }
+
+  int rc = parse_extensions_ini(c, err_if_dl_not_found, verbose);
+  if (rc == 0 && do_init) {
+    for (struct zsv_ext *ext = c->extensions; ext; ext = ext->next) {
+      if (ext_init(ext) != zsv_ext_status_ok)
+        fprintf(stderr, "Error: unable to initialize extension %s\n", ext->id);
+    }
+  }
+  return rc;
+}
+
+static int config_init(struct cli_config *c, char err_if_dl_not_found, char do_init, char verbose) {
+  return config_init_2(c, err_if_dl_not_found, do_init, verbose, 0, 0);
+}
+
+static int config_free(struct cli_config *c) {
+  return zsv_unload_custom_cmds(c->extensions);
+}
+
+static void ext_set_context(zsv_execution_context ctx, void *custom_context) {
+  struct zsv_execution_data *d = ctx;
+  d->custom_context = custom_context;
+}
+
+static void *ext_get_context(zsv_execution_context ctx) {
+  struct zsv_execution_data *d = ctx;
+  return d->custom_context;
+}
+
+static void ext_set_state(zsv_execution_context ctx, void *state) {
+  struct zsv_execution_data *d = ctx;
+  d->state = state;
+}
+
+static void *ext_get_state(zsv_execution_context ctx) {
+  struct zsv_execution_data *d = ctx;
+  return d->state;
+}
+
+static void ext_set_parser(zsv_execution_context ctx, zsv_parser parser) {
+  struct zsv_execution_data *d = ctx;
+  d->parser = parser;
+}
+
+static zsv_parser ext_get_parser(zsv_execution_context ctx) {
+  struct zsv_execution_data *d = ctx;
+  return d->parser;
+}
+
+static void execution_context_free(struct zsv_execution_data *d) {
+  (void)(d);
+}
+
+static enum zsv_ext_status execution_context_init(struct zsv_execution_data *d, int argc, const char *argv[]) {
+  memset(d, 0, sizeof(*d));
+  d->argv = argv;
+  d->argc = argc;
+  return zsv_ext_status_ok;
+}
+
+static char *zsv_ext_errmsg(enum zsv_ext_status stat, zsv_execution_context ctx) {
+  switch (stat) {
+  case zsv_ext_status_ok:
+    return strdup("No error");
+  case zsv_ext_status_memory:
+    return strdup("Out of memory");
+  case zsv_ext_status_unrecognized_cmd:
+    if (!(ctx && ((struct zsv_execution_data *)ctx)->argc > 0))
+      return strdup("Unrecognized command");
+    else {
+      char *s;
+      struct zsv_execution_data *d = ctx;
+      asprintf(&s, "Unrecognized command %s", d->argv[1]);
+      return s;
+    }
+    // use zsv_ext_status_other for silent errors. will not attempt to call errcode() or errstr()
+  case zsv_ext_status_not_permitted:
+    return strdup("Not permitted");
+  case zsv_ext_status_other:
+    // use zsv_ext_status_err for custom errors. will attempt to call errcode() and errstr()
+    // for custom error code and message (if not errcode or errstr not provided, will be silent)
+  case zsv_ext_status_error:
+    return NULL;
+  }
+  return NULL;
+}
+
+// handle_ext_err(): return 1 if handled via ext callbacks, 0 otherwise
+static int handle_ext_err(struct zsv_ext *ext, zsv_execution_context ctx, enum zsv_ext_status stat) {
+  int rc = stat;
+  char *msg = zsv_ext_errmsg(stat, ctx);
+  if (msg) {
+    fprintf(stderr, "Error in extension %s: %s\n", ext->id, msg);
+    free(msg);
+  } else if (ext->module.errcode) {
+    int ext_err = rc = ext->module.errcode(ctx);
+    char *errstr = ext->module.errstr ? ext->module.errstr(ctx, ext_err) : NULL;
+    if (errstr) {
+      fprintf(stderr, "Error (%s): %s\n", ext->id, errstr);
+      if (ext->module.errfree)
+        ext->module.errfree(errstr);
+    }
+  }
+  return rc;
+}
+
+static void ext_set_help(zsv_execution_context ctx, const char *help) {
+  struct zsv_execution_data *data = ctx;
+  if (data && data->ext) {
+    free(data->ext->help);
+    data->ext->help = help ? strdup(help) : NULL;
+  }
+}
+
+static void ext_set_license(zsv_execution_context ctx, const char *license) {
+  struct zsv_execution_data *data = ctx;
+  if (data && data->ext) {
+    free(data->ext->license);
+    data->ext->license = license ? strdup(license) : NULL;
+  }
+}
+
+static char *dup_str_array(const char *ss[]) {
+  size_t len = 0;
+  for (int i = 0; ss && ss[i]; i++)
+    len += strlen(ss[i]);
+
+  if (!len)
+    return NULL;
+  char *mem = malloc(len + 2 * sizeof(*mem));
+  if (mem) {
+    char *tmp = mem;
+    for (int i = 0; ss && ss[i]; i++) {
+      size_t n = strlen(ss[i]);
+      if (n) {
+        memcpy(tmp, ss[i], n);
+        tmp += n;
+      }
+    }
+    mem[len] = mem[len + 1] = '\0';
+  }
+  return mem;
+}
+
+static void ext_set_thirdparty(zsv_execution_context ctx, const char *thirdparty[]) {
+  struct zsv_execution_data *data = ctx;
+  if (data && data->ext) {
+    free(data->ext->thirdparty);
+    data->ext->thirdparty = dup_str_array(thirdparty);
+  }
+}
+
+static enum zsv_ext_status ext_add_command(zsv_execution_context ctx, const char *id, const char *help,
+                                           zsv_ext_main extmain) {
+  struct zsv_execution_data *data = ctx;
+  if (data && data->ext && data->ext->commands_next && id && *id && extmain) {
+    struct zsv_ext_command *cmd = ext_command_new(id, help, extmain);
+    if (cmd) {
+      *data->ext->commands_next = cmd;
+      data->ext->commands_next = &cmd->next;
+      return zsv_ext_status_ok;
+    }
+  }
+  return zsv_ext_status_error;
+}
+
+static enum zsv_ext_status ext_parse_all(zsv_execution_context ctx, void *user_context, void (*row_handler)(void *ctx),
+                                         struct zsv_opts *const custom) {
+  struct zsv_opts opts = custom ? *custom : ext_parser_opts(ctx);
+
+  if (row_handler)
+    opts.row_handler = row_handler;
+  zsv_parser parser = zsv_new(&opts);
+  if (!parser)
+    return zsv_ext_status_memory;
+
+  ext_set_parser(ctx, parser);
+  ext_set_context(ctx, user_context);
+  zsv_set_context(parser, ctx);
+
+  zsv_handle_ctrl_c_signal();
+  enum zsv_status stat = zsv_status_ok;
+  while (!zsv_signal_interrupted && (stat = zsv_parse_more(parser)) == zsv_status_ok)
+    ;
+  if (stat == zsv_status_no_more_input || (zsv_signal_interrupted && stat == zsv_status_ok))
+    stat = zsv_finish(parser);
+  zsv_delete(parser);
+
+  return stat ? zsv_ext_status_error : zsv_ext_status_ok;
+}
+
+static struct zsv_ext_callbacks *zsv_ext_callbacks_init(struct zsv_ext_callbacks *e) {
+  if (e) {
+    memset(e, 0, sizeof(*e));
+    e->set_row_handler = zsv_set_row_handler;
+    e->set_context = zsv_set_context;
+    e->parse_more = zsv_parse_more;
+    e->abort = zsv_abort;
+    e->cell_count = zsv_cell_count;
+    e->get_cell = zsv_get_cell;
+    e->finish = zsv_finish;
+    e->delete = zsv_delete;
+
+    e->ext_set_context = ext_set_context;
+    e->ext_get_context = ext_get_context;
+    e->ext_get_parser = ext_get_parser;
+    e->ext_add_command = ext_add_command;
+
+    e->ext_set_help = ext_set_help;
+    e->ext_set_license = ext_set_license;
+    e->ext_set_thirdparty = ext_set_thirdparty;
+
+    e->ext_parse_all = ext_parse_all;
+    e->ext_parser_opts = ext_parser_opts;
+
+    e->ext_sqlite3_add_csv = zsv_sqlite3_add_csv;
+    e->ext_sqlite3_db_delete = zsv_sqlite3_db_delete;
+    e->ext_sqlite3_db_new = zsv_sqlite3_db_new;
+#ifdef ZSVSHEET_BUILD
+    e->ext_sheet_keypress = zsvsheet_ext_keypress;
+    e->ext_sheet_prompt = zsvsheet_ext_prompt;
+    e->ext_sheet_buffer_set_ctx = zsvsheet_buffer_set_ctx;
+    e->ext_sheet_buffer_get_ctx = zsvsheet_buffer_get_ctx;
+    e->ext_sheet_buffer_set_cell_attrs = zsvsheet_buffer_set_cell_attrs;
+    e->ext_sheet_cell_profile_attrs = zsvsheet_cell_profile_attrs;
+    e->ext_sheet_buffer_get_zsv_opts = zsvsheet_buffer_get_zsv_opts;
+    e->ext_sheet_buffer_on_newline = zsvsheet_buffer_on_newline;
+    e->ext_sheet_buffer_get_selected_cell = zsvsheet_buffer_get_selected_cell;
+    e->ext_sheet_set_status = zsvsheet_set_status;
+    e->ext_sheet_buffer_current = zsvsheet_buffer_current;
+    e->ext_sheet_buffer_prior = zsvsheet_buffer_prior;
+    e->ext_sheet_buffer_info = zsvsheet_buffer_info;
+    e->ext_sheet_buffer_filename = zsvsheet_buffer_filename;
+    e->ext_sheet_buffer_data_filename = zsvsheet_buffer_data_filename;
+    e->ext_sheet_open_file = zsvsheet_open_file;
+    e->ext_sheet_register_proc = zsvsheet_register_proc;
+    e->ext_sheet_register_proc_key_binding = zsvsheet_register_proc_key_binding;
+    e->ext_sheet_push_transformation = zsvsheet_push_transformation;
+    e->ext_sheet_transformation_writer = zsvsheet_transformation_writer;
+    e->ext_sheet_transformation_parser = zsvsheet_transformation_parser;
+    e->ext_sheet_transformation_filename = zsvsheet_transformation_filename;
+    e->ext_sheet_transformation_user_context = zsvsheet_transformation_user_context;
+#endif
+  }
+  return e;
+}
+
+static enum zsv_ext_status ext_init(struct zsv_ext *ext) {
+  enum zsv_ext_status stat = zsv_ext_status_ok;
+  if (!ext->inited) {
+    if (!ext->ok)
+      return zsv_ext_status_error;
+
+    ext->inited = zsv_init_started;
+    struct zsv_ext_callbacks cb;
+    zsv_ext_callbacks_init(&cb);
+    ext->commands_next = &ext->commands;
+
+    struct zsv_execution_data d;
+    memset(&d, 0, sizeof(d));
+    d.ext = ext;
+    if ((stat = ext->module.init(&cb, &d)) != zsv_ext_status_ok) {
+      handle_ext_err(ext, NULL, stat);
+      return stat;
+    }
+    ext->inited = zsv_init_ok; // init ok
+  }
+  return stat;
+}
+
+static int zsv_unload_custom_cmds(struct zsv_ext *ext) {
+  int err = 0;
+  for (struct zsv_ext *next; ext; ext = next) {
+    next = ext->next;
+    if (zsv_ext_delete(ext))
+      err = 1;
+  }
+  return err;
+}
+
+struct zsv_ext_command *find_ext_cmd(struct zsv_ext *ext, const char *id) {
+  for (struct zsv_ext_command *cmd = ext->commands; cmd; cmd = cmd->next)
+    if (!strcmp(cmd->id, id))
+      return cmd;
+  return NULL;
+}
+
+static enum zsv_ext_status run_extension(int argc, const char *argv[], struct zsv_ext *ext) {
+  enum zsv_ext_status stat = zsv_ext_status_error;
+  if (ext) {
+    if ((stat = ext_init(ext)) != zsv_ext_status_ok)
+      return stat;
+
+    struct zsv_ext_command *cmd = find_ext_cmd(ext, argv[1] + 3);
+    if (!cmd) {
+      fprintf(stderr, "Unrecognized command for extension %s: %s\n", ext->id, argv[1] + 3);
+      return zsv_ext_status_unrecognized_cmd;
+    }
+
+    struct zsv_execution_data ctx = {0};
+    if ((stat = execution_context_init(&ctx, argc, argv)) == zsv_ext_status_ok) {
+      struct zsv_opts opts;
+      zsv_args_to_opts(argc, argv, &ctx.argc, ctx.argv, &opts);
+      zsv_set_default_opts(opts);
+      // need a corresponding zsv_set_default_custom_prop_handler?
+
+      stat = cmd->main(&ctx, ctx.argc - 1, &ctx.argv[1], &opts);
+    }
+
+    if (stat != zsv_ext_status_ok)
+      stat = handle_ext_err(ext, &ctx, stat);
+    execution_context_free(&ctx);
+  }
+  return stat;
+}
+
+// havearg(): case-insensitive partial arg matching
+char havearg(const char *arg, const char *form1, size_t min_len1, const char *form2, size_t min_len2) {
+  size_t len = strlen(arg);
+  if (!min_len1)
+    min_len1 = strlen(form1);
+  if (len > min_len1)
+    min_len1 = len;
+
+  if (!zsv_strincmp_ascii((const unsigned char *)arg, min_len1, (const unsigned char *)form1, min_len1))
+    return 1;
+
+  if (form2) {
+    if (!min_len2)
+      min_len2 = strlen(form2);
+    if (len > min_len2)
+      min_len2 = len;
+    if (!zsv_strincmp_ascii((const unsigned char *)arg, min_len2, (const unsigned char *)form2, min_len2))
+      return 1;
+  }
+  return 0;
+}
+
+static struct builtin_cmd *find_builtin(const char *cmd_name) {
+  int builtin_cmd_count = sizeof(builtin_cmds) / sizeof(*builtin_cmds);
+  if (!strcmp(cmd_name, "-h") || !strcmp(cmd_name, "--help"))
+    cmd_name = "help";
+  for (int i = 0; i < builtin_cmd_count; i++)
+    if (havearg(cmd_name, builtin_cmds[i].name, 0, 0, 0))
+      return &builtin_cmds[i];
+  return NULL;
+}
+
+#include "builtin/license.c"
+#include "builtin/thirdparty.c"
+#include "builtin/help.c"
+#include "builtin/version.c"
+#include "builtin/register.c"
+
+static const char *extension_cmd_from_arg(const char *arg) {
+  const char *dash = strchr(arg, '-');
+  if (dash && dash < arg + ZSV_EXTENSION_ID_MAX_LEN && dash[1] != '\0')
+    return dash + 1;
+  return NULL;
+}
+
+#ifndef ZSV_CLI_MAIN
+#define ZSV_CLI_MAIN main
+#endif
+
+ZSV_CLI_EXPORT
+int ZSV_CLI_MAIN(int argc, const char *argv[]) {
+  const char **alt_argv = NULL;
+  struct builtin_cmd *builtin = find_builtin(argc > 1 ? argv[1] : "help");
+  if (builtin) {
+    // help is different from other commands: zsv help <arg> is treated as
+    //   if it was zsv <arg> --help
+    if (builtin->main == main_help && argc > 2) {
+      struct builtin_cmd *help_builtin = find_builtin(argv[2]);
+      if (help_builtin) {
+        const char *argv_tmp[2] = {argv[2], "--help"};
+        if (help_builtin->main)
+          return help_builtin->main(2, argv_tmp);
+        else if (help_builtin->cmd) {
+          struct zsv_opts opts = {0};
+          return help_builtin->cmd(2, argv_tmp, &opts, NULL);
+        } else
+          return fprintf(stderr, "Unexpected syntax!\n");
+      } else {
+        const char *ext_cmd = extension_cmd_from_arg(argv[2]);
+        if (ext_cmd) {
+          alt_argv = calloc(3, sizeof(*alt_argv));
+          alt_argv[0] = argv[0];
+          alt_argv[1] = argv[2];
+          alt_argv[2] = "--help";
+          argc = 3;
+          argv = alt_argv;
+        } else {
+          fprintf(stderr, "Unrecognized command %s\n", argv[2]);
+          free(alt_argv);
+          return 1;
+        }
+      }
+    } else {
+      if (builtin->main)
+        return builtin->main(argc - 1, argc > 1 ? &argv[1] : NULL);
+
+      struct zsv_opts opts;
+      enum zsv_status stat = zsv_args_to_opts(argc, argv, &argc, argv, &opts);
+      if (stat == zsv_status_ok)
+        return builtin->cmd(argc - 1, argc > 1 ? &argv[1] : NULL, &opts, NULL);
+      return stat;
+    }
+  }
+
+  int err = 1;
+  if (extension_cmd_from_arg(argv[1]) != NULL) { // this is an extension command
+    struct cli_config config;
+    memset(&config, 0, sizeof(config));
+    if (!(err = add_extension(argv[1], &config.extensions, 0, 0))) {
+      if (config.extensions)
+        err = run_extension(argc, argv, config.extensions);
+      else {
+        fprintf(stderr, "Unrecognized command or extension %s\n", argv[1]);
+        ;
+        err = 1;
+      }
+    }
+    if (config_free(&config) && !err)
+      err = 1;
+  } else
+    fprintf(stderr, "Unrecognized command %s\n", argv[1]), err = 1;
+
+  free(alt_argv);
+  return err;
+}
+
+// extensions
+static enum zsv_ext_status zsv_ext_delete(struct zsv_ext *ext) {
+  enum zsv_ext_status stat = zsv_ext_status_ok;
+  if (ext) {
+    if (ext->dl) {
+      if (ext->module.exit && ext->inited) {
+        stat = ext->module.exit();
+        if (stat != zsv_ext_status_ok)
+          handle_ext_err(ext, NULL, stat);
+      }
+      dlclose(ext->dl);
+    }
+    for (struct zsv_ext_command *next, *cmd = ext->commands; cmd; cmd = next) {
+      next = cmd->next;
+      ext_command_delete(cmd);
+    }
+    free(ext->id);
+    free(ext->help);
+    free(ext->license);
+    free(ext->thirdparty);
+    free(ext);
+  }
+  return stat;
+}
+
+/**
+ * zsv_ext_init(): return error
+ */
+static int zsv_ext_init(void *dl, const char *dl_name, struct zsv_ext *ext) {
+  memset(ext, 0, sizeof(*ext));
+  if (dl) {
+#define zsv_ext_func_assign(sig, x) ext->module.x = sig zsv_dlsym(dl, "zsv_ext_" #x)
+#include "cli_internal.c.in"
+
+    /* check if required functions are present */
+    if (ext->module.id)
+      return 0;
+    fprintf(stderr, "Dynamic library %s missing required function zsv_ext_id()\n", dl_name);
+  }
+  return 1;
+}
+
+#ifdef __APPLE__
+#include <dlfcn.h>
+#endif
+
+#ifdef _WIN32
+char *get_module_name(HMODULE handle) {
+  wchar_t *pth16 = (wchar_t *)malloc(32768); // max long path length
+  DWORD n16 = GetModuleFileNameW(handle, pth16, 32768);
+  if (n16 <= 0) {
+    free(pth16);
+    return NULL;
+  }
+  pth16[n16] = L'\0';
+  DWORD n8 = WideCharToMultiByte(CP_UTF8, 0, pth16, -1, NULL, 0, NULL, NULL);
+  if (n8 == 0) {
+    free(pth16);
+    return NULL;
+  }
+  char *filepath = (char *)malloc(++n8);
+  if (!WideCharToMultiByte(CP_UTF8, 0, pth16, -1, filepath, n8, NULL, NULL)) {
+    free(pth16);
+    free(filepath);
+    return NULL;
+  }
+  free(pth16);
+  return filepath;
+}
+#endif
+
+static char *dl_name_from_func(const void *func) {
+#ifdef _WIN32
+  HMODULE hModule = NULL;
+  if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+                        (LPCTSTR)func, &hModule))
+    return get_module_name(hModule);
+#elif defined __APPLE__
+  Dl_info info;
+  if (dladdr(func, &info))
+    return strdup(info.dli_fname);
+#else
+  (void)(func);
+#endif
+  return NULL;
+}
+
+#ifdef __EMSCRIPTEN__
+static void *zsv_dlopen(const char *path, int mode) {
+  fprintf(stderr, "Emscripten dlopen() does not work for shared libs > 4kb!"
+                  "fix this when it does."
+                  "See https://github.com/emscripten-core/emscripten/issues/15795\n");
+  return dlopen(path, mode);
+}
+#else
+#define zsv_dlopen dlopen
+#endif
+
+static struct zsv_ext *zsv_ext_new(const char *dl_name, const char *id, char verbose) {
+  struct zsv_ext *dl = NULL;
+  struct zsv_ext tmp;
+#ifdef __EMSCRIPTEN__
+  void *h = NULL;
+#else
+  void *h = zsv_dlopen(dl_name, RTLD_LAZY);
+#endif
+  if (!h) {
+    // not in system search path. try again in the same path as our executable (or in /ext if in emcc)
+    char exe_path[FILENAME_MAX];
+    char have_path = 0;
+#ifdef __EMSCRIPTEN__
+    size_t n = snprintf(exe_path, sizeof(exe_path), "/tmp/zsvext%s.so", id);
+    if (n > 0 && n < sizeof(exe_path)) {
+      fprintf(stderr, "Opening %s\n", exe_path);
+      h = zsv_dlopen(exe_path, RTLD_LAZY);
+    } else
+      fprintf(stderr, "Opening what???\n");
+#else
+    size_t n = zsv_get_executable_path(exe_path, sizeof(exe_path));
+    if (n > 0 && n < sizeof(exe_path)) {
+      char *end = strrchr(exe_path, FILESLASH);
+      if (end) {
+        end[1] = '\0';
+        n = strlen(exe_path);
+        size_t n2 = snprintf(exe_path + n, sizeof(exe_path) - n, "%s", dl_name);
+        if (n2 > 0 && n + n2 < sizeof(exe_path)) {
+          have_path = 1;
+          h = zsv_dlopen(exe_path, RTLD_LAZY);
+        }
+      }
+    }
+#endif
+    if (verbose) {
+      if (have_path)
+        fprintf(stderr, "Library %s not found in path; trying exe dir %s\n", dl_name, exe_path);
+      else
+        fprintf(stderr, "Library %s not found in path; cannot determine exe dir\n", dl_name);
+    }
+  }
+  if (!h)
+#if defined(WIN32) || defined(_WIN32)
+    fprintf(stderr, "Library %s not found\n", dl_name);
+#else
+    fprintf(stderr, "Library %s failed to load: %s\n", dl_name, dlerror());
+#endif
+
+  // run zsv_ext_init to add to our extension list, even if it's invalid
+  tmp.ok = !zsv_ext_init(h, dl_name, &tmp);
+  const char *m_id = tmp.ok && tmp.module.id ? tmp.module.id() : NULL;
+  if (h && (!m_id || strcmp(m_id, (const char *)id))) {
+    fprintf(stderr,
+            "Library %s: unexpected result from zsv_ext_id()\n"
+            "(got %s, expected %s)\n",
+            id, m_id ? m_id : "(null)", id);
+    tmp.ok = 0;
+  } else if (h && tmp.ok) {
+    if (verbose) {
+      char *image_name = dl_name_from_func((const void *)tmp.module.id);
+      fprintf(stderr, "Loaded %s from %s\n", dl_name, image_name ? image_name : "unknown location");
+      free(image_name);
+    }
+  }
+  tmp.dl = h;
+  tmp.id = strdup((const char *)id);
+  if (!(dl = calloc(1, sizeof(*dl))))
+    fprintf(stderr, "Out of memory\n");
+  else
+    *dl = tmp;
+  return dl;
+}