zsv 1.3.0

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

@@ -0,0 +1,71 @@
+#ifndef ZSV_OVERWRITE_H
+#define ZSV_OVERWRITE_H
+
+#include <sqlite3.h>
+
+struct zsv_overwrite_ctx {
+  char *src;
+  size_t author_ix;
+  size_t timestamp_ix;
+  size_t old_value_ix;
+  // enum zsv_overwrite_type type;
+  enum zsv_status (*next)(void *ctx, struct zsv_overwrite_data *odata);
+  struct {
+    FILE *f;
+    zsv_parser parser;
+  } csv;
+  struct {
+    char *filename;
+    sqlite3 *db;
+    sqlite3_stmt *stmt; // select row, column, overwrite
+    const char *sql;
+  } sqlite3;
+  size_t row_ix;
+};
+
+/**
+ * The easiest way to enable overwrite support is to use zsv_overwrite_auto()
+ * which, given an input located at /path/to/my-data.csv, will assume an overwrite source
+ * located at /path/to/.zsv/data/my-data.csv/overwrite.sqlite3
+ * in a table named 'overwrites'
+ *
+ * zsv_overwrite_auto() returns:
+ * - zsv_status_done if a valid overwrite file was found
+ * - zsv_status_no_more_input if no overwrite file was found
+ * - a different status code on error
+ *
+ * This function is used in app/cli.c via the --apply-overwrites option
+ */
+enum zsv_status zsv_overwrite_auto(struct zsv_opts *opts, const char *csv_filename);
+
+/**
+ * As an alternative to zsv_overwrite_auto(), you can specify your own
+ * source from which to fetch overwrite data.
+ * The specified source can be a sqlite3 file or a CSV file
+ *
+ * This approach is used by app/echo.c
+ */
+struct zsv_overwrite_opts {
+  /* src may be either:
+   *
+   * 1. sqlite3 file source:
+   *    sqlite3://<filename>[?sql=<query>]",
+   *
+   * e.g. sqlite3:///path/to/my-overwritedb.sqlite3?sql=select row, column, value from overwrites order by row, column",
+   *
+   * or
+   *
+   * 2. CSV file source
+   *   /path/to/file.csv",
+   * where the CSV columns are row,col,val (in that order, with a header row),
+   * and rows already-sorted by row and column",
+   */
+  const char *src;
+};
+
+void *zsv_overwrite_context_new(struct zsv_overwrite_opts *);
+enum zsv_status zsv_overwrite_next(void *h, struct zsv_overwrite_data *odata);
+enum zsv_status zsv_overwrite_open(void *h);
+enum zsv_status zsv_overwrite_context_delete(void *h);
+
+#endif

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

@@ -0,0 +1,53 @@
+#include <zsv.h>
+
+enum zsvsheet_mode {
+  zsvsheet_mode_add,
+  zsvsheet_mode_remove,
+  zsvsheet_mode_clear,
+  zsvsheet_mode_list,
+  zsvsheet_mode_bulk,
+};
+
+struct zsv_overwrite {
+  struct zsv_overwrite_ctx *ctx;
+  struct zsv_overwrite_data *overwrite;
+  zsv_csv_writer writer;
+  enum zsv_status (*next)(struct zsv_overwrite *data);
+  enum zsvsheet_mode mode;
+  unsigned char force : 1;
+  unsigned char a1 : 1;
+  unsigned char all : 1;
+  unsigned char *bulk_file;
+  // bulk indexes
+  size_t row_ix;
+  size_t col_ix;
+  size_t val_ix;
+  size_t old_value_ix;
+  size_t timestamp_ix;
+  size_t author_ix;
+};
+
+struct zsv_overwrite_args {
+  char *filepath;
+  enum zsv_status (*next)(struct zsv_overwrite *data);
+  // options
+  unsigned char force : 1;
+  unsigned char a1 : 1;
+  unsigned char all : 1;
+  unsigned char *bulk_file;
+  struct zsv_overwrite_data *overwrite;
+  // commands
+  enum zsvsheet_mode mode;
+};
+
+struct zsv_overwrite *zsv_overwrite_writer_new(struct zsv_overwrite_args *args, struct zsv_overwrite_opts *ctx_opts);
+
+void zsv_overwrite_writer_delete();
+
+enum zsv_status zsv_overwrite_writer_add(struct zsv_overwrite *data);
+
+enum zsv_status zsv_overwrite_writer_remove(struct zsv_overwrite *data);
+
+enum zsv_status zsv_overwrite_writer_bulk(struct zsv_overwrite *data);
+
+enum zsv_status zsv_overwrite_writer_clear(struct zsv_overwrite *data);

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

