zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/ext/implementation.h

@@ -0,0 +1,62 @@
+/*
+ * 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_EXT_PRIVATE_H
+#define ZSV_EXT_PRIVATE_H
+
+#include <zsv/ext.h>
+
+/**
+ * @file zsv_ext.h
+ * @brief ZSV extension implementation specification
+ * @defgroup zsv_extension implementation specification
+ * @ingroup ZSV
+ * @{
+ */
+
+/**
+ * Overridable compiler flag ZSV_EXT=1 indicates that we are compiling a ZSV
+ * extension
+ */
+#ifndef ZSV_EXT
+#define ZSV_EXT 1
+#endif
+
+ZSV_BEGIN_DECL
+
+/**
+ * To build a zsv extension:
+ * - implement the following required functions:
+ *   `zsv_ext_id`
+ *   `zsv_ext_init`
+ *   `zsv_ext_main`
+ *
+ * - optionally, implement the following recommended functions:
+ *  `zsv_ext_help`
+ *  `zsv_ext_errstr`
+ *  `zsv_ext_version`
+ *  `zsv_ext_license`
+ *
+ * - on Windows, be sure to decorate your function definitions
+ *   with ZSV_EXT_EXPORT
+ */
+
+#ifdef _WIN32
+#define ZSV_EXT_EXPORT __declspec(dllexport)
+#elif __EMSCRIPTEN__
+#include <emscripten.h>
+#define ZSV_EXT_EXPORT EMSCRIPTEN_KEEPALIVE
+#else
+#define ZSV_EXT_EXPORT
+#endif
+
+#include "implementation_private.h"
+
+/** @} */
+ZSV_END_DECL
+#endif

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/ext/implementation_private.h

@@ -0,0 +1,113 @@
+/*
+ * 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
+ */
+
+/**
+ * @file zsv_ext_private.h
+ * @brief ZSV extension implementation specification
+ * @defgroup zsv_extension implementation specification
+ * @ingroup ZSV
+ * @{
+ */
+
+/**
+ * Return a module identifier, which must be a 2-char string
+ *
+ * Required. Any sub-command that starts with this id followed by a dash
+ * will be passed on to this module
+ *
+ * Your DLL or shared lib filename must correspondingly be "zsvext<id>"
+ *
+ * For example, to implement sub-commands that begin with "my-":
+ *   - your function zsv_ext_id() would return "my"
+ *   - your library would be named zsvextmy.dll (or .so or .dylib)
+ */
+ZSV_EXT_EXPORT
+const char *zsv_ext_id(void);
+
+/**
+ * Initialize your module
+ *
+ * Called once, when your library is loaded
+ *
+ * @param callbacks Pointer to struct holding zsvlib function pointers
+ * @return Zero on success, non-zero on fail
+ */
+ZSV_EXT_EXPORT
+enum zsv_ext_status zsv_ext_init(struct zsv_ext_callbacks *callbacks, zsv_execution_context ctx);
+
+/**
+ * Get your extension's internal error code
+ *
+ * In the case that any of your module functions return zsv_ext_status_error
+ * this function is called to obtain your extension's internal error code
+ *
+ * @param context Execution context
+ * @return Error code
+ */
+ZSV_EXT_EXPORT
+int zsv_ext_errcode(zsv_execution_context context);
+
+/**
+ * Get an error message
+ *
+ * In the case that any of your module functions return zsv_ext_status_error,
+ * this function is called to obtain the message corresponding to the internal
+ * error code returned by zsv_ext_errcode()
+ *
+ * @param context Execution context
+ * @param int Return code from zsv_ext_errcode()
+ * @return Error message to display
+ */
+ZSV_EXT_EXPORT
+char *zsv_ext_errstr(zsv_execution_context context, int err);
+
+/**
+ * Free an error message
+ *
+ * Called after obtaining any non-NULL result from `zsv_ext_errstr()`
+ *
+ * @param errstr The string returned from zsv_ext_errstr()
+ */
+ZSV_EXT_EXPORT
+void zsv_ext_errfree(char *errstr);
+
+/**
+ * Exit your module
+ *
+ * Called once, when your library is unloaded
+ *
+ * @return Zero on success, non-zero on fail
+ */
+ZSV_EXT_EXPORT
+enum zsv_ext_status zsv_ext_exit(void);
+
+/**
+ * Help message. Displayed when user enters any command beginning with
+ *   `zsv help <module-id>`
+ *
+ * @param argc Number of arguments
+ * @param argv Arguments
+ */
+ZSV_EXT_EXPORT
+const char *const *zsv_ext_help(int argc, const char *argv[]);
+
+/**
+ * License message. Displayed when user enters any command beginning with
+ *   `zsv license <module-id>`
+ *
+ */
+ZSV_EXT_EXPORT
+const char *const *zsv_ext_license(void);
+
+/**
+ * Version message. Displayed when user enters any command beginning with
+ *   `zsv version <module-id>`
+ *
+ */
+ZSV_EXT_EXPORT
+const char *const *zsv_ext_version(void);

