@port-labs/jq-node-bindings 0.0.4 → 0.0.6

package/deps/jq/{parser.h → src/parser.h}

@@ -1,8 +1,8 @@
-/* A Bison parser, made by GNU Bison 3.0.2.  */
+/* A Bison parser, made by GNU Bison 3.0.4.  */
 
 /* Bison interface for Yacc-like parsers in C
 
-   Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -30,8 +30,8 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
-#ifndef YY_YY_PARSER_H_INCLUDED
-# define YY_YY_PARSER_H_INCLUDED
+#ifndef YY_YY_SRC_PARSER_H_INCLUDED
+# define YY_YY_SRC_PARSER_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 0
@@ -40,7 +40,7 @@
 extern int yydebug;
 #endif
 /* "%code requires" blocks.  */
-#line 11 "parser.y" /* yacc.c:1909  */
+#line 11 "src/parser.y" /* yacc.c:1909  */
 
 #include "locfile.h"
 struct lexer_param;
@@ -57,7 +57,7 @@ struct lexer_param;
     }                                           \
   } while (0)
 
-#line 61 "parser.h" /* yacc.c:1909  */
+#line 61 "src/parser.h" /* yacc.c:1909  */
 
 /* Token type.  */
 #ifndef YYTOKENTYPE
@@ -101,13 +101,14 @@ struct lexer_param;
     SETDEFINEDOR = 292,
     LESSEQ = 293,
     GREATEREQ = 294,
-    QQSTRING_START = 295,
-    QQSTRING_TEXT = 296,
-    QQSTRING_INTERP_START = 297,
-    QQSTRING_INTERP_END = 298,
-    QQSTRING_END = 299,
-    FUNCDEF = 300,
-    NONOPT = 301
+    ALTERNATION = 295,
+    QQSTRING_START = 296,
+    QQSTRING_TEXT = 297,
+    QQSTRING_INTERP_START = 298,
+    QQSTRING_INTERP_END = 299,
+    QQSTRING_END = 300,
+    FUNCDEF = 301,
+    NONOPT = 302
   };
 #endif
 /* Tokens.  */
@@ -148,26 +149,29 @@ struct lexer_param;
 #define SETDEFINEDOR 292
 #define LESSEQ 293
 #define GREATEREQ 294
-#define QQSTRING_START 295
-#define QQSTRING_TEXT 296
-#define QQSTRING_INTERP_START 297
-#define QQSTRING_INTERP_END 298
-#define QQSTRING_END 299
-#define FUNCDEF 300
-#define NONOPT 301
+#define ALTERNATION 295
+#define QQSTRING_START 296
+#define QQSTRING_TEXT 297
+#define QQSTRING_INTERP_START 298
+#define QQSTRING_INTERP_END 299
+#define QQSTRING_END 300
+#define FUNCDEF 301
+#define NONOPT 302
 
 /* Value type.  */
 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
-typedef union YYSTYPE YYSTYPE;
+
 union YYSTYPE
 {
-#line 31 "parser.y" /* yacc.c:1909  */
+#line 31 "src/parser.y" /* yacc.c:1909  */
 
   jv literal;
   block blk;
 
-#line 170 "parser.h" /* yacc.c:1909  */
+#line 172 "src/parser.h" /* yacc.c:1909  */
 };
+
+typedef union YYSTYPE YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define YYSTYPE_IS_DECLARED 1
 #endif
@@ -190,4 +194,4 @@ struct YYLTYPE
 
 int yyparse (block* answer, int* errors, struct locfile* locations, struct lexer_param* lexer_param_ptr);
 
-#endif /* !YY_YY_PARSER_H_INCLUDED  */
+#endif /* !YY_YY_SRC_PARSER_H_INCLUDED  */

package/deps/jq/{parser.y → src/parser.y}

@@ -83,6 +83,7 @@ struct lexer_param;
 %token SETDEFINEDOR "//="
 %token LESSEQ "<="
 %token GREATEREQ ">="
+%token ALTERNATION "?//"
 
 %token QQSTRING_START
 %token <literal> QQSTRING_TEXT
@@ -111,9 +112,14 @@ struct lexer_param;
 %precedence "catch"
 
 
