zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/utils/dirs_from_json.c

@@ -0,0 +1,253 @@
+#include <yajl_helper/yajl_helper.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/os.h>
+
+struct zsv_dir_from_json_ctx {
+  const char *filepath_prefix;
+  unsigned char buff[4096];
+  size_t content_start;
+  FILE *out;
+  char *out_filepath;
+  struct jv_to_json_ctx jctx;
+  zsv_jq_handle zjq;
+
+  int err;
+  unsigned char in_obj : 1;
+  unsigned char do_check : 1;
+  unsigned char dry : 1;
+  unsigned char _ : 5;
+};
+
+static void zsv_dir_from_json_close_out(struct zsv_dir_from_json_ctx *ctx) {
+  if (ctx->zjq) {
+    zsv_jq_finish(ctx->zjq);
+    zsv_jq_delete(ctx->zjq);
+    ctx->zjq = NULL;
+  }
+  if (ctx->out) {
+    fclose(ctx->out);
+    ctx->out = NULL;
+    free(ctx->out_filepath);
+    ctx->out_filepath = NULL;
+  }
+}
+
+static int zsv_dir_from_json_map_key(yajl_helper_t yh, const unsigned char *s, size_t len) {
+  if (yajl_helper_level(yh) == 1 && len) { // new property file entry
+    struct zsv_dir_from_json_ctx *ctx = yajl_helper_ctx(yh);
+
+    char *fn = NULL;
+    if (ctx->filepath_prefix)
+      asprintf(&fn, "%s%c%.*s", ctx->filepath_prefix, FILESLASH, (int)len, s);
+    else
+      asprintf(&fn, "%.*s", (int)len, s);
+
+    // if we have any backslashes, replace with fwd slash
+    if (fn)
+      for (int i = 0, j = strlen(fn); i < j; i++)
+        if (fn[i] == '\\')
+          fn[i] = '/';
+    if (!fn) {
+      errno = ENOMEM;
+      perror(NULL);
+    } else if (ctx->do_check) {
+      // we just want to check if the destination file exists
+      if (access(fn, F_OK) != -1) { // it exists
+        ctx->err = errno = EEXIST;
+        perror(fn);
+      }
+    } else if (ctx->dry) { // just output the name of the file
+      printf("%s\n", fn);
+    } else if (zsv_mkdirs(fn, 1)) {
+      fprintf(stderr, "Unable to create directories for %s\n", fn);
+    } else if (!((ctx->out = zsv_fopen(fn, "wb")))) {
+      perror(fn);
+    } else {
+      ctx->out_filepath = fn;
+      fn = NULL;
+
+      // if it's a JSON file, use a jq filter to pretty-print
+      if (strlen(ctx->out_filepath) > 5 &&
+          !zsv_stricmp((const unsigned char *)ctx->out_filepath + strlen(ctx->out_filepath) - 5,
+                       (const unsigned char *)".json")) {
+        ctx->jctx.write1 = zsv_jq_fwrite1;
+        ctx->jctx.ctx = ctx->out;
+        ctx->jctx.flags = JV_PRINT_PRETTY | JV_PRINT_SPACE1;
+        enum zsv_jq_status jqstat;
+        ctx->zjq = zsv_jq_new((const unsigned char *)".", jv_to_json_func, &ctx->jctx, &jqstat);
+        if (!ctx->zjq) {
+          fprintf(stderr, "zsv_jq_new: unable to open for %s\n", ctx->out_filepath);
+          zsv_dir_from_json_close_out(ctx);
+        }
+      }
+    }
+    free(fn);
+  }
+  return 1;
+}
+
+static int zsv_dir_from_json_start_obj(yajl_helper_t yh) {
+  if (yajl_helper_level(yh) == 2) {
+    struct zsv_dir_from_json_ctx *ctx = yajl_helper_ctx(yh);
+    ctx->in_obj = 1;
+    ctx->content_start = yajl_get_bytes_consumed(yajl_helper_yajl(yh)) - 1;
+  }
+  return 1;
+}
+
+// zsv_dir_from_json_flush(): return err
+static int zsv_dir_from_json_flush(yajl_handle yajl, struct zsv_dir_from_json_ctx *ctx) {
+  if (ctx->zjq) {
+    size_t current_position = yajl_get_bytes_consumed(yajl);
+    if (current_position <= ctx->content_start)
+      fprintf(stderr, "Error! zsv_dir_from_json_flush unexpected current position\n");
+    else
+      zsv_jq_parse(ctx->zjq, ctx->buff + ctx->content_start, current_position - ctx->content_start);
+    ctx->content_start = 0;
+  }
+  return 0;
+}
+
+static int zsv_dir_from_json_end_obj(yajl_helper_t yh) {
+  if (yajl_helper_level(yh) == 1) { // just finished level 2
+    struct zsv_dir_from_json_ctx *ctx = yajl_helper_ctx(yh);
+    zsv_dir_from_json_flush(yajl_helper_yajl(yh), yajl_helper_ctx(yh));
+    zsv_dir_from_json_close_out(ctx);
+    ctx->in_obj = 0;
+  }
+  return 1;
+}
+
+static int zsv_dir_from_json_process_value(yajl_helper_t yh, struct json_value *value) {
+  if (yajl_helper_level(yh) == 1) { // just finished level 2
+    struct zsv_dir_from_json_ctx *ctx = yajl_helper_ctx(yh);
+    const unsigned char *jsstr;
+    size_t len;
+    json_value_default_string(value, &jsstr, &len);
+    if (ctx->zjq) {
+      unsigned char *js = len ? zsv_json_from_str_n(jsstr, len) : NULL;
+      if (js)
+        zsv_jq_parse(ctx->zjq, js, strlen((char *)js));
+      else
+        zsv_jq_parse(ctx->zjq, "null", 4);
+      free(js);
+    } else if (len && ctx->out)
+      fwrite(jsstr, 1, len, ctx->out);
+    zsv_dir_from_json_close_out(ctx);
+  }
+  return 1;
+}
+
+/**
+ * Convert a JSON stream into file and directory contents
+ * This function is the inverse of zsv_dir_to_json()
+ * Output schema is a dictionary where key = path and value = contents
+ * Files named with .json suffix will be exported as JSON (content must be valid JSON)
+ * Files named with any other suffix will be exported as a single string value (do not try with large files)
+ */
+int zsv_dir_from_json(const unsigned char *target_dir, FILE *src,
+                      unsigned int flags, // ZSV_DIR_FLAG_XX
+                      unsigned char _verbose) {
+  (void)(_verbose);
+  int err = 0;
+  int force = !!(flags & ZSV_DIR_FLAG_FORCE);
+  int dry = !!(flags & ZSV_DIR_FLAG_DRY);
+  char *tmp_fn = NULL; // only used if force = 0 and src == stdin
+  if (!force) {
+    // if input is stdin, we'll need to read it twice, so save it first
+    // this isn't the most efficient way to do it, as it reads it 3 times
+    // but it's easier and the diff is immaterial
+    if (src == stdin) {
+      src = NULL;
+      tmp_fn = zsv_get_temp_filename("zsv_prop_XXXXXXXX");
+      FILE *tmp_f;
+      if (!tmp_fn) {
+        err = errno = ENOMEM;
+        perror(NULL);
+      } else if (!(tmp_f = zsv_fopen(tmp_fn, "wb"))) {
+        err = errno;
+        perror(tmp_fn);
+      } else {
+        err = zsv_copy_file_ptr(stdin, tmp_f);
+        fclose(tmp_f);
+        if (!(src = zsv_fopen(tmp_fn, "rb"))) {
+          err = errno;
+          perror(tmp_fn);
+        }
+      }
+    }
+  }
+
+  if (!err) {
+    // we will run this loop either once (force) or twice (no force):
+    // 1. check before running (no force)
+    // 2. do the import
+    char do_check = !force;
+    if (do_check && !zsv_dir_exists((const char *)target_dir))
+      do_check = 0;
+
+    for (int i = do_check ? 0 : 1; i < 2 && !err; i++) {
+      do_check = i == 0;
+
+      size_t bytes_read;
+      yajl_helper_t yh;
+      struct zsv_dir_from_json_ctx ctx = {0};
+      ctx.filepath_prefix = (const char *)target_dir;
+
+      int (*start_obj)(yajl_helper_t yh) = NULL;
+      int (*end_obj)(yajl_helper_t yh) = NULL;
+      int (*process_value)(struct yajl_helper_parse_state *, struct json_value *) = NULL;
+
+      if (do_check)
+        ctx.do_check = do_check;
+      else {
+        ctx.dry = dry;
+        if (!ctx.dry) {
+          start_obj = zsv_dir_from_json_start_obj;
+          end_obj = zsv_dir_from_json_end_obj;
+          process_value = zsv_dir_from_json_process_value;
+        }
+      }
+
+      yh = yajl_helper_new(32, start_obj, end_obj,                        // map start/end
+                           zsv_dir_from_json_map_key, start_obj, end_obj, // array start/end
+                           process_value, &ctx);
+      if (!yh) {
+        err = errno = ENOMEM;
+        perror(NULL);
+      } else {
+        yajl_handle y = yajl_helper_yajl(yh);
+        while ((bytes_read = fread(ctx.buff, 1, sizeof(ctx.buff), src)) > 0) {
+          if (yajl_parse(y, ctx.buff, bytes_read) != yajl_status_ok)
+            yajl_helper_print_err(y, ctx.buff, bytes_read);
+          if (ctx.in_obj)
+            zsv_dir_from_json_flush(y, &ctx);
+        }
+        if (yajl_complete_parse(y) != yajl_status_ok)
+          yajl_helper_print_err(y, ctx.buff, bytes_read);
+
+        if (ctx.out) { // e.g. if bad JSON and parse failed
+          fclose(ctx.out);
+          free(ctx.out_filepath);
+        }
+        yajl_helper_delete(yh);
+      }
+
+      if (ctx.err)
+        err = ctx.err;
+      if (i == 0) {
+        rewind(src);
+        if (errno) {
+          err = errno;
+          perror(NULL);
+        }
+      }
+    }
+  }
+  if (tmp_fn) {
+    unlink(tmp_fn);
+    free(tmp_fn);
+  }
+
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/dirs_to_json.c

@@ -0,0 +1,121 @@
+struct zsv_dir_foreach_to_json_ctx {
+  struct zsv_dir_filter zsv_dir_filter;
+  const unsigned char *parent_dir;
+  struct jv_to_json_ctx jctx;
+  zsv_jq_handle zjq;
+  unsigned count; // number of files exported so far
+  int err;
+};
+
+static int zsv_dir_foreach_to_json(struct zsv_foreach_dirent_handle *h, size_t depth) {
+  struct zsv_dir_foreach_to_json_ctx *ctx = h->ctx;
+  h->ctx = ctx->zsv_dir_filter.ctx;
+  if (!ctx->zsv_dir_filter.filter(h, depth))
+    h->no_recurse = 1;   // skip this node (only matters if node is dir)
+  else if (!h->is_dir) { // process this file
+    char suffix = 0;
+    if (strlen(h->parent_and_entry) > 5 &&
+        !zsv_stricmp((const unsigned char *)h->parent_and_entry + strlen(h->parent_and_entry) - 5,
+                     (const unsigned char *)".json"))
+      suffix = 'j'; // json
+    else if (strlen(h->parent_and_entry) > 4 &&
+             !zsv_stricmp((const unsigned char *)h->parent_and_entry + strlen(h->parent_and_entry) - 4,
+                          (const unsigned char *)".txt"))
+      suffix = 't'; // text
+    if (suffix) {
+      // for now, only handle json or txt
+      FILE *f = fopen(h->parent_and_entry, "rb");
+      if (!f)
+        perror(h->parent_and_entry);
+      else {
+        // create an entry for this file. the map key is the file name; its value is the file contents
+        unsigned char *js =
+          zsv_json_from_str((const unsigned char *)h->parent_and_entry + strlen((const char *)ctx->parent_dir) + 1);
+        if (!js)
+          errno = ENOMEM, perror(NULL);
+        else if (*js) {
+          if (ctx->count > 0)
+            if (zsv_jq_parse(ctx->zjq, ",", 1))
+              ctx->err = 1;
+          if (!ctx->err) {
+            ctx->count++;
+            if (zsv_jq_parse(ctx->zjq, js, strlen((const char *)js)) || zsv_jq_parse(ctx->zjq, ":", 1))
+              ctx->err = 1;
+            else {
+              switch (suffix) {
+              case 'j': // json
+                if (zsv_jq_parse_file(ctx->zjq, f))
+                  ctx->err = 1;
+                break;
+              case 't': // txt
+                // for now we are going to limit txt file values to 4096 chars and JSON-stringify it
+                {
+                  unsigned char buff[4096];
+                  size_t n = fread(buff, 1, sizeof(buff), f);
+                  unsigned char *txt_js = NULL;
+                  if (n) {
+                    txt_js = zsv_json_from_str_n(buff, n);
+                    if (zsv_jq_parse(ctx->zjq, txt_js ? txt_js : (const unsigned char *)"null",
+                                     txt_js ? strlen((const char *)txt_js) : 4))
+                      ctx->err = 1;
+                  }
+                }
+                break;
+              }
+            }
+          }
+        }
+        free(js);
+        fclose(f);
+      }
+    }
+  }
+  h->ctx = ctx;
+  return 0;
+}
+
+/**
+ * Convert directory contents into a single JSON file
+ * Output schema is a dictionary where key = path and value = contents
+ * Files named with .json suffix will be exported as JSON (content must be valid JSON)
+ * Files named with any other suffix will be exported as a single string value (do not try with large files)
+ *
+ * @param parent_dir : directory to export
+ * @param dest       : file path to output to, or NULL to output to stdout
+ */
+int zsv_dir_to_json(const unsigned char *parent_dir, const unsigned char *output_filename,
+                    struct zsv_dir_filter *zsv_dir_filter, unsigned char verbose) {
+  int err = 0;
+  FILE *fdest = output_filename ? fopen((const char *)output_filename, "wb") : stdout;
+  if (!fdest)
+    err = errno, perror((const char *)output_filename);
+  else {
+    struct zsv_dir_foreach_to_json_ctx ctx = {0};
+    ctx.zsv_dir_filter = *zsv_dir_filter;
+    ctx.parent_dir = parent_dir;
+
+    // use a jq filter to pretty-print
+    ctx.jctx.write1 = zsv_jq_fwrite1;
+    ctx.jctx.ctx = fdest;
+    ctx.jctx.flags = JV_PRINT_PRETTY | JV_PRINT_SPACE1;
+    enum zsv_jq_status jqstat;
+    ctx.zjq = zsv_jq_new((const unsigned char *)".", jv_to_json_func, &ctx.jctx, &jqstat);
+    if (!ctx.zjq)
+      err = 1, fprintf(stderr, "zsv_jq_new\n");
+    else {
+      if (jqstat == zsv_jq_status_ok && zsv_jq_parse(ctx.zjq, "{", 1) == zsv_jq_status_ok) {
+        // export each file
+        zsv_foreach_dirent((const char *)parent_dir, ctx.zsv_dir_filter.max_depth, zsv_dir_foreach_to_json, &ctx,
+                           verbose);
+        if (!ctx.err && zsv_jq_parse(ctx.zjq, "}", 1))
+          ctx.err = 1;
+        if (!ctx.err && zsv_jq_finish(ctx.zjq))
+          ctx.err = 1;
+        zsv_jq_delete(ctx.zjq);
+      }
+      err = ctx.err;
+    }
+    fclose(fdest);
+  }
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/dl.c

@@ -0,0 +1,20 @@
+/*
+ * 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 <zsv/utils/dl.h>
+
+void (*zsv_dlsym(void *restrict handle, const char *restrict name))(void) {
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+  return dlsym(handle, name);
+#pragma GCC diagnostic pop
+}
+
+#ifdef _WIN32
+#include "win/dl.c"
+#endif

data/ext/zsv/vendor/zsv-1.3.0/app/utils/emcc/fs_api.c

@@ -0,0 +1,159 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <dirent.h>
+#include <sys/stat.h>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten.h>
+#else
+#define EMSCRIPTEN_KEEPALIVE
+#endif
+
+#include <zsv/utils/emcc/fs_api.h>
+
+struct fs_data {
+  FILE *f;
+};
+
+EMSCRIPTEN_KEEPALIVE
+fshandle fsopen(const char *fn, const char *mode) {
+  struct fs_data *d = calloc(1, sizeof(*d));
+  if (d)
+    d->f = fopen(fn, mode);
+  return d;
+}
+
+EMSCRIPTEN_KEEPALIVE
+int fsclose(fshandle h) {
+  if (h) {
+    int rc = fclose(h->f);
+    free(h);
+    return rc;
+  }
+  return 1;
+}
+
+EMSCRIPTEN_KEEPALIVE
+size_t fswrite(const void *ptr, size_t n, size_t m, fshandle h) {
+  return fwrite(ptr, n, m, h->f);
+}
+
+EMSCRIPTEN_KEEPALIVE
+void stdflush(int addNewline) {
+  fflush(stdout);
+  if (addNewline)
+    fprintf(stdout, "\n");
+
+  fflush(stderr);
+  if (addNewline)
+    fprintf(stderr, "\n");
+}
+
+/*
+EMSCRIPTEN_KEEPALIVE
+size_t bytesum(const char *fn) {
+  size_t sum = 0;
+  FILE *f = fopen(fn, "rb");
+  if(f) {
+    char buff[1024];
+    size_t bytes_read;
+    while((bytes_read = fread(buff, 1, sizeof(buff), f))) {
+      for(size_t i = 0; i < bytes_read; i++) {
+        sum += buff[i];
+        sum = sum % 1000000000;
+      }
+    }
+    fclose(f);
+  }
+  return sum;
+}
+*/
+
+EMSCRIPTEN_KEEPALIVE
+size_t fsread(void *ptr, size_t n, size_t m, fshandle h) {
+  return fread(ptr, n, m, h->f);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int fsrm(const char *fn) {
+  return unlink(fn);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int fsmkdir(const char *path) {
+#ifdef _WIN32
+  return mkdir(path);
+#endif
+  return mkdir(path, S_IRWXU);
+}
+
+EMSCRIPTEN_KEEPALIVE
+int fsprint(const char *s) {
+  fwrite(s, 1, strlen(s), stdout);
+  return 0;
+}
+
+EMSCRIPTEN_KEEPALIVE
+int fsprinterr(const char *s) {
+  fwrite(s, 1, strlen(s), stderr);
+  fprintf(stderr, "printed fsprinterr\n");
+  return 0;
+}
+
+/**
+ * return single string of entries delimited by newline
+ * caller must free()
+ */
+EMSCRIPTEN_KEEPALIVE
+char *fsls(const char *dir) {
+  struct dirent *de; // Pointer for directory entry
+  // opendir() returns a pointer of DIR type.
+  if (!dir || !*dir)
+    dir = ".";
+  DIR *dr = opendir(dir);
+  if (!dr)
+    fprintf(stderr, "Could not open current directory");
+  else {
+    size_t total_mem = 0;
+    struct tmp_str_list {
+      struct tmp_str_list *next;
+      char *c;
+    };
+    struct tmp_str_list *head = NULL, **tail = &head;
+    while ((de = readdir(dr)) != NULL) { // see http://pubs.opengroup.org/onlinepubs/7990989775/xsh/readdir.html
+      struct tmp_str_list *tmp = malloc(sizeof(*tmp));
+      if (tmp) {
+        tmp->next = NULL;
+        tmp->c = strdup(de->d_name);
+        if (!tmp->c)
+          free(tmp);
+        else {
+          total_mem += (1 + strlen(tmp->c));
+          *tail = tmp;
+          tail = &tmp->next;
+        }
+      }
+    }
+
+    char *final_result = NULL;
+    if (total_mem && (final_result = malloc(total_mem + 1))) {
+      size_t offset = 0;
+      for (struct tmp_str_list *tmp = head, *next; tmp; tmp = next) {
+        next = tmp->next;
+        size_t len = strlen(tmp->c);
+        memcpy(final_result + offset, tmp->c, len);
+        offset += len + 1;
+        final_result[offset - 1] = '\n';
+        free(tmp->c);
+        free(tmp);
+      }
+      final_result[total_mem - 1] = '\0';
+    }
+
+    closedir(dr);
+    return final_result;
+  }
+  return NULL;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/err.c

@@ -0,0 +1,24 @@
+/*
+ * 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 <stdio.h>
+#include <stdarg.h>
+
+int zsv_app_printerr(const char *appname, int eno, const char *fmt, ...) {
+  if (appname && *appname)
+    fprintf(stderr, "(%s) %i: ", appname, eno);
+  else
+    fprintf(stderr, "%i: ", eno);
+
+  va_list argv;
+  va_start(argv, fmt);
+  vfprintf(stderr, fmt, argv);
+  va_end(argv);
+  fprintf(stderr, "\n");
+  return eno;
+}