data/ext/zsv/vendor/zsv-1.3.0/include/zsv/ext/sheet.h

@@ -0,0 +1,73 @@
+#ifndef ZSVSHEET_H
+#define ZSVSHEET_H
+
+/* custom sheet handler id */
+typedef int zsvsheet_proc_id_t;
+
+typedef struct zsvsheet_proc_context *zsvsheet_proc_context_t;
+
+typedef enum zsvsheet_status {
+  zsvsheet_status_ok = 0,
+  zsvsheet_status_error,
+  zsvsheet_status_ignore,
+  zsvsheet_status_duplicate,
+  zsvsheet_status_memory,
+  zsvsheet_status_exit,
+  zsvsheet_status_busy,
+  zsvsheet_status_no_data
+} zsvsheet_status;
+
+typedef struct zsvsheet_context *zsvsheet_context_t;
+typedef struct zsvsheet_subcommand_context *zsvsheet_subcommand_context_t;
+
+typedef void *zsvsheet_buffer_t;
+// int zsvsheet_ext_keypress(zsvsheet_proc_context_t);
+
+typedef struct zsvsheet_transformation *zsvsheet_transformation;
+/**
+ * Transformation options passed to zsvsheet_push_transformation
+ */
+struct zsvsheet_buffer_transformation_opts {
+  /**
+   * Caller supplied context; can be retrieved with ext_sheet_transformation_user_context(trn).
+   *
+   * This is free'd by the library after on_done is called unless it is NULL.
+   */
+  void *user_context;
+  /**
+   * This is called each time a row is parsed and available.
+   *
+   * It can be used to write out a new row immediately or contribute to a calculation
+   * where the partial results are stored in the context.
+   *
+   * Note that when doing a reduction which does not produce output until the end;
+   * it is best to write out a header row in the row_handler and flush the writer. Otherwise the
+   * main thread will be blocked waiting for something to display.
+   *
+   * Once some data has been written to the output file execution is moved to a background thread.
+   *
+   * The parser can be retrieved with ext_sheet_transformation_parser(trn),
+   * the output file writer can be retrieved with ext_sheet_transformation_writer(trn),
+   * the context can be retrieved with ext_sheet_transformation_user_context(trn),
+   * and so on
+   */
+  void (*row_handler)(zsvsheet_transformation trn);
+  /**
+   * Called when the parser has no more data or was cancelled.
+   *
+   * This can be used to free resources, complete a calculation or to write out one
+   * or more final rows.
+   *
+   * For small input files this may be executed in the main thread, for larger ones
+   * it will be done in a background thread. So if an operation done inside this handler
+   * can take a long time even on small inputs then it could block the main thread.
+   */
+  void (*on_done)(zsvsheet_transformation trn);
+};
+
+struct zsvsheet_rowcol {
+  size_t row;
+  size_t col;
+};
+
+#endif

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

