@port-labs/jq-node-bindings 1.0.1 → 1.0.2-rc.1

package/deps/jq/src/builtin.jq

@@ -8,8 +8,7 @@ def unique: group_by(.) | map(.[0]);
 def unique_by(f): group_by(f) | map(.[0]);
 def max_by(f): _max_by_impl(map([f]));
 def min_by(f): _min_by_impl(map([f]));
-def add(f): reduce f as $x (null; . + $x);
-def add: add(.[]);
+def add: reduce .[] as $x (null; . + $x);
 def del(f): delpaths([path(f)]);
 def abs: if . < 0 then - . else . end;
 def _assign(paths; $value): reduce path(paths) as $p (.; setpath($p; $value));
@@ -75,8 +74,6 @@ def fromdateiso8601: strptime("%Y-%m-%dT%H:%M:%SZ")|mktime;
 def todateiso8601: strftime("%Y-%m-%dT%H:%M:%SZ");
 def fromdate: fromdateiso8601;
 def todate: todateiso8601;
-def ltrimstr($left): if startswith($left) then .[$left | length:] end;
-def rtrimstr($right): if endswith($right) then .[:$right | -length] end;
 def match(re; mode): _match_impl(re; mode; false)|.[];
 def match($val): ($val|type) as $vt | if $vt == "string" then match($val; null)
    elif $vt == "array" and ($val | length) > 1 then match($val[0]; $val[1])
@@ -149,14 +146,10 @@ def until(cond; next):
      def _until:
          if cond then . else (next|_until) end;
      _until;
-def limit($n; expr):
-  if $n > 0 then label $out | foreach expr as $item ($n; . - 1; $item, if . <= 0 then break $out else empty end)
-  elif $n == 0 then empty
-  else error("limit doesn't support negative count") end;
-def skip($n; expr):
-  if $n > 0 then foreach expr as $item ($n; . - 1; if . < 0 then $item else empty end)
-  elif $n == 0 then expr
-  else error("skip doesn't support negative count") end;
+def limit($n; exp):
+    if $n > 0 then label $out | foreach exp as $item ($n; .-1; $item, if . <= 0 then break $out else empty end)
+    elif $n == 0 then empty
+    else exp end;
 # range/3, with a `by` expression argument
 def range($init; $upto; $by):
     if $by > 0 then $init|while(. < $upto; . + $by)
@@ -170,9 +163,10 @@ def all(condition): all(.[]; condition);
 def any(condition): any(.[]; condition);
 def all: all(.[]; .);
 def any: any(.[]; .);
+def last(g): reduce g as $item (null; $item);
 def nth($n; g):
   if $n < 0 then error("nth doesn't support negative indices")
-  else first(skip($n; g)) end;
+  else label $out | foreach g as $item ($n + 1; . - 1; if . <= 0 then $item, break $out else empty end) end;
 def first: .[0];
 def last: .[-1];
 def nth($n): .[$n];

package/deps/jq/src/bytecode.h

@@ -2,7 +2,7 @@
 #define BYTECODE_H
 #include <stdint.h>
 
