@port-labs/jq-node-bindings 0.0.1

package/deps/jq/m4/ax_prog_bison_version.m4

@@ -0,0 +1,68 @@
+# ===========================================================================
+#   Modified from
+#   http://www.gnu.org/software/autoconf-archive/ax_prog_perl_version.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PROG_BISON_VERSION([VERSION],[ACTION-IF-TRUE],[ACTION-IF-FALSE])
+#
+# DESCRIPTION
+#
+#   Makes sure that bison supports the version indicated. If true the shell
+#   commands in ACTION-IF-TRUE are executed. If not the shell commands in
+#   ACTION-IF-FALSE are run. Note if $PERL is not set the macro will fail.
+#
+#   Example:
+#
+#     AC_PROG_YACC
+#     AX_PROG_BISON_VERSION([3.0.0],[ ... ],[ ... ])
+#
+#   This will check to make sure that the bison you have supports at least
+#   version 3.0.0.
+#
+#   NOTE: This macro uses the $YACC variable to perform the check.
+#   AX_WITH_YACC can be used to set that variable prior to running this
+#   macro. The $BISON_VERSION variable will be set with the detected
+#   version.
+#
+# LICENSE
+#
+#   Copyright (c) 2009 Francesco Salvestrini <salvestrini@users.sourceforge.net>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 12
+
+AC_DEFUN([AX_PROG_BISON_VERSION],[
+    AC_REQUIRE([AC_PROG_SED])
+    AC_REQUIRE([AC_PROG_GREP])
+
+    AS_IF([test -n "$YACC"],[
+        ax_bison_version="$1"
+
+        AC_MSG_CHECKING([for bison version])
+        changequote(<<,>>)
+        bison_version=`$YACC --version 2>&1 \
+          | $GREP bison \
+          | $SED -e 's/^[^0-9]*//' -e 's/[^0-9]*$//'`
+        changequote([,])
+        AC_MSG_RESULT($bison_version)
+
+	AC_SUBST([BISON_VERSION],[$bison_version])
+
+        AX_COMPARE_VERSION([$ax_bison_version],[le],[$bison_version],[
+	    :
+            $2
+        ],[
+	    :
+            $3
+        ])
+    ],[
+        AC_MSG_WARN([could not find bison])
+        $3
+    ])
+])

package/deps/jq/main.c

