zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/cache.h

@@ -0,0 +1,49 @@
+#ifndef ZSV_CACHE_H
+#define ZSV_CACHE_H
+
+/**
+ * Overridable constants: ZSV_CACHE_PREFIX and ZSV_TEMPFILE_SUFFIX
+ */
+
+#ifndef ZSV_CACHE_PREFIX
+#define ZSV_CACHE_PREFIX "zsv"
+#endif
+
+#ifndef ZSV_TEMPFILE_SUFFIX
+#define ZSV_TEMPFILE_SUFFIX ".~zsv"
+#endif
+
+/**
+ * Cache path definitions
+ */
+#ifdef _WIN32
+#define ZSV_CACHE_DIR "." ZSV_CACHE_PREFIX "\\data"
+#else
+#define ZSV_CACHE_DIR "." ZSV_CACHE_PREFIX "/data"
+#endif
+
+#define ZSV_CACHE_PROPERTIES_NAME "props"
+
+/**
+ * Return the folder or file path to the cache for a given data file
+ * Caller must free the returned result
+ */
+unsigned char *zsv_cache_path(const unsigned char *data_filepath, const unsigned char *cache_filename, char temp_file);
+
+enum zsv_cache_type {
+  zsv_cache_type_property = 1,
+  zsv_cache_type_tag,
+  zsv_cache_type_overwrite
+};
+
+unsigned char *zsv_cache_filepath(const unsigned char *data_filepath, enum zsv_cache_type type, char create_dir,
+                                  char temp_file);
+
+int zsv_cache_print(const unsigned char *filepath, enum zsv_cache_type ctype, const unsigned char *default_value);
+
+int zsv_cache_remove(const unsigned char *filepath, enum zsv_cache_type ctype);
+
+int zsv_modify_cache_file(const unsigned char *filepath, enum zsv_cache_type ctype, const unsigned char *json_value1,
+                          const unsigned char *json_value2, const unsigned char *filter);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/clock.h