@@ -0,0 +1,107 @@
+#ifndef ZSV_PROP_H
+#define ZSV_PROP_H
+
+#include <zsv/common.h>
+#include <yajl_helper/yajl_helper.h>
+
+struct zsv_file_properties {
+  enum zsv_status stat;
+  unsigned int skip;
+  unsigned int header_span;
+
+  // flags used by parser only to indicate whether property was specified
+  unsigned int skip_specified : 1;
+  unsigned int header_span_specified : 1;
+  unsigned int _ : 6;
+};
+
+struct zsv_prop_handler {
+  // handler should return 0 on success or non-zero on error. a non-zero return code will abort the property processing
+  int (*handler)(void *property_parser, const char *property_name, struct json_value *value);
+  void *ctx;
+};
+
+void *zsv_properties_parser_get_custom_ctx(void *property_parser);
+const unsigned char *zsv_properties_parser_get_filepath(void *property_parser);
+struct zsv_opts *zsv_properties_parser_get_opts(void *property_parser_);
+
+/**
+ * set or get default custom property handler
+ */
+void zsv_set_default_custom_prop_handler(struct zsv_prop_handler custom_prop_handler);
+
+struct zsv_prop_handler zsv_get_default_custom_prop_handler(void);
+
+void zsv_clear_default_custom_prop_handler(void);
+
+/**
+ * Load cached file properties into a zsp_opts and/or zsv_file_properties struct
+ *
+ * @param data_filepath            required file path
+ * @param opts (optional)          parser options to load
+ * @param custom_prop              custom property handler
+ * @return struct zsv_file_properties, with .stat set to zsv_status_ok on success
+ */
+struct zsv_file_properties zsv_cache_load_props(const char *data_filepath, struct zsv_opts *opts,
+                                                struct zsv_prop_handler *custom_prop);
+
+/**
+ * Create a new properties parser
+ */
+struct zsv_properties_parser;
+struct zsv_properties_parser *zsv_properties_parser_new(const unsigned char *path,
+                                                        struct zsv_prop_handler *custom_prop_handler,
+                                                        struct zsv_file_properties *fp, struct zsv_opts *opts);
+
+/**
+ * Finished parsing
+ */
+enum zsv_status zsv_properties_parse_complete(struct zsv_properties_parser *parser);
+
+/**
+ * Clean up
+ */
+enum zsv_status zsv_properties_parser_destroy(struct zsv_properties_parser *parser);
+
+/**
+ * zsv_new_with_properties(): use in lieu of zsv_new() to also merge zsv options
+ * with any saved properties (such as rows_to_ignore or header_span) for the
+ * specified input file. In the event that saved properties conflict with a
+ * command-line option, the command-line option "wins" (the property value is
+ * ignored), but a warning is printed
+ *
+ * @param opts       parser options. see `zsv_new()`
+ * @param cust_prop  optional custom file property handler
+ * @param input_path path of file whose zsv properties should be loaded. this
+ *                   param is used solely for loading properties and has no
+ *                   impact on the data that is actually parsed, which is
+ *                   determined by opts->stream
+ * @param handle_out returns zsv parser handle, or NULL on fail
+ */
+enum zsv_status zsv_new_with_properties(struct zsv_opts *opts, struct zsv_prop_handler *custom_prop,
+                                        const char *input_path, zsv_parser *handle_out);
+
+/**
+ * If you are building your own CLI and incorporating zsv CLI commands into it,
+ * the `prop` command can be customized by providing your own function
+ * for determining whether a file in the property cache is a property file,
+ * which can be set using zsv_prop_get_or_set_is_prop_file()
+ *
+ * @param is_prop_file: your function, that returns non-zero if the given file entry
+ *                             is a property file. If NULL, is set to zsv_is_prop_file
+ * @param max_depth   : maximum depth of any property file. if is_prop_file was NULL,
+ *                      max_depth is set to 1
+ */
+
+#include "dirs.h"
+
+struct zsv_dir_filter; /* opaque structure for internal use */
+struct zsv_dir_filter *zsv_prop_get_or_set_is_prop_file(int (*is_prop_file)(struct zsv_foreach_dirent_handle *, size_t),
+                                                        int max_depth, char set);
+
+/**
+ * If you provide your own is_prop_file() function and you also want to include any
+ * zsv property file, your is_prop_file() can call zsv_is_prop_file()
+ */
+int zsv_is_prop_file(struct zsv_foreach_dirent_handle *h, size_t depth);
+#endif

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

