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

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

@@ -0,0 +1,308 @@
+/*
+ * encode.c
+ */
+#include <stdio.h>
+#include "oniguruma.h"
+
+static int
+search(regex_t* reg, unsigned char* str, unsigned char* end)
+{
+  int r;
+  unsigned char *start, *range;
+  OnigRegion *region;
+
+  region = onig_region_new();
+
+  start = str;
+  range = end;
+  r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
+  if (r >= 0) {
+    int i;
+
+    fprintf(stderr, "match at %d  (%s)\n", r,
+            ONIGENC_NAME(onig_get_encoding(reg)));
+    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 (%s)\n",
+            ONIGENC_NAME(onig_get_encoding(reg)));
+  }
+  else { /* error */
+    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+    onig_error_code_to_str(s, r);
+    fprintf(stderr, "ERROR: %s\n", s);
+    fprintf(stderr, "  (%s)\n", ONIGENC_NAME(onig_get_encoding(reg)));
+    return -1;
+  }
+
+  onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+  return 0;
+}
+
+static int
+exec(OnigEncoding enc, OnigOptionType options,
+     char* apattern, char* astr)
+{
+  int r;
+  unsigned char *end;
+  regex_t* reg;
+  OnigErrorInfo einfo;
+  UChar* pattern = (UChar* )apattern;
+  UChar* str     = (UChar* )astr;
+
+  onig_initialize(&enc, 1);
+
+  r = onig_new(&reg, pattern,
+               pattern + onigenc_str_bytelen_null(enc, pattern),
+               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);
+    fprintf(stderr, "ERROR: %s\n", s);
+    return -1;
+  }
+
+  end   = str + onigenc_str_bytelen_null(enc, str);
+  r = search(reg, str, end);
+
+  onig_free(reg);
+  onig_end();
+  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;
+  /* ISO 8859-1 test */
+  static unsigned char str[] = { 0xc7, 0xd6, 0xfe, 0xea, 0xe0, 0xe2, 0x00 };
+  static unsigned char pattern[] = { 0xe7, 0xf6, 0xde, '\\', 'w', '+', 0x00 };
+
+  r = exec(ONIG_ENCODING_SJIS, ONIG_OPTION_NONE,
+	   "^a\\p{Hiragana}c$", "a\202\274c");
+
+  r = exec(ONIG_ENCODING_EUC_JP, ONIG_OPTION_NONE,
+	   "^a\\p{Hiragana}c$", "a\244\276c");
+
+  r = exec(ONIG_ENCODING_CP1251, ONIG_OPTION_IGNORECASE,
+	   "aBc", " AbC");
+
+  r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
+	   " [a-c\337z] ", "  SS  ");
+  r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
+	   " [\330-\341] ", "  SS  ");
+
+  r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
+	   "\337          ", "          Ss          ");
+  r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
+	   "SS          ", "          \337          ");
+  r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
+	   "\\A\\S\\z", "ss");
+
+  r = exec(ONIG_ENCODING_ISO_8859_2, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+
+  r = exec(ONIG_ENCODING_ISO_8859_3, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_4, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_5, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_6, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_7, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_8, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_9, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_10, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_11, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_13, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_14, ONIG_OPTION_IGNORECASE,
+	   "[ac]+", "bbbaAaCCC");
+  r = exec(ONIG_ENCODING_ISO_8859_15, ONIG_OPTION_IGNORECASE,
+	   (char* )pattern, (char* )str);
+  r = exec(ONIG_ENCODING_ISO_8859_16, ONIG_OPTION_IGNORECASE,
+	   (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");
+  r = exec(ONIG_ENCODING_EUC_KR, ONIG_OPTION_NONE, "a+", "bbbaaaccc");
+  r = exec(ONIG_ENCODING_EUC_CN, ONIG_OPTION_NONE, "c+", "bbbaaaccc");
+  r = exec(ONIG_ENCODING_BIG5,   ONIG_OPTION_NONE, "a+", "bbbaaaccc");
+
+  r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
+           "\337", "SS");
+  r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
+           "SS", "\337");
+  r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
+           "SSb\337ssc", "a\337bSS\337cd");
+  r = exec(ONIG_ENCODING_ISO_8859_1, ONIG_OPTION_IGNORECASE,
+           "[a\337]{0,2}", "aSS");
+  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#\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",
+           "\0003\0001\377\020\377\031\377\032\000\000");
+
+  r = exec(ONIG_ENCODING_GB18030, ONIG_OPTION_IGNORECASE,
+	   "(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_deluxe(ONIG_ENCODING_UTF16_BE, 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_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_deluxe(ONIG_ENCODING_UTF16_BE, 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");
+
+  {
+    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_deluxe(ONIG_ENCODING_UTF16_BE, ONIG_ENCODING_UTF16_BE,
+		    ONIG_OPTION_IGNORECASE,
+		    (char* )pat, (char* )str2);
+  }
+
+#if 0
+  /* You should define USE_UNICODE_CASE_FOLD_TURKISH_AZERI in regenc.h. */
+
+  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_deluxe(ONIG_ENCODING_UTF16_BE, 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");
+
+  set_case_fold(ONIGENC_CASE_FOLD_MIN);
+#endif
+
+  return r;
+}

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

