zsv 1.3.1 → 1.4.3

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

@@ -1,372 +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>
-
-#define _GNU_SOURCE 1
-#include <string.h>
-#include <ctype.h>
-
-#define ZSV_COMMAND serialize
-#include "zsv_command.h"
-
-#include <zsv/utils/writer.h>
-#include <zsv/utils/string.h>
-
-struct output_header_name {
-  unsigned char *str;
-  size_t len;
-};
-
-struct serialize_additional_column {
-  struct serialize_additional_column *next;
-  unsigned char *name;
-  size_t len;
-  size_t position_plus_1; // 0 = unassigned / not found
-};
-
-struct serialize_data {
-  FILE *in;
-  const char *input_path;
-  zsv_csv_writer csv_writer;
-  zsv_parser parser;
-
-  struct output_header_name *header_names;
-  unsigned int col_count;
-  unsigned int id_column_position;
-
-  char *err_msg;
-
-  struct serialize_additional_column *additional_columns;
-  struct serialize_additional_column **additional_columns_next;
-  struct {
-    const char *value;
-    unsigned char *value_lc; // only used if case_insensitive is set
-    size_t len;
-    unsigned char case_insensitive : 1;
-    unsigned char entire : 1;
-    unsigned _ : 6;
-  } filter;
-  unsigned char use_column_position : 1;
-  unsigned char _ : 7;
-};
-
-static void serialize_write_tuple(struct serialize_data *data, const unsigned char *id, size_t id_len, char id_quoted,
-                                  const unsigned char *colname, size_t colname_len, const unsigned char *s, size_t len,
-                                  char quoted) {
-  // write row ID, column name, cell value
-  zsv_writer_cell(data->csv_writer, 1, id, id_len, id_quoted);
-  zsv_writer_cell(data->csv_writer, 0, colname, colname_len, 0);
-  zsv_writer_cell(data->csv_writer, 0, s, len, quoted);
-
-  // to do: write additional column headers
-  for (struct serialize_additional_column *col = data->additional_columns; col; col = col->next) {
-    if (col->position_plus_1) {
-      struct zsv_cell c = zsv_get_cell(data->parser, col->position_plus_1 - 1);
-      zsv_writer_cell(data->csv_writer, 0, c.str, c.len, c.quoted);
-    }
-  }
-}
-
-static inline void serialize_cell(struct serialize_data *data, struct zsv_cell id, unsigned i) {
-  struct zsv_cell cell = zsv_get_cell(data->parser, i);
-  char skip = 0;
-  if (data->filter.value) {
-    if (data->filter.case_insensitive) {
-      if (data->filter.entire) {
-        int err = 0;
-        skip = zsv_strincmp(cell.str, cell.len, (const unsigned char *)data->filter.value, data->filter.len);
-        if (err) {
-          skip = 1;
-          fprintf(stderr, "Ignoring invalid utf8: %.*s\n", (int)cell.len, cell.str);
-        }
-      } else { // case-insensitive, not-entire-cell. skip if not contains
-        if (data->filter.value_lc) {
-          size_t len = cell.len;
-          unsigned char *tmp = zsv_strtolowercase(cell.str, &len);
-          if (tmp) {
-            skip = !zsv_strstr(tmp, data->filter.value_lc);
-            free(tmp);
-          }
-        }
-      }
-    } else {
-      if (data->filter.entire) // case-sensitive, exact / entire-cell. skip if not equal
-        skip = !(cell.len == data->filter.len && !memcmp(cell.str, data->filter.value, cell.len));
-      else // case-sensitive, not-entire-cell. skip if not contains
-        skip = !memmem(cell.str, cell.len, data->filter.value, data->filter.len);
-    }
-  }
-
-  if (!skip)
-    // write tuple
-    serialize_write_tuple(data, id.str, id.len, id.quoted, data->header_names[i].str, data->header_names[i].len,
-                          cell.str, cell.len, cell.quoted);
-}
-
-static void serialize_row(void *hook);
-
-static void serialize_header(void *hook) {
-  struct serialize_data *data = hook;
-  zsv_set_row_handler(data->parser, serialize_row);
-  if (data->err_msg)
-    return;
-
-  data->col_count = zsv_cell_count(data->parser);
-  if (!data->col_count)
-    asprintf(&data->err_msg, "No columns read in first row; aborting\n");
-  else {
-    // write header
-    struct zsv_cell idCell = zsv_get_cell(data->parser, data->id_column_position);
-    if (idCell.len == 0) {
-      idCell.str = (unsigned char *)"(Blank)";
-      idCell.len = strlen((const char *)idCell.str);
-    }
-    // if we have additional columns, find them and output their header names
-    if (data->additional_columns) {
-      for (struct serialize_additional_column *c = data->additional_columns; c && !data->err_msg; c = c->next) {
-        for (unsigned i = 0; i < data->col_count && !data->err_msg; i++) {
-          struct zsv_cell tmp = zsv_get_cell(data->parser, i);
-
-          if (!zsv_strincmp(tmp.str, tmp.len, c->name, c->len)) {
-            // found
-            c->position_plus_1 = i + 1;
-            break;
-          }
-        }
-        if (!c->position_plus_1)
-          asprintf(&data->err_msg, "Column '%s' not found\n", (char *)c->name);
-      }
-    }
-    if (!data->err_msg) {
-      data->header_names = calloc(data->col_count, sizeof(*data->header_names));
-      if (!data->header_names)
-        asprintf(&data->err_msg, "Out of memory!");
-    }
-
-    for (unsigned i = 1; i < data->col_count && !data->err_msg; i++) {
-      struct zsv_cell cell = zsv_get_cell(data->parser, i);
-      // save the column header name
-      if (data->use_column_position)
-        asprintf((char **)&data->header_names[i].str, "%u", i);
-      else {
-        struct zsv_cell c = zsv_get_cell(data->parser, i);
-        if (i == 0 && c.len == 0)
-          data->header_names[i].str = (unsigned char *)strdup("(Blank)");
-        else
-          data->header_names[i].str = zsv_writer_str_to_csv(cell.str, cell.len);
-      }
-
-      if (data->header_names[i].str)
-        data->header_names[i].len = strlen((const char *)data->header_names[i].str);
-      else if (cell.len)
-        asprintf(&data->err_msg, "Out of memory!");
-    }
-
-    if (!data->err_msg) {
-      // print the output table header
-      serialize_write_tuple(data, idCell.str, idCell.len, idCell.quoted, (const unsigned char *)"Column",
-                            strlen("Column"), (const unsigned char *)"Value", strlen("Value"), 0);
-
-      if (data->use_column_position) {
-        // process the header row as if it was a data row
-        // output ID cell
-        struct zsv_cell cell = zsv_get_cell(data->parser, data->id_column_position);
-        serialize_write_tuple(data, (const unsigned char *)"Header", strlen("Header"), 0, (const unsigned char *)"0", 1,
-                              cell.str, cell.len, cell.quoted);
-
-        // output other cells
-        for (unsigned i = 0; i < data->col_count; i++) {
-          if (i != data->id_column_position) {
-            cell = zsv_get_cell(data->parser, i);
-            serialize_write_tuple(data, (const unsigned char *)"Header", strlen("Header"), 0, data->header_names[i].str,
-                                  data->header_names[i].len, cell.str, cell.len, cell.quoted);
-          }
-        }
-      }
-    }
-  }
-}
-
-static void serialize_row(void *hook) {
-  struct serialize_data *data = hook;
-  if (data->err_msg)
-    return;
-
-  // get the row id
-  struct zsv_cell id = zsv_get_cell(data->parser, data->id_column_position);
-
-  unsigned j = zsv_cell_count(data->parser);
-  for (unsigned i = 0; i < j && i < data->col_count; i++)
-    if (i != data->id_column_position)
-      serialize_cell(data, id, i);
-}
-
-const char *serialize_usage_msg[] = {
-  APPNAME ": serialize a CSV file into row/column/value triplets",
-  "",
-  "Usage: " APPNAME " [<filename>]",
-  "",
-  "Options:",
-  "  -b                     : output with BOM",
-  "  -f,--filter <value>    : only output cells with text that contains the given value",
-  "  -e,--entire            : match the entire cell's content (only applicable with -f)",
-  "  -i,--case-insensitive  : use case-insensitive match for the filter value",
-  "  --id-column <n>        : the 1-based position of the column to use as the identifier (default=1, max=2000)",
-  "  -p,--position          : output column position instead of name; the second column",
-  "                           will be position 1, and the first row will be treated as a",
-  "                           normal data row",
-  "  -a,--add <column name> : add additional columns to output. may be specified",
-  "                           multiple times for multiple additional columns",
-  NULL,
-};
-
-static int serialize_usage(void) {
-  for (size_t i = 0; serialize_usage_msg[i]; i++)
-    fprintf(stdout, "%s\n", serialize_usage_msg[i]);
-  return 1;
-}
-
-static void serialize_cleanup(struct serialize_data *data) {
-  zsv_writer_delete(data->csv_writer);
-
-  free(data->filter.value_lc);
-  free(data->err_msg);
-
-  if (data->header_names) {
-    for (unsigned int i = 0; i < data->col_count; i++)
-      free(data->header_names[i].str);
-    free(data->header_names);
-  }
-
-  if (data->in && data->in != stdin)
-    fclose(data->in);
-
-  for (struct serialize_additional_column *next, *c = data->additional_columns; c; c = next) {
-    next = c->next;
-    free(c->name);
-    free(c);
-  }
-}
-
-static int serialize_append_additional_column(struct serialize_data *data, const char *name) {
-  struct serialize_additional_column *c = calloc(1, sizeof(*c));
-  if (c) {
-    if ((c->name = (unsigned char *)strdup(name))) {
-      c->len = strlen((char *)c->name);
-      if (!data->additional_columns)
-        data->additional_columns = c;
-      else
-        *data->additional_columns_next = c;
-      data->additional_columns_next = &c->next;
-      return 0;
-    }
-    free(c);
-  }
-  return 1;
-}
-
-int ZSV_MAIN_FUNC(ZSV_COMMAND)(int argc, const char *argv[], struct zsv_opts *opts,
-                               struct zsv_prop_handler *custom_prop_handler) {
-  if (argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
-    serialize_usage();
-    return 0;
-  } else {
-    struct zsv_csv_writer_options writer_opts = zsv_writer_get_default_opts();
-    struct serialize_data data = {0};
-    int err = 0;
-    for (int arg_i = 1; !err && arg_i < argc; arg_i++) {
-      const char *arg = argv[arg_i];
-      if (!strcmp(arg, "-f") || !strcmp(arg, "--filter")) {
-        if (arg_i + 1 < argc)
-          data.filter.value = argv[++arg_i];
-        else {
-          fprintf(stderr, "filter option requires a value\n");
-          err = 1;
-        }
-      } else if (!strcmp(arg, "-a") || !strcmp(arg, "--add")) {
-        if (arg_i + 1 < argc)
-          err = serialize_append_additional_column(&data, argv[++arg_i]);
-        else {
-          fprintf(stderr, "%s option requires a value\n", argv[arg_i]);
-          err = 1;
-        }
-      } else if (!strcmp(arg, "-i") || !strcmp(arg, "--case-insensitive"))
-        data.filter.case_insensitive = 1;
-      else if (!strcmp(arg, "--id-column")) {
-        if (arg_i + 1 < argc && atoi(argv[arg_i + 1]) > 0 && atoi(argv[arg_i + 1]) <= 2000)
-          data.id_column_position = atoi(argv[++arg_i]) - 1;
-        else {
-          fprintf(stderr, "%s option requires a value between 1 and 2000\n", argv[arg_i]);
-          err = 1;
-        }
-      } else if (!strcmp(arg, "-p") || !strcmp(arg, "--position"))
-        data.use_column_position = 1;
-      else if (!strcmp(arg, "-e") || !strcmp(arg, "--entire"))
-        data.filter.entire = 1;
-      else if (!strcmp(argv[arg_i], "-b"))
-        writer_opts.with_bom = 1;
-      else if (data.in) {
-        err = 1;
-        fprintf(stderr, "Input file specified twice, or unrecognized argument: %s\n", argv[arg_i]);
-      } else if (!(data.in = fopen(argv[arg_i], "rb"))) {
-        err = 1;
-        fprintf(stderr, "Could not open for reading: %s\n", argv[arg_i]);
-      } else
-        data.input_path = argv[arg_i];
-    }
-
-    if (data.filter.value) {
-      data.filter.len = strlen(data.filter.value);
-      if (data.filter.case_insensitive)
-        data.filter.value_lc = zsv_strtolowercase((const unsigned char *)data.filter.value, &data.filter.len);
-    }
-
-    if (!data.in) {
-#ifdef NO_STDIN
-      fprintf(stderr, "Please specify an input file\n");
-      err = 1;
-#else
-      data.in = stdin;
-#endif
-    }
-
-    if (err) {
-      serialize_cleanup(&data);
-      return 1;
-    }
-
-    opts->row_handler = serialize_header;
-    opts->stream = data.in;
-    const char *input_path = data.input_path;
-
-    opts->ctx = &data;
-    data.csv_writer = zsv_writer_new(&writer_opts);
-    if (zsv_new_with_properties(opts, custom_prop_handler, input_path, &data.parser) != zsv_status_ok ||
-        !data.csv_writer) {
-      serialize_cleanup(&data);
-      return 1;
-    }
-
-    // create a local csv writer buff for faster performance
-    unsigned char writer_buff[64];
-    zsv_writer_set_temp_buff(data.csv_writer, writer_buff, sizeof(writer_buff));
-
-    // process the input data
-    zsv_handle_ctrl_c_signal();
-    while (!zsv_signal_interrupted && zsv_parse_more(data.parser) == zsv_status_ok)
-      ;
-
-    if (data.err_msg)
-      fprintf(stderr, "Error: %s\n", data.err_msg);
-    zsv_finish(data.parser);
-    zsv_delete(data.parser);
-    serialize_cleanup(&data);
-  }
-  return 0;
-}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/curses.h

