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

package/deps/jq/modules/oniguruma/sample/encode.c

@@ -31,9 +31,10 @@ search(regex_t* reg, unsigned char* str, unsigned char* end)
   }
   else { /* error */
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r);
+    onig_error_code_to_str((UChar* )s, r);
     fprintf(stderr, "ERROR: %s\n", s);
     fprintf(stderr, "  (%s)\n", ONIGENC_NAME(onig_get_encoding(reg)));
+    onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
     return -1;
   }
 
@@ -59,7 +60,7 @@ exec(OnigEncoding enc, OnigOptionType options,
                options, enc, ONIG_SYNTAX_DEFAULT, &einfo);
   if (r != ONIG_NORMAL) {
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r, &einfo);
+    onig_error_code_to_str((UChar* )s, r, &einfo);
     fprintf(stderr, "ERROR: %s\n", s);
     return -1;
   }
@@ -72,55 +73,6 @@ exec(OnigEncoding enc, OnigOptionType options,
   return 0;
 }
 
-static OnigCaseFoldType CF = ONIGENC_CASE_FOLD_MIN;
-
-#if 0
-static void
-set_case_fold(OnigCaseFoldType cf)
-{
-  CF = cf;
-}
-#endif
-
-static int
-exec_deluxe(OnigEncoding pattern_enc, OnigEncoding str_enc,
-            OnigOptionType options, char* apattern, char* astr)
-{
-  int r;
-  unsigned char *end;
-  regex_t* reg;
-  OnigCompileInfo ci;
-  OnigErrorInfo einfo;
-  UChar* pattern = (UChar* )apattern;
-  UChar* str     = (UChar* )astr;
-
-  onig_initialize(&str_enc, 1);
-
-  ci.num_of_elements = 5;
-  ci.pattern_enc = pattern_enc;
-  ci.target_enc  = str_enc;
-  ci.syntax      = ONIG_SYNTAX_DEFAULT;
-  ci.option      = options;
-  ci.case_fold_flag  = CF;
-
-  r = onig_new_deluxe(&reg, pattern,
-                      pattern + onigenc_str_bytelen_null(pattern_enc, pattern),
-                      &ci, &einfo);
-  if (r != ONIG_NORMAL) {
-    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r, &einfo);
-    fprintf(stderr, "ERROR: %s\n", s);
-    return -1;
-  }
-
-  end = str + onigenc_str_bytelen_null(str_enc, str);
-  r = search(reg, str, end);
-
-  onig_free(reg);
-  onig_end();
-  return 0;
-}
-
 extern int main(int argc, char* argv[])
 {
   int r;
@@ -129,55 +81,55 @@ extern int main(int argc, char* argv[])
   static unsigned char pattern[] = { 0xe7, 0xf6, 0xde, '\\', 'w', '+', 0x00 };
 
   r = exec(ONIG_ENCODING_SJIS, ONIG_OPTION_NONE,
-	   "^a\\p{Hiragana}c$", "a\202\274c");
+           "^a\\p{Hiragana}c$", "a\202\274c");
 
   r = exec(ONIG_ENCODING_EUC_JP, ONIG_OPTION_NONE,
-	   "^a\\p{Hiragana}c$", "a\244\276c");
+           "^a\\p{Hiragana}c$", "a\244\276c");
 
   r = exec(ONIG_ENCODING_CP1251, ONIG_OPTION_IGNORECASE,
-	   "aBc", " AbC");
+           "aBc", " AbC");
 
   r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
-	   " [a-c\337z] ", "  SS  ");
+           " [a-c\337z] ", "  SS  ");
   r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
-	   " [\330-\341] ", "  SS  ");
+           " [\330-\341] ", "  SS  ");
 
   r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
-	   "\337          ", "          Ss          ");
+           "\337          ", "          Ss          ");
   r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
-	   "SS          ", "          \337          ");
+           "SS          ", "          \337          ");
   r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
