zsv 1.3.0

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

@@ -0,0 +1,393 @@
+/*
+ * Copyright (C) 2021 Liquidaty and zsv contributors. All rights reserved.
+ *
+ * This file is part of zsv/lib, distributed under the MIT license as defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sglib.h>
+
+#define ZSV_COMMAND stack
+#include "zsv_command.h"
+
+#include <zsv/utils/writer.h>
+#include <zsv/utils/mem.h>
+#include <zsv/utils/string.h>
+
+const char *zsv_stack_usage_msg[] = {
+  APPNAME ": stack one or more csv files vertically, aligning columns with the same name",
+  "",
+  "Usage: " APPNAME " [options] filename [filename...]",
+  "",
+  "Options:",
+  "  -o <filename>      : output file",
+  "  -b                 : output with BOM",
+  "  -q                 : always add double-quotes",
+  //  "  --prepend-filename : output source filename as the first column of each output row",
+  "  --unique           : only output unique column names;",
+  "                       in case of duplicates, only the last (right-most) column will be kept",
+  NULL,
+};
+
+static int zsv_stack_usage(void) {
+  for (size_t i = 0; zsv_stack_usage_msg[i]; i++)
+    fprintf(stdout, "%s\n", zsv_stack_usage_msg[i]);
+  return 0;
+}
+
+typedef struct zsv_stack_colname {
+  struct zsv_stack_colname *next;
+  char unsigned *orig_name;
+  char unsigned *name;
+  unsigned occurrence;
+  unsigned dupes;
+  size_t global_position;
+  unsigned char color;
+  struct zsv_stack_colname *left;
+  struct zsv_stack_colname *right;
+  unsigned int raw_col_ix_plus_1;
+} zsv_stack_colname;
+
+static struct zsv_stack_colname *zsv_stack_colname_init(struct zsv_stack_colname *e, const unsigned char *name,
+                                                        size_t len, unsigned occurrence) {
+  memset(e, 0, sizeof(*e));
+  if (len)
+    e->name = zsv_strtolowercase(name, &len);
+  else
+    e->name = calloc(1, 2);
+  e->occurrence = occurrence;
+  return e;
+}
+
+static void zsv_stack_colname_free(struct zsv_stack_colname *e) {
+  if (e->name)
+    free(e->name);
+  if (e->orig_name)
+    free(e->orig_name);
+}
+
+static void zsv_stack_colname_delete(struct zsv_stack_colname *e) {
+  zsv_stack_colname_free(e);
+  free(e);
+}
+
+static int zsv_stack_colname_cmp(zsv_stack_colname *x, zsv_stack_colname *y) {
+  int i = strcmp((const char *)x->name, (const char *)y->name);
+  if (i == 0)
+    return x->occurrence == y->occurrence ? 0 : x->occurrence > y->occurrence ? 1 : -1;
+  return i;
+}
+
+SGLIB_DEFINE_RBTREE_PROTOTYPES(zsv_stack_colname, left, right, color, zsv_stack_colname_cmp);
+SGLIB_DEFINE_RBTREE_FUNCTIONS(zsv_stack_colname, left, right, color, zsv_stack_colname_cmp);
+
+static void zsv_stack_colname_tree_delete(zsv_stack_colname **tree) {
+  if (tree && *tree) {
+    struct sglib_zsv_stack_colname_iterator it;
+    struct zsv_stack_colname *e;
+    for (e = sglib_zsv_stack_colname_it_init(&it, *tree); e; e = sglib_zsv_stack_colname_it_next(&it))
+      zsv_stack_colname_delete(e);
+    *tree = NULL;
+  }
+}
+
+struct zsv_stack_data;
+struct zsv_stack_input_file {
+  struct zsv_stack_input_file *next;
+  FILE *f;
+  const char *fname;
+  zsv_parser parser;
+
+  // output_column_map[x] = n where x = output col ix, n = 0 if no map, else raw_column_ix
+  zsv_stack_colname *colnames;
+  size_t *output_column_map;
+  size_t output_column_map_size;
+  size_t header_row_end_offset; // location in buff at which the data row begins
+  struct zsv_stack_data *ctx;
+  unsigned char headers_done : 1;
+  unsigned char _ : 7;
+};
+
+struct zsv_stack_data {
+  struct zsv_stack_input_file *inputs;
+  struct zsv_stack_input_file *current_input;
+
+  unsigned inputs_count;
+  unsigned current_input_ix;
+  zsv_stack_colname *colnames;
+  zsv_stack_colname *first_colname;
+  zsv_stack_colname *last_colname;
+  unsigned colnames_count;
+  int err;
+
+  zsv_csv_writer csv_writer;
+
+  unsigned char unique_column_names : 1;
+  unsigned char _ : 7;
+};
+
+static struct zsv_stack_input_file **zsv_stack_input_file_add(const char *filename,
+                                                              struct zsv_stack_input_file **target, unsigned *count,
+                                                              FILE *f, struct zsv_stack_data *ctx) {
+  struct zsv_stack_input_file *e = calloc(1, sizeof(*e));
+  if (e) {
+    e->f = f;
+    e->fname = filename;
+    e->ctx = ctx;
+    *target = e;
+    (*count)++;
+    return &e->next;
+  }
+  return target;
+}
+
+static void zsv_stack_input_files_delete(struct zsv_stack_input_file *list) {
+  for (struct zsv_stack_input_file *next, *e = list; e; e = next) {
+    next = e->next;
+    if (e->f)
+      fclose(e->f);
+    if (e->output_column_map)
+      free(e->output_column_map);
+    zsv_stack_colname_tree_delete(&e->colnames);
+    zsv_delete(e->parser);
+    free(e);
+  }
+}
+
+static void zsv_stack_cleanup(struct zsv_stack_data *data) {
+  zsv_stack_input_files_delete(data->inputs);
+  zsv_stack_colname_tree_delete(&data->colnames);
+  zsv_writer_delete(data->csv_writer);
+}
+
+static struct zsv_stack_colname *zsv_stack_colname_get_or_add(struct zsv_cell c, unsigned occurrence,
+                                                              struct zsv_stack_colname **tree, int *added) {
+  const unsigned char *name = c.str;
+  size_t name_len = c.len;
+  struct zsv_stack_colname e;
+  zsv_stack_colname_init(&e, name, name_len, occurrence);
+  struct zsv_stack_colname *found = sglib_zsv_stack_colname_find_member(*tree, &e);
+  if (found) {
+    found->dupes++;
+    zsv_stack_colname_free(&e);
+  } else {
+    found = calloc(1, sizeof(*found));
+    if (found) {
+      *added = 1;
+      *found = e;
+      if (name)
+        found->orig_name = name ? zsv_memdup(name, name_len) : calloc(1, 2);
+      sglib_zsv_stack_colname_add(tree, found);
+    }
+  }
+  return found;
+}
+
+// zsv_stack_consolidate_header(): return global position
+static unsigned zsv_stack_consolidate_header(struct zsv_stack_data *d, struct zsv_cell cell, unsigned occurrence) {
+  int added = 0;
+  zsv_stack_colname *c = zsv_stack_colname_get_or_add(cell, occurrence, &d->colnames, &added);
+  if (!c)
+    d->err = 1;
+  else {
+    if (added) {
+      c->global_position = ++d->colnames_count;
+      if (d->last_colname)
+        d->last_colname->next = c;
+      else
+        d->first_colname = c;
+      d->last_colname = c;
+    }
+    return c->global_position;
+  }
+  return 0;
+}
+
+static void zsv_stack_header_row(void *ctx) {
+  struct zsv_stack_input_file *input = ctx;
+  if (!input->headers_done && !zsv_row_is_blank(input->parser)) { // skip any blank leading rows
+    input->headers_done = 1;
+    zsv_abort(input->parser);
+  }
+}
+
+static void zsv_stack_data_row(void *ctx) {
+  struct zsv_stack_input_file *input = ctx;
+  if (!input->headers_done) {
+    input->headers_done = 1;
+    return;
+  }
+  if (!zsv_row_is_blank(input->parser)) {
+    size_t colnames_count = input->ctx->colnames_count;
+    for (unsigned i = 0; i < colnames_count; i++) {
+      size_t raw_ix_plus_1;
+      if (i < input->output_column_map_size && ((raw_ix_plus_1 = input->output_column_map[i]))) {
+        struct zsv_cell cell = zsv_get_cell(input->parser, raw_ix_plus_1 - 1);
+        zsv_writer_cell(input->ctx->csv_writer, !i, cell.str, cell.len, cell.quoted);
+      } else
+        zsv_writer_cell(input->ctx->csv_writer, !i, 0x0, 0, 0);
+    }
+  }
+}
+
+int ZSV_MAIN_FUNC(ZSV_COMMAND)(int argc, const char *argv[], struct zsv_opts *opts,
+                               struct zsv_prop_handler *custom_prop_handler) {
+  int err = 0;
+  if (argc < 2) {
+    zsv_stack_usage();
+    return 1;
+  }
+
+  if (argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")))
+    return zsv_stack_usage();
+
+  struct zsv_opts saved_opts = *opts;
+  struct zsv_stack_data data = {0};
+  struct zsv_csv_writer_options writer_opts = zsv_writer_get_default_opts();
+  writer_opts.stream = stdout;
+
+  struct zsv_stack_input_file **next_input = &data.inputs;
+  for (int arg_i = 1; !data.err && arg_i < argc; arg_i++) {
+    const char *arg = argv[arg_i];
+    if (!strcmp(arg, "-b"))
+      writer_opts.with_bom = 1;
+    //    else if (!strcmp(arg, "--prepend-filename")_)
+    //      data.prepend_filename
+    else if (!strcmp(arg, "--unique"))
+      data.unique_column_names = 1;
+    else if (!strcmp(arg, "-o")) {
+      arg_i++;
+      if (arg_i >= argc)
+        fprintf(stderr, "-o option: no filename specified\n");
+      else {
+        if (!(writer_opts.stream = fopen(argv[arg_i], "wb"))) {
+          data.err = 1;
+          fprintf(stderr, "Unable to open file for writing: %s\n", argv[arg_i]);
+        }
+      }
+    } else if (*arg == '-') {
+      fprintf(stderr, "Unrecognized option: %s\n", arg);
+      data.err = 1;
+    } else {
+      FILE *f = fopen(arg, "rb");
+      if (!f) {
+        fprintf(stderr, "Could not open file for reading: %s\n", arg);
+        data.err = 1;
+      } else
+        next_input = zsv_stack_input_file_add(arg, next_input, &data.inputs_count, f, &data);
+    }
+  }
+
+  if (!(data.csv_writer = zsv_writer_new(&writer_opts)))
+    data.err = 1;
+
+  // collect all header names so we can line them up
+  unsigned i = 0;
+  for (struct zsv_stack_input_file *input = data.inputs; !data.err && input; input = input->next, i++) {
+    *opts = saved_opts;
+    opts->row_handler = zsv_stack_header_row;
+    opts->ctx = input;
+
+    // to do: max_cell_size
+    opts->stream = input->f;
+    if (zsv_new_with_properties(opts, custom_prop_handler, input->fname, &input->parser) != zsv_status_ok)
+      data.err = 1;
+    else {
+      zsv_handle_ctrl_c_signal();
+      enum zsv_status status;
+      while (!data.err && !input->headers_done && (status = zsv_parse_more(input->parser)) == zsv_status_ok)
+        ;
+    }
+  }
+
+  // we have read the header row of each input, so:
+  // - consolidate a column header names into a single list
+  // - assign output->input column mappings for each input
+
+  // first, get maximum size of consolidated cols, which is just the sum of the column count
+  // of all inputs
+  size_t max_columns_count = 0;
+  for (struct zsv_stack_input_file *input = data.inputs; !data.err && input; input = input->next)
+    max_columns_count += zsv_cell_count(input->parser);
+
+  // next, for each input, align the input columns with the output columns
+  for (struct zsv_stack_input_file *input = data.inputs; input && !data.err; input = input->next) {
+    if (max_columns_count) {
+      if (!(input->output_column_map = calloc(max_columns_count, sizeof(*input->output_column_map))))
+        data.err = 1;
+      else {
+        input->output_column_map_size = max_columns_count;
+        // assign column indexes to global columns
+        size_t cols_used = zsv_cell_count(input->parser);
+        for (unsigned col_ix = 0; col_ix < cols_used; col_ix++) {
+          struct zsv_cell cell = zsv_get_cell(input->parser, col_ix);
+          unsigned occurrence = 0;
+          if (!data.unique_column_names) {
+            int added;
+            zsv_stack_colname *c = zsv_stack_colname_get_or_add(cell, 0, &input->colnames, &added);
+            if (c)
+              occurrence = c->dupes;
+          }
+          size_t output_ix = zsv_stack_consolidate_header(&data, cell, occurrence);
+          if (output_ix)
+            input->output_column_map[output_ix - 1] = col_ix + 1;
+        }
+      }
+    }
+    zsv_delete(input->parser);
+    input->parser = NULL;
+  }
+
+  // not necessary, but free up unused memory by resizing each input's output_column_map
+  for (struct zsv_stack_input_file *input = data.inputs; input && !data.err; input = input->next) {
+    if (!data.colnames_count) {
+      if (input->output_column_map) {
+        free(input->output_column_map);
+        input->output_column_map = NULL;
+      }
+    } else {
+      size_t *resized = realloc(input->output_column_map, data.colnames_count * sizeof(*resized));
+      if (resized)
+        input->output_column_map = resized;
+    }
+  }
+
+  // print headers
+  for (struct zsv_stack_colname *e = data.first_colname; !data.err && e; e = e->next) {
+    const unsigned char *name = e->orig_name ? e->orig_name : e->name ? e->name : (const unsigned char *)"";
+    zsv_writer_cell(data.csv_writer, e == data.first_colname, name, strlen((const char *)name), 1);
+  }
+
+  // process data
+  for (struct zsv_stack_input_file *input = data.inputs; input && !data.err; input = input->next, i++) {
+    if (input->headers_done) {
+      *opts = saved_opts;
+      opts->row_handler = zsv_stack_data_row;
+      opts->ctx = input;
+
+      rewind(input->f);
+      input->headers_done = 0;
+      opts->stream = input->f;
+      if (zsv_new_with_properties(opts, custom_prop_handler, input->fname, &input->parser) != zsv_status_ok)
+        data.err = 1;
+      else {
+        enum zsv_status status = zsv_status_ok;
+        while (status == zsv_status_ok && !data.err && (status = zsv_parse_more(input->parser)) == zsv_status_ok)
+          ;
+        zsv_finish(input->parser);
+        zsv_delete(input->parser);
+        input->parser = NULL;
+      }
+    }
+  }
+  err = data.err;
+  zsv_stack_cleanup(&data);
+
+  if (writer_opts.stream && writer_opts.stream != stdout)
+    fclose(writer_opts.stream);
+
+  return err;
+}

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

@@ -0,0 +1,322 @@
+/*
+ * 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.h>
+#include <zsv/utils/string.h>
+#include <zsv/utils/arg.h>
+#include <assert.h>
+
+/*
+ * for now we don't really need thread support because this is only being used
+ * by the CLI. However, it's here anyway in case future enhancements or
+ * user customizations need multithreading support
+ */
+#ifndef ZSVTLS
+#ifndef NO_THREADING
+#define ZSVTLS _Thread_local
+#else
+#define ZSVTLS
+#endif
+#endif
+/*
+ * global zsv_default_opts for convenience funcs zsv_get_default_opts() and zsv_set_default_opts()
+ *  for the cli to pass global opts to the standalone modules
+ */
+
+/*
+ * Use a single function for all default-option operations, so as to be able
+ * to use thread-local storage with static initializer
+ */
+static struct zsv_opts *zsv_with_default_opts(char mode) {
+  ZSVTLS static char zsv_default_opts_initd = 0;
+  ZSVTLS static struct zsv_opts zsv_default_opts = {0};
+
+  switch (mode) {
+  case 'c': // clear
+    memset(&zsv_default_opts, 0, sizeof(zsv_default_opts));
+    zsv_default_opts_initd = 0;
+    break;
+  case 'g': // get
+    if (!zsv_default_opts_initd) {
+      zsv_default_opts_initd = 1;
+      zsv_default_opts.max_row_size = ZSV_ROW_MAX_SIZE_DEFAULT;
+      zsv_default_opts.max_columns = ZSV_MAX_COLS_DEFAULT;
+    } else {
+      zsv_default_opts.max_row_size =
+        zsv_default_opts.max_row_size ? zsv_default_opts.max_row_size : ZSV_ROW_MAX_SIZE_DEFAULT;
+      zsv_default_opts.max_columns = zsv_default_opts.max_columns ? zsv_default_opts.max_columns : ZSV_MAX_COLS_DEFAULT;
+    }
+    break;
+  }
+  return &zsv_default_opts;
+}
+
+ZSV_EXPORT
+void zsv_clear_default_opts(void) {
+  zsv_with_default_opts('c');
+}
+
+ZSV_EXPORT
+struct zsv_opts zsv_get_default_opts(void) {
+  return *zsv_with_default_opts('g');
+}
+
+ZSV_EXPORT
+void zsv_set_default_opts(struct zsv_opts opts) {
+  *zsv_with_default_opts(0) = opts;
+}
+
+/**
+ * str_array_index_of: return index in list, or size of list if not found
+ */
+static inline int str_array_index_of(const char *list[], const char *s) {
+  int i;
+  for (i = 0; list[i] && strcmp(list[i], s); i++)
+    ;
+  return i;
+}
+
+#ifdef ZSV_EXTRAS
+
+ZSV_EXPORT
+void zsv_set_default_progress_callback(zsv_progress_callback cb, void *ctx, size_t rows_interval,
+                                       unsigned int seconds_interval) {
+  struct zsv_opts opts = zsv_get_default_opts();
+  opts.progress.callback = cb;
+  opts.progress.ctx = ctx;
+  opts.progress.rows_interval = rows_interval;
+  opts.progress.seconds_interval = seconds_interval;
+  zsv_set_default_opts(opts);
+}
+
+ZSV_EXPORT
+void zsv_set_default_completed_callback(zsv_completed_callback cb, void *ctx) {
+  struct zsv_opts opts = zsv_get_default_opts();
+  opts.completed.callback = cb;
+  opts.completed.ctx = ctx;
+  zsv_set_default_opts(opts);
+}
+
+#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
+ *     -R,--skip-head <n>: skip specified number of initial rows
+ *     -d,--header-row-span <n> : apply header depth (rowspan) of n
+ *     -u,--malformed-utf8-replacement <string>: replacement string (can be empty) in case of malformed UTF8
+ * input (default for "desc" command is '?') -S,--keep-blank-headers  : disable default behavior of ignoring leading
+ * blank rows -0,--header-row <header> : insert the provided CSV as the first row (in position 0) e.g. --header-row
+ * 'col1,col2,\"my col 3\"'", -v,--verbose
+ *     -1,--apply-overwrites: automatically apply cached overwrites
+ *
+ * @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
+ */
+ZSV_EXPORT
+enum zsv_status zsv_args_to_opts(int argc, const char *argv[], int *argc_out, const char **argv_out,
+                                 struct zsv_opts *opts_out) {
+#ifdef ZSV_EXTRAS
+  static const char *short_args = "BcrtOqvRdSu01L";
+#else
+  static const char *short_args = "BcrtOqvRdSu0";
+#endif
+
+  static const char *long_args[] = {
+    "buff-size",
+    "max-column-count",
+    "max-row-size",
+    "tab-delim",
+    "other-delim",
+    "no-quote",
+    "verbose",
+    "skip-head",
+    "header-row-span",
+    "keep-blank-headers",
+    "malformed-utf8-replacement",
+    "header-row",
+#ifdef ZSV_EXTRAS
+    "apply-overwrites",
+    "limit-rows",
+#endif
+    NULL,
+  };
+
+  *opts_out = zsv_get_default_opts();
+  int options_start = 1; // skip this many args before we start looking for options
+  int err = 0;
+  int new_argc = 0;
+  for (; new_argc < options_start && new_argc < argc; new_argc++)
+    argv_out[new_argc] = argv[new_argc];
+
+  for (int i = options_start; !err && i < argc; i++) {
+    char arg = 0;
+    if (*argv[i] != '-') { /* pass this option through */
+      argv_out[new_argc++] = argv[i];
+      continue;
+    }
+    unsigned found_ix = 0;
+    if (argv[i][1] != '-') {
+      char *strchr_result;
+      if (!argv[i][2] && (strchr_result = strchr(short_args, argv[i][1]))) {
+        arg = argv[i][1];
+        found_ix = strchr_result - short_args;
+      }
+#ifndef ZSV_NO_ONLY_CRLF
+    } else if (!strcmp(argv[i] + 2, "only-crlf")) {
+      opts_out->only_crlf_rowend = 1;
+      continue;
+#endif
+    } else {
+      found_ix = str_array_index_of(long_args, argv[i] + 2);
+      arg = short_args[found_ix];
+    }
+
+    char processed = 1;
+    switch (arg) {
+    case 't':
+      opts_out->delimiter = '\t';
+      break;
+    case 'S':
+      opts_out->keep_empty_header_rows = 1;
+      break;
+    case 'q':
+      opts_out->no_quotes = 1;
+      break;
+    case 'v':
+      opts_out->verbose = 1;
+      break;
+#ifdef ZSV_EXTRAS
+    case '1':
+      opts_out->overwrite_auto = 1;
+      break;
+    case 'L':
+#endif
+    case 'B':
+    case 'c':
+    case 'r':
+    case 'O':
+    case 'R':
+    case 'd':
+    case 'u':
+    case '0':
+      if (++i >= argc)
+        err = fprintf(stderr, "Error: option %s requires a value\n", argv[i - 1]);
+      else {
+        const char *val = argv[i];
+        if (arg == 'O') {
+          if (strlen(val) != 1 || *val == 0)
+            err = fprintf(stderr, "Error: delimiter '%s' may only be a single ascii character", val);
+          else if (strchr("\n\r\"", *val))
+            err = fprintf(stderr, "Error: column delimiter may not be '\\n', '\\r' or '\"'\n");
+          else
+            opts_out->delimiter = *val;
+        } else if (arg == 'u') {
+          if (!strcmp(val, "none"))
+            opts_out->malformed_utf8_replace = ZSV_MALFORMED_UTF8_DO_NOT_REPLACE;
+          else if (!*val)
+            opts_out->malformed_utf8_replace = ZSV_MALFORMED_UTF8_REMOVE;
+          else if (strlen(val) > 2 || *val < 0)
+            err =
+              fprintf(stderr, "Error: %s value must be a single-byte UTF8 char, empty string or 'none'\n", argv[i - 1]);
+          else
+            opts_out->malformed_utf8_replace = *val;
+        } else if (arg == '0') {
+          if (*val == 0)
+            err = fprintf(stderr, "Invalid empty Inserted header row\n");
+          else
+            opts_out->insert_header_row = argv[i];
+        } else {
+          /* arg = 'B', 'c', 'r', 'R', 'd', or 'L' (ZSV_EXTRAS only) */
+          long n = atol(val);
+          if (n < 0)
+            err = fprintf(stderr, "Error: option %s value may not be less than zero (got %li\n", val, n);
+#ifdef ZSV_EXTRAS
+          else if (arg == 'L') {
+            if (n < 1)
+              err = fprintf(stderr, "Error: max rows may not be less than 1 (got %s)\n", val);
+            else
+              opts_out->max_rows = n;
+          } else
+#endif
+            if (arg == 'B') {
+            if (n < ZSV_MIN_SCANNER_BUFFSIZE)
+              err =
+                fprintf(stderr, "Error: buff size may not be less than %u (got %s)\n", ZSV_MIN_SCANNER_BUFFSIZE, val);
+            else
+              opts_out->buffsize = n;
+          } else if (arg == 'c') {
+            if (n < 8)
+              err = fprintf(stderr, "Error: max column count may not be less than 8 (got %s)\n", val);
+            else
+              opts_out->max_columns = n;
+          } else if (arg == 'r') {
+            if (n < ZSV_ROW_MAX_SIZE_MIN)
+              err = fprintf(stderr, "Error: max row size size may not be less than %u (got %s)\n", ZSV_ROW_MAX_SIZE_MIN,
+                            val);
+            else
+              opts_out->max_row_size = n;
+          } else if (arg == 'd') {
+            if (n < 8 && n >= 0)
+              opts_out->header_span = n;
+            else
+              err = fprintf(stderr, "Error: header_span must be an integer between 0 and 8\n");
+          } else if (arg == 'R') {
+            if (n >= 0)
+              opts_out->rows_to_ignore = n;
+            else
+              err = fprintf(stderr, "Error: rows_to_skip must be >= 0\n");
+          }
+        }
+      }
+      break;
+    default: /* pass this option through */
+      processed = 0;
+      argv_out[new_argc++] = argv[i];
+      break;
+    }
+    if (processed && opts_out) {
+      if (arg == 'R')
+        opts_out->option_overrides.skip_head = 1;
+      else if (arg == 'd')
+        opts_out->option_overrides.header_row_span = 1;
+      else if (arg == 'c')
+        opts_out->option_overrides.max_column_count = 1;
+      else if (arg == 'u')
+        opts_out->option_overrides.malformed_utf8_replacement = 1;
+    }
+  }
+
+  *argc_out = new_argc;
+  return err ? zsv_status_error : zsv_status_ok;
+}
+
+const char *zsv_next_arg(int arg_i, int argc, const char *argv[], int *err) {
+  if (!(arg_i < argc && strlen(argv[arg_i]) > 0)) {
+    fprintf(stderr, "%s option value invalid: should be non-empty string\n", argv[arg_i - 1]);
+    *err = 1;
+    return NULL;
+  }
+  return argv[arg_i];
+}