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

package/deps/jq/src/builtin.jq

@@ -4,11 +4,11 @@ def map(f): [.[] | f];
 def select(f): if f then . else empty end;
 def sort_by(f): _sort_by_impl(map([f]));
 def group_by(f): _group_by_impl(map([f]));
-def unique: group_by(.) | map(.[0]);
-def unique_by(f): group_by(f) | map(.[0]);
+def unique_by(f): _unique_by_impl(map([f]));
 def max_by(f): _max_by_impl(map([f]));
 def min_by(f): _min_by_impl(map([f]));
-def add: reduce .[] as $x (null; . + $x);
+def add(f): reduce f as $x (null; . + $x);
+def add: add(.[]);
 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));
@@ -74,6 +74,9 @@ 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 trimstr($val): ltrimstr($val) | rtrimstr($val);
 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])
@@ -96,26 +99,16 @@ def scan($re; $flags):
       else .string
       end;
 def scan($re): scan($re; null);
-#
-# If input is an array, then emit a stream of successive subarrays of length n (or less),
-# and similarly for strings.
-def _nwise($n):
-  def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
-  n;
-def _nwise(a; $n): a | _nwise($n);
-#
+
 # splits/1 produces a stream; split/1 is retained for backward compatibility.
-def splits($re; flags): . as $s
-#  # multiple occurrences of "g" are acceptable
-  | [ match($re; "g" + flags) | (.offset, .offset + .length) ]
-  | [0] + . +[$s|length]
-  | _nwise(2)
-  | $s[.[0]:.[1] ] ;
+def splits($re; $flags):
+  .[foreach (match($re; $flags+"g"), null) as {$offset, $length}
+      (null; {start: .next, end: $offset, next: ($offset+$length)})];
 def splits($re): splits($re; null);
-#
+
 # split emits an array for backward compatibility
-def split($re; flags): [ splits($re; flags) ];
-#
+def split($re; $flags): [ splits($re; $flags) ];
+
 # If s contains capture variables, then create a capture object and pipe it to s, bearing
 # in mind that s could be a stream
 def sub($re; s; $flags):
@@ -130,12 +123,12 @@ def sub($re; s; $flags):
             | .previous = ($edit | .offset + .length ) )
           | .result[] + $in[.previous:] )
       // $in;
-#
+
 def sub($re; s): sub($re; s; "");
-#
+
 def gsub($re; s; flags): sub($re; s; flags + "g");
 def gsub($re; s): sub($re; s; "g");
-#
+
 ########################################################################
 # generic iterator/generator
 def while(cond; update):
@@ -146,10 +139,14 @@ def until(cond; next):
      def _until:
          if cond then . else (next|_until) end;
      _until;
-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;
+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;
 # range/3, with a `by` expression argument
 def range($init; $upto; $by):
     if $by > 0 then $init|while(. < $upto; . + $by)
@@ -163,10 +160,9 @@ 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 label $out | foreach g as $item ($n + 1; . - 1; if . <= 0 then $item, break $out else empty end) end;
+  else first(skip($n; g)) end;
 def first: .[0];
 def last: .[-1];
 def nth($n): .[$n];
@@ -213,37 +209,6 @@ def tostream:
   getpath($p) |
   reduce path(.[]?) as $q ([$p, .]; [$p+$q]);
 
-# Assuming the input array is sorted, bsearch/1 returns
-# the index of the target if the target is in the input array; and otherwise
-#  (-1 - ix), where ix is the insertion point that would leave the array sorted.
-# If the input is not sorted, bsearch will terminate but with irrelevant results.
-def bsearch($target):
-  if length == 0 then -1
-  elif length == 1 then
-     if $target == .[0] then 0 elif $target < .[0] then -1 else -2 end
-  else . as $in
-    # state variable: [start, end, answer]
-    # where start and end are the upper and lower offsets to use.
-    | [0, length-1, null]
-    | until( .[0] > .[1] ;
-             if .[2] != null then (.[1] = -1)               # i.e. break
-             else
-               ( ( (.[1] + .[0]) / 2 ) | floor ) as $mid
-               | $in[$mid] as $monkey
-               | if $monkey == $target  then (.[2] = $mid)   # success
-                 elif .[0] == .[1]     then (.[1] = -1)     # failure
-                 elif $monkey < $target then (.[0] = ($mid + 1))
-                 else (.[1] = ($mid - 1))
-                 end
-             end )
-    | if .[2] == null then          # compute the insertion point
-         if $in[ .[0] ] < $target then (-2 -.[0])
-         else (-1 -.[0])
-         end
-      else .[2]
-      end
-  end;
-
 # Apply f to composite entities recursively, and to atoms
 def walk(f):
   def w:

