zsv 1.3.0

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

@@ -0,0 +1,166 @@
+#include <stdlib.h>
+#include <pthread.h>
+#include <string.h>
+#include <zsv/utils/mem.h>
+#include <zsv/ext/sheet.h>
+#include "transformation.h"
+#include "handlers_internal.h"
+
+#ifdef HAVE_PCRE2_8
+#include "../utils/pcre2-8/pcre2-8.h"
+#endif
+
+struct filtered_file_ctx {
+  char *filter;
+  size_t filter_len;
+#ifdef HAVE_PCRE2_8
+  regex_handle_t *regex;
+#endif
+  size_t row_num; // 1-based row number (1 = header row, 2 = first data row)
+  size_t passed;
+  size_t single_row_ix_plus_1;
+  unsigned char seen_header : 1;
+  unsigned char has_row_num : 1;
+  unsigned char _ : 7;
+};
+
+// zsvsheet_nullify_row_buff: return 1 if row has overwrite
+static int zsvsheet_nullify_row_buff(zsv_parser z) {
+  unsigned int j = zsv_cell_count(z);
+  unsigned char *end = NULL;
+  int have_overwrite = 0;
+  for (unsigned int i = 0; i < j; i++) {
+    struct zsv_cell cell = zsv_get_cell(z, i);
+    if (cell.overwritten)
+      have_overwrite = 1;
+    if (end) {
+      while (end < cell.str) {
+        *end = '\0';
+        end++;
+      }
+    }
+    end = cell.str + cell.len;
+  }
+  return have_overwrite;
+}
+
+static void zsvsheet_save_filtered_file_row_handler(zsvsheet_transformation trn) {
+  struct filtered_file_ctx *ctx = zsvsheet_transformation_user_context(trn);
+  zsv_parser parser = zsvsheet_transformation_parser(trn);
+  zsv_csv_writer writer = zsvsheet_transformation_writer(trn);
+  size_t col_count = zsv_cell_count(parser);
+  const size_t single_row_ix_plus_1 = ctx->single_row_ix_plus_1;
+
+  ctx->row_num++;
+  if (col_count == 0)
+    return;
+  if (ctx->seen_header) {
+    size_t start_ix = 0;
+    if (single_row_ix_plus_1) {
+      col_count = single_row_ix_plus_1;
+      start_ix = single_row_ix_plus_1 - 1;
+      if (ctx->has_row_num)
+        col_count++, start_ix++;
+    }
+    int have_overwrite = single_row_ix_plus_1 ? 0 : zsvsheet_nullify_row_buff(parser);
+    if (have_overwrite || single_row_ix_plus_1) {
+      // we need to do this cell by cell
+      for (unsigned int i = start_ix; i < col_count; i++) {
+        struct zsv_cell cell = zsv_get_cell(parser, i);
+        const unsigned char *start = cell.str;
+        const unsigned char *end = cell.str + cell.len;
+        if (cell.len) {
+#ifdef HAVE_PCRE2_8
+          if (ctx->regex) {
+            if (!zsv_pcre2_8_match(ctx->regex, start, end - start))
+              return; // no match: don't save this row
+          } else
+#endif
+            if (!memmem(start, end - start, ctx->filter, ctx->filter_len))
+            return; // no match: don't save this row
+        }
+      }
+    } else {
+      struct zsv_cell first_cell = zsv_get_cell(parser, 0);
+      struct zsv_cell last_cell = zsv_get_cell(parser, col_count - 1);
+      const unsigned char *start = first_cell.str;
+      const unsigned char *end = last_cell.str + last_cell.len;
+      if (end > start) {
+#ifdef HAVE_PCRE2_8
+        if (ctx->regex) {
+          if (!zsv_pcre2_8_match(ctx->regex, start, end - start))
+            return; // no match: don't save this row
+        } else
+#endif
+          if (!memmem(start, end - start, ctx->filter, ctx->filter_len))
+          return; // no match: don't save this row
+      }
+    }
+  } else {
+    struct zsv_cell first_cell = zsv_get_cell(parser, 0);
+    ctx->seen_header = 1;
+    /// just use uibuff->has_row_num?
+    if (first_cell.len == ZSVSHEET_ROWNUM_HEADER_LEN && !memcmp(first_cell.str, ZSVSHEET_ROWNUM_HEADER, first_cell.len))
+      ctx->has_row_num = 1;
+  }
+
+  char row_started = 0;
+  if (!ctx->has_row_num) {
+    // create our own rownum column
+    row_started = 1;
+    if (ctx->row_num == 1)
+      zsv_writer_cell_s(writer, 1, (const unsigned char *)"Row #", 0); // to do: consolidate "Row #"
+    else
+      zsv_writer_cell_zu(writer, 1, ctx->row_num - 1);
+  }
+
+  col_count = zsv_cell_count(parser);
+  for (size_t i = 0; i < col_count; i++) {
+    struct zsv_cell cell = zsv_get_cell(parser, i);
+    zsv_writer_cell(writer, i == 0 && row_started == 0, cell.str, cell.len, cell.quoted);
+  }
+
+  ctx->passed++;
+}
+
+static void zsvsheet_filter_file_on_done(zsvsheet_transformation trn) {
+  struct filtered_file_ctx *ctx = zsvsheet_transformation_user_context(trn);
+  struct zsvsheet_ui_buffer *uib = trn->ui_buffer;
+
+  char *status = NULL;
+  asprintf(&status, "(%zu filtered rows) ", ctx->passed - 1);
+
+  pthread_mutex_lock(&uib->mutex);
+  char *old_status = uib->status;
+  uib->status = status;
+  pthread_mutex_unlock(&uib->mutex);
+
+  free(old_status);
+#ifdef HAVE_PCRE2_8
+  zsv_pcre2_8_delete(ctx->regex);
+#endif
+  free(ctx->filter);
+}
+
+static enum zsvsheet_status zsvsheet_filter_file(zsvsheet_proc_context_t proc_ctx, const char *row_filter,
+                                                 size_t single_row_ix_plus_1) {
+  struct filtered_file_ctx ctx = {
+    .seen_header = 0,
+    .row_num = 0,
+    .passed = 0,
+    .has_row_num = 0,
+    .filter = strdup(row_filter),
+    .filter_len = strlen(row_filter),
+#ifdef HAVE_PCRE2_8
+    .regex = row_filter && *row_filter == '/' && row_filter[1] ? zsv_pcre2_8_new(row_filter + 1, 0) : NULL,
+    .single_row_ix_plus_1 = single_row_ix_plus_1,
+#endif
+  };
+  struct zsvsheet_buffer_transformation_opts opts = {
+    .user_context = zsv_memdup(&ctx, sizeof(ctx)),
+    .row_handler = zsvsheet_save_filtered_file_row_handler,
+    .on_done = zsvsheet_filter_file_on_done,
+  };
+
+  return zsvsheet_push_transformation(proc_ctx, opts);
+}

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

