@port-labs/jq-node-bindings 0.0.1

package/deps/jq/linker.c

@@ -0,0 +1,393 @@
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/stat.h>
+#include <libgen.h>
+
+#ifdef WIN32
+#include <windows.h>
+#include <shlwapi.h>
+#endif
+
+#include "jq_parser.h"
+#include "locfile.h"
+#include "jv.h"
+#include "jq.h"
+#include "parser.h"
+#include "util.h"
+#include "compile.h"
+
+struct lib_loading_state {
+  char **names;
+  block *defs;
+  uint64_t ct;
+};
+static int load_library(jq_state *jq, jv lib_path, int is_data, int raw,
+                        const char *as, block *out_block,
+                        struct lib_loading_state *lib_state);
+
+static int path_is_relative(jv p) {
+  const char *s = jv_string_value(p);
+
+#ifdef WIN32
+  int res = PathIsRelativeA(s);
+#else
+  int res = *s != '/';
+#endif
+  jv_free(p);
+  return res;
+}
+
+
+// Given a lib_path to search first, creates a chain of search paths
+// in the following order:
+// 1. lib_path
+// 2. -L paths passed in on the command line (from jq_state*) or builtin list
+static jv build_lib_search_chain(jq_state *jq, jv search_path, jv jq_origin, jv lib_origin) {
+  assert(jv_get_kind(search_path) == JV_KIND_ARRAY);
+  jv expanded = jv_array();
+  jv expanded_elt;
+  jv err = jv_null();
+  jv_array_foreach(search_path, i, path) {
+    if (jv_get_kind(path) != JV_KIND_STRING) {
+      jv_free(path);
+      continue;
+    }
+    path = expand_path(path);
+    if (!jv_is_valid(path)) {
+      err = path;
+      path = jv_null();
+      continue;
+    }
+    if (strcmp(".",jv_string_value(path)) == 0) {
+      expanded_elt = jv_copy(path);
+    } else if (strncmp("$ORIGIN/",jv_string_value(path),sizeof("$ORIGIN/") - 1) == 0) {
+      expanded_elt = jv_string_fmt("%s/%s",
+                               jv_string_value(jq_origin),
+                               jv_string_value(path) + sizeof ("$ORIGIN/") - 1);
+    } else if (jv_get_kind(lib_origin) == JV_KIND_STRING &&
+               path_is_relative(jv_copy(path))) {
+      expanded_elt = jv_string_fmt("%s/%s",
+                               jv_string_value(lib_origin),
+                               jv_string_value(path));
+    } else {
+      expanded_elt = path;
+      path = jv_invalid();
+    }
+    expanded = jv_array_append(expanded, expanded_elt);
+    jv_free(path);
+  }
+  jv_free(jq_origin);
+  jv_free(lib_origin);
+  jv_free(search_path);
+  return JV_ARRAY(expanded, err);
+}
+
+// Doesn't actually check that name not be an absolute path, and we
+// don't have to: we always append relative paths to others (with a '/'
+// in between).
+static jv validate_relpath(jv name) {
+  const char *s = jv_string_value(name);
+  if (strchr(s, '\\')) {
+    jv res = jv_invalid_with_msg(jv_string_fmt("Modules must be named by relative paths using '/', not '\\' (%s)", s));
+    jv_free(name);
+    return res;
+  }
+  jv components = jv_string_split(jv_copy(name), jv_string("/"));
+  jv rp = jv_array_get(jv_copy(components), 0);
+  components = jv_array_slice(components, 1, jv_array_length(jv_copy(components)));
+  jv_array_foreach(components, i, x) {
+    if (!strcmp(jv_string_value(x), "..")) {
+      jv_free(x);
+      jv_free(rp);
+      jv_free(components);
+      jv res = jv_invalid_with_msg(jv_string_fmt("Relative paths to modules may not traverse to parent directories (%s)", s));
+      jv_free(name);
+      return res;
+    }
+    if (i > 0 && jv_equal(jv_copy(x), jv_array_get(jv_copy(components), i - 1))) {
+      jv_free(x);
+      jv_free(rp);
+      jv_free(components);
+      jv res = jv_invalid_with_msg(jv_string_fmt("module names must not have equal consecutive components: %s",
+                                                 jv_string_value(name)));
+      jv_free(name);
+      return res;
+    }
+    rp = jv_string_concat(rp, jv_string_concat(jv_string("/"), x));
+  }
+  jv_free(components);
+  jv_free(name);
+  return rp;
+}
+
+// Assumes name has been validated
+static jv jv_basename(jv name) {
+  const char *s = jv_string_value(name);
+  const char *p = strrchr(s, '/');
+  if (!p)
+    return name;
+  jv res = jv_string_fmt("%s", p);
+  jv_free(name);
+  return res;
+}
+
+// Asummes validated relative path to module
+static jv find_lib(jq_state *jq, jv rel_path, jv search, const char *suffix, jv jq_origin, jv lib_origin) {
+  if (jv_get_kind(search) != JV_KIND_ARRAY)
+    return jv_invalid_with_msg(jv_string_fmt("Module search path must be an array"));
+  if (jv_get_kind(rel_path) != JV_KIND_STRING)
+    return jv_invalid_with_msg(jv_string_fmt("Module path must be a string"));
+
+  struct stat st;
+  int ret;
+
+  // Ideally we should cache this somewhere
+  search = build_lib_search_chain(jq, search, jq_origin, lib_origin);
+  jv err = jv_array_get(jv_copy(search), 1);
+  search = jv_array_get(search, 0);
+
+  jv bname = jv_basename(jv_copy(rel_path));
+
+  jv_array_foreach(search, i, spath) {
+    if (jv_get_kind(spath) == JV_KIND_NULL) {
+      jv_free(spath);
+      break;
+    }
+    if (jv_get_kind(spath) != JV_KIND_STRING ||
+        strcmp(jv_string_value(spath), "") == 0) {
+      jv_free(spath);
+      continue; /* XXX report non-strings in search path?? */
+    }
+    // Try ${search_dir}/${rel_path}.jq
+    jv testpath = jq_realpath(jv_string_fmt("%s/%s%s",
+                                            jv_string_value(spath),
+                                            jv_string_value(rel_path),
+                                            suffix));
+    ret = stat(jv_string_value(testpath),&st);
+    if (ret == -1 && errno == ENOENT) {
+      jv_free(testpath);
+      // Try ${search_dir}/$(dirname ${rel_path})/jq/main.jq
+      testpath = jq_realpath(jv_string_fmt("%s/%s/%s%s",
+                                           jv_string_value(spath),
+                                           jv_string_value(rel_path),
+                                           "jq/main",
+                                           suffix));
+      ret = stat(jv_string_value(testpath),&st);
+    }
+    if (ret == -1 && errno == ENOENT) {
+      jv_free(testpath);
+      // Try ${search_dir}/${rel_path}/$(basename ${rel_path}).jq
+      testpath = jq_realpath(jv_string_fmt("%s/%s/%s%s",
+                                           jv_string_value(spath),
+                                           jv_string_value(rel_path),
+                                           jv_string_value(bname),
+                                           suffix));
+      ret = stat(jv_string_value(testpath),&st);
+    }
+    if (ret == 0) {
+      jv_free(err);
+      jv_free(rel_path);
+      jv_free(search);
+      jv_free(bname);
+      jv_free(spath);
+      return testpath;
+    }
+    jv_free(testpath);
+    jv_free(spath);
+  }
+  jv output;
+  if (!jv_is_valid(err)) {
+    err = jv_invalid_get_msg(err);
+    output = jv_invalid_with_msg(jv_string_fmt("module not found: %s (%s)",
+                                               jv_string_value(rel_path),
+                                               jv_string_value(err)));
+  } else {
+    output = jv_invalid_with_msg(jv_string_fmt("module not found: %s",
+                                               jv_string_value(rel_path)));
+  }
+  jv_free(err);
+  jv_free(rel_path);
+  jv_free(search);
+  jv_free(bname);
+  return output;
+}
+
+static jv default_search(jq_state *jq, jv value) {
+  if (!jv_is_valid(value)) {
+    // dependent didn't say; prepend . to system search path listj
+    jv_free(value);
+    return jv_array_concat(JV_ARRAY(jv_string(".")), jq_get_lib_dirs(jq));
+  }
+  if (jv_get_kind(value) != JV_KIND_ARRAY)
+    return JV_ARRAY(value);
+  return value;
+}
+
+// XXX Split this into a util that takes a callback, and then...
+static int process_dependencies(jq_state *jq, jv jq_origin, jv lib_origin, block *src_block, struct lib_loading_state *lib_state) {
+  jv deps = block_take_imports(src_block);
+  block bk = *src_block;
+  int nerrors = 0;
+  const char *as_str = NULL;
+
+  jv_array_foreach(deps, i, dep) {
+    int is_data = jv_get_kind(jv_object_get(jv_copy(dep), jv_string("is_data"))) == JV_KIND_TRUE;
+    int raw = 0;
+    jv v = jv_object_get(jv_copy(dep), jv_string("raw"));
+    if (jv_get_kind(v) == JV_KIND_TRUE)
+      raw = 1;
+    jv_free(v);
+    jv relpath = validate_relpath(jv_object_get(jv_copy(dep), jv_string("relpath")));
+    jv as = jv_object_get(jv_copy(dep), jv_string("as"));
+    assert(!jv_is_valid(as) || jv_get_kind(as) == JV_KIND_STRING);
+    if (jv_get_kind(as) == JV_KIND_STRING)
+      as_str = jv_string_value(as);
+    jv search = default_search(jq, jv_object_get(dep, jv_string("search")));
+    // dep is now freed; do not reuse
+
+    // find_lib does a lot of work that could be cached...
+    jv resolved = find_lib(jq, relpath, search, is_data ? ".json" : ".jq", jv_copy(jq_origin), jv_copy(lib_origin));
+    // XXX ...move the rest of this into a callback.
+    if (!jv_is_valid(resolved)) {
+      jv emsg = jv_invalid_get_msg(resolved);
+      jq_report_error(jq, jv_string_fmt("jq: error: %s\n",jv_string_value(emsg)));
+      jv_free(emsg);
+      jv_free(as);
+      jv_free(deps);
+      jv_free(jq_origin);
+      jv_free(lib_origin);
+      return 1;
+    }
+    uint64_t state_idx = 0;
+    for (; state_idx < lib_state->ct; ++state_idx) {
+      if (strcmp(lib_state->names[state_idx],jv_string_value(resolved)) == 0)
+        break;
+    }
+    if (state_idx < lib_state->ct) { // Found
+      jv_free(resolved);
+      // Bind the library to the program
+      bk = block_bind_library(lib_state->defs[state_idx], bk, OP_IS_CALL_PSEUDO, as_str);
+    } else { // Not found.   Add it to the table before binding.
+      block dep_def_block = gen_noop();
+      nerrors += load_library(jq, resolved, is_data, raw, as_str, &dep_def_block, lib_state);
+      // resolved has been freed
+      if (nerrors == 0) {
+        // Bind the library to the program
+        bk = block_bind_library(dep_def_block, bk, OP_IS_CALL_PSEUDO, as_str);
+      }
+    }
+    jv_free(as);
+  }
+  jv_free(lib_origin);
+  jv_free(jq_origin);
+  jv_free(deps);
+  return nerrors;
+}
+
+// Loads the library at lib_path into lib_state, putting the library's defs
+// into *out_block
+static int load_library(jq_state *jq, jv lib_path, int is_data, int raw, const char *as, block *out_block, struct lib_loading_state *lib_state) {
+  int nerrors = 0;
+  struct locfile* src = NULL;
+  block program;
+  jv data;
+  if (is_data && !raw)
+    data = jv_load_file(jv_string_value(lib_path), 0);
+  else
+    data = jv_load_file(jv_string_value(lib_path), 1);
+  int state_idx;
+  if (!jv_is_valid(data)) {
+    if (jv_invalid_has_msg(jv_copy(data)))
+      data = jv_invalid_get_msg(data);
+    else
+      data = jv_string("unknown error");
+    jq_report_error(jq, jv_string_fmt("jq: error loading data file %s: %s\n", jv_string_value(lib_path), jv_string_value(data)));
+    nerrors++;
+    goto out;
+  } else if (is_data) {
+    // import "foo" as $bar;
+    program = gen_const_global(jv_copy(data), as);
+  } else {
+    // import "foo" as bar;
+    src = locfile_init(jq, jv_string_value(lib_path), jv_string_value(data), jv_string_length_bytes(jv_copy(data)));
+    nerrors += jq_parse_library(src, &program);
+    if (nerrors == 0) {
+      char *lib_origin = strdup(jv_string_value(lib_path));
+      nerrors += process_dependencies(jq, jq_get_jq_origin(jq),
+                                      jv_string(dirname(lib_origin)),
+                                      &program, lib_state);
+      free(lib_origin);
+    }
+  }
+  state_idx = lib_state->ct++;
+  lib_state->names = realloc(lib_state->names, lib_state->ct * sizeof(const char *));
+  lib_state->defs = realloc(lib_state->defs, lib_state->ct * sizeof(block));
+  lib_state->names[state_idx] = strdup(jv_string_value(lib_path));
+  lib_state->defs[state_idx] = program;
+  *out_block = program;
+  if (src)
+    locfile_free(src);
+out:
+  jv_free(lib_path);
+  jv_free(data);
+  return nerrors;
+}
+
+// FIXME It'd be nice to have an option to search the same search path
+// as we do in process_dependencies.
+jv load_module_meta(jq_state *jq, jv mod_relpath) {
+  // We can't know the caller's origin; we could though, if it was passed in
+  jv lib_path = find_lib(jq, validate_relpath(mod_relpath), jq_get_lib_dirs(jq), ".jq", jq_get_jq_origin(jq), jv_null());
+  if (!jv_is_valid(lib_path))
+    return lib_path;
+  jv meta = jv_null();
+  jv data = jv_load_file(jv_string_value(lib_path), 1);
+  if (jv_is_valid(data)) {
+    block program;
+    struct locfile* src = locfile_init(jq, jv_string_value(lib_path), jv_string_value(data), jv_string_length_bytes(jv_copy(data)));
+    int nerrors = jq_parse_library(src, &program);
+    if (nerrors == 0) {
+      meta = block_module_meta(program);
+      if (jv_get_kind(meta) == JV_KIND_NULL)
+        meta = jv_object();
+      meta = jv_object_set(meta, jv_string("deps"), block_take_imports(&program));
+    }
+    locfile_free(src);
+    block_free(program);
+  }
+  jv_free(lib_path);
+  jv_free(data);
+  return meta;
+}
+
+int load_program(jq_state *jq, struct locfile* src, block *out_block) {
+  int nerrors = 0;
+  block program;
+  struct lib_loading_state lib_state = {0,0,0};
+  nerrors = jq_parse(src, &program);
+  if (nerrors)
+    return nerrors;
+
+  nerrors = process_dependencies(jq, jq_get_jq_origin(jq), jq_get_prog_origin(jq), &program, &lib_state);
+  block libs = gen_noop();
+  for (uint64_t i = 0; i < lib_state.ct; ++i) {
+    free(lib_state.names[i]);
+    if (nerrors == 0 && !block_is_const(lib_state.defs[i]))
+      libs = block_join(libs, lib_state.defs[i]);
+    else
+      block_free(lib_state.defs[i]);
+  }
+  free(lib_state.names);
+  free(lib_state.defs);
+  if (nerrors)
+    block_free(program);
+  else
+    *out_block = block_drop_unreferenced(block_join(libs, program));
+
+  return nerrors;
+}