@@ -1,15 +0,0 @@
-#if defined(WIN32) || defined(_WIN32)
-#ifdef HAVE_NCURSESW
-#include <ncursesw/ncurses.h>
-#else
-#include <ncurses/ncurses.h>
-#endif // HAVE_NCURSESW
-#else
-#if __has_include(<ncursesw/curses.h>)
-#include <ncursesw/curses.h>
-#elif __has_include(<curses.h>)
-#include <curses.h>
-#else
-#error Cannot find ncurses include file!
-#endif
-#endif

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/cursor.c

@@ -1,119 +0,0 @@
-static size_t input_offset_top(void) {
-  return 0;
-}
-
-static size_t input_offset_bottom(struct zsvsheet_input_dimensions *input_dims,
-                                  size_t buffer_row_count // number of rows in the buffer, w/o regard to header
-) {
-  return input_dims->row_count - buffer_row_count;
-}
-
-static size_t input_offset_centered(struct zsvsheet_input_dimensions *input_dims,
-                                    size_t buffer_row_count, // number of rows in the buffer, w/o regard to header
-                                    size_t target_raw_ix     // raw row index starting at zero, w/o regard to header
-) {
-  if (input_dims->row_count <= buffer_row_count) // entire input fits in buffer
-    return input_offset_top();
-  size_t buffer_half_row_count = buffer_row_count / 2;
-  if (target_raw_ix <= buffer_half_row_count) // target is at the top of the file
-    return input_offset_top();
-  if (target_raw_ix + buffer_half_row_count > input_dims->row_count) // target is at the end of the file
-    return input_offset_bottom(input_dims, buffer_row_count);
-  return target_raw_ix - buffer_half_row_count;
-}
-
-// zsvsheet_goto_input_raw_row
-// return non-zero if buffer must be reloaded
-/*
-      ------- INPUT
-      0  | header   | => BUFFER[BHEADSPAN]
-      1  | ...      | => BUFFER[BHEADSPAN]
-      2  | data
-      ------- BUFFER[BHEADSPAN:]
-ioff->3  |
-      4  |
-      ------- DISPLAY DATA
-      5  | boff-> | displayed data 1
-      6  |        | displayed data 2
-      ...
-      N+4|        | displayed data M = max_y - BHEADSPAN - 1
-      -------
- */
-
-static void set_window_to_cursor(struct zsvsheet_rowcol *buff_offset, size_t target_raw_row,
-                                 struct zsvsheet_rowcol *input_offset, size_t input_header_span,
-                                 struct zsvsheet_display_dimensions *ddims, size_t cursor_row) {
-  // assume that input_offset->row is fixed; set buff_offset->row
-  if (target_raw_row + ddims->header_span >= input_offset->row + cursor_row + input_header_span)
-    buff_offset->row = target_raw_row - input_offset->row - cursor_row + ddims->header_span - input_header_span;
-  else
-    buff_offset->row = 0;
-}
-
-static int zsvsheet_goto_input_raw_row(struct zsvsheet_ui_buffer *uib, size_t input_raw_num, size_t input_header_span,
-                                       struct zsvsheet_display_dimensions *ddims, size_t final_cursor_position) {
-  zsvsheet_screen_buffer_t buffer = uib->buffer;
-  struct zsvsheet_rowcol *input_offset = &uib->input_offset;
-  struct zsvsheet_rowcol *buff_offset = &uib->buff_offset;
-  struct zsvsheet_input_dimensions *input_dims = &uib->dimensions;
-  size_t *cursor_rowp = &uib->cursor_row;
-
-  size_t buffer_rows = zsvsheet_screen_buffer_rows(buffer);
-  int update_buffer = 0;
-  if (input_raw_num < input_offset->row + input_header_span                      // move the buffer up
-      || input_raw_num + input_header_span + 1 > input_offset->row + buffer_rows // move the buffer down
-  ) {
-    input_offset->row = input_offset_centered(input_dims, buffer_rows, input_raw_num);
-    update_buffer = 1;
-  } else if (!(input_raw_num >= input_offset->row + buff_offset->row &&
-               input_raw_num <=
-                 input_offset->row + buff_offset->row + (ddims->rows + ddims->header_span + ddims->footer_span))) {
-    // buffer already has the data but display window needs to move
-  } else {
-    if (final_cursor_position == (size_t)-1) {
-      // just move the cursor however much we needed to shift
-      size_t current = zsvsheet_get_input_raw_row(input_offset, buff_offset, *cursor_rowp);
-      final_cursor_position = *cursor_rowp + input_raw_num - current;
-    }
-  }
-  if (final_cursor_position == (size_t)-1)
-    final_cursor_position = ddims->header_span;
-  if (final_cursor_position < ddims->header_span)
-    final_cursor_position = ddims->header_span;
-  if (final_cursor_position > ddims->rows - ddims->footer_span - 1)
-    final_cursor_position = ddims->rows - ddims->footer_span - 1;
-  *cursor_rowp = final_cursor_position;
-
-  // we may still need to update the buffer if the row we are jumping to will be
-  // in the middle of the screen and therefore we still want to display additional
-  // rows, and those additional rows are not loaded into the buffer
-  if (!update_buffer && final_cursor_position < ddims->rows - 1) {
-    size_t last_raw_row_to_display = input_raw_num + (ddims->rows - 1 - final_cursor_position);
-    if (last_raw_row_to_display > input_dims->row_count)
-      last_raw_row_to_display = input_dims->row_count;
-    if (last_raw_row_to_display < input_offset->row + input_header_span                      // move the buffer up
-        || last_raw_row_to_display + input_header_span + 1 > input_offset->row + buffer_rows // move the buffer down
-    ) {
-      input_offset->row = input_offset_centered(input_dims, buffer_rows, input_raw_num);
-      update_buffer = 1;
-    }
-  }
-  set_window_to_cursor(buff_offset, input_raw_num, input_offset, input_header_span, ddims, *cursor_rowp);
-  return update_buffer;
-}
-
-static int cursor_right(int max_x, unsigned display_width, size_t max_col_count, size_t *cursor_colp,
-                        size_t *start_colp) {
-  size_t cursor_col = *cursor_colp;
-  size_t start_col = *start_colp;
-  int rc = 1;
-  if (cursor_col + 1 < max_x / display_width && start_col + cursor_col + 1 < max_col_count) {
-    cursor_col++;
-  } else if ((start_col + max_x / display_width) < max_col_count) {
-    start_col++;
-  } else
-    rc = 0;
-  *cursor_colp = cursor_col;
-  *start_colp = start_col;
-  return rc;
-}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/errors.c

