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/regcomp.c

    r321 r331  
    44/*-
    55 * Copyright (c) 2002-2013  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 "regparse.h"
    3232
    33 #if defined(USE_MULTI_THREAD_SYSTEM) \
    34   && defined(USE_DEFAULT_MULTI_THREAD_SYSTEM)
    35 #ifdef _WIN32
    36 CRITICAL_SECTION gOnigMutex;
    37 #else
    38 pthread_mutex_t gOnigMutex;
    39 #endif
    40 #endif
    41 
    4233OnigCaseFoldType OnigDefaultCaseFoldFlag = ONIGENC_CASE_FOLD_MIN;
    4334
    … …  
    264255}
    265256
     257#if 0
    266258static int
    267259add_pointer(regex_t* reg, void* addr)
    … …  
    272264  return 0;
    273265}
     266#endif
    274267
    275268static int
    … …  
    483476
    484477  p = prev = sn->s;
    485   prev_len = enclen(enc, p);
     478  prev_len = enclen(enc, p, sn->end);
    486479  p += prev_len;
    487480  blen = prev_len;
    … …  
    489482
    490483  for (; p < sn->end; ) {
    491     len = enclen(enc, p);
     484    len = enclen(enc, p, sn->end);
    492485    if (len == prev_len || ambig) {
    493486      blen += len;
    … …  
    532525
    533526  p = prev = sn->s;
    534   prev_len = enclen(enc, p);
     527  prev_len = enclen(enc, p, end);
    535528  p += prev_len;
    536529  blen = prev_len;
    537530
    538531  for (; p < end; ) {
    539     len = enclen(enc, p);
     532    len = enclen(enc, p, end);
    540533    if (len == prev_len || ambig) {
    541534      blen += len;
    … …  
    592585  int len;
    593586
    594   if (IS_NCCLASS_SHARE(cc)) {
    595     len = SIZE_OPCODE + SIZE_POINTER;
    596     return len;
    597   }
    598 
    599587  if (IS_NULL(cc->mbuf)) {
    600588    len = SIZE_OPCODE + SIZE_BITSET;
    … …  
    621609{
    622610  int r;
    623 
    624   if (IS_NCCLASS_SHARE(cc)) {
    625     add_opcode(reg, OP_CCLASS_NODE);
    626     r = add_pointer(reg, cc);
    627     return r;
    628   }
    629611
    630612  if (IS_NULL(cc->mbuf)) {
    … …  
    639621    if (ONIGENC_MBC_MINLEN(reg->enc) > 1 || bitset_is_empty(cc->bs)) {
    640622      if (IS_NCCLASS_NOT(cc))
    641         add_opcode(reg, OP_CCLASS_MB_NOT);
     623        add_opcode(reg, OP_CCLASS_MB_NOT);
    642624      else
    643         add_opcode(reg, OP_CCLASS_MB);
     625        add_opcode(reg, OP_CCLASS_MB);
    644626
    645627      r = add_multi_byte_cclass(cc->mbuf, reg);
    … …  
    647629    else {
    648630      if (IS_NCCLASS_NOT(cc))
    649         add_opcode(reg, OP_CCLASS_MIX_NOT);
     631        add_opcode(reg, OP_CCLASS_MIX_NOT);
    650632      else
    651         add_opcode(reg, OP_CCLASS_MIX);
     633        add_opcode(reg, OP_CCLASS_MIX);
    652634
    653635      r = add_bitset(reg, cc->bs);
    … …  
    761743    if (qn->greedy && infinite) {
    762744      if (IS_NOT_NULL(qn->next_head_exact) && !CKN_ON)
    763         return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower + cklen;
     745        return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower + cklen;
    764746      else
    765         return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower + cklen;
     747        return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower + cklen;
    766748    }
    767749  }
    … …  
    990972    if (qn->greedy && infinite) {
    991973      if (IS_NOT_NULL(qn->next_head_exact))
    992         return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower;
     974        return SIZE_OP_ANYCHAR_STAR_PEEK_NEXT + tlen * qn->lower;
    993975      else
    994         return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower;
     976        return SIZE_OP_ANYCHAR_STAR + tlen * qn->lower;
    995977    }
    996978  }
    … …  
    1011993
    1012994    if (qn->greedy) {
     995#ifdef USE_OP_PUSH_OR_JUMP_EXACT
    1013996      if (IS_NOT_NULL(qn->head_exact))
    1014997        len += SIZE_OP_PUSH_OR_JUMP_EXACT1 + mod_tlen + SIZE_OP_JUMP;
    1015       else if (IS_NOT_NULL(qn->next_head_exact))
     998      else
     999#endif
     1000      if (IS_NOT_NULL(qn->next_head_exact))
    10161001        len += SIZE_OP_PUSH_IF_PEEK_NEXT + mod_tlen + SIZE_OP_JUMP;
    10171002      else
    … …  
    10791064    if (qn->lower == 1 && tlen > QUANTIFIER_EXPAND_LIMIT_SIZE) {
    10801065      if (qn->greedy) {
     1066#ifdef USE_OP_PUSH_OR_JUMP_EXACT
    10811067        if (IS_NOT_NULL(qn->head_exact))
    10821068          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_OR_JUMP_EXACT1);
    1083         else if (IS_NOT_NULL(qn->next_head_exact))
     1069        else
     1070#endif
     1071        if (IS_NOT_NULL(qn->next_head_exact))
    10841072          r = add_opcode_rel_addr(reg, OP_JUMP, SIZE_OP_PUSH_IF_PEEK_NEXT);
    10851073        else
    … …  
    10971085
    10981086    if (qn->greedy) {
     1087#ifdef USE_OP_PUSH_OR_JUMP_EXACT
    10991088      if (IS_NOT_NULL(qn->head_exact)) {
    11001089        r = add_opcode_rel_addr(reg, OP_PUSH_OR_JUMP_EXACT1,
    … …  
    11071096        -(mod_tlen + (int )SIZE_OP_JUMP + (int )SIZE_OP_PUSH_OR_JUMP_EXACT1));
    11081097      }
    1109       else if (IS_NOT_NULL(qn->next_head_exact)) {
     1098      else
     1099#endif
     1100      if (IS_NOT_NULL(qn->next_head_exact)) {
    11101101        r = add_opcode_rel_addr(reg, OP_PUSH_IF_PEEK_NEXT,
    11111102                                mod_tlen + SIZE_OP_JUMP);
    … …  
    12441235                ? SIZE_OP_MEMORY_END_REC : SIZE_OP_MEMORY_END);
    12451236    }
     1237    else if (IS_ENCLOSE_RECURSION(node)) {
     1238      len = SIZE_OP_MEMORY_START_PUSH;
     1239      len += tlen + (BIT_STATUS_AT(reg->bt_mem_end, node->regnum)
     1240                     ? SIZE_OP_MEMORY_END_PUSH_REC : SIZE_OP_MEMORY_END_REC);
     1241    }
    12461242    else
    12471243#endif
    … …  
    12891285      return ONIGERR_PARSER_BUG;
    12901286    }
     1287    break;
     1288
     1289  case ENCLOSE_ABSENT:
     1290    len = SIZE_OP_PUSH_ABSENT_POS + SIZE_OP_ABSENT + tlen + SIZE_OP_ABSENT_END;
    12911291    break;
    12921292
    … …  
    13551355      r = add_opcode(reg, OP_RETURN);
    13561356    }
     1357    else if (IS_ENCLOSE_RECURSION(node)) {
     1358      if (BIT_STATUS_AT(reg->bt_mem_end, node->regnum))
     1359        r = add_opcode(reg, OP_MEMORY_END_PUSH_REC);
     1360      else
     1361        r = add_opcode(reg, OP_MEMORY_END_REC);
     1362      if (r) return r;
     1363      r = add_mem_num(reg, node->regnum);
     1364    }
    13571365    else
    13581366#endif
    … …  
    14271435    break;
    14281436
     1437  case ENCLOSE_ABSENT:
     1438    len = compile_length_tree(node->target, reg);
     1439    if (len < 0) return len;
     1440
     1441    r = add_opcode(reg, OP_PUSH_ABSENT_POS);
     1442    if (r) return r;
     1443    r = add_opcode_rel_addr(reg, OP_ABSENT, len + SIZE_OP_ABSENT_END);
     1444    if (r) return r;
     1445    r = compile_tree(node->target, reg);
     1446    if (r) return r;
     1447    r = add_opcode(reg, OP_ABSENT_END);
     1448    break;
     1449
    14291450  default:
    14301451    return ONIGERR_TYPE_BUG;
    … …  
    14801501  case ANCHOR_SEMI_END_BUF:   r = add_opcode(reg, OP_SEMI_END_BUF);   break;
    14811502  case ANCHOR_BEGIN_POSITION: r = add_opcode(reg, OP_BEGIN_POSITION); break;
    1482 
    1483   /* used for implicit anchor optimization: /.*a/ ==> /(?:^|\G).*a/ */
    1484   case ANCHOR_ANYCHAR_STAR:   r = add_opcode(reg, OP_BEGIN_POS_OR_LINE); break;
    14851503
    14861504  case ANCHOR_WORD_BOUND:
    … …  
    15901608      len = 0;
    15911609      do {
    1592         r = compile_length_tree(NCAR(node), reg);
    1593         if (r < 0) return r;
    1594         len += r;
    1595         n++;
     1610        r = compile_length_tree(NCAR(node), reg);
     1611        if (r < 0) return r;
     1612        len += r;
     1613        n++;
    15961614      } while (IS_NOT_NULL(node = NCDR(node)));
    15971615      r = len;
    … …  
    16221640#ifdef USE_BACKREF_WITH_LEVEL
    16231641      if (IS_BACKREF_NEST_LEVEL(br)) {
    1624         r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH +
     1642        r = SIZE_OPCODE + SIZE_OPTION + SIZE_LENGTH +
    16251643            SIZE_LENGTH + (SIZE_MEMNUM * br->back_num);
    16261644      }
    … …  
    17861804        int* p;
    17871805
    1788         if (IS_IGNORECASE(reg->options)) {
    1789           r = add_opcode(reg, OP_BACKREF_MULTI_IC);
    1790         }
    1791         else {
    1792           r = add_opcode(reg, OP_BACKREF_MULTI);
    1793         }
     1806        if (IS_IGNORECASE(reg->options)) {
     1807          r = add_opcode(reg, OP_BACKREF_MULTI_IC);
     1808        }
     1809        else {
     1810          r = add_opcode(reg, OP_BACKREF_MULTI);
     1811        }
    17941812        if (r) return r;
    17951813
    … …  
    18851903
    18861904  case NT_ANCHOR:
    1887     {
    1888       AnchorNode* an = NANCHOR(node);
    1889       switch (an->type) {
    1890       case ANCHOR_PREC_READ:
    1891       case ANCHOR_PREC_READ_NOT:
    1892       case ANCHOR_LOOK_BEHIND:
    1893       case ANCHOR_LOOK_BEHIND_NOT:
    1894         r = noname_disable_map(&(an->target), map, counter);
    1895         break;
    1896       }
    1897     }
     1905    if (NANCHOR(node)->target)
     1906      r = noname_disable_map(&(NANCHOR(node)->target), map, counter);
    18981907    break;
    18991908
    … …  
    19521961      EncloseNode* en = NENCLOSE(node);
    19531962      if (en->type == ENCLOSE_CONDITION)
    1954         en->regnum = map[en->regnum].new_val;
     1963        en->regnum = map[en->regnum].new_val;
    19551964      r = renumber_by_map(en->target, map);
    19561965    }
    … …  
    19621971
    19631972  case NT_ANCHOR:
    1964     {
    1965       AnchorNode* an = NANCHOR(node);
    1966       switch (an->type) {
    1967       case ANCHOR_PREC_READ:
    1968       case ANCHOR_PREC_READ_NOT:
    1969       case ANCHOR_LOOK_BEHIND:
    1970       case ANCHOR_LOOK_BEHIND_NOT:
    1971         r = renumber_by_map(an->target, map);
    1972         break;
    1973       }
    1974     }
     1973    if (NANCHOR(node)->target)
     1974      r = renumber_by_map(NANCHOR(node)->target, map);
    19751975    break;
    19761976
    … …  
    20062006    break;
    20072007
     2008  case NT_ANCHOR:
     2009    if (NANCHOR(node)->target)
     2010      r = numbered_ref_check(NANCHOR(node)->target);
     2011    break;
     2012
    20082013  default:
    20092014    break;
    … …  
    20142019
    20152020static int
    2016 disable_noname_group_capture_(Node** root, regex_t* reg, ScanEnv* env, GroupNumRemap* map)
     2021disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)
    20172022{
    20182023  int r, i, pos, counter;
    20192024  BitStatusType loc;
    2020 
     2025  GroupNumRemap* map;
     2026
     2027  map = (GroupNumRemap* )xalloca(sizeof(GroupNumRemap) * (env->num_mem + 1));
    20212028  CHECK_NULL_RETURN_MEMERR(map);
    20222029  for (i = 1; i <= env->num_mem; i++) {
    … …  
    20492056
    20502057  return onig_renumber_name_table(reg, map);
    2051 }
    2052 
    2053 static int
    2054 disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)
    2055 {
    2056         GroupNumRemap* map = (GroupNumRemap*)xmalloc(sizeof(GroupNumRemap) * (env->num_mem + 1));
    2057         int ret = disable_noname_group_capture_(root, reg, env, map);
    2058         xfree(map);
    2059         return ret;
    20602058}
    20612059#endif /* USE_NAMED_GROUP */
    … …  
    20992097    break;
    21002098
    2101 #ifdef USE_SUBEXP_CALL
     2099# ifdef USE_SUBEXP_CALL
    21022100  case NT_CALL:
    21032101    if (IS_CALL_RECURSION(NCALL(node))) {
    … …  
    21072105      r = quantifiers_memory_node_info(NCALL(node)->target);
    21082106    break;
    2109 #endif
     2107# endif
    21102108
    21112109  case NT_QTFR:
    … …  
    21292127      case ENCLOSE_STOP_BACKTRACK:
    21302128      case ENCLOSE_CONDITION:
     2129      case ENCLOSE_ABSENT:
    21312130        r = quantifiers_memory_node_info(en->target);
    21322131        break;
    … …  
    22462245      switch (en->type) {
    22472246      case ENCLOSE_MEMORY:
    2248 #ifdef USE_SUBEXP_CALL
    2249         if (IS_ENCLOSE_MIN_FIXED(en))
    2250           *min = en->min_len;
    2251         else {
    2252           r = get_min_match_length(en->target, min, env);
    2253           if (r == 0) {
    2254             en->min_len = *min;
    2255             SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
     2247        if (IS_ENCLOSE_MIN_FIXED(en))
     2248          *min = en->min_len;
     2249        else {
     2250          if (IS_ENCLOSE_MARK1(NENCLOSE(node)))
     2251            *min = 0;  /* recursive */
     2252          else {
     2253            SET_ENCLOSE_STATUS(node, NST_MARK1);
     2254            r = get_min_match_length(en->target, min, env);
     2255            CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
     2256            if (r == 0) {
     2257              en->min_len = *min;
     2258              SET_ENCLOSE_STATUS(node, NST_MIN_FIXED);
     2259            }
    22562260          }
    2257         }
    2258         break;
    2259 #endif
     2261        }
     2262        break;
     2263
    22602264      case ENCLOSE_OPTION:
    22612265      case ENCLOSE_STOP_BACKTRACK:
    22622266      case ENCLOSE_CONDITION:
    22632267        r = get_min_match_length(en->target, min, env);
     2268        break;
     2269
     2270      case ENCLOSE_ABSENT:
    22642271        break;
    22652272      }
    … …  
    23642371      switch (en->type) {
    23652372      case ENCLOSE_MEMORY:
    2366 #ifdef USE_SUBEXP_CALL
    23672373        if (IS_ENCLOSE_MAX_FIXED(en))
    23682374          *max = en->max_len;
    23692375        else {
    2370           r = get_max_match_length(en->target, max, env);
    2371           if (r == 0) {
    2372             en->max_len = *max;
    2373             SET_ENCLOSE_STATUS(node, NST_MAX_FIXED);
     2376          if (IS_ENCLOSE_MARK1(NENCLOSE(node)))
     2377            *max = ONIG_INFINITE_DISTANCE;
     2378          else {
     2379            SET_ENCLOSE_STATUS(node, NST_MARK1);
     2380            r = get_max_match_length(en->target, max, env);
     2381            CLEAR_ENCLOSE_STATUS(node, NST_MARK1);
     2382            if (r == 0) {
     2383              en->max_len = *max;
     2384              SET_ENCLOSE_STATUS(node, NST_MAX_FIXED);
     2385            }
    23742386          }
    23752387        }
    23762388        break;
    2377 #endif
     2389
    23782390      case ENCLOSE_OPTION:
    23792391      case ENCLOSE_STOP_BACKTRACK:
    23802392      case ENCLOSE_CONDITION:
    23812393        r = get_max_match_length(en->target, max, env);
     2394        break;
     2395
     2396      case ENCLOSE_ABSENT:
    23822397        break;
    23832398      }
    … …  
    24452460      UChar *s = sn->s;
    24462461      while (s < sn->end) {
    2447         s += enclen(reg->enc, s);
     2462        s += enclen(reg->enc, s, sn->end);
    24482463        (*len)++;
    24492464      }
    … …  
    25042519        r = get_char_length_tree1(en->target, reg, len, level);
    25052520        break;
     2521      case ENCLOSE_ABSENT:
    25062522      default:
    25072523        break;
    … …  
    26302646            v = BITSET_AT(xc->bs, i);
    26312647            if ((v != 0 && !IS_NCCLASS_NOT(xc)) ||
    2632                 (v == 0 && IS_NCCLASS_NOT(xc))) {
     2648                (v == 0 && IS_NCCLASS_NOT(xc))) {
    26332649              v = BITSET_AT(yc->bs, i);
    26342650              if ((v != 0 && !IS_NCCLASS_NOT(yc)) ||
    2635                   (v == 0 && IS_NCCLASS_NOT(yc)))
     2651                  (v == 0 && IS_NCCLASS_NOT(yc)))
    26362652                return 0;
    26372653            }
    … …  
    26832699
    26842700      case NT_CCLASS:
    2685         {
    2686           CClassNode* cc = NCCLASS(y);
    2687 
    2688           code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s,
    2689                                      xs->s + ONIGENC_MBC_MAXLEN(reg->enc));
    2690           return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1);
    2691         }
    2692         break;
     2701        {
     2702          CClassNode* cc = NCCLASS(y);
     2703
     2704          code = ONIGENC_MBC_TO_CODE(reg->enc, xs->s,
     2705                                     xs->s + ONIGENC_MBC_MAXLEN(reg->enc));
     2706          return (onig_is_code_in_cc(reg->enc, code, cc) != 0 ? 0 : 1);
     2707        }
     2708        break;
    26932709
    26942710      case NT_STR:
    2695         {
    2696           UChar *q;
    2697           StrNode* ys = NSTR(y);
    2698           len = NSTRING_LEN(x);
    2699           if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y);
    2700           if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) {
    2701             /* tiny version */
    2702             return 0;
     2711        {
     2712          UChar *q;
     2713          StrNode* ys = NSTR(y);
     2714          len = NSTRING_LEN(x);
     2715          if (len > NSTRING_LEN(y)) len = NSTRING_LEN(y);
     2716          if (NSTRING_IS_AMBIG(x) || NSTRING_IS_AMBIG(y)) {
     2717            /* tiny version */
     2718            return 0;
    27032719          }
    27042720          else {
    … …  
    27112727
    27122728      default:
    2713         break;
     2729        break;
    27142730      }
    27152731    }
    … …  
    27682784      QtfrNode* qn = NQTFR(node);
    27692785      if (qn->lower > 0) {
     2786#ifdef USE_OP_PUSH_OR_JUMP_EXACT
    27702787        if (IS_NOT_NULL(qn->head_exact))
    27712788          n = qn->head_exact;
    27722789        else
     2790#endif
    27732791          n = get_head_value_node(qn->target, exact, reg);
    27742792      }
    … …  
    27952813        n = get_head_value_node(en->target, exact, reg);
    27962814        break;
     2815
     2816      case ENCLOSE_ABSENT:
     2817        break;
    27972818      }
    27982819    }
    … …  
    28622883#ifdef USE_SUBEXP_CALL
    28632884
    2864 #define RECURSION_EXIST       1
    2865 #define RECURSION_INFINITE    2
     2885# define RECURSION_EXIST       1
     2886# define RECURSION_INFINITE    2
    28662887
    28672888static int
    … …  
    30633084subexp_recursive_check_trav(Node* node, ScanEnv* env)
    30643085{
    3065 #define FOUND_CALLED_NODE    1
     3086# define FOUND_CALLED_NODE    1
    30663087
    30673088  int type;
    … …  
    31643185        int gnum = cn->group_num;
    31653186
    3166 #ifdef USE_NAMED_GROUP
     3187# ifdef USE_NAMED_GROUP
    31673188        if (env->num_named > 0 &&
    31683189            IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
    … …  
    31703191          return ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED;
    31713192        }
    3172 #endif
     3193# endif
    31733194        if (gnum > env->num_mem) {
    31743195          onig_scan_env_set_error_string(env,
    … …  
    31773198        }
    31783199
    3179 #ifdef USE_NAMED_GROUP
     3200# ifdef USE_NAMED_GROUP
    31803201      set_call_attr:
    3181 #endif
     3202# endif
    31823203        cn->target = nodes[cn->group_num];
    31833204        if (IS_NULL(cn->target)) {
    … …  
    31903211        cn->unset_addr_list = env->unset_addr_list;
    31913212      }
    3192 #ifdef USE_NAMED_GROUP
    3193 #ifdef USE_PERL_SUBEXP_CALL
     3213# ifdef USE_NAMED_GROUP
     3214#  ifdef USE_PERL_SUBEXP_CALL
    31943215      else if (cn->name == cn->name_end) {
    31953216        goto set_call_attr;
    31963217      }
    3197 #endif
     3218#  endif
    31983219      else {
    31993220        int *refs;
    … …  
    32173238        }
    32183239      }
    3219 #endif
     3240# endif
    32203241    }
    32213242    break;
    … …  
    33003321
    33013322static int
    3302 next_setup(Node* node, Node* next_node, int in_root, regex_t* reg)
     3323next_setup(Node* node, Node* next_node, regex_t* reg)
    33033324{
    33043325  int type;
    … …  
    33343355        }
    33353356      }
    3336 
    3337 #ifndef ONIG_DONT_OPTIMIZE
    3338       if (NTYPE(node) == NT_QTFR && /* the type may be changed by above block */
    3339           in_root && /* qn->lower == 0 && */
    3340           NTYPE(qn->target) == NT_CANY &&
    3341           ! IS_MULTILINE(reg->options)) {
    3342         /* implicit anchor: /.*a/ ==> /(?:^|\G).*a/ */
    3343         Node *np;
    3344         np = onig_node_new_list(NULL_NODE, NULL_NODE);
    3345         CHECK_NULL_RETURN_MEMERR(np);
    3346         swap_node(node, np);
    3347         NCDR(node) = onig_node_new_list(np, NULL_NODE);
    3348         if (IS_NULL(NCDR(node))) {
    3349           onig_node_free(np);
    3350           return ONIGERR_MEMORY;
    3351         }
    3352         np = onig_node_new_anchor(ANCHOR_ANYCHAR_STAR);   /* (?:^|\G) */
    3353         CHECK_NULL_RETURN_MEMERR(np);
    3354         NCAR(node) = np;
    3355       }
    3356 #endif
    33573357    }
    33583358  }
    33593359  else if (type == NT_ENCLOSE) {
    33603360    EncloseNode* en = NENCLOSE(node);
    3361     in_root = 0;
    33623361    if (en->type == ENCLOSE_MEMORY) {
    33633362      node = en->target;
    … …  
    35163515
    35173516      if (q < end) {
    3518         r = expand_case_fold_make_rem_string(&rem, q, end, reg);
    3519         if (r != 0) {
    3520           onig_node_free(an);
    3521           goto mem_err2;
    3522         }
    3523 
    3524         xnode = onig_node_list_add(NULL_NODE, snode);
    3525         if (IS_NULL(xnode)) {
    3526           onig_node_free(an);
    3527           onig_node_free(rem);
    3528           goto mem_err2;
    3529         }
    3530         if (IS_NULL(onig_node_list_add(xnode, rem))) {
    3531           onig_node_free(an);
    3532           onig_node_free(xnode);
    3533           onig_node_free(rem);
    3534           goto mem_err;
    3535         }
    3536 
    3537         NCAR(an) = xnode;
     3517        r = expand_case_fold_make_rem_string(&rem, q, end, reg);
     3518        if (r != 0) {
     3519          onig_node_free(an);
     3520          goto mem_err2;
     3521        }
     3522
     3523        xnode = onig_node_list_add(NULL_NODE, snode);
     3524        if (IS_NULL(xnode)) {
     3525          onig_node_free(an);
     3526          onig_node_free(rem);
     3527          goto mem_err2;
     3528        }
     3529        if (IS_NULL(onig_node_list_add(xnode, rem))) {
     3530          onig_node_free(an);
     3531          onig_node_free(xnode);
     3532          onig_node_free(rem);
     3533          goto mem_err;
     3534        }
     3535
     3536        NCAR(an) = xnode;
    35383537      }
    35393538      else {
    3540         NCAR(an) = snode;
     3539        NCAR(an) = snode;
    35413540      }
    35423541
    … …  
    35923591    }
    35933592
    3594     len = enclen(reg->enc, p);
     3593    len = enclen(reg->enc, p, end);
    35953594
    35963595    varlen = is_case_fold_variable_len(n, items, len);
    … …  
    37153714#ifdef USE_COMBINATION_EXPLOSION_CHECK
    37163715
    3717 #define CEC_THRES_NUM_BIG_REPEAT         512
    3718 #define CEC_INFINITE_NUM          0x7fffffff
    3719 
    3720 #define CEC_IN_INFINITE_REPEAT    (1<<0)
    3721 #define CEC_IN_FINITE_REPEAT      (1<<1)
    3722 #define CEC_CONT_BIG_REPEAT       (1<<2)
     3716# define CEC_THRES_NUM_BIG_REPEAT         512
     3717# define CEC_INFINITE_NUM          0x7fffffff
     3718
     3719# define CEC_IN_INFINITE_REPEAT    (1<<0)
     3720# define CEC_IN_FINITE_REPEAT      (1<<1)
     3721# define CEC_CONT_BIG_REPEAT       (1<<2)
    37233722
    37243723static int
    … …  
    38363835    break;
    38373836
    3838 #ifdef USE_SUBEXP_CALL
     3837# ifdef USE_SUBEXP_CALL
    38393838  case NT_CALL:
    38403839    if (IS_CALL_RECURSION(NCALL(node)))
    … …  
    38433842      r = setup_comb_exp_check(NCALL(node)->target, state, env);
    38443843    break;
    3845 #endif
     3844# endif
    38463845
    38473846  default:
    … …  
    38573856#define IN_REPEAT     (1<<2)
    38583857#define IN_VAR_REPEAT (1<<3)
    3859 #define IN_ROOT       (1<<4)
     3858#define IN_CALL       (1<<4)
     3859#define IN_RECCALL    (1<<5)
    38603860
    38613861/* setup_tree does the following work.
    … …  
    38723872  int type;
    38733873  int r = 0;
    3874   int in_root = state & IN_ROOT;
    3875 
    3876   state &= ~IN_ROOT;
     3874
    38773875restart:
    38783876  type = NTYPE(node);
    … …  
    38813879    {
    38823880      Node* prev = NULL_NODE;
    3883       int prev_in_root = 0;
    3884       state |= in_root;
    38853881      do {
    38863882        r = setup_tree(NCAR(node), reg, state, env);
    38873883        if (IS_NOT_NULL(prev) && r == 0) {
    3888           r = next_setup(prev, NCAR(node), prev_in_root, reg);
     3884          r = next_setup(prev, NCAR(node), reg);
    38893885        }
    38903886        prev = NCAR(node);
    3891         prev_in_root = state & IN_ROOT;
    3892         state &= ~IN_ROOT;
    38933887      } while (r == 0 && IS_NOT_NULL(node = NCDR(node)));
    38943888    }
    … …  
    39473941
    39483942      if ((state & IN_REPEAT) != 0) {
    3949         qn->state |= NST_IN_REPEAT;
     3943        qn->state |= NST_IN_REPEAT;
    39503944      }
    39513945
    … …  
    40544048        {
    40554049          OnigOptionType options = reg->options;
    4056           state |= in_root;
    40574050          reg->options = NENCLOSE(node)->option;
    40584051          r = setup_tree(NENCLOSE(node)->target, reg, state, env);
    … …  
    40624055
    40634056      case ENCLOSE_MEMORY:
    4064         if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT)) != 0) {
     4057        if ((state & (IN_ALT | IN_NOT | IN_VAR_REPEAT | IN_CALL)) != 0) {
    40654058          BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);
    40664059          /* SET_ENCLOSE_STATUS(node, NST_MEM_IN_ALT_NOT); */
    40674060        }
    4068         r = setup_tree(en->target, reg, state, env);
    4069         break;
     4061        if (IS_ENCLOSE_CALLED(en))
     4062          state |= IN_CALL;
     4063        if (IS_ENCLOSE_RECURSION(en))
     4064          state |= IN_RECCALL;
     4065        else if ((state & IN_RECCALL) != 0)
     4066          SET_CALL_RECURSION(node);
     4067        r = setup_tree(en->target, reg, state, env);
     4068        break;
    40704069
    40714070      case ENCLOSE_STOP_BACKTRACK:
    … …  
    40944093        }
    40954094#endif
     4095        if (NENCLOSE(node)->regnum > env->num_mem)
     4096          return ONIGERR_INVALID_BACKREF;
     4097        r = setup_tree(NENCLOSE(node)->target, reg, state, env);
     4098        break;
     4099
     4100      case ENCLOSE_ABSENT:
    40964101        r = setup_tree(NENCLOSE(node)->target, reg, state, env);
    40974102        break;
    … …  
    41374142          if (r < 0) return r;
    41384143          if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
    4139           r = setup_look_behind(node, reg, env);
    4140           if (r != 0) return r;
    41414144          if (NTYPE(node) != NT_ANCHOR) goto restart;
    41424145          r = setup_tree(an->target, reg, state, env);
     4146          if (r != 0) return r;
     4147          r = setup_look_behind(node, reg, env);
    41434148        }
    41444149        break;
    … …  
    41504155          if (r < 0) return r;
    41514156          if (r > 0) return ONIGERR_INVALID_LOOK_BEHIND_PATTERN;
    4152           r = setup_look_behind(node, reg, env);
    4153           if (r != 0) return r;
    41544157          if (NTYPE(node) != NT_ANCHOR) goto restart;
    41554158          r = setup_tree(an->target, reg, (state | IN_NOT), env);
     4159          if (r != 0) return r;
     4160          r = setup_look_behind(node, reg, env);
    41564161        }
    41574162        break;
    … …  
    41894194        n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag,
    41904195                                               p, end, items);
    4191       clen = enclen(enc, p);
     4196      clen = enclen(enc, p, end);
     4197      if (p + clen > end)
     4198        clen = (int )(end - p);
    41924199
    41934200      for (j = 0; j < n; j++) {
    … …  
    42074214  }
    42084215  else {
     4216# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
     4217    /* This should not happen. */
     4218    return ONIGERR_TYPE_BUG;
     4219# else
    42094220    if (IS_NULL(*int_skip)) {
    42104221      *int_skip = (int* )xmalloc(sizeof(int) * ONIG_CHAR_TABLE_SIZE);
    … …  
    42194230        n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag,
    42204231                                               p, end, items);
    4221       clen = enclen(enc, p);
     4232      clen = enclen(enc, p, end);
     4233      if (p + clen > end)
     4234        clen = (int )(end - p);
    42224235
    42234236      for (j = 0; j < n; j++) {
    … …  
    42354248      }
    42364249    }
     4250# endif
    42374251  }
    42384252  return 0;
    … …  
    42624276        n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag,
    42634277                                               p, end, items);
    4264       clen = enclen(enc, p);
     4278      clen = enclen(enc, p, end);
     4279      if (p + clen > end)
     4280        clen = (int )(end - p);
    42654281
    42664282      for (j = 0; j < n; j++) {
    … …  
    42804296  }
    42814297  else {
     4298# if OPT_EXACT_MAXLEN < ONIG_CHAR_TABLE_SIZE
     4299    /* This should not happen. */
     4300    return ONIGERR_TYPE_BUG;
     4301# else
    42824302    if (IS_NULL(*int_skip)) {
    42834303      *int_skip = (int* )xmalloc(sizeof(int) * ONIG_CHAR_TABLE_SIZE);
    … …  
    42924312        n = ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc, reg->case_fold_flag,
    42934313                                               p, end, items);
    4294       clen = enclen(enc, p);
     4314      clen = enclen(enc, p, end);
     4315      if (p + clen > end)
     4316        clen = (int )(end - p);
    42954317
    42964318      for (j = 0; j < n; j++) {
    … …  
    43084330      }
    43094331    }
     4332# endif
    43104333  }
    43114334  return 0;
    43124335}
    43134336#endif /* USE_SUNDAY_QUICK_SEARCH */
    4314 
    4315 #define OPT_EXACT_MAXLEN   24
    43164337
    43174338typedef struct {
    … …  
    46044625  end = p + add->len;
    46054626  for (i = to->len; p < end; ) {
    4606     len = enclen(enc, p);
     4627    len = enclen(enc, p, end);
    46074628    if (i + len > OPT_EXACT_MAXLEN) break;
    46084629    for (j = 0; j < len && p < end; j++)
    … …  
    46264647
    46274648  for (i = to->len, p = s; p < end && i < OPT_EXACT_MAXLEN; ) {
    4628     len = enclen(enc, p);
     4649    len = enclen(enc, p, end);
    46294650    if (i + len > OPT_EXACT_MAXLEN) break;
    46304651    for (j = 0; j < len && p < end; j++)
    … …  
    46524673  for (i = 0; i < to->len && i < add->len; ) {
    46534674    if (to->s[i] != add->s[i]) break;
    4654     len = enclen(env->enc, to->s + i);
     4675    len = enclen(env->enc, to->s + i, to->s + to->len);
    46554676
    46564677    for (j = 1; j < len; j++) {
    … …  
    49845005          add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
    49855006        }
    4986         set_mml(&opt->len, slen, slen);
     5007        set_mml(&opt->len, slen, slen);
    49875008      }
    49885009      else {
    4989         OnigDistance max;
     5010        OnigDistance max;
    49905011
    49915012        if (NSTRING_IS_DONT_GET_OPT_INFO(node)) {
    4992           int n = onigenc_strlen(env->enc, sn->s, sn->end);
    4993           max = ONIGENC_MBC_MAXLEN_DIST(env->enc) * n;
     5013          int n = onigenc_strlen(env->enc, sn->s, sn->end);
     5014          max = ONIGENC_MBC_MAXLEN_DIST(env->enc) * n;
    49945015        }
    49955016        else {
    … …  
    50075028        }
    50085029
    5009         set_mml(&opt->len, slen, max);
     5030        set_mml(&opt->len, slen, max);
    50105031      }
    50115032
    … …  
    50235044
    50245045      if (IS_NOT_NULL(cc->mbuf) || IS_NCCLASS_NOT(cc)) {
    5025         OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
     5046        OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
    50265047        OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
    50275048
    … …  
    50295050      }
    50305051      else {
    5031         for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
    5032           z = BITSET_AT(cc->bs, i);
    5033           if ((z && !IS_NCCLASS_NOT(cc)) || (!z && IS_NCCLASS_NOT(cc))) {
    5034             add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
    5035           }
    5036         }
     5052        for (i = 0; i < SINGLE_BYTE_SIZE; i++) {
     5053          z = BITSET_AT(cc->bs, i);
     5054          if ((z && !IS_NCCLASS_NOT(cc)) || (!z && IS_NCCLASS_NOT(cc))) {
     5055            add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
     5056          }
     5057        }
    50375058        set_mml(&opt->len, 1, 1);
    50385059      }
    … …  
    50485069
    50495070      if (max == 1) {
    5050         min = 1;
     5071        min = 1;
    50515072
    50525073        maxcode = NCTYPE(node)->ascii_range ? 0x80 : SINGLE_BYTE_SIZE;
    … …  
    50715092      }
    50725093      else {
    5073         min = ONIGENC_MBC_MINLEN(env->enc);
     5094        min = ONIGENC_MBC_MINLEN(env->enc);
    50745095      }
    50755096      set_mml(&opt->len, min, max);
    … …  
    51905211            if (nopt.exb.reach_end) {
    51915212              for (i = 2; i <= qn->lower &&
    5192                           ! is_full_opt_exact_info(&opt->exb); i++) {
     5213                          ! is_full_opt_exact_info(&opt->exb); i++) {
    51935214                concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
    51945215              }
    … …  
    52615282        r = optimize_node_left(en->target, opt, env);
    52625283        break;
     5284
     5285      case ENCLOSE_ABSENT:
     5286        set_mml(&opt->len, 0, ONIG_INFINITE_DISTANCE);
     5287        break;
    52635288      }
    52645289    }
    … …  
    53125337    if (e->len >= 3 || (e->len >= 2 && allow_reverse)) {
    53135338      r = set_bm_skip(reg->exact, reg->exact_end, reg,
    5314                       reg->map, &(reg->int_map), 0);
    5315       if (r) return r;
    5316 
    5317       reg->optimize = (allow_reverse != 0
     5339                      reg->map, &(reg->int_map), 0);
     5340      if (r == 0) {
     5341        reg->optimize = (allow_reverse != 0
    53185342                       ? ONIG_OPTIMIZE_EXACT_BM : ONIG_OPTIMIZE_EXACT_BM_NOT_REV);
     5343      }
     5344      else {
     5345        reg->optimize = ONIG_OPTIMIZE_EXACT;
     5346      }
    53195347    }
    53205348    else {
    … …  
    53815409        ANCHOR_BEGIN_POSITION | ANCHOR_ANYCHAR_STAR | ANCHOR_ANYCHAR_STAR_ML |
    53825410        ANCHOR_LOOK_BEHIND);
     5411
     5412  if ((opt.anc.left_anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) != 0)
     5413    reg->anchor &= ~ANCHOR_ANYCHAR_STAR_ML;
    53835414
    53845415  reg->anchor |= opt.anc.right_anchor & (ANCHOR_END_BUF | ANCHOR_SEMI_END_BUF |
    … …  
    54555486      }
    54565487
    5457       p += enclen(enc, p);
     5488      p += enclen(enc, p, end);
    54585489    }
    54595490  }
    … …  
    55745605      for (i = 0; i < ONIG_CHAR_TABLE_SIZE; i++) {
    55755606        if (reg->map[i] != 0) {
    5576           if (c > 0)  fputs(", ", f);
    5577           c++;
    5578           if (ONIGENC_MBC_MAXLEN(reg->enc) == 1 &&
    5579               ONIGENC_IS_CODE_PRINT(reg->enc, (OnigCodePoint )i))
    5580             fputc(i, f);
    5581           else
    5582             fprintf(f, "%d", i);
    5583         }
     5607          if (c > 0)  fputs(", ", f);
     5608          c++;
     5609          if (ONIGENC_MBC_MAXLEN(reg->enc) == 1 &&
     5610              ONIGENC_IS_CODE_PRINT(reg->enc, (OnigCodePoint )i))
     5611            fputc(i, f);
     5612          else
     5613            fprintf(f, "%d", i);
     5614        }
    55845615      }
    55855616      fprintf(f, "]\n");
    … …  
    56165647}
    56175648
     5649#ifdef RUBY
    56185650size_t
    56195651onig_memsize(const regex_t *reg)
    … …  
    56395671    return size;
    56405672}
     5673#endif
    56415674
    56425675#define REGEX_TRANSFER(to,from) do {\
    5643   (to)->state = ONIG_STATE_MODIFY;\
    56445676  onig_free_body(to);\
    56455677  xmemcpy(to, from, sizeof(regex_t));\
    … …  
    56475679} while (0)
    56485680
     5681#if 0
    56495682extern void
    56505683onig_transfer(regex_t* to, regex_t* from)
    56515684{
    5652   THREAD_ATOMIC_START;
    56535685  REGEX_TRANSFER(to, from);
    5654   THREAD_ATOMIC_END;
    5655 }
    5656 
    5657 #define REGEX_CHAIN_HEAD(reg) do {\
    5658   while (IS_NOT_NULL((reg)->chain)) {\
    5659     (reg) = (reg)->chain;\
    5660   }\
    5661 } while (0)
    5662 
    5663 extern void
    5664 onig_chain_link_add(regex_t* to, regex_t* add)
    5665 {
    5666   THREAD_ATOMIC_START;
    5667   REGEX_CHAIN_HEAD(to);
    5668   to->chain = add;
    5669   THREAD_ATOMIC_END;
    5670 }
    5671 
    5672 extern void
    5673 onig_chain_reduce(regex_t* reg)
    5674 {
    5675   regex_t *head, *prev;
    5676 
    5677   prev = reg;
    5678   head = prev->chain;
    5679   if (IS_NOT_NULL(head)) {
    5680     reg->state = ONIG_STATE_MODIFY;
    5681     while (IS_NOT_NULL(head->chain)) {
    5682       prev = head;
    5683       head = head->chain;
    5684     }
    5685     prev->chain = (regex_t* )NULL;
    5686     REGEX_TRANSFER(reg, head);
    5687   }
    5688 }
     5686}
     5687#endif
    56895688
    56905689#ifdef ONIG_DEBUG_COMPILE
    5691 static void print_compiled_byte_code_list P_((FILE* f, regex_t* reg));
     5690static void print_compiled_byte_code_list(FILE* f, regex_t* reg);
    56925691#endif
    56935692#ifdef ONIG_DEBUG_PARSE_TREE
    5694 static void print_tree P_((FILE* f, Node* node));
    5695 #endif
    5696 
     5693static void print_tree(FILE* f, Node* node);
     5694#endif
     5695
     5696#ifdef RUBY
    56975697extern int
    56985698onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
    5699               OnigErrorInfo* einfo)
     5699             OnigErrorInfo* einfo)
     5700{
     5701  return onig_compile_ruby(reg, pattern, pattern_end, einfo, NULL, 0);
     5702}
     5703#endif
     5704
     5705#ifdef RUBY
     5706extern int
     5707onig_compile_ruby(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
     5708              OnigErrorInfo* einfo, const char *sourcefile, int sourceline)
     5709#else
     5710extern int
     5711onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
     5712             OnigErrorInfo* einfo)
     5713#endif
    57005714{
    57015715#define COMPILE_INIT_SIZE  20
    … …  
    57115725  if (IS_NOT_NULL(einfo)) einfo->par = (UChar* )NULL;
    57125726
    5713   reg->state = ONIG_STATE_COMPILING;
     5727#ifdef RUBY
     5728  scan_env.sourcefile = sourcefile;
     5729  scan_env.sourceline = sourceline;
     5730#endif
    57145731
    57155732#ifdef ONIG_DEBUG
    … …  
    57375754  r = onig_parse_make_tree(&root, pattern, pattern_end, reg, &scan_env);
    57385755  if (r != 0) goto err;
     5756
     5757#ifdef ONIG_DEBUG_PARSE_TREE
     5758# if 0
     5759  fprintf(stderr, "ORIGINAL PARSE TREE:\n");
     5760  print_tree(stderr, root);
     5761# endif
     5762#endif
    57395763
    57405764#ifdef USE_NAMED_GROUP
    … …  
    57705794#endif
    57715795
    5772   r = setup_tree(root, reg, IN_ROOT, &scan_env);
     5796  r = setup_tree(root, reg, 0, &scan_env);
    57735797  if (r != 0) goto err_unset;
    57745798
    … …  
    57895813#ifdef USE_COMBINATION_EXPLOSION_CHECK
    57905814  if (scan_env.backrefed_mem == 0
    5791 #ifdef USE_SUBEXP_CALL
     5815# ifdef USE_SUBEXP_CALL
    57925816      || scan_env.num_call == 0
    5793 #endif
     5817# endif
    57945818      ) {
    57955819    setup_comb_exp_check(root, 0, &scan_env);
    5796 #ifdef USE_SUBEXP_CALL
     5820# ifdef USE_SUBEXP_CALL
    57975821    if (scan_env.has_recursion != 0) {
    57985822      scan_env.num_comb_exp_check = 0;
    57995823    }
    58005824    else
    5801 #endif
     5825# endif
    58025826    if (scan_env.comb_exp_max_regnum > 0) {
    58035827      int i;
    … …  
    58535877
    58545878#ifdef ONIG_DEBUG_COMPILE
    5855 #ifdef USE_NAMED_GROUP
     5879# ifdef USE_NAMED_GROUP
    58565880  onig_print_names(stderr, reg);
    5857 #endif
     5881# endif
    58585882  print_compiled_byte_code_list(stderr, reg);
    58595883#endif
    58605884
    58615885 end:
    5862   reg->state = ONIG_STATE_NORMAL;
    58635886  return r;
    58645887
    … …  
    58845907}
    58855908
    5886 #ifdef USE_RECOMPILE_API
    5887 extern int
    5888 onig_recompile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
    5889             OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax,
    5890             OnigErrorInfo* einfo)
    5891 {
    5892   int r;
    5893   regex_t *new_reg;
    5894 
    5895   r = onig_new(&new_reg, pattern, pattern_end, option, enc, syntax, einfo);
    5896   if (r) return r;
    5897   if (ONIG_STATE(reg) == ONIG_STATE_NORMAL) {
    5898     onig_transfer(reg, new_reg);
    5899   }
    5900   else {
    5901     onig_chain_link_add(reg, new_reg);
    5902   }
    5903   return 0;
    5904 }
    5905 #endif
    5906 
    59075909static int onig_inited = 0;
    59085910
    … …  
    59105912onig_reg_init(regex_t* reg, OnigOptionType option,
    59115913              OnigCaseFoldType case_fold_flag,
    5912               OnigEncoding enc, OnigSyntaxType* syntax)
     5914              OnigEncoding enc, const OnigSyntaxType* syntax)
    59135915{
    59145916  if (! onig_inited)
    … …  
    59255927    return ONIGERR_INVALID_COMBINATION_OF_OPTIONS;
    59265928  }
    5927 
    5928   (reg)->state = ONIG_STATE_MODIFY;
    59295929
    59305930  if ((option & ONIG_OPTION_NEGATE_SINGLELINE) != 0) {
    … …  
    59565956onig_new_without_alloc(regex_t* reg, const UChar* pattern,
    59575957          const UChar* pattern_end, OnigOptionType option, OnigEncoding enc,
    5958           OnigSyntaxType* syntax, OnigErrorInfo* einfo)
     5958          const OnigSyntaxType* syntax, OnigErrorInfo* einfo)
    59595959{
    59605960  int r;
    … …  
    59695969extern int
    59705970onig_new(regex_t** reg, const UChar* pattern, const UChar* pattern_end,
    5971           OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax,
     5971          OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax,
    59725972          OnigErrorInfo* einfo)
    59735973{
    … …  
    59895989}
    59905990
     5991extern int
     5992onig_initialize(OnigEncoding encodings[] ARG_UNUSED, int n ARG_UNUSED)
     5993{
     5994  return onig_init();
     5995}
    59915996
    59925997extern int
    … …  
    59966001    return 0;
    59976002
    5998   THREAD_SYSTEM_INIT;
    5999   THREAD_ATOMIC_START;
    6000 
    60016003  onig_inited = 1;
     6004
     6005#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
     6006  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
     6007#endif
    60026008
    60036009  onigenc_init();
    … …  
    60086014#endif
    60096015
    6010   THREAD_ATOMIC_END;
    60116016  return 0;
    60126017}
    … …  
    60476052onig_end(void)
    60486053{
    6049   THREAD_ATOMIC_START;
    6050 
    60516054  exec_end_call_list();
    60526055
    … …  
    60556058#endif
    60566059
    6057 #ifdef USE_SHARED_CCLASS_TABLE
    6058   onig_free_shared_cclass_table();
    6059 #endif
    6060 
    6061 #ifdef USE_PARSE_TREE_NODE_RECYCLE
    6062   onig_free_node_list();
     6060#if defined(ONIG_DEBUG_MEMLEAK) && defined(_MSC_VER)
     6061  _CrtDumpMemoryLeaks();
    60636062#endif
    60646063
    60656064  onig_inited = 0;
    60666065
    6067   THREAD_ATOMIC_END;
    6068   THREAD_SYSTEM_END;
    60696066  return 0;
    60706067}
    … …  
    61326129
    61336130/* arguments type */
    6134 #define ARG_SPECIAL     -1
    6135 #define ARG_NON          0
    6136 #define ARG_RELADDR      1
    6137 #define ARG_ABSADDR      2
    6138 #define ARG_LENGTH       3
    6139 #define ARG_MEMNUM       4
    6140 #define ARG_OPTION       5
    6141 #define ARG_STATE_CHECK  6
     6131# define ARG_SPECIAL     -1
     6132# define ARG_NON          0
     6133# define ARG_RELADDR      1
     6134# define ARG_ABSADDR      2
     6135# define ARG_LENGTH       3
     6136# define ARG_MEMNUM       4
     6137# define ARG_OPTION       5
     6138# define ARG_STATE_CHECK  6
    61426139
    61436140OnigOpInfoType OnigOpInfo[] = {
    … …  
    61646161  { OP_CCLASS_MB_NOT,     "cclass-mb-not",   ARG_SPECIAL },
    61656162  { OP_CCLASS_MIX_NOT,    "cclass-mix-not",  ARG_SPECIAL },
    6166   { OP_CCLASS_NODE,       "cclass-node",     ARG_SPECIAL },
    61676163  { OP_ANYCHAR,           "anychar",         ARG_NON },
    61686164  { OP_ANYCHAR_ML,        "anychar-ml",      ARG_NON },
    … …  
    61896185  { OP_SEMI_END_BUF,        "semi-end-buf",    ARG_NON },
    61906186  { OP_BEGIN_POSITION,      "begin-position",  ARG_NON },
    6191   { OP_BEGIN_POS_OR_LINE,   "begin-pos-or-line",    ARG_NON },
    61926187  { OP_BACKREF1,            "backref1",             ARG_NON },
    61936188  { OP_BACKREF2,            "backref2",             ARG_NON },
    … …  
    62316226  { OP_PUSH_LOOK_BEHIND_NOT, "push-look-behind-not", ARG_SPECIAL },
    62326227  { OP_FAIL_LOOK_BEHIND_NOT, "fail-look-behind-not", ARG_NON },
     6228  { OP_PUSH_ABSENT_POS,      "push-absent-pos",      ARG_NON },
     6229  { OP_ABSENT,               "absent",               ARG_RELADDR },
     6230  { OP_ABSENT_END,           "absent-end",           ARG_NON },
    62336231  { OP_CALL,                 "call",                 ARG_ABSADDR },
    62346232  { OP_RETURN,               "return",               ARG_NON },
    … …  
    62676265}
    62686266
    6269 #ifdef ONIG_DEBUG_PARSE_TREE
     6267# ifdef ONIG_DEBUG_PARSE_TREE
    62706268static void
    62716269Indent(FILE* f, int indent)
    … …  
    62746272  for (i = 0; i < indent; i++) putc(' ', f);
    62756273}
    6276 #endif /* ONIG_DEBUG_PARSE_TREE */
     6274# endif /* ONIG_DEBUG_PARSE_TREE */
    62776275
    62786276static void
    … …  
    62936291
    62946292extern void
    6295 onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar** nextp,
     6293onig_print_compiled_byte_code(FILE* f, UChar* bp, UChar* bpend, UChar** nextp,
    62966294                              OnigEncoding enc)
    62976295{
    … …  
    63136311    case ARG_RELADDR:
    63146312      GET_RELADDR_INC(addr, bp);
    6315       fprintf(f, ":(+%d)", addr);
     6313      fprintf(f, ":(%s%d)", (addr >= 0) ? "+" : "", addr);
    63166314      break;
    63176315    case ARG_ABSADDR:
    … …  
    63926390
    63936391    case OP_EXACT1_IC:
    6394       len = enclen(enc, bp);
     6392      len = enclen(enc, bp, bpend);
    63956393      p_string(f, len, bp);
    63966394      bp += len;
    … …  
    64186416      GET_LENGTH_INC(len, bp);
    64196417      q = bp;
    6420 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS
     6418# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
    64216419      ALIGNMENT_RIGHT(q);
    6422 #endif
     6420# endif
    64236421      GET_CODE_POINT(code, q);
    64246422      bp += len;
    … …  
    64326430      GET_LENGTH_INC(len, bp);
    64336431      q = bp;
    6434 #ifndef PLATFORM_UNALIGNED_WORD_ACCESS
     6432# ifndef PLATFORM_UNALIGNED_WORD_ACCESS
    64356433      ALIGNMENT_RIGHT(q);
    6436 #endif
     6434# endif
    64376435      GET_CODE_POINT(code, q);
    64386436      bp += len;
    64396437      fprintf(f, ":%d:%d:%d", n, (int )code, len);
    6440       break;
    6441 
    6442     case OP_CCLASS_NODE:
    6443       {
    6444         CClassNode *cc;
    6445 
    6446         GET_POINTER_INC(cc, bp);
    6447         n = bitset_on_num(cc->bs);
    6448         fprintf(f, ":%"PRIuPTR":%d", (uintptr_t )cc, n);
    6449       }
    64506438      break;
    64516439
    … …  
    65026490      addr = *((RelAddrType* )bp);
    65036491      bp += SIZE_RELADDR;
    6504       fprintf(f, ":(%d)", addr);
     6492      fprintf(f, ":(%s%d)", (addr >= 0) ? "+" : "", addr);
    65056493      p_string(f, 1, bp);
    65066494      bp += 1;
    … …  
    65156503      GET_RELADDR_INC(addr, bp);
    65166504      GET_LENGTH_INC(len, bp);
    6517       fprintf(f, ":%d:(%d)", len, addr);
     6505      fprintf(f, ":%d:(%s%d)", len, (addr >= 0) ? "+" : "", addr);
    65186506      break;
    65196507
    … …  
    65246512      addr = *((RelAddrType* )bp);
    65256513      bp += SIZE_RELADDR;
    6526       fprintf(f, ":%d:(%d)", scn, addr);
     6514      fprintf(f, ":%d:(%s%d)", scn, (addr >= 0) ? "+" : "", addr);
    65276515      break;
    65286516
    … …  
    65306518      GET_MEMNUM_INC(mem, bp);
    65316519      GET_RELADDR_INC(addr, bp);
    6532       fprintf(f, ":%d:(%d)", mem, addr);
     6520      fprintf(f, ":%d:(%s%d)", mem, (addr >= 0) ? "+" : "", addr);
    65336521      break;
    65346522
    65356523    default:
    65366524      fprintf(stderr, "onig_print_compiled_byte_code: undefined code %d\n",
    6537               *--bp);
     6525              bp[-1]);
    65386526    }
    65396527  }
    … …  
    65426530}
    65436531
    6544 #ifdef ONIG_DEBUG_COMPILE
     6532# ifdef ONIG_DEBUG_COMPILE
    65456533static void
    65466534print_compiled_byte_code_list(FILE* f, regex_t* reg)
    … …  
    65596547    else
    65606548      fprintf(f, " %ld:", bp - reg->p);
    6561     onig_print_compiled_byte_code(f, bp, &bp, reg->enc);
     6549    onig_print_compiled_byte_code(f, bp, end, &bp, reg->enc);
    65626550  }
    65636551
    65646552  fprintf(f, "\n");
    65656553}
    6566 #endif /* ONIG_DEBUG_COMPILE */
    6567 
    6568 #ifdef ONIG_DEBUG_PARSE_TREE
     6554# endif /* ONIG_DEBUG_COMPILE */
     6555
     6556# ifdef ONIG_DEBUG_PARSE_TREE
    65696557static void
    65706558print_indent_tree(FILE* f, Node* node, int indent)
    … …  
    66136601  case NT_CCLASS:
    66146602    fprintf(f, "<cclass:%"PRIxPTR">", (intptr_t )node);
    6615     if (IS_NCCLASS_NOT(NCCLASS(node))) fputs(" not", f);
     6603    if (IS_NCCLASS_NOT(NCCLASS(node))) fputs("not ", f);
    66166604    if (NCCLASS(node)->mbuf) {
    66176605      BBuf* bbuf = NCCLASS(node)->mbuf;
    6618       for (i = 0; i < (int )bbuf->used; i++) {
    6619         if (i > 0) fprintf(f, ",");
    6620         fprintf(f, "%0x", bbuf->p[i]);
     6606      OnigCodePoint* data = (OnigCodePoint* )bbuf->p;
     6607      OnigCodePoint* end = (OnigCodePoint* )(bbuf->p + bbuf->used);
     6608      fprintf(f, "%d", *data++);
     6609      for (; data < end; data+=2) {
     6610        fprintf(f, ",");
     6611        fprintf(f, "%04x-%04x", data[0], data[1]);
    66216612      }
    66226613    }
    … …  
    66526643    case ANCHOR_SEMI_END_BUF:   fputs("semi end buf",   f); break;
    66536644    case ANCHOR_BEGIN_POSITION: fputs("begin position", f); break;
    6654     case ANCHOR_ANYCHAR_STAR:   fputs("begin position/line", f); break;
    66556645
    66566646    case ANCHOR_WORD_BOUND:      fputs("word bound",     f); break;
    66576647    case ANCHOR_NOT_WORD_BOUND:  fputs("not word bound", f); break;
    6658 #ifdef USE_WORD_BEGIN_END
     6648#  ifdef USE_WORD_BEGIN_END
    66596649    case ANCHOR_WORD_BEGIN:      fputs("word begin", f);     break;
    66606650    case ANCHOR_WORD_END:        fputs("word end", f);       break;
    6661 #endif
     6651#  endif
    66626652    case ANCHOR_PREC_READ:       fputs("prec read",      f); container_p = TRUE; break;
    66636653    case ANCHOR_PREC_READ_NOT:   fputs("prec read not",  f); container_p = TRUE; break;
    … …  
    66856675    break;
    66866676
    6687 #ifdef USE_SUBEXP_CALL
     6677#  ifdef USE_SUBEXP_CALL
    66886678  case NT_CALL:
    66896679    {
    … …  
    66936683    }
    66946684    break;
    6695 #endif
     6685#  endif
    66966686
    66976687  case NT_QTFR:
    … …  
    67176707      fprintf(f, "condition:%d", NENCLOSE(node)->regnum);
    67186708      break;
     6709    case ENCLOSE_ABSENT:
     6710      fprintf(f, "absent");
     6711      break;
    67196712
    67206713    default:
    … …  
    67446737  print_indent_tree(f, node, 0);
    67456738}
    6746 #endif /* ONIG_DEBUG_PARSE_TREE */
     6739# endif /* ONIG_DEBUG_PARSE_TREE */
    67476740#endif /* ONIG_DEBUG */
Note: See TracChangeset for help on using the changeset viewer.