-	   "\\A\\S\\z", "ss");
+           "\\A\\S\\z", "ss");
 
   r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
 
   r = exec(ONIG_ENCODING_ISO_8859_3, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_4, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_5, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_6, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_7, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_8, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_9, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_10, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_11, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_13, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_14, ONIG_OPTION_IGNORECASE,
-	   "[ac]+", "bbbaAaCCC");
+           "[ac]+", "bbbaAaCCC");
   r = exec(ONIG_ENCODING_ISO_8859_15, ONIG_OPTION_IGNORECASE,
-	   (char* )pattern, (char* )str);
+           (char* )pattern, (char* )str);
   r = exec(ONIG_ENCODING_ISO_8859_16, ONIG_OPTION_IGNORECASE,
-	   (char* )pattern, (char* )str);
+           (char* )pattern, (char* )str);
 
   r = exec(ONIG_ENCODING_KOI8_R, ONIG_OPTION_NONE, "a+", "bbbaaaccc");
   r = exec(ONIG_ENCODING_EUC_TW, ONIG_OPTION_NONE, "b*a+?c+", "bbbaaaccc");
@@ -196,92 +148,50 @@ extern int main(int argc, char* argv[])
   r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
            "is", "iss");
 
-  r = exec_deluxe(ONIG_ENCODING_ASCII, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_NONE, "a+",
-                  "\000b\000a\000a\000a\000c\000c\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_ASCII, ONIG_ENCODING_UTF16_LE,
-                  ONIG_OPTION_NONE, "a+",
-                  "b\000a\000a\000a\000a\000c\000\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_LE,
-                  ONIG_OPTION_NONE,
-                  "\000b\000a\000a\000a\000c\000c\000\000",
-                  "x\000b\000a\000a\000a\000c\000c\000\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_ISO_8859_1, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-                  "\337", "\000S\000S\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_ISO_8859_1, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-                  "SS", "\000\337\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_ISO_8859_1, ONIG_ENCODING_UTF16_LE,
-                  ONIG_OPTION_IGNORECASE,
-                  "\337", "S\000S\000\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_ISO_8859_1, ONIG_ENCODING_UTF32_BE,
-                  ONIG_OPTION_IGNORECASE,
-                  "SS", "\000\000\000\337\000\000\000\000");
-
-  r = exec_deluxe(ONIG_ENCODING_ISO_8859_1, ONIG_ENCODING_UTF32_LE,
-                  ONIG_OPTION_IGNORECASE,
-                  "\337", "S\000\000\000S\000\000\000\000\000\000\000");
-
   r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_NONE,
-	   "\000[\000[\000:\000a\000l\000n\000u\000m\000:\000]\000]\000+\000\000",
+           "\000[\000[\000:\000a\000l\000n\000u\000m\000:\000]\000]\000+\000\000",
            "\000#\002\120\000a\000Z\012\077\012\076\012\075\000\000");
   /* 0x0a3d == \012\075 : is not alnum */
   /* 0x0a3e == \012\076 : is alnum */
 
   r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_NONE,
-	   "\000\\\000d\000+\000\000",
+           "\000\\\000d\000+\000\000",
            "\0003\0001\377\020\377\031\377\032\000\000");
 
   r = exec(ONIG_ENCODING_GB18030, ONIG_OPTION_IGNORECASE,
-	   "(Aa\\d)+", "BaA5Aa0234");
+           "(Aa\\d)+", "BaA5Aa0234");
 
-  r = exec_deluxe(ONIG_ENCODING_ISO_8859_1, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_NONE,
-		  "^\\P{Hiragana}\\p{^Hiragana}(\\p{Hiragana}+)$",
-		  "\060\100\060\240\060\101\060\102\060\226\060\237\000\000");
+  r = exec(ONIG_ENCODING_GB18030, ONIG_OPTION_NONE,
+           "[[^\\w]]+[^\xee\xef]\xee\xef", "[[^\\w]]+[^\xee\xef]\xee\xef");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\000[\000\337\000]\000\000", "\000S\000S\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\000[\000\337\000]\000\000", "\000S\000S\000\000");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\000[\000\337\000]\000\000", "\000s\000S\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\000[\000\337\000]\000\000", "\000s\000S\000\000");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\000^\000[\000\001\000-\377\375\000]\000$\000\000",
-		  "\000s\000S\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\000^\000[\000\001\000-\377\375\000]\000$\000\000",
+           "\000s\000S\000\000");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\000S\000S\000\000",
-		  "\000S\000T\000\337\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\000S\000S\000\000",
+           "\000S\000T\000\337\000\000");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\000S\000T\000S\000S\000\000",
-		  "\000S\000t\000s\000S\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\000S\000T\000S\000S\000\000",
+           "\000S\000t\000s\000S\000\000");
 
   {
     UChar pat[]  = { 0x1f, 0xfc, 0x00, 0x00 };
     UChar str1[] = { 0x21, 0x26, 0x1f, 0xbe, 0x00, 0x00 };
     UChar str2[] = { 0x1f, 0xf3, 0x00, 0x00 };
 
-    r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-		    ONIG_OPTION_IGNORECASE,
-		    (char* )pat, (char* )str1);
+    r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+             (char* )pat, (char* )str1);
 