@@ -0,0 +1,110 @@
+/*
+ * listcap.c
+ *
+ * capture history (?@...) sample.
+ */
+#include <stdio.h>
+#include <string.h>
+#include "oniguruma.h"
+
+static int
+node_callback(int group, int beg, int end, int level, int at, void* arg)
+{
+  int i;
+
+  if (at != ONIG_TRAVERSE_CALLBACK_AT_FIRST)
+    return -1; /* error */
+
+  /* indent */
+  for (i = 0; i < level * 2; i++)
+    fputc(' ', stderr);
+
+  fprintf(stderr, "%d: (%d-%d)\n", group, beg, end);
+  return 0;
+}
+
+extern int ex(unsigned char* str, unsigned char* pattern,
+              OnigSyntaxType* syntax)
+{
+  int r;
+  unsigned char *start, *range, *end;
+  regex_t* reg;
+  OnigErrorInfo einfo;
+  OnigRegion *region;
+
+  r = onig_new(&reg, pattern, pattern + strlen((char* )pattern),
+	       ONIG_OPTION_DEFAULT, ONIG_ENCODING_ASCII, syntax, &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;
+  }
+
+  fprintf(stderr, "number of captures: %d\n", onig_number_of_captures(reg));
+  fprintf(stderr, "number of capture histories: %d\n",
+          onig_number_of_capture_histories(reg));
+
+  region = onig_region_new();
+
+  end   = str + strlen((char* )str);
+  start = str;
+  range = end;
+  r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
+  if (r >= 0) {
+    int i;
+
+    fprintf(stderr, "match at %d\n", r);
+    for (i = 0; i < region->num_regs; i++) {
+      fprintf(stderr, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]);
+    }
+    fprintf(stderr, "\n");
+
+    r = onig_capture_tree_traverse(region, ONIG_TRAVERSE_CALLBACK_AT_FIRST,
+                                   node_callback, (void* )0);
+  }
+  else if (r == ONIG_MISMATCH) {
+    fprintf(stderr, "search fail\n");
+  }
+  else { /* error */
+    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+    onig_error_code_to_str(s, r);
+    return -1;
+  }
+
+  onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+  onig_free(reg);
+  return 0;
+}
+
+
+extern int main(int argc, char* argv[])
+{
+  int r;
+  OnigSyntaxType syn;
+
+  static UChar* str1 = (UChar* )"((())())";
+  static UChar* pattern1
+    = (UChar* )"\\g<p>(?@<p>\\(\\g<s>\\)){0}(?@<s>(?:\\g<p>)*|){0}";
+
+  static UChar* str2     = (UChar* )"x00x00x00";
+  static UChar* pattern2 = (UChar* )"(?@x(?@\\d+))+";
+
+  static UChar* str3     = (UChar* )"0123";
+  static UChar* pattern3 = (UChar* )"(?@.)(?@.)(?@.)(?@.)";
+
+  OnigEncoding use_encs[] = { ONIG_ENCODING_ASCII };
+  onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));
+
+ /* enable capture hostory */
+  onig_copy_syntax(&syn, ONIG_SYNTAX_DEFAULT);
+  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);
+
+  onig_end();
+  return r;
+}

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