@@ -0,0 +1,214 @@
+#include "file.h"
+#include "procedure.h"
+
+static void zsvsheet_key_handlers_delete(struct zsvsheet_key_data **root, struct zsvsheet_key_data ***nextp) {
+  for (struct zsvsheet_key_data *next, *e = *root; e; e = next) {
+    next = e->next;
+    free(e->long_name);
+    free(e);
+  }
+  *root = NULL;
+  *nextp = &(*root)->next;
+}
+
+struct zsvsheet_key_data *zsvsheet_get_registered_key_handler(int ch, const char *long_name,
+                                                              struct zsvsheet_key_data *root) {
+  for (struct zsvsheet_key_data *kh = root; kh; kh = kh->next)
+    if (ch == kh->ch || (long_name && kh->long_name && !strcmp(long_name, kh->long_name)))
+      return kh;
+  return NULL;
+}
+
+/****** API ******/
+
+/**
+ * Set the subcommand prompt
+ */
+zsvsheet_status zsvsheet_subcommand_prompt(zsvsheet_subcommand_context_t ctx, const char *fmt, ...) {
+  va_list argv;
+  va_start(argv, fmt);
+  int n = vsnprintf(ctx->prompt, sizeof(ctx->prompt), fmt, argv);
+  va_end(argv);
+  if (n > 0 && (size_t)n < sizeof(ctx->prompt))
+    return zsvsheet_status_ok;
+  return zsvsheet_status_error;
+}
+
+/**
+ * Set a status message
+ */
+zsvsheet_status zsvsheet_set_status(struct zsvsheet_proc_context *ctx, const char *fmt, ...) {
+  struct zsvsheet_sheet_context *state = (struct zsvsheet_sheet_context *)ctx->subcommand_context;
+  va_list argv;
+  va_start(argv, fmt);
+  vsnprintf(zsvsheet_status_text, sizeof(zsvsheet_status_text), fmt, argv);
+  va_end(argv);
+  // note: if (n < (int)sizeof(zsvsheet_status_text)), then we just ignore
+  zsvsheet_display_status_text(state->display_info.dimensions);
+  return zsvsheet_status_ok;
+}
+
+/**
+ * Get the key press that triggered this subcommand handler
+ */
+int zsvsheet_ext_keypress(zsvsheet_proc_context_t ctx) {
+  if (ctx && ctx->invocation.type == zsvsheet_proc_invocation_type_keypress)
+    return ctx->invocation.u.keypress.ch;
+  return -1;
+}
+
+/**
+ * Get the current buffer
+ */
+zsvsheet_buffer_t zsvsheet_buffer_current(struct zsvsheet_proc_context *ctx) {
+  struct zsvsheet_sheet_context *state = (struct zsvsheet_sheet_context *)ctx->subcommand_context;
+  return state && state->display_info.ui_buffers.current ? *state->display_info.ui_buffers.current : NULL;
+}
+
+/**
+ * Get the prior buffer
+ */
+zsvsheet_buffer_t zsvsheet_buffer_prior(zsvsheet_buffer_t b) {
+  struct zsvsheet_ui_buffer *uib = b;
+  return uib ? uib->prior : NULL;
+}
+
+/**
+ * Get the filename associated with a buffer
+ */
+const char *zsvsheet_buffer_filename(zsvsheet_buffer_t h) {
+  struct zsvsheet_ui_buffer *uib = h;
+  return uib ? uib->filename : NULL;
+}
+
+/**
+ * Get the data file associated with a buffer. This might not be the same as the filename,
+ * such as when the data has been filtered
+ */
+const char *zsvsheet_buffer_data_filename(zsvsheet_buffer_t h) {
+  struct zsvsheet_ui_buffer *uib = h;
+  if (uib)
+    return uib->data_filename ? uib->data_filename : uib->filename;
+  return NULL;
+}
+
+/**
+ * Set custom handler on Enter key press
+ *
+ * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+ */
+enum zsv_ext_status zsvsheet_buffer_on_newline(zsvsheet_buffer_t h,
+                                               zsvsheet_status (*on_newline)(zsvsheet_proc_context_t)) {
+  if (h)
+    ((struct zsvsheet_ui_buffer *)h)->on_newline = on_newline;
+  return zsv_ext_status_ok;
+}
+
+/**
+ * Get the currently-selected cell
+ */
+zsvsheet_status zsvsheet_buffer_get_selected_cell(zsvsheet_buffer_t h, struct zsvsheet_rowcol *rc) {
+  struct zsvsheet_ui_buffer *uib = h;
+  if (!uib)
+    return zsvsheet_status_error;
+  rc->row = uib->cursor_row + uib->input_offset.row + uib->buff_offset.row;
+  rc->col = uib->cursor_col + uib->input_offset.col + uib->buff_offset.col;
+  return zsvsheet_status_ok;
+}
+
+/**
+ * Set custom context
+ * @param on_close optional callback to invoke when the buffer is closed
+ *
+ * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+ */
+enum zsv_ext_status zsvsheet_buffer_set_ctx(zsvsheet_buffer_t h, void *ctx, void (*on_close)(void *)) {
+  if (h) {
+    // TO DO: return zsv_ext_status_not_permitted if this buffer is protected and the caller is not authorized
+    struct zsvsheet_ui_buffer *uib = h;
+    uib->ext_ctx = ctx;
+    uib->ext_on_close = on_close;
+  }
+  return zsv_ext_status_ok;
+}
+
+/**
+ * Get custom context previously set via zsvsheet_buffer_set_ctx()
+ */
+enum zsv_ext_status zsvsheet_buffer_get_ctx(zsvsheet_buffer_t h, void **ctx_out) {
+  // TO DO: return zsv_ext_status_not_permitted if this buffer is protected and the caller is not authorized
+  *ctx_out = h ? ((struct zsvsheet_ui_buffer *)h)->ext_ctx : NULL;
+  return zsv_ext_status_ok;
+}
+
+/** Set callback for fetching cell attributes **/
+void zsvsheet_buffer_set_cell_attrs(zsvsheet_buffer_t h,
+                                    enum zsv_ext_status (*get_cell_attrs)(void *ext_ctx, zsvsheet_cell_attr_t *,
+                                                                          size_t start_row, size_t row_count,
+                                                                          size_t col_count)) {
+  if (h) {
+    struct zsvsheet_ui_buffer *buff = h;
+    buff->get_cell_attrs = get_cell_attrs;
+    zsvsheet_ui_buffer_update_cell_attr(buff);
+  }
+}
+
+/** Get zsv_opts use to open the buffer's data file **/
+struct zsv_opts zsvsheet_buffer_get_zsv_opts(zsvsheet_buffer_t h) {
+  if (h) {
+    struct zsvsheet_ui_buffer *buff = h;
+    return buff->zsv_opts;
+  }
+  struct zsv_opts opts = {0};
+  return opts;
+}
+
+/**
+ * Get information about the type and state of the buffer and its backing file.
+ *
+ * This returns a copy of the information. Properties relating to the index and transformations
+ * are updated by background threads and may be stale upon return. However they only ever
+ * transition from false to true.
+ */
+struct zsvsheet_buffer_info_internal zsvsheet_buffer_info_internal(zsvsheet_buffer_t h) {
+  struct zsvsheet_buffer_info_internal info = {0};
+
+  if (h) {
+    struct zsvsheet_ui_buffer *b = h;
+
+    pthread_mutex_lock(&b->mutex);
+    info.index_started = b->index_started;
+    info.index_ready = b->index_ready;
+    info.write_in_progress = b->write_in_progress;
+    info.write_done = b->write_done;
+    pthread_mutex_unlock(&b->mutex);
+  }
+
+  return info;
+}
+
+struct zsvsheet_buffer_data zsvsheet_buffer_info(zsvsheet_buffer_t h) {
+  struct zsvsheet_buffer_data d = {0};
+  struct zsvsheet_ui_buffer *b = h;
+  if (b) {
+    d.has_row_num = b->has_row_num;
+  }
+  return d;
+}
+
+/**
+ * Get the corresponding cell attributes for the given profile
+ */
+zsvsheet_cell_attr_t zsvsheet_cell_profile_attrs(enum zsvsheet_cell_profile_t t) {
+  switch (t) {
+  case zsvsheet_cell_attr_profile_link:
+#ifndef A_ITALIC
+    return A_BOLD;
+#else
+    return A_ITALIC | A_BOLD;
+#endif
+  default:
+    break;
+  }
+  return zsvsheet_cell_attr_profile_none;
+}

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