@@ -1,45 +0,0 @@
-struct zsvsheet_errors_data {
-  struct zsvsheet_ui_buffer *uib;
-  size_t rows_fetched;
-  const char *row_data[1];
-};
-
-const unsigned char **zsvsheet_errors_header(void *d) {
-  struct zsvsheet_errors_data *data = d;
-  data->row_data[0] = "Error";
-  return (const unsigned char **)data->row_data;
-}
-
-const unsigned char *zsvsheet_errors_status(void *_) {
-  (void)(_);
-  return (const unsigned char *)"<esc> to exit, then :errors-clear to clear";
-}
-
-const unsigned char **zsvsheet_errors_row(void *d) {
-  struct zsvsheet_errors_data *data = d;
-  while (data->rows_fetched < data->uib->parse_errs.count) {
-    data->row_data[0] = data->uib->parse_errs.errors[data->rows_fetched];
-    data->rows_fetched++;
-    if (data->row_data[0] && *data->row_data[0])
-      return (const unsigned char **)data->row_data;
-  }
-  return NULL;
-}
-
-static zsvsheet_status zsvsheet_errors_handler(struct zsvsheet_proc_context *ctx) {
-  struct zsvsheet_errors_data d = {0};
-  d.uib = zsvsheet_buffer_current(ctx);
-  if (!d.uib)
-    return zsvsheet_status_error;
-  if (ctx->proc_id == zsvsheet_builtin_proc_errors_clear) {
-    uib_parse_errs_clear(&d.uib->parse_errs);
-    return zsvsheet_status_ok;
-  }
-  if (d.uib->parse_errs.count == 0) {
-    zsvsheet_ui_buffer_set_status(d.uib, "No errors");
-    return zsvsheet_status_ok;
-  }
-  const size_t cols = 1;
-  return zsvsheet_buffer_new_static(ctx, cols, zsvsheet_errors_header, zsvsheet_errors_row, zsvsheet_errors_status, &d,
-                                    NULL);
-}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/file.c