package/deps/jq/linker.h

@@ -0,0 +1,7 @@
+#ifndef LINKER_H
+#define LINKER_H
+
+int load_program(jq_state *jq, struct locfile* src, block *out_block);
+jv load_module_meta(jq_state *jq, jv modname);
+
+#endif

package/deps/jq/locfile.c

@@ -0,0 +1,91 @@
+#include <assert.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "jq.h"
+#include "jv_alloc.h"
+#include "locfile.h"
+
+
+struct locfile* locfile_init(jq_state *jq, const char *fname, const char* data, int length) {
+  struct locfile* l = jv_mem_alloc(sizeof(struct locfile));
+  l->jq = jq;
+  l->fname = jv_string(fname);
+  l->data = jv_mem_alloc(length);
+  memcpy((char*)l->data,data,length);
+  l->length = length;
+  l->nlines = 1;
+  l->refct = 1;
+  for (int i=0; i<length; i++) {
+    if (data[i] == '\n') l->nlines++;
+  }
+  l->linemap = jv_mem_alloc(sizeof(int) * (l->nlines + 1));
+  l->linemap[0] = 0;
+  int line = 1;
+  for (int i=0; i<length; i++) {
+    if (data[i] == '\n') {
+      l->linemap[line] = i+1;   // at start of line, not of \n
+      line++;
+    }
+  }
+  l->linemap[l->nlines] = length+1;   // virtual last \n
+  return l;
+}
+
+struct locfile* locfile_retain(struct locfile* l) {
+  l->refct++;
+  return l;
+}
+void locfile_free(struct locfile* l) {
+  if (--(l->refct) == 0) {
+    jv_free(l->fname);
+    jv_mem_free(l->linemap);
+    jv_mem_free((char*)l->data);
+    jv_mem_free(l);
+  }
+}
+
+int locfile_get_line(struct locfile* l, int pos) {
+  assert(pos < l->length);
+  int line = 1;
+  while (l->linemap[line] <= pos) line++;   // == if pos at start (before, never ==, because pos never on \n)
+  assert(line-1 < l->nlines);
+  return line-1;
+}
+
+static int locfile_line_length(struct locfile* l, int line) {
+  assert(line < l->nlines);
+  return l->linemap[line+1] - l->linemap[line] -1;   // -1 to omit \n
+}
+
+void locfile_locate(struct locfile* l, location loc, const char* fmt, ...) {
+  va_list fmtargs;
+  va_start(fmtargs, fmt);
+  int startline;
+  int offset;
+
+  if (loc.start != -1) {
+    startline = locfile_get_line(l, loc.start);
+    offset = l->linemap[startline];
+  }
+
+  jv m1 = jv_string_vfmt(fmt, fmtargs);
+  if (!jv_is_valid(m1)) {
+    jq_report_error(l->jq, m1);
+    return;
+  }
+  if (loc.start == -1) {
+    jq_report_error(l->jq, jv_string_fmt("jq: error: %s\n<unknown location>", jv_string_value(m1)));
+    jv_free(m1);
+    return;
+  }
+  jv m2 = jv_string_fmt("%s at %s, line %d:\n%.*s%*s", jv_string_value(m1),
+                        jv_string_value(l->fname), startline + 1,
+                        locfile_line_length(l, startline), l->data + offset,
+                        loc.start - offset, "");
+  jv_free(m1);
+  jq_report_error(l->jq, m2);
+  return;
+}

