zsv 1.3.0

data/ext/zsv/vendor/zsv-1.3.0/app/utils/pcre2-8/pcre2-8-test.c

@@ -0,0 +1,123 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "./pcre2-8.h"
+
+/**
+ * @brief Reads an entire file into a new buffer.
+ *
+ * @param filename The name of the file to read.
+ * @param out_size Pointer to a size_t to store the file size.
+ * @return A new buffer containing the file contents (must be free'd) or NULL on error.
+ */
+char *read_file_to_buffer(const char *filename, size_t *out_size) {
+  const char *tmp_filename = "./pcre2-8-test.temp";
+  if (!strcmp(filename, "-")) { // write stdin to temp file
+    FILE *tmp = fopen(tmp_filename, "wb");
+    if (!tmp) {
+      perror(tmp_filename);
+      return NULL;
+    }
+    size_t sz;
+    char buff[4096];
+    while ((sz = fread(buff, 1, sizeof(buff), stdin)) > 0)
+      fwrite(buff, 1, sz, tmp);
+    fclose(tmp);
+    filename = tmp_filename;
+  }
+  FILE *f = fopen(filename, "rb");
+  if (f == NULL) {
+    perror(filename);
+    return NULL;
+  }
+
+  // Seek to end to find file size
+  if (fseek(f, 0, SEEK_END) != 0) {
+    perror("Error seeking in file");
+    fclose(f);
+    return NULL;
+  }
+
+  long file_size = ftell(f);
+  if (file_size == -1) {
+    perror("Error getting file size");
+    fclose(f);
+    return NULL;
+  }
+  rewind(f); // Go back to the start
+
+  // Allocate buffer for file content + 1 for a null terminator
+  char *buffer = malloc(file_size + 1);
+  if (buffer == NULL) {
+    fprintf(stderr, "Error: Could not allocate memory for file.\n");
+    fclose(f);
+    return NULL;
+  }
+
+  // Read the file
+  size_t bytes_read = fread(buffer, 1, file_size, f);
+  if (bytes_read != (size_t)file_size) {
+    fprintf(stderr, "Error reading file (read %zu, expected %ld).\n", bytes_read, file_size);
+    fclose(f);
+    free(buffer);
+    return NULL;
+  }
+
+  fclose(f);
+  buffer[file_size] = '\0'; // Null-terminate the string
+  *out_size = (size_t)file_size;
+  return buffer;
+}
+
+/**
+ * @brief Main entry point.
+ *
+ * Takes a regex pattern and a filename as command-line arguments.
+ */
+int main(int argc, char *argv[]) {
+  if (argc != 3) {
+    fprintf(stderr, "Usage: %s <pattern> <filename, or - for stdin>\n", argv[0]);
+    return 1;
+  }
+
+  const char *pattern_string = argv[1];
+  const char *filename = argv[2];
+
+  // Read file into memory
+  size_t file_size = 0;
+  char *file_content = read_file_to_buffer(filename, &file_size);
+  if (file_content == NULL) {
+    return 1; // Error already printed
+  }
+
+  // Compile the pattern (pass 0 for default options,
+  // PCRE2_UTF and PCRE2_MULTILINE are added by the library)
+  regex_handle_t *handle = zsv_pcre2_8_new(pattern_string, 0);
+  if (handle == NULL) {
+    fprintf(stderr, "Error compiling regex pattern.\n");
+    free(file_content);
+    return 1;
+  }
+
+  // Check for anchors
+  if (zsv_pcre2_8_has_anchors(pattern_string)) {
+    printf("Pattern contains ^ or $ line anchors.\n");
+  } else {
+    printf("Pattern does not contain line anchors.\n");
+  }
+
+  // Perform the match
+  int result = zsv_pcre2_8_match(handle, file_content, file_size);
+
+  if (result) {
+    printf("Match\n");
+  } else {
+    printf("No Match\n");
+  }
+
+  // Clean up
+  zsv_pcre2_8_delete(handle);
+  free(file_content);
+
+  return 0;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/pcre2-8/pcre2-8.c

@@ -0,0 +1,153 @@
+#define PCRE2_CODE_UNIT_WIDTH 8
+#include <pcre2.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "pcre2-8.h"
+
+/**
+ * @brief Defines the internal structure of the handle.
+ * We only need to store the compiled code.
+ */
+struct zsv_pcre2_handle {
+  pcre2_code *re;
+  pcre2_match_data *cached_match_data;
+};
+
+/**
+ * @brief Implementation of zsv_pcre2_8_new.
+ */
+regex_handle_t *zsv_pcre2_8_new(const char *pattern, uint32_t options) {
+  regex_handle_t *handle = calloc(1, sizeof(regex_handle_t));
+  if (handle == NULL) {
+    perror("zsv_pcre2_8_new");
+    return NULL;
+  }
+
+  int error_number;
+  PCRE2_SIZE error_offset;
+
+  // utf-8 and multiline support
+  uint32_t compile_options = options | PCRE2_UTF | PCRE2_MULTILINE;
+
+  pcre2_compile_context *compile_context = pcre2_compile_context_create_8(NULL);
+  if (compile_context == NULL) {
+    printf("Error: Failed to create compile context.\n");
+    free(handle);
+    return NULL;
+  }
+
+  // set newline convention to '\0'
+  pcre2_set_newline_8(compile_context, PCRE2_NEWLINE_NUL);
+
+  handle->re = pcre2_compile_8((PCRE2_SPTR)pattern,   // the pattern
+                               PCRE2_ZERO_TERMINATED, // pattern is zero-terminated
+                               compile_options,       // user options + UTF + MULTILINE
+                               &error_number,         // for error number
+                               &error_offset,         // for error offset
+                               compile_context        // use our configured compile context
+  );
+
+  // free the compile context (no longer needed)
+  pcre2_compile_context_free_8(compile_context);
+
+  if (handle->re == NULL) {
+    PCRE2_UCHAR buffer[256];
+    pcre2_get_error_message_8(error_number, buffer, sizeof(buffer));
+    printf("PCRE2 compilation failed for pattern \"%s\" at offset %d: %s\n", pattern, (int)error_offset, buffer);
+    free(handle);
+    return NULL;
+  }
+
+  handle->cached_match_data = pcre2_match_data_create_from_pattern_8(handle->re, NULL);
+
+  return handle;
+}
+
+/**
+ * @brief Implementation of zsv_pcre2_8_match.
+ */
+int zsv_pcre2_8_match(regex_handle_t *handle, const unsigned char *subject, size_t len) {
+  int rc = pcre2_match_8(handle->re, (PCRE2_SPTR)subject, len, 0, 0, handle->cached_match_data, NULL);
+  if (rc >= 0) // matched
+    return 1;
+  if (rc != PCRE2_ERROR_NOMATCH)
+    fprintf(stderr, "zsv_pcre2_8_match: match error %i\n", rc);
+  return 0;
+}
+
+/**
+ * @brief Implementation of zsv_pcre2_8_has_anchors.
+ */
+int zsv_pcre2_8_has_anchors(const char *pattern) {
+  int in_char_class = 0;
+
+  if (pattern == NULL) {
+    return 0;
+  }
+
+  for (int i = 0; pattern[i] != '\0'; i++) {
+    // First, check for an escape character
+    if (pattern[i] == '\\') {
+      // Check how many backslashes precede this point
+      int backslash_count = 0;
+      for (int j = i - 1; j >= 0; j--) {
+        if (pattern[j] == '\\') {
+          backslash_count++;
+        } else {
+          break;
+        }
+      }
+      // If we are on an *escaped* backslash (e.g., "\\"),
+      // it doesn't escape the *next* character.
+      if (backslash_count % 2 == 0) {
+        // This backslash is NOT itself escaped, so it *will*
+        // escape the next character. Skip the next char.
+        i++;
+        if (pattern[i] == '\0') {
+          // Pattern ended with a backslash
+          return 0;
+        }
+      }
+      // If the backslash_count is odd, this backslash *is*
+      // escaped (e.g., "\\\^"), so it does NOT escape the
+      // next character. We just continue normally.
+      continue;
+    }
+
+    // We are on a non-escaped character
+    if (in_char_class) {
+      if (pattern[i] == ']') {
+        in_char_class = 0;
+      }
+      // Inside a char class, all chars are treated as literals
+      // or class operators (like -), so we ignore ^ and $
+    } else {
+      switch (pattern[i]) {
+      case '[':
+        in_char_class = 1;
+        break;
+      case '^':
+      case '$':
+        // Found an unescaped anchor *outside* a char class
+        return 1;
+      default:
+        // Any other character
+        break;
+      }
+    }
+  }
+  return 0; // No anchors found
+}
+
+/**
+ * @brief Implementation of zsv_pcre2_8_delete.
+ */
+void zsv_pcre2_8_delete(regex_handle_t *handle) {
+  if (handle) {
+    if (handle->cached_match_data)
+      pcre2_match_data_free_8(handle->cached_match_data);
+    if (handle->re)
+      pcre2_code_free_8(handle->re);
+    free(handle);
+  }
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/pcre2-8/pcre2-8.h

@@ -0,0 +1,54 @@
+#ifndef PCRE2_8_LIB_H
+#define PCRE2_8_LIB_H
+
+#include <stddef.h> // For size_t
+#include <stdint.h> // For uint32_t
+
+/**
+ * @brief An opaque handle for a compiled regex pattern.
+ */
+typedef struct zsv_pcre2_handle regex_handle_t;
+
+/**
+ * @brief Compiles a regex pattern into a handle for matching.
+ *
+ * This function automatically enables PCRE2_UTF, PCRE2_MULTILINE,
+ * and PCRE2_NEWLINE_NUL. This configures the multiline anchors (^ and $)
+ * to use '\0' (NULL) as the line delimiter.
+ *
+ * @param pattern The null-terminated, UTF-8 encoded regex pattern.
+ * @param options Additional PCRE2_COMPILE_... options to be OR'd in.
+ * @return A pointer to a handle, or NULL on compilation error.
+ */
+regex_handle_t *zsv_pcre2_8_new(const char *pattern, uint32_t options);
+
+/**
+ * @brief Matches a compiled regex handle against a subject string.
+ *
+ * @param handle A valid handle returned from zsv_pcre2_8_new.
+ * @param subject The subject string to search.
+ * @param subject_length The length (in bytes) of the subject string.
+ * @return 1 if a match is found, 0 otherwise (no match or error).
+ */
+int zsv_pcre2_8_match(regex_handle_t *handle, const unsigned char *subject, size_t subject_length);
+
+/**
+ * @brief Checks if a pattern string contains any unescaped line anchors
+ * (^ or $) that are *not* inside a character class.
+ *
+ * This is a robust-enough check to see if a pattern is attempting
+ * line-based matching.
+ *
+ * @param pattern The null-terminated, UTF-8 encoded regex pattern.
+ * @return 1 if a line anchor is found, 0 otherwise.
+ */
+int zsv_pcre2_8_has_anchors(const char *pattern);
+
+/**
+ * @brief Frees the resources associated with a regex handle.
+ *
+ * @param handle The handle to free.
+ */
+void zsv_pcre2_8_delete(regex_handle_t *handle);
+
+#endif // PCRE2_8_LIB_H

data/ext/zsv/vendor/zsv-1.3.0/app/utils/prop.c

@@ -0,0 +1,267 @@
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <zsv.h>
+#include <zsv/utils/prop.h>
+#include <zsv/utils/cache.h>
+#include <zsv/utils/file.h>
+#include <zsv/utils/overwrite.h>
+#include <yajl_helper/yajl_helper.h>
+
+#ifndef ZSVTLS
+#ifndef NO_THREADING
+#define ZSVTLS _Thread_local
+#else
+#define ZSVTLS
+#endif
+#endif
+// see arg.c
+
+static struct zsv_prop_handler *zsv_with_default_custom_prop_handler(char mode) {
+  ZSVTLS static char zsv_default_custom_prop_initd = 0;
+  ZSVTLS static struct zsv_prop_handler zsv_default_custom_prop_handler = {0};
+
+  switch (mode) {
+  case 'c': // clear
+    memset(&zsv_default_custom_prop_handler, 0, sizeof(zsv_default_custom_prop_handler));
+    zsv_default_custom_prop_initd = 0;
+    break;
+  case 'g': // get
+    if (!zsv_default_custom_prop_initd) {
+      zsv_default_custom_prop_initd = 1;
+      zsv_default_custom_prop_handler.handler = NULL;
+      zsv_default_custom_prop_handler.ctx = NULL;
+    }
+    break;
+  }
+  return &zsv_default_custom_prop_handler;
+}
+
+ZSV_EXPORT
+void zsv_clear_default_custom_prop_handler(void) {
+  zsv_with_default_custom_prop_handler('c');
+}
+
+ZSV_EXPORT
+struct zsv_prop_handler zsv_get_default_custom_prop_handler(void) {
+  return *zsv_with_default_custom_prop_handler('g');
+}
+
+ZSV_EXPORT
+void zsv_set_default_custom_prop_handler(struct zsv_prop_handler custom_prop_handler) {
+  *zsv_with_default_custom_prop_handler(0) = custom_prop_handler;
+}
+
+// TO DO: import these through a proper header
+static int zsv_properties_parse_process_value(yajl_helper_t yh, struct json_value *value);
+
+struct zsv_properties_parser {
+  yajl_helper_t yh;
+  yajl_status stat;
+
+  // queryable data
+  struct zsv_file_properties *fp;
+  struct zsv_opts *opts;
+  struct zsv_prop_handler *custom_prop_handler;
+  const unsigned char *filepath; // path to this properties file
+};
+
+const unsigned char *zsv_properties_parser_get_filepath(void *p_) {
+  struct zsv_properties_parser *p = p_;
+  return p ? p->filepath : NULL;
+}
+
+void *zsv_properties_parser_get_custom_ctx(void *p_) {
+  struct zsv_properties_parser *p = p_;
+  return p && p->custom_prop_handler ? p->custom_prop_handler->ctx : NULL;
+}
+
+struct zsv_opts *zsv_properties_parser_get_opts(void *p_) {
+  struct zsv_properties_parser *p = p_;
+  return p ? p->opts : NULL;
+}
+
+/**
+ * Create a new properties parser
+ */
+struct zsv_properties_parser *zsv_properties_parser_new(const unsigned char *path,
+                                                        struct zsv_prop_handler *custom_prop_handler,
+                                                        struct zsv_file_properties *fp, struct zsv_opts *opts) {
+  struct zsv_properties_parser *parser = calloc(1, sizeof(*parser));
+  if (parser) {
+    parser->yh = yajl_helper_new(32,
+                                 NULL, // start_map,
+                                 NULL, // end_map,
+                                 NULL, // map_key,
+                                 NULL, // start_array,
+                                 NULL, // end_array,
+                                 zsv_properties_parse_process_value, parser);
+    if (!parser->yh)
+      free(parser);
+    else {
+      parser->custom_prop_handler = custom_prop_handler;
+      parser->fp = fp;
+      parser->filepath = path;
+      parser->opts = opts;
+      parser->stat = yajl_status_ok;
+      return parser;
+    }
+  }
+  // error
+  return NULL;
+}
+
+/**
+ * Finished parsing
+ */
+enum zsv_status zsv_properties_parse_complete(struct zsv_properties_parser *parser) {
+  if (parser && parser->stat == yajl_status_ok)
+    parser->stat = yajl_complete_parse(yajl_helper_yajl(parser->yh));
+  return parser && parser->stat == yajl_status_ok ? zsv_status_ok : zsv_status_error;
+}
+
+/**
+ * Clean up
+ */
+enum zsv_status zsv_properties_parser_destroy(struct zsv_properties_parser *parser) {
+  yajl_helper_delete(parser->yh);
+  yajl_status stat = parser->stat;
+  free(parser);
+  return stat == yajl_status_ok ? zsv_status_ok : zsv_status_error;
+}
+
+/**
+ * Load cached file properties into a zsp_opts and/or zsv_file_properties struct
+ *
+ * @param data_filepath            required file path
+ * @param opts (optional)          parser options to load. will be updated to reflect
+ *                                 what is actually used
+ * @param custom_prop_handler (optional) handler for custom properties
+ * @return zsv_status_ok on success
+ */
+struct zsv_file_properties zsv_cache_load_props(const char *data_filepath, struct zsv_opts *opts,
+                                                struct zsv_prop_handler *custom_prop_handler) {
+  // we need some memory to save the parsed properties
+  // if the caller did not provide that, use our own
+  struct zsv_file_properties tmp = {0};
+  if (!(data_filepath && *data_filepath))
+    return tmp; // e.g. input = stdin
+
+  struct zsv_file_properties *fp = &tmp;
+  struct zsv_properties_parser *p = NULL;
+  unsigned char *fn = zsv_cache_filepath((const unsigned char *)data_filepath, zsv_cache_type_property, 0, 0);
+  if (!fn)
+    tmp.stat = zsv_status_memory;
+  else {
+    FILE *f;
+    int err;
+    if (!zsv_file_readable((char *)fn, &err, &f)) {
+      if (err != ENOENT) {
+        perror((const char *)fn);
+        tmp.stat = zsv_status_error;
+      }
+    } else {
+      p = zsv_properties_parser_new(fn, custom_prop_handler, fp, opts);
+      if (!p)
+        tmp.stat = zsv_status_memory;
+      else if (p->stat != yajl_status_ok)
+        tmp.stat = zsv_status_error;
+      else {
+        unsigned char buff[1024];
+        size_t bytes_read;
+        while ((bytes_read = fread(buff, 1, sizeof(buff), f))) {
+          if ((p->stat = yajl_parse(yajl_helper_yajl(p->yh), buff, bytes_read)) != yajl_status_ok) {
+            tmp.stat = zsv_status_error;
+            break;
+          }
+        }
+        if (tmp.stat == zsv_status_ok)
+          zsv_properties_parse_complete(p);
+      }
+      fclose(f);
+    }
+    free(fn);
+  }
+
+  if (tmp.stat == zsv_status_ok) {
+    // warn if the loaded properties conflict with command-line options
+    if (fp->skip_specified) {
+      if (opts && opts->option_overrides.skip_head && opts->rows_to_ignore != fp->skip)
+        fprintf(stderr, "Warning: file property 'skip-head' overridden by command option\n");
+      else if (opts)
+        opts->rows_to_ignore = fp->skip;
+    }
+    if (fp->header_span_specified) {
+      if (opts && opts->option_overrides.header_row_span && opts->header_span != fp->header_span)
+        fprintf(stderr, "Warning: file property 'header-row-span' overridden by command option\n");
+      else if (opts)
+        opts->header_span = fp->header_span;
+    }
+  }
+  if (p && tmp.stat == zsv_status_ok && zsv_properties_parser_destroy(p) != zsv_status_ok)
+    tmp.stat = zsv_status_error;
+  return tmp;
+}
+
+static int zsv_properties_parse_process_value(yajl_helper_t yh, struct json_value *value) {
+  struct zsv_properties_parser *parser = yajl_helper_ctx(yh);
+  struct zsv_file_properties *fp = parser->fp;
+  if (yajl_helper_level_raw(yh) == 1) {
+    const char *prop_name = yajl_helper_get_map_key(yh, 0);
+    unsigned int *target = NULL;
+    if (!strcmp(prop_name, "skip-head")) {
+      target = &fp->skip;
+      fp->skip_specified = 1;
+    } else if (!strcmp(prop_name, "header-row-span")) {
+      target = &fp->header_span;
+      fp->header_span_specified = 1;
+    }
+
+    if (!target) {
+      int rc = 1;
+      struct zsv_prop_handler *custom_prop_handler = parser->custom_prop_handler;
+      if (custom_prop_handler && custom_prop_handler->handler)
+        rc = custom_prop_handler->handler(parser, prop_name, value);
+      if (rc) {
+        fprintf(stderr, "Unrecognized property: %s\n", prop_name);
+        fp->stat = zsv_status_error;
+      }
+    } else {
+      int err = 0;
+      long long i = json_value_long(value, &err);
+      if (err || i < 0 || i > UINT_MAX) {
+        fp->stat = zsv_status_error;
+        fprintf(stderr, "Invalid %s property value: should be an integer between 0 and %u", prop_name, UINT_MAX);
+      } else
+        *target = (unsigned int)i;
+    }
+  }
+  return 1;
+}
+
+/**
+ * zsv_new_with_properties(): use in lieu of zsv_new() to also merge zsv options
+ * with any saved properties (such as rows_to_ignore or header_span) for the
+ * specified input file. In the event that saved properties conflict with a
+ * command-line option, the command-line option "wins" (the property value is
+ * ignored), but a warning is printed
+ *
+ * optional `struct zsv_file_properties` supports custom file property processing
+ */
+enum zsv_status zsv_new_with_properties(struct zsv_opts *opts, struct zsv_prop_handler *custom_prop_handler,
+                                        const char *input_path, zsv_parser *handle_out) {
+  *handle_out = NULL;
+  if (input_path) {
+    struct zsv_file_properties fp = zsv_cache_load_props(input_path, opts, custom_prop_handler);
+    if (fp.stat != zsv_status_ok)
+      return fp.stat;
+  }
+#ifdef ZSV_EXTRAS
+  if (opts->overwrite_auto)
+    zsv_overwrite_auto(opts, input_path);
+#endif
+  if ((*handle_out = zsv_new(opts)))
+    return zsv_status_ok;
+  return zsv_status_memory;
+}

data/ext/zsv/vendor/zsv-1.3.0/app/utils/signal.c

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2021 Liquidaty and the zsv/lib contributors
+ * All rights reserved
+ *
+ * This file is part of zsv/lib, distributed under the license defined at
+ * https://opensource.org/licenses/MIT
+ */
+
+#include <signal.h>
+#include <stdio.h>
+#include <string.h>
+
+volatile sig_atomic_t zsv_signal_interrupted = 0;
+
+#ifdef _WIN32
+#include <windows.h>
+
+static int consoleHandler(DWORD signal) {
+  if (signal == CTRL_C_EVENT) {
+    if (!zsv_signal_interrupted) {
+      zsv_signal_interrupted = 1;
+      fclose(stdin);
+      return 1;
+    }
+  }
+  return 0;
+}
+
+void zsv_handle_ctrl_c_signal(void) {
+  if (!SetConsoleCtrlHandler(consoleHandler, 1))
+    fprintf(stderr, "Warning: unable to set signal handler\n");
+}
+
+#else
+
+// handle signal interrupts: first Ctrl-C sets interrupt
+// second reverts to default Ctrl-C behavior
+
+static void INThandler(int sig) {
+  signal(sig, SIG_IGN); // ignore
+  if (!zsv_signal_interrupted) {
+    zsv_signal_interrupted = 1;
+    signal(SIGINT, NULL); // restore default handler
+  }
+}
+
+void zsv_handle_ctrl_c_signal(void) {
+  // sigaction only ADDs the handler instead of REPLACING it
+  // so we will use signal() instead
+  signal(SIGINT, INThandler);
+}
+
+#endif