@@ -1,63 +0,0 @@
-int zsvsheet_ui_buffer_open_file_opts(struct zsvsheet_ui_buffer_opts *uibopts,
-                                      struct zsv_prop_handler *custom_prop_handler,
-                                      struct zsvsheet_ui_buffer **ui_buffer_stack_bottom,
-                                      struct zsvsheet_ui_buffer **ui_buffer_stack_top) {
-  struct zsvsheet_opts zsvsheet_opts = {0};
-  struct zsvsheet_screen_buffer_opts bopts = {0};
-  struct zsvsheet_ui_buffer *tmp_ui_buffer = NULL;
-
-  if (!uibopts->buff_opts)
-    uibopts->buff_opts = &bopts;
-
-  int err = 0;
-  if ((err = read_data(&tmp_ui_buffer, uibopts, 0, 0, 0, &zsvsheet_opts, custom_prop_handler)) != 0 || !tmp_ui_buffer ||
-      !tmp_ui_buffer->buff_used_rows) {
-    zsvsheet_ui_buffer_delete(tmp_ui_buffer);
-    if (err)
-      return err;
-    return -1;
-  }
-  tmp_ui_buffer->cursor_row = 1; // first row is header
-  zsvsheet_ui_buffer_push(ui_buffer_stack_bottom, ui_buffer_stack_top, tmp_ui_buffer);
-
-  return 0;
-}
-
-int zsvsheet_ui_buffer_open_file(const char *filename, const struct zsv_opts *zsv_optsp,
-                                 struct zsv_prop_handler *custom_prop_handler,
-                                 struct zsvsheet_ui_buffer **ui_buffer_stack_bottom,
-                                 struct zsvsheet_ui_buffer **ui_buffer_stack_top) {
-  struct zsvsheet_ui_buffer_opts uibopts = {0};
-  uibopts.filename = filename;
-  if (zsv_optsp)
-    uibopts.zsv_opts = *zsv_optsp;
-
-  return zsvsheet_ui_buffer_open_file_opts(&uibopts, custom_prop_handler, ui_buffer_stack_bottom, ui_buffer_stack_top);
-}
-
-/****** API ******/
-
-/**
- * Open a tabular file as a new buffer
- */
-zsvsheet_status zsvsheet_open_file(struct zsvsheet_proc_context *ctx, const char *filepath, struct zsv_opts *zopts) {
-  struct zsvsheet_sheet_context *state = (struct zsvsheet_sheet_context *)ctx->subcommand_context;
-  struct zsvsheet_display_info *di = &state->display_info;
-  if (!di || !di->ui_buffers.base || !di->ui_buffers.current)
-    return zsvsheet_status_error;
-  int err = zsvsheet_ui_buffer_open_file(filepath, zopts, NULL, di->ui_buffers.base, di->ui_buffers.current);
-  if (err)
-    return zsvsheet_status_error;
-  return zsvsheet_status_ok;
-}
-
-zsvsheet_status zsvsheet_open_file_opts(struct zsvsheet_proc_context *ctx, struct zsvsheet_ui_buffer_opts *opts) {
-  struct zsvsheet_sheet_context *state = (struct zsvsheet_sheet_context *)ctx->subcommand_context;
-  struct zsvsheet_display_info *di = &state->display_info;
-  if (!di || !di->ui_buffers.base || !di->ui_buffers.current)
-    return zsvsheet_status_error;
-  int err = zsvsheet_ui_buffer_open_file_opts(opts, NULL, di->ui_buffers.base, di->ui_buffers.current);
-  if (err)
-    return zsvsheet_status_error;
-  return zsvsheet_status_ok;
-}

data/ext/zsv/vendor/zsv-1.3.0/app/sheet/file.h

@@ -1,12 +0,0 @@
-#ifndef ZSVSHEET_FILE_H
-#define ZSVSHEET_FILE_H
-
-int zsvsheet_ui_buffer_open_file(const char *filename, const struct zsv_opts *zsv_optsp,
-                                 struct zsv_prop_handler *custom_prop_handler,
-                                 struct zsvsheet_ui_buffer **ui_buffer_stack_bottom,
-                                 struct zsvsheet_ui_buffer **ui_buffer_stack_top);
-
-zsvsheet_status zsvsheet_open_file_opts(struct zsvsheet_proc_context *ctx, struct zsvsheet_ui_buffer_opts *opts);
-zsvsheet_status zsvsheet_open_file(struct zsvsheet_proc_context *ctx, const char *filepath, struct zsv_opts *zopts);
-
-#endif