zsv 1.3.0 → 1.4.3

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

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

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

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

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

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

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

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

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

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

@@ -1,16 +0,0 @@
-#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);
-  }
-}