@@ -0,0 +1,128 @@
+#ifndef ZSVSHEET_HANDLER_INTERNAL_H
+#define ZSVSHEET_HANDLER_INTERNAL_H
+
+struct zsvsheet_context {
+  const char *subcommand_value; // e.g. "/path/to/myfile.csv"
+  int ch;                       // key press value from getch()
+  struct {
+    struct zsvsheet_ui_buffer **base;
+    struct zsvsheet_ui_buffer **current;
+  } ui_buffers;
+  const struct zsvsheet_display_dimensions *display_dims;
+  struct zsv_prop_handler *custom_prop_handler;
+};
+
+struct zsvsheet_subcommand_context {
+  int ch; // keyboard shortcut
+  struct zsvsheet_ui_buffer *ui_buffers;
+  struct zsvsheet_ui_buffer *current_ui_buffer;
+  char prompt[256];
+};
+
+struct zsvsheet_key_data {
+  struct zsvsheet_key_data *next;
+  int ch;          // from getch()
+  char *long_name; // command name that can be manually invoked via run-command <cmd>
+  zsvsheet_status (*subcommand_handler)(zsvsheet_subcommand_context_t);
+  zsvsheet_status (*handler)(zsvsheet_context_t);
+};
+
+/**
+ * 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);
+
+/** extension support **/
+
+/**
+ * Set the subcommand prompt
+ */
+zsvsheet_status zsvsheet_subcommand_prompt(zsvsheet_subcommand_context_t ctx, const char *fmt, ...);
+
+/**
+ * Set a status message
+ */
+
+zsvsheet_status zsvsheet_set_status(struct zsvsheet_proc_context *ctx, const char *fmt, ...);
+
+/**
+ * Get the key press that triggered this subcommand handler
+ */
+int zsvsheet_ext_keypress(zsvsheet_proc_context_t);
+
+/**
+ * Get the current buffer
+ */
+zsvsheet_buffer_t zsvsheet_buffer_current(struct zsvsheet_proc_context *ctx);
+
+/**
+ * Get the prior buffer
+ */
+zsvsheet_buffer_t zsvsheet_buffer_prior(zsvsheet_buffer_t);
+
+/**
+ * Get the filename associated with a buffer
+ */
+const char *zsvsheet_buffer_filename(zsvsheet_buffer_t h);
+
+/**
+ * Get the data file associated with a buffer. This might not be the same as the filename,
+ * such as when the data has been filtered
+ */
+const char *zsvsheet_buffer_data_filename(zsvsheet_buffer_t h);
+
+/**
+ * Set custom context
+ * @param on_close optional callback to invoke when the buffer is closed
+ *
+ * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+ */
+enum zsv_ext_status zsvsheet_buffer_set_ctx(zsvsheet_buffer_t h, void *ctx, void (*on_close)(void *));
+
+/**
+ * Get custom context previously set via zsvsheet_buffer_set_ctx()
+ * @param ctx_out result will be written to this address
+ *
+ * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+ */
+enum zsv_ext_status zsvsheet_buffer_get_ctx(zsvsheet_buffer_t h, void **ctx_out);
+
+/**
+ * Set custom handler on Enter key press
+ *
+ * @return zsv_ext_status_ok on success, else zsv_ext_status error code
+ */
+enum zsv_ext_status zsvsheet_buffer_on_newline(zsvsheet_buffer_t h,
+                                               zsvsheet_status (*on_newline)(zsvsheet_proc_context_t));
+
+zsvsheet_status zsvsheet_buffer_get_selected_cell(zsvsheet_buffer_t h, struct zsvsheet_rowcol *rc);
+
+/**
+ * Set custom cell attributes
+ */
+void zsvsheet_buffer_set_cell_attrs(zsvsheet_buffer_t h,
+                                    enum zsv_ext_status (*get_cell_attrs)(void *ext_ctx, zsvsheet_cell_attr_t *,
+                                                                          size_t start_row, size_t row_count,
+                                                                          size_t col_count));
+
+/** Get zsv_opts use to open the buffer's data file **/
+struct zsv_opts zsvsheet_buffer_get_zsv_opts(zsvsheet_buffer_t h);
+
+/**
+ * Register a custom sheet command
+ */
+zsvsheet_status zsvsheet_register_command(int ch, const char *long_name,
+                                          zsvsheet_status (*subcommand_handler)(zsvsheet_subcommand_context_t),
+                                          zsvsheet_status (*handler)(zsvsheet_context_t));
+
+/**
+ * Transform the current buffer's underlying file into a new one and open the new file in a buffer
+ */
+enum zsvsheet_status zsvsheet_push_transformation(zsvsheet_proc_context_t ctx,
+                                                  struct zsvsheet_buffer_transformation_opts opts);
+#endif
+
+struct zsvsheet_buffer_data zsvsheet_buffer_info(zsvsheet_buffer_t buff);
+
+/** cell formatting **/
+zsvsheet_cell_attr_t zsvsheet_cell_profile_attrs(enum zsvsheet_cell_profile_t);

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

