zsv 1.3.0

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

@@ -0,0 +1,322 @@
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <zsv/utils/prop.h>
+#include "sheet_internal.h"
+#include "screen_buffer.h"
+#include "../utils/index.h"
+#include "index.h"
+
+#if defined(WIN32) || defined(_WIN32)
+#ifndef NO_MEMMEM
+#define NO_MEMMEM
+#endif
+#include <zsv/utils/memmem.h>
+#endif
+#include <zsv/utils/writer.h>
+#include <zsv/utils/file.h>
+
+// zsvsheet_found_in_row: return 0 if not found, else 1-based index of column
+static size_t zsvsheet_found_in_row(zsv_parser parser, size_t col_start, size_t col_count, const char *target,
+                                    size_t target_len, size_t specified_column_plus_1,
+                                    char find_exact // not yet implemented
+) {
+  if (col_start >= col_count)
+    return 0;
+
+  struct zsv_cell first_cell = zsv_get_cell(parser, col_start);
+  struct zsv_cell last_cell = zsv_get_cell(parser, col_count - 1);
+
+  if (memmem(first_cell.str, last_cell.str - first_cell.str + last_cell.len, target, target_len)) {
+    for (size_t i = col_start; i < col_count; i++) {
+      if (specified_column_plus_1 == 0 || i + 1 == specified_column_plus_1) {
+        struct zsv_cell c = zsv_get_cell(parser, i);
+        if (find_exact) {
+          if (c.len == target_len && !memcmp(c.str, target, c.len))
+            return i + 1;
+        } else if (memmem(c.str, c.len, target, target_len))
+          return i + 1;
+      }
+    }
+  }
+  return 0;
+}
+
+static void *get_data_index(void *d);
+
+static void get_data_index_async(struct zsvsheet_ui_buffer *uibuffp, const char *filename, struct zsv_opts *optsp,
+                                 struct zsv_prop_handler *custom_prop_handler, char *old_ui_status) {
+  struct zsvsheet_index_opts *ixopts = calloc(1, sizeof(*ixopts));
+  ixopts->mutexp = &uibuffp->mutex;
+  ixopts->filename = filename;
+  ixopts->zsv_opts = *optsp;
+  ixopts->custom_prop_handler = custom_prop_handler;
+  ixopts->uib = uibuffp;
+  ixopts->uib->ixopts = ixopts;
+  ixopts->old_ui_status = old_ui_status;
+
+  if (uibuffp->worker_active)
+    zsvsheet_ui_buffer_join_worker(uibuffp);
+  zsvsheet_ui_buffer_create_worker(uibuffp, get_data_index, ixopts);
+}
+
+static int read_data(struct zsvsheet_ui_buffer **uibufferp,   // a new zsvsheet_ui_buffer will be allocated
+                     struct zsvsheet_ui_buffer_opts *uibopts, // if *uibufferp == NULL and uibopts != NULL
+                     size_t start_row, size_t start_col, size_t header_span, struct zsvsheet_opts *zsvsheet_opts,
+                     struct zsv_prop_handler *custom_prop_handler) {
+  int rc = 0;
+  struct uib_parse_errs parse_errs;
+  uib_parse_errs_init(&parse_errs, 100);
+  FILE *fp = NULL;
+  const char *filename = (uibufferp && *uibufferp) ? (*uibufferp)->filename : uibopts ? uibopts->filename : NULL;
+  struct zsv_opts opts = {0};
+  if (uibufferp && *uibufferp)
+    opts = (*uibufferp)->zsv_opts;
+  else if (uibopts)
+    opts = uibopts->zsv_opts;
+
+  struct zsvsheet_ui_buffer *uibuff = uibufferp ? *uibufferp : NULL;
+  size_t remaining_rows_to_skip = start_row;
+  size_t remaining_header_to_skip = header_span;
+  size_t original_row_num = 0;
+
+  if (uibuff) {
+    if (uibuff->data_filename)
+      filename = uibuff->data_filename;
+    else if (uibuff->filename)
+      filename = uibuff->filename;
+  }
+
+  if (!filename && uibopts) {
+    if (uibopts->data_filename)
+      filename = uibopts->data_filename;
+    else if (uibopts->filename)
+      filename = uibopts->filename;
+  }
+
+  assert(filename != NULL);
+  fp = fopen(filename, "rb");
+  if (!fp) {
+    rc = errno;
+    goto done;
+  }
+
+  opts.stream = fp; // Input file stream
+
+  opts.errprintf = uib_parse_errs_printf;
+  if (uibuff)
+    opts.errf = &uibuff->parse_errs;
+  else
+    opts.errf = &parse_errs;
+
+  zsv_parser parser = {0};
+  if (zsv_new_with_properties(&opts, custom_prop_handler, filename, &parser) != zsv_status_ok) {
+    rc = errno ? errno : -1;
+    goto done;
+  }
+
+  // clear error logging before reusing opts
+  opts.errprintf = zsv_no_printf;
+  if (uibuff) {
+    pthread_mutex_lock(&uibuff->mutex);
+
+    enum zsv_index_status zst = zsv_index_status_ok;
+    if (zsvsheet_ui_buffer_index_ready(uibuff, 1)) {
+      opts.header_span = 0;
+      opts.rows_to_ignore = 0;
+
+      zst = zsv_index_seek_row(uibuff->index, &opts, start_row);
+
+      zsv_delete(parser);
+      parser = zsv_new(&opts);
+
+      remaining_header_to_skip = 0;
+      remaining_rows_to_skip = 0;
+      original_row_num = header_span + start_row;
+    }
+    pthread_mutex_unlock(&uibuff->mutex);
+    if (zst != zsv_index_status_ok) {
+      rc = errno ? errno : -1;
+      goto done;
+    }
+  }
+
+  size_t rows_read = header_span;
+
+  size_t find_len = zsvsheet_opts->find ? strlen(zsvsheet_opts->find) : 0;
+  size_t rows_searched = 0;
+  zsvsheet_screen_buffer_t buffer = uibuff ? uibuff->buffer : NULL;
+  if (uibuff && uibuff->has_row_num)
+    zsvsheet_opts->hide_row_nums = 1;
+
+  while (zsv_next_row(parser) == zsv_status_row &&
+         (rows_read == 0 || rows_read < zsvsheet_screen_buffer_rows(buffer))) { // for each row
+
+    size_t col_count = zsv_cell_count(parser);
+    if (uibuff == NULL && uibufferp && uibopts && col_count > 0) {
+      enum zsvsheet_priv_status stat;
+      struct zsvsheet_ui_buffer *tmp_uibuff = NULL;
+      if (!(buffer = zsvsheet_screen_buffer_new(col_count, uibopts->buff_opts, &stat)) ||
+          stat != zsvsheet_priv_status_ok || !(tmp_uibuff = zsvsheet_ui_buffer_new(buffer, uibopts))) {
+        if (tmp_uibuff)
+          zsvsheet_ui_buffer_delete(tmp_uibuff);
+        else
+          zsvsheet_screen_buffer_delete(buffer);
+        rc = -1;
+        goto done;
+      }
+      *uibufferp = uibuff = tmp_uibuff;
+      if (uibuff) {
+        uibuff->parse_errs = parse_errs;            // transfer errors
+        memset(&parse_errs, 0, sizeof(parse_errs)); // prevent double-free
+      }
+    }
+
+    // row number
+    size_t rownum_column_offset = 0;
+    if (rows_read == 0 && zsvsheet_opts->hide_row_nums == 0) {
+      // Check if we already have Row #
+      // TO DO: instead of checking the header, use (*uibufferp)->has_row_num
+      struct zsv_cell c = zsv_get_cell(parser, 0);
+      if (c.len == ZSVSHEET_ROWNUM_HEADER_LEN && !memcmp(c.str, ZSVSHEET_ROWNUM_HEADER, c.len)) {
+        zsvsheet_opts->hide_row_nums = 1;
+        if (uibuff)
+          uibuff->has_row_num = 1;
+      }
+    }
+
+    original_row_num++;
+    if (remaining_header_to_skip > 0) {
+      remaining_header_to_skip--;
+      continue;
+    }
+    if (uibuff) {
+      if (col_count + !buffer->opts.no_rownum_column > buffer->cols) {
+        if (zsvsheet_screen_buffer_grow(buffer, col_count) != zsvsheet_priv_status_ok) {
+          rc = -1;
+          goto done;
+        }
+      }
+      if (col_count > uibuff->dimensions.col_count)
+        uibuff->dimensions.col_count = col_count;
+    }
+
+    if (remaining_rows_to_skip > 0) {
+      remaining_rows_to_skip--;
+      continue;
+    }
+
+    if (zsvsheet_opts->find) { // find the next occurrence
+      rows_searched++;
+      size_t colIndexPlus1 =
+        zsvsheet_found_in_row(parser, zsvsheet_opts->found_colnum, col_count, zsvsheet_opts->find, find_len,
+                              zsvsheet_opts->find_specified_column_plus_1, zsvsheet_opts->find_exact);
+      if (colIndexPlus1) {
+        zsvsheet_opts->found_rownum = rows_searched + start_row;
+        zsvsheet_opts->found_colnum = colIndexPlus1 - 1;
+        break;
+      } else
+        zsvsheet_opts->found_colnum = 0; // next row search starts at beg of row
+      continue;
+    }
+
+    if (zsvsheet_opts->hide_row_nums == 0) {
+      if (rows_read == 0) // header
+        zsvsheet_screen_buffer_write_cell(buffer, 0, 0, (const unsigned char *)ZSVSHEET_ROWNUM_HEADER);
+      else {
+        char buff[32];
+        int n = snprintf(buff, sizeof(buff), "%zu", original_row_num - 1);
+        if (!(n > 0 && n < (int)sizeof(buff)))
+          sprintf(buff, "########");
+        zsvsheet_screen_buffer_write_cell(buffer, rows_read, 0, (unsigned char *)buff);
+      }
+      rownum_column_offset = 1;
+    }
+
+    for (size_t i = start_col; i < col_count && i + rownum_column_offset < zsvsheet_screen_buffer_cols(buffer); i++) {
+      struct zsv_cell c = zsv_get_cell(parser, i);
+      if (c.len)
+        zsvsheet_screen_buffer_write_cell_w_len(buffer, rows_read, i + rownum_column_offset, c.str, c.len);
+    }
+
+    rows_read++;
+  }
+  if (!uibuff) {
+    rc = 0;
+    goto done;
+  }
+
+  pthread_mutex_lock(&uibuff->mutex);
+  char need_index = !uibuff->index_started && !uibuff->write_in_progress;
+  char *old_ui_status = uibuff->status;
+  if (need_index)
+    uibuff->index_started = 1;
+  pthread_mutex_unlock(&uibuff->mutex);
+
+  if (need_index) {
+    if (asprintf(&uibuff->status, "%s(building index) ", old_ui_status ? old_ui_status : "") == -1) {
+      rc = -1;
+      goto done;
+    }
+
+    uibuff->buff_used_rows = rows_read;
+    uibuff->dimensions.row_count = rows_read;
+    if (original_row_num > 1 && rows_read > 0) {
+      opts.stream = NULL;
+      get_data_index_async(uibuff, filename, &opts, custom_prop_handler, old_ui_status);
+    }
+  } else if (rows_read > uibuff->buff_used_rows) {
+    uibuff->buff_used_rows = rows_read;
+    uibuff->dimensions.row_count = rows_read;
+  }
+
+done:
+  uib_parse_errs_clear(&parse_errs);
+  if (fp)
+    fclose(fp);
+  zsv_delete(parser);
+  return rc;
+}
+
+// get_data_index(): return an index for constant-time access
+static void *get_data_index(void *gdi) {
+  struct zsvsheet_index_opts *d = gdi;
+  pthread_mutex_t *mutexp = d->mutexp;
+  int *errp = d->errp;
+  struct zsvsheet_ui_buffer *uib = d->uib;
+  char *ui_status = uib->status;
+
+  enum zsv_index_status ix_status = build_memory_index(d);
+
+  if (ix_status != zsv_index_status_ok) {
+    pthread_mutex_lock(mutexp);
+    if (errp != NULL)
+      *errp = errno;
+    free(d);
+    pthread_mutex_unlock(mutexp);
+    return NULL;
+  }
+
+  pthread_mutex_lock(mutexp);
+  uib->status = d->old_ui_status;
+  uib->ixopts = NULL;
+  pthread_mutex_unlock(mutexp);
+
+  free(ui_status);
+  free(d);
+
+  return NULL;
+}
+
+static size_t zsvsheet_find_next(struct zsvsheet_ui_buffer *uib, struct zsvsheet_opts *zsvsheet_opts,
+                                 size_t header_span, struct zsv_prop_handler *custom_prop_handler) {
+  struct zsvsheet_rowcol *input_offset = &uib->input_offset;
+  struct zsvsheet_rowcol *buff_offset = &uib->buff_offset;
+  size_t cursor_row = uib->cursor_row;
+  size_t start_row = input_offset->row + buff_offset->row + header_span + cursor_row - 1;
+  if (start_row > 0)
+    start_row--;
+  read_data(&uib, NULL, start_row, 0, header_span, zsvsheet_opts, custom_prop_handler);
+  zsvsheet_opts->find = NULL;
+  return zsvsheet_opts->found_rownum;
+}

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