@@ -0,0 +1,18 @@
+/*
+ * 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_SIGNAL_H
+#define ZSV_SIGNAL_H
+
+#include <signal.h>
+
+extern volatile sig_atomic_t zsv_signal_interrupted;
+
+void zsv_handle_ctrl_c_signal(void);
+
+#endif

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

@@ -0,0 +1,11 @@
+#ifndef ZSV_UTILS_SQL_H
+#define ZSV_UTILS_SQL_H
+
+typedef struct zsv_sqlite3_db *zsv_sqlite3_db_t;
+
+struct zsv_sqlite3_dbopts {
+  unsigned char in_memory : 1;
+  unsigned char _ : 7;
+};
+
+#endif

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

@@ -0,0 +1,148 @@
+/*
+ * 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 ASCII_STRING_H
+#define ASCII_STRING_H
+
+#include "../zsv_export.h"
+#include <stddef.h>
+#include <stdint.h>
+
+/*
+ * zsv_strtolowercase(): convert to lower case. if built with utf8proc, converts unicode points
+ *   on malformed UTF8, prints to stderr
+ *
+ * @param s     string to convert
+ * @param lenp  pointer to length of input string; will be set to length of output string
+ *
+ * @returns     newly-allocated string; caller must free()
+ */
+unsigned char *zsv_strtolowercase(const unsigned char *s, size_t *lenp);
+
+/*
+ * zsv_strtolowercase_w_err(): convert to lower case. if built with utf8proc, converts unicode points
+ *   on malformed UTF8, sets *err to non-zero
+ *
+ */
+unsigned char *zsv_strtolowercase_w_err(const unsigned char *s, size_t *lenp, int *err);
+
+const unsigned char *zsv_strstr(const unsigned char *hay, const unsigned char *needle);
+
+/*
+ * zsv_stricmp, zsv_strincmp(): case-insensitive comparison (unicode-compatible if built with utf8proc)
+ * zsv_strincmp_ascii: ascii case-insensitive comparison
+ *
+ * @param   s1     string to convert
+ * @param   len1   length of s1
+ * @param   s2     string to convert
+ * @param   len2   length of s2
+ *
+ * @returns 0 if the strings are equal, -1 if s1 < s2, else 1
+ */
+int zsv_stricmp(const unsigned char *s1, const unsigned char *s2);
+int zsv_strincmp(const unsigned char *s1, size_t len1, const unsigned char *s2, size_t len2);
+int zsv_strincmp_ascii(const unsigned char *s1, size_t len1, const unsigned char *s2, size_t len2);
+
+#define ZSV_STRWHITE_FLAG_NO_EMBEDDED_NEWLINE 1
+/**
+ * zsv_strwhite(): convert consecutive white to single space
+ *
+ * @param s     string to convert
+ * @param len   length of input string
+ * @param flags bitfield of any of the following flags:
+ *                ZSV_STRWHITE_FLAG_NO_EMBEDDED_NEWLINE
+ */
+size_t zsv_strwhite(unsigned char *s, size_t len, unsigned int flags);
+
+/**
+ * Force a string to conform to UTF8 encoding. Replaces any non-conforming utf8
+ * with the specified char, or removes from the string (and shortens the string)
+ * if replace = 0
+ * @param  s        input string. invalid UTF8 bytes will be overwritten
+ * @param  n        length (in bytes) of input
+ * @param  replace  the character to replace any malformed UTF8 bytes with, or 0
+ *                  to remove and shorten the result
+ * @param  callback optional callback invoked upon scanning malformed UTF8
+ * @param  ctx      context pointer passed to callback
+ * @return          length of the valid string
+ */
+ZSV_EXPORT
+size_t zsv_strencode(unsigned char *s, size_t n, unsigned char replace,
+                     int (*malformed_handler)(void *, const unsigned char *s, size_t n, size_t offset),
+                     void *handler_ctx);
+
+size_t zsv_strip_trailing_zeros(const char *s, size_t len);
+
+/**
+ * Trim trailing whitespace
+ * Returns the input string and new length
+ */
+const unsigned char *zsv_strtrim_right(const char unsigned *restrict s, size_t *lenp);
+
+/**
+ * Trim leading whitespace
+ * Returns the pointer to the new string start and new length
+ */
+const unsigned char *zsv_strtrim_left(const char unsigned *restrict s, size_t *lenp);
+
+/**
+ * Trim leading and trailing whitespace
+  Returns the pointer to the new string start and new length
+ */
+const unsigned char *zsv_strtrim(const char unsigned *restrict s, size_t *lenp);
+
+/**
+ * zsv_strunescape_backslash(): convert consecutive white to single space
+ *
+ * @param s     string to convert
+ * @param len   length of input string
+ * @param flags bitfield of ZSV_STRWHITE_FLAG_XXX values
+ */
+size_t zsv_strunescape_backslash(unsigned char *s, size_t len);
+
+/**
+ * Get the next UTF8 codepoint in a string
+ * Return: length of next character (in bytes), or 0 on error or end of string
+ */
+size_t zsv_strnext(const unsigned char *s, size_t len, int32_t *codepoint);
+
+/**
+ * Get the last UTF8 codepoint in a string
+ * Return: length of last character (in bytes), or 0 on error or end of string
+ */
+size_t zsv_strlast(const unsigned char *s, size_t len, int32_t *codepoint);
+
+/**
+ *  Check if the next char is a plus or minus. If so, return its length, else return 0
+ */
+size_t zsv_strnext_is_sign(const unsigned char *s, size_t len);
+
+/**
+ *  Check if the next char is a currency char. If so, return its length, else return 0
+ */
+size_t zsv_strnext_is_currency(const unsigned char *s, size_t len);
+
+/*
+ * Convert a string to a double. must convert entire string, else returns error
+ * @param s     string to convert
+ * @param d     pointer to converted value, on success
+ *
+ * @returns     0 on success, non-zero on error
+ */
+int zsv_strtod_exact(const char *s, double *d);
+
+/*
+ * `zsv_get_cell_trimmed` is equivalent to `zsv_get_cell`, except that it
+ * @param s     string to convert
+ * @param len   length of input string
+ * returns a value with leading and trailing whitespace removed
+ */
+#include <zsv.h>
+struct zsv_cell zsv_get_cell_trimmed(zsv_parser parser, size_t index);
+
+#endif

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

