@port-labs/jq-node-bindings 0.0.13 → 0.0.15-dev1

package/deps/jq/src/jv.h

@@ -5,6 +5,17 @@
 #include <stdint.h>
 #include <stdio.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ >= 7) || \
+    (defined(__clang__) && __clang_major__ >= 10)
+# define JQ_FALLTHROUGH __attribute__((fallthrough))
+#else
+# define JQ_FALLTHROUGH do {} while (0) /* fallthrough */
+#endif
+
 typedef enum {
   JV_KIND_INVALID,
   JV_KIND_NULL,
@@ -54,16 +65,19 @@ jv jv_invalid_with_msg(jv);
 jv jv_invalid_get_msg(jv);
 int jv_invalid_has_msg(jv);
 
-
 jv jv_null(void);
 jv jv_true(void);
 jv jv_false(void);
 jv jv_bool(int);
 
 jv jv_number(double);
+jv jv_number_with_literal(const char*);
 double jv_number_value(jv);
 int jv_is_integer(jv);
 
+int jv_number_has_literal(jv n);
+const char* jv_number_get_literal(jv);
+
 jv jv_array(void);
 jv jv_array_sized(int);
 int jv_array_length(jv);
@@ -99,6 +113,9 @@ jv jv_array_indexes(jv, jv);
   __attribute__ ((__format__( __printf__, fmt_arg_num, args_num)))
 #define JV_VPRINTF_LIKE(fmt_arg_num) \
   __attribute__ ((__format__( __printf__, fmt_arg_num, 0)))
+#else
+#define JV_PRINTF_LIKE(fmt_arg_num, args_num)
+#define JV_VPRINTF_LIKE(fmt_arg_num)
 #endif
 
 
@@ -224,6 +241,7 @@ enum {
 
 jv jv_parse(const char* string);
 jv jv_parse_sized(const char* string, int length);
+jv jv_parse_custom_flags(const char* string, int flags);
 
 typedef void (*jv_nomem_handler_f)(void *);
 void jv_nomem_handler(jv_nomem_handler_f, void *);
@@ -249,6 +267,9 @@ int jv_cmp(jv, jv);
 jv jv_group(jv, jv);
 jv jv_sort(jv, jv);
 
+#ifdef __cplusplus
+}
+#endif
 
 #endif
 

package/deps/jq/src/jv_alloc.c

@@ -37,7 +37,7 @@ static void memory_exhausted() {
   if (nomem_handler.handler)
     nomem_handler.handler(nomem_handler.data); // Maybe handler() will longjmp() to safety
   // Or not
-  fprintf(stderr, "error: cannot allocate memory\n");
+  fprintf(stderr, "jq: error: cannot allocate memory\n");
   abort();
 }
 #else /* USE_TLS */
@@ -45,9 +45,11 @@ static void memory_exhausted() {
 #ifdef HAVE_PTHREAD_KEY_CREATE
 #include <pthread.h>
 
-pthread_key_t nomem_handler_key;
-pthread_once_t mem_once = PTHREAD_ONCE_INIT;
+static pthread_key_t nomem_handler_key;
+static pthread_once_t mem_once = PTHREAD_ONCE_INIT;
 
+/* tsd_fini is called on application exit */
+/* it clears the nomem_handler allocated in the main thread */
 static void tsd_fini(void) {
   struct nomem_handler *nomem_handler;
   nomem_handler = pthread_getspecific(nomem_handler_key);
@@ -57,30 +59,45 @@ static void tsd_fini(void) {
   }
 }
 
+/* The tsd_fini_thread is a destructor set by calling */
+/* pthread_key_create(&nomem_handler_key, tsd_fini_thread) */
+/* It is called when thread ends */
+static void tsd_fini_thread(void *nomem_handler) {
+  free(nomem_handler);
+}
+
 static void tsd_init(void) {
-  if (pthread_key_create(&nomem_handler_key, NULL) != 0) {
-    fprintf(stderr, "error: cannot create thread specific key");
+  if (pthread_key_create(&nomem_handler_key, tsd_fini_thread) != 0) {
+    fprintf(stderr, "jq: error: cannot create thread specific key");
     abort();
   }
   if (atexit(tsd_fini) != 0) {
-    fprintf(stderr, "error: cannot set an exit handler");
+    fprintf(stderr, "jq: error: cannot set an exit handler");
     abort();
   }
-  struct nomem_handler *nomem_handler = calloc(1, sizeof(struct nomem_handler));
-  if (pthread_setspecific(nomem_handler_key, nomem_handler) != 0) {
-    fprintf(stderr, "error: cannot set thread specific data");
-    abort();
+}
+
+static void tsd_init_nomem_handler(void)
+{
+  if (pthread_getspecific(nomem_handler_key) == NULL) {
+    struct nomem_handler *nomem_handler = calloc(1, sizeof(struct nomem_handler));
+    if (pthread_setspecific(nomem_handler_key, nomem_handler) != 0) {
+      fprintf(stderr, "jq: error: cannot set thread specific data");
+      abort();
+    }
   }
 }
 
 void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
   pthread_once(&mem_once, tsd_init); // cannot fail
+  tsd_init_nomem_handler();
+
   struct nomem_handler *nomem_handler;
 
   nomem_handler = pthread_getspecific(nomem_handler_key);
   if (nomem_handler == NULL) {
     handler(data);
-    fprintf(stderr, "error: cannot allocate memory\n");
+    fprintf(stderr, "jq: error: cannot allocate memory\n");
     abort();
   }
   nomem_handler->handler = handler;
@@ -91,11 +108,13 @@ static void memory_exhausted() {
   struct nomem_handler *nomem_handler;
 
   pthread_once(&mem_once, tsd_init);
+  tsd_init_nomem_handler();
+
   nomem_handler = pthread_getspecific(nomem_handler_key);
-  if (nomem_handler)
+  if (nomem_handler && nomem_handler->handler)
     nomem_handler->handler(nomem_handler->data); // Maybe handler() will longjmp() to safety
   // Or not
-  fprintf(stderr, "error: cannot allocate memory\n");
+  fprintf(stderr, "jq: error: cannot allocate memory\n");
   abort();
 }
 
@@ -110,7 +129,7 @@ void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
 }
 
 static void memory_exhausted() {
-  fprintf(stderr, "error: cannot allocate memory\n");
+  fprintf(stderr, "jq: error: cannot allocate memory\n");
   abort();
 }
 
@@ -165,15 +184,3 @@ void* jv_mem_realloc(void* p, size_t sz) {
   }
   return p;
 }
-
-#ifndef NDEBUG
-volatile char jv_mem_uninitialised;
-__attribute__((constructor)) void jv_mem_uninit_setup(){
-  // ignore warning that this reads uninitialized memory - that's the point!
-#ifndef __clang_analyzer__
-  char* p = malloc(1);
-  jv_mem_uninitialised = *p;
-  free(p);
-#endif
-}
-#endif

package/deps/jq/src/jv_alloc.h

@@ -4,17 +4,6 @@
 #include <stddef.h>
 #include "jv.h"
 
-#ifndef NDEBUG
-extern volatile char jv_mem_uninitialised;
-#endif
-
-static void jv_mem_invalidate(void* mem, size_t n) {
-#ifndef NDEBUG
-  char* m = mem;
-  while (n--) *m++ ^= jv_mem_uninitialised ^ jv_mem_uninitialised;
-#endif
-}
-
 void* jv_mem_alloc(size_t);
 void* jv_mem_alloc_unguarded(size_t);
 void* jv_mem_calloc(size_t, size_t);

package/deps/jq/src/jv_aux.c

@@ -1,9 +1,21 @@
+#include <assert.h>
+#include <limits.h>
+#include <math.h>
 #include <string.h>
 #include <stdlib.h>
-#include <assert.h>
 #include "jv_alloc.h"
+#include "jv_private.h"
+
+// making this static verbose function here
+// until we introduce a less confusing naming scheme
+// of jv_* API with regards to the memory management
+static double jv_number_get_value_and_consume(jv number) {
+  double value = jv_number_value(number);
+  jv_free(number);
+  return value;
+}
 
-static int parse_slice(jv j, jv slice, int* pstart, int* pend) {
+static jv parse_slice(jv j, jv slice, int* pstart, int* pend) {
   // Array slices
   jv start_jv = jv_object_get(jv_copy(slice), jv_string("start"));
   jv end_jv = jv_object_get(slice, jv_string("end"));
@@ -17,8 +29,14 @@ static int parse_slice(jv j, jv slice, int* pstart, int* pend) {
   } else if (jv_get_kind(j) == JV_KIND_STRING) {
     len = jv_string_length_codepoints(j);
   } else {
+    /*
+     * XXX This should be dead code because callers shouldn't call this
+     * function if `j' is neither an array nor a string.
+     */
     jv_free(j);
-    return 0;
+    jv_free(start_jv);
+    jv_free(end_jv);
+    return jv_invalid_with_msg(jv_string("Only arrays and strings can be sliced"));
   }
   if (jv_get_kind(end_jv) == JV_KIND_NULL) {
     jv_free(end_jv);
@@ -28,27 +46,34 @@ static int parse_slice(jv j, jv slice, int* pstart, int* pend) {
       jv_get_kind(end_jv) != JV_KIND_NUMBER) {
     jv_free(start_jv);
     jv_free(end_jv);
-    return 0;
-  } else {
-    double dstart = jv_number_value(start_jv);
-    double dend = jv_number_value(end_jv);
-    if (dstart < 0) dstart += len;
-    if (dend < 0) dend += len;
-    if (dstart < 0) dstart = 0;
-    if (dstart > len) dstart = len;
-
-    int start = (int)dstart;
-    int end = (dend > len) ? len : (int)dend;
-    // Ends are exclusive but e.g. 1 < 1.5 so :1.5 should be :2 not :1
-    if(end < dend) end += 1;
-
-    if (end > len) end = len;
-    if (end < start) end = start;
-    assert(0 <= start && start <= end && end <= len);
-    *pstart = start;
-    *pend = end;
-    return 1;
+    return jv_invalid_with_msg(jv_string("Array/string slice indices must be integers"));
   }
+
+  double dstart = jv_number_value(start_jv);
+  double dend = jv_number_value(end_jv);
+  int start, end;
+
+  jv_free(start_jv);
+  jv_free(end_jv);
+  if (isnan(dstart)) dstart = 0;
+  if (dstart < 0)    dstart += len;
+  if (dstart < 0)    dstart = 0;
+  if (dstart > len)  dstart = len;
+  start = dstart > INT_MAX ? INT_MAX : (int)dstart; // Rounds down
+
+  if (isnan(dend))   dend = len;
+  if (dend < 0)      dend += len;
+  if (dend < 0)      dend  = start;
+  end = dend > INT_MAX ? INT_MAX : (int)dend;
+  if (end > len)     end = len;
+  if (end < len)     end += end < dend ? 1 : 0; // We round start down
+                                                // but round end up
+
+  if (end < start) end = start;
+  assert(0 <= start && start <= end && end <= len);
+  *pstart = start;
+  *pend = end;
+  return jv_true();
 }
 
 jv jv_get(jv t, jv k) {
@@ -60,35 +85,44 @@ jv jv_get(jv t, jv k) {
       v = jv_null();
     }
   } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
-    if(jv_is_integer(k)){
-      int idx = (int)jv_number_value(k);
-      if (idx < 0)
-        idx += jv_array_length(jv_copy(t));
-      v = jv_array_get(t, idx);
-      if (!jv_is_valid(v)) {
-        jv_free(v);
-        v = jv_null();
-      }
-    } else {
+    if (jvp_number_is_nan(k)) {
       jv_free(t);
-      jv_free(k);
       v = jv_null();
+    } else {
+      double didx = jv_number_value(k);
+      if (jvp_number_is_nan(k)) {
+        v = jv_null();
+      } else {
+        if (didx < INT_MIN) didx = INT_MIN;
+        if (didx > INT_MAX) didx = INT_MAX;
+        int idx = (int)didx;
+        if (idx < 0)
+          idx += jv_array_length(jv_copy(t));
+        v = jv_array_get(t, idx);
+        if (!jv_is_valid(v)) {
+          jv_free(v);
+          v = jv_null();
+        }
+      }
     }
+    jv_free(k);
   } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_OBJECT) {
     int start, end;
-    if (parse_slice(jv_copy(t), k, &start, &end)) {
+    jv e = parse_slice(jv_copy(t), k, &start, &end);
+    if (jv_get_kind(e) == JV_KIND_TRUE) {
       v = jv_array_slice(t, start, end);
     } else {
       jv_free(t);
-      v = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
+      v = e;
     }
   } else if (jv_get_kind(t) == JV_KIND_STRING && jv_get_kind(k) == JV_KIND_OBJECT) {
     int start, end;
-    if (parse_slice(jv_copy(t), k, &start, &end)) {
+    jv e = parse_slice(jv_copy(t), k, &start, &end);
+    if (jv_get_kind(e) == JV_KIND_TRUE) {
       v = jv_string_slice(t, start, end);
     } else {
-      v = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an string slice must be numbers"));
       jv_free(t);
+      v = e;
     }
   } else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_ARRAY) {
     v = jv_array_indexes(t, k);
@@ -133,13 +167,24 @@ jv jv_set(jv t, jv k, jv v) {
     t = jv_object_set(t, k, v);
   } else if (jv_get_kind(k) == JV_KIND_NUMBER &&
              (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
-    if (isnull) t = jv_array();
-    t = jv_array_set(t, (int)jv_number_value(k), v);
+    if (jvp_number_is_nan(k)) {
+      jv_free(t);
+      jv_free(k);
+      t = jv_invalid_with_msg(jv_string("Cannot set array element at NaN index"));
+    } else {
+      double didx = jv_number_value(k);
+      if (didx < INT_MIN) didx = INT_MIN;
+      if (didx > INT_MAX) didx = INT_MAX;
+      if (isnull) t = jv_array();
+      t = jv_array_set(t, (int)didx, v);
+      jv_free(k);
+    }
   } else if (jv_get_kind(k) == JV_KIND_OBJECT &&
              (jv_get_kind(t) == JV_KIND_ARRAY || isnull)) {
     if (isnull) t = jv_array();
     int start, end;
-    if (parse_slice(jv_copy(t), k, &start, &end)) {
+    jv e = parse_slice(jv_copy(t), k, &start, &end);
+    if (jv_get_kind(e) == JV_KIND_TRUE) {
       if (jv_get_kind(v) == JV_KIND_ARRAY) {
         int array_len = jv_array_length(jv_copy(t));
         assert(0 <= start && start <= end && end <= array_len);
@@ -171,8 +216,14 @@ jv jv_set(jv t, jv k, jv v) {
     } else {
       jv_free(t);
       jv_free(v);
-      t = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
+      t = e;
     }
+  } else if (jv_get_kind(k) == JV_KIND_OBJECT && jv_get_kind(t) == JV_KIND_STRING) {
+    jv_free(t);
+    jv_free(k);
+    jv_free(v);
+    /* Well, why not?  We should implement this... */
+    t = jv_invalid_with_msg(jv_string_fmt("Cannot update string slices"));
   } else {
     jv err = jv_invalid_with_msg(jv_string_fmt("Cannot update field at %s index of %s",
                                                jv_kind_name(jv_get_kind(k)),
@@ -200,9 +251,15 @@ jv jv_has(jv t, jv k) {
     jv_free(elem);
   } else if (jv_get_kind(t) == JV_KIND_ARRAY &&
              jv_get_kind(k) == JV_KIND_NUMBER) {
-    jv elem = jv_array_get(t, (int)jv_number_value(k));
-    ret = jv_bool(jv_is_valid(elem));
-    jv_free(elem);
+    if (jvp_number_is_nan(k)) {
+      jv_free(t);
+      ret = jv_false();
+    } else {
+      jv elem = jv_array_get(t, (int)jv_number_value(k));
+      ret = jv_bool(jv_is_valid(elem));
+      jv_free(elem);
+    }
+    jv_free(k);
   } else {
     ret = jv_invalid_with_msg(jv_string_fmt("Cannot check whether %s has a %s key",
                                             jv_kind_name(jv_get_kind(t)),
@@ -235,12 +292,14 @@ static jv jv_dels(jv t, jv keys) {
         }
       } else if (jv_get_kind(key) == JV_KIND_OBJECT) {
         int start, end;
-        if (parse_slice(jv_copy(t), key, &start, &end)) {
+        jv e = parse_slice(jv_copy(t), key, &start, &end);
+        if (jv_get_kind(e) == JV_KIND_TRUE) {
           starts = jv_array_append(starts, jv_number(start));
           ends = jv_array_append(ends, jv_number(end));
         } else {
           jv_free(new_array);
-          new_array = jv_invalid_with_msg(jv_string_fmt("Start and end indices of an array slice must be numbers"));
+          jv_free(key);
+          new_array = e;
           goto arr_out;
         }
       } else {
@@ -255,10 +314,10 @@ static jv jv_dels(jv t, jv keys) {
     int neg_idx = 0;
     int nonneg_idx = 0;
     int len = jv_array_length(jv_copy(t));
-    jv_array_foreach(t, i, elem) {
+    for (int i = 0; i < len; ++i) {
       int del = 0;
       while (neg_idx < jv_array_length(jv_copy(neg_keys))) {
-        int delidx = len + (int)jv_number_value(jv_array_get(jv_copy(neg_keys), neg_idx));
+        int delidx = len + (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(neg_keys), neg_idx));
         if (i == delidx) {
           del = 1;
         }
@@ -268,7 +327,7 @@ static jv jv_dels(jv t, jv keys) {
         neg_idx++;
       }
       while (nonneg_idx < jv_array_length(jv_copy(nonneg_keys))) {
-        int delidx = (int)jv_number_value(jv_array_get(jv_copy(nonneg_keys), nonneg_idx));
+        int delidx = (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(nonneg_keys), nonneg_idx));
         if (i == delidx) {
           del = 1;
         }
@@ -278,15 +337,13 @@ static jv jv_dels(jv t, jv keys) {
         nonneg_idx++;
       }
       for (int sidx=0; !del && sidx<jv_array_length(jv_copy(starts)); sidx++) {
-        if ((int)jv_number_value(jv_array_get(jv_copy(starts), sidx)) <= i &&
-            i < (int)jv_number_value(jv_array_get(jv_copy(ends), sidx))) {
+        if ((int)jv_number_get_value_and_consume(jv_array_get(jv_copy(starts), sidx)) <= i &&
+            i < (int)jv_number_get_value_and_consume(jv_array_get(jv_copy(ends), sidx))) {
           del = 1;
         }
       }
       if (!del)
-        new_array = jv_array_append(new_array, elem);
-      else
-        jv_free(elem);
+        new_array = jv_array_append(new_array, jv_array_get(jv_copy(t), i));
     }
   arr_out:
     jv_free(neg_keys);
@@ -335,8 +392,38 @@ jv jv_setpath(jv root, jv path, jv value) {
   }
   jv pathcurr = jv_array_get(jv_copy(path), 0);
   jv pathrest = jv_array_slice(path, 1, jv_array_length(jv_copy(path)));
-  return jv_set(root, pathcurr,
-                jv_setpath(jv_get(jv_copy(root), jv_copy(pathcurr)), pathrest, value));
+
+  /*
+   * We need to be careful not to make extra copies since that leads to
+   * quadratic behavior (e.g., when growing large data structures in a
+   * reduction with `setpath/2`, i.e., with `|=`.
+   */
+  if (jv_get_kind(pathcurr) == JV_KIND_OBJECT) {
+    // Assignment to slice -- dunno yet how to avoid the extra copy
+    return jv_set(root, pathcurr,
+                  jv_setpath(jv_get(jv_copy(root), jv_copy(pathcurr)), pathrest, value));
+  }
+
+  jv subroot = jv_get(jv_copy(root), jv_copy(pathcurr));
+  if (!jv_is_valid(subroot)) {
+    jv_free(root);
+    jv_free(pathcurr);
+    jv_free(pathrest);
+    jv_free(value);
+    return subroot;
+  }
+
+  // To avoid the extra copy we drop the reference from `root` by setting that
+  // to null first.
+  root = jv_set(root, jv_copy(pathcurr), jv_null());
+  if (!jv_is_valid(root)) {
+    jv_free(subroot);
+    jv_free(pathcurr);
+    jv_free(pathrest);
+    jv_free(value);
+    return root;
+  }
+  return jv_set(root, pathcurr, jv_setpath(subroot, pathrest, value));
 }
 
 jv jv_getpath(jv root, jv path) {
@@ -465,7 +552,7 @@ jv jv_keys_unsorted(jv x) {
 jv jv_keys(jv x) {
   if (jv_get_kind(x) == JV_KIND_OBJECT) {
     int nkeys = jv_object_length(jv_copy(x));
-    jv* keys = jv_mem_calloc(sizeof(jv), nkeys);
+    jv* keys = jv_mem_calloc(nkeys, sizeof(jv));
     int kidx = 0;
     jv_object_foreach(x, key, value) {
       keys[kidx++] = key;
@@ -511,14 +598,13 @@ int jv_cmp(jv a, jv b) {
     break;
 
   case JV_KIND_NUMBER: {
-    double da = jv_number_value(a), db = jv_number_value(b);
-
-    // handle NaN as though it were null
-    if (da != da) r = jv_cmp(jv_null(), jv_number(db));
-    else if (db != db) r = jv_cmp(jv_number(da), jv_null());
-    else if (da < db) r = -1;
-    else if (da == db) r = 0;
-    else r = 1;
+    if (jvp_number_is_nan(a)) {
+      r = jv_cmp(jv_null(), jv_copy(b));
+    } else if (jvp_number_is_nan(b)) {
+      r = jv_cmp(jv_copy(a), jv_null());
+    } else {
+      r = jvp_number_cmp(a, b);
+    }
     break;
   }
 
@@ -587,7 +673,7 @@ static struct sort_entry* sort_items(jv objects, jv keys) {
   assert(jv_get_kind(keys) == JV_KIND_ARRAY);
   assert(jv_array_length(jv_copy(objects)) == jv_array_length(jv_copy(keys)));
   int n = jv_array_length(jv_copy(objects));
-  struct sort_entry* entries = jv_mem_calloc(sizeof(struct sort_entry), n);
+  struct sort_entry* entries = jv_mem_calloc(n, sizeof(struct sort_entry));
   for (int i=0; i<n; i++) {
     entries[i].object = jv_array_get(jv_copy(objects), i);
     entries[i].key = jv_array_get(jv_copy(keys), i);

package/deps/jq/src/jv_dtoa.c

@@ -195,6 +195,7 @@
 #include "jv_dtoa.h"
 
 #include "jv_alloc.h"
+#include "jv.h"
 #define MALLOC jv_mem_alloc
 #define FREE jv_mem_free
 
@@ -298,7 +299,7 @@ extern "C" {
 #endif
 
 #if defined(IEEE_8087) + defined(IEEE_MC68k) + defined(VAX) + defined(IBM) != 1
-Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
+#  error Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
 #endif
 
 typedef union { double d; ULong L[2]; } U;
@@ -1723,6 +1724,7 @@ gethex(struct dtoa_context* C,  CONST char **sp, U *rvp, int rounding, int sign)
 		  case '-':
 			esign = 1;
 			/* no break */
+			JQ_FALLTHROUGH;
 		  case '+':
 			s++;
 		  }
@@ -2327,7 +2329,10 @@ retlow1:
 jvp_strtod
  (struct dtoa_context* C, const char *s00, char **se)
 {
-	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1, test_scale;
+	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
+#ifdef Honor_FLT_ROUNDS
+	int test_scale;
+#endif
 	int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign;
 	CONST char *s, *s0, *s1;
 	double aadj, aadj1;
@@ -2367,10 +2372,12 @@ jvp_strtod
 		case '-':
 			sign = 1;
 			/* no break */
+			JQ_FALLTHROUGH;
 		case '+':
 			if (*++s)
 				goto break2;
 			/* no break */
+			JQ_FALLTHROUGH;
 		case 0:
 			goto ret0;
 		case '\t':
@@ -2478,6 +2485,7 @@ jvp_strtod
 		switch(c = *++s) {
 			case '-':
 				esign = 1;
+				JQ_FALLTHROUGH;
 			case '+':
 				c = *++s;
 			}
@@ -3699,6 +3707,7 @@ jvp_dtoa
 		case 2:
 			leftright = 0;
 			/* no break */
+			JQ_FALLTHROUGH;
 		case 4:
 			if (ndigits <= 0)
 				ndigits = 1;
@@ -3707,6 +3716,7 @@ jvp_dtoa
 		case 3:
 			leftright = 0;
 			/* no break */
+			JQ_FALLTHROUGH;
 		case 5:
 			i = ndigits + k + 1;
 			ilim = i;

package/deps/jq/src/jv_dtoa_tsd.c

@@ -0,0 +1,51 @@
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "jv_thread.h"
+#include "jv_dtoa_tsd.h"
+#include "jv_dtoa.h"
+#include "jv_alloc.h"
+
+static pthread_once_t dtoa_ctx_once = PTHREAD_ONCE_INIT;
+
+static pthread_key_t dtoa_ctx_key;
+static void tsd_dtoa_ctx_dtor(void *ctx) {
+  if (ctx) {
+    jvp_dtoa_context_free((struct dtoa_context *)ctx);
+    jv_mem_free(ctx);
+  }
+}
+
+#ifndef WIN32
+static
+#endif
+void jv_tsd_dtoa_ctx_fini() {
+  struct dtoa_context *ctx = pthread_getspecific(dtoa_ctx_key);
+  tsd_dtoa_ctx_dtor(ctx);
+  pthread_setspecific(dtoa_ctx_key, NULL);
+}
+
+#ifndef WIN32
+static
+#endif
+void jv_tsd_dtoa_ctx_init() {
+  if (pthread_key_create(&dtoa_ctx_key, tsd_dtoa_ctx_dtor) != 0) {
+    fprintf(stderr, "error: cannot create thread specific key");
+    abort();
+  }
+  atexit(jv_tsd_dtoa_ctx_fini);
+}
+
+inline struct dtoa_context *tsd_dtoa_context_get() {
+  pthread_once(&dtoa_ctx_once, jv_tsd_dtoa_ctx_init); // cannot fail
+  struct dtoa_context *ctx = (struct dtoa_context*)pthread_getspecific(dtoa_ctx_key);
+  if (!ctx) {
+    ctx = malloc(sizeof(struct dtoa_context));
+    jvp_dtoa_context_init(ctx);
+    if (pthread_setspecific(dtoa_ctx_key, ctx) != 0) {
+      fprintf(stderr, "error: cannot set thread specific data");
+      abort();
+    }
+  }
+  return ctx;
+}

package/deps/jq/src/jv_dtoa_tsd.h

@@ -0,0 +1,4 @@
+#ifndef JV_DTOA_TSD_H
+#define JV_DTOA_TSD_H
+struct dtoa_context *tsd_dtoa_context_get();
+#endif