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

package/deps/jq/src/execute.c

@@ -49,6 +49,8 @@ struct jq_state {
   void *input_cb_data;
   jq_msg_cb debug_cb;
   void *debug_cb_data;
+  jq_msg_cb stderr_cb;
+  void *stderr_cb_data;
 };
 
 struct closure {
@@ -292,7 +294,7 @@ uint16_t* stack_restore(jq_state *jq){
     assert(path_len >= 0);
     jq->path = jv_array_slice(jq->path, 0, path_len);
   } else {
-    assert(path_len == 0);
+    fork->path_len = 0;
   }
   jv_free(jq->value_at_path);
   jq->value_at_path = fork->value_at_path;
@@ -313,7 +315,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();
@@ -337,8 +341,6 @@ static void set_error(jq_state *jq, jv value) {
 #define ON_BACKTRACK(op) ((op)+NUM_OPCODES)
 
 jv jq_next(jq_state *jq) {
-  jv cfunc_input[MAX_CFUNCTION_ARGS];
-
   jv_nomem_handler(jq->nomem_handler, jq->nomem_handler_data);
 
   uint16_t* pc = stack_restore(jq);
@@ -346,6 +348,7 @@ jv jq_next(jq_state *jq) {
 
   int raising;
   int backtracking = !jq->initial_execution;
+
   jq->initial_execution = 0;
   assert(jv_get_kind(jq->error) == JV_KIND_NULL);
   while (1) {
@@ -402,6 +405,12 @@ jv jq_next(jq_state *jq) {
 
     case TOP: break;
 
+    case ERRORK: {
+      jv v = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++);
+      set_error(jq, jv_invalid_with_msg(v));
+      goto do_backtrack;
+    }
+
     case LOADK: {
       jv v = jv_array_get(jv_copy(frame_current(jq)->bc->constants), *pc++);
       assert(jv_is_valid(v));
@@ -509,21 +518,25 @@ jv jq_next(jq_state *jq) {
       uint16_t v = *pc++;
       jv* var = frame_local_var(jq, v, level);
       jv max = stack_pop(jq);
-      if (raising) goto do_backtrack;
+      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")));
         jv_free(max);
         goto do_backtrack;
-      } else if (jv_number_value(jv_copy(*var)) >= jv_number_value(jv_copy(max))) {
+      } else if (jv_number_value(*var) >= jv_number_value(max)) {
         /* finished iterating */
+        jv_free(max);
         goto do_backtrack;
       } else {
-        jv curr = jv_copy(*var);
+        jv curr = *var;
         *var = jv_number(jv_number_value(*var) + 1);
 
         struct stack_pos spos = stack_get_pos(jq);
-        stack_push(jq, jv_copy(max));
+        stack_push(jq, max);
         stack_save(jq, pc - 3, spos);
 
         stack_push(jq, curr);
@@ -538,8 +551,8 @@ jv jq_next(jq_state *jq) {
       jv* var = frame_local_var(jq, v, level);
       if (jq->debug_trace_enabled) {
         printf("V%d = ", v);
-        jv_dump(jv_copy(*var), 0);
-        printf(" (%d)\n", jv_get_refcnt(*var));
+        jv_dump(jv_copy(*var), JV_PRINT_REFCOUNT);
+        printf("\n");
       }
       jv_free(stack_pop(jq));
       stack_push(jq, jv_copy(*var));
@@ -553,17 +566,22 @@ jv jq_next(jq_state *jq) {
       jv* var = frame_local_var(jq, v, level);
       if (jq->debug_trace_enabled) {
         printf("V%d = ", v);
-        jv_dump(jv_copy(*var), 0);
-        printf(" (%d)\n", jv_get_refcnt(*var));
+        jv_dump(jv_copy(*var), JV_PRINT_REFCOUNT);
+        printf("\n");
       }
       jv_free(stack_popn(jq));
+
+      // This `stack_push()` invalidates the `var` reference, so
       stack_push(jq, *var);
+      // we have to re-resolve `var` before we can set it to null
+      var = frame_local_var(jq, v, level);
       *var = jv_null();
       break;
     }
 
     case STOREVN:
         stack_save(jq, pc - 1, stack_get_pos(jq));
+        JQ_FALLTHROUGH;
     case STOREV: {
       uint16_t level = *pc++;
       uint16_t v = *pc++;
@@ -723,7 +741,7 @@ jv jq_next(jq_state *jq) {
       }
       stack_push(jq, container);
       stack_push(jq, jv_number(-1));
-      // fallthrough
+      JQ_FALLTHROUGH;
     }
     case ON_BACKTRACK(EACH):
     case ON_BACKTRACK(EACH_OPT): {
@@ -763,8 +781,10 @@ jv jq_next(jq_state *jq) {
       }
 
       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) {
@@ -798,7 +818,59 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
-    case FORK_OPT:
+    case TRY_BEGIN:
+      stack_save(jq, pc - 1, stack_get_pos(jq));
+      pc++; // skip handler offset this time
+      break;
+
+    case TRY_END:
+      stack_save(jq, pc - 1, stack_get_pos(jq));
+      break;
+
+    case ON_BACKTRACK(TRY_BEGIN): {
+      if (!raising) {
+        /*
+         * `try EXP ...` -- EXP backtracked (e.g., EXP was `empty`), so we
+         * backtrack more:
+         */
+        jv_free(stack_pop(jq));
+        goto do_backtrack;
+      }
+
+      /*
+       * Else `(try EXP ... ) | EXP2` raised an error.
+       *
+       * If the error was wrapped in another error, then that means EXP2 raised
+       * the error.  We unwrap it and re-raise it as it wasn't raised by EXP.
+       *
+       * See commentary in gen_try().
+       */
+      jv e = jv_invalid_get_msg(jv_copy(jq->error));
+      if (!jv_is_valid(e) && jv_invalid_has_msg(jv_copy(e))) {
+        set_error(jq, e);
+        goto do_backtrack;
+      }
+      jv_free(e);
+
+      /*
+       * Else we caught an error containing a non-error value, so we jump to
+       * the handler.
+       *
+       * See commentary in gen_try().
+       */
+      uint16_t offset = *pc++;
+      jv_free(stack_pop(jq)); // free the input
+      stack_push(jq, jv_invalid_get_msg(jq->error));  // push the error's message
+      jq->error = jv_null();
+      pc += offset;
+      break;
+    }
+    case ON_BACKTRACK(TRY_END):
+      // Wrap the error so the matching TRY_BEGIN doesn't catch it
+      if (raising)
+        set_error(jq, jv_invalid_with_msg(jv_copy(jq->error)));
+      goto do_backtrack;
+
     case DESTRUCTURE_ALT:
     case FORK: {
       stack_save(jq, pc - 1, stack_get_pos(jq));
@@ -806,7 +878,6 @@ jv jq_next(jq_state *jq) {
       break;
     }
 
-    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
@@ -836,39 +907,27 @@ jv jq_next(jq_state *jq) {
 
     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++];
-      typedef jv (*func_1)(jq_state*,jv);
-      typedef jv (*func_2)(jq_state*,jv,jv);
-      typedef jv (*func_3)(jq_state*,jv,jv,jv);
-      typedef jv (*func_4)(jq_state*,jv,jv,jv,jv);
-      typedef jv (*func_5)(jq_state*,jv,jv,jv,jv,jv);
+      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 = ((func_1)function->fptr)(jq, in[0]); break;
-      case 2: top = ((func_2)function->fptr)(jq, in[0], in[1]); break;
-      case 3: top = ((func_3)function->fptr)(jq, in[0], in[1], in[2]); break;
-      case 4: top = ((func_4)function->fptr)(jq, in[0], in[1], in[2], in[3]); break;
-      case 5: top = ((func_5)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;
     }
 
@@ -1004,12 +1063,24 @@ jq_state *jq_init(void) {
   jq->exit_code = jv_invalid();
   jq->error_message = jv_invalid();
 
+  jq->input_cb = NULL;
+  jq->input_cb_data = NULL;
+
+  jq->debug_cb = NULL;
+  jq->debug_cb_data = NULL;
+
+  jq->stderr_cb = NULL;
+  jq->stderr_cb_data = NULL;
+
   jq->err_cb = default_err_cb;
   jq->err_cb_data = stderr;
 
   jq->attrs = jv_object();
   jq->path = jv_null();
   jq->value_at_path = jv_null();
+
+  jq->nomem_handler = NULL;
+  jq->nomem_handler_data = NULL;
   return jq;
 }
 
@@ -1166,7 +1237,7 @@ int jq_compile_args(jq_state *jq, const char* str, jv args) {
   if (nerrors == 0) {
     nerrors = builtins_bind(jq, &program);
     if (nerrors == 0) {
-      nerrors = block_compile(program, &jq->bc, locations, args = args2obj(args));
+      nerrors = block_compile(program, &jq->bc, locations, args2obj(args));
     }
   } else
     jv_free(args);
@@ -1191,7 +1262,8 @@ jv jq_get_prog_origin(jq_state *jq) {
 }
 
 jv jq_get_lib_dirs(jq_state *jq) {
-  return jq_get_attr(jq, jv_string("JQ_LIBRARY_PATH"));
+  jv lib_dirs = jq_get_attr(jq, jv_string("JQ_LIBRARY_PATH"));
+  return jv_is_valid(lib_dirs) ? lib_dirs : jv_array();
 }
 
 void jq_set_attrs(jq_state *jq, jv attrs) {
@@ -1232,6 +1304,16 @@ void jq_get_debug_cb(jq_state *jq, jq_msg_cb *cb, void **data) {
   *data = jq->debug_cb_data;
 }
 
+void jq_set_stderr_cb(jq_state *jq, jq_msg_cb cb, void *data) {
+  jq->stderr_cb = cb;
+  jq->stderr_cb_data = data;
+}
+
+void jq_get_stderr_cb(jq_state *jq, jq_msg_cb *cb, void **data) {
+  *cb = jq->stderr_cb;
+  *data = jq->stderr_cb_data;
+}
+
 void
 jq_halt(jq_state *jq, jv exit_code, jv error_message)
 {

package/deps/jq/src/inject_errors.c

@@ -1,5 +1,3 @@
-
-#define _GNU_SOURCE /* for RTLD_NEXT */
 #include <assert.h>
 #include <dlfcn.h>
 #include <errno.h>

package/deps/jq/src/jq.h

@@ -4,6 +4,10 @@
 #include <stdio.h>
 #include "jv.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 enum {
   JQ_DEBUG_TRACE = 1,
   JQ_DEBUG_TRACE_DETAIL = 2,
@@ -34,9 +38,10 @@ 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 **);
-
 void jq_set_debug_cb(jq_state *, jq_msg_cb, void *);
 void jq_get_debug_cb(jq_state *, jq_msg_cb *, void **);
+void jq_set_stderr_cb(jq_state *, jq_msg_cb, void *);
+void jq_get_stderr_cb(jq_state *, jq_msg_cb *, void **);
 
 void jq_set_attrs(jq_state *, jv);
 jv jq_get_attrs(jq_state *);
@@ -68,4 +73,8 @@ jv jq_util_input_get_current_line(jq_state*);
 
 int jq_set_colors(const char *);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* !JQ_H */

package/deps/jq/src/jq_test.c

@@ -2,24 +2,46 @@
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
+#ifdef HAVE_PTHREAD
+#include <pthread.h>
+#endif
 #include "jv.h"
 #include "jq.h"
 
 static void jv_test();
-static void run_jq_tests(jv, int, FILE *);
-
+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
 
 int jq_testsuite(jv libdirs, int verbose, int argc, char* argv[]) {
   FILE *testdata = stdin;
+  int skip = -1;
+  int take = -1;
   jv_test();
   if (argc > 0) {
-    testdata = fopen(argv[0], "r");
-    if (!testdata) {
-      perror("fopen");
-      exit(1);
+    for(int i = 0; i < argc; i++) {
+      if (!strcmp(argv[i], "--skip")) {
+        skip = atoi(argv[i+1]);
+        i++;
+      } else if (!strcmp(argv[i], "--take")) {
+        take = atoi(argv[i+1]);
+        i++;
+      } else {
+        testdata = fopen(argv[i], "r");
+        if (!testdata) {
+          perror("fopen");
+          exit(1);
+        }
+      }
     }
   }
-  run_jq_tests(libdirs, verbose, testdata);
+  run_jq_tests(libdirs, verbose, testdata, skip, take);
+  run_jq_start_state_tests();
+#ifdef HAVE_PTHREAD
+  run_jq_pthread_tests();
+#endif
   return 0;
 }
 
@@ -53,8 +75,8 @@ static void test_err_cb(void *data, jv e) {
   jv_free(e);
 }
 
-static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
-  char prog[4096];
+static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata, int skip, int take) {
+  char prog[4096] = {0};
   char buf[4096];
   struct err_data err_msg;
   int tests = 0, passed = 0, invalid = 0;
@@ -63,6 +85,9 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
   int check_msg = 0;
   jq_state *jq = NULL;
 
+  int tests_to_skip = skip > 0 ? skip : 0;
+  int tests_to_take = take;
+
   jq = jq_init();
   assert(jq);
   if (jv_get_kind(lib_dirs) == JV_KIND_NULL)
@@ -80,9 +105,36 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
       continue;
     }
     if (prog[strlen(prog)-1] == '\n') prog[strlen(prog)-1] = 0;
-    printf("Testing '%s' at line number %u\n", prog, lineno);
+
+    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;
+    } else if (skip == 0) {
+      printf("Skipped %d tests\n", tests_to_skip);
+      skip = -1;
+    }
+
+    if (take > 0) {
+      take--;
+    } else if (take == 0) {
+      printf("Hit the number of tests limit (%d), breaking\n", tests_to_take);
+      break;
+    }
+
     int pass = 1;
     tests++;
+    printf("Test #%d: '%s' at line number %u\n", tests + tests_to_skip, prog, lineno);
     int compiled = jq_compile(jq, prog);
 
     if (must_fail) {
@@ -145,6 +197,7 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
       }
       jv actual = jq_next(jq);
       if (!jv_is_valid(actual)) {
+        jv_free(expected);
         jv_free(actual);
         printf("*** Insufficient results for test at line number %u: %s\n", lineno, prog);
         pass = 0;
@@ -157,11 +210,13 @@ 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;
       }
+#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);
     }
@@ -179,11 +234,167 @@ static void run_jq_tests(jv lib_dirs, int verbose, FILE *testdata) {
     passed+=pass;
   }
   jq_teardown(&jq);
-  printf("%d of %d tests passed (%d malformed)\n", passed,tests,invalid);
+
+  int total_skipped = tests_to_skip;
+
+  if (skip > 0) {
+    total_skipped = tests_to_skip - skip;
+  }
+
+  printf("%d of %d tests passed (%d malformed, %d skipped)\n",
+    passed, tests, invalid, total_skipped);
+
+  if (skip > 0) {
+    printf("WARN: skipped past the end of file, exiting with status 2\n");
+    exit(2);
+  }
+
   if (passed != tests) exit(1);
 }
 
 
+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
+struct test_pthread_data {
+    int result;
+};
+
+static int test_pthread_jq_parse(jq_state *jq, struct jv_parser *parser)
+{
+    int rv = 0;
+    jv value;
+
+    value = jv_parser_next(parser);
+    while (jv_is_valid(value)) {
+        jq_start(jq, value, 0);
+        jv result = jq_next(jq);
+
+        while (jv_is_valid(result)) {
+            jv_free(result);
+            result = jq_next(jq);
+        }
+        jv_free(result);
+        value = jv_parser_next(parser);
+    }
+    jv_free(value);
+    return rv;
+}
+
+static void *test_pthread_run(void *ptr) {
+    int rv;
+    jq_state *jq;
+    const char *prg = ".data";
+    const char *buf = "{ \"data\": 1 }";
+    struct test_pthread_data *data = ptr;
+
+    jq = jq_init();
+    if (jq_compile(jq, prg) == 0) {
+        jq_teardown(&jq);
+        return NULL;
+    }
+
+    struct jv_parser *parser = jv_parser_new(0);
+    jv_parser_set_buf(parser, buf, strlen(buf), 0);
+    rv = test_pthread_jq_parse(jq, parser);
+
+    data->result = rv;
+
+    jv_parser_free(parser);
+    jq_teardown(&jq);
+    return NULL;
+}
+
+static void run_jq_pthread_tests() {
+    pthread_t threads[NUMBER_OF_THREADS];
+    struct test_pthread_data data[NUMBER_OF_THREADS];
+    int createerror;
+    int a;
+
+    memset(&threads, 0, sizeof(threads));
+    memset(&data, 0, sizeof(data));
+
+    // Create all threads
+    for (a = 0; a < NUMBER_OF_THREADS; ++a) {
+        createerror = pthread_create(&threads[a], NULL, test_pthread_run, &data[a]);
+        assert(createerror == 0);
+    }
+
+    // wait for all threads
+    for(a = 0; a < NUMBER_OF_THREADS; ++a) {
+        if (threads[a] != 0) {
+            pthread_join(threads[a], NULL);
+        }
+    }
+
+    // check results
+    for(a = 0; a < NUMBER_OF_THREADS; ++a) {
+        assert(data[a].result == 0);
+    }
+}
+#endif // HAVE_PTHREAD
+
+
 static void jv_test() {
   /// JSON parser regression tests
   {