-    r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-		    ONIG_OPTION_IGNORECASE,
-		    (char* )pat, (char* )str2);
+    r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+             (char* )pat, (char* )str2);
   }
 
 #if 0
@@ -289,17 +199,14 @@ extern int main(int argc, char* argv[])
 
   set_case_fold(ONIGENC_CASE_FOLD_TURKISH_AZERI);
 
-  r = exec_deluxe(ONIG_ENCODING_UTF8, ONIG_ENCODING_UTF8,
-                  ONIG_OPTION_IGNORECASE,
-		  "Ii", "\304\261\304\260");
+  r = exec(ONIG_ENCODING_UTF8, ONIG_ENCODING_UTF8, ONIG_OPTION_IGNORECASE,
+           "Ii", "\304\261\304\260");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\000I\000i\000\000", "\001\061\001\060\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\000I\000i\000\000", "\001\061\001\060\000\000");
 
-  r = exec_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
-                  ONIG_OPTION_IGNORECASE,
-		  "\001\061\001\060\000\000", "\000I\000i\000\000");
+  r = exec(ONIG_ENCODING_UTF16_BE, ONIG_OPTION_IGNORECASE,
+           "\001\061\001\060\000\000", "\000I\000i\000\000");
 
   set_case_fold(ONIGENC_CASE_FOLD_MIN);
 #endif

package/deps/jq/modules/oniguruma/sample/listcap.c

@@ -24,7 +24,7 @@ node_callback(int group, int beg, int end, int level, int at, void* arg)
 }
 
 extern int ex(unsigned char* str, unsigned char* pattern,
-              OnigSyntaxType* syntax)
+              OnigSyntaxType* syntax, OnigOptionType options)
 {
   int r;
   unsigned char *start, *range, *end;
@@ -33,10 +33,10 @@ extern int ex(unsigned char* str, unsigned char* pattern,
   OnigRegion *region;
 
   r = onig_new(&reg, pattern, pattern + strlen((char* )pattern),
-	       ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, syntax, &einfo);
+               options, ONIG_ENCODING_ASCII, syntax, &einfo);
   if (r != ONIG_NORMAL) {
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r, &einfo);
+    onig_error_code_to_str((UChar* )s, r, &einfo);
     fprintf(stderr, "ERROR: %s\n", s);
     return -1;
   }
@@ -68,7 +68,9 @@ extern int ex(unsigned char* str, unsigned char* pattern,
   }
   else { /* error */
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r);
+    onig_error_code_to_str((UChar* )s, r);
+    onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+    onig_free(reg);
     return -1;
   }
 
@@ -82,6 +84,7 @@ extern int main(int argc, char* argv[])
 {
   int r;
   OnigSyntaxType syn;
+  OnigEncoding use_encs[1];
 
   static UChar* str1 = (UChar* )"((())())";
   static UChar* pattern1
@@ -93,17 +96,22 @@ extern int main(int argc, char* argv[])
   static UChar* str3     = (UChar* )"0123";
   static UChar* pattern3 = (UChar* )"(?@.)(?@.)(?@.)(?@.)";
 
-  OnigEncoding use_encs[] = { ONIG_ENCODING_ASCII };
+  static UChar* str4 = (UChar* )"(((a))(a)) ((((a))(a)))";
+  static UChar* pattern4
+    = (UChar* )"\\g<p>(?@<p>\\(\\g<s>\\)){0}(?@<s>(?:\\g<p>)*|a){0}";
+
+  use_encs[0] = ONIG_ENCODING_ASCII;
   onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));
 
- /* enable capture hostory */
+ /* enable capture history */
   onig_copy_syntax(&syn, ONIG_SYNTAX_DEFAULT);
