zsv 1.3.0

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

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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,12 @@
+#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