@@ -0,0 +1,203 @@
+#include "screen_buffer.h"
+
+#include <zsv/ext.h> // zsvsheet_cell_attr_t
+
+struct zsvsheet_screen_buffer {
+  size_t cols;
+  size_t long_cell_count;
+  struct zsvsheet_screen_buffer_opts opts;
+  unsigned char *data;
+  zsvsheet_cell_attr_t *cell_attrs; // used for per-cell attron() and attroff()
+  // to do: add hooks for extension
+};
+
+static inline size_t buffer_data_offset(zsvsheet_screen_buffer_t buff, size_t row, size_t col) {
+  assert(row < buff->opts.rows && col < buff->cols);
+  return row * buff->cols * buff->opts.cell_buff_len + col * buff->opts.cell_buff_len;
+}
+
+static void set_long_cell(zsvsheet_screen_buffer_t buff, size_t offset, char *heap) {
+  char **target = (char **)(buff->data + offset);
+  *target = heap;
+  // set flag indicating that this is long cell
+  *(buff->data + offset + buff->opts.cell_buff_len - 1) = (char)1;
+}
+
+static char *get_long_cell(zsvsheet_screen_buffer_t buff, size_t offset) {
+  char **valuep = (char **)(buff->data + offset);
+  if (valuep)
+    return *valuep;
+  return NULL;
+}
+
+static inline int is_long_cell(const unsigned char *mem, size_t cell_buff_len) {
+  return *(mem + cell_buff_len - 1) != '\0';
+}
+
+size_t zsvsheet_screen_buffer_cols(zsvsheet_screen_buffer_t buff) {
+  return buff->cols;
+}
+
+size_t zsvsheet_screen_buffer_rows(zsvsheet_screen_buffer_t buff) {
+  return buff->opts.rows;
+}
+
+static void free_long_cell(zsvsheet_screen_buffer_t buff, size_t offset) {
+  if (is_long_cell(buff->data + offset, buff->opts.cell_buff_len)) {
+    char *value_copy = get_long_cell(buff, offset);
+    free(value_copy);
+    memset(buff->data + offset, 0, buff->opts.cell_buff_len);
+    buff->long_cell_count--;
+  }
+}
+
+void zsvsheet_screen_buffer_delete(zsvsheet_screen_buffer_t buff) {
+  if (buff) {
+    for (size_t i = 0; i < buff->opts.rows && buff->long_cell_count > 0; i++) {
+      for (size_t j = 0; j < buff->cols && buff->long_cell_count > 0; j++) {
+        size_t offset = buffer_data_offset(buff, i, j);
+        free_long_cell(buff, offset);
+      }
+    }
+    free(buff->cell_attrs);
+    free(buff->data);
+    free(buff);
+  }
+}
+
+zsvsheet_screen_buffer_t zsvsheet_screen_buffer_new(size_t cols, struct zsvsheet_screen_buffer_opts *opts,
+                                                    enum zsvsheet_priv_status *stat) {
+  struct zsvsheet_screen_buffer_opts bopts = {0};
+  if (!opts)
+    opts = &bopts;
+  *stat = zsvsheet_priv_status_ok;
+  if (opts->rows == 0)
+    opts->rows = ZSVSHEET_SCREEN_BUFFER_DEFAULT_ROW_COUNT;
+  else if (opts->rows < 256)
+    opts->rows = 256;
+  if (opts->cell_buff_len == 0)
+    opts->cell_buff_len = ZSVSHEET_SCREEN_BUFFER_DEFAULT_CELL_BUFF_LEN;
+  if (opts->max_cell_len == 0)
+    opts->max_cell_len = ZSVSHEET_SCREEN_BUFFER_DEFAULT_MAX_CELL_LEN;
+  if (opts->cell_buff_len < sizeof(void *) * 2)
+    *stat = zsvsheet_priv_status_error;
+  else {
+    if (!opts->no_rownum_column)
+      cols++;
+    void *data = calloc(opts->rows, cols * opts->cell_buff_len);
+    if (!data)
+      *stat = zsvsheet_priv_status_memory;
+    else {
+      struct zsvsheet_screen_buffer *buff = calloc(1, sizeof(*buff));
+      if (!buff)
+        *stat = zsvsheet_priv_status_memory;
+      else {
+        buff->opts.rows = opts->rows;
+        buff->cols = cols;
+        buff->data = data;
+        buff->opts = *opts;
+        return buff;
+      }
+    }
+    free(data);
+  }
+  return NULL;
+}
+
+enum zsvsheet_priv_status zsvsheet_screen_buffer_grow(zsvsheet_screen_buffer_t buff, size_t cols) {
+  size_t old_cols = buff->cols;
+  size_t rows = buff->opts.rows;
+  size_t cell_buff_len = buff->opts.cell_buff_len;
+  size_t old_row_len = old_cols * cell_buff_len;
+
+  if (!buff->opts.no_rownum_column)
+    cols++;
+
+  size_t row_len = cols * cell_buff_len;
+
+  assert(cols > old_cols);
+
+  void *old_data = buff->data;
+  void *data = calloc(rows, cols * cell_buff_len);
+  if (!data)
+    return zsvsheet_priv_status_memory;
+
+  for (size_t i = 0; i < rows; i++) {
+    size_t old_row_off = i * old_row_len;
+    size_t row_off = i * row_len;
+
+    memcpy((char *)data + row_off, (char *)old_data + old_row_off, old_row_len);
+  }
+
+  buff->data = data;
+  buff->cols = cols;
+
+  free(old_data);
+
+  return zsvsheet_priv_status_ok;
+}
+
+#ifndef UTF8_NOT_FIRST_CHAR
+#define UTF8_NOT_FIRST_CHAR(x) ((x & 0xC0) == 0x80)
+#endif
+
+enum zsvsheet_priv_status zsvsheet_screen_buffer_write_cell_w_len(zsvsheet_screen_buffer_t buff, size_t row, size_t col,
+                                                                  const unsigned char *value, size_t len) {
+  enum zsvsheet_priv_status stat = zsvsheet_priv_status_ok;
+  size_t offset = buffer_data_offset(buff, row, col);
+  free_long_cell(buff, offset);
+  if (len < buff->opts.cell_buff_len) {
+    if (len)
+      // copy into fixed-size buff
+      memcpy(buff->data + offset, value, len);
+    *(buff->data + offset + len) = '\0';
+  } else {
+    // we have a long cell
+    if (len > buff->opts.max_cell_len) {
+      len = buff->opts.max_cell_len;
+      while (len > 0 && value[len] >= 128 && UTF8_NOT_FIRST_CHAR(value[len]))
+        // we are in the middle of a multibyte char, so back up
+        len--;
+    }
+    if (!len) // the only reason len could be 0 is if our input was not valid utf8, but check to make sure anyway
+      stat = zsvsheet_priv_status_utf8;
+    else {
+      char *value_copy = malloc(1 + len);
+      if (value_copy) {
+        memcpy(value_copy, value, len);
+        value_copy[len] = '\0';
+        set_long_cell(buff, offset, value_copy);
+        buff->long_cell_count++;
+      } else
+        stat = zsvsheet_priv_status_memory;
+    }
+  }
+  return stat;
+}
+
+enum zsvsheet_priv_status zsvsheet_screen_buffer_write_cell(zsvsheet_screen_buffer_t buff, size_t row, size_t col,
+                                                            const unsigned char *value) {
+  return zsvsheet_screen_buffer_write_cell_w_len(buff, row, col, value, strlen((void *)value));
+}
+
+int zsvsheet_screen_buffer_cell_attrs(zsvsheet_screen_buffer_t buff, size_t row, size_t col) {
+  if (buff->cell_attrs) {
+    size_t offset = row * buff->cols + col;
+    return buff->cell_attrs[offset];
+  }
+  return 0;
+}
+
+const unsigned char *zsvsheet_screen_buffer_cell_display(zsvsheet_screen_buffer_t buff, size_t row, size_t col) {
+  if (row < buff->opts.rows && col < buff->cols) {
+    size_t offset = row * buff->cols * buff->opts.cell_buff_len + col * buff->opts.cell_buff_len;
+    const unsigned char *cell = &buff->data[offset];
+    if (!is_long_cell(cell, buff->opts.cell_buff_len))
+      return cell;
+
+    // if the fixed-length cell memory does not end with NULL,
+    // then the cell value is a pointer to memory holding the value
+    return (unsigned char *)get_long_cell(buff, offset);
+  }
+  return NULL;
+}

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