@@ -0,0 +1,41 @@
+/*
+ * 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
+ */
+
+// clang-format off
+
+#ifndef ZSV_UTF8_CHARLEN_NOERR
+// ZSV_UTF8_CHARLEN_NOERR: return > 0 if valid utf8, +1 on error
+#define ZSV_UTF8_CHARLEN_NOERR(c)                       \
+  (!(c & 128) ? 1 :                                     \
+   (c & 224) == 192 ? 2 : /* 110xxxxx */                \
+   (c & 240) == 224 ? 3 : /* 1110xxxx */                \
+   (c & 248) == 240 ? 4 : /* 11110xxx */                \
+   (c & 252) == 248 ? 5 : /* 111110xx */                \
+   (c & 254) == 252 ? 6 : /* 1111110x */                \
+   1 /* error */                                        \
+   )
+#endif
+
+#ifndef ZSV_UTF8_CHARLEN
+// ZSV_UTF8_CHARLEN: return > 0 if valid utf8, -1 on error
+#define ZSV_UTF8_CHARLEN(c)                             \
+  (!(c & 128) ? 1 :                                     \
+   (c & 224) == 192 ? 2 : /* 110xxxxx */                \
+   (c & 240) == 224 ? 3 : /* 1110xxxx */                \
+   (c & 248) == 240 ? 4 : /* 11110xxx */                \
+   (c & 252) == 248 ? 5 : /* 111110xx */                \
+   (c & 254) == 252 ? 6 : /* 1111110x */                \
+   -1 /* error */                                       \
+   )
+#endif
+
+// clang-format on
+
+#ifndef ZSV_UTF8_SUBSEQUENT_CHAR_OK
+#define ZSV_UTF8_SUBSEQUENT_CHAR_OK(c) ((c & 192) == 128)
+#endif

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