-  onig_set_syntax_op2(&syn, 
+  onig_set_syntax_op2(&syn,
        onig_get_syntax_op2(&syn) | ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY);
 
-  r = ex(str1, pattern1, &syn);
-  r = ex(str2, pattern2, &syn);
-  r = ex(str3, pattern3, &syn);
+  r = ex(str1, pattern1, &syn, ONIG_OPTION_NONE);
+  r = ex(str2, pattern2, &syn, ONIG_OPTION_NONE);
+  r = ex(str3, pattern3, &syn, ONIG_OPTION_NONE);
+  r = ex(str4, pattern4, &syn, ONIG_OPTION_FIND_LONGEST);
 
   onig_end();
   return r;

package/deps/jq/modules/oniguruma/sample/names.c

@@ -7,8 +7,8 @@
 
 static int
 name_callback(const UChar* name, const UChar* name_end,
-	      int ngroup_num, int* group_nums,
-	      regex_t* reg, void* arg)
+              int ngroup_num, int* group_nums,
+              regex_t* reg, void* arg)
 {
   int i, gn, ref;
   char* s;
@@ -31,18 +31,19 @@ extern int main(int argc, char* argv[])
   regex_t* reg;
   OnigErrorInfo einfo;
   OnigRegion *region;
+  OnigEncoding use_encs[1];
 
   static UChar* pattern = (UChar* )"(?<foo>a*)(?<bar>b*)(?<foo>c*)";
   static UChar* str = (UChar* )"aaabbbbcc";
 
-  OnigEncoding use_encs[] = { ONIG_ENCODING_ASCII };
+  use_encs[0] = ONIG_ENCODING_ASCII;
   onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));
 
   r = onig_new(&reg, pattern, pattern + strlen((char* )pattern),
-	ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
+        ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
   if (r != ONIG_NORMAL) {
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r, &einfo);
+    onig_error_code_to_str((UChar* )s, r, &einfo);
     fprintf(stderr, "ERROR: %s\n", s);
     return -1;
   }
@@ -64,7 +65,10 @@ extern int main(int argc, char* argv[])
   }
   else { /* error */
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r);
+    onig_error_code_to_str((UChar* )s, r);
+    onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+    onig_free(reg);
+    onig_end();
     return -1;
   }
 

package/deps/jq/modules/oniguruma/sample/posix.c

@@ -16,6 +16,7 @@ static int x(regex_t* reg, unsigned char* pattern, unsigned char* str)
   if (r != 0 && r != REG_NOMATCH) {
     regerror(r, reg, buf, sizeof(buf));
     fprintf(stderr, "ERROR: %s\n", buf);
+    regfree(reg);
     return -1;
   }
 
@@ -28,6 +29,7 @@ static int x(regex_t* reg, unsigned char* pattern, unsigned char* str)
       fprintf(stderr, "%d: %d-%d\n", i, pmatch[i].rm_so, pmatch[i].rm_eo);
     }
   }
+  regfree(reg);
   return 0;
 }
 
@@ -40,12 +42,14 @@ extern int main(int argc, char* argv[])
 
   reg_set_encoding(REG_POSIX_ENCODING_ASCII);
 
-  /* default syntax (ONIG_SYNTAX_RUBY) */
+  /* default syntax (ONIG_SYNTAX_ONIGURUMA) */
   pattern = (UChar* )"^a+b{2,7}[c-f]?$|uuu";
   r = regcomp(&reg, (char* )pattern, REG_EXTENDED);
   if (r) {
     regerror(r, &reg, buf, sizeof(buf));
     fprintf(stderr, "ERROR: %s\n", buf);
+    regfree(&reg);
+    onig_end();
     return -1;
   }
   x(&reg, pattern, (UChar* )"aaabbbbd");
@@ -56,6 +60,8 @@ extern int main(int argc, char* argv[])
   if (r) {
     regerror(r, &reg, buf, sizeof(buf));
     fprintf(stderr, "ERROR: %s\n", buf);
+    regfree(&reg);
+    onig_end();
     return -1;
   }
   x(&reg, pattern, (UChar* )"a+b{2,7}d?|uuu");