package/deps/jq/src/bytecode.h

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

package/deps/jq/src/compile.c

@@ -1,5 +1,4 @@
 #include <assert.h>
-#include <math.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -7,7 +6,7 @@
 #include "bytecode.h"
 #include "locfile.h"
 #include "jv_alloc.h"
-#include "linker.h"
+#include "util.h"
 
 /*
   The intermediate representation for jq filters is as a sequence of
@@ -129,7 +128,7 @@ block gen_location(location loc, struct locfile* l, block b) {
   return b;
 }
 
-block gen_noop() {
+block gen_noop(void) {
   block b = {0,0};
   return b;
 }
@@ -845,46 +844,26 @@ block gen_reduce(block source, block matcher, block init, block body) {
 }
 
 block gen_foreach(block source, block matcher, block init, block update, block extract) {
-  block output = gen_op_targetlater(JUMP);
   block state_var = gen_op_var_fresh(STOREV, "foreach");
-  block loop = BLOCK(gen_op_simple(DUPN),
-                     // get a value from the source expression:
-                     source,
-                     // destructure the value into variable(s) for all the code
-                     // in the body to see
-                     bind_alternation_matchers(matcher,
-                                  // load the loop state variable
-                                  BLOCK(gen_op_bound(LOADVN, state_var),
-                                        // generate updated state
-                                        update,
-                                        // save the updated state for value extraction
-                                        gen_op_simple(DUP),
-                                        // save new state
-                                        gen_op_bound(STOREV, state_var),
-                                        // extract an output...
-                                        extract,
-                                        // ...and output it by jumping
-                                        // past the BACKTRACK that comes
-                                        // right after the loop body,
-                                        // which in turn is there
-                                        // because...
-                                        //
-                                        // (Incidentally, extract can also
-                                        // backtrack, e.g., if it calls
-                                        // empty, in which case we don't
-                                        // get here.)
-                                        output)));
-  block foreach = BLOCK(gen_op_simple(DUP),
-                        init,
-                        state_var,
-                        gen_op_target(FORK, loop),
-                        loop,
-                        // ...at this point `foreach`'s original input
-                        // will be on top of the stack, and we don't
-                        // want to output it, so we backtrack.
-                        gen_op_simple(BACKTRACK));
-  inst_set_target(output, foreach); // make that JUMP go bast the BACKTRACK at the end of the loop
-  return foreach;
+  return BLOCK(gen_op_simple(DUP),
+               init,
+               state_var,
+               gen_op_simple(DUP),
+               // get a value from the source expression:
+               source,
+               // destructure the value into variable(s) for all the code
+               // in the body to see
+               bind_alternation_matchers(matcher,
+                            // load the loop state variable
+                            BLOCK(gen_op_bound(LOADVN, state_var),
+                                  // generate updated state
+                                  update,
+                                  // save the updated state for value extraction
+                                  gen_op_simple(DUP),
+                                  // save new state
+                                  gen_op_bound(STOREV, state_var),
+                                  // extract an output...
+                                  extract)));
 }
 
 block gen_definedor(block a, block b) {
@@ -1374,7 +1353,7 @@ int block_compile(block b, struct bytecode** out, struct locfile* lf, jv args) {
   bc->globals = jv_mem_alloc(sizeof(struct symbol_table));
   int ncfunc = count_cfunctions(b);
   bc->globals->ncfunctions = 0;
-  bc->globals->cfunctions = jv_mem_calloc(ncfunc, sizeof(struct cfunction));
+  bc->globals->cfunctions = jv_mem_calloc(MAX(ncfunc, 1), sizeof(struct cfunction));
   bc->globals->cfunc_names = jv_array();
   bc->debuginfo = jv_object_set(jv_object(), jv_string("name"), jv_null());
   jv env = jv_invalid();

package/deps/jq/src/compile.h

@@ -16,7 +16,7 @@ typedef struct block {
 
 block gen_location(location, struct locfile*, block);
 
-block gen_noop();
+block gen_noop(void);
 int block_is_noop(block b);
 block gen_op_simple(opcode op);
 block gen_error(jv constant);

package/deps/jq/src/execute.c

@@ -318,7 +318,9 @@ 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();
@@ -342,8 +344,6 @@ static void set_error(jq_state *jq, jv value) {
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
 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);
@@ -796,8 +796,10 @@ jv jq_next(jq_state *jq, unsigned int timeout_sec) {
       }
 
       if (!keep_going || raising) {
-        if (keep_going)
+        if (keep_going) {
+          jv_free(key);
           jv_free(value);
+        }
         jv_free(container);
         goto do_backtrack;
       } else if (is_last) {
@@ -920,34 +922,27 @@ jv jq_next(jq_state *jq, unsigned int timeout_sec) {
 
     case CALL_BUILTIN: {
       int nargs = *pc++;
-      jv top = stack_pop(jq);
-      jv* in = cfunc_input;
-      in[0] = top;
-      for (int i = 1; i < nargs; i++) {
-        in[i] = stack_pop(jq);
-      }
       struct cfunction* function = &frame_current(jq)->bc->globals->cfunctions[*pc++];
+      jv in[MAX_CFUNCTION_ARGS];
+      for (int i = 0; i < nargs; ++i)
+        in[i] = stack_pop(jq);
+
+      jv top;
       switch (function->nargs) {
-      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"));
+      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");
       }
 
-      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`
+      if (!jv_is_valid(top)) {
+        if (jv_invalid_has_msg(jv_copy(top)))
+          set_error(jq, top);
         goto do_backtrack;
       }
+
+      stack_push(jq, top);
       break;
     }
 

package/deps/jq/src/jq_test.c

@@ -8,10 +8,11 @@
 #include "jv.h"
 #include "jq.h"
 
-static void jv_test();
+static void jv_test(void);
 static void run_jq_tests(jv, int, FILE *, int, int);
+static void run_jq_start_state_tests(void);
 #ifdef HAVE_PTHREAD
-static void run_jq_pthread_tests();
+static void run_jq_pthread_tests(void);
 #endif
 
 #define TIMEOUT_SEC 5
@@ -39,6 +40,7 @@ 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
@@ -70,13 +72,11 @@ static void test_err_cb(void *data, jv e) {
     e = jv_dump_string(e, JV_PRINT_INVALID);
   if (!strncmp(jv_string_value(e), "jq: error", sizeof("jq: error") - 1))
     snprintf(err_data->buf, sizeof(err_data->buf), "%s", jv_string_value(e));
-  if (strchr(err_data->buf, '\n'))
-    *(strchr(err_data->buf, '\n')) = '\0';
   jv_free(e);
 }
 
 static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int take) {
-  char prog[4096];
+  char prog[4096] = {0};
   char buf[4096];
   struct err_data err_msg;
   int tests = 0, passed = 0, invalid = 0;
@@ -108,18 +108,7 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
 
     if (skip > 0) {
       skip--;
-
-      // skip past test data
-      while (fgets(buf, sizeof(buf), testdata)) {
-        lineno++;
-        if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
-          break;
-      }
-
-      must_fail = 0;
-      check_msg = 0;
-
-      continue;
+      goto next;
     } else if (skip == 0) {
       printf("Skipped %d tests\n", tests_to_skip);
       skip = -1;
@@ -139,37 +128,40 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
 
     if (must_fail) {
       jq_set_error_cb(jq, NULL, NULL);
-      if (!fgets(buf, sizeof(buf), testdata)) { invalid++; break; }
-      lineno++;
-      if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = 0;
       if (compiled) {
-        printf("*** Test program compiled that should not have at line %u: %s\n", lineno, prog);
-        must_fail = 0;
-        check_msg = 0;
-        invalid++;
-        continue;
+        printf("*** Test program compiled successfully, but should fail at line number %u: %s\n", lineno, prog);
+        goto fail;
       }
-      if (check_msg && strcmp(buf, err_msg.buf) != 0) {
-        printf("*** Erroneous test program failed with wrong message (%s) at line %u: %s\n", err_msg.buf, lineno, prog);
+      char *err_buf = err_msg.buf;
+      while (fgets(buf, sizeof(buf), testdata)) {
+        lineno++;
+        if (skipline(buf)) break;
+        if (check_msg) {
+          if (buf[strlen(buf)-1] == '\n') buf[strlen(buf)-1] = '\0';
+          if (strncmp(buf, err_buf, strlen(buf)) != 0) {
+            if (strchr(err_buf, '\n')) *strchr(err_buf, '\n') = '\0';
+            printf("*** Erroneous program failed with '%s', but expected '%s' at line number %u: %s\n", err_buf, buf, lineno, prog);
+            goto fail;
+          }
+          err_buf += strlen(buf);
+          if (*err_buf == '\n') err_buf++;
+        }
+      }
+      if (check_msg && *err_buf != '\0') {
+        if (strchr(err_buf, '\n')) *strchr(err_buf, '\n') = '\0';
+        printf("*** Erroneous program failed with extra message '%s' at line %u: %s\n", err_buf, lineno, prog);
         invalid++;
-      } else {
-        passed++;
+        pass = 0;
       }
       must_fail = 0;
       check_msg = 0;
+      passed += pass;
       continue;
     }
 
     if (!compiled) {
       printf("*** Test program failed to compile at line %u: %s\n", lineno, prog);
-      invalid++;
-      // skip past test data
-      while (fgets(buf, sizeof(buf), testdata)) {
-        lineno++;
-        if (buf[0] == '\n' || (buf[0] == '\r' && buf[1] == '\n'))
-          break;
-      }
-      continue;
+      goto fail;
     }
     if (verbose) {
       printf("Disassembly:\n");
@@ -181,8 +173,7 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
     jv input = jv_parse(buf);
     if (!jv_is_valid(input)) {
       printf("*** Input is invalid on line %u: %s\n", lineno, buf);
-      invalid++;
-      continue;
+      goto fail;
     }
     jq_start(jq, input, verbose ? JQ_DEBUG_TRACE : 0);
 
@@ -192,8 +183,7 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
       jv expected = jv_parse(buf);
       if (!jv_is_valid(expected)) {
         printf("*** Expected result is invalid on line %u: %s\n", lineno, buf);
-        invalid++;
-        continue;
+        goto fail;
       }
       jv actual = jq_next(jq, TIMEOUT_SEC);
       if (!jv_is_valid(actual)) {
@@ -210,11 +200,13 @@ 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);
     }
@@ -224,12 +216,25 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int
         printf("*** Superfluous result: ");
         jv_dump(extra, 0);
         printf(" for test at line number %u, %s\n", lineno, prog);
+        invalid++;
         pass = 0;
       } else {
         jv_free(extra);
       }
     }
-    passed+=pass;
+    passed += pass;
+    continue;
+
+fail:
+    invalid++;
+
+next:
+    while (fgets(buf, sizeof(buf), testdata)) {
+      lineno++;
+      if (skipline(buf)) break;
+    }
+    must_fail = 0;
+    check_msg = 0;
   }
   jq_teardown(&jq);
 
@@ -251,6 +256,66 @@ 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, TIMEOUT_SEC);
+    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(void) {
+  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
@@ -303,7 +368,7 @@ static void *test_pthread_run(void *ptr) {
     return NULL;
 }
 
-static void run_jq_pthread_tests() {
+static void run_jq_pthread_tests(void) {
     pthread_t threads[NUMBER_OF_THREADS];
     struct test_pthread_data data[NUMBER_OF_THREADS];
     int createerror;
@@ -320,7 +385,11 @@ static void run_jq_pthread_tests() {
 
     // wait for all threads
     for(a = 0; a < NUMBER_OF_THREADS; ++a) {
+#ifdef __MVS__
+        if (threads[a].__ != 0) {
+#else
         if (threads[a] != 0) {
+#endif
             pthread_join(threads[a], NULL);
         }
     }
@@ -333,7 +402,7 @@ static void run_jq_pthread_tests() {
 #endif // HAVE_PTHREAD
 
 
-static void jv_test() {
+static void jv_test(void) {
   /// JSON parser regression tests
   {
     jv v = jv_parse("{\"a':\"12\"}");