zsv 1.3.1 → 1.4.3

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

@@ -1,400 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-#include <zsv/utils/string.h>
-#include <zsv/utils/writer.h>
-#include <zsv/utils/jq.h>
-#include <jq.h>
-#include <jv.h>
-
-// all jv_ functions defined here consume their jv value
-// consumes:
-//  jv_string_length_bytes
-//  jv_dumpf
-//  jv_dump_string
-//
-// does not consume:
-//  jv_number_value
-//  jv_string_value
-//  jv_get_kind
-
-static int jv_print_scalar_str(jv value, char inside_string, FILE *f, char as_csv) {
-  f = f ? f : stdout;
-  switch (jv_get_kind(value)) {
-  case JV_KIND_STRING: {
-    size_t len = jv_string_length_bytes(jv_copy(value));
-    const char *s = jv_string_value(value);
-    if (!as_csv)
-      fprintf(f, "%.*s", (int)len, s);
-    else {
-      unsigned char *csv = zsv_csv_quote((unsigned char *)s, len, NULL, 0);
-      if (!csv)
-        fprintf(f, "%.*s", (int)len, s);
-      else {
-        if (inside_string)
-          fprintf(f, "%s%.*s", inside_string > 1 ? ";" : "", (int)(strlen((char *)csv) - 2), csv + 1);
-        else
-          fprintf(f, "%s", csv);
-        free(csv);
-      }
-    }
-    jv_free(value);
-    return 1;
-  } break;
-  default:
-    break;
-  }
-  jv_free(value);
-  return 0;
-}
-
-static int jv_print_scalar(jv value, char inside_string, FILE *f, char as_csv) {
-  f = f ? f : stdout;
-  switch (jv_get_kind(value)) {
-  case JV_KIND_INVALID:
-    fprintf(f, "<invalid json>");
-    jv_free(value);
-    return 1;
-  case JV_KIND_NULL:
-    fprintf(f, "null");
-    jv_free(value);
-    return 1;
-  case JV_KIND_TRUE:
-    fprintf(f, "true");
-    jv_free(value);
-    return 1;
-  case JV_KIND_FALSE:
-    fprintf(f, "false");
-    jv_free(value);
-    return 1;
-  case JV_KIND_NUMBER: {
-    char s[64];
-    int n = snprintf(s, sizeof(s), "%lf", jv_number_value(value));
-    if (n > 0 && (size_t)n < sizeof(s))
-      fprintf(f, "%.*s", (int)zsv_strip_trailing_zeros(s, n), s);
-  }
-    jv_free(value);
-    return 1;
-  default:
-    return jv_print_scalar_str(value, inside_string, f, as_csv);
-  }
-}
-
-static void jv_to_csv_aux(jv value, FILE *f, int inside_string) {
-  f = f ? f : stdout;
-  if (!jv_print_scalar(jv_copy(value), inside_string, f, 1)) {
-    switch (jv_get_kind(value)) {
-    case JV_KIND_ARRAY:
-      // flatten
-      if (!inside_string)
-        fprintf(f, "\"");
-      jv_array_foreach(value, i, item) {
-        if (i)
-          fprintf(f, ";");
-        jv_to_csv_aux(item, f, 1);
-      }
-      if (!inside_string)
-        fprintf(f, "\"");
-      break;
-    case JV_KIND_OBJECT:
-      // flatten
-      if (!inside_string)
-        fprintf(f, "\"");
-      jv_object_foreach(value, key, item) {
-        jv_print_scalar(key, 1, f, 1);
-        fprintf(f, ":");
-        jv_to_csv_aux(item, f, 1);
-        fprintf(f, ";");
-      }
-      if (!inside_string)
-        fprintf(f, "\"");
-      break;
-    default:
-      break;
-    }
-  }
-  jv_free(value);
-}
-
-size_t zsv_jq_fwrite1(void *restrict FILE_ptr, const void *restrict buff, size_t len) {
-  return fwrite(buff, len, 1, FILE_ptr);
-}
-
-void jv_to_json_func(jv value, void *ctx) {
-  struct jv_to_json_ctx *data = ctx;
-  if (data->output_started)
-    data->write1(data->ctx, "\n", 1);
-  data->output_started = 1;
-  if (data->write1 == zsv_jq_fwrite1) {
-    if (data->raw_output && jv_get_kind(value) == JV_KIND_STRING)
-      fwrite(jv_string_value(value), 1, jv_string_length_bytes(jv_copy(value)), data->ctx);
-    else
-      jv_dumpf(value, data->ctx, data->flags);
-  } else {
-    // jv_dump_string is memory-inefficient
-    // would be better to create custom dump function that, instead of writing to string buffer,
-    // could directly invoke func()
-    jv jv_s = jv_dump_string(value, data->flags);
-    const char *p = jv_string_value(jv_s);
-    size_t len = jv_string_length_bytes(jv_copy(jv_s));
-    if (len)
-      data->write1(data->ctx, p, len);
-    jv_free(jv_s);
-  }
-}
-
-void jv_to_csv_multi(jv value, void *jv_to_csv_multi_ctx) {
-  struct jv_to_csv_multi_ctx *ctx = jv_to_csv_multi_ctx;
-  FILE *f = ctx->get_file(ctx->ctx);
-  jv_to_csv(value, f);
-}
-
-void jv_to_csv(jv value, void *file) {
-  FILE *f = file;
-  f = f ? f : stdout;
-  if (jv_print_scalar(jv_copy(value), 0, f, 1))
-    fprintf(f, "\n");
-  else {
-    switch (jv_get_kind(value)) {
-    case JV_KIND_ARRAY:
-      jv_array_foreach(value, i, item) {
-        if (i)
-          fprintf(f, ",");
-        jv_to_csv_aux(item, f, 0);
-      }
-      fprintf(f, "\n");
-      break;
-    case JV_KIND_OBJECT:
-      jv_object_foreach(value, key, item) {
-        jv_print_scalar(key, 0, f, 1);
-        fprintf(f, ",");
-        jv_to_csv_aux(item, f, 0);
-        fprintf(f, "\n");
-      }
-      fprintf(f, "\n");
-      break;
-    default:
-      break;
-    }
-  }
-  jv_free(value);
-}
-
-static void jv_to_txt_aux(jv value, FILE *f) {
-  f = f ? f : stdout;
-  if (!jv_print_scalar(jv_copy(value), 0, f, 0)) {
-    switch (jv_get_kind(value)) {
-    case JV_KIND_ARRAY:
-      // flatten
-      fprintf(f, "[");
-      jv_array_foreach(value, i, item) {
-        if (i)
-          fprintf(f, ";");
-        jv_to_txt_aux(item, f);
-      }
-      fprintf(f, "]");
-      break;
-    case JV_KIND_OBJECT:
-      // flatten
-      fprintf(f, "{");
-      jv_object_foreach(value, key, item) {
-        jv_print_scalar(key, 1, f, 0);
-        fprintf(f, ":");
-        jv_to_txt_aux(item, f);
-        fprintf(f, ";");
-      }
-      fprintf(f, "}");
-      break;
-    default:
-      break;
-    }
-  }
-  jv_free(value);
-}
-
-void jv_to_txt(jv value, void *file) {
-  FILE *f = file;
-  f = f ? f : stdout;
-  if (jv_print_scalar(jv_copy(value), 0, f, 0))
-    fprintf(f, "\n");
-  else {
-    switch (jv_get_kind(value)) {
-    case JV_KIND_ARRAY:
-      jv_array_foreach(value, i, item) {
-        if (i)
-          fprintf(f, ",");
-        jv_to_txt_aux(item, f);
-      }
-      fprintf(f, "\n");
-      break;
-    case JV_KIND_OBJECT:
-      jv_object_foreach(value, key, item) {
-        jv_print_scalar(key, 0, f, 0);
-        fprintf(f, ",");
-        jv_to_txt_aux(item, f);
-        fprintf(f, "\n");
-      }
-      fprintf(f, "\n");
-      break;
-    default:
-      break;
-    }
-  }
-  jv_free(value);
-}
-
-void jv_to_lqjq(jv value, void *h) {
-  zsv_jq_handle lqjq = h;
-
-  // jv_dump_string is memory-inefficient
-  // would be better to create custom dump function that, instead of writing to string buffer,
-  // could directly invoke func()
-  jv jv_s = jv_dump_string(value, 0);
-  size_t len = jv_string_length_bytes(jv_copy(jv_s));
-  const char *p = jv_string_value(jv_s);
-  if (len)
-    zsv_jq_parse(lqjq, p, len);
-  jv_free(jv_s);
-}
-
-struct zsv_jq_data {
-  void *jq;
-  struct jv_parser *parser;
-  void (*func)(jv, void *);
-  void *ctx;
-
-  FILE *trace;
-  enum zsv_jq_status status;
-  unsigned char non_null : 1;
-  unsigned char _ : 7;
-};
-
-static zsv_jq_handle zsv_jq_new_aux(const unsigned char *filter, void (*func)(jv, void *), void *ctx,
-                                    enum zsv_jq_status *statusp, int init_flags) {
-  enum zsv_jq_status status = zsv_jq_status_ok;
-  struct zsv_jq_data *d = calloc(1, sizeof(*d));
-  if (!d || !(d->jq = jq_init()) || !(d->parser = jv_parser_new(init_flags)))
-    status = zsv_jq_status_memory;
-  else if (!jq_compile(d->jq, (const char *)filter))
-    status = d->status = zsv_jq_status_compile;
-  if (status == zsv_jq_status_ok) {
-    d->func = func;
-    d->ctx = ctx;
-  } else {
-    zsv_jq_delete(d);
-    d = NULL;
-  }
-  if (statusp)
-    *statusp = status;
-  return d;
-}
-
-zsv_jq_handle zsv_jq_new(const unsigned char *filter, void (*func)(jv, void *), void *ctx,
-                         enum zsv_jq_status *statusp) {
-  return zsv_jq_new_aux(filter, func, ctx, statusp, 0);
-}
-
-zsv_jq_handle zsv_jq_new_stream(const unsigned char *filter, void (*func)(jv, void *), void *ctx,
-                                enum zsv_jq_status *statusp) {
-  return zsv_jq_new_aux(filter, func, ctx, statusp, JV_PARSE_STREAMING);
-}
-
-void zsv_jq_delete(zsv_jq_handle h) {
-  if (h) {
-    if (h->parser)
-      jv_parser_free(h->parser);
-    if (h->jq)
-      jq_teardown((jq_state **)&h->jq);
-    free(h);
-  }
-}
-
-static int zsv_jq_process(jq_state *jq, jv value, void (*func)(jv, void *), void *ctx);
-
-size_t zsv_jq_write(const char *s, size_t n, size_t m, zsv_jq_handle h) {
-  zsv_jq_parse(h, s, n * m);
-  return n * m;
-}
-
-enum zsv_jq_status zsv_jq_parse_file(zsv_jq_handle h, FILE *f) {
-  char buff[4096];
-  for (size_t bytes_read = fread(buff, 1, sizeof(buff), f); bytes_read && h->status == zsv_jq_status_ok;
-       bytes_read = fread(buff, 1, sizeof(buff), f)) {
-    zsv_jq_parse(h, buff, bytes_read);
-    if (feof(f))
-      break;
-  }
-  return h->status;
-}
-
-enum zsv_jq_status zsv_jq_parse(zsv_jq_handle restrict h, const void *restrict s, size_t len) {
-  if (h->status != zsv_jq_status_ok)
-    return h->status;
-
-  jv_parser_set_buf(h->parser, (const char *)s, len, 1);
-  if (h->trace)
-    fwrite(s, len, 1, h->trace);
-
-  jv value;
-  while (jv_is_valid(value = jv_parser_next(h->parser))) {
-    if (!h->non_null && jv_get_kind(value) != JV_KIND_NULL)
-      h->non_null = 1;
-    zsv_jq_process(h->jq, value, h->func, h->ctx);
-  }
-
-  jv msg = jv_invalid_get_msg(value);
-  if (jv_get_kind(msg) == JV_KIND_STRING) {
-    fprintf(stderr, "jq: parse error: %s\n", jv_string_value(msg));
-    h->status = zsv_jq_status_error;
-  } else
-    jv_free(msg);
-  jv_free(value);
-
-  return h->status;
-}
-
-void zsv_jq_trace(zsv_jq_handle h, FILE *trace) {
-  if (h)
-    h->trace = trace;
-}
-
-enum zsv_jq_status zsv_jq_finish(zsv_jq_handle h) {
-  jv value;
-  jv_parser_set_buf(h->parser, "", 0, 0);
-  while (jv_is_valid(value = jv_parser_next(h->parser)))
-    zsv_jq_process(h->jq, value, h->func, h->ctx);
-  return zsv_jq_status_ok;
-}
-
-static int zsv_jq_process(jq_state *jq,
-                          jv value, // will be consumed
-                          void (*func)(jv, void *), void *ctx) {
-  int ret = 14;           // No valid results && -e -> exit(4)
-  jq_start(jq, value, 0); // consumes value
-
-  jv result;
-  while (jv_is_valid(result = jq_next(jq))) {
-    ret = 0;
-    func(result, ctx);
-  }
-  jv_free(result);
-
-  return ret;
-}
-
-void jv_to_bool(jv value, void *char_result) {
-  char *c = char_result;
-  switch (jv_get_kind(value)) {
-  case JV_KIND_TRUE:
-    *c = 1;
-    break;
-  case JV_KIND_FALSE:
-    *c = 0;
-    break;
-  case JV_KIND_NUMBER:
-    *c = (jv_number_value(value) > 0);
-    break;
-  default:
-    break;
-  }
-  jv_free(value);
-}

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

