zsv 1.3.1 → 1.4.3

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

@@ -1,393 +0,0 @@
-/*
- * 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

@@ -1,322 +0,0 @@
-/*
- * 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];
-}