package/deps/jq/locfile.h

@@ -0,0 +1,29 @@
+#ifndef LOCFILE_H
+#define LOCFILE_H
+
+#include "jq.h"
+
+typedef struct {
+  int start, end;
+} location;
+
+static const location UNKNOWN_LOCATION = {-1, -1};
+
+struct locfile {
+  jv fname;
+  const char* data;
+  int length;
+  int* linemap;
+  int nlines;
+  char *error;
+  jq_state *jq;
+  int refct;
+};
+
+struct locfile* locfile_init(jq_state *, const char *, const char *, int);
+struct locfile* locfile_retain(struct locfile *);
+int locfile_get_line(struct locfile *, int);
+void locfile_free(struct locfile *);
+void locfile_locate(struct locfile *, location, const char *, ...);
+
+#endif

package/deps/jq/m4/ax_compare_version.m4

@@ -0,0 +1,177 @@
+# ===========================================================================
+#    http://www.gnu.org/software/autoconf-archive/ax_compare_version.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_COMPARE_VERSION(VERSION_A, OP, VERSION_B, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
+#
+# DESCRIPTION
+#
+#   This macro compares two version strings. Due to the various number of
+#   minor-version numbers that can exist, and the fact that string
+#   comparisons are not compatible with numeric comparisons, this is not
+#   necessarily trivial to do in a autoconf script. This macro makes doing
+#   these comparisons easy.
+#
+#   The six basic comparisons are available, as well as checking equality
+#   limited to a certain number of minor-version levels.
+#
+#   The operator OP determines what type of comparison to do, and can be one
+#   of:
+#
+#    eq  - equal (test A == B)
+#    ne  - not equal (test A != B)
+#    le  - less than or equal (test A <= B)
+#    ge  - greater than or equal (test A >= B)
+#    lt  - less than (test A < B)
+#    gt  - greater than (test A > B)
+#
+#   Additionally, the eq and ne operator can have a number after it to limit
+#   the test to that number of minor versions.
+#
+#    eq0 - equal up to the length of the shorter version
+#    ne0 - not equal up to the length of the shorter version
+#    eqN - equal up to N sub-version levels
+#    neN - not equal up to N sub-version levels
+#
+#   When the condition is true, shell commands ACTION-IF-TRUE are run,
+#   otherwise shell commands ACTION-IF-FALSE are run. The environment
+#   variable 'ax_compare_version' is always set to either 'true' or 'false'
+#   as well.
+#
+#   Examples:
+#
+#     AX_COMPARE_VERSION([3.15.7],[lt],[3.15.8])
+#     AX_COMPARE_VERSION([3.15],[lt],[3.15.8])
+#
+#   would both be true.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq],[3.15.8])
+#     AX_COMPARE_VERSION([3.15],[gt],[3.15.8])
+#
+#   would both be false.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq2],[3.15.8])
+#
+#   would be true because it is only comparing two minor versions.
+#
+#     AX_COMPARE_VERSION([3.15.7],[eq0],[3.15])
+#
+#   would be true because it is only comparing the lesser number of minor
+#   versions of the two values.
+#
+#   Note: The characters that separate the version numbers do not matter. An
+#   empty string is the same as version 0. OP is evaluated by autoconf, not
+#   configure, so must be a string, not a variable.
+#
+#   The author would like to acknowledge Guido Draheim whose advice about
+#   the m4_case and m4_ifvaln functions make this macro only include the
+#   portions necessary to perform the specific comparison specified by the
+#   OP argument in the final configure script.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Tim Toolan <toolan@ele.uri.edu>
+#
+#   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 11
+
+dnl #########################################################################
+AC_DEFUN([AX_COMPARE_VERSION], [
+  AC_REQUIRE([AC_PROG_AWK])
+
+  # Used to indicate true or false condition
+  ax_compare_version=false
+
+  # Convert the two version strings to be compared into a format that
+  # allows a simple string comparison.  The end result is that a version
+  # string of the form 1.12.5-r617 will be converted to the form
+  # 0001001200050617.  In other words, each number is zero padded to four
+  # digits, and non digits are removed.
+  AS_VAR_PUSHDEF([A],[ax_compare_version_A])
+  A=`echo "$1" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
+                     -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/[[^0-9]]//g'`
+
+  AS_VAR_PUSHDEF([B],[ax_compare_version_B])
+  B=`echo "$3" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
+                     -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
+                     -e 's/[[^0-9]]//g'`
+
+  dnl # In the case of le, ge, lt, and gt, the strings are sorted as necessary
+  dnl # then the first line is used to determine if the condition is true.
+  dnl # The sed right after the echo is to remove any indented white space.
+  m4_case(m4_tolower($2),
+  [lt],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/false/;s/x${B}/true/;1q"`
+  ],
+  [gt],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort | sed "s/x${A}/false/;s/x${B}/true/;1q"`
+  ],
+  [le],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort | sed "s/x${A}/true/;s/x${B}/false/;1q"`
+  ],
+  [ge],[
+    ax_compare_version=`echo "x$A
+x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/true/;s/x${B}/false/;1q"`
+  ],[
+    dnl Split the operator from the subversion count if present.
+    m4_bmatch(m4_substr($2,2),
+    [0],[
+      # A count of zero means use the length of the shorter version.
+      # Determine the number of characters in A and B.
+      ax_compare_version_len_A=`echo "$A" | $AWK '{print(length)}'`
+      ax_compare_version_len_B=`echo "$B" | $AWK '{print(length)}'`
+
+      # Set A to no more than B's length and B to no more than A's length.
+      A=`echo "$A" | sed "s/\(.\{$ax_compare_version_len_B\}\).*/\1/"`
+      B=`echo "$B" | sed "s/\(.\{$ax_compare_version_len_A\}\).*/\1/"`
+    ],
+    [[0-9]+],[
+      # A count greater than zero means use only that many subversions
+      A=`echo "$A" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
+      B=`echo "$B" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
+    ],
+    [.+],[
+      AC_WARNING(
+        [illegal OP numeric parameter: $2])
+    ],[])
+
+    # Pad zeros at end of numbers to make same length.
+    ax_compare_version_tmp_A="$A`echo $B | sed 's/./0/g'`"
+    B="$B`echo $A | sed 's/./0/g'`"
+    A="$ax_compare_version_tmp_A"
+
+    # Check for equality or inequality as necessary.
+    m4_case(m4_tolower(m4_substr($2,0,2)),
+    [eq],[
+      test "x$A" = "x$B" && ax_compare_version=true
+    ],
+    [ne],[
+      test "x$A" != "x$B" && ax_compare_version=true
+    ],[
+      AC_WARNING([illegal OP parameter: $2])
+    ])
+  ])
+
+  AS_VAR_POPDEF([A])dnl
+  AS_VAR_POPDEF([B])dnl
+
+  dnl # Execute ACTION-IF-TRUE / ACTION-IF-FALSE.
+  if test "$ax_compare_version" = "true" ; then
+    m4_ifvaln([$4],[$4],[:])dnl
+    m4_ifvaln([$5],[else $5])dnl
+  fi
+]) dnl AX_COMPARE_VERSION