�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Foniguruma%2F'>oniguruma</a>/<a href='?path=%2Fbig%2FSRC%2Foniguruma%2Ftest%2F'>test</a>/</p><hr><h3>✏️ Editing: test_regset.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
 * test_regset.c  --- test for regset API
 * Copyright (c) 2019  K.Kosako
 */
#include &lt;stdlib.h&gt;
#include &lt;stdio.h&gt;
#include &lt;string.h&gt;
#include &lt;time.h&gt;

#include &quot;oniguruma.h&quot;

static int nsucc  = 0;
static int nfail  = 0;
static int nerror = 0;


static int
make_regset(int line_no, int n, char* pat[], OnigRegSet** rset, int error_no)
{
  int r;
  int i;
  OnigRegSet* set;
  regex_t* reg;
  OnigErrorInfo einfo;

  *rset = NULL;
  r = onig_regset_new(&amp;set, 0, NULL);
  if (r != 0) return r;

  for (i = 0; i &lt; n; i++) {
    r = onig_new(&amp;reg, (UChar* )pat[i], (UChar* )(pat[i] + strlen(pat[i])),
                 ONIG_OPTION_DEFAULT, ONIG_ENCODING_UTF8, ONIG_SYNTAX_DEFAULT,
                 &amp;einfo);
    if (r != 0) {
      char s[ONIG_MAX_ERROR_MESSAGE_LEN];

      if (error_no == 0) {
        onig_error_code_to_str((UChar* )s, r, &amp;einfo);
        fprintf(stderr, &quot;ERROR: %d: %s  /%s/\n&quot;, line_no, s, pat[i]);
        nerror++;
      }
      else {
        if (r == error_no) {
          fprintf(stdout, &quot;OK(ERROR): %d: /%s/ %d\n&quot;, line_no, pat[i], r);
          nsucc++;
        }
        else {
          fprintf(stdout, &quot;FAIL(ERROR): %d: /%s/ %d, %d\n&quot;,
                  line_no, pat[i], error_no, r);
          nfail++;
        }
      }
      onig_regset_free(set);
      return r;
    }

    r = onig_regset_add(set, reg);
    if (r != 0) {
      onig_regset_free(set);
      fprintf(stderr, &quot;ERROR: %d: onig_regset_add(): /%s/\n&quot;, line_no, pat[i]);
      nerror++;
      return r;
    }
  }

  *rset = set;
  return 0;
}

static double
get_sec(clock_t start, clock_t end)
{
  double t;

  t = (double )(end - start) / CLOCKS_PER_SEC;
  return t;
}

/* use clock(), because clock_gettime() doesn&#039;t exist in Windows and old Unix. */

static int
time_test(int repeat, int n, char* ps[], char* s, char* end, double* rt_set, double* rt_reg)
{
  int r;
  int i;
  int match_pos;
  OnigRegSet* set;
  clock_t ts1, ts2;
  double t_set, t_reg;

  r = make_regset(0, n, ps, &amp;set, 0);
  if (r != 0) return r;

  ts1 = clock();
  for (i = 0; i &lt; repeat; i++) {
    r = onig_regset_search(set, (UChar* )s, (UChar* )end, (UChar* )s, (UChar* )end,
                           ONIG_REGSET_POSITION_LEAD, ONIG_OPTION_NONE, &amp;match_pos);
    if (r &lt; 0) {
      fprintf(stderr, &quot;FAIL onig_regset_search(POSITION_LEAD): %d\n&quot;, r);
      onig_regset_free(set);
      return r;
    }
  }

  ts2 = clock();
  t_set = get_sec(ts1, ts2);

  ts1 = clock();
  for (i = 0; i &lt; repeat; i++) {
    r = onig_regset_search(set, (UChar* )s, (UChar* )end, (UChar* )s, (UChar* )end,
                           ONIG_REGSET_REGEX_LEAD, ONIG_OPTION_NONE, &amp;match_pos);
    if (r &lt; 0) {
      fprintf(stderr, &quot;FAIL onig_regset_search(REGEX_LEAD): %d\n&quot;, r);
      onig_regset_free(set);
      return r;
    }
  }

  ts2 = clock();
  t_reg = get_sec(ts1, ts2);

  onig_regset_free(set);

  *rt_set = t_set;
  *rt_reg = t_reg;
  return 0;
}

