@port-labs/jq-node-bindings 1.0.4 → 1.1.0-dev

package/deps/jq/src/jv.c

@@ -119,15 +119,15 @@ const jv JV_INVALID = {JVP_FLAGS_INVALID, 0, 0, 0, {0}};
 const jv JV_FALSE = {JVP_FLAGS_FALSE, 0, 0, 0, {0}};
 const jv JV_TRUE = {JVP_FLAGS_TRUE, 0, 0, 0, {0}};
 
-jv jv_true() {
+jv jv_true(void) {
   return JV_TRUE;
 }
 
-jv jv_false() {
+jv jv_false(void) {
   return JV_FALSE;
 }
 
-jv jv_null() {
+jv jv_null(void) {
   return JV_NULL;
 }
 
@@ -155,7 +155,7 @@ jv jv_invalid_with_msg(jv err) {
   return x;
 }
 
-jv jv_invalid() {
+jv jv_invalid(void) {
   return JV_INVALID;
 }
 
@@ -206,16 +206,13 @@ enum {
   JVP_NUMBER_DECIMAL = 1
 };
 
-#define JV_NUMBER_SIZE_INIT      (0)
-#define JV_NUMBER_SIZE_CONVERTED (1)
-
 #define JVP_FLAGS_NUMBER_NATIVE       JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_NATIVE, 0))
 #define JVP_FLAGS_NUMBER_LITERAL      JVP_MAKE_FLAGS(JV_KIND_NUMBER, JVP_MAKE_PFLAGS(JVP_NUMBER_DECIMAL, 1))
 
 // the decimal precision of binary double
-#define DEC_NUBMER_DOUBLE_PRECISION   (17)
+#define DEC_NUMBER_DOUBLE_PRECISION   (17)
 #define DEC_NUMBER_STRING_GUARD       (14)
-#define DEC_NUBMER_DOUBLE_EXTRA_UNITS ((DEC_NUBMER_DOUBLE_PRECISION - DECNUMDIGITS + DECDPUN - 1)/DECDPUN)
+#define DEC_NUMBER_DOUBLE_EXTRA_UNITS ((DEC_NUMBER_DOUBLE_PRECISION - DECNUMDIGITS + DECDPUN - 1)/DECDPUN)
 
 #include "jv_thread.h"
 #ifdef WIN32
@@ -495,12 +492,12 @@ static pthread_once_t dec_ctx_once = PTHREAD_ONCE_INIT;
 
 // atexit finalizer to clean up the tsd dec contexts if main() exits
 // without having called pthread_exit()
-void jv_tsd_dec_ctx_fini() {
+void jv_tsd_dec_ctx_fini(void) {
   jv_mem_free(pthread_getspecific(dec_ctx_key));
   pthread_setspecific(dec_ctx_key, NULL);
 }
 
-void jv_tsd_dec_ctx_init() {
+void jv_tsd_dec_ctx_init(void) {
   if (pthread_key_create(&dec_ctx_key, jv_mem_free) != 0) {
     fprintf(stderr, "error: cannot create thread specific key");
     abort();
@@ -542,7 +539,7 @@ typedef struct {
 
 typedef struct {
   decNumber number;
-  decNumberUnit units[DEC_NUBMER_DOUBLE_EXTRA_UNITS];
+  decNumberUnit units[DEC_NUMBER_DOUBLE_EXTRA_UNITS];
 } decNumberDoublePrecision;
 
 
@@ -562,7 +559,6 @@ static decNumber* jvp_dec_number_ptr(jv j) {
 }
 
 static jvp_literal_number* jvp_literal_number_alloc(unsigned literal_length) {
-
   /* The number of units needed is ceil(DECNUMDIGITS/DECDPUN)         */
   int units = ((literal_length+DECDPUN-1)/DECDPUN);
 
@@ -571,26 +567,34 @@ static jvp_literal_number* jvp_literal_number_alloc(unsigned literal_length) {
     + sizeof(decNumberUnit) * units
   );
 
+  n->refcnt = JV_REFCNT_INIT;
+  n->num_double = NAN;
+  n->literal_data = NULL;
   return n;
 }
 
 static jv jvp_literal_number_new(const char * literal) {
+  jvp_literal_number* n = jvp_literal_number_alloc(strlen(literal));
 
-  jvp_literal_number * n = jvp_literal_number_alloc(strlen(literal));
-
-  n->refcnt = JV_REFCNT_INIT;
-  n->literal_data = NULL;
   decContext *ctx = DEC_CONTEXT();
   decContextClearStatus(ctx, DEC_Conversion_syntax);
   decNumberFromString(&n->num_decimal, literal, ctx);
-  n->num_double = NAN;
 
   if (ctx->status & DEC_Conversion_syntax) {
     jv_mem_free(n);
     return JV_INVALID;
   }
+  if (decNumberIsNaN(&n->num_decimal)) {
+    // Reject NaN with payload.
+    if (n->num_decimal.digits > 1 || *n->num_decimal.lsu != 0) {
+      jv_mem_free(n);
+      return JV_INVALID;
+    }
+    jv_mem_free(n);
+    return jv_number(NAN);
+  }
 
-  jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, JV_NUMBER_SIZE_INIT, {&n->refcnt}};
+  jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&n->refcnt}};
   return r;
 }
 
@@ -600,11 +604,11 @@ static double jvp_literal_number_to_double(jv j) {
 
   // init as decimal64 but change digits to allow conversion to binary64 (double)
   decContextDefault(&dblCtx, DEC_INIT_DECIMAL64);
-  dblCtx.digits = DEC_NUBMER_DOUBLE_PRECISION;
+  dblCtx.digits = DEC_NUMBER_DOUBLE_PRECISION;
 
   decNumber *p_dec_number = jvp_dec_number_ptr(j);
   decNumberDoublePrecision dec_double;
-  char literal[DEC_NUBMER_DOUBLE_PRECISION + DEC_NUMBER_STRING_GUARD + 1];
+  char literal[DEC_NUMBER_DOUBLE_PRECISION + DEC_NUMBER_STRING_GUARD + 1];
 
   // reduce the number to the shortest possible form
   // that fits into the 64 bit floating point representation
@@ -698,9 +702,8 @@ double jv_number_value(jv j) {
   if (JVP_HAS_FLAGS(j, JVP_FLAGS_NUMBER_LITERAL)) {
     jvp_literal_number* n = jvp_literal_number_ptr(j);
 
-    if (j.size != JV_NUMBER_SIZE_CONVERTED) {
+    if (isnan(n->num_double)) {
       n->num_double = jvp_literal_number_to_double(j);
-      j.size = JV_NUMBER_SIZE_CONVERTED;
     }
 
     return n->num_double;
@@ -731,7 +734,37 @@ int jvp_number_is_nan(jv n) {
     return decNumberIsNaN(pdec);
   }
 #endif
-  return n.u.number != n.u.number;
+  return isnan(n.u.number);
+}
+
+jv jv_number_abs(jv n) {
+  assert(JVP_HAS_KIND(n, JV_KIND_NUMBER));
+
+#ifdef USE_DECNUM
+  if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) {
+    jvp_literal_number* m = jvp_literal_number_alloc(jvp_dec_number_ptr(n)->digits);
+
+    decNumberAbs(&m->num_decimal, jvp_dec_number_ptr(n), DEC_CONTEXT());
+    jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&m->refcnt}};
+    return r;
+  }
+#endif
+  return jv_number(fabs(jv_number_value(n)));
+}
+
+jv jv_number_negate(jv n) {
+  assert(JVP_HAS_KIND(n, JV_KIND_NUMBER));
+
+#ifdef USE_DECNUM
+  if (JVP_HAS_FLAGS(n, JVP_FLAGS_NUMBER_LITERAL)) {
+    jvp_literal_number* m = jvp_literal_number_alloc(jvp_dec_number_ptr(n)->digits);
+
+    decNumberMinus(&m->num_decimal, jvp_dec_number_ptr(n), DEC_CONTEXT());
+    jv r = {JVP_FLAGS_NUMBER_LITERAL, 0, 0, 0, {&m->refcnt}};
+    return r;
+  }
+#endif
+  return jv_number(-jv_number_value(n));
 }
 
 int jvp_number_cmp(jv a, jv b) {
@@ -958,7 +991,7 @@ jv jv_array_sized(int n) {
   return jvp_array_new(n);
 }
 
-jv jv_array() {
+jv jv_array(void) {
   return jv_array_sized(16);
 }
 
@@ -992,6 +1025,11 @@ jv jv_array_set(jv j, int idx, jv val) {
     jv_free(val);
     return jv_invalid_with_msg(jv_string("Out of bounds negative array index"));
   }
+  if (idx > (INT_MAX >> 2) - jvp_array_offset(j)) {
+    jv_free(j);
+    jv_free(val);
+    return jv_invalid_with_msg(jv_string("Array index too large"));
+  }
   // copy/free of val,j coalesced
   jv* slot = jvp_array_write(&j, idx);
   jv_free(*slot);
@@ -1011,6 +1049,7 @@ jv jv_array_concat(jv a, jv b) {
   // FIXME: could be faster
   jv_array_foreach(b, i, elem) {
     a = jv_array_append(a, elem);
+    if (!jv_is_valid(a)) break;
   }
   jv_free(b);
   return a;
@@ -1025,14 +1064,13 @@ jv jv_array_slice(jv a, int start, int end) {
 jv jv_array_indexes(jv a, jv b) {
   jv res = jv_array();
   int idx = -1;
-  jv_array_foreach(a, ai, aelem) {
-    jv_free(aelem);
+  int alen = jv_array_length(jv_copy(a));
+  for (int ai = 0; ai < alen; ++ai) {
     jv_array_foreach(b, bi, belem) {
-      if (!jv_equal(jv_array_get(jv_copy(a), ai + bi), jv_copy(belem)))
+      if (!jv_equal(jv_array_get(jv_copy(a), ai + bi), belem))
         idx = -1;
       else if (bi == 0 && idx == -1)
         idx = ai;
-      jv_free(belem);
     }
     if (idx > -1)
       res = jv_array_append(res, jv_number(idx));
@@ -1110,6 +1148,7 @@ static jv jvp_string_empty_new(uint32_t length) {
   jvp_string* s = jvp_string_alloc(length);
   s->length_hashed = 0;
   memset(s->data, 0, length);
+  s->data[length] = 0;
   jv r = {JVP_FLAGS_STRING, 0, 0, 0, {&s->refcnt}};
   return r;
 }
@@ -1274,15 +1313,22 @@ jv jv_string_indexes(jv j, jv k) {
   assert(JVP_HAS_KIND(k, JV_KIND_STRING));
   const char *jstr = jv_string_value(j);
   const char *idxstr = jv_string_value(k);
-  const char *p;
+  const char *p, *lp;
   int jlen = jv_string_length_bytes(jv_copy(j));
   int idxlen = jv_string_length_bytes(jv_copy(k));
   jv a = jv_array();
 
   if (idxlen != 0) {
-    p = jstr;
+    int n = 0;
+    p = lp = jstr;
     while ((p = _jq_memmem(p, (jstr + jlen) - p, idxstr, idxlen)) != NULL) {
-      a = jv_array_append(a, jv_number(p - jstr));
+      while (lp < p) {
+        lp += jvp_utf8_decode_length(*lp);
+        n++;
+      }
+
+      a = jv_array_append(a, jv_number(n));
+      if (!jv_is_valid(a)) break;
       p++;
     }
   }
@@ -1291,6 +1337,32 @@ jv jv_string_indexes(jv j, jv k) {
   return a;
 }
 
+jv jv_string_repeat(jv j, int n) {
+  assert(JVP_HAS_KIND(j, JV_KIND_STRING));
+  if (n < 0) {
+    jv_free(j);
+    return jv_null();
+  }
+  int len = jv_string_length_bytes(jv_copy(j));
+  int64_t res_len = (int64_t)len * n;
+  if (res_len >= INT_MAX) {
+    jv_free(j);
+    return jv_invalid_with_msg(jv_string("Repeat string result too long"));
+  }
+  if (res_len == 0) {
+    jv_free(j);
+    return jv_string("");
+  }
+  jv res = jv_string_empty(res_len);
+  res = jvp_string_append(res, jv_string_value(j), len);
+  for (int curr = len, grow; curr < res_len; curr += grow) {
+    grow = MIN(res_len - curr, curr);
+    res = jvp_string_append(res, jv_string_value(res), grow);
+  }
+  jv_free(j);
+  return res;
+}
+
 jv jv_string_split(jv j, jv sep) {
   assert(JVP_HAS_KIND(j, JV_KIND_STRING));
   assert(JVP_HAS_KIND(sep, JV_KIND_STRING));
@@ -1305,14 +1377,17 @@ jv jv_string_split(jv j, jv sep) {
 
   if (seplen == 0) {
     int c;
-    while ((jstr = jvp_utf8_next(jstr, jend, &c)))
+    while ((jstr = jvp_utf8_next(jstr, jend, &c))) {
       a = jv_array_append(a, jv_string_append_codepoint(jv_string(""), c));
+      if (!jv_is_valid(a)) break;
+    }
   } else {
     for (p = jstr; p < jend; p = s + seplen) {
       s = _jq_memmem(p, jend - p, sepstr, seplen);
       if (s == NULL)
         s = jend;
       a = jv_array_append(a, jv_string_sized(p, s - p));
+      if (!jv_is_valid(a)) break;
       // Add an empty string to denote that j ends on a sep
       if (s + seplen == jend && seplen != 0)
         a = jv_array_append(a, jv_string(""));
@@ -1330,8 +1405,10 @@ jv jv_string_explode(jv j) {
   const char* end = i + len;
   jv a = jv_array_sized(len);
   int c;
-  while ((i = jvp_utf8_next(i, end, &c)))
+  while ((i = jvp_utf8_next(i, end, &c))) {
     a = jv_array_append(a, jv_number(c));
+    if (!jv_is_valid(a)) break;
+  }
   jv_free(j);
   return a;
 }
@@ -1605,10 +1682,13 @@ static void jvp_object_free(jv o) {
   }
 }
 
-static jv jvp_object_rehash(jv object) {
+static int jvp_object_rehash(jv *objectp) {
+  jv object = *objectp;
   assert(JVP_HAS_KIND(object, JV_KIND_OBJECT));
   assert(jvp_refcnt_unshared(object.u.ptr));
   int size = jvp_object_size(object);
+  if (size > INT_MAX >> 2)
+    return 0;
   jv new_object = jvp_object_new(size * 2);
   for (int i=0; i<size; i++) {
     struct object_slot* slot = jvp_object_get_slot(object, i);
@@ -1621,7 +1701,8 @@ static jv jvp_object_rehash(jv object) {
   }
   // references are transported, just drop the old table
   jv_mem_free(jvp_object_ptr(object));
-  return new_object;
+  *objectp = new_object;
+  return 1;
 }
 
 static jv jvp_object_unshare(jv object) {
@@ -1650,27 +1731,32 @@ static jv jvp_object_unshare(jv object) {
   return new_object;
 }
 
-static jv* jvp_object_write(jv* object, jv key) {
+static int jvp_object_write(jv* object, jv key, jv **valpp) {
   *object = jvp_object_unshare(*object);
   int* bucket = jvp_object_find_bucket(*object, key);
   struct object_slot* slot = jvp_object_find_slot(*object, key, bucket);
   if (slot) {
     // already has the key
     jvp_string_free(key);
-    return &slot->value;
+    *valpp = &slot->value;
+    return 1;
   }
   slot = jvp_object_add_slot(*object, key, bucket);
   if (slot) {
     slot->value = jv_invalid();
   } else {
-    *object = jvp_object_rehash(*object);
+    if (!jvp_object_rehash(object)) {
+      *valpp = NULL;
+      return 0;
+    }
     bucket = jvp_object_find_bucket(*object, key);
     assert(!jvp_object_find_slot(*object, key, bucket));
     slot = jvp_object_add_slot(*object, key, bucket);
     assert(slot);
     slot->value = jv_invalid();
   }
-  return &slot->value;
+  *valpp = &slot->value;
+  return 1;
 }
 
 static int jvp_object_delete(jv* object, jv key) {
@@ -1737,7 +1823,7 @@ static int jvp_object_contains(jv a, jv b) {
  * Objects (public interface)
  */
 #define DEFAULT_OBJECT_SIZE 8
-jv jv_object() {
+jv jv_object(void) {
   return jvp_object_new(8);
 }
 
@@ -1770,7 +1856,11 @@ jv jv_object_set(jv object, jv key, jv value) {
   assert(JVP_HAS_KIND(object, JV_KIND_OBJECT));
   assert(JVP_HAS_KIND(key, JV_KIND_STRING));
   // copy/free of object, key, value coalesced
-  jv* slot = jvp_object_write(&object, key);
+  jv* slot;
+  if (!jvp_object_write(&object, key, &slot)) {
+    jv_free(object);
+    return jv_invalid_with_msg(jv_string("Object too big"));
+  }
   jv_free(*slot);
   *slot = value;
   return object;
@@ -1795,6 +1885,7 @@ jv jv_object_merge(jv a, jv b) {
   assert(JVP_HAS_KIND(a, JV_KIND_OBJECT));
   jv_object_foreach(b, k, v) {
     a = jv_object_set(a, k, v);
+    if (!jv_is_valid(a)) break;
   }
   jv_free(b);
   return a;
@@ -1814,6 +1905,7 @@ jv jv_object_merge_recursive(jv a, jv b) {
       jv_free(elem);
       a = jv_object_set(a, k, v);
     }
+    if (!jv_is_valid(a)) break;
   }
   jv_free(b);
   return a;

package/deps/jq/src/jv.h

@@ -74,8 +74,10 @@ jv jv_number(double);
 jv jv_number_with_literal(const char*);
 double jv_number_value(jv);
 int jv_is_integer(jv);
+jv jv_number_abs(jv);
+jv jv_number_negate(jv);
 
-int jv_number_has_literal(jv n);
+int jv_number_has_literal(jv);
 const char* jv_number_get_literal(jv);
 
 jv jv_array(void);
@@ -113,6 +115,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
 
 
@@ -131,6 +136,7 @@ jv jv_string_fmt(const char*, ...) JV_PRINTF_LIKE(1, 2);
 jv jv_string_append_codepoint(jv a, uint32_t c);
 jv jv_string_append_buf(jv a, const char* buf, int len);
 jv jv_string_append_str(jv a, const char* str);
+jv jv_string_repeat(jv j, int n);
 jv jv_string_split(jv j, jv sep);
 jv jv_string_explode(jv j);
 jv jv_string_implode(jv j);
@@ -223,7 +229,7 @@ enum jv_print_flags {
   JV_PRINT_SPACE2   = 1024,
 };
 #define JV_PRINT_INDENT_FLAGS(n) \
-    ((n) < 0 || (n) > 7 ? JV_PRINT_TAB | JV_PRINT_PRETTY : (n) == 0 ? 0 : (n) << 8 | JV_PRINT_PRETTY)
+    ((n) < 0 || (n) > 7 ? JV_PRINT_TAB | JV_PRINT_PRETTY : (n) << 8 | JV_PRINT_PRETTY)
 void jv_dumpf(jv, FILE *f, int flags);
 void jv_dump(jv, int flags);
 void jv_show(jv, int flags);
@@ -261,8 +267,9 @@ jv jv_delpaths(jv, jv);
 jv jv_keys(jv /*object or array*/);
 jv jv_keys_unsorted(jv /*object or array*/);
 int jv_cmp(jv, jv);
-jv jv_group(jv, jv);
 jv jv_sort(jv, jv);
+jv jv_group(jv, jv);
+jv jv_unique(jv, jv);
 
 #ifdef __cplusplus
 }

package/deps/jq/src/jv_alloc.c

@@ -1,7 +1,8 @@
-#include <stdlib.h>
+#include <assert.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
-#include "jv_alloc.h"
+#include "jv.h"
 
 struct nomem_handler {
     jv_nomem_handler_f handler;
@@ -33,7 +34,7 @@ void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
   nomem_handler.handler = handler;
 }
 
-static void memory_exhausted() {
+static void memory_exhausted(void) {
   if (nomem_handler.handler)
     nomem_handler.handler(nomem_handler.data); // Maybe handler() will longjmp() to safety
   // Or not
@@ -104,7 +105,7 @@ void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
   nomem_handler->data = data;
 }
 
-static void memory_exhausted() {
+static void memory_exhausted(void) {
   struct nomem_handler *nomem_handler;
 
   pthread_once(&mem_once, tsd_init);
@@ -128,7 +129,7 @@ void jv_nomem_handler(jv_nomem_handler_f handler, void *data) {
   nomem_handler.data = data;
 }
 
-static void memory_exhausted() {
+static void memory_exhausted(void) {
   fprintf(stderr, "jq: error: cannot allocate memory\n");
   abort();
 }
@@ -150,6 +151,7 @@ void* jv_mem_alloc_unguarded(size_t sz) {
 }
 
 void* jv_mem_calloc(size_t nemb, size_t sz) {
+  assert(nemb > 0 && sz > 0);
   void* p = calloc(nemb, sz);
   if (!p) {
     memory_exhausted();
@@ -158,6 +160,7 @@ void* jv_mem_calloc(size_t nemb, size_t sz) {
 }
 
 void* jv_mem_calloc_unguarded(size_t nemb, size_t sz) {
+  assert(nemb > 0 && sz > 0);
   return calloc(nemb, sz);
 }
 

package/deps/jq/src/jv_alloc.h

@@ -2,7 +2,6 @@
 #define JV_ALLOC_H
 
 #include <stddef.h>
-#include "jv.h"
 
 void* jv_mem_alloc(size_t);
 void* jv_mem_alloc_unguarded(size_t);

package/deps/jq/src/jv_aux.c

@@ -3,6 +3,7 @@
 #include <math.h>
 #include <string.h>
 #include <stdlib.h>
+#include "jv.h"
 #include "jv_alloc.h"
 #include "jv_private.h"
 
@@ -193,18 +194,19 @@ jv jv_set(jv t, jv k, jv v) {
         if (slice_len < insert_len) {
           // array is growing
           int shift = insert_len - slice_len;
-          for (int i = array_len - 1; i >= end; i--) {
+          for (int i = array_len - 1; i >= end && jv_is_valid(t); i--) {
             t = jv_array_set(t, i + shift, jv_array_get(jv_copy(t), i));
           }
         } else if (slice_len > insert_len) {
           // array is shrinking
           int shift = slice_len - insert_len;
-          for (int i = end; i < array_len; i++) {
+          for (int i = end; i < array_len && jv_is_valid(t); i++) {
             t = jv_array_set(t, i - shift, jv_array_get(jv_copy(t), i));
           }
-          t = jv_array_slice(t, 0, array_len - shift);
+          if (jv_is_valid(t))
+            t = jv_array_slice(t, 0, array_len - shift);
         }
-        for (int i=0; i < insert_len; i++) {
+        for (int i = 0; i < insert_len && jv_is_valid(t); i++) {
           t = jv_array_set(t, start + i, jv_array_get(jv_copy(v), i));
         }
         jv_free(v);
@@ -314,7 +316,7 @@ 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_get_value_and_consume(jv_array_get(jv_copy(neg_keys), neg_idx));
@@ -343,9 +345,7 @@ static jv jv_dels(jv t, jv keys) {
         }
       }
       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);
@@ -419,6 +419,7 @@ jv jv_setpath(jv root, jv path, jv value) {
   // 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);
@@ -553,6 +554,10 @@ 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));
+    if (nkeys == 0) {
+      jv_free(x);
+      return jv_array();
+    }
     jv* keys = jv_mem_calloc(nkeys, sizeof(jv));
     int kidx = 0;
     jv_object_foreach(x, key, value) {
@@ -674,6 +679,11 @@ 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));
+  if (n == 0) {
+    jv_free(objects);
+    jv_free(keys);
+    return NULL;
+  }
   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);
@@ -728,3 +738,26 @@ jv jv_group(jv objects, jv keys) {
   jv_mem_free(entries);
   return ret;
 }
+
+jv jv_unique(jv objects, jv keys) {
+  assert(jv_get_kind(objects) == JV_KIND_ARRAY);
+  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 = sort_items(objects, keys);
+  jv ret = jv_array();
+  jv curr_key = jv_invalid();
+  for (int i = 0; i < n; i++) {
+    if (jv_equal(jv_copy(curr_key), jv_copy(entries[i].key))) {
+      jv_free(entries[i].key);
+      jv_free(entries[i].object);
+    } else {
+      jv_free(curr_key);
+      curr_key = entries[i].key;
+      ret = jv_array_append(ret, entries[i].object);
+    }
+  }
+  jv_free(curr_key);
+  jv_mem_free(entries);
+  return ret;
+}

package/deps/jq/src/jv_dtoa.c

@@ -299,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;
@@ -2368,29 +2368,21 @@ jvp_strtod
 
 	sign = nz0 = nz1 = nz = bc.dplen = bc.uflchk = 0;
 	dval(&rv) = 0.;
-	for(s = s00;;s++) switch(*s) {
+	switch(*(s = s00)) {
 		case '-':
 			sign = 1;
 			/* no break */
 			JQ_FALLTHROUGH;
 		case '+':
 			if (*++s)
-				goto break2;
+				break;
 			/* no break */
 			JQ_FALLTHROUGH;
 		case 0:
 			goto ret0;
-		case '\t':
-		case '\n':
-		case '\v':
-		case '\f':
-		case '\r':
-		case ' ':
-			continue;
 		default:
-			goto break2;
+			break;
 		}
- break2:
 	if (*s == '0') {
 #ifndef NO_HEX_FP /*{*/
 		switch(s[1]) {