@@ -0,0 +1,43 @@
+struct zsvsheet_help_data {
+  size_t rows_fetched;
+  const char *row_data[3];
+};
+
+const unsigned char **zsvsheet_get_help_header(void *d) {
+  struct zsvsheet_help_data *data = d;
+  data->row_data[0] = "Key(s)";
+  data->row_data[1] = "Action";
+  data->row_data[2] = "Description";
+  return (const unsigned char **)data->row_data;
+}
+
+const unsigned char *zsvsheet_get_help_status(void *_) {
+  (void)(_);
+  return (const unsigned char *)"<esc> to exit help";
+}
+
+const unsigned char **zsvsheet_get_help_row(void *d) {
+  struct zsvsheet_help_data *data = d;
+  while (1) {
+    size_t i = data->rows_fetched++;
+    if (zsvsheet_get_key_binding(i) == NULL)
+      return NULL;
+
+    struct zsvsheet_key_binding *kb = zsvsheet_get_key_binding(i);
+    struct zsvsheet_procedure *proc = zsvsheet_find_procedure(kb->proc_id);
+    if (proc == NULL || kb->hidden)
+      continue;
+
+    data->row_data[0] = zsvsheet_key_binding_ch_name(kb);
+    data->row_data[1] = proc->name;
+    data->row_data[2] = proc->description;
+    return (const unsigned char **)data->row_data;
+  }
+}
+
+static zsvsheet_status zsvsheet_help_handler(struct zsvsheet_proc_context *ctx) {
+  const size_t cols = 3;
+  struct zsvsheet_help_data d = {0};
+  return zsvsheet_buffer_new_static(ctx, cols, zsvsheet_get_help_header, zsvsheet_get_help_row,
+                                    zsvsheet_get_help_status, &d, NULL);
+}

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

