zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/2json.c

@@ -0,0 +1,381 @@
+/*
+ * Copyright (C) 2021-2022 Liquidaty and zsv contributors. 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 <string.h>
+#include <stdlib.h>
+#include <jsonwriter.h>
+#include <sqlite3.h>
+
+#define ZSV_COMMAND 2json
+#include "zsv_command.h"
+
+#include <zsv/utils/writer.h>
+#include <zsv/utils/mem.h>
+#include <zsv/utils/db.h>
+
+struct zsv_2json_header {
+  struct zsv_2json_header *next;
+  char *name;
+};
+
+#define LQ_2JSON_MAX_INDEXES 32
+
+struct zsv_2json_data {
+  zsv_parser parser;
+  jsonwriter_handle jsw;
+
+  size_t rows_processed; // includes header row
+
+  struct {
+    const char *clauses[LQ_2JSON_MAX_INDEXES];
+    char unique[LQ_2JSON_MAX_INDEXES];
+    unsigned count;
+  } indexes;
+
+  struct zsv_2json_header *headers, *current_header;
+  struct zsv_2json_header **headers_next;
+
+  char *db_tablename;
+
+#define ZSV_JSON_SCHEMA_OBJECT 1
+#define ZSV_JSON_SCHEMA_DATABASE 2
+  unsigned char schema : 2;
+  unsigned char no_header : 1;
+  unsigned char no_empty : 1;
+  unsigned char err : 1;
+  unsigned char from_db : 1;
+  unsigned char compact : 1;
+  unsigned char _ : 1;
+};
+
+static void zsv_2json_cleanup(struct zsv_2json_data *data) {
+  for (struct zsv_2json_header *next, *h = data->headers; h; h = next) {
+    next = h->next;
+    if (h->name)
+      free(h->name);
+    free(h);
+  }
+  free(data->db_tablename);
+}
+
+static void write_header_cell(struct zsv_2json_data *data, const unsigned char *utf8_value, size_t len) {
+  if (data->schema == ZSV_JSON_SCHEMA_OBJECT) {
+    struct zsv_2json_header *h;
+    if (!(h = calloc(1, sizeof(*h)))) {
+      fprintf(stderr, "Out of memory!\n");
+      data->err = 1;
+    } else {
+      *data->headers_next = h;
+      data->headers_next = &h->next;
+      if ((h->name = malloc(len + 1))) {
+        memcpy(h->name, utf8_value, len);
+        h->name[len] = '\0';
+      }
+    }
+  } else {
+    // to do: add options to set data type, etc
+    jsonwriter_start_object(data->jsw);
+    jsonwriter_object_key(data->jsw, "name");
+    jsonwriter_strn(data->jsw, utf8_value, len);
+    jsonwriter_end(data->jsw);
+  }
+}
+
+static void write_data_cell(struct zsv_2json_data *data, const unsigned char *utf8_value, size_t len) {
+  if (data->schema == ZSV_JSON_SCHEMA_OBJECT) {
+    if (!data->current_header)
+      return;
+    char *current_header_name = data->current_header->name;
+    data->current_header = data->current_header->next;
+
+    if (len || !data->no_empty)
+      jsonwriter_object_key(data->jsw, current_header_name);
+    else
+      return;
+  }
+  jsonwriter_strn(data->jsw, utf8_value, len);
+}
+
+static char *zsv_2json_db_first_tname(sqlite3 *db) {
+  char *tname = NULL;
+  sqlite3_stmt *stmt = NULL;
+  const char *sql = "select name from sqlite_master where type = 'table'";
+  if (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL) != SQLITE_OK)
+    fprintf(stderr, "Unable to prepare %s: %s\n", sql, sqlite3_errmsg(db));
+  else if (sqlite3_step(stmt) == SQLITE_ROW) {
+    const unsigned char *text = sqlite3_column_text(stmt, 0);
+    if (text) {
+      int len = sqlite3_column_bytes(stmt, 0);
+      tname = zsv_memdup(text, len);
+    }
+  }
+  if (stmt)
+    sqlite3_finalize(stmt);
+  return tname;
+}
+
+static void zsv_2json_row(void *ctx) {
+  struct zsv_2json_data *data = ctx;
+  unsigned int cols = zsv_cell_count(data->parser);
+  if (cols) {
+    char obj = 0;
+    char arr = 0;
+    if (!data->rows_processed) {         // header row
+      jsonwriter_start_array(data->jsw); // start array of rows
+      if (data->schema == ZSV_JSON_SCHEMA_DATABASE) {
+        jsonwriter_start_object(data->jsw); // start this row
+        obj = 1;
+
+        if (data->db_tablename)
+          jsonwriter_object_cstr(data->jsw, "name", data->db_tablename);
+
+        // to do: check index syntax (as of now, we just take argument value
+        // as-is and assume it will translate into a valid SQLITE3 command)
+        char have_index = 0;
+        for (unsigned i = 0; i < data->indexes.count; i++) {
+          const char *name_start = data->indexes.clauses[i];
+          const char *on = strstr(name_start, " on ");
+          if (on) {
+            on += 4;
+            while (*on == ' ')
+              on++;
+          }
+          if (!on || !*on)
+            continue;
+
+          const char *name_end = name_start;
+          while (name_end && *name_end && *name_end != ' ')
+            name_end++;
+
+          if (name_end > name_start) {
+            if (!have_index) {
+              have_index = 1;
+              jsonwriter_object_object(data->jsw, "indexes");
+            }
+            char *tmp = zsv_memdup(name_start, name_end - name_start);
+            jsonwriter_object_object(data->jsw, tmp); // this index
+            free(tmp);
+            jsonwriter_object_cstr(data->jsw, "on", on);
+            if (data->indexes.unique[i])
+              jsonwriter_object_bool(data->jsw, "unique", 1);
+            jsonwriter_end_object(data->jsw); // end this index
+          }
+        }
+        if (have_index)
+          jsonwriter_end_object(data->jsw); // indexes
+
+        jsonwriter_object_array(data->jsw, "columns");
+        arr = 1;
+      } else if (data->schema != ZSV_JSON_SCHEMA_OBJECT) {
+        jsonwriter_start_array(data->jsw); // start this row
+        arr = 1;
+      }
+    } else { // processing a data row, not header row
+      if (data->schema == ZSV_JSON_SCHEMA_OBJECT) {
+        jsonwriter_start_object(data->jsw); // start this row
+        obj = 1;
+      } else {
+        if (data->rows_processed == 1 && data->schema == ZSV_JSON_SCHEMA_DATABASE)
+          jsonwriter_start_array(data->jsw); // start the table-data element
+        jsonwriter_start_array(data->jsw);   // start this row
+        arr = 1;
+      }
+    }
+
+    for (unsigned int i = 0; i < cols; i++) {
+      struct zsv_cell cell = zsv_get_cell(data->parser, i);
+      // output this cell
+      if (!data->rows_processed && !data->no_header) // this is header row
+        write_header_cell(data, cell.str, cell.len);
+      else
+        write_data_cell(data, cell.str, cell.len);
+    }
+
+    // end this row
+    if (arr)
+      jsonwriter_end_array(data->jsw);
+    if (obj)
+      jsonwriter_end_object(data->jsw);
+    data->rows_processed++;
+  }
+  data->current_header = data->headers;
+}
+
+static int zsv_db2json(const char *input_filename, char **tname, jsonwriter_handle jsw) {
+  sqlite3 *db;
+  int rc =
+    sqlite3_open_v2(input_filename, &db, SQLITE_OPEN_READONLY | SQLITE_OPEN_FULLMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL);
+  int err = 0;
+  if (!db)
+    fprintf(stderr, "Unable to open db at %s\n", input_filename), err = 1;
+  else if (rc != SQLITE_OK)
+    fprintf(stderr, "Unable to open db at %s: %s\n", input_filename, sqlite3_errmsg(db)), err = 1;
+  else if (!*tname)
+    *tname = zsv_2json_db_first_tname(db);
+
+  if (!*tname)
+    fprintf(stderr, "No table name provided, and none found in %s\n", input_filename), err = 1;
+  else
+    err = zsv_dbtable2json(db, *tname, jsw, 0);
+  return err;
+}
+
+int ZSV_MAIN_FUNC(ZSV_COMMAND)(int argc, const char *argv[], struct zsv_opts *optsp,
+                               struct zsv_prop_handler *custom_prop_handler) {
+  struct zsv_opts opts = *optsp;
+  struct zsv_2json_data data = {0};
+  data.headers_next = &data.headers;
+
+  const char *usage[] = {
+    APPNAME ": streaming CSV to JSON converter, or SQLite3 DB to JSON converter",
+    "",
+    "Usage: " APPNAME " [options] [file.csv]",
+    "",
+    "Options:",
+    "  -h,--help                     : show usage",
+    "  -o,--output <filename>        : filename to write output to",
+    "  --compact                     : output compact JSON",
+    "  --from-db                     : input is sqlite3 database",
+    "  --db-table <table_name>       : name of table in input database to convert",
+    "  --object                      : output as array of objects",
+    "  --no-empty                    : omit empty properties (only with --object)",
+    "  --database                    : output in database schema",
+    "  --no-header                   : treat the header row as a data row",
+    "  --index <name_on_expr>        : add index to database schema",
+    "  --unique-index <name_on_expr> : add unique index to database schema",
+    NULL,
+  };
+
+  FILE *out = NULL;
+  const char *input_path = NULL;
+  enum zsv_status err = zsv_status_ok;
+  int done = 0;
+
+  for (int i = 1; !err && !done && i < argc; i++) {
+    if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) {
+      for (int j = 0; usage[j]; j++)
+        fprintf(stdout, "%s\n", usage[j]);
+      done = 1;
+    } else if (!strcmp(argv[i], "-o") || !strcmp(argv[i], "--output")) {
+      if (++i >= argc)
+        fprintf(stderr, "%s option requires a filename value\n", argv[i - 1]), err = zsv_status_error;
+      else if (out && out != stdout)
+        fprintf(stderr, "Output file specified more than once\n"), err = zsv_status_error;
+      else if (!(out = fopen(argv[i], "wb")))
+        fprintf(stderr, "Unable to open for writing: %s\n", argv[i]), err = zsv_status_error;
+    } else if (!strcmp(argv[i], "--index") || !strcmp(argv[i], "--unique-index")) {
+      if (++i >= argc)
+        fprintf(stderr, "%s option requires a filename value\n", argv[i - 1]), err = zsv_status_error;
+      else if (data.indexes.count > LQ_2JSON_MAX_INDEXES)
+        fprintf(stderr, "Max index count exceeded; ignoring %s\n", argv[i]), err = zsv_status_error;
+      else if (!strstr(argv[i], " on "))
+        fprintf(stderr, "Index value should be in the form of 'index_name on expr'; got %s\n", argv[i]),
+          err = zsv_status_error;
+      else {
+        if (!strcmp(argv[i - 1], "--unique-index"))
+          data.indexes.unique[data.indexes.count] = 1;
+        data.indexes.clauses[data.indexes.count++] = argv[i];
+      }
+    } else if (!strcmp(argv[i], "--no-empty")) {
+      data.no_empty = 1;
+    } else if (!strcmp(argv[i], "--db-table")) {
+      if (++i >= argc)
+        fprintf(stderr, "%s option requires a table name value\n", argv[i - 1]), err = zsv_status_error;
+      else if (data.db_tablename)
+        fprintf(stderr, "%s option specified more than once\n", argv[i - 1]), err = zsv_status_error;
+      else
+        data.db_tablename = strdup(argv[i]);
+    } else if (!strcmp(argv[i], "--from-db")) {
+      if (++i >= argc)
+        fprintf(stderr, "%s option requires a filename value\n", argv[i - 1]), err = zsv_status_error;
+      else if (opts.stream)
+        fprintf(stderr, "Input file specified more than once\n"), err = zsv_status_error;
+      else if (!(opts.stream = fopen(argv[i], "rb")))
+        fprintf(stderr, "Unable to open for reading: %s\n", argv[i]), err = zsv_status_error;
+      else {
+        input_path = argv[i];
+        data.from_db = 1;
+      }
+    } else if (!strcmp(argv[i], "--database") || !strcmp(argv[i], "--object")) {
+      if (data.schema)
+        fprintf(stderr, "Output schema specified more than once\n"), err = zsv_status_error;
+      else if (!strcmp(argv[i], "--database"))
+        data.schema = ZSV_JSON_SCHEMA_DATABASE;
+      else
+        data.schema = ZSV_JSON_SCHEMA_OBJECT;
+    } else if (!strcmp(argv[i], "--no-header"))
+      data.no_header = 1;
+    else if (!strcmp(argv[i], "--compact"))
+      data.compact = 1;
+    else {
+      if (opts.stream)
+        fprintf(stderr, "Input file specified more than once\n"), err = zsv_status_error;
+      else if (!(opts.stream = fopen(argv[i], "rb")))
+        fprintf(stderr, "Unable to open for reading: %s\n", argv[i]), err = zsv_status_error;
+      else
+        input_path = argv[i];
+    }
+  }
+
+  if (!(err || done)) {
+    if (data.indexes.count && data.schema != ZSV_JSON_SCHEMA_DATABASE)
+      fprintf(stderr, "--index/--unique-index can only be used with --database\n"), err = zsv_status_error;
+    else if (data.no_header && data.schema)
+      fprintf(stderr, "--no-header cannot be used together with --object or --database\n"), err = zsv_status_error;
+    else if (data.no_empty && data.schema != ZSV_JSON_SCHEMA_OBJECT)
+      fprintf(stderr, "--no-empty can only be used with --object\n"), err = zsv_status_error;
+    else if (!opts.stream) {
+      if (data.from_db)
+        fprintf(stderr, "Database input specified, but no input file provided\n"), err = zsv_status_error;
+      else {
+#ifdef NO_STDIN
+        fprintf(stderr, "Please specify an input file\n"), err = zsv_status_error;
+#else
+        opts.stream = stdin;
+#endif
+      }
+    }
+  }
+
+  if (!(err || done)) {
+    if (!out)
+      out = stdout;
+    if (!(data.jsw = jsonwriter_new(out)))
+      err = zsv_status_error;
+    else {
+      if (data.compact)
+        jsonwriter_set_option(data.jsw, jsonwriter_option_compact);
+      if (data.from_db) {
+        if (opts.stream != stdin) {
+          fclose(opts.stream);
+          opts.stream = NULL;
+        }
+        err = zsv_db2json(input_path, &data.db_tablename, data.jsw);
+      } else {
+        opts.row_handler = zsv_2json_row;
+        opts.ctx = &data;
+        if (zsv_new_with_properties(&opts, custom_prop_handler, input_path, &data.parser) == zsv_status_ok) {
+          zsv_handle_ctrl_c_signal();
+          while (!data.err && !zsv_signal_interrupted && zsv_parse_more(data.parser) == zsv_status_ok)
+            ;
+          zsv_finish(data.parser);
+          zsv_delete(data.parser);
+          jsonwriter_end_all(data.jsw);
+        }
+        err = data.err;
+      }
+    }
+    jsonwriter_delete(data.jsw);
+  }
+
+  zsv_2json_cleanup(&data);
+  if (opts.stream && opts.stream != stdin)
+    fclose(opts.stream);
+  if (out && out != stdout)
+    fclose(out);
+  return err;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/2tsv.c

@@ -0,0 +1,228 @@
+/*
+ * 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 <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#define ZSV_COMMAND 2tsv
+#include "zsv_command.h"
+
+#include <zsv/utils/utf8.h>
+
+enum zsv_2tsv_status {
+  zsv_2tsv_status_ok = 0,
+  zsv_2tsv_status_out_of_memory
+};
+
+#define ZSV_2TSV_BUFF_SIZE 65536
+
+struct static_buff {
+  char *buff; // will be ZSV_2TSV_BUFF_SIZE
+  size_t used;
+  FILE *stream;
+};
+
+struct zsv_2tsv_data {
+  zsv_parser parser;
+  struct static_buff out;
+  unsigned char convert_to_space : 1;
+  unsigned char _ : 7;
+};
+
+__attribute__((always_inline)) static inline void zsv_2tsv_flush(struct static_buff *b) {
+  fwrite(b->buff, b->used, 1, b->stream);
+  b->used = 0;
+}
+
+static inline void zsv_2tsv_write(struct static_buff *b, const unsigned char *s, size_t n) {
+  if (n) {
+    if (VERY_UNLIKELY(n + b->used > ZSV_2TSV_BUFF_SIZE)) {
+      zsv_2tsv_flush(b);
+      if (VERY_UNLIKELY(n > ZSV_2TSV_BUFF_SIZE)) { // n too big, so write directly
+        fwrite(s, n, 1, b->stream);
+        return;
+      }
+    }
+    // n + used < buff size
+    memcpy(b->buff + b->used, s, n);
+    b->used += n;
+  }
+}
+
+// zsv_to_tsv(): convert, if necessary, to text suitable for tab-delimited output.
+// - return NULL if nothing to convert
+// - else, return allocated char * of converted tsv (caller must free), and update *lenp
+// - on error, set *err
+__attribute__((always_inline)) static inline unsigned char *zsv_to_tsv(const unsigned char *utf8, size_t *len,
+                                                                       enum zsv_2tsv_status *err,
+                                                                       char convert_to_space) {
+  // replace tab, newline and lf with \t, \n or \r or backslash
+  size_t do_convert = 0;
+  for (size_t i = 0; i < *len; i++) {
+    if (UNLIKELY(utf8[i] == '\t' || utf8[i] == '\n' || utf8[i] == '\r' || utf8[i] == '\\'))
+      do_convert++;
+  }
+  if (LIKELY(do_convert == 0))
+    return NULL;
+
+  unsigned char *converted = malloc(*len + do_convert + 1);
+  if (!converted)
+    *err = zsv_2tsv_status_out_of_memory;
+  else {
+    size_t j = 0;
+    for (size_t i = 0; i < *len; i++) {
+      if (UNLIKELY(utf8[i] == '\t' || utf8[i] == '\n' || utf8[i] == '\r' || utf8[i] == '\\')) {
+        if (convert_to_space)
+          converted[j++] = utf8[i] == '\\' ? '\\' : ' ';
+        else {
+          converted[j++] = '\\';
+          converted[j++] = utf8[i] == '\t' ? 't' : utf8[i] == '\n' ? 'n' : utf8[i] == '\r' ? 'r' : '\\';
+        }
+      } else
+        converted[j++] = utf8[i];
+    }
+    converted[j] = '\0';
+    *len = j;
+  }
+  return converted;
+}
+
+__attribute__((always_inline)) static inline void zsv_2tsv_cell(struct zsv_2tsv_data *data, unsigned char *utf8_value,
+                                                                size_t len, char no_newline_or_slash,
+                                                                char convert_to_space) {
+  // output cell contents (converted if necessary)
+  if (len) {
+    enum zsv_2tsv_status err = zsv_2tsv_status_ok;
+    if (VERY_LIKELY(no_newline_or_slash && !memchr(utf8_value, '\t', len))) {
+      zsv_2tsv_write(&data->out, utf8_value, len);
+      return;
+    }
+
+    // if we're here, there either definitely an embedded tab, or maybe an embedded \n or \r
+    unsigned char *converted = zsv_to_tsv(utf8_value, &len, &err, convert_to_space);
+    if (converted != NULL) {
+      zsv_2tsv_write(&data->out, converted, len);
+      free(converted);
+    } else if (UNLIKELY(err))
+      fprintf(stderr, "Out of memory!\n");
+    else
+      zsv_2tsv_write(&data->out, utf8_value, len);
+  }
+}
+
+static void zsv_2tsv_row(void *ctx) {
+  struct zsv_2tsv_data *data = ctx;
+  unsigned int cols = zsv_cell_count(data->parser);
+  if (cols) {
+    struct zsv_cell cell = zsv_get_cell(data->parser, 0);
+    struct zsv_cell end = zsv_get_cell(data->parser, cols - 1);
+    unsigned char *start = cell.str;
+    size_t row_len = end.str + end.len - start;
+    char no_newline_or_slash = 0;
+    if (LIKELY(!(memchr(start, '\n', row_len) || memchr(start, '\r', row_len) || memchr(start, '\\', row_len))))
+      no_newline_or_slash = 1;
+
+    const char convert_to_space = data->convert_to_space;
+    zsv_2tsv_cell(ctx, cell.str, cell.len, no_newline_or_slash, convert_to_space);
+    for (unsigned int i = 1; i < cols; i++) {
+      zsv_2tsv_write(&data->out, (const unsigned char *)"\t", 1);
+      cell = zsv_get_cell(data->parser, i);
+      zsv_2tsv_cell(ctx, cell.str, cell.len, no_newline_or_slash, convert_to_space);
+    }
+  }
+  zsv_2tsv_write(&data->out, (const unsigned char *)"\n", 1);
+}
+
+int zsv_2tsv_usage(int rc) {
+  static const char *zsv_2tsv_usage_msg[] = {
+    APPNAME ": convert CSV to TSV (tab-delimited text) suitable for simple-delimiter",
+    "          text processing. By default, embedded tabs or multilines will be escaped",
+    "          to \\t, \\n or \\r, respectively",
+    "",
+    "Usage: " APPNAME " [filename] [options]",
+    "  e.g. " APPNAME " < file.csv > file.tsv",
+    "",
+    "Options:",
+    "  -o <file>         : save output to <file>",
+    "  --convert-to-space: convert embedded \\t, \\n or \\r to space",
+    NULL,
+  };
+
+  for (size_t i = 0; zsv_2tsv_usage_msg[i]; i++)
+    fprintf(stdout, "%s\n", zsv_2tsv_usage_msg[i]);
+
+  return rc;
+}
+
+int ZSV_MAIN_FUNC(ZSV_COMMAND)(int argc, const char *argv[], struct zsv_opts *optsp,
+                               struct zsv_prop_handler *custom_prop_handler) {
+  struct zsv_opts opts = *optsp;
+  struct zsv_2tsv_data data = {0};
+  const char *input_path = NULL;
+  int err = 0;
+  for (int i = 1; !err && i < argc; i++) {
+    if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h"))
+      return zsv_2tsv_usage(0);
+    if (!strcmp(argv[i], "--convert-to-space"))
+      data.convert_to_space = 1;
+    else if (!strcmp(argv[i], "-o") || !strcmp(argv[i], "--output")) {
+      if (++i >= argc)
+        fprintf(stderr, "%s option requires a filename value\n", argv[i - 1]), err = 1;
+      else if (data.out.stream && data.out.stream != stdout)
+        fprintf(stderr, "Output file specified more than once\n"), err = 1;
+      else if (!(data.out.stream = fopen(argv[i], "wb")))
+        fprintf(stderr, "Unable to open for writing: %s\n", argv[i]), err = 1;
+    } else {
+      if (opts.stream)
+        fprintf(stderr, "Input file specified more than once\n"), err = 1;
+      else if (!(opts.stream = fopen(argv[i], "rb")))
+        fprintf(stderr, "Unable to open for reading: %s\n", argv[i]), err = 1;
+      else
+        input_path = argv[i];
+    }
+  }
+
+  if (err) {
+    goto exit_2tsv;
+  }
+
+  if (!opts.stream) {
+#ifdef NO_STDIN
+    fprintf(stderr, "Please specify an input file\n");
+    err = 1;
+    goto exit_2tsv;
+#else
+    opts.stream = stdin;
+#endif
+  }
+
+  if (!data.out.stream)
+    data.out.stream = stdout;
+
+  opts.row_handler = zsv_2tsv_row;
+  opts.ctx = &data;
+  if (zsv_new_with_properties(&opts, custom_prop_handler, input_path, &data.parser) == zsv_status_ok) {
+    char output[ZSV_2TSV_BUFF_SIZE];
+    data.out.buff = output;
+
+    zsv_handle_ctrl_c_signal();
+    enum zsv_status status;
+    while (!zsv_signal_interrupted && (status = zsv_parse_more(data.parser)) == zsv_status_ok)
+      ;
+    zsv_finish(data.parser);
+    zsv_delete(data.parser);
+    zsv_2tsv_flush(&data.out);
+  }
+
+exit_2tsv:
+  if (opts.stream && opts.stream != stdin)
+    fclose(opts.stream);
+  if (data.out.stream && data.out.stream != stdout)
+    fclose(data.out.stream);
+  return err;
+}