@@ -66,6 +72,8 @@ extern int main(int argc, char* argv[])
   if (r) {
     regerror(r, &reg, buf, sizeof(buf));
     fprintf(stderr, "ERROR: %s\n", buf);
+    regfree(&reg);
+    onig_end();
     return -1;
   }
   x(&reg, pattern, (UChar* )"aaaabbbbbbd");
@@ -77,6 +85,8 @@ extern int main(int argc, char* argv[])
   if (r) {
     regerror(r, &reg, buf, sizeof(buf));
     fprintf(stderr, "ERROR: %s\n", buf);
+    regfree(&reg);
+    onig_end();
     return -1;
   }
   x(&reg, pattern, (UChar* )"aaabbbbd)");
@@ -86,11 +96,12 @@ extern int main(int argc, char* argv[])
   if (r) {
     regerror(r, &reg, buf, sizeof(buf));
     fprintf(stderr, "ERROR: %s\n", buf);
+    regfree(&reg);
+    onig_end();
     return -1;
   }
   x(&reg, pattern, (UChar* )"a\nb\n");
 
-  regfree(&reg);
   onig_end();
   return 0;
 }

package/deps/jq/modules/oniguruma/sample/regset.c

@@ -0,0 +1,95 @@
+/*
+ * regset.c
+ */
+#include <stdio.h>
+#include <string.h>
+#include "oniguruma.h"
+
+extern int main(int argc, char* argv[])
+{
+  int r;
+  int i, n;
+  int match_pos;
+  unsigned char *start, *range, *end;
+  OnigRegSet* set;
+  OnigRegSetLead lead;
+  regex_t* reg;
+  OnigErrorInfo einfo;
+  char ebuf[ONIG_MAX_ERROR_MESSAGE_LEN];
+  OnigEncoding use_encs[1];
+
+  static UChar* str = (UChar* )"aaaaaaaaaaaaaaaaaaaaaaca";
+
+  static char* pat[] = {
+    "a(.*)b|a(.)c",
+    "^(abc)",
+    "a(.....)c"
+  };
+
+  use_encs[0] = ONIG_ENCODING_UTF8;
+  onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));
+
+  r = onig_regset_new(&set, 0, NULL);
+  if (r != ONIG_NORMAL) {
+    onig_error_code_to_str((UChar* )ebuf, r);
+    fprintf(stderr, "ERROR: %s\n", ebuf);
+    onig_end();
+    return -1;
+  }
+
+  n = sizeof(pat) / sizeof(pat[0]);
+
+  for (i = 0; i < n; i++) {
+    r = onig_new(&reg, (UChar* )pat[i], (UChar* )(pat[i] + strlen(pat[i])),
+                 ONIG_OPTION_DEFAULT, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT,
+                 &einfo);
+    if (r != ONIG_NORMAL) {
+      onig_error_code_to_str((UChar* )ebuf, r, &einfo);
+      fprintf(stderr, "ERROR: %s\n", ebuf);
+      onig_regset_free(set);
+      onig_end();
+      return -1;
+    }
+
+    r = onig_regset_add(set, reg);
+    if (r != ONIG_NORMAL) {
+      onig_free(reg);
+      onig_regset_free(set);
+      onig_end();
+      return -1;
+    }
+  }
+
+  end   = str + strlen((char* )str);
+  start = str;
+  range = end;
+  lead = ONIG_REGSET_POSITION_LEAD;
+  //lead = ONIG_REGSET_PRIORITY_TO_REGEX_ORDER;
+  r = onig_regset_search(set, str, end, start, range, lead, ONIG_OPTION_NONE,
+                         &match_pos);
+  if (r >= 0) {
+    OnigRegion *region;
+
+    fprintf(stderr, "match regex index: %d\n", r);
+    fprintf(stderr, "match position: %d\n", match_pos);
+
+    region = onig_regset_get_region(set, r);
+    for (i = 0; i < region->num_regs; i++) {
+      fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]);
+    }
+  }
+  else if (r == ONIG_MISMATCH) {
+    fprintf(stderr, "search fail\n");
+  }
+  else { /* error */
+    onig_error_code_to_str((UChar* )ebuf, r);
+    fprintf(stderr, "ERROR: %s\n", ebuf);
+    onig_regset_free(set);
+    onig_end();
+    return -1;
+  }
+
+  onig_regset_free(set);
+  onig_end();
+  return 0;
+}

package/deps/jq/modules/oniguruma/sample/scan.c

