Ignore:
Timestamp:
Jan 21, 2018, 12:10:09 AM (6 years ago)
Author:
coas-nagasima
Message:

prototoolに関連するプロジェクトをnewlibからmuslを使うよう変更・更新
ntshellをnewlibの下位の実装から、muslのsyscallの実装に変更・更新
以下のOSSをアップデート
・mruby-1.3.0
・musl-1.1.18
・onigmo-6.1.3
・tcc-0.9.27
以下のOSSを追加
・openssl-1.1.0e
・curl-7.57.0
・zlib-1.2.11
以下のmrbgemsを追加
・iij/mruby-digest
・iij/mruby-env
・iij/mruby-errno
・iij/mruby-iijson
・iij/mruby-ipaddr
・iij/mruby-mock
・iij/mruby-require
・iij/mruby-tls-openssl

Location:
EcnlProtoTool/trunk/onigmo-6.1.3
Files:
1 edited
1 moved

Legend:

Unmodified
Added
Removed

  • EcnlProtoTool/trunk/onigmo-6.1.3/src/regexec.c

    r321 r331  
    44/*-
    55 * Copyright (c) 2002-2008  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
    6  * Copyright (c) 2011-2014  K.Takata  <kentkt AT csc DOT jp>
     6 * Copyright (c) 2011-2016  K.Takata  <kentkt AT csc DOT jp>
    77 * All rights reserved.
    88 *
    … …  
    3131#include "regint.h"
    3232
    33 #define USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    34 
    35 #ifndef USE_DIRECT_THREADED_VM
     33#ifdef RUBY
     34# undef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
     35#else
     36# define USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
     37#endif
     38
     39#ifndef USE_TOKEN_THREADED_VM
    3640# ifdef __GNUC__
    37 #   define USE_DIRECT_THREADED_VM 1
     41#  define USE_TOKEN_THREADED_VM 1
    3842# else
    39 #   define USE_DIRECT_THREADED_VM 0
     43#  define USE_TOKEN_THREADED_VM 0
    4044# endif
    4145#endif
    4246
     47#ifdef RUBY
     48# define ENC_DUMMY_FLAG (1<<24)
     49static inline int
     50rb_enc_asciicompat(OnigEncoding enc)
     51{
     52  return ONIGENC_MBC_MINLEN(enc)==1 && !((enc)->ruby_encoding_index & ENC_DUMMY_FLAG);
     53}
     54# undef ONIGENC_IS_MBC_ASCII_WORD
     55# define ONIGENC_IS_MBC_ASCII_WORD(enc,s,end) \
     56    (rb_enc_asciicompat(enc) ? (ISALNUM(*s) || *s=='_') : \
     57   onigenc_ascii_is_code_ctype( \
     58        ONIGENC_MBC_TO_CODE(enc,s,end),ONIGENC_CTYPE_WORD,enc))
     59#endif /* RUBY */
     60
    4361#ifdef USE_CRNL_AS_LINE_TERMINATOR
    44 #define ONIGENC_IS_MBC_CRNL(enc,p,end) \
     62# define ONIGENC_IS_MBC_CRNL(enc,p,end) \
    4563  (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \
    46    ONIGENC_MBC_TO_CODE(enc,(p+enclen(enc,p)),end) == 10)
    47 #define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
     64   ONIGENC_MBC_TO_CODE(enc,(p+enclen(enc,p,end)),end) == 10)
     65# define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
    4866  is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev))
    4967static int
    … …  
    5472    if (ONIGENC_MBC_TO_CODE(enc, p, end) == 0x0a) {
    5573      if (check_prev) {
    56         const UChar *prev = onigenc_get_prev_char_head(enc, start, p);
     74        const UChar *prev = onigenc_get_prev_char_head(enc, start, p, end);
    5775        if ((prev != NULL) && ONIGENC_MBC_TO_CODE(enc, prev, end) == 0x0d)
    5876          return 0;
    … …  
    6482    }
    6583    else {
    66       const UChar *pnext = p + enclen(enc, p);
     84      const UChar *pnext = p + enclen(enc, p, end);
    6785      if (pnext < end &&
    6886          ONIGENC_MBC_TO_CODE(enc, p, end) == 0x0d &&
    … …  
    7997}
    8098#else /* USE_CRNL_AS_LINE_TERMINATOR */
    81 #define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
     99# define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
    82100  ONIGENC_IS_MBC_NEWLINE((enc), (p), (end))
    83101#endif /* USE_CRNL_AS_LINE_TERMINATOR */
    … …  
    94112    for (i = 0; i < node->num_childs; i++) {
    95113      if (IS_NOT_NULL(node->childs[i])) {
    96         history_tree_free(node->childs[i]);
     114        history_tree_free(node->childs[i]);
    97115      }
    98116    }
    … …  
    145163history_tree_add_child(OnigCaptureTreeNode* parent, OnigCaptureTreeNode* child)
    146164{
    147 #define HISTORY_TREE_INIT_ALLOC_SIZE  8
     165# define HISTORY_TREE_INIT_ALLOC_SIZE  8
    148166
    149167  if (parent->num_childs >= parent->allocated) {
    … …  
    153171      n = HISTORY_TREE_INIT_ALLOC_SIZE;
    154172      parent->childs =
    155         (OnigCaptureTreeNode** )xmalloc(sizeof(OnigCaptureTreeNode*) * n);
     173        (OnigCaptureTreeNode** )xmalloc(sizeof(OnigCaptureTreeNode*) * n);
    156174      CHECK_NULL_RETURN_MEMERR(parent->childs);
    157175    }
    … …  
    160178      n = parent->allocated * 2;
    161179      tmp =
    162         (OnigCaptureTreeNode** )xrealloc(parent->childs,
    163                                         sizeof(OnigCaptureTreeNode*) * n);
     180        (OnigCaptureTreeNode** )xrealloc(parent->childs,
     181                                        sizeof(OnigCaptureTreeNode*) * n);
    164182      if (tmp == 0) {
    165183        history_tree_clear(parent);
    … …  
    337355
    338356extern void
    339 onig_region_copy(OnigRegion* to, OnigRegion* from)
     357onig_region_copy(OnigRegion* to, const OnigRegion* from)
    340358{
    341359#define RREGC_SIZE   (sizeof(int) * from->num_regs)
    … …  
    386404#define STK_RETURN                 0x0900
    387405#define STK_VOID                   0x0a00  /* for fill a blank */
     406#define STK_ABSENT_POS             0x0b00  /* for absent */
     407#define STK_ABSENT                 0x0c00  /* absent inner loop marker */
    388408
    389409/* stack type check mask */
    … …  
    393413
    394414#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
    395 #define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
     415# define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
    396416  (msa).stack_p  = (void* )0;\
    397417  (msa).options  = (arg_option);\
    … …  
    402422} while(0)
    403423#else
    404 #define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
     424# define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
    405425  (msa).stack_p  = (void* )0;\
    406426  (msa).options  = (arg_option);\
    … …  
    413433#ifdef USE_COMBINATION_EXPLOSION_CHECK
    414434
    415 #define STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE  16
    416 
    417 #define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num) do {     \
     435# define STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE  16
     436
     437# define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num) do {    \
    418438  if ((state_num) > 0 && str_len >= STATE_CHECK_STRING_THRESHOLD_LEN) {\
    419439    unsigned int size = (unsigned int )(((str_len) + 1) * (state_num) + 7) >> 3;\
    … …  
    441461  } while(0)
    442462
    443 #define MATCH_ARG_FREE(msa) do {\
     463# define MATCH_ARG_FREE(msa) do {\
    444464  if ((msa).stack_p) xfree((msa).stack_p);\
    445465  if ((msa).state_check_buff_size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) { \
    … …  
    448468} while(0)
    449469#else /* USE_COMBINATION_EXPLOSION_CHECK */
    450 #define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num)
    451 #define MATCH_ARG_FREE(msa)  if ((msa).stack_p) xfree((msa).stack_p)
     470# define MATCH_ARG_FREE(msa)  if ((msa).stack_p) xfree((msa).stack_p)
    452471#endif /* USE_COMBINATION_EXPLOSION_CHECK */
    453472
    … …  
    466485      stk_end   = stk_base + msa->stack_n;\
    467486    } else {\
    468       stk_alloc = (OnigStackType* )xmalloc(sizeof(OnigStackType) * (stack_num));\
     487      stk_alloc = (OnigStackType* )xalloca(sizeof(OnigStackType) * (stack_num));\
    469488      stk_base  = stk_alloc;\
    470489      stk       = stk_base;\
    … …  
    472491    }\
    473492  } else if (msa->stack_p) {\
    474     alloc_addr = (char* )xmalloc(sizeof(OnigStackIndex) * (ptr_num));\
     493    alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num));\
    475494    heap_addr  = NULL;\
    476495    stk_alloc  = (OnigStackType* )(msa->stack_p);\
    … …  
    480499  }\
    481500  else {\
    482     alloc_addr = (char* )xmalloc(sizeof(OnigStackIndex) * (ptr_num)\
     501    alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num)\
    483502                       + sizeof(OnigStackType) * (stack_num));\
    484503    heap_addr  = NULL;\
    … …  
    538557    if (limit_size != 0 && n > limit_size) {
    539558      if ((unsigned int )(stk_end - stk_base) == limit_size)
    540         return ONIGERR_MATCH_STACK_LIMIT_OVER;
     559        return ONIGERR_MATCH_STACK_LIMIT_OVER;
    541560      else
    542         n = limit_size;
     561        n = limit_size;
    543562    }
    544563    x = (OnigStackType* )xrealloc(stk_base, sizeof(OnigStackType) * n);
    … …  
    577596
    578597#ifdef USE_COMBINATION_EXPLOSION_CHECK
    579 #define STATE_CHECK_POS(s,snum) \
     598# define STATE_CHECK_POS(s,snum) \
    580599  (((s) - str) * num_comb_exp_check + ((snum) - 1))
    581 #define STATE_CHECK_VAL(v,snum) do {\
     600# define STATE_CHECK_VAL(v,snum) do {\
    582601  if (state_check_buff != NULL) {\
    583602    int x = STATE_CHECK_POS(s,snum);\
    … …  
    588607
    589608
    590 #define ELSE_IF_STATE_CHECK_MARK(stk) \
     609# define ELSE_IF_STATE_CHECK_MARK(stk) \
    591610  else if ((stk)->type == STK_STATE_CHECK_MARK) { \
    592611    int x = STATE_CHECK_POS(stk->u.state.pstr, stk->u.state.state_check);\
    … …  
    594613  }
    595614
    596 #define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
     615# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
    597616  STACK_ENSURE(1);\
    598617  stk->type = (stack_type);\
    … …  
    605624} while(0)
    606625
    607 #define STACK_PUSH_ENSURED(stack_type,pat) do {\
     626# define STACK_PUSH_ENSURED(stack_type,pat) do {\
    608627  stk->type = (stack_type);\
    609628  stk->u.state.pcode = (pat);\
    … …  
    612631} while(0)
    613632
    614 #define STACK_PUSH_ALT_WITH_STATE_CHECK(pat,s,sprev,snum,keep) do {\
     633# define STACK_PUSH_ALT_WITH_STATE_CHECK(pat,s,sprev,snum,keep) do {\
    615634  STACK_ENSURE(1);\
    616635  stk->type = STK_ALT;\
    … …  
    623642} while(0)
    624643
    625 #define STACK_PUSH_STATE_CHECK(s,snum) do {\
     644# define STACK_PUSH_STATE_CHECK(s,snum) do {\
    626645  if (state_check_buff != NULL) {\
    627646    STACK_ENSURE(1);\
    … …  
    635654#else /* USE_COMBINATION_EXPLOSION_CHECK */
    636655
    637 #define ELSE_IF_STATE_CHECK_MARK(stk)
    638 
    639 #define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
     656# define ELSE_IF_STATE_CHECK_MARK(stk)
     657
     658# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
    640659  STACK_ENSURE(1);\
    641660  stk->type = (stack_type);\
    … …  
    647666} while(0)
    648667
    649 #define STACK_PUSH_ENSURED(stack_type,pat) do {\
     668# define STACK_PUSH_ENSURED(stack_type,pat) do {\
    650669  stk->type = (stack_type);\
    651670  stk->u.state.pcode = (pat);\
    … …  
    657676#define STACK_PUSH_POS(s,sprev,keep)         STACK_PUSH(STK_POS,NULL_UCHARP,s,sprev,keep)
    658677#define STACK_PUSH_POS_NOT(pat,s,sprev,keep) STACK_PUSH(STK_POS_NOT,pat,s,sprev,keep)
    659 #define STACK_PUSH_STOP_BT              STACK_PUSH_TYPE(STK_STOP_BT)
     678#define STACK_PUSH_ABSENT                    STACK_PUSH_TYPE(STK_ABSENT)
     679#define STACK_PUSH_STOP_BT                   STACK_PUSH_TYPE(STK_STOP_BT)
    660680#define STACK_PUSH_LOOK_BEHIND_NOT(pat,s,sprev,keep) \
    661681        STACK_PUSH(STK_LOOK_BEHIND_NOT,pat,s,sprev,keep)
    … …  
    769789} while(0)
    770790
     791#define STACK_PUSH_ABSENT_POS(start, end) do {\
     792  STACK_ENSURE(1);\
     793  stk->type = STK_ABSENT_POS;\
     794  stk->u.absent_pos.abs_pstr = (start);\
     795  stk->u.absent_pos.end_pstr = (end);\
     796  STACK_INC;\
     797} while(0)
     798
    771799
    772800#ifdef ONIG_DEBUG
    773 #define STACK_BASE_CHECK(p, at) \
     801# define STACK_BASE_CHECK(p, at) \
    774802  if ((p) < stk_base) {\
    775803    fprintf(stderr, "at %s\n", at);\
    … …  
    777805  }
    778806#else
    779 #define STACK_BASE_CHECK(p, at)
     807# define STACK_BASE_CHECK(p, at)
    780808#endif
    781809
    … …  
    867895    ELSE_IF_STATE_CHECK_MARK(stk);\
    868896  }\
     897} while(0)
     898
     899#define STACK_POP_TIL_ABSENT  do {\
     900  while (1) {\
     901    stk--;\
     902    STACK_BASE_CHECK(stk, "STACK_POP_TIL_ABSENT"); \
     903    if (stk->type == STK_ABSENT) break;\
     904    else if (stk->type == STK_MEM_START) {\
     905      mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
     906      mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
     907    }\
     908    else if (stk->type == STK_REPEAT_INC) {\
     909      STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
     910    }\
     911    else if (stk->type == STK_MEM_END) {\
     912      mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
     913      mem_end_stk[stk->u.mem.num]   = stk->u.mem.end;\
     914    }\
     915    ELSE_IF_STATE_CHECK_MARK(stk);\
     916  }\
     917} while(0)
     918
     919#define STACK_POP_ABSENT_POS(start, end) do {\
     920  stk--;\
     921  STACK_BASE_CHECK(stk, "STACK_POP_ABSENT_POS"); \
     922  (start) = stk->u.absent_pos.abs_pstr;\
     923  (end) = stk->u.absent_pos.end_pstr;\
    869924} while(0)
    870925
    … …  
    10641119} while(0)
    10651120
    1066 #define STRING_CMP_IC(case_fold_flag,s1,ps2,len) do {\
    1067   if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len) == 0) \
     1121#define STRING_CMP_IC(case_fold_flag,s1,ps2,len,text_end) do {\
     1122  if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \
    10681123    goto fail; \
    10691124} while(0)
    10701125
    10711126static int string_cmp_ic(OnigEncoding enc, int case_fold_flag,
    1072                          UChar* s1, UChar** ps2, OnigDistance mblen)
     1127                         UChar* s1, UChar** ps2, OnigDistance mblen, const UChar* text_end)
    10731128{
    10741129  UChar buf1[ONIGENC_MBC_CASE_FOLD_MAXLEN];
    10751130  UChar buf2[ONIGENC_MBC_CASE_FOLD_MAXLEN];
    1076   UChar *p1, *p2, *end1, *s2, *end2;
     1131  UChar *p1, *p2, *end1, *s2;
    10771132  int len1, len2;
    10781133
    10791134  s2   = *ps2;
    10801135  end1 = s1 + mblen;
    1081   end2 = s2 + mblen;
    10821136  while (s1 < end1) {
    1083     len1 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s1, end1, buf1);
    1084     len2 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s2, end2, buf2);
     1137    len1 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s1, text_end, buf1);
     1138    len2 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s2, text_end, buf2);
    10851139    if (len1 != len2) return 0;
    10861140    p1 = buf1;
    … …  
    11061160} while(0)
    11071161
    1108 #define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,is_fail) do {\
    1109   if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len) == 0) \
     1162#define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,text_end,is_fail) do {\
     1163  if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \
    11101164    is_fail = 1; \
    11111165  else \
    … …  
    11151169
    11161170#define IS_EMPTY_STR           (str == end)
    1117 #define ON_STR_BEGIN(s)       ((s) == str)
    1118 #define ON_STR_END(s)         ((s) == end)
     1171#define ON_STR_BEGIN(s)        ((s) == str)
     1172#define ON_STR_END(s)          ((s) == end)
    11191173#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    1120 #define DATA_ENSURE_CHECK1     (s < right_range)
    1121 #define DATA_ENSURE_CHECK(n)   (s + (n) <= right_range)
    1122 #define DATA_ENSURE(n)         if (s + (n) > right_range) goto fail
     1174# define DATA_ENSURE_CHECK1    (s < right_range)
     1175# define DATA_ENSURE_CHECK(n)  (s + (n) <= right_range)
     1176# define DATA_ENSURE(n)        if (s + (n) > right_range) goto fail
     1177# define ABSENT_END_POS        right_range
    11231178#else
    1124 #define DATA_ENSURE_CHECK1     (s < end)
    1125 #define DATA_ENSURE_CHECK(n)   (s + (n) <= end)
    1126 #define DATA_ENSURE(n)         if (s + (n) > end) goto fail
     1179# define DATA_ENSURE_CHECK1    (s < end)
     1180# define DATA_ENSURE_CHECK(n)  (s + (n) <= end)
     1181# define DATA_ENSURE(n)        if (s + (n) > end) goto fail
     1182# define ABSENT_END_POS        end
    11271183#endif /* USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE */
    11281184
    … …  
    11411197      n = k->u.mem.num;
    11421198      if (n <= ONIG_MAX_CAPTURE_HISTORY_GROUP &&
    1143           BIT_STATUS_AT(reg->capture_history, n) != 0) {
    1144         child = history_node_new();
    1145         CHECK_NULL_RETURN_MEMERR(child);
    1146         child->group = n;
    1147         child->beg = k->u.mem.pstr - str;
    1148         r = history_tree_add_child(node, child);
    1149         if (r != 0) {
    1150           history_tree_free(child);
    1151           return r;
    1152         }
    1153         *kp = (k + 1);
    1154         r = make_capture_history_tree(child, kp, stk_top, str, reg);
    1155         if (r != 0) return r;
    1156 
    1157         k = *kp;
    1158         child->end = k->u.mem.pstr - str;
     1199          BIT_STATUS_AT(reg->capture_history, n) != 0) {
     1200        child = history_node_new();
     1201        CHECK_NULL_RETURN_MEMERR(child);
     1202        child->group = n;
     1203        child->beg = k->u.mem.pstr - str;
     1204        r = history_tree_add_child(node, child);
     1205        if (r != 0) {
     1206          history_tree_free(child);
     1207          return r;
     1208        }
     1209        *kp = (k + 1);
     1210        r = make_capture_history_tree(child, kp, stk_top, str, reg);
     1211        if (r != 0) return r;
     1212
     1213        k = *kp;
     1214        child->end = k->u.mem.pstr - str;
    11591215      }
    11601216    }
    11611217    else if (k->type == STK_MEM_END) {
    11621218      if (k->u.mem.num == node->group) {
    1163         node->end = k->u.mem.pstr - str;
    1164         *kp = k;
    1165         return 0;
     1219        node->end = k->u.mem.pstr - str;
     1220        *kp = k;
     1221        return 0;
    11661222      }
    11671223    }
    … …  
    11861242}
    11871243
    1188 static int backref_match_at_nested_level(regex_t* reg
    1189          , OnigStackType* top, OnigStackType* stk_base
    1190          , int ignore_case, int case_fold_flag
    1191          , int nest, int mem_num, UChar* memp, UChar** s, const UChar* send)
     1244static int backref_match_at_nested_level(regex_t* reg,
     1245         OnigStackType* top, OnigStackType* stk_base,
     1246         int ignore_case, int case_fold_flag,
     1247         int nest, int mem_num, UChar* memp, UChar** s, const UChar* send)
    11921248{
    11931249  UChar *ss, *p, *pstart, *pend = NULL_UCHARP;
    … …  
    12161272            if (ignore_case != 0) {
    12171273              if (string_cmp_ic(reg->enc, case_fold_flag,
    1218                                 pstart, &ss, pend - pstart) == 0)
     1274                                pstart, &ss, pend - pstart, send) == 0)
    12191275                return 0; /* or goto next_mem; */
    12201276            }
    … …  
    12461302#ifdef ONIG_DEBUG_STATISTICS
    12471303
    1248 #define USE_TIMEOFDAY
    1249 
    1250 #ifdef USE_TIMEOFDAY
    1251 #ifdef HAVE_SYS_TIME_H
    1252 #include <sys/time.h>
    1253 #endif
    1254 #ifdef HAVE_UNISTD_H
    1255 #include <unistd.h>
    1256 #endif
     1304# ifdef _WIN32
     1305#  include <windows.h>
     1306static LARGE_INTEGER ts, te, freq;
     1307#  define GETTIME(t)      QueryPerformanceCounter(&(t))
     1308#  define TIMEDIFF(te,ts) (unsigned long )(((te).QuadPart - (ts).QuadPart) \
     1309                            * 1000000 / freq.QuadPart)
     1310# else /* _WIN32 */
     1311
     1312#  define USE_TIMEOFDAY
     1313
     1314#  ifdef USE_TIMEOFDAY
     1315#   ifdef HAVE_SYS_TIME_H
     1316#    include <sys/time.h>
     1317#   endif
     1318#   ifdef HAVE_UNISTD_H
     1319#    include <unistd.h>
     1320#   endif
    12571321static struct timeval ts, te;
    1258 #define GETTIME(t)        gettimeofday(&(t), (struct timezone* )0)
    1259 #define TIMEDIFF(te,ts)  (((te).tv_usec - (ts).tv_usec) + \
    1260                            (((te).tv_sec - (ts).tv_sec)*1000000))
    1261 #else /* USE_TIMEOFDAY */
    1262 #ifdef HAVE_SYS_TIMES_H
    1263 #include <sys/times.h>
    1264 #endif
     1322#   define GETTIME(t)      gettimeofday(&(t), (struct timezone* )0)
     1323#   define TIMEDIFF(te,ts) (((te).tv_usec - (ts).tv_usec) + \
     1324                            (((te).tv_sec - (ts).tv_sec)*1000000))
     1325#  else /* USE_TIMEOFDAY */
     1326#   ifdef HAVE_SYS_TIMES_H
     1327#    include <sys/times.h>
     1328#   endif
    12651329static struct tms ts, te;
    1266 #define GETTIME(t)         times(&(t))
    1267 #define TIMEDIFF(te,ts)   ((te).tms_utime - (ts).tms_utime)
    1268 #endif /* USE_TIMEOFDAY */
     1330#   define GETTIME(t)       times(&(t))
     1331#   define TIMEDIFF(te,ts)  ((te).tms_utime - (ts).tms_utime)
     1332#  endif /* USE_TIMEOFDAY */
     1333
     1334# endif /* _WIN32 */
    12691335
    12701336static int OpCounter[256];
    … …  
    12751341static int MaxStackDepth = 0;
    12761342
    1277 #define MOP_IN(opcode) do {\
     1343# define MOP_IN(opcode) do {\
    12781344  if (opcode == OpPrevTarget) OpPrevCounter[OpCurr]++;\
    12791345  OpCurr = opcode;\
    … …  
    12821348} while(0)
    12831349
    1284 #define MOP_OUT do {\
     1350# define MOP_OUT do {\
    12851351  GETTIME(te);\
    12861352  OpTime[OpCurr] += TIMEDIFF(te, ts);\
    … …  
    12951361  }
    12961362  MaxStackDepth = 0;
     1363# ifdef _WIN32
     1364  QueryPerformanceFrequency(&freq);
     1365# endif
    12971366}
    12981367
    … …  
    13091378}
    13101379
    1311 #define STACK_INC do {\
     1380# define STACK_INC do {\
    13121381  stk++;\
    13131382  if (stk - stk_base > MaxStackDepth) \
    … …  
    13161385
    13171386#else /* ONIG_DEBUG_STATISTICS */
    1318 #define STACK_INC     stk++
    1319 
    1320 #define MOP_IN(opcode)
    1321 #define MOP_OUT
     1387# define STACK_INC     stk++
     1388
     1389# define MOP_IN(opcode)
     1390# define MOP_OUT
    13221391#endif /* ONIG_DEBUG_STATISTICS */
    13231392
    13241393
    1325 
    1326 /* matching region of POSIX API */
    1327 typedef int regoff_t;
    1328 
    1329 typedef struct {
    1330   regoff_t  rm_so;
    1331   regoff_t  rm_eo;
    1332 } posix_regmatch_t;
     1394#ifdef ONIG_DEBUG_MATCH
     1395static char *
     1396stack_type_str(int stack_type)
     1397{
     1398  switch (stack_type) {
     1399    case STK_ALT:               return "Alt   ";
     1400    case STK_LOOK_BEHIND_NOT:   return "LBNot ";
     1401    case STK_POS_NOT:           return "PosNot";
     1402    case STK_MEM_START:         return "MemS  ";
     1403    case STK_MEM_END:           return "MemE  ";
     1404    case STK_REPEAT_INC:        return "RepInc";
     1405    case STK_STATE_CHECK_MARK:  return "StChMk";
     1406    case STK_NULL_CHECK_START:  return "NulChS";
     1407    case STK_NULL_CHECK_END:    return "NulChE";
     1408    case STK_MEM_END_MARK:      return "MemEMk";
     1409    case STK_POS:               return "Pos   ";
     1410    case STK_STOP_BT:           return "StopBt";
     1411    case STK_REPEAT:            return "Rep   ";
     1412    case STK_CALL_FRAME:        return "Call  ";
     1413    case STK_RETURN:            return "Ret   ";
     1414    case STK_VOID:              return "Void  ";
     1415    case STK_ABSENT_POS:        return "AbsPos";
     1416    case STK_ABSENT:            return "Absent";
     1417    default:                    return "      ";
     1418  }
     1419}
     1420#endif
    13331421
    13341422/* match data(str - end) from position (sstart). */
    13351423/* if sstart == str then set sprev to NULL. */
    13361424static OnigPosition
    1337 match_at_(regex_t* reg, const UChar* str, const UChar* end,
     1425match_at(regex_t* reg, const UChar* str, const UChar* end,
    13381426#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    13391427         const UChar* right_range,
    13401428#endif
    1341          const UChar* sstart, UChar* sprev, OnigMatchArg* msa, char **palloca_base)
     1429         const UChar* sstart, UChar* sprev, OnigMatchArg* msa)
    13421430{
    13431431  static const UChar FinishCode[] = { OP_FINISH };
    … …  
    13541442  UChar *p = reg->p;
    13551443  UChar *pkeep;
     1444  char *alloca_base;
    13561445  char *xmalloc_base = NULL;
    13571446  OnigStackType *stk_alloc, *stk_base, *stk, *stk_end;
    … …  
    13661455#endif
    13671456
    1368 #if USE_DIRECT_THREADED_VM
    1369 #define VM_LOOP JUMP;
    1370 #define VM_LOOP_END
    1371 #define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK;
    1372 #define DEFAULT L_DEFAULT:
    1373 #define NEXT sprev = sbegin; JUMP
    1374 #define JUMP goto *oplabels[*p++]
     1457#if USE_TOKEN_THREADED_VM
     1458# define OP_OFFSET  1
     1459# define VM_LOOP JUMP;
     1460# define VM_LOOP_END
     1461# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK;
     1462# define DEFAULT L_DEFAULT:
     1463# define NEXT sprev = sbegin; JUMP
     1464# define JUMP goto *oplabels[*p++]
    13751465
    13761466  static const void *oplabels[] = {
    … …  
    14001490    &&L_OP_CCLASS_MB_NOT,
    14011491    &&L_OP_CCLASS_MIX_NOT,
    1402     &&L_OP_CCLASS_NODE,          /* pointer to CClassNode node */
    14031492
    14041493    &&L_OP_ANYCHAR,                 /* "."  */
    … …  
    14131502    &&L_OP_WORD_BOUND,
    14141503    &&L_OP_NOT_WORD_BOUND,
    1415 #ifdef USE_WORD_BEGIN_END
     1504# ifdef USE_WORD_BEGIN_END
    14161505    &&L_OP_WORD_BEGIN,
    14171506    &&L_OP_WORD_END,
    1418 #else
     1507# else
    14191508    &&L_DEFAULT,
    14201509    &&L_DEFAULT,
    1421 #endif
     1510# endif
    14221511    &&L_OP_ASCII_WORD,
    14231512    &&L_OP_NOT_ASCII_WORD,
    14241513    &&L_OP_ASCII_WORD_BOUND,
    14251514    &&L_OP_NOT_ASCII_WORD_BOUND,
    1426 #ifdef USE_WORD_BEGIN_END
     1515# ifdef USE_WORD_BEGIN_END
    14271516    &&L_OP_ASCII_WORD_BEGIN,
    14281517    &&L_OP_ASCII_WORD_END,
    1429 #else
     1518# else
    14301519    &&L_DEFAULT,
    14311520    &&L_DEFAULT,
    1432 #endif
     1521# endif
    14331522
    14341523    &&L_OP_BEGIN_BUF,
    … …  
    14381527    &&L_OP_SEMI_END_BUF,
    14391528    &&L_OP_BEGIN_POSITION,
    1440     &&L_OP_BEGIN_POS_OR_LINE,    /* used for implicit anchor optimization */
    14411529
    14421530    &&L_OP_BACKREF1,
    … …  
    14461534    &&L_OP_BACKREF_MULTI,
    14471535    &&L_OP_BACKREF_MULTI_IC,
    1448 #ifdef USE_BACKREF_WITH_LEVEL
     1536# ifdef USE_BACKREF_WITH_LEVEL
    14491537    &&L_OP_BACKREF_WITH_LEVEL,   /* \k<xxx+n>, \k<xxx-n> */
    1450 #else
     1538# else
    14511539    &&L_DEFAULT,
    1452 #endif
     1540# endif
    14531541    &&L_OP_MEMORY_START,
    14541542    &&L_OP_MEMORY_START_PUSH,    /* push back-tracker to stack */
    14551543    &&L_OP_MEMORY_END_PUSH,      /* push back-tracker to stack */
    1456 #ifdef USE_SUBEXP_CALL
     1544# ifdef USE_SUBEXP_CALL
    14571545    &&L_OP_MEMORY_END_PUSH_REC,  /* push back-tracker to stack */
    1458 #else
     1546# else
    14591547    &&L_DEFAULT,
    1460 #endif
     1548# endif
    14611549    &&L_OP_MEMORY_END,
    1462 #ifdef USE_SUBEXP_CALL
     1550# ifdef USE_SUBEXP_CALL
    14631551    &&L_OP_MEMORY_END_REC,       /* push marker to stack */
    1464 #else
     1552# else
    14651553    &&L_DEFAULT,
    1466 #endif
     1554# endif
    14671555
    14681556    &&L_OP_KEEP,
    … …  
    14721560    &&L_OP_PUSH,
    14731561    &&L_OP_POP,
     1562# ifdef USE_OP_PUSH_OR_JUMP_EXACT
    14741563    &&L_OP_PUSH_OR_JUMP_EXACT1,  /* if match exact then push, else jump. */
     1564# else
     1565    &&L_DEFAULT,
     1566# endif
    14751567    &&L_OP_PUSH_IF_PEEK_NEXT,    /* if match exact then push, else none. */
    14761568    &&L_OP_REPEAT,               /* {n,m} */
    … …  
    14821574    &&L_OP_NULL_CHECK_START,     /* null loop checker start */
    14831575    &&L_OP_NULL_CHECK_END,       /* null loop checker end   */
    1484 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
     1576# ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
    14851577    &&L_OP_NULL_CHECK_END_MEMST, /* null loop checker end (with capture status) */
    1486 #else
     1578# else
    14871579    &&L_DEFAULT,
    1488 #endif
    1489 #ifdef USE_SUBEXP_CALL
     1580# endif
     1581# ifdef USE_SUBEXP_CALL
    14901582    &&L_OP_NULL_CHECK_END_MEMST_PUSH, /* with capture status and push check-end */
    1491 #else
     1583# else
    14921584    &&L_DEFAULT,
    1493 #endif
     1585# endif
    14941586
    14951587    &&L_OP_PUSH_POS,             /* (?=...)  start */
    … …  
    15021594    &&L_OP_PUSH_LOOK_BEHIND_NOT, /* (?<!...) start */
    15031595    &&L_OP_FAIL_LOOK_BEHIND_NOT, /* (?<!...) end   */
    1504 
    1505 #ifdef USE_SUBEXP_CALL
     1596    &&L_OP_PUSH_ABSENT_POS,      /* (?~...)  start */
     1597    &&L_OP_ABSENT,               /* (?~...)  start of inner loop */
     1598    &&L_OP_ABSENT_END,           /* (?~...)  end   */
     1599
     1600# ifdef USE_SUBEXP_CALL
    15061601    &&L_OP_CALL,                 /* \g<name> */
    15071602    &&L_OP_RETURN,
    1508 #else
     1603# else
    15091604    &&L_DEFAULT,
    15101605    &&L_DEFAULT,
    1511 #endif
     1606# endif
    15121607    &&L_OP_CONDITION,
    15131608
    1514 #ifdef USE_COMBINATION_EXPLOSION_CHECK
     1609# ifdef USE_COMBINATION_EXPLOSION_CHECK
    15151610    &&L_OP_STATE_CHECK_PUSH,         /* combination explosion check and push */
    15161611    &&L_OP_STATE_CHECK_PUSH_OR_JUMP, /* check ok -> push, else jump  */
    15171612    &&L_OP_STATE_CHECK,              /* check only */
    1518 #else
     1613# else
    15191614    &&L_DEFAULT,
    15201615    &&L_DEFAULT,
    15211616    &&L_DEFAULT,
    1522 #endif
    1523 #ifdef USE_COMBINATION_EXPLOSION_CHECK
     1617# endif
     1618# ifdef USE_COMBINATION_EXPLOSION_CHECK
    15241619    &&L_OP_STATE_CHECK_ANYCHAR_STAR,
    15251620    &&L_OP_STATE_CHECK_ANYCHAR_ML_STAR,
    1526 #else
     1621# else
    15271622    &&L_DEFAULT,
    15281623    &&L_DEFAULT,
    1529 #endif
     1624# endif
    15301625    /* no need: IS_DYNAMIC_OPTION() == 0 */
    1531 #if 0   /* no need: IS_DYNAMIC_OPTION() == 0 */
     1626# if 0   /* no need: IS_DYNAMIC_OPTION() == 0 */
    15321627    &&L_OP_SET_OPTION_PUSH,    /* set option and push recover option */
    15331628    &&L_OP_SET_OPTION          /* set option */
    1534 #else
     1629# else
    15351630    &&L_DEFAULT,
    15361631    &&L_DEFAULT
    1537 #endif
     1632# endif
    15381633  };
    1539 #else
    1540 
    1541 #define VM_LOOP                                 \
     1634#else /* USE_TOKEN_THREADED_VM */
     1635
     1636# define OP_OFFSET  0
     1637# define VM_LOOP                                \
    15421638  while (1) {                                   \
    15431639  OPCODE_EXEC_HOOK;                             \
    15441640  sbegin = s;                                   \
    15451641  switch (*p++) {
    1546 #define VM_LOOP_END } sprev = sbegin; }
    1547 #define CASE(x) case x:
    1548 #define DEFAULT default:
    1549 #define NEXT break
    1550 #define JUMP continue; break
    1551 #endif
     1642# define VM_LOOP_END } sprev = sbegin; }
     1643# define CASE(x) case x:
     1644# define DEFAULT default:
     1645# define NEXT break
     1646# define JUMP continue; break
     1647#endif /* USE_TOKEN_THREADED_VM */
    15521648
    15531649
    15541650#ifdef USE_SUBEXP_CALL
    1555   /* Stack #0 is used to store the pattern itself and used for (?R), \g<0>, etc. */
    1556   n = reg->num_repeat + (reg->num_mem + 1) * 2;
    1557 
    1558   STACK_INIT(*palloca_base, xmalloc_base, n, INIT_MATCH_STACK_SIZE);
     1651/* Stack #0 is used to store the pattern itself and used for (?R), \g<0>,
     1652   etc. Additional space is required. */
     1653# define ADD_NUMMEM 1
     1654#else
     1655/* Stack #0 not is used. */
     1656# define ADD_NUMMEM 0
     1657#endif
     1658
     1659  n = reg->num_repeat + (reg->num_mem + ADD_NUMMEM) * 2;
     1660
     1661  STACK_INIT(alloca_base, xmalloc_base, n, INIT_MATCH_STACK_SIZE);
    15591662  pop_level = reg->stack_pop_level;
    15601663  num_mem = reg->num_mem;
    1561   repeat_stk = (OnigStackIndex* )*palloca_base;
     1664  repeat_stk = (OnigStackIndex* )alloca_base;
    15621665
    15631666  mem_start_stk = (OnigStackIndex* )(repeat_stk + reg->num_repeat);
    1564   mem_end_stk   = mem_start_stk + (num_mem + 1);
    1565 #else /* USE_SUBEXP_CALL */
    1566   /* Stack #0 not is used. */
    1567   n = reg->num_repeat + reg->num_mem * 2;
    1568 
    1569   STACK_INIT(*palloca_base, xmalloc_base, n, INIT_MATCH_STACK_SIZE);
    1570   pop_level = reg->stack_pop_level;
    1571   num_mem = reg->num_mem;
    1572   repeat_stk = (OnigStackIndex* )*palloca_base;
    1573 
    1574   mem_start_stk = (OnigStackIndex* )(repeat_stk + reg->num_repeat);
    1575   mem_end_stk   = mem_start_stk + num_mem;
     1667  mem_end_stk   = mem_start_stk + (num_mem + ADD_NUMMEM);
     1668  {
     1669    OnigStackIndex *pp = mem_start_stk;
     1670    for (; pp < repeat_stk + n; pp += 2) {
     1671      pp[0] = INVALID_STACK_INDEX;
     1672      pp[1] = INVALID_STACK_INDEX;
     1673    }
     1674  }
     1675#ifndef USE_SUBEXP_CALL
    15761676  mem_start_stk--; /* for index start from 1,
    15771677                      mem_start_stk[1]..mem_start_stk[num_mem] */
    15781678  mem_end_stk--;   /* for index start from 1,
    15791679                      mem_end_stk[1]..mem_end_stk[num_mem] */
    1580 #endif /* USE_SUBEXP_CALL */
    1581   {
    1582       OnigStackIndex *pp = mem_start_stk;
    1583       for (; pp < (repeat_stk + n); pp+=2) {
    1584           pp[0] = INVALID_STACK_INDEX;
    1585           pp[1] = INVALID_STACK_INDEX;
    1586       }
    1587   }
     1680#endif
    15881681
    15891682#ifdef ONIG_DEBUG_MATCH
    1590   fprintf(stderr, "match_at: str: %"PRIdPTR" (%p), end: %"PRIdPTR" (%p), start: %"PRIdPTR" (%p), sprev: %"PRIdPTR" (%p)\n",
    1591           (intptr_t )str, str, (intptr_t )end, end, (intptr_t )sstart, sstart, (intptr_t )sprev, sprev);
     1683  fprintf(stderr, "match_at: str: %"PRIuPTR" (%p), end: %"PRIuPTR" (%p), start: %"PRIuPTR" (%p), sprev: %"PRIuPTR" (%p)\n",
     1684          (uintptr_t )str, str, (uintptr_t )end, end, (uintptr_t )sstart, sstart, (uintptr_t )sprev, sprev);
    15921685  fprintf(stderr, "size: %d, start offset: %d\n",
    15931686          (int )(end - str), (int )(sstart - str));
     1687  fprintf(stderr, "\n ofs> str                   stk:type   addr:opcode\n");
    15941688#endif
    15951689
    … …  
    16011695
    16021696#ifdef ONIG_DEBUG_MATCH
    1603 #define OPCODE_EXEC_HOOK                                                \
     1697# define OPCODE_EXEC_HOOK                                               \
    16041698    if (s) {                                                            \
    16051699      UChar *op, *q, *bp, buf[50];                                      \
    16061700      int len;                                                          \
    1607       op = p - 1;                                                       \
     1701      op = p - OP_OFFSET;                                               \
    16081702      fprintf(stderr, "%4"PRIdPTR"> \"", (*op == OP_FINISH) ? (ptrdiff_t )-1 : s - str); \
    16091703      bp = buf;                                                         \
    … …  
    16111705      if (*op != OP_FINISH) {    /* s may not be a valid pointer if OP_FINISH. */ \
    16121706        for (i = 0; i < 7 && q < end; i++) {                            \
    1613           len = enclen(encode, q);                                      \
     1707          len = enclen(encode, q, end);                                 \
    16141708          while (len-- > 0) *bp++ = *q++;                               \
    16151709        }                                                               \
     1710        if (q < end) { xmemcpy(bp, "...", 3); bp += 3; }                \
    16161711      }                                                                 \
    1617       if (q < end) { xmemcpy(bp, "...\"", 4); bp += 4; }                \
    1618       else         { xmemcpy(bp, "\"",    1); bp += 1; }                \
     1712      xmemcpy(bp, "\"", 1); bp += 1;                                    \
    16191713      *bp = 0;                                                          \
    16201714      fputs((char* )buf, stderr);                                       \
    16211715      for (i = 0; i < 20 - (bp - buf); i++) fputc(' ', stderr);         \
    1622       fprintf(stderr, "%4"PRIdPTR":", (op == FinishCode) ? (ptrdiff_t )-1 : op - reg->p); \
    1623       onig_print_compiled_byte_code(stderr, op, NULL, encode);           \
     1716      fprintf(stderr, "%4"PRIdPTR":%s %4"PRIdPTR":",                    \
     1717          stk - stk_base - 1,                                           \
     1718          (stk > stk_base) ? stack_type_str(stk[-1].type) : "      ",   \
     1719          (op == FinishCode) ? (ptrdiff_t )-1 : op - reg->p);           \
     1720      onig_print_compiled_byte_code(stderr, op, reg->p+reg->used, NULL, encode); \
    16241721      fprintf(stderr, "\n");                                            \
    16251722    }
    16261723#else
    1627 #define OPCODE_EXEC_HOOK ((void) 0)
     1724# define OPCODE_EXEC_HOOK ((void) 0)
    16281725#endif
    16291726
    … …  
    16421739          else
    16431740            goto end_best_len;
    1644         }
     1741        }
    16451742#endif
    16461743        best_len = n;
    16471744        region = msa->region;
    16481745        if (region) {
    1649 #ifdef USE_POSIX_API_REGION_OPTION
    1650           if (IS_POSIX_REGION(msa->options)) {
    1651             posix_regmatch_t* rmt = (posix_regmatch_t* )region;
    1652 
    1653             rmt[0].rm_so = (regoff_t )(((pkeep > s) ? s : pkeep) - str);
    1654             rmt[0].rm_eo = (regoff_t )(s - str);
    1655             for (i = 1; i <= num_mem; i++) {
    1656               if (mem_end_stk[i] != INVALID_STACK_INDEX) {
    1657                 if (BIT_STATUS_AT(reg->bt_mem_start, i))
    1658                   rmt[i].rm_so = (regoff_t )(STACK_AT(mem_start_stk[i])->u.mem.pstr - str);
    1659                 else
    1660                   rmt[i].rm_so = (regoff_t )((UChar* )((void* )(mem_start_stk[i])) - str);
    1661 
    1662                 rmt[i].rm_eo = (regoff_t )((BIT_STATUS_AT(reg->bt_mem_end, i)
     1746          region->beg[0] = ((pkeep > s) ? s : pkeep) - str;
     1747          region->end[0] = s - str;
     1748          for (i = 1; i <= num_mem; i++) {
     1749            if (mem_end_stk[i] != INVALID_STACK_INDEX) {
     1750              if (BIT_STATUS_AT(reg->bt_mem_start, i))
     1751                region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
     1752              else
     1753                region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str;
     1754
     1755              region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i)
    16631756                                ? STACK_AT(mem_end_stk[i])->u.mem.pstr
    1664                                 : (UChar* )((void* )mem_end_stk[i])) - str);
    1665               }
    1666               else {
    1667                 rmt[i].rm_so = rmt[i].rm_eo = ONIG_REGION_NOTPOS;
    1668               }
     1757                                : (UChar* )((void* )mem_end_stk[i])) - str;
     1758            }
     1759            else {
     1760              region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
    16691761            }
    16701762          }
    1671           else {
    1672 #endif /* USE_POSIX_API_REGION_OPTION */
    1673             region->beg[0] = ((pkeep > s) ? s : pkeep) - str;
    1674             region->end[0] = s - str;
    1675             for (i = 1; i <= num_mem; i++) {
    1676               if (mem_end_stk[i] != INVALID_STACK_INDEX) {
    1677                 if (BIT_STATUS_AT(reg->bt_mem_start, i))
    1678                   region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
    1679                 else
    1680                   region->beg[i] = (UChar* )((void* )mem_start_stk[i]) - str;
    1681 
    1682                 region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i)
    1683                                   ? STACK_AT(mem_end_stk[i])->u.mem.pstr
    1684                                   : (UChar* )((void* )mem_end_stk[i])) - str;
    1685               }
    1686               else {
    1687                 region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
    1688               }
     1763
     1764#ifdef USE_CAPTURE_HISTORY
     1765          if (reg->capture_history != 0) {
     1766            int r;
     1767            OnigCaptureTreeNode* node;
     1768
     1769            if (IS_NULL(region->history_root)) {
     1770              region->history_root = node = history_node_new();
     1771              CHECK_NULL_RETURN_MEMERR(node);
    16891772            }
    1690 
    1691 #ifdef USE_CAPTURE_HISTORY
    1692             if (reg->capture_history != 0) {
    1693               int r;
    1694               OnigCaptureTreeNode* node;
    1695 
    1696               if (IS_NULL(region->history_root)) {
    1697                 region->history_root = node = history_node_new();
    1698                 CHECK_NULL_RETURN_MEMERR(node);
    1699               }
    1700               else {
    1701                 node = region->history_root;
    1702                 history_tree_clear(node);
    1703               }
    1704 
    1705               node->group = 0;
    1706               node->beg   = ((pkeep > s) ? s : pkeep) - str;
    1707               node->end   = s - str;
    1708 
    1709               stkp = stk_base;
    1710               r = make_capture_history_tree(region->history_root, &stkp,
    1711                                             stk, (UChar* )str, reg);
    1712               if (r < 0) {
    1713                 best_len = r; /* error code */
    1714                 goto finish;
    1715               }
     1773            else {
     1774              node = region->history_root;
     1775              history_tree_clear(node);
    17161776            }
     1777
     1778            node->group = 0;
     1779            node->beg   = ((pkeep > s) ? s : pkeep) - str;
     1780            node->end   = s - str;
     1781
     1782            stkp = stk_base;
     1783            r = make_capture_history_tree(region->history_root, &stkp,
     1784                stk, (UChar* )str, reg);
     1785            if (r < 0) {
     1786              best_len = r; /* error code */
     1787              goto finish;
     1788            }
     1789          }
    17171790#endif /* USE_CAPTURE_HISTORY */
    1718 #ifdef USE_POSIX_API_REGION_OPTION
    1719           } /* else IS_POSIX_REGION() */
    1720 #endif
    17211791        } /* if (region) */
    17221792      } /* n > best_len */
    … …  
    17421812
    17431813    CASE(OP_EXACT1)  MOP_IN(OP_EXACT1);
    1744 #if 0
    17451814      DATA_ENSURE(1);
    17461815      if (*p != *s) goto fail;
    17471816      p++; s++;
    1748 #endif
    1749       if (*p != *s++) goto fail;
    1750       DATA_ENSURE(0);
    1751       p++;
    17521817      MOP_OUT;
    17531818      NEXT;
    … …  
    17671832        while (len-- > 0) {
    17681833          if (*p != *q) {
    1769             goto fail;
    1770           }
     1834            goto fail;
     1835          }
    17711836          p++; q++;
    17721837        }
    … …  
    19502015      if (BITSET_AT(((BitSetRef )p), *s) == 0) goto fail;
    19512016      p += SIZE_BITSET;
    1952       s += enclen(encode, s);   /* OP_CCLASS can match mb-code. \D, \S */
     2017      s += enclen(encode, s, end);   /* OP_CCLASS can match mb-code. \D, \S */
    19532018      MOP_OUT;
    19542019      NEXT;
    19552020
    19562021    CASE(OP_CCLASS_MB)  MOP_IN(OP_CCLASS_MB);
    1957       if (! ONIGENC_IS_MBC_HEAD(encode, s)) goto fail;
     2022      if (! ONIGENC_IS_MBC_HEAD(encode, s, end)) goto fail;
    19582023
    19592024    cclass_mb:
    … …  
    19652030
    19662031        DATA_ENSURE(1);
    1967         mb_len = enclen(encode, s);
     2032        mb_len = enclen(encode, s, end);
    19682033        DATA_ENSURE(mb_len);
    19692034        ss = s;
    … …  
    19852050    CASE(OP_CCLASS_MIX)  MOP_IN(OP_CCLASS_MIX);
    19862051      DATA_ENSURE(1);
    1987       if (ONIGENC_IS_MBC_HEAD(encode, s)) {
     2052      if (ONIGENC_IS_MBC_HEAD(encode, s, end)) {
    19882053        p += SIZE_BITSET;
    19892054        goto cclass_mb;
    … …  
    20052070      if (BITSET_AT(((BitSetRef )p), *s) != 0) goto fail;
    20062071      p += SIZE_BITSET;
    2007       s += enclen(encode, s);
     2072      s += enclen(encode, s, end);
    20082073      MOP_OUT;
    20092074      NEXT;
    … …  
    20112076    CASE(OP_CCLASS_MB_NOT)  MOP_IN(OP_CCLASS_MB_NOT);
    20122077      DATA_ENSURE(1);
    2013       if (! ONIGENC_IS_MBC_HEAD(encode, s)) {
     2078      if (! ONIGENC_IS_MBC_HEAD(encode, s, end)) {
    20142079        s++;
    20152080        GET_LENGTH_INC(tlen, p);
    … …  
    20232088        OnigCodePoint code;
    20242089        UChar *ss;
    2025         int mb_len = enclen(encode, s);
     2090        int mb_len = enclen(encode, s, end);
    20262091
    20272092        if (! DATA_ENSURE_CHECK(mb_len)) {
    2028           DATA_ENSURE(1);
     2093          DATA_ENSURE(1);
    20292094          s = (UChar* )end;
    20302095          p += tlen;
    … …  
    20522117    CASE(OP_CCLASS_MIX_NOT)  MOP_IN(OP_CCLASS_MIX_NOT);
    20532118      DATA_ENSURE(1);
    2054       if (ONIGENC_IS_MBC_HEAD(encode, s)) {
     2119      if (ONIGENC_IS_MBC_HEAD(encode, s, end)) {
    20552120        p += SIZE_BITSET;
    20562121        goto cclass_mb_not;
    … …  
    20682133      NEXT;
    20692134
    2070     CASE(OP_CCLASS_NODE)  MOP_IN(OP_CCLASS_NODE);
    2071       {
    2072         OnigCodePoint code;
    2073         void *node;
    2074         int mb_len;
    2075         UChar *ss;
    2076 
    2077         DATA_ENSURE(1);
    2078         GET_POINTER_INC(node, p);
    2079         mb_len = enclen(encode, s);
    2080         ss = s;
    2081         s += mb_len;
    2082         DATA_ENSURE(0);
    2083         code = ONIGENC_MBC_TO_CODE(encode, ss, s);
    2084         if (onig_is_code_in_cc_len(mb_len, code, node) == 0) goto fail;
    2085       }
    2086       MOP_OUT;
    2087       NEXT;
    2088 
    20892135    CASE(OP_ANYCHAR)  MOP_IN(OP_ANYCHAR);
    20902136      DATA_ENSURE(1);
    2091       n = enclen(encode, s);
     2137      n = enclen(encode, s, end);
    20922138      DATA_ENSURE(n);
    20932139      if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0)) goto fail;
    … …  
    20982144    CASE(OP_ANYCHAR_ML)  MOP_IN(OP_ANYCHAR_ML);
    20992145      DATA_ENSURE(1);
    2100       n = enclen(encode, s);
     2146      n = enclen(encode, s, end);
    21012147      DATA_ENSURE(n);
    21022148      s += n;
    … …  
    21072153      while (DATA_ENSURE_CHECK1) {
    21082154        STACK_PUSH_ALT(p, s, sprev, pkeep);
    2109         n = enclen(encode, s);
    2110         DATA_ENSURE(n);
    2111         if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))  goto fail;
    2112         sprev = s;
    2113         s += n;
    2114       }
    2115       MOP_OUT;
    2116       NEXT;
     2155        n = enclen(encode, s, end);
     2156        DATA_ENSURE(n);
     2157        if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))  goto fail;
     2158        sprev = s;
     2159        s += n;
     2160      }
     2161      MOP_OUT;
     2162      JUMP;
    21172163
    21182164    CASE(OP_ANYCHAR_ML_STAR)  MOP_IN(OP_ANYCHAR_ML_STAR);
    21192165      while (DATA_ENSURE_CHECK1) {
    21202166        STACK_PUSH_ALT(p, s, sprev, pkeep);
    2121         n = enclen(encode, s);
     2167        n = enclen(encode, s, end);
    21222168        if (n > 1) {
    21232169          DATA_ENSURE(n);
    … …  
    21312177      }
    21322178      MOP_OUT;
    2133       NEXT;
     2179      JUMP;
    21342180
    21352181    CASE(OP_ANYCHAR_STAR_PEEK_NEXT)  MOP_IN(OP_ANYCHAR_STAR_PEEK_NEXT);
    … …  
    21382184          STACK_PUSH_ALT(p + 1, s, sprev, pkeep);
    21392185        }
    2140         n = enclen(encode, s);
    2141         DATA_ENSURE(n);
    2142         if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))  goto fail;
    2143         sprev = s;
    2144         s += n;
     2186        n = enclen(encode, s, end);
     2187        DATA_ENSURE(n);
     2188        if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))  goto fail;
     2189        sprev = s;
     2190        s += n;
    21452191      }
    21462192      p++;
    … …  
    21532199          STACK_PUSH_ALT(p + 1, s, sprev, pkeep);
    21542200        }
    2155         n = enclen(encode, s);
     2201        n = enclen(encode, s, end);
    21562202        if (n > 1) {
    21572203          DATA_ENSURE(n);
    … …  
    21762222
    21772223        STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep);
    2178         n = enclen(encode, s);
    2179         DATA_ENSURE(n);
    2180         if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))  goto fail;
    2181         sprev = s;
    2182         s += n;
     2224        n = enclen(encode, s, end);
     2225        DATA_ENSURE(n);
     2226        if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))  goto fail;
     2227        sprev = s;
     2228        s += n;
    21832229      }
    21842230      MOP_OUT;
    … …  
    21942240
    21952241        STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep);
    2196         n = enclen(encode, s);
     2242        n = enclen(encode, s, end);
    21972243        if (n > 1) {
    21982244          DATA_ENSURE(n);
    … …  
    22142260        goto fail;
    22152261
    2216       s += enclen(encode, s);
     2262      s += enclen(encode, s, end);
    22172263      MOP_OUT;
    22182264      NEXT;
    … …  
    22232269        goto fail;
    22242270
    2225       s += enclen(encode, s);
     2271      s += enclen(encode, s, end);
    22262272      MOP_OUT;
    22272273      NEXT;
    … …  
    22322278        goto fail;
    22332279
    2234       s += enclen(encode, s);
     2280      s += enclen(encode, s, end);
    22352281      MOP_OUT;
    22362282      NEXT;
    … …  
    22412287        goto fail;
    22422288
    2243       s += enclen(encode, s);
     2289      s += enclen(encode, s, end);
    22442290      MOP_OUT;
    22452291      NEXT;
    … …  
    23722418
    23732419    CASE(OP_BEGIN_LINE)  MOP_IN(OP_BEGIN_LINE);
    2374     op_begin_line:
    23752420      if (ON_STR_BEGIN(s)) {
    23762421        if (IS_NOTBOL(msa->options)) goto fail;
    … …  
    24222467      }
    24232468      else if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 1)) {
    2424         UChar* ss = s + enclen(encode, s);
     2469        UChar* ss = s + enclen(encode, s, end);
    24252470        if (ON_STR_END(ss)) {
    24262471          MOP_OUT;
    … …  
    24302475        else if (IS_NEWLINE_CRLF(option)
    24312476            && ONIGENC_IS_MBC_CRNL(encode, s, end)) {
    2432           ss += enclen(encode, ss);
     2477          ss += enclen(encode, ss, end);
    24332478          if (ON_STR_END(ss)) {
    24342479            MOP_OUT;
    … …  
    24442489      if (s != msa->gpos)
    24452490        goto fail;
    2446 
    2447       MOP_OUT;
    2448       JUMP;
    2449 
    2450     CASE(OP_BEGIN_POS_OR_LINE)  MOP_IN(OP_BEGIN_POS_OR_LINE);
    2451       if (s != msa->gpos)
    2452         goto op_begin_line;
    24532491
    24542492      MOP_OUT;
    … …  
    25432581        sprev = s;
    25442582        STRING_CMP(pstart, s, n);
    2545         while (sprev + (len = enclen(encode, sprev)) < s)
     2583        while (sprev + (len = enclen(encode, sprev, end)) < s)
    25462584          sprev += len;
    25472585
    … …  
    25732611        DATA_ENSURE(n);
    25742612        sprev = s;
    2575         STRING_CMP_IC(case_fold_flag, pstart, &s, n);
    2576         while (sprev + (len = enclen(encode, sprev)) < s)
     2613        STRING_CMP_IC(case_fold_flag, pstart, &s, (int)n, end);
     2614        while (sprev + (len = enclen(encode, sprev, end)) < s)
    25772615          sprev += len;
    25782616
    … …  
    26092647          if (is_fail) continue;
    26102648          s = swork;
    2611           while (sprev + (len = enclen(encode, sprev)) < s)
     2649          while (sprev + (len = enclen(encode, sprev, end)) < s)
    26122650            sprev += len;
    26132651
    … …  
    26452683          sprev = s;
    26462684          swork = s;
    2647           STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, is_fail);
     2685          STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, end, is_fail);
    26482686          if (is_fail) continue;
    26492687          s = swork;
    2650           while (sprev + (len = enclen(encode, sprev)) < s)
     2688          while (sprev + (len = enclen(encode, sprev, end)) < s)
    26512689            sprev += len;
    26522690
    … …  
    26712709
    26722710        sprev = s;
    2673         if (backref_match_at_nested_level(reg, stk, stk_base, ic
    2674                   , case_fold_flag, (int )level, (int )tlen, p, &s, end)) {
    2675           while (sprev + (len = enclen(encode, sprev)) < s)
     2711        if (backref_match_at_nested_level(reg, stk, stk_base, ic,
     2712                  case_fold_flag, (int )level, (int )tlen, p, &s, end)) {
     2713          while (sprev + (len = enclen(encode, sprev, end)) < s)
    26762714            sprev += len;
    26772715
    … …  
    27152753        if (isnull) {
    27162754#ifdef ONIG_DEBUG_MATCH
    2717           fprintf(stderr, "NULL_CHECK_END: skip  id:%d, s:%"PRIdPTR" (%p)\n",
    2718                   (int )mem, (intptr_t )s, s);
     2755          fprintf(stderr, "NULL_CHECK_END: skip  id:%d, s:%"PRIuPTR" (%p)\n",
     2756                  (int )mem, (uintptr_t )s, s);
    27192757#endif
    27202758        null_check_found:
    … …  
    27482786        STACK_NULL_CHECK_MEMST(isnull, mem, s, reg);
    27492787        if (isnull) {
    2750 #ifdef ONIG_DEBUG_MATCH
    2751           fprintf(stderr, "NULL_CHECK_END_MEMST: skip  id:%d, s:%"PRIdPTR" (%p)\n",
    2752                   (int )mem, (intptr_t )s, s);
    2753 #endif
     2788# ifdef ONIG_DEBUG_MATCH
     2789          fprintf(stderr, "NULL_CHECK_END_MEMST: skip  id:%d, s:%"PRIuPTR" (%p)\n",
     2790                  (int )mem, (uintptr_t )s, s);
     2791# endif
    27542792          if (isnull == -1) goto fail;
    27552793          goto null_check_found;
    … …  
    27672805
    27682806        GET_MEMNUM_INC(mem, p); /* mem: null check id */
    2769 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
     2807# ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
    27702808        STACK_NULL_CHECK_MEMST_REC(isnull, mem, s, reg);
    2771 #else
     2809# else
    27722810        STACK_NULL_CHECK_REC(isnull, mem, s);
    2773 #endif
     2811# endif
    27742812        if (isnull) {
    2775 #ifdef ONIG_DEBUG_MATCH
    2776           fprintf(stderr, "NULL_CHECK_END_MEMST_PUSH: skip  id:%d, s:%"PRIdPTR" (%p)\n",
    2777                   (int )mem, (intptr_t )s, s);
    2778 #endif
     2813# ifdef ONIG_DEBUG_MATCH
     2814          fprintf(stderr, "NULL_CHECK_END_MEMST_PUSH: skip  id:%d, s:%"PRIuPTR" (%p)\n",
     2815                  (int )mem, (uintptr_t )s, s);
     2816# endif
    27792817          if (isnull == -1) goto fail;
    27802818          goto null_check_found;
    … …  
    28402878      JUMP;
    28412879
     2880#ifdef USE_OP_PUSH_OR_JUMP_EXACT
    28422881    CASE(OP_PUSH_OR_JUMP_EXACT1)  MOP_IN(OP_PUSH_OR_JUMP_EXACT1);
    28432882      GET_RELADDR_INC(addr, p);
    … …  
    28512890      MOP_OUT;
    28522891      JUMP;
     2892#endif
    28532893
    28542894    CASE(OP_PUSH_IF_PEEK_NEXT)  MOP_IN(OP_PUSH_IF_PEEK_NEXT);
    … …  
    29052945      stkp->u.repeat.count++;
    29062946      if (stkp->u.repeat.count >= reg->repeat_range[mem].upper) {
    2907         /* end of repeat. Nothing to do. */
     2947        /* end of repeat. Nothing to do. */
    29082948      }
    29092949      else if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
    2910         STACK_PUSH_ALT(p, s, sprev, pkeep);
    2911         p = STACK_AT(si)->u.repeat.pcode; /* Don't use stkp after PUSH. */
     2950        STACK_PUSH_ALT(p, s, sprev, pkeep);
     2951        p = STACK_AT(si)->u.repeat.pcode; /* Don't use stkp after PUSH. */
    29122952      }
    29132953      else {
    2914         p = stkp->u.repeat.pcode;
     2954        p = stkp->u.repeat.pcode;
    29152955      }
    29162956      STACK_PUSH_REPEAT_INC(si);
    … …  
    29342974      stkp->u.repeat.count++;
    29352975      if (stkp->u.repeat.count < reg->repeat_range[mem].upper) {
    2936         if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
    2937           UChar* pcode = stkp->u.repeat.pcode;
    2938 
    2939           STACK_PUSH_REPEAT_INC(si);
    2940           STACK_PUSH_ALT(pcode, s, sprev, pkeep);
    2941         }
    2942         else {
    2943           p = stkp->u.repeat.pcode;
    2944           STACK_PUSH_REPEAT_INC(si);
    2945         }
     2976        if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
     2977          UChar* pcode = stkp->u.repeat.pcode;
     2978
     2979          STACK_PUSH_REPEAT_INC(si);
     2980          STACK_PUSH_ALT(pcode, s, sprev, pkeep);
     2981        }
     2982        else {
     2983          p = stkp->u.repeat.pcode;
     2984          STACK_PUSH_REPEAT_INC(si);
     2985        }
    29462986      }
    29472987      else if (stkp->u.repeat.count == reg->repeat_range[mem].upper) {
    2948         STACK_PUSH_REPEAT_INC(si);
     2988        STACK_PUSH_REPEAT_INC(si);
    29492989      }
    29502990      MOP_OUT;
    … …  
    29963036    CASE(OP_LOOK_BEHIND)  MOP_IN(OP_LOOK_BEHIND);
    29973037      GET_LENGTH_INC(tlen, p);
    2998       s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen);
     3038      s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (int )tlen);
    29993039      if (IS_NULL(s)) goto fail;
    3000       sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);
     3040      sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end);
    30013041      MOP_OUT;
    30023042      JUMP;
    … …  
    30053045      GET_RELADDR_INC(addr, p);
    30063046      GET_LENGTH_INC(tlen, p);
    3007       q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen);
     3047      q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (int )tlen);
    30083048      if (IS_NULL(q)) {
    30093049        /* too short case -> success. ex. /(?<!XXX)a/.match("a")
    … …  
    30153055        STACK_PUSH_LOOK_BEHIND_NOT(p + addr, s, sprev, pkeep);
    30163056        s = q;
    3017         sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);
     3057        sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end);
    30183058      }
    30193059      MOP_OUT;
    … …  
    30223062    CASE(OP_FAIL_LOOK_BEHIND_NOT)  MOP_IN(OP_FAIL_LOOK_BEHIND_NOT);
    30233063      STACK_POP_TIL_LOOK_BEHIND_NOT;
     3064      goto fail;
     3065      NEXT;
     3066
     3067    CASE(OP_PUSH_ABSENT_POS)  MOP_IN(OP_PUSH_ABSENT_POS);
     3068      /* Save the absent-start-pos and the original end-pos. */
     3069      STACK_PUSH_ABSENT_POS(s, ABSENT_END_POS);
     3070      MOP_OUT;
     3071      JUMP;
     3072
     3073    CASE(OP_ABSENT)  MOP_IN(OP_ABSENT);
     3074      {
     3075        const UChar* aend = ABSENT_END_POS;
     3076        UChar* absent;
     3077        UChar* selfp = p - 1;
     3078
     3079        STACK_POP_ABSENT_POS(absent, ABSENT_END_POS);  /* Restore end-pos. */
     3080        GET_RELADDR_INC(addr, p);
     3081#ifdef ONIG_DEBUG_MATCH
     3082        fprintf(stderr, "ABSENT: s:%p, end:%p, absent:%p, aend:%p\n", s, end, absent, aend);
     3083#endif
     3084        if ((absent > aend) && (s > absent)) {
     3085          /* An empty match occurred in (?~...) at the start point.
     3086           * Never match. */
     3087          STACK_POP;
     3088          goto fail;
     3089        }
     3090        else if ((s >= aend) && (s > absent)) {
     3091          if (s > aend) {
     3092            /* Only one (or less) character matched in the last iteration.
     3093             * This is not a possible point. */
     3094            goto fail;
     3095          }
     3096          /* All possible points were found. Try matching after (?~...). */
     3097          DATA_ENSURE(0);
     3098          p += addr;
     3099        }
     3100        else {
     3101          STACK_PUSH_ALT(p + addr, s, sprev, pkeep); /* Push possible point. */
     3102          n = enclen(encode, s, end);
     3103          STACK_PUSH_ABSENT_POS(absent, ABSENT_END_POS); /* Save the original pos. */
     3104          STACK_PUSH_ALT(selfp, s + n, s, pkeep); /* Next iteration. */
     3105          STACK_PUSH_ABSENT;
     3106          ABSENT_END_POS = aend;
     3107        }
     3108      }
     3109      MOP_OUT;
     3110      JUMP;
     3111
     3112    CASE(OP_ABSENT_END)  MOP_IN(OP_ABSENT_END);
     3113      /* The pattern inside (?~...) was matched.
     3114       * Set the end-pos temporary and go to next iteration. */
     3115      if (sprev < ABSENT_END_POS)
     3116        ABSENT_END_POS = sprev;
     3117#ifdef ONIG_DEBUG_MATCH
     3118      fprintf(stderr, "ABSENT_END: end:%p\n", ABSENT_END_POS);
     3119#endif
     3120      STACK_POP_TIL_ABSENT;
    30243121      goto fail;
    30253122      NEXT;
    … …  
    30573154    CASE(OP_FAIL)
    30583155      if (0) {
    3059         /* fall */
     3156        /* fall */
    30603157      fail:
    3061         MOP_OUT;
     3158        MOP_OUT;
    30623159      }
    30633160      MOP_IN(OP_FAIL);
    … …  
    30703167#ifdef USE_COMBINATION_EXPLOSION_CHECK
    30713168      if (stk->u.state.state_check != 0) {
    3072         stk->type = STK_STATE_CHECK_MARK;
    3073         stk++;
     3169        stk->type = STK_STATE_CHECK_MARK;
     3170        stk++;
    30743171      }
    30753172#endif
    … …  
    31053202}
    31063203
    3107 static OnigPosition
    3108 match_at(regex_t* reg, const UChar* str, const UChar* end,
    3109 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    3110         const UChar* right_range,
    3111 #endif
    3112         const UChar* sstart, UChar* sprev, OnigMatchArg* msa)
    3113 {
    3114         char *alloca_base = NULL;
    3115         OnigPosition ret = match_at_(reg, str, end,
    3116 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    3117                 right_range,
    3118 #endif
    3119                 sstart, sprev, msa, &alloca_base);
    3120         if(alloca_base) xfree(alloca_base);
    3121         return ret;
    3122 }
    31233204
    31243205static UChar*
    … …  
    31563237        return s;
    31573238    }
    3158     s += enclen(enc, s);
     3239    s += enclen(enc, s, text_end);
    31593240  }
    31603241
    … …  
    31643245static int
    31653246str_lower_case_match(OnigEncoding enc, int case_fold_flag,
    3166                      const UChar* t, const UChar* tend,
     3247                     const UChar* t, const UChar* tend,
    31673248                     const UChar* p, const UChar* end)
    31683249{
    … …  
    32013282      return s;
    32023283
    3203     s += enclen(enc, s);
     3284    s += enclen(enc, s, text_end);
    32043285  }
    32053286
    … …  
    32193300    s = (UChar* )text_start;
    32203301  else
    3221     s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s);
     3302    s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s, text_end);
    32223303
    32233304  while (s >= text) {
    … …  
    32333314        return s;
    32343315    }
    3235     s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s);
     3316    s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
    32363317  }
    32373318
    … …  
    32523333    s = (UChar* )text_start;
    32533334  else
    3254     s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s);
     3335    s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s, text_end);
    32553336
    32563337  while (s >= text) {
    32573338    if (str_lower_case_match(enc, case_fold_flag,
    3258                              target, target_end, s, text_end))
     3339                             target, target_end, s, text_end))
    32593340      return s;
    32603341
    3261     s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s);
     3342    s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
    32623343  }
    32633344
    … …  
    32763357  ptrdiff_t skip, tlen1;
    32773358
    3278 #ifdef ONIG_DEBUG_SEARCH
     3359# ifdef ONIG_DEBUG_SEARCH
    32793360  fprintf(stderr, "bm_search_notrev: text: %"PRIuPTR" (%p), text_end: %"PRIuPTR" (%p), text_range: %"PRIuPTR" (%p)\n",
    3280           text, text, text_end, text_end, text_range, text_range);
    3281 #endif
     3361          (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
     3362# endif
    32823363
    32833364  tail = target_end - 1;
    … …  
    33003381      t = s;
    33013382      do {
    3302         s += enclen(reg->enc, s);
     3383        s += enclen(reg->enc, s, end);
    33033384      } while ((s - t) < skip && s < end);
    33043385    }
    33053386  }
    33063387  else {
     3388# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    33073389    while (s < end) {
    33083390      p = se = s + tlen1;
    … …  
    33153397      t = s;
    33163398      do {
    3317         s += enclen(reg->enc, s);
     3399        s += enclen(reg->enc, s, end);
    33183400      } while ((s - t) < skip && s < end);
    33193401    }
     3402# endif
    33203403  }
    33213404
    … …  
    33313414  const UChar *tail;
    33323415
    3333 #ifdef ONIG_DEBUG_SEARCH
    3334   fprintf(stderr, "bm_search: text: %"PRIuPTR", text_end: %"PRIuPTR", text_range: %"PRIuPTR"\n",
    3335           text, text_end, text_range);
    3336 #endif
     3416# ifdef ONIG_DEBUG_SEARCH
     3417  fprintf(stderr, "bm_search: text: %"PRIuPTR" (%p), text_end: %"PRIuPTR" (%p), text_range: %"PRIuPTR" (%p)\n",
     3418          (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
     3419# endif
    33373420
    33383421  end = text_range + (target_end - target) - 1;
    … …  
    33463429      p = s;
    33473430      t = tail;
    3348 #ifdef ONIG_DEBUG_SEARCH
     3431# ifdef ONIG_DEBUG_SEARCH
    33493432      fprintf(stderr, "bm_search_loop: pos: %"PRIdPTR" %s\n",
    33503433          (intptr_t )(s - text), s);
    3351 #endif
     3434# endif
    33523435      while (*p == *t) {
    33533436        if (t == target) return (UChar* )p;
    … …  
    33583441  }
    33593442  else { /* see int_map[] */
     3443# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    33603444    while (s < end) {
    33613445      p = s;
    … …  
    33673451      s += reg->int_map[*s];
    33683452    }
     3453# endif
    33693454  }
    33703455  return (UChar* )NULL;
    … …  
    33833468  int case_fold_flag = reg->case_fold_flag;
    33843469
    3385 #ifdef ONIG_DEBUG_SEARCH
     3470# ifdef ONIG_DEBUG_SEARCH
    33863471  fprintf(stderr, "bm_search_notrev_ic: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
    33873472          (int )text, text, (int )text_end, text_end, (int )text_range, text_range);
    3388 #endif
     3473# endif
    33893474
    33903475  tail = target_end - 1;
    … …  
    34053490      t = s;
    34063491      do {
    3407         s += enclen(reg->enc, s);
     3492        s += enclen(reg->enc, s, end);
    34083493      } while ((s - t) < skip && s < end);
    34093494    }
    34103495  }
    34113496  else {
     3497# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    34123498    while (s < end) {
    34133499      se = s + tlen1;
    … …  
    34183504      t = s;
    34193505      do {
    3420         s += enclen(reg->enc, s);
     3506        s += enclen(reg->enc, s, end);
    34213507      } while ((s - t) < skip && s < end);
    34223508    }
     3509# endif
    34233510  }
    34243511
    … …  
    34363523  int case_fold_flag = reg->case_fold_flag;
    34373524
    3438 #ifdef ONIG_DEBUG_SEARCH
     3525# ifdef ONIG_DEBUG_SEARCH
    34393526  fprintf(stderr, "bm_search_ic: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
    34403527          (int )text, text, (int )text_end, text_end, (int )text_range, text_range);
    3441 #endif
     3528# endif
    34423529
    34433530  end = text_range + (target_end - target) - 1;
    … …  
    34573544  }
    34583545  else { /* see int_map[] */
     3546# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    34593547    while (s < end) {
    34603548      p = s - (target_end - target) + 1;
    … …  
    34643552      s += reg->int_map[*s];
    34653553    }
     3554# endif
    34663555  }
    34673556  return (UChar* )NULL;
    … …  
    34803569  ptrdiff_t skip, tlen1;
    34813570  OnigEncoding enc = reg->enc;
    3482   int (*mbc_enc_len)(const OnigUChar* p) = enc->mbc_enc_len;
    3483 
    3484 #ifdef ONIG_DEBUG_SEARCH
    3485   fprintf(stderr, "bm_search_notrev: text: %"PRIdPTR" (%p), text_end: %"PRIdPTR" (%p), text_range: %"PRIdPTR" (%p)\n",
    3486           (intptr_t )text, text, (intptr_t )text_end, text_end, (intptr_t )text_range, text_range);
    3487 #endif
     3571
     3572# ifdef ONIG_DEBUG_SEARCH
     3573  fprintf(stderr, "bm_search_notrev: text: %"PRIuPTR" (%p), text_end: %"PRIuPTR" (%p), text_range: %"PRIuPTR" (%p)\n",
     3574          (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
     3575# endif
    34883576
    34893577  tail = target_end - 1;
    … …  
    35073595      t = s;
    35083596      do {
    3509         s += mbc_enc_len(s);
     3597        s += enclen(enc, s, end);
    35103598      } while ((s - t) < skip && s < end);
    35113599    }
    35123600  }
    35133601  else {
     3602# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    35143603    while (s < end) {
    35153604      p = se = s + tlen1;
    … …  
    35233612      t = s;
    35243613      do {
    3525         s += mbc_enc_len(s);
     3614        s += enclen(enc, s, end);
    35263615      } while ((s - t) < skip && s < end);
    35273616    }
     3617# endif
    35283618  }
    35293619
    … …  
    35393629  const UChar *tail;
    35403630  ptrdiff_t tlen1;
     3631
     3632# ifdef ONIG_DEBUG_SEARCH
     3633  fprintf(stderr, "bm_search: text: %"PRIuPTR" (%p), text_end: %"PRIuPTR" (%p), text_range: %"PRIuPTR" (%p)\n",
     3634          (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
     3635# endif
    35413636
    35423637  tail = target_end - 1;
    … …  
    35603655  }
    35613656  else { /* see int_map[] */
     3657# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    35623658    while (s < end) {
    35633659      p = s;
    … …  
    35703666      s += reg->int_map[s[1]];
    35713667    }
     3668# endif
    35723669  }
    35733670  return (UChar* )NULL;
    … …  
    35843681  ptrdiff_t skip, tlen1;
    35853682  OnigEncoding enc = reg->enc;
    3586   int (*mbc_enc_len)(const OnigUChar* p) = enc->mbc_enc_len;
    35873683  int case_fold_flag = reg->case_fold_flag;
    35883684
    3589 #ifdef ONIG_DEBUG_SEARCH
    3590   fprintf(stderr, "bm_search_notrev_ic: text: %"PRIdPTR" (%p), text_end: %"PRIdPTR" (%p), text_range: %"PRIdPTR" (%p)\n",
    3591           (intptr_t )text, text, (intptr_t )text_end, text_end, (intptr_t )text_range, text_range);
    3592 #endif
     3685# ifdef ONIG_DEBUG_SEARCH
     3686  fprintf(stderr, "bm_search_notrev_ic: text: %"PRIuPTR" (%p), text_end: %"PRIuPTR" (%p), text_range: %"PRIuPTR" (%p)\n",
     3687          (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
     3688# endif
    35933689
    35943690  tail = target_end - 1;
    … …  
    36103706      t = s;
    36113707      do {
    3612         s += mbc_enc_len(s);
     3708        s += enclen(enc, s, end);
    36133709      } while ((s - t) < skip && s < end);
    36143710    }
    36153711  }
    36163712  else {
     3713# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    36173714    while (s < end) {
    36183715      se = s + tlen1;
    … …  
    36243721      t = s;
    36253722      do {
    3626         s += mbc_enc_len(s);
     3723        s += enclen(enc, s, end);
    36273724      } while ((s - t) < skip && s < end);
    36283725    }
     3726# endif
    36293727  }
    36303728
    … …  
    36433741  int case_fold_flag = reg->case_fold_flag;
    36443742
    3645 #ifdef ONIG_DEBUG_SEARCH
    3646   fprintf(stderr, "bm_search_ic: text: %"PRIdPTR" (%p), text_end: %"PRIdPTR" (%p), text_range: %"PRIdPTR" (%p)\n",
    3647           (intptr_t )text, text, (intptr_t )text_end, text_end, (intptr_t )text_range, text_range);
    3648 #endif
     3743# ifdef ONIG_DEBUG_SEARCH
     3744  fprintf(stderr, "bm_search_ic: text: %"PRIuPTR" (%p), text_end: %"PRIuPTR" (%p), text_range: %"PRIuPTR" (%p)\n",
     3745          (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
     3746# endif
    36493747
    36503748  tail = target_end - 1;
    … …  
    36663764  }
    36673765  else { /* see int_map[] */
     3766# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
    36683767    while (s < end) {
    36693768      p = s - tlen1;
    … …  
    36743773      s += reg->int_map[s[1]];
    36753774    }
     3775# endif
    36763776  }
    36773777  return (UChar* )NULL;
    … …  
    36793779#endif /* USE_SUNDAY_QUICK_SEARCH */
    36803780
     3781#ifdef USE_INT_MAP_BACKWARD
    36813782static int
    36823783set_bm_backward_skip(UChar* s, UChar* end, OnigEncoding enc ARG_UNUSED,
    … …  
    37113812    s = text_start;
    37123813  else
    3713     s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, adjust_text, s);
     3814    s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, adjust_text, s, text_end);
    37143815
    37153816  while (s >= text) {
    … …  
    37233824
    37243825    s -= reg->int_map_backward[*s];
    3725     s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, adjust_text, s);
     3826    s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, adjust_text, s, text_end);
    37263827  }
    37273828
    37283829  return (UChar* )NULL;
    37293830}
     3831#endif
    37303832
    37313833static UChar*
    37323834map_search(OnigEncoding enc, UChar map[],
    3733            const UChar* text, const UChar* text_range)
     3835           const UChar* text, const UChar* text_range, const UChar* text_end)
    37343836{
    37353837  const UChar *s = text;
    … …  
    37383840    if (map[*s]) return (UChar* )s;
    37393841
    3740     s += enclen(enc, s);
     3842    s += enclen(enc, s, text_end);
    37413843  }
    37423844  return (UChar* )NULL;
    … …  
    37463848map_search_backward(OnigEncoding enc, UChar map[],
    37473849                    const UChar* text, const UChar* adjust_text,
    3748                     const UChar* text_start)
     3850                    const UChar* text_start, const UChar* text_end)
    37493851{
    37503852  const UChar *s = text_start;
    … …  
    37533855    if (map[*s]) return (UChar* )s;
    37543856
    3755     s = onigenc_get_prev_char_head(enc, adjust_text, s);
     3857    s = onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
    37563858  }
    37573859  return (UChar* )NULL;
    … …  
    37653867  UChar *prev;
    37663868  OnigMatchArg msa;
    3767 
    3768 #if defined(USE_RECOMPILE_API) && defined(USE_MULTI_THREAD_SYSTEM)
    3769  start:
    3770   THREAD_ATOMIC_START;
    3771   if (ONIG_STATE(reg) >= ONIG_STATE_NORMAL) {
    3772     ONIG_STATE_INC(reg);
    3773     if (IS_NOT_NULL(reg->chain) && ONIG_STATE(reg) == ONIG_STATE_NORMAL) {
    3774       onig_chain_reduce(reg);
    3775       ONIG_STATE_INC(reg);
    3776     }
    3777   }
    3778   else {
    3779     int n;
    3780 
    3781     THREAD_ATOMIC_END;
    3782     n = 0;
    3783     while (ONIG_STATE(reg) < ONIG_STATE_NORMAL) {
    3784       if (++n > THREAD_PASS_LIMIT_COUNT)
    3785         return ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT;
    3786       THREAD_PASS;
    3787     }
    3788     goto start;
    3789   }
    3790   THREAD_ATOMIC_END;
    3791 #endif /* USE_RECOMPILE_API && USE_MULTI_THREAD_SYSTEM */
    37923869
    37933870  MATCH_ARG_INIT(msa, option, region, at, at);
    … …  
    37993876#endif
    38003877
    3801   if (region
    3802 #ifdef USE_POSIX_API_REGION_OPTION
    3803       && !IS_POSIX_REGION(option)
    3804 #endif
    3805       ) {
     3878  if (region) {
    38063879    r = onig_region_resize_clear(region, reg->num_mem + 1);
    38073880  }
    … …  
    38103883
    38113884  if (r == 0) {
    3812     prev = (UChar* )onigenc_get_prev_char_head(reg->enc, str, at);
     3885    prev = (UChar* )onigenc_get_prev_char_head(reg->enc, str, at, end);
    38133886    r = match_at(reg, str, end,
    38143887#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    … …  
    38193892
    38203893  MATCH_ARG_FREE(msa);
    3821   ONIG_STATE_DEC_THREAD(reg);
    38223894  return r;
    38233895}
    … …  
    38313903#ifdef ONIG_DEBUG_SEARCH
    38323904  fprintf(stderr, "forward_search_range: str: %"PRIuPTR" (%p), end: %"PRIuPTR" (%p), s: %"PRIuPTR" (%p), range: %"PRIuPTR" (%p)\n",
    3833           (intptr_t )str, str, (intptr_t )end, end, (intptr_t )s, s, (intptr_t )range, range);
     3905          (uintptr_t )str, str, (uintptr_t )end, end, (uintptr_t )s, s, (uintptr_t )range, range);
    38343906#endif
    38353907
    … …  
    38413913    else {
    38423914      UChar *q = p + reg->dmin;
    3843       while (p < q) p += enclen(reg->enc, p);
     3915
     3916      if (q >= end) return 0; /* fail */
     3917      while (p < q) p += enclen(reg->enc, p, end);
    38443918    }
    38453919  }
    … …  
    38523926  case ONIG_OPTIMIZE_EXACT_IC:
    38533927    p = slow_search_ic(reg->enc, reg->case_fold_flag,
    3854                        reg->exact, reg->exact_end, p, end, range);
     3928                       reg->exact, reg->exact_end, p, end, range);
    38553929    break;
    38563930
    … …  
    38723946
    38733947  case ONIG_OPTIMIZE_MAP:
    3874     p = map_search(reg->enc, reg->map, p, range);
     3948    p = map_search(reg->enc, reg->map, p, range, end);
    38753949    break;
    38763950  }
    … …  
    38803954    retry_gate:
    38813955      pprev = p;
    3882       p += enclen(reg->enc, p);
     3956      p += enclen(reg->enc, p, end);
    38833957      goto retry;
    38843958    }
    … …  
    38913965        if (!ON_STR_BEGIN(p)) {
    38923966          prev = onigenc_get_prev_char_head(reg->enc,
    3893                                             (pprev ? pprev : str), p);
     3967                                            (pprev ? pprev : str), p, end);
    38943968          if (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0))
    38953969            goto retry_gate;
    … …  
    39163990      if (low_prev) {
    39173991        if (*low > s)
    3918           *low_prev = onigenc_get_prev_char_head(reg->enc, s, p);
     3992          *low_prev = onigenc_get_prev_char_head(reg->enc, s, p, end);
    39193993        else
    39203994          *low_prev = onigenc_get_prev_char_head(reg->enc,
    3921                                                  (pprev ? pprev : str), p);
     3995                                                 (pprev ? pprev : str), p, end);
    39223996      }
    39233997    }
    39243998    else {
    39253999      if (reg->dmax != ONIG_INFINITE_DISTANCE) {
    3926         *low = p - reg->dmax;
    3927         if (*low > s) {
    3928           *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s,
    3929                                                               *low, (const UChar** )low_prev);
    3930           if (low_prev && IS_NULL(*low_prev))
    3931             *low_prev = onigenc_get_prev_char_head(reg->enc,
    3932                                                    (pprev ? pprev : s), *low);
     4000        if (p < str + reg->dmax) {
     4001          *low = (UChar* )str;
     4002          if (low_prev)
     4003            *low_prev = onigenc_get_prev_char_head(reg->enc, str, *low, end);
    39334004        }
    39344005        else {
    3935           if (low_prev)
    3936             *low_prev = onigenc_get_prev_char_head(reg->enc,
    3937                                                (pprev ? pprev : str), *low);
     4006          *low = p - reg->dmax;
     4007          if (*low > s) {
     4008            *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s,
     4009                                                                *low, end, (const UChar** )low_prev);
     4010            if (low_prev && IS_NULL(*low_prev))
     4011              *low_prev = onigenc_get_prev_char_head(reg->enc,
     4012                                                     (pprev ? pprev : s), *low, end);
     4013          }
     4014          else {
     4015            if (low_prev)
     4016              *low_prev = onigenc_get_prev_char_head(reg->enc,
     4017                                                 (pprev ? pprev : str), *low, end);
     4018          }
    39384019        }
    39394020      }
    … …  
    39604041                      UChar** low, UChar** high)
    39614042{
    3962   int r;
    39634043  UChar *p;
    39644044
    … …  
    39784058  case ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC:
    39794059    p = slow_search_backward_ic(reg->enc, reg->case_fold_flag,
    3980                                 reg->exact, reg->exact_end,
    3981                                 range, adjrange, end, p);
     4060                                reg->exact, reg->exact_end,
     4061                                range, adjrange, end, p);
    39824062    break;
    39834063
    39844064  case ONIG_OPTIMIZE_EXACT_BM:
    39854065  case ONIG_OPTIMIZE_EXACT_BM_NOT_REV:
     4066#ifdef USE_INT_MAP_BACKWARD
    39864067    if (IS_NULL(reg->int_map_backward)) {
     4068      int r;
    39874069      if (s - range < BM_BACKWARD_SEARCH_LENGTH_THRESHOLD)
    39884070        goto exact_method;
    … …  
    39944076    p = bm_search_backward(reg, reg->exact, reg->exact_end, range, adjrange,
    39954077                           end, p);
     4078#else
     4079    goto exact_method;
     4080#endif
    39964081    break;
    39974082
    39984083  case ONIG_OPTIMIZE_MAP:
    3999     p = map_search_backward(reg->enc, reg->map, range, adjrange, p);
     4084    p = map_search_backward(reg->enc, reg->map, range, adjrange, p, end);
    40004085    break;
    40014086  }
    … …  
    40084093      case ANCHOR_BEGIN_LINE:
    40094094        if (!ON_STR_BEGIN(p)) {
    4010           prev = onigenc_get_prev_char_head(reg->enc, str, p);
     4095          prev = onigenc_get_prev_char_head(reg->enc, str, p, end);
    40114096          if (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)) {
    40124097            p = prev;
    … …  
    40284113        }
    40294114        else if (! ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, p, str, end, reg->options, 1)) {
    4030           p = onigenc_get_prev_char_head(reg->enc, adjrange, p);
     4115          p = onigenc_get_prev_char_head(reg->enc, adjrange, p, end);
    40314116          if (IS_NULL(p)) goto fail;
    40324117          goto retry;
    … …  
    40404125      *low  = p - reg->dmax;
    40414126      *high = p - reg->dmin;
    4042       *high = onigenc_get_right_adjust_char_head(reg->enc, adjrange, *high);
     4127      *high = onigenc_get_right_adjust_char_head(reg->enc, adjrange, *high, end);
    40434128    }
    40444129
    … …  
    40784163#endif
    40794164
    4080 #if defined(USE_RECOMPILE_API) && defined(USE_MULTI_THREAD_SYSTEM)
    4081  start:
    4082   THREAD_ATOMIC_START;
    4083   if (ONIG_STATE(reg) >= ONIG_STATE_NORMAL) {
    4084     ONIG_STATE_INC(reg);
    4085     if (IS_NOT_NULL(reg->chain) && ONIG_STATE(reg) == ONIG_STATE_NORMAL) {
    4086       onig_chain_reduce(reg);
    4087       ONIG_STATE_INC(reg);
    4088     }
    4089   }
    4090   else {
    4091     int n;
    4092 
    4093     THREAD_ATOMIC_END;
    4094     n = 0;
    4095     while (ONIG_STATE(reg) < ONIG_STATE_NORMAL) {
    4096       if (++n > THREAD_PASS_LIMIT_COUNT)
    4097         return ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT;
    4098       THREAD_PASS;
    4099     }
    4100     goto start;
    4101   }
    4102   THREAD_ATOMIC_END;
    4103 #endif /* USE_RECOMPILE_API && USE_MULTI_THREAD_SYSTEM */
    4104 
    41054165#ifdef ONIG_DEBUG_SEARCH
    41064166  fprintf(stderr,
    41074167     "onig_search (entry point): str: %"PRIuPTR" (%p), end: %"PRIuPTR", start: %"PRIuPTR", range: %"PRIuPTR"\n",
    4108      (intptr_t )str, str, end - str, start - str, range - str);
    4109 #endif
    4110 
    4111   if (region
    4112 #ifdef USE_POSIX_API_REGION_OPTION
    4113       && !IS_POSIX_REGION(option)
    4114 #endif
    4115       ) {
     4168     (uintptr_t )str, str, end - str, start - str, range - str);
     4169#endif
     4170
     4171  if (region) {
    41164172    r = onig_region_resize_clear(region, reg->num_mem + 1);
    41174173    if (r) goto finish_no_msa;
    … …  
    41224178
    41234179#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
    4124 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
    4125 #define MATCH_AND_RETURN_CHECK(upper_range) \
     4180# ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
     4181#  define MATCH_AND_RETURN_CHECK(upper_range) \
    41264182  r = match_at(reg, str, end, (upper_range), s, prev, &msa); \
    41274183  if (r != ONIG_MISMATCH) {\
    … …  
    41334189    else goto finish; /* error */ \
    41344190  }
    4135 #else
    4136 #define MATCH_AND_RETURN_CHECK(upper_range) \
     4191# else
     4192#  define MATCH_AND_RETURN_CHECK(upper_range) \
    41374193  r = match_at(reg, str, end, (upper_range), s, prev, &msa); \
    41384194  if (r != ONIG_MISMATCH) {\
    … …  
    41424198    else goto finish; /* error */ \
    41434199  }
    4144 #endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */
     4200# endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */
    41454201#else
    4146 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
    4147 #define MATCH_AND_RETURN_CHECK(none) \
     4202# ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
     4203#  define MATCH_AND_RETURN_CHECK(none) \
    41484204  r = match_at(reg, str, end, s, prev, &msa);\
    41494205  if (r != ONIG_MISMATCH) {\
    … …  
    41554211    else goto finish; /* error */ \
    41564212  }
    4157 #else
    4158 #define MATCH_AND_RETURN_CHECK(none) \
     4213# else
     4214#  define MATCH_AND_RETURN_CHECK(none) \
    41594215  r = match_at(reg, str, end, s, prev, &msa);\
    41604216  if (r != ONIG_MISMATCH) {\
    … …  
    41644220    else goto finish; /* error */ \
    41654221  }
    4166 #endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */
     4222# endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */
    41674223#endif /* USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE */
    41684224
    … …  
    41764232    begin_position:
    41774233      if (range > start)
    4178         range = start + 1;
     4234      {
     4235        if (global_pos > start)
     4236        {
     4237          if (global_pos < range)
     4238            range = global_pos + 1;
     4239        }
     4240        else
     4241          range = start + 1;
     4242      }
    41794243      else
    41804244        range = start;
    … …  
    42064270          start = min_semi_end - reg->anchor_dmax;
    42074271          if (start < end)
    4208             start = onigenc_get_right_adjust_char_head(reg->enc, str, start);
     4272            start = onigenc_get_right_adjust_char_head(reg->enc, str, start, end);
    42094273        }
    42104274        if ((OnigDistance )(max_semi_end - (range - 1)) < reg->anchor_dmin) {
    … …  
    42224286        if ((OnigDistance )(max_semi_end - start) < reg->anchor_dmin) {
    42234287          start = max_semi_end - reg->anchor_dmin;
    4224           start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start);
     4288          start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start, end);
    42254289        }
    42264290        if (range > start) goto mismatch_no_msa;
    … …  
    42284292    }
    42294293    else if (reg->anchor & ANCHOR_SEMI_END_BUF) {
    4230       UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, 1);
     4294      UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, end, 1);
    42314295
    42324296      max_semi_end = (UChar* )end;
    … …  
    42354299
    42364300#ifdef USE_CRNL_AS_LINE_TERMINATOR
    4237         pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, 1);
     4301        pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, end, 1);
    42384302        if (IS_NOT_NULL(pre_end) &&
    42394303            IS_NEWLINE_CRLF(reg->options) &&
    … …  
    42524316    }
    42534317    else if ((reg->anchor & ANCHOR_ANYCHAR_STAR_ML)) {
    4254       if (! (reg->anchor & ANCHOR_LOOK_BEHIND)) {
    4255         goto begin_position;
    4256       }
     4318      goto begin_position;
    42574319    }
    42584320  }
    … …  
    42964358  if (range > start) {   /* forward search */
    42974359    if (s > str)
    4298       prev = onigenc_get_prev_char_head(reg->enc, str, s);
     4360      prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
    42994361    else
    43004362      prev = (UChar* )NULL;
    … …  
    43144376
    43154377      if ((end - start) < reg->threshold_len)
    4316         goto mismatch;
     4378        goto mismatch;
    43174379
    43184380      if (reg->dmax != ONIG_INFINITE_DISTANCE) {
    … …  
    43274389            MATCH_AND_RETURN_CHECK(orig_range);
    43284390            prev = s;
    4329             s += enclen(reg->enc, s);
     4391            s += enclen(reg->enc, s, end);
    43304392          }
    43314393        } while (s < range);
    … …  
    43364398                                   &low, &high, (UChar** )NULL)) goto mismatch;
    43374399
    4338         if ((reg->anchor & ANCHOR_ANYCHAR_STAR) != 0) {
    4339           do {
    4340             if ((reg->anchor & ANCHOR_BEGIN_POSITION) == 0)
    4341               msa.gpos = s;     /* move \G position */
    4342             MATCH_AND_RETURN_CHECK(orig_range);
    4343             prev = s;
    4344             s += enclen(reg->enc, s);
    4345 
    4346             if ((reg->anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) == 0) {
    4347               while (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)
    4348                      && s < range) {
    4349                 prev = s;
    4350                 s += enclen(reg->enc, s);
    4351               }
    4352             }
    4353           } while (s < range);
    4354           goto mismatch;
    4355         }
     4400        if ((reg->anchor & ANCHOR_ANYCHAR_STAR) != 0) {
     4401          do {
     4402            MATCH_AND_RETURN_CHECK(orig_range);
     4403            prev = s;
     4404            s += enclen(reg->enc, s, end);
     4405
     4406            if ((reg->anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) == 0) {
     4407              while (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)
     4408                  && s < range) {
     4409                prev = s;
     4410                s += enclen(reg->enc, s, end);
     4411              }
     4412            }
     4413          } while (s < range);
     4414          goto mismatch;
     4415        }
    43564416      }
    43574417    }
    … …  
    43604420      MATCH_AND_RETURN_CHECK(orig_range);
    43614421      prev = s;
    4362       s += enclen(reg->enc, s);
     4422      s += enclen(reg->enc, s, end);
    43634423    } while (s < range);
    43644424
    … …  
    43724432
    43734433      if (range < end)
    4374         adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range);
     4434        adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range, end);
    43754435      else
    43764436        adjrange = (UChar* )end;
    … …  
    43894449
    43904450          while (s >= low) {
    4391             prev = onigenc_get_prev_char_head(reg->enc, str, s);
     4451            prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
    43924452            MATCH_AND_RETURN_CHECK(orig_start);
    43934453            s = prev;
    … …  
    44084468            else
    44094469              sch_start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc,
    4410                                                     start, sch_start);
     4470                                                    start, sch_start, end);
    44114471          }
    44124472        }
    … …  
    44174477
    44184478    do {
    4419       prev = onigenc_get_prev_char_head(reg->enc, str, s);
     4479      prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
    44204480      MATCH_AND_RETURN_CHECK(orig_start);
    44214481      s = prev;
    … …  
    44364496 finish:
    44374497  MATCH_ARG_FREE(msa);
    4438   ONIG_STATE_DEC_THREAD(reg);
    44394498
    44404499  /* If result is mismatch and no FIND_NOT_EMPTY option,
    44414500     then the region is not set in match_at(). */
    4442   if (IS_FIND_NOT_EMPTY(reg->options) && region
    4443 #ifdef USE_POSIX_API_REGION_OPTION
    4444       && !IS_POSIX_REGION(option)
    4445 #endif
    4446       ) {
     4501  if (IS_FIND_NOT_EMPTY(reg->options) && region) {
    44474502    onig_region_clear(region);
    44484503  }
    … …  
    44504505#ifdef ONIG_DEBUG
    44514506  if (r != ONIG_MISMATCH)
    4452     fprintf(stderr, "onig_search: error %"PRIdPTR"\n", r);
     4507    fprintf(stderr, "onig_search: error %"PRIdPTRDIFF"\n", r);
    44534508#endif
    44544509  return r;
    … …  
    44574512  r = ONIG_MISMATCH;
    44584513 finish_no_msa:
    4459   ONIG_STATE_DEC_THREAD(reg);
    44604514#ifdef ONIG_DEBUG
    44614515  if (r != ONIG_MISMATCH)
    4462     fprintf(stderr, "onig_search: error %"PRIdPTR"\n", r);
     4516    fprintf(stderr, "onig_search: error %"PRIdPTRDIFF"\n", r);
    44634517#endif
    44644518  return r;
    44654519
    44664520 match:
    4467   ONIG_STATE_DEC_THREAD(reg);
    44684521  MATCH_ARG_FREE(msa);
    44694522  return s - str;
    44704523}
    44714524
     4525extern OnigPosition
     4526onig_scan(regex_t* reg, const UChar* str, const UChar* end,
     4527          OnigRegion* region, OnigOptionType option,
     4528          int (*scan_callback)(OnigPosition, OnigPosition, OnigRegion*, void*),
     4529          void* callback_arg)
     4530{
     4531  OnigPosition r;
     4532  OnigPosition n;
     4533  int rs;
     4534  const UChar* start;
     4535
     4536  n = 0;
     4537  start = str;
     4538  while (1) {
     4539    r = onig_search(reg, str, end, start, end, region, option);
     4540    if (r >= 0) {
     4541      rs = scan_callback(n, r, region, callback_arg);
     4542      n++;
     4543      if (rs != 0)
     4544        return rs;
     4545
     4546      if (region->end[0] == start - str) {
     4547        if (start >= end) break;
     4548        start += enclen(reg->enc, start, end);
     4549      }
     4550      else
     4551        start = str + region->end[0];
     4552
     4553      if (start > end)
     4554        break;
     4555    }
     4556    else if (r == ONIG_MISMATCH) {
     4557      break;
     4558    }
     4559    else { /* error */
     4560      return r;
     4561    }
     4562  }
     4563
     4564  return n;
     4565}
     4566
    44724567extern OnigEncoding
    4473 onig_get_encoding(regex_t* reg)
     4568onig_get_encoding(const regex_t* reg)
    44744569{
    44754570  return reg->enc;
    … …  
    44774572
    44784573extern OnigOptionType
    4479 onig_get_options(regex_t* reg)
     4574onig_get_options(const regex_t* reg)
    44804575{
    44814576  return reg->options;
    … …  
    44834578
    44844579extern  OnigCaseFoldType
    4485 onig_get_case_fold_flag(regex_t* reg)
     4580onig_get_case_fold_flag(const regex_t* reg)
    44864581{
    44874582  return reg->case_fold_flag;
    44884583}
    44894584
    4490 extern OnigSyntaxType*
    4491 onig_get_syntax(regex_t* reg)
     4585extern const OnigSyntaxType*
     4586onig_get_syntax(const regex_t* reg)
    44924587{
    44934588  return reg->syntax;
    … …  
    44954590
    44964591extern int
    4497 onig_number_of_captures(regex_t* reg)
     4592onig_number_of_captures(const regex_t* reg)
    44984593{
    44994594  return reg->num_mem;
    … …  
    45014596
    45024597extern int
    4503 onig_number_of_capture_histories(regex_t* reg)
     4598onig_number_of_capture_histories(const regex_t* reg)
    45044599{
    45054600#ifdef USE_CAPTURE_HISTORY
    … …  
    45184613
    45194614extern void
    4520 onig_copy_encoding(OnigEncoding to, OnigEncoding from)
     4615onig_copy_encoding(OnigEncodingType *to, OnigEncoding from)
    45214616{
    45224617  *to = *from;
Note: See TracChangeset for help on using the changeset viewer.