@@ -0,0 +1,81 @@
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <zsv.h>
+#include <zsv/utils/prop.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/writer.h>
+
+#include "../utils/index.h"
+#include "index.h"
+static void build_memory_index_row_handler(void *ctx) {
+  struct zsvsheet_indexer *ixr = ctx;
+  struct zsv_index *ix = ixr->ix;
+  zsv_parser parser = ixr->parser;
+  uint64_t line_end = zsv_cum_scanned_length(parser);
+
+  if (zsv_index_add_row(ix, line_end) != zsv_index_status_ok)
+    zsv_abort(parser);
+}
+
+enum zsv_index_status build_memory_index(struct zsvsheet_index_opts *optsp) {
+  struct zsvsheet_indexer ixr = {0};
+  enum zsv_index_status ret = zsv_index_status_error;
+  struct zsv_opts ix_zopts = optsp->zsv_opts;
+
+  if (optsp->uib->data_filename) {
+    ix_zopts.stream = fopen(optsp->uib->data_filename, "rb");
+  } else {
+    ix_zopts.stream = fopen(optsp->filename, "rb");
+  }
+
+  if (!ix_zopts.stream)
+    goto out;
+
+  ix_zopts.ctx = &ixr;
+  ix_zopts.row_handler = build_memory_index_row_handler;
+
+  enum zsv_status zst = zsv_new_with_properties(&ix_zopts, optsp->custom_prop_handler, optsp->filename, &ixr.parser);
+  if (zst != zsv_status_ok)
+    goto out;
+
+  ixr.ix = zsv_index_new();
+  if (!ixr.ix)
+    goto out;
+
+  optsp->uib->index = ixr.ix;
+
+  char cancelled = 0;
+  size_t committed_bytes = 0;
+  while (!cancelled && (zst = zsv_parse_more(ixr.parser)) == zsv_status_ok) {
+    if (zsv_cum_scanned_length(ixr.parser) - committed_bytes < 32 * 1024 * 1024)
+      continue;
+    committed_bytes = zsv_cum_scanned_length(ixr.parser);
+
+    pthread_mutex_lock(&optsp->uib->mutex);
+    if (optsp->uib->worker_cancelled) {
+      cancelled = 1;
+      zst = zsv_status_cancelled;
+    }
+    zsv_index_commit_rows(ixr.ix);
+    optsp->uib->index_ready = 1;
+    pthread_mutex_unlock(&optsp->uib->mutex);
+  }
+
+  zsv_finish(ixr.parser);
+  pthread_mutex_lock(&optsp->uib->mutex);
+  zsv_index_commit_rows(ixr.ix);
+  optsp->uib->index_ready = 1;
+  pthread_mutex_unlock(&optsp->uib->mutex);
+
+  if (zst == zsv_status_no_more_input || zst == zsv_status_cancelled)
+    ret = zsv_index_status_ok;
+
+out:
+  if (ixr.parser)
+    zsv_delete(ixr.parser);
+  if (ix_zopts.stream)
+    fclose(ix_zopts.stream);
+
+  return ret;
+}

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

@@ -0,0 +1,25 @@
+#ifndef SHEET_INDEX_H
+#define SHEET_INDEX_H
+
+#include <pthread.h>
+
+#include "zsv.h"
+
+struct zsvsheet_indexer {
+  zsv_parser parser;
+  struct zsv_index *ix;
+};
+
+struct zsvsheet_index_opts {
+  pthread_mutex_t *mutexp;
+  const char *filename;
+  struct zsv_opts zsv_opts;
+  struct zsvsheet_ui_buffer *uib;
+  int *errp;
+  struct zsv_prop_handler *custom_prop_handler;
+  char *old_ui_status;
+};
+
+enum zsv_index_status build_memory_index(struct zsvsheet_index_opts *optsp);
+
+#endif