@@ -21,14 +21,14 @@ scan_callback(int n, int r, OnigRegion* region, void* arg)
 }
 
 static int
-scan(regex_t* reg, unsigned char* str, unsigned char* end)
+scan(regex_t* reg, OnigOptionType options, unsigned char* str, unsigned char* end)
 {
   int r;
   OnigRegion *region;
 
   region = onig_region_new();
 
-  r = onig_scan(reg, str, end, region, ONIG_OPTION_NONE, scan_callback, NULL);
+  r = onig_scan(reg, str, end, region, options, scan_callback, NULL);
   if (r >= 0) {
     fprintf(stdout, "total: %d match\n", r);
   }
@@ -36,6 +36,7 @@ scan(regex_t* reg, unsigned char* str, unsigned char* end)
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
     onig_error_code_to_str((OnigUChar* )s, r);
     fprintf(stderr, "ERROR: %s\n", s);
+    onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
     return -1;
   }
 
@@ -44,7 +45,7 @@ scan(regex_t* reg, unsigned char* str, unsigned char* end)
 }
 
 static int
-exec(OnigEncoding enc, OnigOptionType options, char* apattern, char* astr)
+exec(OnigEncoding enc, OnigOptionType options, OnigOptionType runtime_options, char* apattern, char* astr)
 {
   int r;
   unsigned char *end;
@@ -63,11 +64,12 @@ exec(OnigEncoding enc, OnigOptionType options, char* apattern, char* astr)
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
     onig_error_code_to_str((OnigUChar* )s, r, &einfo);
     fprintf(stderr, "ERROR: %s\n", s);
+    onig_end();
     return -1;
   }
 
   end = str + onigenc_str_bytelen_null(enc, str);
-  r = scan(reg, str, end);
+  r = scan(reg, runtime_options, str, end);
 
   onig_free(reg);
   onig_end();
@@ -77,11 +79,23 @@ exec(OnigEncoding enc, OnigOptionType options, char* apattern, char* astr)
 
 extern int main(int argc, char* argv[])
 {
-  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE,
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, ONIG_OPTION_NONE,
        "\\Ga+\\s*", "a aa aaa baaa");
+  fprintf(stdout, "\n");
+
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, ONIG_OPTION_NOT_BEGIN_POSITION,
+       "\\Ga+\\s*", "a aa aaa baaa");
+  fprintf(stdout, "\n");
 
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, ONIG_OPTION_NONE,
+       "(?!\\G)a+\\s*", "a aa aaa baaa");
   fprintf(stdout, "\n");
-  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE,
+
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, ONIG_OPTION_NOT_BEGIN_POSITION,
+       "(?!\\G)a+\\s*", "a aa aaa baaa");
+  fprintf(stdout, "\n");
+
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE, ONIG_OPTION_NONE,
        "a+\\s*", "a aa aaa baaa");
 
   return 0;

package/deps/jq/modules/oniguruma/sample/simple.c

@@ -12,18 +12,19 @@ extern int main(int argc, char* argv[])
   regex_t* reg;
   OnigErrorInfo einfo;
   OnigRegion *region;
+  OnigEncoding use_encs[1];
 
   static UChar* pattern = (UChar* )"a(.*)b|[e-f]+";
   static UChar* str     = (UChar* )"zzzzaffffffffb";
 
-  OnigEncoding use_encs[] = { ONIG_ENCODING_ASCII };
+  use_encs[0] = ONIG_ENCODING_ASCII;
   onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));
 
   r = onig_new(&reg, pattern, pattern + strlen((char* )pattern),
-	ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
+        ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, ONIG_SYNTAX_DEFAULT, &einfo);
   if (r != ONIG_NORMAL) {
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r, &einfo);
+    onig_error_code_to_str((UChar* )s, r, &einfo);
     fprintf(stderr, "ERROR: %s\n", s);
     return -1;
   }
@@ -47,8 +48,11 @@ extern int main(int argc, char* argv[])
   }
   else { /* error */
     char s[ONIG_MAX_ERROR_MESSAGE_LEN];
-    onig_error_code_to_str(s, r);
+    onig_error_code_to_str((UChar* )s, r);
     fprintf(stderr, "ERROR: %s\n", s);
+    onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+    onig_free(reg);
+    onig_end();
     return -1;
   }