Move source files to src/

1 files changed, 462 insertions, 0 deletions

diff --git a/src/util.c b/src/util.c
new file mode 100644
index 00000000..86b19831
--- /dev/null
+++ b/src/util.c
@@ -0,0 +1,462 @@
+
+#ifdef HAVE_MEMMEM
+#define _GNU_SOURCE
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <assert.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stddef.h>
+#ifdef HAVE_ALLOCA_H
+# include <alloca.h>
+#elif !defined alloca
+# ifdef __GNUC__
+#  define alloca __builtin_alloca
+# elif defined _MSC_VER
+#  include <malloc.h>
+#  define alloca _alloca
+# elif !defined HAVE_ALLOCA
+#  ifdef  __cplusplus
+extern "C"
+#  endif
+void *alloca (size_t);
+# endif
+#endif
+#ifndef WIN32
+#include <pwd.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#include <processenv.h>
+#include <shellapi.h>
+#include <wchar.h>
+#include <wtypes.h>
+#endif
+
+
+#include "util.h"
+#include "jq.h"
+#include "jv_alloc.h"
+
+#ifdef WIN32
+FILE *fopen(const char *fname, const char *mode) {
+  size_t sz = MultiByteToWideChar(CP_UTF8, 0, fname, -1, NULL, 0);
+  wchar_t *wfname = alloca(sz);
+  MultiByteToWideChar(CP_UTF8, 0, fname, -1, wfname, sz);
+
+  sz = MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0);
+  wchar_t *wmode = alloca(sz);
+  MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, sz);
+  return _wfopen(wfname, wmode);
+}
+#endif
+
+#ifndef HAVE_MKSTEMP
+int mkstemp(char *template) {
+  size_t len = strlen(template);
+  int tries=5;
+  int fd;
+
+  // mktemp() truncates template when it fails
+  char *s = alloca(len + 1);
+  assert(s != NULL);
+  strcpy(s, template);
+
+  do {
+    // Restore template
+    strcpy(template, s);
+    (void) mktemp(template);
+    fd = open(template, O_CREAT | O_EXCL | O_RDWR, 0600);
+  } while (fd == -1 && tries-- > 0);
+  return fd;
+}
+#endif
+
+jv expand_path(jv path) {
+  assert(jv_get_kind(path) == JV_KIND_STRING);
+  const char *pstr = jv_string_value(path);
+  jv ret = path;
+  if (jv_string_length_bytes(jv_copy(path)) > 1 && pstr[0] == '~' && pstr[1] == '/') {
+    jv home = get_home();
+    if (jv_is_valid(home)) {
+      ret = jv_string_fmt("%s/%s",jv_string_value(home),pstr+2);
+      jv_free(home);
+    } else {
+      jv emsg = jv_invalid_get_msg(home);
+      ret = jv_invalid_with_msg(jv_string_fmt("Could not expand %s. (%s)", pstr, jv_string_value(emsg)));
+      jv_free(emsg);
+    }
+    jv_free(path);
+  }
+  return ret;
+}
+
+jv get_home() {
+  jv ret;
+  char *home = getenv("HOME");
+  if (!home) {
+#ifndef WIN32
+    struct passwd* pwd = getpwuid(getuid());
+    if (pwd)
+      ret = jv_string(pwd->pw_dir);
+    else
+      ret = jv_invalid_with_msg(jv_string("Could not find home directory."));
+#else
+    home = getenv("USERPROFILE");
+    if (!home) {
+      char *hd = getenv("HOMEDRIVE");
+      if (!hd) hd = "";
+      home = getenv("HOMEPATH");
+      if (!home) {
+        ret = jv_invalid_with_msg(jv_string("Could not find home directory."));
+      } else {
+        ret = jv_string_fmt("%s%s",hd,home);
+      }
+    } else {
+      ret = jv_string(home);
+    }
+#endif
+  } else {
+    ret = jv_string(home);
+  }
+  return ret;
+}
+
+
+jv jq_realpath(jv path) {
+  int path_max;
+  char *buf = NULL;
+#ifdef _PC_PATH_MAX
+  path_max = pathconf(jv_string_value(path),_PC_PATH_MAX);
+#else
+  path_max = PATH_MAX;
+#endif
+  if (path_max > 0) {
+     buf = malloc(sizeof(char) * path_max);
+  }
+#ifdef WIN32
+  char *tmp = _fullpath(buf, jv_string_value(path), path_max);
+#else
+  char *tmp = realpath(jv_string_value(path), buf);
+#endif
+  if (tmp == NULL) {
+    free(buf);
+    return path;
+  }
+  jv_free(path);
+  path = jv_string(tmp);
+  free(tmp);
+  return path;
+}
+
+const void *_jq_memmem(const void *haystack, size_t haystacklen,
+                       const void *needle, size_t needlelen) {
+#ifdef HAVE_MEMMEM
+  return (const void*)memmem(haystack, haystacklen, needle, needlelen);
+#else
+  const char *h = haystack;
+  const char *n = needle;
+  size_t hi, hi2, ni;
+
+  if (haystacklen < needlelen || haystacklen == 0)
+    return NULL;
+  for (hi = 0; hi < (haystacklen - needlelen + 1); hi++) {
+    for (ni = 0, hi2 = hi; ni < needlelen; ni++, hi2++) {
+      if (h[hi2] != n[ni])
+        goto not_this;
+    }
+
+    return &h[hi];
+
+not_this:
+    continue;
+  }
+  return NULL;
+#endif /* !HAVE_MEMMEM */
+}
+
+struct jq_util_input_state {
+  jq_util_msg_cb err_cb;
+  void *err_cb_data;
+  jv_parser *parser;
+  FILE* current_input;
+  char **files;
+  int nfiles;
+  int curr_file;
+  int failures;
+  jv slurped;
+  char buf[4096];
+  size_t buf_valid_len;
+  jv current_filename;
+  size_t current_line;
+};
+
+static void fprinter(void *data, const char *fname) {
+  fprintf((FILE *)data, "jq: error: Could not open file %s: %s\n", fname, strerror(errno));
+}
+
+// If parser == NULL -> RAW
+jq_util_input_state *jq_util_input_init(jq_util_msg_cb err_cb, void *err_cb_data) {
+  if (err_cb == NULL) {
+    err_cb = fprinter;
+    err_cb_data = stderr;
+  }
+  jq_util_input_state *new_state = jv_mem_alloc(sizeof(*new_state));
+  memset(new_state, 0, sizeof(*new_state));
+  new_state->err_cb = err_cb;
+  new_state->err_cb_data = err_cb_data;
+  new_state->parser = NULL;
+  new_state->current_input = NULL;
+  new_state->files = NULL;
+  new_state->nfiles = 0;
+  new_state->curr_file = 0;
+  new_state->slurped = jv_invalid();
+  new_state->buf[0] = 0;
+  new_state->buf_valid_len = 0;
+  new_state->current_filename = jv_invalid();
+  new_state->current_line = 0;
+
+  return new_state;
+}
+
+void jq_util_input_set_parser(jq_util_input_state *state, jv_parser *parser, int slurp) {
+  assert(!jv_is_valid(state->slurped));
+  state->parser = parser;
+
+  if (parser == NULL && slurp)
+    state->slurped = jv_string("");
+  else if (slurp)
+    state->slurped = jv_array();
+  else
+    state->slurped = jv_invalid();
+}
+
+void jq_util_input_free(jq_util_input_state **state) {
+  jq_util_input_state *old_state = *state;
+  *state = NULL;
+  if (old_state == NULL)
+    return;
+
+  if (old_state->parser != NULL)
+    jv_parser_free(old_state->parser);
+  for (int i = 0; i < old_state->nfiles; i++)
+    free(old_state->files[i]);
+  free(old_state->files);
+  jv_free(old_state->slurped);
+  jv_free(old_state->current_filename);
+  jv_mem_free(old_state);
+}
+
+void jq_util_input_add_input(jq_util_input_state *state, const char *fname) {
+  state->files = jv_mem_realloc(state->files, (state->nfiles + 1) * sizeof(state->files[0]));
+  state->files[state->nfiles++] = jv_mem_strdup(fname);
+}
+
+int jq_util_input_errors(jq_util_input_state *state) {
+  return state->failures;
+}
+
+static const char *next_file(jq_util_input_state *state) {
+  if (state->curr_file < state->nfiles)
+    return state->files[state->curr_file++];
+  return NULL;
+}
+
+static int jq_util_input_read_more(jq_util_input_state *state) {
+  if (!state->current_input || feof(state->current_input) || ferror(state->current_input)) {
+    if (state->current_input && ferror(state->current_input)) {
+      // System-level input error on the stream. It will be closed (below).
+      // TODO: report it. Can't use 'state->err_cb()' as it is hard-coded for
+      //       'open' related problems.
+      fprintf(stderr,"Input error: %s\n", strerror(errno));
+    }
+    if (state->current_input) {
+      if (state->current_input == stdin) {
+        clearerr(stdin); // perhaps we can read again; anyways, we don't fclose(stdin)
+      } else {
+        fclose(state->current_input);
+      }
+      state->current_input = NULL;
+      jv_free(state->current_filename);
+      state->current_filename = jv_invalid();
+      state->current_line = 0 ;
+    }
+    const char *f = next_file(state);
+    if (f != NULL) {
+      if (!strcmp(f, "-")) {
+        state->current_input = stdin;
+        state->current_filename = jv_string("<stdin>");
+      } else {
+        state->current_input = fopen(f, "r");
+        state->current_filename = jv_string(f);
+        if (!state->current_input) {
+          state->err_cb(state->err_cb_data, f);
+          state->failures++;
+        }
+      }
+      state->current_line = 0;
+    }
+  }
+
+  state->buf[0] = 0;
+  state->buf_valid_len = 0;
+  if (state->current_input) {
+    char *res;
+    memset(state->buf, 0, sizeof(state->buf));
+
+    while (!(res = fgets(state->buf, sizeof(state->buf), state->current_input)) &&
+           ferror(state->current_input) && errno == EINTR)
+      clearerr(state->current_input);
+    if (res == NULL) {
+      state->buf[0] = 0;
+      if (ferror(state->current_input))
+        state->failures++;
+    } else {
+      const char *p = memchr(state->buf, '\n', sizeof(state->buf));
+
+      if (p != NULL)
+        state->current_line++;
+
+      if (p == NULL && state->parser != NULL) {
+        /*
+         * There should be no NULs in JSON texts (but JSON text
+         * sequences are another story).
+         */
+        state->buf_valid_len = strlen(state->buf);
+      } else if (p == NULL && feof(state->current_input)) {
+        size_t i;
+
+        /*
+         * XXX We can't know how many bytes we've read!
+         *
+         * We can't use getline() because there need not be any newlines
+         * in the input.  The only entirely correct choices are: use
+         * fgetc() or fread().  Using fread() will complicate buffer
+         * management here.
+         *
+         * For now we guess how much fgets() read.
+         */
+        for (p = state->buf, i = 0; i < sizeof(state->buf); i++) {
+          if (state->buf[i] != '\0')
+            p = &state->buf[i];
+        }
+        state->buf_valid_len = p - state->buf + 1;
+      } else if (p == NULL) {
+        state->buf_valid_len = sizeof(state->buf) - 1;
+      } else {
+        state->buf_valid_len = (p - state->buf) + 1;
+      }
+    }
+  }
+  return state->curr_file == state->nfiles &&
+      (!state->current_input || feof(state->current_input) || ferror(state->current_input));
+}
+
+jv jq_util_input_next_input_cb(jq_state *jq, void *data) {
+  return jq_util_input_next_input((jq_util_input_state *)data);
+}
+
+// Return the current_filename:current_line
+jv jq_util_input_get_position(jq_state *jq) {
+  jq_input_cb cb = NULL;
+  void *cb_data = NULL;
+  jq_get_input_cb(jq, &cb, &cb_data);
+  assert(cb == jq_util_input_next_input_cb);
+  if (cb != jq_util_input_next_input_cb)
+    return jv_invalid_with_msg(jv_string("Invalid jq_util_input API usage"));
+  jq_util_input_state *s = (jq_util_input_state *)cb_data;
+
+  // We can't assert that current_filename is a string because if
+  // the error was a JSON parser error then we may not have set
+  // current_filename yet.
+  if (jv_get_kind(s->current_filename) != JV_KIND_STRING)
+    return jv_string("<unknown>");
+
+  jv v = jv_string_fmt("%s:%lu", jv_string_value(s->current_filename), (unsigned long)s->current_line);
+  return v;
+}
+
+jv jq_util_input_get_current_filename(jq_state* jq) {
+  jq_input_cb cb=NULL;
+  void *cb_data=NULL;
+  jq_get_input_cb(jq, &cb, &cb_data);
+  if (cb != jq_util_input_next_input_cb)
+    return jv_invalid_with_msg(jv_string("Unknown input filename"));
+  jq_util_input_state *s = (jq_util_input_state *)cb_data;
+  jv v = jv_copy(s->current_filename);
+  return v;
+}
+
+jv jq_util_input_get_current_line(jq_state* jq) {
+  jq_input_cb cb=NULL;
+  void *cb_data=NULL;
+  jq_get_input_cb(jq, &cb, &cb_data);
+  if (cb != jq_util_input_next_input_cb)
+    return jv_invalid_with_msg(jv_string("Unknown input line number"));
+  jq_util_input_state *s = (jq_util_input_state *)cb_data;
+  jv v = jv_number(s->current_line);
+  return v;
+}
+
+
+// Blocks to read one more input from stdin and/or given files
+// When slurping, it returns just one value
+jv jq_util_input_next_input(jq_util_input_state *state) {
+  int is_last = 0;
+  jv value = jv_invalid(); // need more input
+  do {
+    if (state->parser == NULL) {
+      // Raw input
+      is_last = jq_util_input_read_more(state);
+      if (state->buf_valid_len == 0)
+        continue;
+      if (jv_is_valid(state->slurped)) {
+        // Slurped raw input
+        state->slurped = jv_string_concat(state->slurped, jv_string_sized(state->buf, state->buf_valid_len));
+      } else {
+        if (!jv_is_valid(value))
+          value = jv_string("");
+        if (state->buf[state->buf_valid_len-1] == '\n') {
+          // whole line
+          state->buf[state->buf_valid_len-1] = 0;
+          return jv_string_concat(value, jv_string_sized(state->buf, state->buf_valid_len-1));
+        }
+        value = jv_string_concat(value, jv_string_sized(state->buf, state->buf_valid_len));
+        state->buf[0] = '\0';
+        state->buf_valid_len = 0;
+      }
+    } else {
+      if (jv_parser_remaining(state->parser) == 0) {
+        is_last = jq_util_input_read_more(state);
+        if (is_last && state->buf_valid_len == 0) {
+          value = jv_invalid();
+          break;
+        }
+        jv_parser_set_buf(state->parser, state->buf, state->buf_valid_len, !is_last);
+      }
+      value = jv_parser_next(state->parser);
+      if (jv_is_valid(state->slurped)) {
+        if (jv_is_valid(value)) {
+          state->slurped = jv_array_append(state->slurped, value);
+          value = jv_invalid();
+        } else if (jv_invalid_has_msg(jv_copy(value)))
+          return value; // Not slurped parsed input
+      } else if (jv_is_valid(value) || jv_invalid_has_msg(jv_copy(value))) {
+        return value;
+      }
+    }
+  } while (!is_last);
+
+  if (jv_is_valid(state->slurped)) {
+    value = state->slurped;
+    state->slurped = jv_invalid();
+  }
+  return value;
+}