@@ -0,0 +1,25 @@
+/*
+ * 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_WIN_H
+#define ZSV_DL_WIN_H
+
+#ifdef _WIN32
+
+#include <windows.h>
+
+#define RTLD_LAZY 0
+void *dlopen(const char *dll_name, int flags);
+
+void *dlsym(void *handle, const char *symbol);
+
+int dlclose(void *handle);
+
+#endif
+
+#endif

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

@@ -0,0 +1,101 @@
+/*
+ * 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_WRITER_H
+#define ZSV_WRITER_H
+
+#include <stdio.h>
+#include <stdint.h> // uint64_t
+
+#define ZSV_WRITER_NEW_ROW 1
+#define ZSV_WRITER_SAME_ROW 0
+
+/**
+ * csv writer options
+ *
+ * If `output_path` is non-NULL, `stream` must be NULL or stdout and `write` must be NULL or fwrite
+ ***/
+struct zsv_csv_writer_options {
+  char with_bom;
+  size_t (*write)(const void *restrict, size_t size, size_t nitems, void *restrict stream);
+  void *stream;
+  void (*table_init)(void *);
+  void *table_init_ctx;
+  const char *output_path; // if provided, will be created by zsv_writer_new() and closed by zsv_writer_delete()
+  void (*on_row)(void *);
+  void *on_row_ctx;
+
+  void (*on_delete)(void *);
+  void *on_delete_ctx;
+};
+
+void zsv_writer_set_default_opts(struct zsv_csv_writer_options opts);
+struct zsv_csv_writer_options zsv_writer_get_default_opts(void);
+
+enum zsv_writer_status {
+  zsv_writer_status_ok = 0,
+  zsv_writer_status_error,
+  zsv_writer_status_missing_handle,
+  zsv_writer_status_unknown = 999
+};
+
+struct zsv_writer_data;
+typedef struct zsv_writer_data *zsv_csv_writer;
+
+/**
+ * Get a new CSV writer
+ *
+ * @returns handle, or NULL on error, in which case errno will be set
+ */
+zsv_csv_writer zsv_writer_new(struct zsv_csv_writer_options *opts);
+enum zsv_writer_status zsv_writer_delete(zsv_csv_writer w);
+
+enum zsv_writer_status zsv_writer_flush(zsv_csv_writer w);
+
+void zsv_writer_set_temp_buff(zsv_csv_writer w, unsigned char *buff, size_t buffsize);
+
+enum zsv_writer_status zsv_writer_cell(zsv_csv_writer,
+                                       char new_row, // ZSV_WRITER_NEW_ROW or ZSV_WRITER_SAME_ROW
+                                       const unsigned char *s, size_t len, char check_if_needs_quoting);
+
+/*
+ * Get total bytes that have been written (to disk and buffer)
+ */
+uint64_t zsv_writer_cum_bytes_written(zsv_csv_writer);
+
+unsigned char *zsv_writer_str_to_csv(const unsigned char *s, size_t len);
+
+/*
+ * quote a CSV string, if needed
+ * @return NULL if no quoting required, `buff` if quoted value written to buff,
+ * or newly-allocated memory if buff not large enough (caller must free)
+ */
+unsigned char *zsv_csv_quote(const unsigned char *utf8_value, size_t len, unsigned char *buff, size_t buffsize);
+
+// zsv_writer_cell convenience funcs: zsv_writer_cell_XX where XX = printf specifier
+enum zsv_writer_status zsv_writer_cell_zu(zsv_csv_writer w, char new_row, size_t zu);
+
+enum zsv_writer_status zsv_writer_cell_s(zsv_csv_writer w, char new_row, const unsigned char *s,
+                                         char check_if_needs_quoting);
+
+enum zsv_writer_status zsv_writer_cell_Lf(zsv_csv_writer w, char new_row,
+                                          const char *fmt_spec, // provide X in %XLf e.g. ".2" or ""
+                                          long double ldbl);
+
+// write a blank cell
+enum zsv_writer_status zsv_writer_cell_blank(zsv_csv_writer w, char new_row);
+
+/**
+ * set a value to be prepended to the next cell value that is written
+ *
+ * @param w  handle to the writer
+ * @param s  text value to write (can be NULL)
+ */
+void zsv_writer_cell_prepend(zsv_csv_writer w, const unsigned char *s);
+
+#endif

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