@@ -0,0 +1,329 @@
+/*
+ * 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_EXT_H
+#define ZSV_EXT_H
+
+#define ZSV_EXTENSION_ID_MIN_LEN 2
+#define ZSV_EXTENSION_ID_MAX_LEN 8
+
+#include <stdio.h>
+#include <stdint.h>
+#include "common.h"
+#include "ext/sheet.h"
+#include "utils/sql.h"
+#include "utils/prop.h"
+#include "utils/writer.h"
+
+/**
+ * @file ext.h
+ * @brief ZSV extension api, common to zsvlib and any zsv extension
+ * @defgroup zsv_extension api
+ * @ingroup ZSV
+ * @{
+ */
+ZSV_BEGIN_DECL
+
+/**
+ * Status and error codes for zsv extensions. If a command's `main()` program
+ * returns a status other than zsv_ext_status_ok, `zsv_ext_errcode()` will be
+ * called and its result used for the final exit code. If it returns
+ * zsv_ext_status_error, then furthermore, `zsv_ext_errstr()` will be called
+ * and any non-null result displayed as an error message
+ */
+enum zsv_ext_status {
+  zsv_ext_status_ok = 0,
+  zsv_ext_status_memory,
+  zsv_ext_status_unrecognized_cmd,
+
+  /**
+   * if a zsv_ext function returns zsv_ext_status_error, an error message
+   * is generated by calling the module's `zsv_ext_errcode()` and `zsv_ext_errstr()`
+   * functions. Otherwise an error string is generated from the zsv_ext_status code
+   */
+  zsv_ext_status_error,
+
+  /**
+   * operation not permitted, such as an extension attempting
+   * to modify a buffer that is owned by a different extension
+   */
+  zsv_ext_status_not_permitted,
+
+  /**
+   * zsv_ext_status_other is treated as a silent error by ZSV, e.g. if you have
+   * already handled your error and do not want any further error message displayed
+   */
+  zsv_ext_status_other
+};
+
+/**
+ * The context in which any call to your extension is made, used with:
+ *   `set_ext_context()`
+ *   `get_ext_context()`
+ */
+typedef void *zsv_execution_context;
+
+/**
+ * Signature of the function called for each implemented sub-command
+ */
+typedef enum zsv_ext_status (*zsv_ext_main)(zsv_execution_context ctx, int argc, const char *argv[],
+                                            struct zsv_opts *opts);
+
+/**
+ * ZSV callbacks structure
+ *
+ * Contains the addresses of the ZSV functions that can be used by custom
+ * extensions, and which are passed from ZSV to the extension via the
+ * custom `zsv_ext_init()` implementation. See zsv_ext.h for additional
+ * extension specifications, or examples/extension.c for an example
+ * implementation
+ *
+ * For a description of each callback, see the corresponding zsv_-prefixed
+ * function in zsv.h
+ */
+struct zsvsheet_buffer_data {
+  unsigned char has_row_num : 1;
+  unsigned char _ : 7;
+};
+
+typedef uint32_t zsvsheet_cell_attr_t;
+enum zsvsheet_cell_profile_t {
+  zsvsheet_cell_attr_profile_none = 0,
+  zsvsheet_cell_attr_profile_link,
+};
+
+struct zsv_ext_callbacks {
+  void (*set_row_handler)(zsv_parser handle, void (*row)(void *ctx));
+  void (*set_context)(zsv_parser handle, void *ctx);
+  enum zsv_status (*parse_more)(struct zsv_scanner *scanner);
+  void (*abort)(struct zsv_scanner *scanner);
+  size_t (*cell_count)(zsv_parser parser);
+  struct zsv_cell (*get_cell)(zsv_parser parser, size_t ix);
+  enum zsv_status (*finish)(zsv_parser);
+  enum zsv_status (*delete)(zsv_parser);
+
+  /**
+   * Set or get custom context (e.g. to persist private data between
+   * ZSV-initiated calls to your extension)
+   */
+  void (*ext_set_context)(zsv_execution_context ctx, void *private_context);
+  void *(*ext_get_context)(zsv_execution_context ctx);
+
+  zsv_parser (*ext_get_parser)(zsv_execution_context ctx);
+
+  /**
+   * To add an extension command, invoke `ext_add_command`, passing it your command's
+   * handler function as a callback with a `zsv_ext_main` signature
+   */
+  enum zsv_ext_status (*ext_add_command)(zsv_execution_context ctx, const char *id, const char *help,
+                                         zsv_ext_main main);
+  void (*ext_set_help)(zsv_execution_context ctx, const char *help);
+  void (*ext_set_license)(zsv_execution_context ctx, const char *license);
+  void (*ext_set_thirdparty)(zsv_execution_context ctx, const char *thirdparty[]);
+
+  /**
+   * fetch options from execution context. used to fetch just the ctx-related parser
+   * opts, including any of the below if specified by the user when zsv was invoked:
+   *     -B,--buff-size <N>
+   *     -c,--max-column-count <N>
+   *     -r,--max-row-size <N>
+   *     -t,--tab-delim
+   *     -O,--other-delim <C>
+   *     -q,--no-quote
+   *     -v,--verbose
+   *
+   * @param ctx execution context
+   * @return option values
+   */
+  struct zsv_opts (*ext_parser_opts)(zsv_execution_context ctx);
+
+  /**
+   * convenience function that calls ext_args_to_opts, allocates parser,
+   * sets custom ctx, runs parser, and de-allocates parser
+   */
+  enum zsv_ext_status (*ext_parse_all)(zsv_execution_context ctx, void *user_context, void (*row_handler)(void *ctx),
+                                       struct zsv_opts *const custom);
+  /**
+   * As an alternative to `ext_parse_all()`, for more granular control:
+   * ```
+   * struct zsv_opts opts = custom ? *custom : zsv_get_default_opts();
+   * zsv_parser parser = zsv_new(&opts);
+   * if(!parser)
+   *   stat = zsv_ext_status_memory;
+   * else {
+   *   opts.row = YOUR_COMMAND_rowhandler;
+   *   // ... set other options ...
+   *   zsv_parser p = new_with_context(ctx, &opts);
+   *   while((stat = zsv_parse_more(parser)) == zsv_status_ok) ;
+   *   if(stat == zsv_status_no_more_input)
+   *     stat = zsv_finish(p);
+   *   zsv_delete(p);
+   * }
+   * ```
+   */
+
+  /****************************************
+   * Registering a custom `sheet` command *
+   ****************************************/
+  zsvsheet_proc_id_t (*ext_sheet_register_proc)(const char *name, const char *description,
+                                                zsvsheet_status (*handler)(zsvsheet_proc_context_t ctx));
+
+  /**
+   * Bind a command to a key binding
+   * TO DO: allow binding of key that already exists; in which case
+   * allow handler to act as middleware that can cancel or allow other handlers to be executed
+   *
+   * @return 0 on success, else error
+   */
+  int (*ext_sheet_register_proc_key_binding)(char ch, zsvsheet_proc_id_t proc_id);
+
+  /*** Custom command prompt ***/
+  /**
+   * Set the prompt for entering a subcommand
+   * @param  s text to set the subcommand prompt to. must be < 256 bytes in length
+   * returns zsvsheet_status_ok on success
+   */
+  zsvsheet_status (*ext_sheet_prompt)(zsvsheet_proc_context_t ctx, char *buffer, size_t bufsz, const char *fmt, ...);
+
+  /*** Custom command handling ***/
+  /**
+   * Set a status message
+   */
+  zsvsheet_status (*ext_sheet_set_status)(zsvsheet_proc_context_t ctx, const char *fmt, ...);
+
+  /**
+   * Get the key press that triggered this subcommand handler
+   */
+  int (*ext_sheet_keypress)(zsvsheet_proc_context_t ctx);
+
+  /****** Managing buffers ******/
+  /**
+   * Get the current buffer
+   */
+  zsvsheet_buffer_t (*ext_sheet_buffer_current)(zsvsheet_proc_context_t ctx);
+
+  /**
+   * Get the prior buffer
+   */
+  zsvsheet_buffer_t (*ext_sheet_buffer_prior)(zsvsheet_buffer_t b);
+
+  /**
+   * Get info about a buffer
+   */
+  struct zsvsheet_buffer_data (*ext_sheet_buffer_info)(zsvsheet_buffer_t);
+
+  /**
+   * Get the filename associated with a buffer
+   */
+  const char *(*ext_sheet_buffer_filename)(zsvsheet_buffer_t);
+
+  /**
+   * Get the data file associated with a buffer. This might not be the same as the filename,
+   * such as when the data has been filtered
+   */
+  const char *(*ext_sheet_buffer_data_filename)(zsvsheet_buffer_t);
+
+  /**
+   * Get the currently-selected cell
+   */
+  zsvsheet_status (*ext_sheet_buffer_get_selected_cell)(zsvsheet_buffer_t, struct zsvsheet_rowcol *);
+
+  /**
+   * Open a tabular file as a new buffer
+   */
+  zsvsheet_status (*ext_sheet_open_file)(zsvsheet_proc_context_t, const char *filepath, struct zsv_opts *zopts);
+
+  /**
+   * Set custom context
+   * @param on_close optional callback to invoke when the buffer is closed
+   *
+   * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+   */
+  enum zsv_ext_status (*ext_sheet_buffer_set_ctx)(zsvsheet_buffer_t h, void *ctx, void (*on_close)(void *));
+
+  /**
+   * Get custom context previously set via zsvsheet_buffer_set_ctx()
+   * @param ctx_out result will be written to this address
+   *
+   * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+   */
+  enum zsv_ext_status (*ext_sheet_buffer_get_ctx)(zsvsheet_buffer_t h, void **ctx_out);
+
+  /**
+   *
+   */
+  zsvsheet_cell_attr_t (*ext_sheet_cell_profile_attrs)(enum zsvsheet_cell_profile_t);
+
+  /**
+   * Set custom cell attributes
+   */
+  void (*ext_sheet_buffer_set_cell_attrs)(zsvsheet_buffer_t h,
+                                          enum zsv_ext_status (*get_cell_attrs)(void *pdh, zsvsheet_cell_attr_t *attrs,
+                                                                                size_t start_row, size_t row_count,
+                                                                                size_t cols));
+
+  /**
+   * Set custom handler on Enter key press
+   *
+   * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+   */
+  enum zsv_ext_status (*ext_sheet_buffer_on_newline)(zsvsheet_buffer_t h,
+                                                     zsvsheet_status (*on_newline)(zsvsheet_proc_context_t));
+
+  /**
+   * Get zsv_opts used to open the buffer's data file
+   */
+  struct zsv_opts (*ext_sheet_buffer_get_zsv_opts)(zsvsheet_buffer_t h);
+
+  /**
+   * SQLITE3 helpers
+   */
+  int (*ext_sqlite3_add_csv)(struct zsv_sqlite3_db *zdb, const char *csv_filename, struct zsv_opts *opts,
+                             struct zsv_prop_handler *custom_prop_handler);
+  void (*ext_sqlite3_db_delete)(zsv_sqlite3_db_t);
+  zsv_sqlite3_db_t (*ext_sqlite3_db_new)(struct zsv_sqlite3_dbopts *dbopts);
+
+  /**
+   * Create a new buffer from the current one using a transformation
+   * and make the new buffer the current one
+   *
+   * Note that the transformation is performed in a seperate thread so the user_context
+   * must not be a stack variable
+   *
+   * See struct zsvsheet_buffer_transformation_opts in zsv/ext/sheet.h
+   */
+  zsvsheet_status (*ext_sheet_push_transformation)(zsvsheet_proc_context_t ctx,
+                                                   struct zsvsheet_buffer_transformation_opts opts);
+
+  /**
+   * Get the writer associated with a transformation.
+   *
+   * The transformation itself is passed as the context variable to the row handler
+   */
+  zsv_csv_writer (*ext_sheet_transformation_writer)(zsvsheet_transformation trn);
+
+  /**
+   * Get the user provided context from the context provided to a transformation row handler
+   */
+  void *(*ext_sheet_transformation_user_context)(zsvsheet_transformation trn);
+
+  /**
+   * Get the parser from the context provided to a transformation row handler
+   */
+  zsv_parser (*ext_sheet_transformation_parser)(zsvsheet_transformation trn);
+
+  /**
+   * Get the filename that the transformation writer outputs to from the context provided to a transformation row
+   * handler.
+   */
+  const char *(*ext_sheet_transformation_filename)(zsvsheet_transformation trn);
+};
+
+/** @} */
+ZSV_END_DECL
+#endif

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