@@ -0,0 +1,566 @@
+#include <assert.h>
+#include <ctype.h>
+#include <errno.h>
+#include <libgen.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#ifdef WIN32
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#include <processenv.h>
+#include <shellapi.h>
+#include <wchar.h>
+#include <wtypes.h>
+#endif
+
+#include "compile.h"
+#include "jv.h"
+#include "jq.h"
+#include "jv_alloc.h"
+#include "util.h"
+#include "version.h"
+
+int jq_testsuite(jv lib_dirs, int verbose, int argc, char* argv[]);
+
+static const char* progname;
+
+/*
+ * For a longer help message we could use a better option parsing
+ * strategy, one that lets stack options.
+ */
+static void usage(int code) {
+  FILE *f = stderr;
+
+  if (code == 0)
+    f = stdout;
+
+  int ret = fprintf(f,
+    "jq - commandline JSON processor [version %s]\n"
+    "Usage: %s [options] <jq filter> [file...]\n\n"
+    "\tjq is a tool for processing JSON inputs, applying the\n"
+    "\tgiven filter to its JSON text inputs and producing the\n"
+    "\tfilter's results as JSON on standard output.\n"
+    "\tThe simplest filter is ., which is the identity filter,\n"
+    "\tcopying jq's input to its output unmodified (except for\n"
+    "\tformatting).\n"
+    "\tFor more advanced filters see the jq(1) manpage (\"man jq\")\n"
+    "\tand/or https://stedolan.github.io/jq\n\n"
+    "\tSome of the options include:\n"
+    "\t -c\t\tcompact instead of pretty-printed output;\n"
+    "\t -n\t\tuse `null` as the single input value;\n"
+    "\t -e\t\tset the exit status code based on the output;\n"
+    "\t -s\t\tread (slurp) all inputs into an array; apply filter to it;\n"
+    "\t -r\t\toutput raw strings, not JSON texts;\n"
+    "\t -R\t\tread raw strings, not JSON texts;\n"
+    "\t -C\t\tcolorize JSON;\n"
+    "\t -M\t\tmonochrome (don't colorize JSON);\n"
+    "\t -S\t\tsort keys of objects on output;\n"
+    "\t --tab\tuse tabs for indentation;\n"
+    "\t --arg a v\tset variable $a to value <v>;\n"
+    "\t --argjson a v\tset variable $a to JSON value <v>;\n"
+    "\t --slurpfile a f\tset variable $a to an array of JSON texts read from <f>;\n"
+    "\tSee the manpage for more options.\n", JQ_VERSION, progname);
+  exit((ret < 0 && code == 0) ? 2 : code);
+}
+
+static void die() {
+  fprintf(stderr, "Use %s --help for help with command-line options,\n", progname);
+  fprintf(stderr, "or see the jq manpage, or online docs  at https://stedolan.github.io/jq\n");
+  exit(2);
+}
+
+
+
+
+static int isoptish(const char* text) {
+  return text[0] == '-' && (text[1] == '-' || isalpha(text[1]));
+}
+
+static int isoption(const char* text, char shortopt, const char* longopt, size_t *short_opts) {
+  if (text[0] != '-' || text[1] == '-')
+    *short_opts = 0;
+  if (text[0] != '-') return 0;
+
+  // check long option
+  if (text[1] == '-' && !strcmp(text+2, longopt)) return 1;
+  else if (text[1] == '-') return 0;
+
+  // must be short option; check it and...
+  if (!shortopt) return 0;
+  if (strchr(text, shortopt) != NULL) {
+    (*short_opts)++; // ...count it (for option stacking)
+    return 1;
+  }
+  return 0;
+}
+
+enum {
+  SLURP                 = 1,
+  RAW_INPUT             = 2,
+  PROVIDE_NULL          = 4,
+  RAW_OUTPUT            = 8,
+  ASCII_OUTPUT          = 32,
+  COLOUR_OUTPUT         = 64,
+  NO_COLOUR_OUTPUT      = 128,
+  SORTED_OUTPUT         = 256,
+  FROM_FILE             = 512,
+  RAW_NO_LF             = 1024,
+  UNBUFFERED_OUTPUT     = 2048,
+  EXIT_STATUS           = 4096,
+  SEQ                   = 8192,
+  RUN_TESTS             = 16384,
+  /* debugging only */
+  DUMP_DISASM           = 32768,
+};
+static int options = 0;
+
+static int process(jq_state *jq, jv value, int flags, int dumpopts) {
+  int ret = 14; // No valid results && -e -> exit(4)
+  jq_start(jq, value, flags);
+  jv result;
+  while (jv_is_valid(result = jq_next(jq))) {
+    if ((options & RAW_OUTPUT) && jv_get_kind(result) == JV_KIND_STRING) {
+      fwrite(jv_string_value(result), 1, jv_string_length_bytes(jv_copy(result)), stdout);
+      ret = 0;
+      jv_free(result);
+    } else {
+      if (jv_get_kind(result) == JV_KIND_FALSE || jv_get_kind(result) == JV_KIND_NULL)
+        ret = 11;
+      else
+        ret = 0;
+      if (options & SEQ)
+        priv_fwrite("\036", 1, stdout, dumpopts & JV_PRINT_ISATTY);
+      jv_dump(result, dumpopts);
+    }
+    if (!(options & RAW_NO_LF))
+      priv_fwrite("\n", 1, stdout, dumpopts & JV_PRINT_ISATTY);
+    if (options & UNBUFFERED_OUTPUT)
+      fflush(stdout);
+  }
+  if (jv_invalid_has_msg(jv_copy(result))) {
+    // Uncaught jq exception
+    jv msg = jv_invalid_get_msg(jv_copy(result));
+    jv input_pos = jq_util_input_get_position(jq);
+    if (jv_get_kind(msg) == JV_KIND_STRING) {
+      fprintf(stderr, "jq: error (at %s): %s\n",
+              jv_string_value(input_pos), jv_string_value(msg));
+    } else {
+      msg = jv_dump_string(msg, 0);
+      fprintf(stderr, "jq: error (at %s) (not a string): %s\n",
+              jv_string_value(input_pos), jv_string_value(msg));
+    }
+    ret = 5;
+    jv_free(input_pos);
+    jv_free(msg);
+  }
+  jv_free(result);
+  return ret;
+}
+
+static void debug_cb(void *data, jv input) {
+  int dumpopts = *(int *)data;
+  jv_dumpf(JV_ARRAY(jv_string("DEBUG:"), input), stderr, dumpopts & ~(JV_PRINT_PRETTY));
+  fprintf(stderr, "\n");
+}
+
+int main(int argc, char* argv[]) {
+  jq_state *jq = NULL;
+  int ret = 0;
+  int compiled = 0;
+  int parser_flags = 0;
+  int nfiles = 0;
+  int badwrite;
+  jv program_arguments = jv_array();
+
+#ifdef WIN32
+  SetConsoleOutputCP(CP_UTF8);
+  fflush(stdout);
+  fflush(stderr);
+  _setmode(fileno(stdout), _O_TEXT | _O_U8TEXT);
+  _setmode(fileno(stderr), _O_TEXT | _O_U8TEXT);
+  int wargc;
+  wchar_t **wargv = CommandLineToArgvW(GetCommandLineW(), &wargc);
+  assert(wargc == argc);
+  size_t arg_sz;
+  for (int i = 0; i < argc; i++) {
+    argv[i] = alloca((arg_sz = WideCharToMultiByte(CP_UTF8,
+                                                   0,
+                                                   wargv[i],
+                                                   -1, 0, 0, 0, 0)));
+    WideCharToMultiByte(CP_UTF8, 0, wargv[i], -1, argv[i], arg_sz, 0, 0);
+  }
+#endif
+
+  if (argc) progname = argv[0];
+
+  jq = jq_init();
+  if (jq == NULL) {
+    perror("malloc");
+    ret = 2;
+    goto out;
+  }
+
+  int dumpopts = JV_PRINT_INDENT_FLAGS(2);
+  const char* program = 0;
+
+  jq_util_input_state *input_state = jq_util_input_init(NULL, NULL); // XXX add err_cb
+
+  int further_args_are_files = 0;
+  int jq_flags = 0;
+  size_t short_opts = 0;
+  jv lib_search_paths = jv_null();
+  for (int i=1; i<argc; i++, short_opts = 0) {
+    if (further_args_are_files) {
+      jq_util_input_add_input(input_state, argv[i]);
+      nfiles++;
+    } else if (!strcmp(argv[i], "--")) {
+      if (!program) usage(2);
+      further_args_are_files = 1;
+    } else if (!isoptish(argv[i])) {
+      if (program) {
+        jq_util_input_add_input(input_state, argv[i]);
+        nfiles++;
+      } else {
+        program = argv[i];
+      }
+    } else {
+      if (argv[i][1] == 'L') {
+        if (jv_get_kind(lib_search_paths) == JV_KIND_NULL)
+          lib_search_paths = jv_array();
+        if (argv[i][2] != 0) { // -Lname (faster check than strlen)
+            lib_search_paths = jv_array_append(lib_search_paths, jq_realpath(jv_string(argv[i]+2)));
+        } else if (i >= argc - 1) {
+          fprintf(stderr, "-L takes a parameter: (e.g. -L /search/path or -L/search/path)\n");
+          die();
+        } else {
+          lib_search_paths = jv_array_append(lib_search_paths, jq_realpath(jv_string(argv[i+1])));
+          i++;
+        }
+        continue;
+      }
+
+      if (isoption(argv[i], 's', "slurp", &short_opts)) {
+        options |= SLURP;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'r', "raw-output", &short_opts)) {
+        options |= RAW_OUTPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'c', "compact-output", &short_opts)) {
+        dumpopts &= ~(JV_PRINT_TAB | JV_PRINT_INDENT_FLAGS(7));
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'C', "color-output", &short_opts)) {
+        options |= COLOUR_OUTPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'M', "monochrome-output", &short_opts)) {
+        options |= NO_COLOUR_OUTPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'a', "ascii-output", &short_opts)) {
+        options |= ASCII_OUTPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "unbuffered", &short_opts)) {
+        options |= UNBUFFERED_OUTPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'S', "sort-keys", &short_opts)) {
+        options |= SORTED_OUTPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'R', "raw-input", &short_opts)) {
+        options |= RAW_INPUT;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'n', "null-input", &short_opts)) {
+        options |= PROVIDE_NULL;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'f', "from-file", &short_opts)) {
+        options |= FROM_FILE;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'j', "join-output", &short_opts)) {
+        options |= RAW_OUTPUT | RAW_NO_LF;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "tab", &short_opts)) {
+        dumpopts &= ~JV_PRINT_INDENT_FLAGS(7);
+        dumpopts |= JV_PRINT_TAB | JV_PRINT_PRETTY;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "indent", &short_opts)) {
+        if (i >= argc - 1) {
+          fprintf(stderr, "%s: --indent takes one parameter\n", progname);
+          die();
+        }
+        dumpopts &= ~(JV_PRINT_TAB | JV_PRINT_INDENT_FLAGS(7));
+        int indent = atoi(argv[i+1]);
+        if (indent < -1 || indent > 7) {
+          fprintf(stderr, "%s: --indent takes a number between -1 and 7\n", progname);
+          die();
+        }
+        dumpopts |= JV_PRINT_INDENT_FLAGS(indent);
+        i++;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "seq", &short_opts)) {
+        options |= SEQ;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "stream", &short_opts)) {
+        parser_flags |= JV_PARSE_STREAMING;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "stream-errors", &short_opts)) {
+        parser_flags |= JV_PARSE_STREAM_ERRORS;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'e', "exit-status", &short_opts)) {
+        options |= EXIT_STATUS;
+        if (!short_opts) continue;
+      }
+      // FIXME: For --arg* we should check that the varname is acceptable
+      if (isoption(argv[i], 0, "arg", &short_opts)) {
+        if (i >= argc - 2) {
+          fprintf(stderr, "%s: --arg takes two parameters (e.g. --arg varname value)\n", progname);
+          die();
+        }
+        jv arg = jv_object();
+        arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
+        arg = jv_object_set(arg, jv_string("value"), jv_string(argv[i+2]));
+        program_arguments = jv_array_append(program_arguments, arg);
+        i += 2; // skip the next two arguments
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "argjson", &short_opts)) {
+        if (i >= argc - 2) {
+          fprintf(stderr, "%s: --argjson takes two parameters (e.g. --argjson varname text)\n", progname);
+          die();
+        }
+        jv v = jv_parse(argv[i+2]);
+        if (!jv_is_valid(v)) {
+          fprintf(stderr, "%s: invalid JSON text passed to --argjson\n", progname);
+          die();
+        }
+        jv arg = jv_object();
+        arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
+        arg = jv_object_set(arg, jv_string("value"), v);
+        program_arguments = jv_array_append(program_arguments, arg);
+        i += 2; // skip the next two arguments
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 0, "argfile", &short_opts) ||
+          isoption(argv[i], 0, "slurpfile", &short_opts)) {
+        const char *which;
+        if (isoption(argv[i], 0, "argfile", &short_opts))
+          which = "argfile";
+        else
+          which = "slurpfile";
+        if (i >= argc - 2) {
+          fprintf(stderr, "%s: --%s takes two parameters (e.g. --%s varname filename)\n", progname, which, which);
+          die();
+        }
+        jv arg = jv_object();
+        arg = jv_object_set(arg, jv_string("name"), jv_string(argv[i+1]));
+        jv data = jv_load_file(argv[i+2], 0);
+        if (!jv_is_valid(data)) {
+          data = jv_invalid_get_msg(data);
+          fprintf(stderr, "%s: Bad JSON in --%s %s %s: %s\n", progname, which,
+                  argv[i+1], argv[i+2], jv_string_value(data));
+          jv_free(data);
+          jv_free(arg);
+          ret = 2;
+          goto out;
+        }
+        if (isoption(argv[i], 0, "argfile", &short_opts) &&
+            jv_get_kind(data) == JV_KIND_ARRAY && jv_array_length(jv_copy(data)) == 1)
+            data = jv_array_get(data, 0);
+        arg = jv_object_set(arg, jv_string("value"), data);
+        program_arguments = jv_array_append(program_arguments, arg);
+        i += 2; // skip the next two arguments
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i],  0,  "debug-dump-disasm", &short_opts)) {
+        options |= DUMP_DISASM;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i],  0,  "debug-trace", &short_opts)) {
+        jq_flags |= JQ_DEBUG_TRACE;
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'h', "help", &short_opts)) {
+        usage(0);
+        if (!short_opts) continue;
+      }
+      if (isoption(argv[i], 'V', "version", &short_opts)) {
+        printf("jq-%s\n", JQ_VERSION);
+        ret = 0;
+        goto out;
+      }
+      if (isoption(argv[i], 0, "run-tests", &short_opts)) {
+        i++;
+        // XXX Pass program_arguments, even a whole jq_state *, through;
+        // could be useful for testing
+        ret = jq_testsuite(lib_search_paths,
+                           (options & DUMP_DISASM) || (jq_flags & JQ_DEBUG_TRACE),
+                           argc - i, argv + i);
+        goto out;
+      }
+
+      // check for unknown options... if this argument was a short option
+      if (strlen(argv[i]) != short_opts + 1) {
+        fprintf(stderr, "%s: Unknown option %s\n", progname, argv[i]);
+        die();
+      }
+    }
+  }
+
+  if (isatty(fileno(stdout))) {
+    dumpopts |= JV_PRINT_ISATTY;
+#ifndef WIN32
+  /* Disable colour by default on Windows builds as Windows
+     terminals tend not to display it correctly */
+    dumpopts |= JV_PRINT_COLOUR;
+#endif
+  }
+  if (options & SORTED_OUTPUT) dumpopts |= JV_PRINT_SORTED;
+  if (options & ASCII_OUTPUT) dumpopts |= JV_PRINT_ASCII;
+  if (options & COLOUR_OUTPUT) dumpopts |= JV_PRINT_COLOUR;
+  if (options & NO_COLOUR_OUTPUT) dumpopts &= ~JV_PRINT_COLOUR;
+
+  if (jv_get_kind(lib_search_paths) == JV_KIND_NULL) {
+    // Default search path list
+    lib_search_paths = JV_ARRAY(jv_string("~/.jq"),
+                                jv_string("$ORIGIN/../lib/jq"),
+                                jv_string("$ORIGIN/lib"));
+  }
+  jq_set_attr(jq, jv_string("JQ_LIBRARY_PATH"), lib_search_paths);
+
+  char *origin = strdup(argv[0]);
+  if (origin == NULL) {
+    fprintf(stderr, "Error: out of memory\n");
+    exit(1);
+  }
+  jq_set_attr(jq, jv_string("JQ_ORIGIN"), jv_string(dirname(origin)));
+  free(origin);
+
+  if (strchr(JQ_VERSION, '-') == NULL)
+    jq_set_attr(jq, jv_string("VERSION_DIR"), jv_string(JQ_VERSION));
+  else
+    jq_set_attr(jq, jv_string("VERSION_DIR"), jv_string_fmt("%.*s-master", (int)(strchr(JQ_VERSION, '-') - JQ_VERSION), JQ_VERSION));
+
+#if (!defined(WIN32) && defined(HAVE_ISATTY)) || defined(HAVE__ISATTY)
+
+#if defined(HAVE__ISATTY) && defined(isatty)
+#undef isatty
+#define isatty _isatty
+#endif
+
+  if (!program && isatty(STDOUT_FILENO) && !isatty(STDIN_FILENO))
+    program = ".";
+#endif
+
+  if (!program) usage(2);
+
+  if (options & FROM_FILE) {
+    char *program_origin = strdup(program);
+    if (program_origin == NULL) {
+      perror("malloc");
+      exit(2);
+    }
+
+    jv data = jv_load_file(program, 1);
+    if (!jv_is_valid(data)) {
+      data = jv_invalid_get_msg(data);
+      fprintf(stderr, "%s: %s\n", progname, jv_string_value(data));
+      jv_free(data);
+      ret = 2;
+      goto out;
+    }
+    jq_set_attr(jq, jv_string("PROGRAM_ORIGIN"), jq_realpath(jv_string(dirname(program_origin))));
+    compiled = jq_compile_args(jq, jv_string_value(data), jv_copy(program_arguments));
+    free(program_origin);
+    jv_free(data);
+  } else {
+    jq_set_attr(jq, jv_string("PROGRAM_ORIGIN"), jq_realpath(jv_string("."))); // XXX is this good?
+    compiled = jq_compile_args(jq, program, jv_copy(program_arguments));
+  }
+  if (!compiled){
+    ret = 3;
+    goto out;
+  }
+
+  if (options & DUMP_DISASM) {
+    jq_dump_disassembly(jq, 0);
+    printf("\n");
+  }
+
+  if ((options & SEQ))
+    parser_flags |= JV_PARSE_SEQ;
+
+  if ((options & RAW_INPUT))
+    jq_util_input_set_parser(input_state, NULL, (options & SLURP) ? 1 : 0);
+  else
+    jq_util_input_set_parser(input_state, jv_parser_new(parser_flags), (options & SLURP) ? 1 : 0);
+
+  // Let jq program read from inputs
+  jq_set_input_cb(jq, jq_util_input_next_input_cb, input_state);
+
+  // Let jq program call `debug` builtin and have that go somewhere
+  jq_set_debug_cb(jq, debug_cb, &dumpopts);
+
+  if (nfiles == 0)
+    jq_util_input_add_input(input_state, "-");
+
+  if (options & PROVIDE_NULL) {
+    ret = process(jq, jv_null(), jq_flags, dumpopts);
+  } else {
+    jv value;
+    while (jq_util_input_errors(input_state) == 0 &&
+           (jv_is_valid((value = jq_util_input_next_input(input_state))) || jv_invalid_has_msg(jv_copy(value)))) {
+      if (jv_is_valid(value)) {
+        ret = process(jq, value, jq_flags, dumpopts);
+        continue;
+      }
+
+      // Parse error
+      jv msg = jv_invalid_get_msg(value);
+      if (!(options & SEQ)) {
+        // --seq -> errors are not fatal
+        ret = 4;
+        fprintf(stderr, "parse error: %s\n", jv_string_value(msg));
+        jv_free(msg);
+        break;
+      }
+      fprintf(stderr, "ignoring parse error: %s\n", jv_string_value(msg));
+      jv_free(msg);
+    }
+  }
+
+  if (jq_util_input_errors(input_state) != 0)
+    ret = 2;
+
+out:
+  badwrite = ferror(stdout);
+  if (fclose(stdout)!=0 || badwrite) {
+    fprintf(stderr,"Error: writing output failed: %s\n", strerror(errno));
+    ret = 2;
+  }
+
+  jv_free(program_arguments);
+  jq_util_input_free(&input_state);
+  jq_teardown(&jq);
+  if (ret >= 10 && (options & EXIT_STATUS))
+    return ret - 10;
+  if (ret >= 10)
+    return 0;
+  return ret;
+}