@@ -0,0 +1,33 @@
+#ifndef ZSV_EXPORT_H
+#define ZSV_EXPORT_H
+
+// clang-format off
+#ifdef __EMSCRIPTEN__
+# include <emscripten.h>
+# define ZSV_EXPORT EMSCRIPTEN_KEEPALIVE
+#else
+# ifdef ZSV_BUILD_SHARED
+#  if defined(_WIN32) || defined(__CYGWIN__)
+#   ifdef __GNUC__
+#    define ZSV_EXPORT __attribute__((dllexport))
+#   else
+#    define ZSV_EXPORT __declspec(dllexport)
+#   endif
+#  else
+#   ifdef __GNUC__
+#    define ZSV_EXPORT __attribute__((dllimport))
+#   else
+#    define ZSV_EXPORT __declspec(dllimport)
+#   endif
+#  endif
+# else
+#  if __GNUC__ >= 4
+#   define ZSV_EXPORT __attribute__((visibility("default")))
+#  else
+#   define ZSV_EXPORT
+#  endif
+# endif
+#endif
+// clang-format on
+
+#endif

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

@@ -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
+ */
+
+#ifndef ZSV_H
+#define ZSV_H
+
+#ifndef ZSV_EXTRAS
+#define ZSV_EXTRAS
+#endif
+
+#include <stddef.h>
+#include "zsv/common.h"
+#include "zsv/api.h"
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/src/vector_delim.c

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2021 Tai Chi Minh Ralph Eastwood (self), Matt Wong (Guarnerix Inc dba Liquidaty)
+ * 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 <time.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#if VECTOR_BYTES == 64 && (defined(HAVE__BLSR_U64) || defined(HAVE___BLSR_U64))
+#if defined(HAVE__BLSR_U64)
+#define clear_lowest_bit(n) _blsr_u64(n)
+#else
+#define clear_lowest_bit(n) __blsr_u64(n)
+#endif
+#elif VECTOR_BYTES == 32 && (defined(HAVE__BLSR_U32) || defined(HAVE___BLSR_U32))
+#if defined(HAVE__BLSR_U32)
+#define clear_lowest_bit(n) _blsr_u32(n)
+#else
+#define clear_lowest_bit(n) __blsr_u32(n)
+#endif
+#else
+#define clear_lowest_bit(n) (n & (n - 1))
+#endif
+
+// vec_delims: return bitfield of next 32 bytes that contain at least 1 token
+__attribute__((always_inline)) static inline int vec_delims(const unsigned char *s, size_t n,
+                                                            zsv_uc_vector *char_match1, zsv_uc_vector *char_match2,
+                                                            zsv_uc_vector *char_match3, zsv_uc_vector *char_match4,
+                                                            zsv_mask_t *maskp) {
+  zsv_uc_vector *pSrc1 = (zsv_uc_vector *)s;
+  zsv_uc_vector str_simd;
+
+  unsigned j = n / sizeof(str_simd); // VECTOR_BYTES;
+  zsv_mask_t mask = 0;
+  unsigned total_bytes = 0;
+
+  for (unsigned i = 0; i < j; i++) {
+    memcpy(&str_simd, s + i * sizeof(str_simd), sizeof(str_simd));
+    zsv_uc_vector vtmp = str_simd == *char_match1;
+    vtmp += (str_simd == *char_match2);
+    vtmp += (str_simd == *char_match3);
+    vtmp += (str_simd == *char_match4);
+    mask = movemask_pseudo(vtmp);
+
+    if (LIKELY(mask != 0)) { // check if we found one of the 4 chars
+      *maskp = mask;
+      return total_bytes;
+    } else {
+      // not found, moving to next chunk
+      total_bytes += sizeof(*pSrc1);
+    }
+  }
+  return total_bytes; // nothing found in entire buffer
+}