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

package/deps/jq/src/jv_parse.c

@@ -124,14 +124,19 @@ static void parser_free(struct jv_parser* p) {
 
 static pfunc value(struct jv_parser* p, jv val) {
   if ((p->flags & JV_PARSE_STREAMING)) {
-    if (jv_is_valid(p->next) || p->last_seen == JV_LAST_VALUE)
+    if (jv_is_valid(p->next) || p->last_seen == JV_LAST_VALUE) {
+      jv_free(val);
       return "Expected separator between values";
+    }
     if (p->stacklen > 0)
       p->last_seen = JV_LAST_VALUE;
     else
       p->last_seen = JV_LAST_NONE;
   } else {
-    if (jv_is_valid(p->next)) return "Expected separator between values";
+    if (jv_is_valid(p->next)) {
+      jv_free(val);
+      return "Expected separator between values";
+    }
   }
   jv_free(p->next);
   p->next = val;
@@ -241,6 +246,17 @@ static pfunc stream_token(struct jv_parser* p, char ch) {
   case '[':
     if (jv_is_valid(p->next))
       return "Expected a separator between values";
+    if (p->last_seen == JV_LAST_OPEN_OBJECT)
+      // Looks like {["foo"]}
+      return "Expected string key after '{', not '['";
+    if (p->last_seen == JV_LAST_COMMA) {
+      last = jv_array_get(jv_copy(p->path), p->stacklen - 1);
+      k = jv_get_kind(last);
+      jv_free(last);
+      if (k != JV_KIND_NUMBER)
+        // Looks like {"x":"y",["foo"]}
+        return "Expected string key after ',' in object, not '['";
+    }
     p->path = jv_array_append(p->path, jv_number(0)); // push
     p->last_seen = JV_LAST_OPEN_ARRAY;
     p->stacklen++;
@@ -249,6 +265,17 @@ static pfunc stream_token(struct jv_parser* p, char ch) {
   case '{':
     if (p->last_seen == JV_LAST_VALUE)
       return "Expected a separator between values";
+    if (p->last_seen == JV_LAST_OPEN_OBJECT)
+      // Looks like {{"foo":"bar"}}
+      return "Expected string key after '{', not '{'";
+    if (p->last_seen == JV_LAST_COMMA) {
+      last = jv_array_get(jv_copy(p->path), p->stacklen - 1);
+      k = jv_get_kind(last);
+      jv_free(last);
+      if (k != JV_KIND_NUMBER)
+        // Looks like {"x":"y",{"foo":"bar"}}
+        return "Expected string key after ',' in object, not '{'";
+    }
     // Push object key: null, since we don't know it yet
     p->path = jv_array_append(p->path, jv_null()); // push
     p->last_seen = JV_LAST_OPEN_OBJECT;
@@ -256,8 +283,12 @@ static pfunc stream_token(struct jv_parser* p, char ch) {
     break;
 
   case ':':
-    if (p->stacklen == 0 || jv_get_kind(jv_array_get(jv_copy(p->path), p->stacklen - 1)) == JV_KIND_NUMBER)
+    last = jv_invalid();
+    if (p->stacklen == 0 || jv_get_kind(last = jv_array_get(jv_copy(p->path), p->stacklen - 1)) == JV_KIND_NUMBER) {
+      jv_free(last);
       return "':' not as part of an object";
+    }
+    jv_free(last);
     if (!jv_is_valid(p->next) || p->last_seen == JV_LAST_NONE)
       return "Expected string key before ':'";
     if (jv_get_kind(p->next) != JV_KIND_STRING)
@@ -290,7 +321,7 @@ static pfunc stream_token(struct jv_parser* p, char ch) {
         p->output = JV_ARRAY(jv_copy(p->path), p->next);
         p->next = jv_invalid();
       }
-      p->path = jv_array_set(p->path, p->stacklen - 1, jv_true()); // ready for another name:value pair
+      p->path = jv_array_set(p->path, p->stacklen - 1, jv_null()); // ready for another key:value pair
       p->last_seen = JV_LAST_COMMA;
     } else {
       assert(k == JV_KIND_NULL);
@@ -462,7 +493,7 @@ static pfunc found_string(struct jv_parser* p) {
         return "Invalid escape";
       }
     } else {
-      if (c > 0 && c < 0x001f)
+      if (c >= 0 && c <= 0x001f)
         return "Invalid string: control characters from U+0000 through U+001F must be escaped";
       *out++ = c;
     }
@@ -481,7 +512,13 @@ static pfunc check_literal(struct jv_parser* p) {
   switch (p->tokenbuf[0]) {
   case 't': pattern = "true"; plen = 4; v = jv_true(); break;
   case 'f': pattern = "false"; plen = 5; v = jv_false(); break;
-  case 'n': pattern = "null"; plen = 4; v = jv_null(); break;
+  case '\'':
+    return "Invalid string literal; expected \", but got '";
+  case 'n':
+    // if it starts with 'n', it could be a literal "nan"
+    if (p->tokenbuf[1] == 'u') {
+      pattern = "null"; plen = 4; v = jv_null();
+    }
   }
   if (pattern) {
     if (p->tokenpos != plen) return "Invalid literal";
@@ -492,11 +529,20 @@ static pfunc check_literal(struct jv_parser* p) {
   } else {
     // FIXME: better parser
     p->tokenbuf[p->tokenpos] = 0;
-    char* end = 0;
+#ifdef USE_DECNUM
+    jv number = jv_number_with_literal(p->tokenbuf);
+    if (jv_get_kind(number) == JV_KIND_INVALID) {
+      return "Invalid numeric literal";
+    }
+    TRY(value(p, number));
+#else
+    char *end = 0;
     double d = jvp_strtod(&p->dtoa, p->tokenbuf, &end);
-    if (end == 0 || *end != 0)
+    if (end == 0 || *end != 0) {
       return "Invalid numeric literal";
+    }
     TRY(value(p, jv_number(d)));
+#endif
   }
   p->tokenpos = 0;
   return 0;
@@ -566,11 +612,11 @@ static int stream_check_done(struct jv_parser* p, jv* out) {
   }
 }
 
-static int parse_check_truncation(struct jv_parser* p) {
-  return ((p->flags & JV_PARSE_SEQ) && !p->last_ch_was_ws && (p->stackpos > 0 || p->tokenpos > 0 || jv_get_kind(p->next) == JV_KIND_NUMBER));
+static int seq_check_truncation(struct jv_parser* p) {
+  return (!p->last_ch_was_ws && (p->stackpos > 0 || p->tokenpos > 0 || jv_get_kind(p->next) == JV_KIND_NUMBER));
 }
 
-static int stream_check_truncation(struct jv_parser* p) {
+static int stream_seq_check_truncation(struct jv_parser* p) {
   jv_kind k = jv_get_kind(p->next);
   return (p->stacklen > 0 || k == JV_KIND_NUMBER || k == JV_KIND_TRUE || k == JV_KIND_FALSE || k == JV_KIND_NULL);
 }
@@ -590,7 +636,7 @@ static int stream_is_top_num(struct jv_parser* p) {
    (((p)->flags & JV_PARSE_STREAMING) ? stream_token((p), (ch)) : parse_token((p), (ch)))
 
 #define check_truncation(p) \
-   (((p)->flags & JV_PARSE_STREAMING) ? stream_check_truncation((p)) : parse_check_truncation((p)))
+   (((p)->flags & JV_PARSE_STREAMING) ? stream_seq_check_truncation((p)) : seq_check_truncation((p)))
 
 #define is_top_num(p) \
    (((p)->flags & JV_PARSE_STREAMING) ? stream_is_top_num((p)) : parse_is_top_num((p)))
@@ -601,7 +647,8 @@ static pfunc scan(struct jv_parser* p, char ch, jv* out) {
     p->line++;
     p->column = 0;
   }
-  if (ch == '\036' /* ASCII RS; see draft-ietf-json-sequence-07 */) {
+  if ((p->flags & JV_PARSE_SEQ)
+      && ch == '\036' /* ASCII RS; see draft-ietf-json-sequence-07 */) {
     if (check_truncation(p)) {
       if (check_literal(p) == 0 && is_top_num(p))
         return "Potentially truncated top-level numeric value";
@@ -814,9 +861,9 @@ jv jv_parser_next(struct jv_parser* p) {
   }
 }
 
-jv jv_parse_sized(const char* string, int length) {
+jv jv_parse_sized_custom_flags(const char* string, int length, int flags) {
   struct jv_parser parser;
-  parser_init(&parser, 0);
+  parser_init(&parser, flags);
   jv_parser_set_buf(&parser, string, length, 0);
   jv value = jv_parser_next(&parser);
   if (jv_is_valid(value)) {
@@ -853,6 +900,14 @@ jv jv_parse_sized(const char* string, int length) {
   return value;
 }
 
+jv jv_parse_sized(const char* string, int length) {
+  return jv_parse_sized_custom_flags(string, length, 0);
+}
+
 jv jv_parse(const char* string) {
   return jv_parse_sized(string, strlen(string));
 }
+
+jv jv_parse_custom_flags(const char* string, int flags) {
+  return jv_parse_sized_custom_flags(string, strlen(string), flags);
+}

package/deps/jq/src/jv_print.c

@@ -11,8 +11,10 @@
 
 #include "jv.h"
 #include "jv_dtoa.h"
+#include "jv_dtoa_tsd.h"
 #include "jv_unicode.h"
 #include "jv_alloc.h"
+#include "jv_private.h"
 
 #ifndef MAX_PRINT_DEPTH
 #define MAX_PRINT_DEPTH (256)
@@ -23,18 +25,16 @@
 #define COLRESET (ESC "[0m")
 
 // Color table. See https://en.wikipedia.org/wiki/ANSI_escape_code#Colors
-// for how to choose these.
-static const jv_kind color_kinds[] =
-  {JV_KIND_NULL,   JV_KIND_FALSE, JV_KIND_TRUE, JV_KIND_NUMBER,
-   JV_KIND_STRING, JV_KIND_ARRAY, JV_KIND_OBJECT};
-static char color_bufs[sizeof(color_kinds)/sizeof(color_kinds[0])][16];
+// for how to choose these. The order is same as jv_kind definition, and
+// the last color is used for object keys.
+static char color_bufs[8][16];
 static const char *color_bufps[8];
-static const char* def_colors[] =
-  {COL("1;30"),    COL("0;39"),      COL("0;39"),     COL("0;39"),
-   COL("0;32"),      COL("1;39"),     COL("1;39")};
-#define FIELD_COLOR COL("34;1")
+static const char *const def_colors[] =
+  {COL("0;90"),    COL("0;39"),      COL("0;39"),     COL("0;39"),
+   COL("0;32"),    COL("1;39"),      COL("1;39"),     COL("1;34")};
+#define FIELD_COLOR (colors[7])
 
-static const char **colors = def_colors;
+static const char *const *colors = def_colors;
 
 int
 jq_set_colors(const char *c)
@@ -79,7 +79,7 @@ static void put_buf(const char *s, int len, FILE *fout, jv *strout, int is_tty)
     if (len == -1)
       len = strlen(s);
     wl = MultiByteToWideChar(CP_UTF8, 0, s, len, NULL, 0);
-    ws = jv_mem_calloc((wl + 1), sizeof(*ws));
+    ws = jv_mem_calloc(wl + 1, sizeof(*ws));
     if (!ws)
       return;
     wl = MultiByteToWideChar(CP_UTF8, 0, s, len, ws, wl + 1);
@@ -192,14 +192,9 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
   char buf[JVP_DTOA_FMT_MAX_LEN];
   const char* color = 0;
   double refcnt = (flags & JV_PRINT_REFCOUNT) ? jv_get_refcnt(x) - 1 : -1;
-  if (flags & JV_PRINT_COLOR) {
-    for (unsigned i=0; i<sizeof(color_kinds)/sizeof(color_kinds[0]); i++) {
-      if (jv_get_kind(x) == color_kinds[i]) {
-        color = colors[i];
-        put_str(color, F, S, flags & JV_PRINT_ISATTY);
-        break;
-      }
-    }
+  if ((flags & JV_PRINT_COLOR) && jv_get_kind(x) != JV_KIND_INVALID) {
+    color = colors[(int)jv_get_kind(x) - 1];
+    put_str(color, F, S, flags & JV_PRINT_ISATTY);
   }
   if (indent > MAX_PRINT_DEPTH) {
     put_str("<skipped: too deep>", F, S, flags & JV_PRINT_ISATTY);
@@ -211,7 +206,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       if (jv_get_kind(msg) == JV_KIND_STRING) {
         put_str("<invalid:", F, S, flags & JV_PRINT_ISATTY);
         jvp_dump_string(msg, flags | JV_PRINT_ASCII, F, S, flags & JV_PRINT_ISATTY);
-        put_str(">", F, S, flags & JV_PRINT_ISATTY);
+        put_char('>', F, S, flags & JV_PRINT_ISATTY);
       } else {
         put_str("<invalid>", F, S, flags & JV_PRINT_ISATTY);
       }
@@ -229,16 +224,29 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
     put_str("true", F, S, flags & JV_PRINT_ISATTY);
     break;
   case JV_KIND_NUMBER: {
-    double d = jv_number_value(x);
-    if (d != d) {
-      // JSON doesn't have NaN, so we'll render it as "null"
-      put_str("null", F, S, flags & JV_PRINT_ISATTY);
+    if (jvp_number_is_nan(x)) {
+      jv_dump_term(C, jv_null(), flags, indent, F, S);
     } else {
-      // Normalise infinities to something we can print in valid JSON
-      if (d > DBL_MAX) d = DBL_MAX;
-      if (d < -DBL_MAX) d = -DBL_MAX;
-      put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY);
+#ifdef USE_DECNUM
+      const char * literal_data = jv_number_get_literal(x);
+      if (literal_data) {
+        put_str(literal_data, F, S, flags & JV_PRINT_ISATTY);
+      } else {
+#endif
+        double d = jv_number_value(x);
+        if (d != d) {
+          // JSON doesn't have NaN, so we'll render it as "null"
+          put_str("null", F, S, flags & JV_PRINT_ISATTY);
+        } else {
+          // Normalise infinities to something we can print in valid JSON
+          if (d > DBL_MAX) d = DBL_MAX;
+          if (d < -DBL_MAX) d = -DBL_MAX;
+          put_str(jvp_dtoa_fmt(C, buf, d), F, S, flags & JV_PRINT_ISATTY);
+        }
+      }
+#ifdef USE_DECNUM
     }
+#endif
     break;
   }
   case JV_KIND_STRING:
@@ -251,22 +259,18 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       put_str("[]", F, S, flags & JV_PRINT_ISATTY);
       break;
     }
-    put_str("[", F, S, flags & JV_PRINT_ISATTY);
-    if (flags & JV_PRINT_PRETTY) {
-      put_char('\n', F, S, flags & JV_PRINT_ISATTY);
-      put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
-    }
+    put_char('[', F, S, flags & JV_PRINT_ISATTY);
     jv_array_foreach(x, i, elem) {
       if (i!=0) {
-        if (flags & JV_PRINT_PRETTY) {
-          put_str(",\n", F, S, flags & JV_PRINT_ISATTY);
-          put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
-        } else {
-          put_str(",", F, S, flags & JV_PRINT_ISATTY);
-        }
+        if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
+        put_char(',', F, S, flags & JV_PRINT_ISATTY);
+      }
+      if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
+      if (flags & JV_PRINT_PRETTY) {
+        put_char('\n', F, S, flags & JV_PRINT_ISATTY);
+        put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
       }
       jv_dump_term(C, elem, flags, indent + 1, F, S);
-      if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
     }
     if (flags & JV_PRINT_PRETTY) {
       put_char('\n', F, S, flags & JV_PRINT_ISATTY);
@@ -284,10 +288,6 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       break;
     }
     put_char('{', F, S, flags & JV_PRINT_ISATTY);
-    if (flags & JV_PRINT_PRETTY) {
-      put_char('\n', F, S, flags & JV_PRINT_ISATTY);
-      put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
-    }
     int first = 1;
     int i = 0;
     jv keyset = jv_null();
@@ -318,14 +318,14 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       }
 
       if (!first) {
-        if (flags & JV_PRINT_PRETTY){
-          put_str(",\n", F, S, flags & JV_PRINT_ISATTY);
-          put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
-        } else {
-          put_str(",", F, S, flags & JV_PRINT_ISATTY);
-        }
+        if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
+        put_char(',', F, S, flags & JV_PRINT_ISATTY);
       }
       if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
+      if (flags & JV_PRINT_PRETTY) {
+        put_char('\n', F, S, flags & JV_PRINT_ISATTY);
+        put_indent(indent + 1, flags, F, S, flags & JV_PRINT_ISATTY);
+      }
 
       first = 0;
       if (color) put_str(FIELD_COLOR, F, S, flags & JV_PRINT_ISATTY);
@@ -334,11 +334,13 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
       if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
 
       if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
-      put_str((flags & JV_PRINT_PRETTY) ? ": " : ":", F, S, flags & JV_PRINT_ISATTY);
+      put_char(':', F, S, flags & JV_PRINT_ISATTY);
       if (color) put_str(COLRESET, F, S, flags & JV_PRINT_ISATTY);
+      if (flags & JV_PRINT_PRETTY) {
+        put_char(' ', F, S, flags & JV_PRINT_ISATTY);
+      }
 
       jv_dump_term(C, value, flags, indent + 1, F, S);
-      if (color) put_str(color, F, S, flags & JV_PRINT_ISATTY);
     }
     if (flags & JV_PRINT_PRETTY) {
       put_char('\n', F, S, flags & JV_PRINT_ISATTY);
@@ -357,10 +359,7 @@ static void jv_dump_term(struct dtoa_context* C, jv x, int flags, int indent, FI
 }
 
 void jv_dumpf(jv x, FILE *f, int flags) {
-  struct dtoa_context C;
-  jvp_dtoa_context_init(&C);
-  jv_dump_term(&C, x, flags, 0, f, 0);
-  jvp_dtoa_context_free(&C);
+  jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, f, 0);
 }
 
 void jv_dump(jv x, int flags) {
@@ -376,11 +375,8 @@ void jv_show(jv x, int flags) {
 }
 
 jv jv_dump_string(jv x, int flags) {
-  struct dtoa_context C;
-  jvp_dtoa_context_init(&C);
   jv s = jv_string("");
-  jv_dump_term(&C, x, flags, 0, 0, &s);
-  jvp_dtoa_context_free(&C);
+  jv_dump_term(tsd_dtoa_context_get(), x, flags, 0, 0, &s);
   return s;
 }
 

package/deps/jq/src/jv_private.h

@@ -0,0 +1,7 @@
+#ifndef JV_PRIVATE
+#define JV_PRIVATE
+
+int jvp_number_cmp(jv, jv);
+int jvp_number_is_nan(jv);
+
+#endif //JV_PRIVATE

package/deps/jq/src/jv_thread.h

@@ -0,0 +1,76 @@
+#ifndef JV_THREAD_H
+#define JV_THREAD_H
+
+#ifdef WIN32
+#ifndef __MINGW32__
+#include <windows.h>
+#include <winnt.h>
+#include <errno.h>
+
+/* Copied from Heimdal: pthread-like mutexes for WIN32 -- see lib/base/heimbase.h in Heimdal */
+typedef struct pthread_mutex {
+    HANDLE      h;
+} pthread_mutex_t;
+
+#define PTHREAD_MUTEX_INITIALIZER { INVALID_HANDLE_VALUE }
+
+static inline int
+pthread_mutex_init(pthread_mutex_t *m)
+{
+    m->h = CreateSemaphore(NULL, 1, 1, NULL);
+    if (m->h == INVALID_HANDLE_VALUE)
+        return EAGAIN;
+    return 0;
+}
+
+static inline int
+pthread_mutex_lock(pthread_mutex_t *m)
+{
+    HANDLE h, new_h;
+    int created = 0;
+
+    h = InterlockedCompareExchangePointer(&m->h, m->h, m->h);
+    if (h == INVALID_HANDLE_VALUE || h == NULL) {
+        created = 1;
+        new_h = CreateSemaphore(NULL, 0, 1, NULL);
+        if (new_h == INVALID_HANDLE_VALUE)
+            return EAGAIN;
+        if (InterlockedCompareExchangePointer(&m->h, new_h, h) != h) {
+            created = 0;
+            CloseHandle(new_h);
+        }
+    }
+    if (!created)
+        WaitForSingleObject(m->h, INFINITE);
+    return 0;
+}
+
+static inline int
+pthread_mutex_unlock(pthread_mutex_t *m)
+{
+    if (ReleaseSemaphore(m->h, 1, NULL) == FALSE)
+        return EPERM;
+    return 0;
+}
+static inline int
+pthread_mutex_destroy(pthread_mutex_t *m)
+{
+    HANDLE h;
+
+    h = InterlockedCompareExchangePointer(&m->h, INVALID_HANDLE_VALUE, m->h);
+    if (h != INVALID_HANDLE_VALUE)
+        CloseHandle(h);
+    return 0;
+}
+
+typedef unsigned long pthread_key_t;
+int pthread_key_create(pthread_key_t *, void (*)(void *));
+int pthread_setspecific(pthread_key_t, void *);
+void *pthread_getspecific(pthread_key_t);
+#else
+#include <pthread.h>
+#endif
+#else
+#include <pthread.h>
+#endif
+#endif /* JV_THREAD_H */

package/deps/jq/src/jv_unicode.c

@@ -118,3 +118,21 @@ int jvp_utf8_encode(int codepoint, char* out) {
   assert(out - start == jvp_utf8_encode_length(codepoint));
   return out - start;
 }
+
+// characters with White_Space property in:
+// https://www.unicode.org/Public/UCD/latest/ucd/PropList.txt
+int jvp_codepoint_is_whitespace(int c) {
+  return
+    (c >= 0x0009 && c <= 0x000D) || // <control-0009>..<control-000D>
+    c == 0x0020                  || // SPACE
+    c == 0x0085                  || // <control-0085>
+    c == 0x00A0                  || // NO-BREAK SPACE
+    c == 0x1680                  || // OGHAM SPACE MARK
+    (c >= 0x2000 && c <= 0x200A) || // EN QUAD..HAIR SPACE
+    c == 0x2028                  || // LINE SEPARATOR
+    c == 0x2029                  || // PARAGRAPH SEPARATOR
+    c == 0x202F                  || // NARROW NO-BREAK SPACE
+    c == 0x205F                  || // MEDIUM MATHEMATICAL SPACE
+    c == 0x3000                     // IDEOGRAPHIC SPACE
+    ;
+}

package/deps/jq/src/jv_unicode.h

@@ -9,4 +9,6 @@ int jvp_utf8_decode_length(char startchar);
 
 int jvp_utf8_encode_length(int codepoint);
 int jvp_utf8_encode(int codepoint, char* out);
+
+int jvp_codepoint_is_whitespace(int c);
 #endif