@@ -0,0 +1,36 @@
+#ifndef ZSVSHEET_SCREEN_BUFFER_H
+#define ZSVSHEET_SCREEN_BUFFER_H
+
+#define ZSVSHEET_SCREEN_BUFFER_DEFAULT_CELL_BUFF_LEN 16
+#define ZSVSHEET_SCREEN_BUFFER_DEFAULT_MAX_CELL_LEN 32768 - 1
+#define ZSVSHEET_SCREEN_BUFFER_DEFAULT_ROW_COUNT 1024
+
+typedef struct zsvsheet_screen_buffer *zsvsheet_screen_buffer_t;
+
+struct zsvsheet_screen_buffer_opts {
+  size_t cell_buff_len;  // default = 16. must be >= 2 * sizeof(void *)
+  size_t max_cell_len;   // length in bytes; defaults to 32767
+  size_t rows;           // rows to buffer. cannot be < 256
+  char no_rownum_column; // reserved. TO DO: if set, omit row num column
+};
+
+zsvsheet_screen_buffer_t zsvsheet_screen_buffer_new(size_t cols, struct zsvsheet_screen_buffer_opts *opts,
+                                                    enum zsvsheet_priv_status *stat);
+enum zsvsheet_priv_status zsvsheet_screen_buffer_grow(zsvsheet_screen_buffer_t buff, size_t cols);
+
+enum zsvsheet_priv_status zsvsheet_screen_buffer_write_cell(zsvsheet_screen_buffer_t buff, size_t row, size_t col,
+                                                            const unsigned char *value);
+
+enum zsvsheet_priv_status zsvsheet_screen_buffer_write_cell_w_len(zsvsheet_screen_buffer_t buff, size_t row, size_t col,
+                                                                  const unsigned char *value, size_t len);
+
+const unsigned char *zsvsheet_screen_buffer_cell_display(zsvsheet_screen_buffer_t buff, size_t row, size_t col);
+
+int zsvsheet_screen_buffer_cell_attrs(zsvsheet_screen_buffer_t buff, size_t row, size_t col);
+
+void zsvsheet_screen_buffer_delete(zsvsheet_screen_buffer_t);
+
+size_t zsvsheet_screen_buffer_cols(zsvsheet_screen_buffer_t);
+size_t zsvsheet_screen_buffer_rows(zsvsheet_screen_buffer_t buff);
+
+#endif