-#include "jq.h"
+#include "jv.h"
 
 typedef enum {
 #define OP(name, imm, in, out) name,
@@ -44,14 +44,9 @@ struct opcode_description {
 const struct opcode_description* opcode_describe(opcode op);
 
 
-#define MAX_CFUNCTION_ARGS 4
+#define MAX_CFUNCTION_ARGS 10
 struct cfunction {
-  union {
-    jv (*a1)(jq_state *, jv);
-    jv (*a2)(jq_state *, jv, jv);
-    jv (*a3)(jq_state *, jv, jv, jv);
-    jv (*a4)(jq_state *, jv, jv, jv, jv);
-  } fptr;
+  jv (*fptr)();
   const char* name;
   int nargs;
 };

package/deps/jq/src/compile.c

@@ -832,7 +832,7 @@ block gen_reduce(block source, block matcher, block init, block body) {
   block loop = BLOCK(gen_op_simple(DUPN),
                      source,
                      bind_alternation_matchers(matcher,
-                                  BLOCK(gen_op_bound(LOADV, res_var),
+                                  BLOCK(gen_op_bound(LOADVN, res_var),
                                         body,
                                         gen_op_bound(STOREV, res_var))),
                      gen_op_simple(BACKTRACK));
@@ -854,7 +854,7 @@ block gen_foreach(block source, block matcher, block init, block update, block e
                      // in the body to see
                      bind_alternation_matchers(matcher,
                                   // load the loop state variable
-                                  BLOCK(gen_op_bound(LOADV, state_var),
+                                  BLOCK(gen_op_bound(LOADVN, state_var),
                                         // generate updated state
                                         update,
                                         // save the updated state for value extraction

package/deps/jq/src/decNumber/decBasic.c

@@ -756,7 +756,7 @@ static void decFiniteMultiply(bcdnum *num, uByte *bcdacc,
   #endif
 
   /* Effect the multiplication */
-  // The multiplication proceeds using MFC's lazy-carry resolution
+  // The multiplcation proceeds using MFC's lazy-carry resolution
   // algorithm from decNumber.  First, the multiplication is
   // effected, allowing accumulation of the partial products (which
   // are in base-billion at each column position) into 64 bits

package/deps/jq/src/decNumber/decCommon.c

@@ -376,7 +376,7 @@ static decFloat * decFinalize(decFloat *df, bcdnum *num,
             UBFROMUI(ub-3, 0);               // to 00000000
             }
           // [note ub could now be to left of msd, and it is not safe
-          // to write to the left of the msd]
+          // to write to the the left of the msd]
           // now at most 3 digits left to non-9 (usually just the one)
           for (; ub>=umsd; *ub=0, ub--) {
             if (*ub==9) continue;            // carry

package/deps/jq/src/decNumber/decNumber.c

@@ -2168,7 +2168,7 @@ decNumber * decNumberPower(decNumber *res, const decNumber *lhs,
       // if a negative power the constant 1 is needed, and if not subset
       // invert the lhs now rather than inverting the result later
       if (decNumberIsNegative(rhs)) {   // was a **-n [hence digits>0]
-        decNumber *inv=invbuff;         // assume use fixed buffer
+        decNumber *inv=invbuff;         // asssume use fixed buffer
         decNumberCopy(&dnOne, dac);     // dnOne=1;  [needed now or later]
         #if DECSUBSET
         if (set->extended) {            // need to calculate 1/lhs
@@ -3798,7 +3798,7 @@ static void decToString(const decNumber *dn, char *string, Flag eng) {
 /*                                                                    */
 /* Addition, especially x=x+1, is speed-critical.                     */
 /* The static buffer is larger than might be expected to allow for    */
-/* calls from higher-level functions (notable exp).                    */
+/* calls from higher-level funtions (notable exp).                    */
 /* ------------------------------------------------------------------ */
 static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
                             const decNumber *rhs, decContext *set,
@@ -4212,7 +4212,7 @@ static decNumber * decAddOp(decNumber *res, const decNumber *lhs,
 /* long subtractions.  These are acc and var1 respectively.           */
 /* var1 is a copy of the lhs coefficient, var2 is the rhs coefficient.*/
 /* The static buffers may be larger than might be expected to allow   */
-/* for calls from higher-level functions (notable exp).                */
+/* for calls from higher-level funtions (notable exp).                */
 /* ------------------------------------------------------------------ */
 static decNumber * decDivideOp(decNumber *res,
                                const decNumber *lhs, const decNumber *rhs,
@@ -5203,7 +5203,7 @@ static decNumber * decMultiplyOp(decNumber *res, const decNumber *lhs,
 /*    exp(-x) where x can be the tiniest number (Ntiny).              */
 /*                                                                    */
 /* 2. Normalizing x to be <=0.1 (instead of <=1) reduces loop         */
-/*    iterations by approximately a third with additional (although    */
+/*    iterations by appoximately a third with additional (although    */
 /*    diminishing) returns as the range is reduced to even smaller    */
 /*    fractions.  However, h (the power of 10 used to correct the     */
 /*    result at the end, see below) must be kept <=8 as otherwise     */

package/deps/jq/src/execute.c

@@ -18,6 +18,9 @@
 #include "builtin.h"
 #include "util.h"
 #include "linker.h"
+#include "time.h"
+
+#define CHECK_TIMEOUT_FREQ 100
 
 struct jq_state {
   void (*nomem_handler)(void *);
@@ -315,9 +318,7 @@ static void jq_reset(jq_state *jq) {
 
   jq->halted = 0;
   jv_free(jq->exit_code);
-  jq->exit_code = jv_invalid();
   jv_free(jq->error_message);
-  jq->error_message = jv_invalid();
   if (jv_get_kind(jq->path) != JV_KIND_INVALID)
     jv_free(jq->path);
   jq->path = jv_null();
@@ -340,7 +341,9 @@ static void set_error(jq_state *jq, jv value) {
 
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
-jv jq_next(jq_state *jq) {
+jv jq_next(jq_state *jq, unsigned int timeout_sec) {
+  jv cfunc_input[MAX_CFUNCTION_ARGS];
+
   jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data);
 
   uint16_t* pc = stack_restore(jq);
@@ -349,6 +352,9 @@ jv jq_next(jq_state *jq) {
   int raising;
   int backtracking = !jq->initial_execution;
 
+  char check_timeout_freq = CHECK_TIMEOUT_FREQ;
+  clock_t deadline = clock() + timeout_sec * CLOCKS_PER_SEC;
+
   jq->initial_execution = 0;
   assert(jv_get_kind(jq->error) == JV_KIND_NULL);
   while (1) {
@@ -357,6 +363,15 @@ jv jq_next(jq_state *jq) {
         printf("\t<halted>\n");
       return jv_invalid();
     }
+
+    if(check_timeout_freq != 0) {
+      check_timeout_freq--;
+    } else if (clock() > deadline) {
+      return jv_invalid_with_msg(jv_string("timeout"));
+    } else {
+      check_timeout_freq = CHECK_TIMEOUT_FREQ;
+    }
+
     uint16_t opcode = *pc;
     raising = 0;
 
@@ -521,7 +536,7 @@ jv jq_next(jq_state *jq) {
       if (raising) {
         jv_free(max);
         goto do_backtrack;
-      } 
+      }
       if (jv_get_kind(*var) != JV_KIND_NUMBER ||
           jv_get_kind(max) != JV_KIND_NUMBER) {
         set_error(jq, jv_invalid_with_msg(jv_string_fmt("Range bounds must be numeric")));
@@ -781,10 +796,8 @@ jv jq_next(jq_state *jq) {
       }
 
       if (!keep_going || raising) {
-        if (keep_going) {
-          jv_free(key);
+        if (keep_going)
           jv_free(value);
-        }
         jv_free(container);
         goto do_backtrack;
       } else if (is_last) {
@@ -907,27 +920,34 @@ jv jq_next(jq_state *jq) {
 
     case CALL_BUILTIN: {
       int nargs = *pc++;
-      struct cfunction* function = &frame_current(jq)->bc->globals->cfunctions[*pc++];
-      jv in[MAX_CFUNCTION_ARGS];
-      for (int i = 0; i < nargs; ++i)
+      jv top = stack_pop(jq);
+      jv* in = cfunc_input;
+      in[0] = top;
+      for (int i = 1; i < nargs; i++) {
         in[i] = stack_pop(jq);
-
-      jv top;
+      }
+      struct cfunction* function = &frame_current(jq)->bc->globals->cfunctions[*pc++];
       switch (function->nargs) {
-      case 1: top = function->fptr.a1(jq, in[0]); break;
-      case 2: top = function->fptr.a2(jq, in[0], in[1]); break;
-      case 3: top = function->fptr.a3(jq, in[0], in[1], in[2]); break;
-      case 4: top = function->fptr.a4(jq, in[0], in[1], in[2], in[3]); break;
-      default: assert(0 && "Invalid number of arguments");
+      case 1: top = ((jv (*)(jq_state *, jv))function->fptr)(jq, in[0]); break;
+      case 2: top = ((jv (*)(jq_state *, jv, jv))function->fptr)(jq, in[0], in[1]); break;
+      case 3: top = ((jv (*)(jq_state *, jv, jv, jv))function->fptr)(jq, in[0], in[1], in[2]); break;
+      case 4: top = ((jv (*)(jq_state *, jv, jv, jv, jv))function->fptr)(jq, in[0], in[1], in[2], in[3]); break;
+      case 5: top = ((jv (*)(jq_state *, jv, jv, jv, jv, jv))function->fptr)(jq, in[0], in[1], in[2], in[3], in[4]); break;
+      // FIXME: a) up to 7 arguments (input + 6), b) should assert
+      // because the compiler should not generate this error.
+      default: return jv_invalid_with_msg(jv_string("Function takes too many arguments"));
       }
 
-      if (!jv_is_valid(top)) {
-        if (jv_invalid_has_msg(jv_copy(top)))
-          set_error(jq, top);
+      if (jv_is_valid(top)) {
+        stack_push(jq, top);
+      } else if (jv_invalid_has_msg(jv_copy(top))) {
+        set_error(jq, top);
+        goto do_backtrack;
+      } else {
+        // C-coded function returns invalid w/o msg? -> backtrack, as if
+        // it had returned `empty`
         goto do_backtrack;
       }
-
-      stack_push(jq, top);
       break;
     }
 

package/deps/jq/src/jq.h

@@ -27,7 +27,7 @@ int jq_compile(jq_state *, const char*);
 int jq_compile_args(jq_state *, const char*, jv);
 void jq_dump_disassembly(jq_state *, int);
 void jq_start(jq_state *, jv value, int);
-jv jq_next(jq_state *);
+jv jq_next(jq_state *, unsigned int);
 void jq_teardown(jq_state **);
 
 void jq_halt(jq_state *, jv, jv);

package/deps/jq/src/jq_test.c

@@ -10,11 +10,12 @@
 
 static void jv_test();
 static void run_jq_tests(jv, int, FILE *, int, int);
-static void run_jq_start_state_tests();
 #ifdef HAVE_PTHREAD
 static void run_jq_pthread_tests();
 #endif
 
+#define TIMEOUT_SEC 5
+
 int jq_testsuite(jv libdirs, int verbose, int argc, char* argv[]) {
   FILE *testdata = stdin;
   int skip = -1;
@@ -38,7 +39,6 @@ int jq_testsuite(jv libdirs, int verbose, int argc, char* argv[]) {
     }
   }
   run_jq_tests(libdirs, verbose, testdata, skip, take);
-  run_jq_start_state_tests();
 #ifdef HAVE_PTHREAD
   run_jq_pthread_tests();
 #endif
@@ -76,7 +76,7 @@ static void test_err_cb(void *data, jv e) {
 }
 
 static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int take) {
-  char prog[4096] = {0};
+  char prog[4096];
   char buf[4096];
   struct err_data err_msg;
   int tests = 0, passed = 0, invalid = 0;
@@ -195,7 +195,7 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
         invalid++;
         continue;
       }
-      jv actual = jq_next(jq);
+      jv actual = jq_next(jq, TIMEOUT_SEC);
       if (!jv_is_valid(actual)) {
         jv_free(expected);
         jv_free(actual);
@@ -210,18 +210,16 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
         printf(" for test at line number %u: %s\n", lineno, prog);
         pass = 0;
       }
-#ifdef USE_DECNUM
       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);
       jv_free(reparsed);
-#endif
       jv_free(expected);
       jv_free(actual);
     }
     if (pass) {
-      jv extra = jq_next(jq);
+      jv extra = jq_next(jq, TIMEOUT_SEC);
       if (jv_is_valid(extra)) {
         printf("*** Superfluous result: ");
         jv_dump(extra, 0);
@@ -253,66 +251,6 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
 }
 
 
-static int test_start_state(jq_state *jq, char *prog) {
-  int pass = 1;
-  jv message = jq_get_error_message(jq);
-  if (jv_is_valid(message)) {
-    printf("*** Expected error_message to be invalid after jq_start: %s\n", prog);
-    pass = 0;
-  }
-  jv_free(message);
-
-  jv exit_code = jq_get_exit_code(jq);
-  if (jv_is_valid(exit_code)) {
-    printf("*** Expected exit_code to be invalid after jq_start: %s\n", prog);
-    pass = 0;
-  }
-  jv_free(exit_code);
-
-  if (jq_halted(jq)) {
-    printf("*** Expected jq to not be halted after jq_start: %s\n", prog);
-    pass = 0;
-  }
-
-  return pass;
-}
-
-// Test jq_state is reset after subsequent calls to jq_start.
-static void test_jq_start_resets_state(char *prog, const char *input) {
-  printf("Test jq_state: %s\n", prog);
-  jq_state *jq = jq_init();
-  assert(jq);
-
-  int compiled = jq_compile(jq, prog);
-  assert(compiled);
-
-  // First call to jq_start. Run until completion.
-  jv parsed_input = jv_parse(input);
-  assert(jv_is_valid(parsed_input));
-  jq_start(jq, parsed_input, 0);
-  assert(test_start_state(jq, prog));
-  while (1) {
-    jv result = jq_next(jq);
-    int valid = jv_is_valid(result);
-    jv_free(result);
-    if (!valid) { break; }
-  }
-
-  // Second call to jq_start.
-  jv parsed_input2 = jv_parse(input);
-  assert(jv_is_valid(parsed_input2));
-  jq_start(jq, parsed_input2, 0);
-  assert(test_start_state(jq, prog));
-
-  jq_teardown(&jq);
-}
-
-static void run_jq_start_state_tests() {
-  test_jq_start_resets_state(".[]", "[1,2,3]");
-  test_jq_start_resets_state(".[] | if .%2 == 0 then halt_error else . end", "[1,2,3]");
-}
-
-
 /// pthread regression test
 #ifdef HAVE_PTHREAD
 #define NUMBER_OF_THREADS 3
@@ -328,11 +266,11 @@ static int test_pthread_jq_parse(jq_state *jq, struct jv_parser *parser)
     value = jv_parser_next(parser);
     while (jv_is_valid(value)) {
         jq_start(jq, value, 0);
-        jv result = jq_next(jq);
+        jv result = jq_next(jq, TIMEOUT_SEC);
 
         while (jv_is_valid(result)) {
             jv_free(result);
-            result = jq_next(jq);
+            result = jq_next(jq, TIMEOUT_SEC);
         }
         jv_free(result);
         value = jv_parser_next(parser);

package/deps/jq/src/jv.c

@@ -213,9 +213,9 @@ enum {
 #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_NUMBER_DOUBLE_PRECISION   (17)
+#define DEC_NUBMER_DOUBLE_PRECISION   (17)
 #define DEC_NUMBER_STRING_GUARD       (14)
-#define DEC_NUMBER_DOUBLE_EXTRA_UNITS ((DEC_NUMBER_DOUBLE_PRECISION - DECNUMDIGITS + DECDPUN - 1)/DECDPUN)
+#define DEC_NUBMER_DOUBLE_EXTRA_UNITS ((DEC_NUBMER_DOUBLE_PRECISION - DECNUMDIGITS + DECDPUN - 1)/DECDPUN)
 
 #include "jv_thread.h"
 #ifdef WIN32
@@ -542,7 +542,7 @@ typedef struct {
 
 typedef struct {
   decNumber number;
-  decNumberUnit units[DEC_NUMBER_DOUBLE_EXTRA_UNITS];
+  decNumberUnit units[DEC_NUBMER_DOUBLE_EXTRA_UNITS];
 } decNumberDoublePrecision;
 
 
@@ -600,11 +600,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_NUMBER_DOUBLE_PRECISION;
+  dblCtx.digits = DEC_NUBMER_DOUBLE_PRECISION;
 
   decNumber *p_dec_number = jvp_dec_number_ptr(j);
   decNumberDoublePrecision dec_double;
-  char literal[DEC_NUMBER_DOUBLE_PRECISION + DEC_NUMBER_STRING_GUARD + 1];
+  char literal[DEC_NUBMER_DOUBLE_PRECISION + DEC_NUMBER_STRING_GUARD + 1];
 
   // reduce the number to the shortest possible form
   // that fits into the 64 bit floating point representation
@@ -1025,13 +1025,14 @@ 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;
-  int alen = jv_array_length(jv_copy(a));
-  for (int ai = 0; ai < alen; ++ai) {
+  jv_array_foreach(a, ai, aelem) {
+    jv_free(aelem);
     jv_array_foreach(b, bi, belem) {
-      if (!jv_equal(jv_array_get(jv_copy(a), ai + bi), belem))
+      if (!jv_equal(jv_array_get(jv_copy(a), ai + bi), jv_copy(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));
@@ -1273,21 +1274,15 @@ 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, *lp;
+  const char *p;
   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) {
-    int n = 0;
-    p = lp = jstr;
+    p = jstr;
     while ((p = _jq_memmem(p, (jstr + jlen) - p, idxstr, idxlen)) != NULL) {
-      while (lp < p) {
-        lp += jvp_utf8_decode_length(*lp);
-        n++;
-      }
-
-      a = jv_array_append(a, jv_number(n));
+      a = jv_array_append(a, jv_number(p - jstr));
       p++;
     }
   }

package/deps/jq/src/jv.h

@@ -113,9 +113,6 @@ 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
 
 

package/deps/jq/src/jv_aux.c

@@ -314,7 +314,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));
-    for (int i = 0; i < len; ++i) {
+    jv_array_foreach(t, i, elem) {
       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,7 +343,9 @@ static jv jv_dels(jv t, jv keys) {
         }
       }
       if (!del)
-        new_array = jv_array_append(new_array, jv_array_get(jv_copy(t), i));
+        new_array = jv_array_append(new_array, elem);
+      else
+        jv_free(elem);
     }
   arr_out:
     jv_free(neg_keys);
@@ -417,7 +419,6 @@ 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);

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
-#  error Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
+Exactly one of IEEE_8087, IEEE_MC68k, VAX, or IBM should be defined.
 #endif
 
 typedef union { double d; ULong L[2]; } U;

package/deps/jq/src/jv_parse.c

@@ -512,8 +512,6 @@ static pfunc check_literal(struct jv_parser* p) {
   switch (p->tokenbuf[0]) {
   case 't': pattern = "true"; plen = 4; v = jv_true(); break;
   case 'f': pattern = "false"; plen = 5; v = jv_false(); break;
-  case '\'':
-    return "Invalid string literal; expected \", but got '";
   case 'n':
     // if it starts with 'n', it could be a literal "nan"
     if (p->tokenbuf[1] == 'u') {

package/deps/jq/src/jv_print.c

@@ -29,12 +29,12 @@
 // the last color is used for object keys.
 static char color_bufs[8][16];
 static const char *color_bufps[8];
-static const char *const def_colors[] =
+static const char* def_colors[] =
   {COL("0;90"),    COL("0;39"),      COL("0;39"),     COL("0;39"),
    COL("0;32"),    COL("1;39"),      COL("1;39"),     COL("1;34")};
 #define FIELD_COLOR (colors[7])
 
-static const char *const *colors = def_colors;
+static const char **colors = def_colors;
 
 int
 jq_set_colors(const char *c)
@@ -206,7 +206,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       if (jv_get_kind(msg) == JV_KIND_STRING) {
         put_str("<invalid:", F, S, flags & JV_PRINT_ISATTY);
         jvp_dump_string(msg, flags | JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
-        put_char('>', F, S, flags & JV_PRINT_ISATTY);
+        put_str(">", F, S, flags & JV_PRINT_ISATTY);
       } else {
         put_str("<invalid>", F, S, flags & JV_PRINT_ISATTY);
       }
@@ -259,18 +259,22 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_str("[]", F, S, flags & JV_PRINT_ISATTY);
       break;
     }
-    put_char('[', F, S, flags & JV_PRINT_ISATTY);
+    put_str("[", F, S, flags & JV_PRINT_ISATTY);
+    if (flags & JV_PRINT_PRETTY) {
+      put_char('\n', F, S, flags & JV_PRINT_ISATTY);
+      put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
+    }
     jv_array_foreach(x, i, elem) {
       if (i!=0) {
-        if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
-        put_char(',', F, S, flags & JV_PRINT_ISATTY);
-      }
-      if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
-      if (flags & JV_PRINT_PRETTY) {
-        put_char('\n', F, S, flags & JV_PRINT_ISATTY);
-        put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
+        if (flags & JV_PRINT_PRETTY) {
+          put_str(",\n", F, S, flags & JV_PRINT_ISATTY);
+          put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
+        } else {
+          put_str(",", F, S, flags & JV_PRINT_ISATTY);
+        }
       }
       jv_dump_term(C, elem, flags, indent + 1, F, S);
+      if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
     }
     if (flags & JV_PRINT_PRETTY) {
       put_char('\n', F, S, flags & JV_PRINT_ISATTY);
@@ -288,6 +292,10 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       break;
     }
     put_char('{', F, S, flags & JV_PRINT_ISATTY);
+    if (flags & JV_PRINT_PRETTY) {
+      put_char('\n', F, S, flags & JV_PRINT_ISATTY);
+      put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
+    }
     int first = 1;
     int i = 0;
     jv keyset = jv_null();
@@ -318,14 +326,14 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       }
 
       if (!first) {
-        if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
-        put_char(',', F, S, flags & JV_PRINT_ISATTY);
+        if (flags & JV_PRINT_PRETTY){
+          put_str(",\n", F, S, flags & JV_PRINT_ISATTY);
+          put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
+        } else {
+          put_str(",", F, S, flags & JV_PRINT_ISATTY);
+        }
       }
       if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
-      if (flags & JV_PRINT_PRETTY) {
-        put_char('\n', F, S, flags & JV_PRINT_ISATTY);
-        put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
-      }
 
       first = 0;
       if (color) put_str(FIELD_COLOR, F, S, flags & JV_PRINT_ISATTY);
@@ -334,13 +342,11 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
 
       if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
-      put_char(':', F, S, flags & JV_PRINT_ISATTY);
+      put_str((flags & JV_PRINT_PRETTY) ? ": " : ":", F, S, flags & JV_PRINT_ISATTY);
       if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
-      if (flags & JV_PRINT_PRETTY) {
-        put_char(' ', F, S, flags & JV_PRINT_ISATTY);
-      }
 
       jv_dump_term(C, value, flags, indent + 1, F, S);
+      if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
     }
     if (flags & JV_PRINT_PRETTY) {
       put_char('\n', F, S, flags & JV_PRINT_ISATTY);