static void
fisher_yates_shuffle(int n, char* ps[], char* cps[])
{
#define GET_RAND(n)  (rand()%(n+1))
#define SWAP(a,b)    { char* tmp = a; a = b; b = tmp; }

  int i;

  for (i = 0; i &lt; n; i++)
    cps[i] = ps[i];

  for (i = n - 1; i &gt; 0; i--) {
    int x = GET_RAND(i);
    SWAP(cps[i], cps[x]);
  }
}

static void
time_compare(int n, char* ps[], char* s, char* end)
{
  int r;
  int i;
  int repeat;
  double t_set, t_reg;
  double total_set, total_reg;
  char** cps;

  cps = (char** )malloc(sizeof(char*) * n);
  if (cps == 0) return ;

  repeat = 100 / n;
  total_set = total_reg = 0.0;
  for (i = 0; i &lt; n; i++) {
    fisher_yates_shuffle(n, ps, cps);
    r = time_test(repeat, n, cps, s, end, &amp;t_set, &amp;t_reg);
    if (r != 0) {
      free(cps);
      return ;
    }
    total_set += t_set;
    total_reg += t_reg;
  }

  free(cps);

  fprintf(stdout, &quot;POS lead: %6.2lfmsec.  REG lead: %6.2lfmsec.\n&quot;,
          total_set * 1000.0, total_reg * 1000.0);
}


static OnigRegSetLead XX_LEAD = ONIG_REGSET_POSITION_LEAD;