@@ -1,120 +0,0 @@
-/*
- * 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 <stdlib.h>
-#include <string.h>
-#include <stddef.h>
-
-static inline char is_json_esc_char(unsigned char c) {
-  return (c == '"' || c == '\\' || c < 32);
-}
-
-static void str2hex(unsigned char *to, const unsigned char *p, size_t len) {
-  static const char *hex = "0123456789abcdef";
-
-  for (; len--; p++) {
-    *to++ = hex[p[0] >> 4];
-    *to++ = hex[p[0] & 0x0f];
-  }
-}
-
-static inline unsigned json_esc_char(unsigned char c, char replace[]) {
-  unsigned replacelen;
-  char hex = 0;
-  switch (c) {
-  case '"':
-    replace[1] = '"';
-    break;
-  case '\\':
-    replace[1] = '\\';
-    break;
-  case '\b':
-    replace[1] = 'b';
-    break;
-  case '\f':
-    replace[1] = 'f';
-    break;
-  case '\n':
-    replace[1] = 'n';
-    break;
-  case '\r':
-    replace[1] = 'r';
-    break;
-  case '\t':
-    replace[1] = 't';
-    break;
-  default:
-    hex = 1;
-  }
-
-  replace[0] = '\\';
-  if (hex) {
-    // unicode-hex: but 2/3 are not always zeroes...
-    replace[1] = 'u';
-    replace[2] = '0';
-    replace[3] = '0';
-    str2hex((unsigned char *)replace + 4, &c, 1);
-    replacelen = 6;
-    replace[6] = '\0';
-  } else {
-    replacelen = 2;
-    replace[2] = '\0';
-  }
-  return replacelen;
-}
-
-static unsigned json_escaped_str_len(const unsigned char *s, size_t len) {
-  unsigned count = 0;
-  for (size_t i = 0; i < len; i++, count++) {
-    switch (s[i]) {
-    case '"':
-    case '\\':
-    case '\b':
-    case '\f':
-    case '\n':
-    case '\r':
-    case '\t':
-      count++;
-      break;
-    default:
-      if (s[i] < 31)
-        count += 6;
-      break;
-    }
-  }
-  return count + 2; // + 2 for surrounding quotation marks
-}
-
-unsigned char *zsv_json_from_str_n(const unsigned char *s, size_t len) {
-  size_t new_len = json_escaped_str_len(s, len);
-  unsigned char *new_s = calloc(new_len + 2, sizeof(*new_s));
-  if (new_s) {
-    new_s[0] = new_s[new_len - 1] = (unsigned char)'"';
-    if (new_len == len + 2)
-      memcpy(new_s + 1, s, len);
-    else {
-      char replace[8];
-      for (size_t i = 0, j = 1; i < len && j < new_len - 1; i++) {
-        if (!is_json_esc_char(s[i]))
-          new_s[j++] = s[i];
-        else {
-          size_t rlen = json_esc_char(s[i], replace);
-          memcpy(new_s + j, replace, rlen);
-          j += rlen;
-        }
-      }
-    }
-  }
-  return new_s;
-}
-
-unsigned char *zsv_json_from_str(const unsigned char *s) {
-  if (!s)
-    return (unsigned char *)strdup("null");
-  return zsv_json_from_str_n(s, strlen((const char *)s));
-}

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

@@ -1,18 +0,0 @@
-/*
- * 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 <stdlib.h> // calloc
-#include <string.h> // memcpy
-
-/* zsv_memdup(): return copy with double-NULL terminator. caller must free() */
-void *zsv_memdup(const void *src, size_t n) {
-  void *m = calloc(1, n + 2);
-  if (n)
-    memcpy(m, src, n);
-  return m;
-}

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

