zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/zsv_command.h

@@ -0,0 +1,40 @@
+#ifndef ZSV_COMMAND_H
+#define ZSV_COMMAND_H
+
+/**
+ * Include zsv headers and entry point declaration
+ * If the command will *not* use common zsv parsing options, then prior to
+ * including this file, define
+ *   ZSV_COMMAND_NO_OPTIONS
+ */
+
+#include <zsv.h>
+#include <zsv/utils/arg.h>
+#include <zsv/utils/prop.h>
+#include <zsv/utils/compiler.h>
+#include <zsv/utils/signal.h>
+#include <zsv/utils/memmem.h>
+
+#include "zsv_main.h"
+
+#define APPNAME1(x) #x
+#define APPNAME2(x) APPNAME1(x)
+#define APPNAME APPNAME2(ZSV_COMMAND)
+
+#include <zsv/utils/err.h>
+
+#ifdef ZSV_COMMAND_NO_OPTIONS
+ZSV_MAIN_NO_OPTIONS_DECL(ZSV_COMMAND);
+#else
+ZSV_MAIN_DECL(ZSV_COMMAND);
+#endif
+
+/**
+ * If we are currently compiling a standalone executable (e.g. zsv_select),
+ * then include the main() code
+ */
+#ifndef ZSV_CLI
+#include "zsv_command_standalone.c"
+#endif
+
+#endif

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

@@ -0,0 +1,16 @@
+/**
+ * Stub for standalone zsv command compilation e.g. for building zsv_select, zsv_count etc each as separate executables
+ */
+int main(int argc, const char *argv[]) {
+#ifdef ZSV_COMMAND_NO_OPTIONS
+  // if ZSV_MAIN_NO_OPTIONS is defined, we just call the command entry point
+  // with the original argc and argv arguments
+  return ZSV_MAIN_NO_OPTIONS_FUNC(ZSV_COMMAND)(argc, argv);
+#else
+  struct zsv_opts opts;
+  enum zsv_status stat = zsv_args_to_opts(argc, argv, &argc, argv, &opts);
+  if (stat != zsv_status_ok)
+    return stat;
+  return ZSV_MAIN_FUNC(ZSV_COMMAND)(argc, argv, &opts, NULL);
+#endif
+}

data/ext/zsv/vendor/zsv-1.3.0/app/zsv_main.h

@@ -0,0 +1,44 @@
+#ifndef ZSV_MAIN_H
+#define ZSV_MAIN_H
+
+/**
+ * ZSV commands can each be compiled as either a standalone executable or a
+ * command bundled into the `zsv` CLI. To support these different options
+ * without repeating common invocation code, we define two sets of macros: one
+ * set each for commands that do, and that do not, use common zsv parsing
+ * options. Each set has a macro each for the entry point name and declaration
+ */
+
+#define ZSV_MAIN_FUNC1(x) zsv_##x##_main
+#define ZSV_MAINEXT_FUNC1(x) zsv_##x##_mainext
+#define ZSV_MAIN_NO_OPTIONS_FUNC1(x) zsv_##x##_main_no_options
+
+struct zsv_opts;
+struct zsv_prop_handler;
+
+/* macros for commands that use common zsv parsing */
+#define ZSV_MAIN_FUNC(x) ZSV_MAIN_FUNC1(x)
+#define ZSV_MAINEXT_FUNC(x) ZSV_MAINEXT_FUNC1(x)
+#define ZSV_MAIN_DECL(x)                                                                                               \
+  int ZSV_MAIN_FUNC(x)(int argc, const char *argv[], struct zsv_opts *opts,                                            \
+                       struct zsv_prop_handler *custom_prop_handler)
+
+/* macros for commands that do not use common zsv parsing */
+#define ZSV_MAIN_NO_OPTIONS_FUNC(x) ZSV_MAIN_NO_OPTIONS_FUNC1(x)
+#define ZSV_MAIN_NO_OPTIONS_DECL(x) int ZSV_MAIN_NO_OPTIONS_FUNC(x)(int argc, const char *argv[])
+
+/* macros for commands that require loading extensions before running */
+#define ZSV_MAINEXT_FUNC_DEFINE(x)                                                                                     \
+  int ZSV_MAINEXT_FUNC(x)(int argc, const char *argv[], struct zsv_opts *optsp,                                        \
+                          struct zsv_prop_handler *custom_prop_handler) {                                              \
+    int ZSV_MAIN_FUNC(x)(int argc, const char *argv[], struct zsv_opts *optsp,                                         \
+                         struct zsv_prop_handler *custom_prop_handler);                                                \
+    /* initialize extensions */                                                                                        \
+    struct cli_config config;                                                                                          \
+    config_init(&config, 1, 1, 0);                                                                                     \
+    return ZSV_MAIN_FUNC(sheet)(argc, argv, optsp, custom_prop_handler);                                               \
+  }                                                                                                                    \
+  /* extra declaration to allow trailing semicolon */ int ZSV_MAIN_FUNC(x)(                                            \
+    int argc, const char *argv[], struct zsv_opts *optsp, struct zsv_prop_handler *custom_prop_handler)
+
+#endif

