@port-labs/jq-node-bindings 0.0.4 → 0.0.6

package/deps/jq/{execute.c → src/execute.c}

@@ -40,6 +40,10 @@ struct jq_state {
   int initial_execution;
   unsigned next_label;
 
+  int halted;
+  jv exit_code;
+  jv error_message;
+
   jv attrs;
   jq_input_cb input_cb;
   void *input_cb_data;
@@ -64,7 +68,7 @@ struct frame {
   stack_ptr env;            // jq stack address of frame to return to
   stack_ptr retdata;        // jq stack address to unwind to on RET
   uint16_t* retaddr;        // jq bytecode return address
-  union frame_entry entries[0]; // nclosures + nlocals
+  union frame_entry entries[]; // nclosures + nlocals
 };
 
 static int frame_size(struct bytecode* bc) {
@@ -242,6 +246,28 @@ static void path_append(jq_state* jq, jv component, jv value_at_path) {
   }
 }
 
+/* For f_getpath() */
+jv
+_jq_path_append(jq_state *jq, jv v, jv p, jv value_at_path) {
+  if (jq->subexp_nest != 0 ||
+      jv_get_kind(jq->path) != JV_KIND_ARRAY ||
+      !jv_is_valid(value_at_path)) {
+    jv_free(v);
+    jv_free(p);
+    return value_at_path;
+  }
+  if (!jv_identical(v, jv_copy(jq->value_at_path))) {
+    jv_free(p);
+    return value_at_path;
+  }
+  if (jv_get_kind(p) == JV_KIND_ARRAY)
+    jq->path = jv_array_concat(jq->path, p);
+  else
+    jq->path = jv_array_append(jq->path, p);
+  jv_free(jq->value_at_path);
+  return jv_copy(jq->value_at_path = value_at_path);
+}
+
 uint16_t* stack_restore(jq_state *jq){
   while (!stack_pop_will_free(&jq->stk, jq->fork_top)) {
     if (stack_pop_will_free(&jq->stk, jq->stk_top)) {
@@ -285,6 +311,9 @@ static void jq_reset(jq_state *jq) {
   jv_free(jq->error);
   jq->error = jv_null();
 
+  jq->halted = 0;
+  jv_free(jq->exit_code);
+  jv_free(jq->error_message);
   if (jv_get_kind(jq->path) != JV_KIND_INVALID)
     jv_free(jq->path);
   jq->path = jv_null();
@@ -320,6 +349,11 @@ jv jq_next(jq_state *jq) {
   jq->initial_execution = 0;
   assert(jv_get_kind(jq->error) == JV_KIND_NULL);
   while (1) {
+    if (jq->halted) {
+      if (jq->debug_trace_enabled)
+        printf("\t<halted>\n");
+      return jv_invalid();
+    }
     uint16_t opcode = *pc;
     raising = 0;
 
@@ -331,10 +365,9 @@ jv jq_next(jq_state *jq) {
       if (!backtracking) {
         int stack_in = opdesc->stack_in;
         if (stack_in == -1) stack_in = pc[1];
+        param = jq->stk_top;
         for (int i=0; i<stack_in; i++) {
-          if (i == 0) {
-            param = jq->stk_top;
-          } else {
+          if (i != 0) {
             printf(" | ");
             param = *stack_block_next(&jq->stk, param);
           }
@@ -344,6 +377,12 @@ jv jq_next(jq_state *jq) {
           //printf(" -- ");
           //jv_dump(jv_copy(jq->path), 0);
         }
+        if (jq->debug_trace_enabled & JQ_DEBUG_TRACE_DETAIL) {
+          while ((param = *stack_block_next(&jq->stk, param))) {
+            printf(" || ");
+            jv_dump(jv_copy(*(jv*)stack_block(&jq->stk, param)), JV_PRINT_REFCOUNT);
+          }
+        }
       } else {
         printf("\t<backtracking>");
       }
@@ -417,6 +456,15 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
+    case PUSHK_UNDER: {
+      jv v = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++);
+      assert(jv_is_valid(v));
+      jv v2 = stack_pop(jq);
+      stack_push(jq, v);
+      stack_push(jq, v2);
+      break;
+    }
+
     case POP: {
       jv_free(stack_pop(jq));
       break;
@@ -514,6 +562,8 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
+    case STOREVN:
+        stack_save(jq, pc - 1, stack_get_pos(jq));
     case STOREV: {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
@@ -529,6 +579,16 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
+    case ON_BACKTRACK(STOREVN): {
+      uint16_t level = *pc++;
+      uint16_t v = *pc++;
+      jv* var = frame_local_var(jq, v, level);
+      jv_free(*var);
+      *var = jv_null();
+      goto do_backtrack;
+      break;
+    }
+
     case STORE_GLOBAL: {
       // Get the constant
       jv val = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++);
@@ -739,21 +799,29 @@ jv jq_next(jq_state *jq) {
     }
 
     case FORK_OPT:
+    case DESTRUCTURE_ALT:
     case FORK: {
       stack_save(jq, pc - 1, stack_get_pos(jq));
       pc++; // skip offset this time
       break;
     }
 
-    case ON_BACKTRACK(FORK_OPT): {
+    case ON_BACKTRACK(FORK_OPT):
+    case ON_BACKTRACK(DESTRUCTURE_ALT): {
       if (jv_is_valid(jq->error)) {
         // `try EXP ...` backtracked here (no value, `empty`), so we backtrack more
         jv_free(stack_pop(jq));
         goto do_backtrack;
       }
       // `try EXP ...` exception caught in EXP
-      jv_free(stack_pop(jq)); // free the input
-      stack_push(jq, jv_invalid_get_msg(jq->error));  // push the error's message
+      // DESTRUCTURE_ALT doesn't want the error message on the stack,
+      // as we would just want to throw it away anyway.
+      if (opcode != ON_BACKTRACK(DESTRUCTURE_ALT)) {
+        jv_free(stack_pop(jq)); // free the input
+        stack_push(jq, jv_invalid_get_msg(jq->error));  // push the error's message
+      } else {
+        jv_free(jq->error);
+      }
       jq->error = jv_null();
       uint16_t offset = *pc++;
       pc += offset;
@@ -932,6 +1000,10 @@ jq_state *jq_init(void) {
   jq->curr_frame = 0;
   jq->error = jv_null();
 
+  jq->halted = 0;
+  jq->exit_code = jv_invalid();
+  jq->error_message = jv_invalid();
+
   jq->err_cb = default_err_cb;
   jq->err_cb_data = stderr;
 
@@ -974,11 +1046,7 @@ void jq_start(jq_state *jq, jv input, int flags) {
 
   stack_push(jq, input);
   stack_save(jq, jq->bc->code, stack_get_pos(jq));
-  if (flags & JQ_DEBUG_TRACE) {
-    jq->debug_trace_enabled = 1;
-  } else {
-    jq->debug_trace_enabled = 0;
-  }
+  jq->debug_trace_enabled = flags & JQ_DEBUG_TRACE_ALL;
   jq->initial_execution = 1;
 }
 
@@ -1066,9 +1134,26 @@ static struct bytecode *optimize(struct bytecode *bc) {
   return optimize_code(bc);
 }
 
+static jv
+args2obj(jv args)
+{
+  if (jv_get_kind(args) == JV_KIND_OBJECT)
+    return args;
+  assert(jv_get_kind(args) == JV_KIND_ARRAY);
+  jv r = jv_object();
+  jv kk = jv_string("name");
+  jv vk = jv_string("value");
+  jv_array_foreach(args, i, v)
+    r = jv_object_set(r, jv_object_get(jv_copy(v), kk), jv_object_get(v, vk));
+  jv_free(args);
+  jv_free(kk);
+  jv_free(vk);
+  return r;
+}
+
 int jq_compile_args(jq_state *jq, const char* str, jv args) {
   jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data);
-  assert(jv_get_kind(args) == JV_KIND_ARRAY);
+  assert(jv_get_kind(args) == JV_KIND_ARRAY || jv_get_kind(args) == JV_KIND_OBJECT);
   struct locfile* locations;
   locations = locfile_init(jq, "<top-level>", str, strlen(str));
   block program;
@@ -1079,29 +1164,22 @@ int jq_compile_args(jq_state *jq, const char* str, jv args) {
   }
   int nerrors = load_program(jq, locations, &program);
   if (nerrors == 0) {
-    jv_array_foreach(args, i, arg) {
-      jv name = jv_object_get(jv_copy(arg), jv_string("name"));
-      jv value = jv_object_get(arg, jv_string("value"));
-      program = gen_var_binding(gen_const(value), jv_string_value(name), program);
-      jv_free(name);
-    }
-
     nerrors = builtins_bind(jq, &program);
     if (nerrors == 0) {
-      nerrors = block_compile(program, &jq->bc, locations);
+      nerrors = block_compile(program, &jq->bc, locations, args = args2obj(args));
     }
-  }
+  } else
+    jv_free(args);
   if (nerrors)
     jq_report_error(jq, jv_string_fmt("jq: %d compile %s", nerrors, nerrors > 1 ? "errors" : "error"));
   if (jq->bc)
     jq->bc = optimize(jq->bc);
-  jv_free(args);
   locfile_free(locations);
   return jq->bc != NULL;
 }
 
 int jq_compile(jq_state *jq, const char* str) {
-  return jq_compile_args(jq, str, jv_array());
+  return jq_compile_args(jq, str, jv_object());
 }
 
 jv jq_get_jq_origin(jq_state *jq) {
@@ -1153,3 +1231,28 @@ void jq_get_debug_cb(jq_state *jq, jq_msg_cb *cb, void **data) {
   *cb = jq->debug_cb;
   *data = jq->debug_cb_data;
 }
+
+void
+jq_halt(jq_state *jq, jv exit_code, jv error_message)
+{
+  assert(!jq->halted);
+  jq->halted = 1;
+  jq->exit_code = exit_code;
+  jq->error_message = error_message;
+}
+
+int
+jq_halted(jq_state *jq)
+{
+  return jq->halted;
+}
+
+jv jq_get_exit_code(jq_state *jq)
+{
+  return jv_copy(jq->exit_code);
+}
+
+jv jq_get_error_message(jq_state *jq)
+{
+  return jv_copy(jq->error_message);
+}

package/deps/jq/{jq.h → src/jq.h}

@@ -2,9 +2,13 @@
 #define JQ_H
 
 #include <stdio.h>
-#include <jv.h>
+#include "jv.h"
 
-enum {JQ_DEBUG_TRACE = 1};
+enum {
+  JQ_DEBUG_TRACE = 1,
+  JQ_DEBUG_TRACE_DETAIL = 2,
+  JQ_DEBUG_TRACE_ALL = JQ_DEBUG_TRACE | JQ_DEBUG_TRACE_DETAIL,
+};
 
 typedef struct jq_state jq_state;
 typedef void (*jq_msg_cb)(void *, jv);
@@ -22,6 +26,11 @@ void jq_start(jq_state *, jv value, int);
 jv jq_next(jq_state *);
 void jq_teardown(jq_state **);
 
+void jq_halt(jq_state *, jv, jv);
+int jq_halted(jq_state *);
+jv jq_get_exit_code(jq_state *);
+jv jq_get_error_message(jq_state *);
+
 typedef jv (*jq_input_cb)(jq_state *, void *);
 void jq_set_input_cb(jq_state *, jq_input_cb, void *);
 void jq_get_input_cb(jq_state *, jq_input_cb *, void **);
@@ -57,4 +66,6 @@ jv jq_util_input_get_position(jq_state*);
 jv jq_util_input_get_current_filename(jq_state*);
 jv jq_util_input_get_current_line(jq_state*);
 
+int jq_set_colors(const char *);
+
 #endif /* !JQ_H */

package/deps/jq/{jq_test.c → src/jq_test.c}

@@ -157,7 +157,7 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
         printf(" for test at line number %u: %s\n", lineno, prog);
         pass = 0;
       }
-      jv as_string = jv_dump_string(jv_copy(expected), rand() & ~(JV_PRINT_COLOUR|JV_PRINT_REFCOUNT));
+      jv as_string = jv_dump_string(jv_copy(expected), rand() & ~(JV_PRINT_COLOR|JV_PRINT_REFCOUNT));
       jv reparsed = jv_parse_sized(jv_string_value(as_string), jv_string_length_bytes(jv_copy(as_string)));
       assert(jv_equal(jv_copy(expected), jv_copy(reparsed)));
       jv_free(as_string);

package/deps/jq/{jv.c → src/jv.c}

@@ -6,6 +6,7 @@
 #include <string.h>
 #include <stdarg.h>
 #include <limits.h>
+#include <math.h>
 
 #include "jv_alloc.h"
 #include "jv.h"
@@ -295,10 +296,18 @@ static jv jvp_array_slice(jv a, int start, int end) {
     jv_free(a);
     return jv_array();
   }
-  // FIXME FIXME FIXME large offsets
-  a.offset += start;
-  a.size = end - start;
-  return a;
+
+  if (a.offset + start >= 1 << (sizeof(a.offset) * CHAR_BIT)) {
+    jv r = jv_array_sized(end - start);
+    for (int i = start; i < end; i++)
+      r = jv_array_append(r, jv_array_get(jv_copy(a), i));
+    jv_free(a);
+    return r;
+  } else {
+    a.offset += start;
+    a.size = end - start;
+    return a;
+  }
 }
 
 /*
@@ -1105,6 +1114,16 @@ jv jv_object_get(jv object, jv key) {
   return val;
 }
 
+int jv_object_has(jv object, jv key) {
+  assert(jv_get_kind(object) == JV_KIND_OBJECT);
+  assert(jv_get_kind(key) == JV_KIND_STRING);
+  jv* slot = jvp_object_read(object, key);
+  int res = slot ? 1 : 0;
+  jv_free(object);
+  jv_free(key);
+  return res;
+}
+
 jv jv_object_set(jv object, jv key, jv value) {
   assert(jv_get_kind(object) == JV_KIND_OBJECT);
   assert(jv_get_kind(key) == JV_KIND_STRING);
@@ -1302,7 +1321,7 @@ int jv_identical(jv a, jv b) {
       r = a.u.ptr == b.u.ptr;
       break;
     case JV_KIND_NUMBER:
-      r = a.u.number == b.u.number;
+      r = memcmp(&a.u.number, &b.u.number, sizeof(a.u.number)) == 0;
       break;
     default:
       r = 1;

package/deps/jq/{jv.h → src/jv.h}

@@ -92,7 +92,7 @@ jv jv_array_indexes(jv, jv);
 #define JV_ARRAY_9(e1,e2,e3,e4,e5,e6,e7,e8,e9) (jv_array_append(JV_ARRAY_8(e1,e2,e3,e4,e5,e6,e7,e8),e9))
 #define JV_ARRAY_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,NAME,...) NAME
 #define JV_ARRAY(...) \
-  JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1)(__VA_ARGS__)
+  JV_ARRAY_IDX(__VA_ARGS__, JV_ARRAY_9, JV_ARRAY_8, JV_ARRAY_7, JV_ARRAY_6, JV_ARRAY_5, JV_ARRAY_4, JV_ARRAY_3, JV_ARRAY_2, JV_ARRAY_1, dummy)(__VA_ARGS__)
 
 #ifdef __GNUC__
 #define JV_PRINTF_LIKE(fmt_arg_num, args_num) \
@@ -123,6 +123,7 @@ jv jv_string_implode(jv j);
 
 jv jv_object(void);
 jv jv_object_get(jv object, jv key);
+int jv_object_has(jv object, jv key);
 jv jv_object_set(jv object, jv key, jv value);
 jv jv_object_delete(jv object, jv key);
 int jv_object_length(jv object);
@@ -144,17 +145,51 @@ jv jv_object_iter_value(jv, int);
            : 0;                                                         \
          jv_i__ = jv_object_iter_next(t, jv_i__))                       \
 
-#define JV_OBJECT_1(k) (jv_object_set(jv_object(),(k),jv_null()))
+#define jv_object_keys_foreach(t, k)                                 \
+  for (int jv_i__ = jv_object_iter(t), jv_j__ = 1; jv_j__; jv_j__ = 0)  \
+    for (jv k;                                                          \
+         jv_object_iter_valid((t), jv_i__) ?                            \
+           (k = jv_object_iter_key(t, jv_i__),                          \
+            1)                                                          \
+           : 0;                                                         \
+         jv_i__ = jv_object_iter_next(t, jv_i__))
+
+#define JV_OBJECT_1(k1) (jv_object_set(jv_object(),(k1),jv_null()))
 #define JV_OBJECT_2(k1,v1) (jv_object_set(jv_object(),(k1),(v1)))
-#define JV_OBJECT_3(k1,v1,k2) (jv_object_set(JV_OBJECT_2(k1,v1),k2,jv_null()))
-#define JV_OBJECT_4(k1,v1,k2,v2) (jv_object_set(JV_OBJECT_2(k1,v1),k2,v2))
-#define JV_OBJECT_5(k1,v1,k2,v2,k3) (jv_object_set(JV_OBJECT_4(k1,v1,k2,v2),k3,jv_null))
-#define JV_OBJECT_6(k1,v1,k2,v2,k3,v3) (jv_object_set(JV_OBJECT_4(k1,v1,k2,v2),k3,v3))
-#define JV_OBJECT_7(k1,v1,k2,v2,k3,v3,k4) (jv_object_set(JV_OBJECT_6(k1,v1,k2,v2,k3,v3),k4,jv_null()))
-#define JV_OBJECT_8(k1,v1,k2,v2,k3,v3,k4,v4) (jv_object_set(JV_OBJECT_6(k1,v1,k2,v2,k3,v3),k4,v4))
-#define JV_OBJECT_IDX(_1,_2,_3,_4,_5,_6,_7,_8,NAME,...) NAME
+#define JV_OBJECT_3(k1,v1,k2) (jv_object_set(JV_OBJECT_2((k1),(v1)),(k2),jv_null()))
+#define JV_OBJECT_4(k1,v1,k2,v2) (jv_object_set(JV_OBJECT_2((k1),(v1)),(k2),(v2)))
+#define JV_OBJECT_5(k1,v1,k2,v2,k3) (jv_object_set(JV_OBJECT_4((k1),(v1),(k2),(v2)),(k3),jv_null()))
+#define JV_OBJECT_6(k1,v1,k2,v2,k3,v3) (jv_object_set(JV_OBJECT_4((k1),(v1),(k2),(v2)),(k3),(v3)))
+#define JV_OBJECT_7(k1,v1,k2,v2,k3,v3,k4) (jv_object_set(JV_OBJECT_6((k1),(v1),(k2),(v2),(k3),(v3)),(k4),jv_null()))
+#define JV_OBJECT_8(k1,v1,k2,v2,k3,v3,k4,v4) (jv_object_set(JV_OBJECT_6((k1),(v1),(k2),(v2),(k3),(v3)),(k4),(v4)))
+#define JV_OBJECT_9(k1,v1,k2,v2,k3,v3,k4,v4,k5) \
+    (jv_object_set(JV_OBJECT_8((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4)),(k5),jv_null()))
+#define JV_OBJECT_10(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5) \
+    (jv_object_set(JV_OBJECT_8((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4)),(k5),(v5)))
+#define JV_OBJECT_11(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6) \
+    (jv_object_set(JV_OBJECT_10((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5)),(k6),jv_null()))
+#define JV_OBJECT_12(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6) \
+    (jv_object_set(JV_OBJECT_10((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5)),(k6),(v6)))
+#define JV_OBJECT_13(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6,k7) \
+    (jv_object_set(JV_OBJECT_12((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5),(k6),(v6)),(k7),jv_null()))
+#define JV_OBJECT_14(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6,k7,v7) \
+    (jv_object_set(JV_OBJECT_12((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5),(k6),(v6)),(k7),(v7)))
+#define JV_OBJECT_15(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6,k7,v7,k8) \
+    (jv_object_set(JV_OBJECT_14((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5),(k6),(v6),(k7),(v7)),(k8),jv_null()))
+#define JV_OBJECT_16(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6,k7,v7,k8,v8) \
+    (jv_object_set(JV_OBJECT_14((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5),(k6),(v6),(k7),(v7)),(k8),(v8)))
+#define JV_OBJECT_17(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6,k7,v7,k8,v8,k9) \
+    (jv_object_set(JV_OBJECT_16((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5),(k6),(v6),(k7),(v7),(k8),(v8)),(k9),jv_null()))
+#define JV_OBJECT_18(k1,v1,k2,v2,k3,v3,k4,v4,k5,v5,k6,v6,k7,v7,k8,v8,k9,v9) \
+    (jv_object_set(JV_OBJECT_16((k1),(v1),(k2),(v2),(k3),(v3),(k4),(v4),(k5),(v5),(k6),(v6),(k7),(v7),(k8),(v8)),(k9),(v9)))
+#define JV_OBJECT_IDX(_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12,_13,_14,_15,_16,_17,_18,NAME,...) NAME
 #define JV_OBJECT(...) \
-  JV_OBJECT_IDX(__VA_ARGS__, JV_OBJECT_8, JV_OBJECT_7, JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3, JV_OBJECT_2, JV_OBJECT_1)(__VA_ARGS__)
+  JV_OBJECT_IDX(__VA_ARGS__, \
+                JV_OBJECT_18, JV_OBJECT_17, JV_OBJECT_16, JV_OBJECT_15, \
+                JV_OBJECT_14, JV_OBJECT_13, JV_OBJECT_12, JV_OBJECT_11, \
+                JV_OBJECT_10, JV_OBJECT_9, JV_OBJECT_8, JV_OBJECT_7,    \
+                JV_OBJECT_6, JV_OBJECT_5, JV_OBJECT_4, JV_OBJECT_3,     \
+                JV_OBJECT_2, JV_OBJECT_1)(__VA_ARGS__)
 
 
 
@@ -163,7 +198,7 @@ int jv_get_refcnt(jv);
 enum jv_print_flags {
   JV_PRINT_PRETTY   = 1,
   JV_PRINT_ASCII    = 2,
-  JV_PRINT_COLOUR   = 4,
+  JV_PRINT_COLOR    = 4, JV_PRINT_COLOUR = 4,
   JV_PRINT_SORTED   = 8,
   JV_PRINT_INVALID  = 16,
   JV_PRINT_REFCOUNT = 32,

package/deps/jq/{jv_aux.c → src/jv_aux.c}

@@ -214,7 +214,7 @@ jv jv_has(jv t, jv k) {
 }
 
 // assumes keys is a sorted array
-jv jv_dels(jv t, jv keys) {
+static jv jv_dels(jv t, jv keys) {
   assert(jv_get_kind(keys) == JV_KIND_ARRAY);
   assert(jv_is_valid(t));
 
@@ -222,13 +222,17 @@ jv jv_dels(jv t, jv keys) {
     // no change
   } else if (jv_get_kind(t) == JV_KIND_ARRAY) {
     // extract slices, they must be handled differently
-    jv orig_keys = keys;
-    keys = jv_array();
+    jv neg_keys = jv_array();
+    jv nonneg_keys = jv_array();
     jv new_array = jv_array();
     jv starts = jv_array(), ends = jv_array();
-    jv_array_foreach(orig_keys, i, key) {
+    jv_array_foreach(keys, i, key) {
       if (jv_get_kind(key) == JV_KIND_NUMBER) {
-        keys = jv_array_append(keys, key);
+        if (jv_number_value(key) < 0) {
+          neg_keys = jv_array_append(neg_keys, key);
+        } else {
+          nonneg_keys = jv_array_append(nonneg_keys, key);
+        }
       } else if (jv_get_kind(key) == JV_KIND_OBJECT) {
         int start, end;
         if (parse_slice(jv_copy(t), key, &start, &end)) {
@@ -248,18 +252,30 @@ jv jv_dels(jv t, jv keys) {
       }
     }
 
-    int kidx = 0;
+    int neg_idx = 0;
+    int nonneg_idx = 0;
+    int len = jv_array_length(jv_copy(t));
     jv_array_foreach(t, i, elem) {
       int del = 0;
-      while (kidx < jv_array_length(jv_copy(keys))) {
-        int delidx = (int)jv_number_value(jv_array_get(jv_copy(keys), kidx));
+      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));
         if (i == delidx) {
           del = 1;
         }
         if (i < delidx) {
           break;
         }
-        kidx++;
+        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));
+        if (i == delidx) {
+          del = 1;
+        }
+        if (i < delidx) {
+          break;
+        }
+        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 &&
@@ -273,9 +289,10 @@ jv jv_dels(jv t, jv keys) {
         jv_free(elem);
     }
   arr_out:
+    jv_free(neg_keys);
+    jv_free(nonneg_keys);
     jv_free(starts);
     jv_free(ends);
-    jv_free(orig_keys);
     jv_free(t);
     t = new_array;
   } else if (jv_get_kind(t) == JV_KIND_OBJECT) {
@@ -390,6 +407,11 @@ static jv delpaths_sorted(jv object, jv paths, int start) {
 }
 
 jv jv_delpaths(jv object, jv paths) {
+  if (jv_get_kind(paths) != JV_KIND_ARRAY) {
+    jv_free(object);
+    jv_free(paths);
+    return jv_invalid_with_msg(jv_string("Paths must be specified as an array"));
+  }
   paths = jv_sort(paths, jv_copy(paths));
   jv_array_foreach(paths, i, elem) {
     if (jv_get_kind(elem) != JV_KIND_ARRAY) {
@@ -443,7 +465,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_alloc(sizeof(jv) * nkeys);
+    jv* keys = jv_mem_calloc(sizeof(jv), nkeys);
     int kidx = 0;
     jv_object_foreach(x, key, value) {
       keys[kidx++] = key;
@@ -549,14 +571,15 @@ int jv_cmp(jv a, jv b) {
 struct sort_entry {
   jv object;
   jv key;
+  int index;
 };
 
 static int sort_cmp(const void* pa, const void* pb) {
   const struct sort_entry* a = pa;
   const struct sort_entry* b = pb;
   int r = jv_cmp(jv_copy(a->key), jv_copy(b->key));
-  // comparing by address if r == 0 makes the sort stable
-  return r ? r : (int)(a - b);
+  // comparing by index if r == 0 makes the sort stable
+  return r ? r : (a->index - b->index);
 }
 
 static struct sort_entry* sort_items(jv objects, jv keys) {
@@ -564,10 +587,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));
-  struct sort_entry* entries = jv_mem_alloc(sizeof(struct sort_entry) * n);
+  struct sort_entry* entries = jv_mem_calloc(sizeof(struct sort_entry), n);
   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);
+    entries[i].index = i;
   }
   jv_free(objects);
   jv_free(keys);

package/deps/jq/{jv_dtoa.c → src/jv_dtoa.c}

@@ -2327,7 +2327,7 @@ retlow1:
 jvp_strtod
  (struct dtoa_context* C, const char *s00, char **se)
 {
-	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1;
+	int bb2, bb5, bbe, bd2, bd5, bbbits, bs2, c, e, e1, test_scale;
 	int esign, i, j, k, nd, nd0, nf, nz, nz0, nz1, sign;
 	CONST char *s, *s0, *s1;
 	double aadj, aadj1;
@@ -2941,12 +2941,11 @@ jvp_strtod
 					if (!word1(&rv)
 					 && !(word0(&rv) & Frac_mask)) {
 						y = word0(&rv) & Exp_mask;
+						test_scale = y;
 #ifdef Avoid_Underflow
-						if (!bc.scale || y > 2*P*Exp_msk1)
-#else
-						if (y)
+						test_scale = (!bc.scale || y > 2*P*Exp_msk1);
 #endif
-						  {
+						if (test_scale) {
 						  delta = lshift(C, delta,Log2P);
 						  if (cmp(C, delta, bs) <= 0)
 							adj.d = -0.5;