@@ -0,0 +1,90 @@
+/*
+ * 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_ARG_H
+#define ZSV_ARG_H
+
+#include <zsv/common.h>
+
+/* 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);
+
+/**
+ * set or get default parser options
+ */
+void zsv_set_default_opts(struct zsv_opts);
+
+struct zsv_opts zsv_get_default_opts(void);
+
+void zsv_clear_default_opts(void);
+
+#ifdef ZSV_EXTRAS
+
+/**
+ * set the default option progress callback (e.g. from wasm where `struct zsv_opts`
+ * cannot be independently accessed)
+ * @param cb callback to call
+ * @param ctx pointer passed to callback
+ * @param frequency number of rows to parse between progress calls
+ */
+void zsv_set_default_progress_callback(zsv_progress_callback cb, void *ctx, size_t rows_interval,
+                                       unsigned int seconds_interval);
+
+/**
+ * set the default option completed callback (e.g. from wasm where `struct zsv_opts`
+ * cannot be independently accessed)
+ * @param cb callback to call
+ * @param ctx pointer passed to callback
+ */
+void zsv_set_default_completed_callback(zsv_completed_callback cb, void *ctx);
+
+#endif
+
+/**
+ * Convert common command-line arguments to zsv_opts
+ * Return new argc/argv values with processed args stripped out
+ * Initializes opts_out with `zsv_get_default_opts()`, then with
+ * the below common options if present:
+ *     -B,--buff-size <N>
+ *     -c,--max-column-count <N>
+ *     -r,--max-row-size <N>
+ *     -t,--tab-delim
+ *     -O,--other-delim <C>
+ *     -q,--no-quote
+ *     -S,--keep-blank-headers: disable default behavior of ignoring leading blank rows
+ *     -d,--header-row-span <n>: apply header depth (rowspan) of n
+ *     -v,--verbose
+ *
+ * @param  argc      count of args to process
+ * @param  argv      args to process
+ * @param  argc_out  count of unprocessed args
+ * @param  argv_out  array of unprocessed arg values. Must be allocated by caller
+ *                   with size of at least argc * sizeof(*argv)
+ * @param  opts_out  options, updated to reflect any processed args
+ * @return           zero on success, non-zero on error
+ */
+enum zsv_status zsv_args_to_opts(int argc, const char *argv[], int *argc_out, const char **argv_out,
+                                 struct zsv_opts *opts_out);
+
+/**
+ * Fetch the next arg, if it exists, else print an error message
+ * The argc_i argument does not need to be valid; it will be checked
+ * against argc.
+ *
+ * Example:
+ *   const char *value = zsv_next_arg(++arg_i, argc, argv, &err);
+ *
+ * @param  argc_i index of next arg to test
+ * @param  argc   total arg count
+ * @param  argv   args to process
+ * @param  err    return non-zero in the case of error
+ * @return        next argument, if it exists, else NULL
+ */
+const char *zsv_next_arg(int arg_i, int argc, const char *argv[], int *err);
+
+#endif