@@ -0,0 +1,75 @@
+/*
+ * names.c -- example of group name callback.
+ */
+#include <stdio.h>
+#include <string.h>
+#include "oniguruma.h"
+
+static int
+name_callback(const UChar* name, const UChar* name_end,
+	      int ngroup_num, int* group_nums,
+	      regex_t* reg, void* arg)
+{
+  int i, gn, ref;
+  char* s;
+  OnigRegion *region = (OnigRegion* )arg;
+
+  for (i = 0; i < ngroup_num; i++) {
+    gn = group_nums[i];
+    ref = onig_name_to_backref_number(reg, name, name_end, region);
+    s = (ref == gn ? "*" : "");
+    fprintf(stderr, "%s (%d): ", name, gn);
+    fprintf(stderr, "(%d-%d) %s\n", region->beg[gn], region->end[gn], s);
+  }
+  return 0;  /* 0: continue */
+}
+
+extern int main(int argc, char* argv[])
+{
+  int r;
+  unsigned char *start, *range, *end;
+  regex_t* reg;
+  OnigErrorInfo einfo;
+  OnigRegion *region;
+
+  static UChar* pattern = (UChar* )"(?<foo>a*)(?<bar>b*)(?<foo>c*)";
+  static UChar* str = (UChar* )"aaabbbbcc";
+
+  OnigEncoding use_encs[] = { 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);
+  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;
+  }
+
+  fprintf(stderr, "number of names: %d\n", onig_number_of_names(reg));
+
+  region = onig_region_new();
+
+  end   = str + strlen((char* )str);
+  start = str;
+  range = end;
+  r = onig_search(reg, str, end, start, range, region, ONIG_OPTION_NONE);
+  if (r >= 0) {
+    fprintf(stderr, "match at %d\n\n", r);
+    r = onig_foreach_name(reg, name_callback, (void* )region);
+  }
+  else if (r == ONIG_MISMATCH) {
+    fprintf(stderr, "search fail\n");
+  }
+  else { /* error */
+    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+    onig_error_code_to_str(s, r);
+    return -1;
+  }
+
+  onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+  onig_free(reg);
+  onig_end();
+  return 0;
+}

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

@@ -0,0 +1,96 @@
+/*
+ * posix.c
+ */
+#include <stdio.h>
+#include "onigposix.h"
+
+typedef unsigned char  UChar;
+
+static int x(regex_t* reg, unsigned char* pattern, unsigned char* str)
+{
+  int r, i;
+  char buf[200];
+  regmatch_t pmatch[20];
+
+  r = regexec(reg, (char* )str, reg->re_nsub + 1, pmatch, 0);
+  if (r != 0 && r != REG_NOMATCH) {
+    regerror(r, reg, buf, sizeof(buf));
+    fprintf(stderr, "ERROR: %s\n", buf);
+    return -1;
+  }
+
+  if (r == REG_NOMATCH) {
+    fprintf(stderr, "FAIL: /%s/ '%s'\n", pattern, str);
+  }
+  else {
+    fprintf(stderr, "OK: /%s/ '%s'\n", pattern, str);
+    for (i = 0; i <= (int )reg->re_nsub; i++) {
+      fprintf(stderr, "%d: %d-%d\n", i, pmatch[i].rm_so, pmatch[i].rm_eo);
+    }
+  }
+  return 0;
+}
+
+extern int main(int argc, char* argv[])
+{
+  int r;
+  char buf[200];
+  regex_t reg;
+  UChar* pattern;
+
+  reg_set_encoding(REG_POSIX_ENCODING_ASCII);
+
+  /* default syntax (ONIG_SYNTAX_RUBY) */
+  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);
+    return -1;
+  }
+  x(&reg, pattern, (UChar* )"aaabbbbd");
+
+  /* POSIX Basic RE (REG_EXTENDED is not specified.) */
+  pattern = (UChar* )"^a+b{2,7}[c-f]?|uuu";
+  r = regcomp(&reg, (char* )pattern, 0);
+  if (r) {
+    regerror(r, &reg, buf, sizeof(buf));
+    fprintf(stderr, "ERROR: %s\n", buf);
+    return -1;
+  }
+  x(&reg, pattern, (UChar* )"a+b{2,7}d?|uuu");
+
+  /* POSIX Basic RE (REG_EXTENDED is not specified.) */
+  pattern = (UChar* )"^a*b\\{2,7\\}\\([c-f]\\)$";
+  r = regcomp(&reg, (char* )pattern, 0);
+  if (r) {
+    regerror(r, &reg, buf, sizeof(buf));
+    fprintf(stderr, "ERROR: %s\n", buf);
+    return -1;
+  }
+  x(&reg, pattern, (UChar* )"aaaabbbbbbd");
+
+  /* POSIX Extended RE */
+  onig_set_default_syntax(ONIG_SYNTAX_POSIX_EXTENDED);
+  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);
+    return -1;
+  }
+  x(&reg, pattern, (UChar* )"aaabbbbd)");
+
+  pattern = (UChar* )"^b.";
+  r = regcomp(&reg, (char* )pattern, REG_EXTENDED | REG_NEWLINE);
+  if (r) {
+    regerror(r, &reg, buf, sizeof(buf));
+    fprintf(stderr, "ERROR: %s\n", buf);
+    return -1;
+  }
+  x(&reg, pattern, (UChar* )"a\nb\n");
+
+  regfree(&reg);
+  onig_end();
+  return 0;
+}

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