package/deps/jq/opcode_list.h

@@ -0,0 +1,44 @@
+OP(LOADK, CONSTANT, 1, 1)
+OP(DUP,   NONE,     1, 2)
+OP(DUPN,  NONE,     1, 2)
+OP(DUP2,  NONE,     2, 3)
+OP(POP,   NONE,     1, 0)
+OP(LOADV, VARIABLE, 1, 1)
+OP(LOADVN, VARIABLE, 1, 1)
+OP(STOREV, VARIABLE, 1, 0)
+OP(STORE_GLOBAL, GLOBAL, 0, 0)
+OP(INDEX, NONE,     2, 1)
+OP(INDEX_OPT, NONE,     2, 1)
+OP(EACH,  NONE,     1, 1)
+OP(EACH_OPT,  NONE,     1, 1)
+OP(FORK,  BRANCH,   0, 0)
+OP(FORK_OPT,  BRANCH,   0, 0)
+OP(JUMP,  BRANCH,   0, 0)
+OP(JUMP_F,BRANCH,   1, 0)
+OP(BACKTRACK, NONE, 0, 0)
+OP(APPEND, VARIABLE,1, 0)
+OP(INSERT, NONE,    4, 2)
+OP(RANGE, VARIABLE, 1, 1)
+
+OP(SUBEXP_BEGIN,  NONE,     1, 2)
+OP(SUBEXP_END,    NONE,     2, 2)
+
+OP(PATH_BEGIN, NONE, 1, 2)
+OP(PATH_END,   NONE, 2, 1)
+
+OP(CALL_BUILTIN, CFUNC, -1, 1)
+
+OP(CALL_JQ, UFUNC, 1, 1)
+OP(RET, NONE, 1, 1)
+OP(TAIL_CALL_JQ, UFUNC, 1, 1)
+
+OP(CLOSURE_PARAM, DEFINITION, 0, 0)
+OP(CLOSURE_REF, CLOSURE_REF_IMM, 0, 0)
+OP(CLOSURE_CREATE, DEFINITION, 0, 0)
+OP(CLOSURE_CREATE_C, DEFINITION, 0, 0)
+
+OP(TOP, NONE, 0, 0)
+OP(CLOSURE_PARAM_REGULAR, DEFINITION, 0, 0)
+OP(DEPS, CONSTANT, 0, 0)
+OP(MODULEMETA, CONSTANT, 0, 0)
+OP(GENLABEL, NONE, 0, 1)