data/ext/zsv/vendor/zsv-1.3.0/examples/js/zsv_parser_api_dummy.c

@@ -0,0 +1,3 @@
+int main() {
+  return 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/examples/lib/parse_by_chunk.c

@@ -0,0 +1,100 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <zsv.h>
+
+/** zsv example parsing in chunks
+ *
+ * This sample code shows how to use `zsv_parse_bytes()`
+ * to parse a chunk of bytes, instead of using `zsv_parse_more()`
+ * to pull data from a stream
+ *
+ * Note that, when given a choice, using `zsv_parse_more()`
+ * may be slightly more efficient / performant as is requires
+ * less memory copying
+ *
+ * In this example, we just count rows, but you could substitute in any
+ * row handler you want
+ **/
+
+/**
+ * Create a structure to hold our data while we parse
+ * In this case, we are just going to keep track of row count
+ */
+struct chunk_parse_data {
+  unsigned count;
+};
+
+/**
+ * Our row handler function will take a pointer to our data
+ * and increment its count by 1
+ */
+static void chunk_parse_row(void *dat) {
+  struct chunk_parse_data *data = dat;
+  data->count++;
+}
+
+/**
+ * Main routine will output a help message if called with -h or --help,
+ * otherwise will read from stdin and run through the CSV parser
+ */
+int main(int argc, const char *argv[]) {
+  if (argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
+    printf("Usage: parse_by_chunk < file.csv\n\n");
+    printf("Reads stdin in chunks, parses each chunk using `zsv_parse_bytes()`,\n");
+    printf("and outputs the number of rows parsed.\n");
+    return 0;
+  }
+
+  FILE *f = stdin; /* read from stdin */
+
+  /**
+   * create a vanilla parser
+   */
+  zsv_parser p = zsv_new(NULL);
+  if (!p)
+    fprintf(stderr, "Out of memory!");
+  else {
+    /**
+     * Configure the parser to use our row handler, and to pass
+     * it our data when it's called
+     */
+    struct chunk_parse_data d = {0};
+    zsv_set_row_handler(p, chunk_parse_row);
+    zsv_set_context(p, &d);
+
+    /**
+     * Allocate a buffer that we will fetch data from and pass to the parser.
+     * In this example we use a heap buffer, but we could just as well
+     * have allocated it on the stack
+     */
+    int chunk_size = 4096;
+    unsigned char *buff = malloc(chunk_size);
+
+    /**
+     * Read and parse each chunk until the end of the stream is reached
+     */
+    while (1) {
+      size_t bytes_read = fread(buff, 1, chunk_size, f);
+      if (!bytes_read)
+        break;
+      zsv_parse_bytes(p, buff, bytes_read);
+    }
+
+    /**
+     * Finish any remaining parsing
+     */
+    zsv_finish(p);
+
+    /**
+     * Clean up
+     */
+    zsv_delete(p);
+    free(buff);
+
+    /**
+     * Print result
+     */
+    printf("Count: %u\n", d.count);
+  }
+}

data/ext/zsv/vendor/zsv-1.3.0/examples/lib/print_my_column.c

@@ -0,0 +1,143 @@
+/**
+ * Simple example using libzsv to call a row handler after each row is parsed
+ *
+ * In this example, we will use libzsv to parse a CSV file, look for a specified
+ * column of data, and for each row of data, output only that column
+ *
+ * Example:
+ *   `echo "hi,there,you\na,b,c\nd,e,f" | ./print_my_column there
+ * Outputs:
+ *   there
+ *
+ * In our implementation, we will define two row handlers. The first handler
+ * will be used to handle the first row, which we assume to be the header,
+ * and will search for the target column to identify what position it is in
+ * (or whether we can't find it). The second handler will be used to process
+ * each data row, and will output the target column
+ */
+static void print_my_column(void *ctx);
+static void find_my_column(void *ctx);
+
+#include <stdio.h>
+#include <zsv.h>
+#include <string.h>
+
+/**
+ * First, we define a structure that will contain all the information that
+ * our row handler will need
+ */
+struct my_data {
+  zsv_parser parser;
+  const char *target_column_name; /* name of column to find and output */
+  size_t target_column_position;  /* will be set to the position of the column to output */
+  char not_found;                 /* if we can't find the column, we'll set this flag */
+};
+
+/**
+ * Our first callback will search each cell in the (header) row. If it finds a match
+ * it sets the `target_column_position`, otherwise it halts further processing and
+ * sets the `not_found` flag
+ */
+static void find_my_column(void *ctx) {
+  struct my_data *data = ctx;
+  size_t target_column_name_len = strlen(data->target_column_name);
+
+  /* iterate through each cell */
+  size_t cell_count = zsv_cell_count(data->parser);
+  char found = 0;
+  for (size_t i = 0; i < cell_count; i++) {
+    struct zsv_cell c = zsv_get_cell(data->parser, i);
+    if (c.len == target_column_name_len && !memcmp(data->target_column_name, c.str, c.len)) {
+      data->target_column_position = i;
+      found = 1;
+      break;
+    }
+  }
+
+  if (!found) {
+    /**
+     * We couldn't find the target column name in our header row. Output a message and abort
+     */
+    fprintf(stderr, "Could not find column %.*s\n", (int)target_column_name_len, data->target_column_name);
+
+    /**
+     * Once `zsv_abort()` is called, the parser will no longer invoke any callbacks
+     * and `zsv_parse_more()` will return `zsv_status_cancelled`
+     */
+    zsv_abort(data->parser);
+
+    /**
+     * set a flag that we will later use to determine our program's exit code
+     */
+    data->not_found = 1;
+  } else {
+    /**
+     * we found the column we are looking for. print its name, and change our row handler
+     * by calling `zsv_set_row_handler()`
+     */
+    printf("%s\n", data->target_column_name);
+    zsv_set_row_handler(data->parser, print_my_column);
+  }
+}
+
+/**
+ * Output data from the selected column
+ */
+static void print_my_column(void *ctx) {
+  struct my_data *data = ctx;
+
+  /* use zsv_get_cell() to get our cell data */
+  struct zsv_cell c = zsv_get_cell(data->parser, data->target_column_position);
+
+  /* print the data, followed by a newline */
+  printf("%.*s\n", (int)c.len, c.str);
+}
+
+/**
+ * Main routine. Our example will take a single argument specifying a column
+ * name, read from stdin, and output, for each row, the specified column
+ */
+int main(int argc, const char *argv[]) {
+  if (argc < 2) {
+    fprintf(stderr, "Usage: print_my_column column_name < input.csv\n");
+    fprintf(stderr,
+            "Example:\n"
+            "  echo \"A,B,C\\nA1,B1,C1\\nA2,B2,\\nA3,,C3\\n,,C3\" | %s B\n\n",
+            argv[0]);
+    return 0;
+  }
+
+  /**
+   * Initialize context data
+   */
+  struct my_data data = {0};
+  data.target_column_name = argv[1];
+
+  /**
+   * Initialize parser options
+   */
+  struct zsv_opts opts = {0};
+  opts.row_handler = find_my_column;
+  opts.ctx = &data;
+
+  /**
+   * Create a parser
+   */
+  data.parser = zsv_new(&opts);
+
+  /**
+   * Continuously parse our input until we have no more input
+   * or an error has occurred (such as not finding the specified
+   * column name in the first row)
+   */
+  while (zsv_parse_more(data.parser) == zsv_status_ok)
+    ;
+
+  /**
+   * Clean up
+   */
+  zsv_finish(data.parser);
+  zsv_delete(data.parser);
+
+  return data.not_found;
+}

data/ext/zsv/vendor/zsv-1.3.0/examples/lib/pull.c

@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <string.h>
+#include <zsv.h>
+
+/**
+ * Simple example using libzsv as a pull parser for CSV input
+ *
+ * This is the same as simple.c, but uses pull parsing instead of push parsing
+ *
+ * We will check each cell in the row to determine if it is blank, and output
+ * the row number, the total number of cells and the number of blank cells
+ *
+ * Example:
+ *   `echo 'abc,def\nghi,,,' | build/simple -`
+ * Outputs:
+ *   Row 1 has 2 columns of which 0 are non-blank
+ *   Row 2 has 4 columns of which 3 are non-blank
+ *
+ * With pull parsing, the parser just repeatedly calls zsv_next_row() so long
+ * as it returns `zsv_status_row`
+ */
+
+/**
+ * Main routine. Our program will take a single argument (a file name, or -)
+ * and output, for each row, the numbers of total and blank cells
+ */
+int main(int argc, const char *argv[]) {
+  if (argc != 2) {
+    fprintf(stderr, "Reads a CSV file or stdin, and for each row,\n"
+                    " output counts of total and blank cells\n");
+    fprintf(stderr, "Usage: simple <filename or dash(-) for stdin>\n");
+    fprintf(stderr,
+            "Example:\n"
+            "  echo \"A1,B1,C1\\nA2,B2,\\nA3,,C3\\n,,C3\" | %s -\n\n",
+            argv[0]);
+    return 0;
+  }
+
+  FILE *f = strcmp(argv[1], "-") ? fopen(argv[1], "rb") : stdin;
+  if (!f) {
+    perror(argv[1]);
+    return 1;
+  }
+
+  /**
+   * Create a parser
+   */
+  struct zsv_opts opts = {0};
+  opts.stream = f;
+  zsv_parser parser = zsv_new(&opts);
+  if (!parser) {
+    fprintf(stderr, "Could not allocate parser!\n");
+    return -1;
+  }
+
+  /**
+   * iterate through all rows
+   */
+  size_t row_num = 0;
+  while (zsv_next_row(parser) == zsv_status_row) {
+    row_num++;
+
+    /* get a cell count */
+    size_t cell_count = zsv_cell_count(parser);
+
+    /* iterate through each cell in this row, to count blanks */
+    size_t nonblank = 0;
+    for (size_t i = 0; i < cell_count; i++) {
+      struct zsv_cell c = zsv_get_cell(parser, i);
+      /* use r.values[] and r.lengths[] to get cell data */
+      /* Here, we only care about lengths */
+      if (c.len > 0)
+        nonblank++;
+    }
+
+    /* print our results for this row */
+    printf("Row %zu has %zu columns of which %zu %s non-blank\n", row_num, cell_count, nonblank,
+           nonblank == 1 ? "is" : "are");
+  }
+  /**
+   * Clean up
+   */
+  zsv_delete(parser);
+
+  if (f != stdin)
+    fclose(f);
+
+  return 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/examples/lib/simple.c

@@ -0,0 +1,123 @@
+#include <stdio.h>
+#include <string.h>
+#include <zsv.h>
+
+/**
+ * Simple example using libzsv to call a row handler after each row is parsed
+ *
+ * In this super simple example, we will use libzsv to parse a CSV file
+ * and call our custom row handler after each row is parsed. Our row handler
+ * will check each cell in the row to determine if it is blank, and output
+ * the row number, the total number of cells and the number of blank cells
+ *
+ * Example:
+ *   `echo 'abc,def\nghi,,,' | build/simple -`
+ * Outputs:
+ *   Row 1 has 2 columns of which 0 are non-blank
+ *   Row 2 has 4 columns of which 3 are non-blank
+ */
+
+/**
+ * First, we define a structure that will contain all the information that
+ * our row handler will need
+ */
+struct my_data {
+  zsv_parser parser; /* used to access the parsed data */
+  size_t row_num;    /* used to track the current row number */
+};
+
+/**
+ * Our row handler is passed a pointer to our structure
+ */
+void my_row_handler(void *ctx) {
+  struct my_data *data = ctx;
+
+  /* get a cell count */
+  size_t cell_count = zsv_cell_count(data->parser);
+
+  /* iterate through each cell in this row, to count blanks */
+  size_t nonblank = 0;
+  for (size_t i = 0; i < cell_count; i++) {
+    /* use zsv_get_cell() to get our cell data */
+    struct zsv_cell c = zsv_get_cell(data->parser, i);
+
+    /* check if the cell data length is zero */
+    if (c.len > 0)
+      nonblank++;
+  }
+
+  /* print our results for this row */
+  printf("Row %zu has %zu columns of which %zu %s non-blank\n", ++data->row_num, cell_count, nonblank,
+         nonblank == 1 ? "is" : "are");
+}
+
+/**
+ * Main routine. Our program will take a single argument (a file name, or -)
+ * and output, for each row, the numbers of total and blank cells
+ */
+int main(int argc, const char *argv[]) {
+
+  /**
+   * Process our arguments; output usage and/or errors if appropriate
+   */
+  if (argc != 2) {
+    fprintf(stderr, "Reads a CSV file or stdin, and for each row,\n"
+                    " output counts of total and blank cells\n");
+    fprintf(stderr, "Usage: simple <filename or dash(-) for stdin>\n");
+    fprintf(stderr,
+            "Example:\n"
+            "  echo \"A1,B1,C1\\nA2,B2,\\nA3,,C3\\n,,C3\" | %s -\n\n",
+            argv[0]);
+    return 0;
+  }
+
+  FILE *f = strcmp(argv[1], "-") ? fopen(argv[1], "rb") : stdin;
+  if (!f) {
+    perror(argv[1]);
+    return 1;
+  }
+
+  /**
+   * Configure our parser options. Here, all we do is specify our row handler
+   * and the pointer that will be passed to our row handler. There are many
+   * other options to control the parser behavior (CSV vs TSV vs other
+   * delimited; header row span etc)-- for details, see
+   * ../../include/zsv/api.h
+   */
+  struct zsv_opts opts = {0};
+  opts.row_handler = my_row_handler;
+  struct my_data data = {0};
+  opts.ctx = &data;
+  opts.stream = f;
+
+  /**
+   * Create a parser
+   */
+  data.parser = zsv_new(&opts);
+
+  /**
+   * Continuously parse our input until we have no more input
+   */
+  enum zsv_status stat;
+  while ((stat = zsv_parse_more(data.parser)) == zsv_status_ok)
+    ;
+
+  /**
+   * Clean up
+   */
+  zsv_finish(data.parser);
+  zsv_delete(data.parser);
+
+  if (f != stdin)
+    fclose(f);
+
+  /**
+   * If there was a parse error, print it
+   */
+  if (stat != zsv_status_no_more_input) {
+    fprintf(stderr, "Parse error: %s\n", zsv_parse_status_desc(stat));
+    return 1;
+  }
+
+  return 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/fuzz/fuzz.c

@@ -0,0 +1,16 @@
+#include <unistd.h>
+#include "../src/zsv.c"
+
+__AFL_FUZZ_INIT();
+
+int main() {
+  __AFL_INIT();
+  unsigned char *src = 0;
+  unsigned char *buf = __AFL_FUZZ_TESTCASE_BUF;
+  while (__AFL_LOOP(10000)) {
+    int len = __AFL_FUZZ_TESTCASE_LEN;
+    src = realloc(src, len);
+    memcpy(src, buf, len);
+    zsv_parse_bytes(zsv_new(0), src, len);
+  }
+}