static void
xx(int line_no, int n, char* ps[], char* s, int from, int to, int mem, int not, int error_no)
{
  int r;
  int match_pos;
  int match_index;
  OnigRegSet* set;
  char *end;

  r = make_regset(line_no, n, ps, &amp;set, error_no);
  if (r != 0) return ;

  end = s + strlen(s);

  r = onig_regset_search(set, (UChar* )s, (UChar* )end, (UChar* )s, (UChar* )end,
                         XX_LEAD, ONIG_OPTION_NONE, &amp;match_pos);
  if (r &lt; 0) {
    if (r == ONIG_MISMATCH) {
      if (not) {
        fprintf(stdout, &quot;OK(N): %d\n&quot;, line_no);
        nsucc++;
      }
      else {
        fprintf(stdout, &quot;FAIL: %d\n&quot;, line_no);
        nfail++;
      }
    }
    else {
      if (error_no == 0) {
        char buf[ONIG_MAX_ERROR_MESSAGE_LEN];
        onig_error_code_to_str((UChar* )buf, r);
        fprintf(stderr, &quot;ERROR: %d: %s\n&quot;, line_no, buf);
        nerror++;
      }
      else {
        if (r == error_no) {
          fprintf(stdout, &quot;OK(ERROR): %d: %d\n&quot;, line_no, r);
          nsucc++;
        }
        else {
          fprintf(stdout, &quot;FAIL ERROR NO: %d: %d, %d\n&quot;, line_no, error_no, r);
          nfail++;
        }
      }
    }
  }
  else {
    if (not) {
      fprintf(stdout, &quot;FAIL(N): %d\n&quot;, line_no);
      nfail++;
    }
    else {
      OnigRegion* region;

      match_index = r;
      region = onig_regset_get_region(set, match_index);
      if (region == 0) {
        fprintf(stderr, &quot;ERROR: %d: can&#039;t get region.\n&quot;, line_no);
        nerror++;
        onig_regset_free(set);
        return ;
      }

      if (region-&gt;beg[mem] == from &amp;&amp; region-&gt;end[mem] == to) {
        fprintf(stdout, &quot;OK: %d\n&quot;, line_no);
        nsucc++;
      }
      else {
        char buf[1000];
        int len;
        len = region-&gt;end[mem] - region-&gt;beg[mem];
        strncpy(buf, s + region-&gt;beg[mem], len);
        buf[len] = &#039;\0&#039;;
        fprintf(stdout, &quot;FAIL: %d: %d-%d : %d-%d (%s)\n&quot;, line_no,
                from, to, region-&gt;beg[mem], region-&gt;end[mem], buf);
        nfail++;
      }
    }
  }

  onig_regset_free(set);
}

static void
x2(int line_no, int n, char* ps[], char* s, int from, int to)
{
  xx(line_no, n, ps, s, from, to, 0, 0, 0);
}

static void
x3(int line_no, int n, char* ps[], char* s, int from, int to, int mem)
{
  xx(line_no, n, ps, s, from, to, mem, 0, 0);
}

static void
n(int line_no, int n, char* ps[], char* s)
{
  xx(line_no, n, ps, s, 0, 0, 0, 1, 0);
}

#define ASIZE(a)              sizeof(a)/sizeof(a[0])
#define X2(ps,s,from,to)      x2(__LINE__,ASIZE(ps),ps,s,from,to)
#define X3(ps,s,from,to,mem)  x3(__LINE__,ASIZE(ps),ps,s,from,to,mem)
#define N(ps,s)                n(__LINE__,ASIZE(ps),ps,s)
#define NZERO(s)               n(__LINE__,0,(char** )0,s)

#ifndef _WIN32

/* getdelim() doesn&#039;t exist in Windows */

static int
get_all_content_of_file(char* path, char** rs, char** rend)
{
  ssize_t len;
  size_t n;
  char* line;
  FILE* fp;

  fp = fopen(path, &quot;r&quot;);
  if (fp == 0) return -1;

  n = 0;
  line = NULL;
  len = getdelim(&amp;line, &amp;n, EOF, fp);
  fclose(fp);
  if (len &lt; 0) return -2;

  *rs   = line;
  *rend = line + len;
  return 0;
}
#endif


#define TEXT_PATH    &quot;kofu-utf8.txt&quot;

/* --- To get kofu.txt ---
   $ wget https://www.aozora.gr.jp/cards/000148/files/774_ruby_1640.zip
   $ unzip 774_ruby_1640.zip
   $ nkf -Lu -w8 kofu.txt &gt; kofu-utf8.txt
     (convert encoding to utf-8 with BOM and line terminator to be Unix-form)
*/

static char* p1[] = {
  &quot;abc&quot;,
  &quot;(bca)&quot;,
  &quot;(cab)&quot;
};

static char* p2[] = {
  &quot;小説&quot;,
  &quot;9&quot;,
  &quot;夏目漱石&quot;,
};

static char* p3[] = {
  &quot;^いる。&quot;,
  &quot;^校正&quot;,
  &quot;^底本&quot;,
  &quot;^　翌日&quot;,
};

static char* p4[] = {
  &quot;《[^》]{5}》&quot;,
  &quot;《[^》]{6}》&quot;,
  &quot;《[^》]{7}》&quot;,
  &quot;《[^》]{8}》&quot;,
  &quot;《[^》]{9}》&quot;,
  &quot;《[^》]{10}》&quot;,
  &quot;《[^》]{11}》&quot;,
  &quot;《[^》]{12}》&quot;,
  &quot;《[^》]{13}》&quot;,
  &quot;《[^》]{14}》&quot;,
  &quot;《[^》]{15}》&quot;,
  &quot;《[^》]{16}》&quot;,
  &quot;《[^》]{17}》&quot;,
  &quot;《[^》]{18}》&quot;,
  &quot;《[^》]{19}》&quot;,
  &quot;《[^》]{20}》&quot;,
};

static char* p5[] = {
  &quot;小室圭&quot;,
  &quot;bbbbbb&quot;,
  &quot;ドナルド・トランプ&quot;,
  &quot;筑摩書房&quot;,
  &quot;松原&quot;,
  &quot;aaaaaaaaa&quot;,
  &quot;bbbbbbbbb&quot;,
  &quot;ccccc&quot;,
  &quot;ddddddddddd&quot;,
  &quot;eee&quot;,
  &quot;ffffffffffff&quot;,
  &quot;gggggggggg&quot;,
  &quot;hhhhhhhhhhhhhh&quot;,
  &quot;iiiiiii&quot;,
};

static char* p6[] = {
  &quot;^.{1000,}&quot;,
  &quot;松原&quot;,
  &quot;小室圭&quot;,
  &quot;ドナルド・トランプ&quot;,
  &quot;筑摩書房&quot;,
};

static char* p7[] = {
  &quot;0+&quot;, &quot;1+&quot;, &quot;2+&quot;, &quot;3+&quot;, &quot;4+&quot;, &quot;5+&quot;, &quot;6+&quot;, &quot;7+&quot;, &quot;8+&quot;, &quot;9+&quot;,
};

static char* p8[] = {&quot;a&quot;, &quot;.*&quot;};

extern int
main(int argc, char* argv[])
{
#ifndef _WIN32
  int file_exist;
#endif
  int r;
  char *s, *end;
  OnigEncoding use_encs[1];

  use_encs[0] = ONIG_ENCODING_UTF8;
  onig_initialize(use_encs, sizeof(use_encs)/sizeof(use_encs[0]));

  srand(12345);

  XX_LEAD = ONIG_REGSET_POSITION_LEAD;

  NZERO(&quot; abab bccab ca&quot;);
  X2(p1, &quot; abab bccab ca&quot;, 8, 11);
  X3(p1, &quot; abab bccab ca&quot;, 8, 11, 1);
  N(p2, &quot; XXXX AAA 1223 012345678bbb&quot;);
  X2(p2, &quot;0123456789&quot;, 9, 10);
  X2(p7, &quot;abcde 555 qwert&quot;, 6, 9);
  X2(p8, &quot;&quot;, 0, 0);

  XX_LEAD = ONIG_REGSET_REGEX_LEAD;

  NZERO(&quot; abab bccab ca&quot;);
  X2(p1, &quot; abab bccab ca&quot;, 8, 11);
  X3(p1, &quot; abab bccab ca&quot;, 8, 11, 1);
  N(p2, &quot; XXXX AAA 1223 012345678bbb&quot;);
  X2(p2, &quot;0123456789&quot;, 9, 10);
  X2(p7, &quot;abcde 555 qwert&quot;, 6, 9);

#ifndef _WIN32
  r = get_all_content_of_file(TEXT_PATH, &amp;s, &amp;end);
  if (r == 0) {
    fprintf(stdout, &quot;FILE: %s, size: %d\n&quot;, TEXT_PATH, (int )(end - s));
    file_exist = 1;
  }
  else {
    fprintf(stdout, &quot;Ignore %s\n&quot;, TEXT_PATH);
    file_exist = 0;
  }

  if (file_exist != 0) {
    X2(p2, s, 10, 22);
    X2(p3, s, 496079, 496088);
    X2(p4, s, 1294, 1315);
  }
#endif

  fprintf(stdout,
          &quot;\nRESULT   SUCC: %4d,  FAIL: %d,  ERROR: %d      (by Oniguruma %s)\n&quot;,
          nsucc, nfail, nerror, onig_version());

#ifndef _WIN32
  if (file_exist != 0) {
    fprintf(stdout, &quot;\n&quot;);
    time_compare(ASIZE(p2), p2, s, end);
    time_compare(ASIZE(p3), p3, s, end);
    time_compare(ASIZE(p4), p4, s, end);
    time_compare(ASIZE(p5), p5, s, end);
    time_compare(ASIZE(p6), p6, s, end);
    fprintf(stdout, &quot;\n&quot;);
    free(s);
  }
#endif

  onig_end();

  return ((nfail == 0 &amp;&amp; nerror == 0) ? 0 : -1);
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Foniguruma%2Ftest'>🔙 Back</a></p>