@@ -0,0 +1,88 @@
+/*
+ * scan.c
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include "oniguruma.h"
+
+static int
+scan_callback(int n, int r, OnigRegion* region, void* arg)
+{
+  int i;
+
+  fprintf(stdout, "scan: %d\n", n);
+
+  fprintf(stdout, "match at %d\n", r);
+  for (i = 0; i < region->num_regs; i++) {
+    fprintf(stdout, "%d: (%d-%d)\n", i, region->beg[i], region->end[i]);
+  }
+
+  return 0;
+}
+
+static int
+scan(regex_t* reg, 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);
+  if (r >= 0) {
+    fprintf(stdout, "total: %d match\n", r);
+  }
+  else { /* error */
+    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+    onig_error_code_to_str((OnigUChar* )s, r);
+    fprintf(stderr, "ERROR: %s\n", s);
+    return -1;
+  }
+
+  onig_region_free(region, 1 /* 1:free self, 0:free contents only */);
+  return 0;
+}
+
+static int
+exec(OnigEncoding enc, OnigOptionType options, char* apattern, char* astr)
+{
+  int r;
+  unsigned char *end;
+  regex_t* reg;
+  OnigErrorInfo einfo;
+  UChar* pattern_end;
+  UChar* pattern = (UChar* )apattern;
+  UChar* str     = (UChar* )astr;
+
+  onig_initialize(&enc, 1);
+
+  pattern_end = pattern + onigenc_str_bytelen_null(enc, pattern);
+
+  r = onig_new(&reg, pattern, pattern_end, options, enc, ONIG_SYNTAX_DEFAULT, &einfo);
+  if (r != ONIG_NORMAL) {
+    char s[ONIG_MAX_ERROR_MESSAGE_LEN];
+    onig_error_code_to_str((OnigUChar* )s, r, &einfo);
+    fprintf(stderr, "ERROR: %s\n", s);
+    return -1;
+  }
+
+  end = str + onigenc_str_bytelen_null(enc, str);
+  r = scan(reg, str, end);
+
+  onig_free(reg);
+  onig_end();
+  return 0;
+}
+
+
+extern int main(int argc, char* argv[])
+{
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE,
+       "\\Ga+\\s*", "a aa aaa baaa");
+
+  fprintf(stdout, "\n");
+  exec(ONIG_ENCODING_UTF8, ONIG_OPTION_NONE,
+       "a+\\s*", "a aa aaa baaa");
+
+  return 0;
+}