@@ -0,0 +1,36 @@
+/*
+ * 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
+ */
+
+#ifndef __ZSV_UTIL_CLOCK_H__
+#define __ZSV_UTIL_CLOCK_H__
+
+#include <time.h>
+#include <stdio.h>
+
+void zsv_clocks_begin(void);
+void zsv_clocks_end(void);
+
+size_t zsv_fread_clock(void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+size_t zsv_fwrite_clock(const void *restrict ptr, size_t size, size_t nitems, FILE *restrict stream);
+int zsv_fflush_clock(FILE *stream);
+
+#if USE_CLOCK
+
+#define ZSV_FREAD zsv_fread_clock
+#define ZSV_FWRITE zsv_fwrite_clock
+#define ZSV_FFLUSH zsv_fflush_clock
+
+#else
+
+#define ZSV_FREAD fread
+#define ZSV_FWRITE fwrite
+#define ZSV_FFLUSH fflush
+
+#endif
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/compiler.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2021 Tai Chi Minh Ralph Eastwood
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#ifndef ZSV_UTILS_COMPILER
+#define ZSV_UTILS_COMPILER
+
+#ifdef HAVE___BUILTIN_EXPECT
+
+#ifndef LIKELY
+#define LIKELY(x) __builtin_expect(x, 1)
+#endif
+
+#ifndef UNLIKELY
+#define UNLIKELY(x) __builtin_expect(x, 0)
+#endif
+
+#ifndef VERY_LIKELY
+#ifdef NO___BUILTIN_EXPECT_WITH_PROBABILITY
+#define VERY_LIKELY(x) LIKELY(x)
+#else
+#define VERY_LIKELY(x) __builtin_expect_with_probability(x, 1, 0.999)
+#endif
+#endif
+
+#ifndef VERY_UNLIKELY
+#ifdef NO___BUILTIN_EXPECT_WITH_PROBABILITY
+#define VERY_UNLIKELY(x) UNLIKELY(x)
+#else
+#define VERY_UNLIKELY(x) __builtin_expect_with_probability(x, 0, 0.999)
+#endif
+#endif
+
+#else
+/* no HAVE___BUILTIN_EXPECT */
+#ifndef LIKELY
+#define LIKELY(x) (x)
+#endif
+
+#ifndef UNLIKELY
+#define UNLIKELY(x) (x)
+#endif
+
+#ifndef VERY_LIKELY
+#define VERY_LIKELY(x) (x)
+#endif
+
+#ifndef VERY_UNLIKELY
+#define VERY_UNLIKELY(x) (x)
+#endif
+
+#endif /* HAVE___BUILTIN_EXPECT */
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/db.h

@@ -0,0 +1,19 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_DB_H
+#define ZSV_DB_H
+
+#include <sqlite3.h>
+#include <jsonwriter.h>
+
+// zsv_dbtable2json: convert a db table to json
+// @limit: if nonzero, limit number of rows processed
+int zsv_dbtable2json(sqlite3 *db, const char *tname, jsonwriter_handle jsw, size_t limit);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/dirs.h

@@ -0,0 +1,147 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_DIRS_H
+#define ZSV_DIRS_H
+
+#include <stdio.h>
+
+/* Maximum length of file name */
+#if !defined(FILENAME_MAX)
+#define FILENAME_MAX MAX_PATH
+#endif
+
+/* file slash */
+#if !defined(FILESLASH)
+#ifdef _WIN32
+#define FILESLASH '\\'
+#else
+#define FILESLASH '/'
+#endif
+#endif
+
+/**
+ * Get os-independent configuration file path
+ * prefix should be determined at compile time e.g. /usr/local or ""
+ * @return length written to buff, or 0 if failed
+ */
+size_t zsv_get_config_dir(char *buff, size_t buffsize, const char *prefix);
+
+/**
+ * Get the path of the current executable
+ */
+size_t zsv_get_executable_path(char *buff, size_t buffsize);
+
+/**
+ * Get current user's home dir, without trailing slash
+ * On win, any backslashes are replaced with fwd slash
+ *   ex: zsv_get_home_dir(char[MAX_PATH], MAX_PATH)
+ * returns 0 if no home dir could be found
+ * returns > 0 and < bufflen on success
+ * returns > 0 and >= bufflen if buffer was too small
+ */
+int zsv_get_home_dir(char *buff, size_t bufflen);
+
+/**
+ * Check if a directory exists
+ * return true (non-zero) or false (zero)
+ */
+int zsv_dir_exists(const char *path);
+
+/**
+ * mkdir that works with UNC paths on Win
+ * if fail, use zsv_perror() instead of perror()
+ */
+int zsv_mkdir(const char *path);
+
+/**
+ * Make a directory, as well as any intermediate dirs
+ * return zero on success
+ */
+int zsv_mkdirs(const char *path, char path_is_filename);
+
+/**
+ * Recursively remove a directory and all of its contents
+ * return zero on success
+ */
+int zsv_remove_dir_recursive(const unsigned char *path);
+
+#include <sys/stat.h>
+
+struct zsv_foreach_dirent_handle {
+  const char *parent;           /* name of the parent directory */
+  const char *entry;            /* file / dir name of current entry being processed */
+  const char *parent_and_entry; /* parent + entry separated by file separator */
+  const struct stat stat;       /* stat of current entry */
+
+  void *ctx; /* caller-provided context to pass to handler */
+
+  unsigned char verbose : 1;
+  unsigned char is_dir : 1;     /* non-zero if this entry is a directory */
+  unsigned char no_recurse : 1; /* set to 1 when handling a dir to prevent recursing into it */
+  unsigned char _ : 5;
+};
+
+typedef int (*zsv_foreach_dirent_handler)(struct zsv_foreach_dirent_handle *h, size_t depth);
+
+/**
+ * Recursively process entries (files and folders) in a directory
+ *
+ * @param dir_path    : path of directory to begin processing children of
+ * @param max_depth   : maximum depth to recurse, or 0 for no maximum
+ * @param handler     : caller-provided entry handler. return 0 on success, non-zero on error
+ * @param ctx         : pointer passed to the handler
+ * @param verbose     : non-zero for verbose output
+ *
+ * returns error
+ */
+int zsv_foreach_dirent(const char *dir_path, size_t max_depth, zsv_foreach_dirent_handler handler, void *ctx,
+                       char verbose);
+
+struct zsv_dir_filter {
+  zsv_foreach_dirent_handler
+    filter;         /* filter function; return 1 to process this node. if node is dir, return 0 to skip entirely */
+  size_t max_depth; /* max depth to recurse */
+  void *ctx;        /* pointer to pass to filter function */
+};
+
+/**
+ * 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 output_filename : file path to output to, or NULL to output to stdout
+ * @param file_filter     : filter determining which files to export
+ */
+int zsv_dir_to_json(const unsigned char *parent_dir, const unsigned char *output_filename,
+                    struct zsv_dir_filter *file_filter, unsigned char verbose);
+
+/**
+ * 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)
+ *
+ * @param target_dir : directory to create / import into
+ * @param        : file path to output to, or NULL to output to stdout
+ * @flags        : ZSV_DIR_FLAG_xxx values as defined below
+ *
+ * Returns 0 on success, non-zero on error
+ */
+
+#define ZSV_DIR_FLAG_FORCE 1 /* overwrite target files if they already exist */
+#define ZSV_DIR_FLAG_DRY 2   /* dry run, output names of files that would be created/overwritten */
+
+int zsv_dir_from_json(const unsigned char *target_dir, FILE *fsrc,
+                      unsigned int flags, // ZSV_DIR_FLAG_XX
+                      unsigned char verbose);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/dl.h

@@ -0,0 +1,22 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_DL_H
+#define ZSV_DL_H
+
+#ifdef _WIN32
+#include <zsv/utils/win/dl.h>
+#define DL_SUFFIX "dll"
+#else
+#include <dlfcn.h>
+#define DL_SUFFIX "so"
+#endif
+
+void (*zsv_dlsym(void *restrict handle, const char *restrict name))(void);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/emcc/fs_api.h

@@ -0,0 +1,28 @@
+#ifndef LQ_FS_API_H
+#define LQ_FS_API_H
+
+typedef struct fs_data *fshandle;
+
+fshandle fsopen(const char *fn, const char *mode);
+
+int fsclose(fshandle h);
+
+size_t fswrite(const void *ptr, size_t n, size_t m, fshandle h);
+
+void stdflush(int addNewline);
+
+size_t bytesum(const char *fn);
+
+size_t fsread(void *ptr, size_t n, size_t m, fshandle h);
+
+int fsrm(const char *fn);
+
+int fsmkdir(const char *path);
+
+int fsprint(const char *s);
+
+int fsprinterr(const char *s);
+
+char *fsls(const char *dir);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/err.h

@@ -0,0 +1,22 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_ERR_H
+#define ZSV_ERR_H
+
+int zsv_app_printerr(const char *appname, int eno, const char *fmt, ...);
+
+#ifdef APPNAME
+#define zsv_printerr(...) zsv_app_printerr(APPNAME, __VA_ARGS__)
+#else
+#pragma message("zsv_printerr defined without APPNAME")
+#pragma message("to avoid this, include err.h after defining APPNAME to quoted string")
+#define zsv_printerr(...) zsv_app_printerr(0x0, __VA_ARGS__)
+#endif
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/file-mem.h

@@ -0,0 +1,17 @@
+#ifndef ZSV_MEMFILE_H_H
+#define ZSV_MEMFILE_H_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+typedef struct zsv_memfile zsv_memfile;
+
+// Public API Functions
+zsv_memfile *zsv_memfile_open(size_t buffsz);
+size_t zsv_memfile_write(const void *data, size_t sz, size_t n, zsv_memfile *zfm);
+int zsv_memfile_rewind(zsv_memfile *zfm);
+size_t zsv_memfile_read(void *buffer, size_t size, size_t nitems, zsv_memfile *zfm);
+void zsv_memfile_close(zsv_memfile *zfm);
+
+#endif // ZSV_FILEMEM_H_H

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/file.h

@@ -0,0 +1,99 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_FILE_H
+#define ZSV_FILE_H
+
+#include <stdio.h>
+#include "file-mem.h"
+
+#ifndef LINEEND
+#if defined(WIN32) || defined(_WIN64) || defined(_WIN32)
+#define LINEEND "\r\n"
+#else
+#define LINEEND "\n"
+#endif
+#endif // LINEEND
+/**
+ * Get a temp file name. The returned value, if any, will have been allocated
+ * on the heap, and the caller should `free()`
+ *
+ * @param prefix string with which the resulting file name will be prefixed
+ */
+char *zsv_get_temp_filename(const char *prefix);
+
+/**
+ *  Replacement for tmpfile().
+ *  Returns filename; file must be manually removed after fclose
+ *
+ *  @param mode optional mode passed to fopen(); if NULL, defaults to "wb"
+ */
+FILE *zsv_tmpfile(const char *prefix, char **filename, const char *mode);
+
+/**
+ * Check if a file exists and is readable (with fopen + "rb")
+ *
+ * @param filename
+ * @returns: true  (1) if file exists
+ */
+int zsv_file_exists(const char *filename);
+
+/**
+ * Check if a file exists and is readable (with fopen + "rb")
+ *
+ * @param filename
+ * @param err      if file is not readbale, *err is set to a code as defined in errno.h
+ * @param f_out:   if provided, on success, set to the opened file ptr
+ * @returns: true  (1) if file exists and is readable
+ */
+int zsv_file_readable(const char *filename, int *err, FILE **f_out);
+
+/**
+ * Function that is the same as `fwrite()`, but can be used as a callback
+ * argument to `zsv_set_scan_filter()`
+ *
+ * @param FILEp      pointer to a FILE object, cast as a void *, to write to
+ * @param buff       pointer to the buffer of data to write
+ * @param bytes_read number of bytes in the buffer to write
+ */
+size_t zsv_filter_write(void *FILEp, unsigned char *buff, size_t bytes_read);
+
+/**
+ * Get a file path's directory length and base name
+ * Returns the length of the directory portion of the path
+ * and the base name portion of the path
+ */
+size_t zsv_dir_len_basename(const char *filepath, const char **basename);
+
+/**
+ * Copy a file. Create any needed directories
+ * On error, prints error message and returns non-zero
+ */
+int zsv_copy_file(const char *src, const char *dest);
+
+/**
+ * Copy a file, given source and destination FILE pointers
+ * Return error number per errno.h
+ */
+int zsv_copy_file_ptr(FILE *src, FILE *dest);
+
+/**
+ * Copy a file-like, given source and destination handles
+ * and read/write functions
+ * Return error number per errno.h
+ */
+int zsv_copy_filelike_ptr(
+  FILE *src, size_t (*freadx)(void *restrict ptr, size_t size, size_t nitems, void *restrict stream), FILE *dest,
+  size_t (*fwritex)(const void *restrict ptr, size_t size, size_t nitems, void *restrict stream));
+/**
+ * printf that does nothing. useful in certain circumstances for ignoring
+ * errors e.g. opening the same file twice and not dupicating error logs
+ */
+int zsv_no_printf(void *, const char *format, ...);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/jq.h

@@ -0,0 +1,65 @@
+#ifndef LQJQ_INTERNAL_H
+#define LQJQ_INTERNAL_H
+
+#include <ctype.h>
+#include <jq.h>
+
+enum zsv_jq_status {
+  zsv_jq_status_ok = 0,
+  zsv_jq_status_compile,
+  zsv_jq_status_memory,
+  zsv_jq_status_error
+};
+
+size_t zsv_jq_fwrite1(void *restrict FILE_ptr, const void *restrict buff, size_t len);
+
+struct jv_to_json_ctx {
+  size_t (*write1)(void *restrict ctx, const void *restrict buff, size_t len); // e.g. zsv_jq_fwrite1
+  void *ctx;                                                                   // e.g. FILE *
+  int flags;                                                                   // passed on to jv_dumpf / jv_dump_string
+  char raw_output;
+  char output_started;
+};
+
+void jv_to_json_w_ctx(jv value, void *jv_to_json_ctx);
+
+typedef struct zsv_jq_data *zsv_jq_handle;
+
+zsv_jq_handle zsv_jq_new(const unsigned char *filter, void (*func)(jv, void *), void *ctx, enum zsv_jq_status *statusp);
+
+// for streaming parsing
+zsv_jq_handle zsv_jq_new_stream(const unsigned char *filter, void (*func)(jv, void *), void *ctx,
+                                enum zsv_jq_status *statusp);
+
+enum zsv_jq_status zsv_jq_parse_file(zsv_jq_handle h, FILE *f);
+
+enum zsv_jq_status zsv_jq_parse(zsv_jq_handle restrict h, const void *restrict s, size_t len);
+
+size_t zsv_jq_write(const char *s, size_t n, size_t m, zsv_jq_handle h);
+
+enum zsv_jq_status zsv_jq_finish(zsv_jq_handle h);
+
+void zsv_jq_trace(zsv_jq_handle h, FILE *);
+
+void zsv_jq_delete(zsv_jq_handle h);
+
+// helper functions
+void jv_to_lqjq(jv value, void *zsv_jq_handle);
+
+void jv_to_csv(jv value, void *file);
+
+void jv_to_bool(jv value, void *char_result);
+
+void jv_to_txt(jv value, void *file);
+
+struct jv_to_csv_multi_ctx {
+  FILE *(*get_file)(void *ctx);
+  void *ctx;
+};
+
+// jv_to_csv_multi: write csv rows to different files
+void jv_to_csv_multi(jv value, void *jv_to_csv_multi_ctx);
+
+void jv_to_json_func(jv value, void *jv_to_json_func_dat);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/json.h

@@ -0,0 +1,19 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_JSON_H
+#define ZSV_JSON_H
+
+/**
+ * Convert a string to json (including the surrounding quotes)
+ * Returns newly-allocated string (caller must free())
+ */
+unsigned char *zsv_json_from_str(const unsigned char *s);
+unsigned char *zsv_json_from_str_n(const unsigned char *s, size_t len);
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/mem.h

@@ -0,0 +1,19 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_MEM_H
+#define ZSV_MEM_H
+
+/* zsv_memdup(): return copy with double-NULL terminator. caller must free() */
+void *zsv_memdup(const void *src, size_t n);
+
+#ifndef MEMDUP
+#define MEMDUP zsv_memdup
+#endif
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/memmem.h

@@ -0,0 +1,13 @@
+#ifndef ZSV_MEMMEM_H
+#define ZSV_MEMMEM_H
+
+#ifdef NO_MEMMEM
+
+#include <stdint.h>
+void *zsvmemmem(const void *h0, size_t k, const void *n0, size_t l);
+
+#define memmem zsvmemmem
+
+#endif
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/utils/os.h

@@ -0,0 +1,54 @@
+/*
+ * 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
+ */
+
+#ifndef ZSV_OS_H
+#define ZSV_OS_H
+
+void zsv_perror(const char *);
+
+/**
+ * zsv_fopen(): same as normal fopen(), except on Win it also works with long filenames
+ */
+#ifndef _WIN32
+#define zsv_fopen fopen
+#else
+#include <stdio.h>
+FILE *zsv_fopen(const char *fname, const char *mode);
+char *zsv_ensureLongPathPrefix(const char *original_path, unsigned char always_prefix);
+#endif
+
+/**
+ * zsv_remove(): same as normal remove()
+ but for files only, and on Win it also works with long filenames
+ */
+#ifndef _WIN32
+#define zsv_remove remove
+#else
+#include <stdio.h>
+int zsv_remove_winlp(const char *path_utf8);
+#define zsv_remove zsv_remove_winlp
+#endif
+
+int zsv_replace_file(const char *src, const char *dest);
+
+#ifdef _WIN32
+#include <windows.h>
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
+#endif
+
+void zsv_win_to_unicode(const void *path, wchar_t *wbuf, size_t wbuf_len);
+
+#endif // #ifdef _WIN32
+
+/**
+ * get number of cores
+ */
+unsigned int zsv_get_number_of_cores();
+#endif // ZSV_OS_H