-%type <blk> Exp Term MkDict MkDictPair ExpD ElseBody QQString
-%type <blk> FuncDef FuncDefs String Import Imports Param Params
-%type <blk> Arg Args Module Pattern ArrayPats ObjPats ObjPat
+%type <blk> Exp Term
+%type <blk> MkDict MkDictPair ExpD
+%type <blk> ElseBody
+%type <blk> String QQString
+%type <blk> FuncDef FuncDefs
+%type <blk> Module Import Imports ImportWhat ImportFrom
+%type <blk> Param Params Arg Args
+%type <blk> Patterns RepPatterns Pattern ArrayPats ObjPats ObjPat
 %type <literal> Keyword
 %{
 #include "lexer.h"
@@ -159,8 +165,16 @@ int yylex(YYSTYPE* yylval, YYLTYPE* yylloc, block* answer, int* errors,
   return tok;
 }
 
-static block gen_dictpair(block k, block v) {
-  return BLOCK(gen_subexp(k), gen_subexp(v), gen_op_simple(INSERT));
+/* Returns string message if the block is a constant that is not valid as an
+ * object key. */
+static jv check_object_key(block k) {
+  if (block_is_const(k) && block_const_kind(k) != JV_KIND_STRING) {
+    char errbuf[15];
+    return jv_string_fmt("Cannot use %s (%s) as object key",
+        jv_kind_name(block_const_kind(k)),
+        jv_dump_string_trunc(jv_copy(block_const(k)), errbuf, sizeof(errbuf)));
+  }
+  return jv_invalid();
 }
 
 static block gen_index(block obj, block key) {
@@ -186,6 +200,16 @@ static block constant_fold(block a, block b, int op) {
   if (!block_is_single(a) || !block_is_const(a) ||
       !block_is_single(b) || !block_is_const(b))
     return gen_noop();
+  if (op == '+') {
+    if (block_const_kind(a) == JV_KIND_NULL) {
+      block_free(a);
+      return b;
+    }
+    if (block_const_kind(b) == JV_KIND_NULL) {
+      block_free(b);
+      return a;
+    }
+  }
   if (block_const_kind(a) != block_const_kind(b))
     return gen_noop();
 
@@ -246,7 +270,7 @@ static block gen_binop(block a, block b, int op) {
 }
 
 static block gen_format(block a, jv fmt) {
-  return BLOCK(a, gen_call("format", BLOCK(gen_lambda(gen_const(fmt)))));
+  return BLOCK(a, gen_call("format", gen_lambda(gen_const(fmt))));
 }
 
 static block gen_definedor_assign(block object, block val) {
@@ -286,8 +310,9 @@ Module:
 } |
 "module" Exp ';' {
   if (!block_is_const($2)) {
-    FAIL(@$, "Module metadata must be constant.");
+    FAIL(@$, "Module metadata must be constant");
     $$ = gen_noop();
+    block_free($2);
   } else {
     $$ = gen_module($2);
   }
@@ -314,19 +339,18 @@ FuncDef Exp %prec FUNCDEF {
   $$ = block_bind_referenced($1, $2, OP_IS_CALL_PSEUDO);
 } |
 
-Term "as" Pattern '|' Exp {
+Term "as" Patterns '|' Exp {
   $$ = gen_destructure($1, $3, $5);
 } |
-
-"reduce" Term "as" Pattern '(' Exp ';' Exp ')' {
+"reduce" Term "as" Patterns '(' Exp ';' Exp ')' {
   $$ = gen_reduce($2, $4, $6, $8);
 } |
 
-"foreach" Term "as" Pattern '(' Exp ';' Exp ';' Exp ')' {
+"foreach" Term "as" Patterns '(' Exp ';' Exp ';' Exp ')' {
   $$ = gen_foreach($2, $4, $6, $8, $10);
 } |
 
-"foreach" Term "as" Pattern '(' Exp ';' Exp ')' {
+"foreach" Term "as" Patterns '(' Exp ';' Exp ')' {
   $$ = gen_foreach($2, $4, $6, $8, gen_noop());
 } |
 
@@ -471,62 +495,58 @@ Term {
 }
 
 Import:
-"import" String "as" '$' IDENT ';' {
+ImportWhat ';' {
+  $$ = $1;
+} |
+ImportWhat Exp ';' {
+  if (!block_is_const($2)) {
+    FAIL(@$, "Module metadata must be constant");
+    $$ = gen_noop();
+    block_free($1);
+    block_free($2);
+  } else if (block_const_kind($2) != JV_KIND_OBJECT) {
+    FAIL(@$, "Module metadata must be an object");
+    $$ = gen_noop();
+    block_free($1);
+    block_free($2);
+  } else {
+    $$ = gen_import_meta($1, $2);
+  }
+}
+
+ImportWhat:
+"import" ImportFrom "as" '$' IDENT {
   jv v = block_const($2);
   // XXX Make gen_import take only blocks and the int is_data so we
   // don't have to free so much stuff here
-  $$ = gen_import(jv_string_value(v), gen_noop(), jv_string_value($5), 1);
+  $$ = gen_import(jv_string_value(v), jv_string_value($5), 1);
   block_free($2);
   jv_free($5);
   jv_free(v);
 } |
-"import" String "as" IDENT ';' {
+"import" ImportFrom "as" IDENT {
   jv v = block_const($2);
-  $$ = gen_import(jv_string_value(v), gen_noop(), jv_string_value($4), 0);
+  $$ = gen_import(jv_string_value(v), jv_string_value($4), 0);
   block_free($2);
   jv_free($4);
   jv_free(v);
 } |
-"include" String ';' {
+"include" ImportFrom {
   jv v = block_const($2);
-  $$ = gen_import(jv_string_value(v), gen_noop(), NULL, 0);
+  $$ = gen_import(jv_string_value(v), NULL, 0);
   block_free($2);
   jv_free(v);
-} |
-"import" String "as" IDENT Exp ';' {
-  if (!block_is_const($5)) {
-    FAIL(@$, "Module metadata must be constant.");
-    $$ = gen_noop();
-  } else {
-    jv v = block_const($2);
-    $$ = gen_import(jv_string_value(v), $5, jv_string_value($4), 0);
-    jv_free(v);
-  }
-  block_free($2);
-  jv_free($4);
-} |
-"include" String Exp ';' {
-  if (!block_is_const($3)) {
-    FAIL(@$, "Module metadata must be constant.");
-    $$ = gen_noop();
-  } else {
-    jv v = block_const($2);
-    $$ = gen_import(jv_string_value(v), $3, NULL, 0);
-    jv_free(v);
-  }
-  block_free($2);
-} |
-"import" String "as" '$' IDENT Exp ';' {
-  if (!block_is_const($6)) {
-    FAIL(@$, "Module metadata must be constant.");
-    $$ = gen_noop();
+}
+
+ImportFrom:
+String {
+  if (!block_is_const($1)) {
+    FAIL(@$, "Import path must be constant");
+    $$ = gen_const(jv_string(""));
+    block_free($1);
   } else {
-    jv v = block_const($2);
-    $$ = gen_import(jv_string_value(v), $6, jv_string_value($5), 1);
-    jv_free(v);
+    $$ = $1;
   }
-  block_free($2);
-  jv_free($5);
 }
 
 FuncDef:
@@ -754,6 +774,22 @@ Exp {
   $$ = gen_lambda($1);
 }
 
+RepPatterns:
+RepPatterns "?//" Pattern {
+  $$ = BLOCK($1, gen_destructure_alt($3));
+} |
+Pattern {
+  $$ = gen_destructure_alt($1);
+}
+
+Patterns:
+RepPatterns "?//" Pattern {
+  $$ = BLOCK($1, $3);
+} |
+Pattern {
+  $$ = $1;
+}
+
 Pattern:
 '$' IDENT {
   $$ = gen_op_unbound(STOREV, jv_string_value($2));
@@ -786,6 +822,9 @@ ObjPat:
 '$' IDENT {
   $$ = gen_object_matcher(gen_const($2), gen_op_unbound(STOREV, jv_string_value($2)));
 } |
+'$' IDENT ':' Pattern {
+  $$ = gen_object_matcher(gen_const($2), BLOCK(gen_op_simple(DUP), gen_op_unbound(STOREV, jv_string_value($2)), $4));
+} |
 IDENT ':' Pattern {
   $$ = gen_object_matcher(gen_const($1), $3);
 } |
@@ -796,7 +835,16 @@ String ':' Pattern {
   $$ = gen_object_matcher($1, $3);
 } |
 '(' Exp ')' ':' Pattern {
+  jv msg = check_object_key($2);
+  if (jv_is_valid(msg)) {
+    FAIL(@$, jv_string_value(msg));
+  }
+  jv_free(msg);
   $$ = gen_object_matcher($2, $5);
+} |
+error ':' Pattern {
+  FAIL(@$, "May need parentheses around object key expression");
+  $$ = $3;
 }
 
 Keyword:
@@ -889,9 +937,17 @@ IDENT ':' ExpD {
                     gen_index(gen_noop(), gen_const($1)));
   }
 | '(' Exp ')' ':' ExpD {
+  jv msg = check_object_key($2);
+  if (jv_is_valid(msg)) {
+    FAIL(@$, jv_string_value(msg));
+  }
+  jv_free(msg);
   $$ = gen_dictpair($2, $5);
   }
-| '(' error ')' ':' ExpD { $$ = $5; }
+| error ':' ExpD {
+  FAIL(@$, "May need parentheses around object key expression");
+  $$ = $3;
+  }
 %%
 
 int jq_parse(struct locfile* locations, block* answer) {

package/deps/jq/{util.c → src/util.c}

@@ -47,12 +47,12 @@ void *alloca (size_t);
 
 #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);
+  size_t sz = sizeof(wchar_t) * MultiByteToWideChar(CP_UTF8, 0, fname, -1, NULL, 0);
+  wchar_t *wfname = alloca(sz + 2); // +2 is not needed, but just in case
   MultiByteToWideChar(CP_UTF8, 0, fname, -1, wfname, sz);
 
-  sz = MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0);
-  wchar_t *wmode = alloca(sz);
+  sz = sizeof(wchar_t) * MultiByteToWideChar(CP_UTF8, 0, mode, -1, NULL, 0);
+  wchar_t *wmode = alloca(sz + 2); // +2 is not needed, but just in case
   MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, sz);
   return _wfopen(wfname, wmode);
 }
@@ -139,7 +139,7 @@ jv jq_realpath(jv path) {
   path_max = PATH_MAX;
 #endif
   if (path_max > 0) {
-     buf = malloc(sizeof(char) * path_max);
+     buf = jv_mem_alloc(path_max);
   }
 #ifdef WIN32
   char *tmp = _fullpath(buf, jv_string_value(path), path_max);
@@ -410,6 +410,7 @@ jv jq_util_input_get_current_line(jq_state* jq) {
 // When slurping, it returns just one value
 jv jq_util_input_next_input(jq_util_input_state *state) {
   int is_last = 0;
+  int has_more = 0;
   jv value = jv_invalid(); // need more input
   do {
     if (state->parser == NULL) {
@@ -435,14 +436,16 @@ jv jq_util_input_next_input(jq_util_input_state *state) {
     } else {
       if (jv_parser_remaining(state->parser) == 0) {
         is_last = jq_util_input_read_more(state);
-        if (is_last && state->buf_valid_len == 0) {
+        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)) {
+        // When slurping an input that doesn't have a trailing newline,
+        // we might have more than one value on the same line, so let's check
+        // to see if we have more data to parse.
+        has_more = jv_parser_remaining(state->parser);
         if (jv_is_valid(value)) {
           state->slurped = jv_array_append(state->slurped, value);
           value = jv_invalid();
@@ -452,7 +455,7 @@ jv jq_util_input_next_input(jq_util_input_state *state) {
         return value;
       }
     }
-  } while (!is_last);
+  } while (!is_last || has_more);
 
   if (jv_is_valid(state->slurped)) {
     value = state->slurped;

package/deps/jq/tests/base64.test

@@ -0,0 +1,35 @@
+# Tests are groups of three lines: program, input, expected output
+# Blank lines and lines starting with # are ignored
+
+@base64
+"<>&'\"\t"
+"PD4mJyIJ"
+
+# decoding encoded output results in same text
+(@base64|@base64d)
+"<>&'\"\t"
+"<>&'\"\t"
+
+# regression test for #436
+@base64
+"foóbar\n"
+"Zm/Ds2Jhcgo="
+
+@base64d
+"Zm/Ds2Jhcgo="
+"foóbar\n"
+
+# optional trailing equals padding (With padding, this is cWl4YmF6Cg==)
+@base64d
+"cWl4YmF6Cg"
+"qixbaz\n"
+
+# invalid base64 characters (whitespace)
+. | try @base64d catch .
+"Not base64 data"
+"string (\"Not base64...) is not valid base64 data"
+
+# invalid base64 (too many bytes, QUJD = "ABCD"
+. | try @base64d catch .
+"QUJDa"
+"string (\"QUJDa\") trailing base64 byte found"

package/deps/jq/tests/base64test

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+. "${0%/*}/setup" "$@"
+
+$VALGRIND $Q $JQ -L "$mods" --run-tests $JQTESTDIR/base64.test

package/deps/jq/tests/jq-f-test.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+# this next line is ignored by jq, which otherwise does not continue comments \
+exec jq -nef "$0" "$@"
+true