@@ -1,132 +0,0 @@
-// from musl 1.37.5 system/lib/libc/musl/src/string/memmem.c
-// clang-format off
-#include <string.h>
-#include <stdint.h>
-static char *twobyte_memmem(const unsigned char *h, size_t k, const unsigned char *n)
-{
-	uint16_t nw = n[0]<<8 | n[1], hw = h[0]<<8 | h[1];
-	for (h++, k--; k; k--, hw = hw<<8 | *++h)
-		if (hw == nw) return (char *)h-1;
-	return 0;
-}
-static char *threebyte_memmem(const unsigned char *h, size_t k, const unsigned char *n)
-{
-	uint32_t nw = n[0]<<24 | n[1]<<16 | n[2]<<8;
-	uint32_t hw = h[0]<<24 | h[1]<<16 | h[2]<<8;
-	for (h+=2, k-=2; k; k--, hw = (hw|*++h)<<8)
-		if (hw == nw) return (char *)h-2;
-	return 0;
-}
-static char *fourbyte_memmem(const unsigned char *h, size_t k, const unsigned char *n)
-{
-	uint32_t nw = n[0]<<24 | n[1]<<16 | n[2]<<8 | n[3];
-	uint32_t hw = h[0]<<24 | h[1]<<16 | h[2]<<8 | h[3];
-	for (h+=3, k-=3; k; k--, hw = hw<<8 | *++h)
-		if (hw == nw) return (char *)h-3;
-	return 0;
-}
-#define MAX(a,b) ((a)>(b)?(a):(b))
-#define MIN(a,b) ((a)<(b)?(a):(b))
-#define BITOP(a,b,op) \
- ((a)[(size_t)(b)/(8*sizeof *(a))] op (size_t)1<<((size_t)(b)%(8*sizeof *(a))))
-static char *twoway_memmem(const unsigned char *h, const unsigned char *z, const unsigned char *n, size_t l)
-{
-	size_t i, ip, jp, k, p, ms, p0, mem, mem0;
-	size_t byteset[32 / sizeof(size_t)] = { 0 };
-	size_t shift[256];
-	/* Computing length of needle and fill shift table */
-	for (i=0; i<l; i++)
-		BITOP(byteset, n[i], |=), shift[n[i]] = i+1;
-	/* Compute maximal suffix */
-	ip = -1; jp = 0; k = p = 1;
-	while (jp+k<l) {
-		if (n[ip+k] == n[jp+k]) {
-			if (k == p) {
-				jp += p;
-				k = 1;
-			} else k++;
-		} else if (n[ip+k] > n[jp+k]) {
-			jp += k;
-			k = 1;
-			p = jp - ip;
-		} else {
-			ip = jp++;
-			k = p = 1;
-		}
-	}
-	ms = ip;
-	p0 = p;
-	/* And with the opposite comparison */
-	ip = -1; jp = 0; k = p = 1;
-	while (jp+k<l) {
-		if (n[ip+k] == n[jp+k]) {
-			if (k == p) {
-				jp += p;
-				k = 1;
-			} else k++;
-		} else if (n[ip+k] < n[jp+k]) {
-			jp += k;
-			k = 1;
-			p = jp - ip;
-		} else {
-			ip = jp++;
-			k = p = 1;
-		}
-	}
-	if (ip+1 > ms+1) ms = ip;
-	else p = p0;
-	/* Periodic needle? */
-	if (memcmp(n, n+p, ms+1)) {
-		mem0 = 0;
-		p = MAX(ms, l-ms-1) + 1;
-	} else mem0 = l-p;
-	mem = 0;
-	/* Search loop */
-	for (;;) {
-		/* If remainder of haystack is shorter than needle, done */
-		if (z-h < l) return 0;
-		/* Check last byte first; advance by shift on mismatch */
-		if (BITOP(byteset, h[l-1], &)) {
-			k = l-shift[h[l-1]];
-			if (k) {
-				if (mem0 && mem && k < p) k = l-p;
-				h += k;
-				mem = 0;
-				continue;
-			}
-		} else {
-			h += l;
-			mem = 0;
-			continue;
-		}
-		/* Compare right half */
-		for (k=MAX(ms+1,mem); k<l && n[k] == h[k]; k++);
-		if (k < l) {
-			h += k-ms;
-			mem = 0;
-			continue;
-		}
-		/* Compare left half */
-		for (k=ms+1; k>mem && n[k-1] == h[k-1]; k--);
-		if (k <= mem) return (char *)h;
-		h += p;
-		mem = mem0;
-	}
-}
-void *zsvmemmem(const void *h0, size_t k, const void *n0, size_t l)
-{
-	const unsigned char *h = h0, *n = n0;
-	/* Return immediately on empty needle */
-	if (!l) return (void *)h;
-	/* Return immediately when needle is longer than haystack */
-	if (k<l) return 0;
-	/* Use faster algorithms for short needles */
-	h = memchr(h0, *n, k);
-	if (!h || l==1) return (void *)h;
-	k -= h - (const unsigned char *)h0;
-	if (k<l) return 0;
-	if (l==2) return twobyte_memmem(h, k, n);
-	if (l==3) return threebyte_memmem(h, k, n);
-	if (l==4) return fourbyte_memmem(h, k, n);
-	return twoway_memmem(h, h+k, n, l);
-}