34# undef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
36# define USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
39#ifndef USE_TOKEN_THREADED_VM
41# define USE_TOKEN_THREADED_VM 1
43# define USE_TOKEN_THREADED_VM 0
48# define ENC_DUMMY_FLAG (1<<24)
50rb_enc_asciicompat(OnigEncoding enc)
52 return ONIGENC_MBC_MINLEN(enc)==1 && !((enc)->ruby_encoding_index & ENC_DUMMY_FLAG);
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))
61#ifdef USE_CRNL_AS_LINE_TERMINATOR
62# define ONIGENC_IS_MBC_CRNL(enc,p,end) \
63 (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \
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) \
66 is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev))
68is_mbc_newline_ex(OnigEncoding enc,
const UChar *p,
const UChar *start,
69 const UChar *end, OnigOptionType option,
int check_prev)
71 if (IS_NEWLINE_CRLF(option)) {
72 if (ONIGENC_MBC_TO_CODE(enc, p, end) == 0x0a) {
74 const UChar *prev = onigenc_get_prev_char_head(enc, start, p, end);
75 if ((prev != NULL) && ONIGENC_MBC_TO_CODE(enc, prev, end) == 0x0d)
84 const UChar *pnext = p + enclen(enc, p, end);
86 ONIGENC_MBC_TO_CODE(enc, p, end) == 0x0d &&
87 ONIGENC_MBC_TO_CODE(enc, pnext, end) == 0x0a)
89 if (ONIGENC_IS_MBC_NEWLINE(enc, p, end))
95 return ONIGENC_IS_MBC_NEWLINE(enc, p, end);
99# define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
100 ONIGENC_IS_MBC_NEWLINE((enc), (p), (end))
103#ifdef USE_CAPTURE_HISTORY
104static void history_tree_free(OnigCaptureTreeNode* node);
107history_tree_clear(OnigCaptureTreeNode* node)
111 if (IS_NOT_NULL(node)) {
112 for (i = 0; i < node->num_childs; i++) {
113 if (IS_NOT_NULL(node->childs[i])) {
114 history_tree_free(node->childs[i]);
117 for (i = 0; i < node->allocated; i++) {
118 node->childs[i] = (OnigCaptureTreeNode* )0;
120 node->num_childs = 0;
121 node->beg = ONIG_REGION_NOTPOS;
122 node->end = ONIG_REGION_NOTPOS;
125 node->childs = (OnigCaptureTreeNode** )0;
130history_tree_free(OnigCaptureTreeNode* node)
132 history_tree_clear(node);
137history_root_free(OnigRegion* r)
139 if (IS_NOT_NULL(r->history_root)) {
140 history_tree_free(r->history_root);
141 r->history_root = (OnigCaptureTreeNode* )0;
145static OnigCaptureTreeNode*
146history_node_new(
void)
148 OnigCaptureTreeNode* node;
150 node = (OnigCaptureTreeNode* )
xmalloc(
sizeof(OnigCaptureTreeNode));
151 CHECK_NULL_RETURN(node);
152 node->childs = (OnigCaptureTreeNode** )0;
154 node->num_childs = 0;
156 node->beg = ONIG_REGION_NOTPOS;
157 node->end = ONIG_REGION_NOTPOS;
163history_tree_add_child(OnigCaptureTreeNode* parent, OnigCaptureTreeNode* child)
165# define HISTORY_TREE_INIT_ALLOC_SIZE 8
167 if (parent->num_childs >= parent->allocated) {
170 if (IS_NULL(parent->childs)) {
171 n = HISTORY_TREE_INIT_ALLOC_SIZE;
173 (OnigCaptureTreeNode** )
xmalloc(
sizeof(OnigCaptureTreeNode*) * n);
174 CHECK_NULL_RETURN_MEMERR(parent->childs);
177 OnigCaptureTreeNode** tmp;
178 n = parent->allocated * 2;
180 (OnigCaptureTreeNode** )
xrealloc(parent->childs,
181 sizeof(OnigCaptureTreeNode*) * n);
183 history_tree_clear(parent);
184 return ONIGERR_MEMORY;
186 parent->childs = tmp;
188 for (i = parent->allocated; i < n; i++) {
189 parent->childs[i] = (OnigCaptureTreeNode* )0;
191 parent->allocated = n;
194 parent->childs[parent->num_childs] = child;
195 parent->num_childs++;
199static OnigCaptureTreeNode*
200history_tree_clone(OnigCaptureTreeNode* node)
203 OnigCaptureTreeNode *clone, *child;
205 clone = history_node_new();
206 CHECK_NULL_RETURN(clone);
208 clone->beg = node->beg;
209 clone->end = node->end;
210 for (i = 0; i < node->num_childs; i++) {
211 child = history_tree_clone(node->childs[i]);
212 if (IS_NULL(child)) {
213 history_tree_free(clone);
214 return (OnigCaptureTreeNode* )0;
216 r = history_tree_add_child(clone, child);
218 history_tree_free(child);
219 history_tree_free(clone);
220 return (OnigCaptureTreeNode* )0;
227extern OnigCaptureTreeNode*
228onig_get_capture_tree(OnigRegion* region)
230 return region->history_root;
234#ifdef USE_MATCH_CACHE
261static OnigPosition count_num_cache_opcodes_inner(
263 MemNumType current_repeat_mem,
int lookaround_nesting,
264 UChar** pp,
long* num_cache_opcodes_ptr
268 UChar* pend = reg->p + reg->used;
270 MemNumType repeat_mem;
271 OnigEncoding enc = reg->enc;
272 long num_cache_opcodes = *num_cache_opcodes_ptr;
281 case OP_EXACT1: p++;
break;
282 case OP_EXACT2: p += 2;
break;
283 case OP_EXACT3: p += 3;
break;
284 case OP_EXACT4: p += 4;
break;
285 case OP_EXACT5: p += 5;
break;
287 GET_LENGTH_INC(
len, p); p +=
len;
break;
288 case OP_EXACTMB2N1: p += 2;
break;
289 case OP_EXACTMB2N2: p += 4;
break;
290 case OP_EXACTMB2N3: p += 6;
break;
292 GET_LENGTH_INC(
len, p); p +=
len * 2;
break;
294 GET_LENGTH_INC(
len, p); p +=
len * 3;
break;
298 GET_LENGTH_INC(mb_len, p);
299 GET_LENGTH_INC(
len, p);
305 len = enclen(enc, p, pend); p +=
len;
break;
307 GET_LENGTH_INC(
len, p); p +=
len;
break;
311 p += SIZE_BITSET;
break;
313 case OP_CCLASS_MB_NOT:
314 GET_LENGTH_INC(
len, p); p +=
len;
break;
316 case OP_CCLASS_MIX_NOT:
318 GET_LENGTH_INC(
len, p);
325 case OP_ANYCHAR_STAR:
326 case OP_ANYCHAR_ML_STAR:
327 num_cache_opcodes++;
break;
328 case OP_ANYCHAR_STAR_PEEK_NEXT:
329 case OP_ANYCHAR_ML_STAR_PEEK_NEXT:
330 p++; num_cache_opcodes++;
break;
335 case OP_NOT_WORD_BOUND:
341 case OP_NOT_ASCII_WORD:
342 case OP_ASCII_WORD_BOUND:
343 case OP_NOT_ASCII_WORD_BOUND:
344 case OP_ASCII_WORD_BEGIN:
345 case OP_ASCII_WORD_END:
352 case OP_SEMI_END_BUF:
353 case OP_BEGIN_POSITION:
360 case OP_BACKREF_MULTI:
361 case OP_BACKREF_MULTI_IC:
362 case OP_BACKREF_WITH_LEVEL:
365 case OP_MEMORY_START:
366 case OP_MEMORY_START_PUSH:
367 case OP_MEMORY_END_PUSH:
368 case OP_MEMORY_END_PUSH_REC:
370 case OP_MEMORY_END_REC:
373 if (lookaround_nesting != 0) {
392 case OP_PUSH_OR_JUMP_EXACT1:
393 case OP_PUSH_IF_PEEK_NEXT:
394 p += SIZE_RELADDR + 1; num_cache_opcodes++;
break;
397 if (current_repeat_mem != -1) {
401 GET_MEMNUM_INC(repeat_mem, p);
403 if (reg->repeat_range[repeat_mem].lower == 0 && reg->repeat_range[repeat_mem].upper == 0) {
404 long dummy_num_cache_opcodes = 0;
405 result = count_num_cache_opcodes_inner(reg, repeat_mem, lookaround_nesting, &p, &dummy_num_cache_opcodes);
406 if (result < 0 || dummy_num_cache_opcodes < 0) {
410 if (reg->repeat_range[repeat_mem].lower == 0) {
413 result = count_num_cache_opcodes_inner(reg, repeat_mem, lookaround_nesting, &p, &num_cache_opcodes);
414 if (result < 0 || num_cache_opcodes < 0) {
418 if (repeat_range->lower < repeat_range->upper) {
424 case OP_REPEAT_INC_NG:
425 GET_MEMNUM_INC(repeat_mem, p);
426 if (repeat_mem != current_repeat_mem) {
431 case OP_REPEAT_INC_SG:
432 case OP_REPEAT_INC_NG_SG:
434 case OP_NULL_CHECK_START:
437 case OP_NULL_CHECK_END:
438 case OP_NULL_CHECK_END_MEMST_PUSH:
441 case OP_NULL_CHECK_END_MEMST:
446 if (lookaround_nesting < 0) {
450 result = count_num_cache_opcodes_inner(reg, current_repeat_mem, lookaround_nesting + 1, &p, &num_cache_opcodes);
451 if (result < 0 || num_cache_opcodes < 0) {
455 case OP_PUSH_POS_NOT:
456 if (lookaround_nesting < 0) {
461 result = count_num_cache_opcodes_inner(reg, current_repeat_mem, lookaround_nesting + 1, &p, &num_cache_opcodes);
462 if (result < 0 || num_cache_opcodes < 0) {
466 case OP_PUSH_LOOK_BEHIND_NOT:
467 if (lookaround_nesting < 0) {
473 result = count_num_cache_opcodes_inner(reg, current_repeat_mem, lookaround_nesting + 1, &p, &num_cache_opcodes);
474 if (result < 0 || num_cache_opcodes < 0) {
478 case OP_PUSH_STOP_BT:
479 if (lookaround_nesting != 0) {
483 result = count_num_cache_opcodes_inner(reg, current_repeat_mem, -1, &p, &num_cache_opcodes);
484 if (result < 0 || num_cache_opcodes < 0) {
490 case OP_FAIL_LOOK_BEHIND_NOT:
497 case OP_PUSH_ABSENT_POS:
509 case OP_STATE_CHECK_PUSH:
510 case OP_STATE_CHECK_PUSH_OR_JUMP:
512 case OP_STATE_CHECK_ANYCHAR_STAR:
513 case OP_STATE_CHECK_ANYCHAR_ML_STAR:
516 case OP_SET_OPTION_PUSH:
528 *num_cache_opcodes_ptr = num_cache_opcodes;
532 *num_cache_opcodes_ptr = num_cache_opcodes;
536 *num_cache_opcodes_ptr = NUM_CACHE_OPCODES_IMPOSSIBLE;
540 return ONIGERR_UNDEFINED_BYTECODE;
545count_num_cache_opcodes(
const regex_t* reg,
long* num_cache_opcodes_ptr)
548 *num_cache_opcodes_ptr = 0;
549 OnigPosition result = count_num_cache_opcodes_inner(reg, -1, 0, &p, num_cache_opcodes_ptr);
550 if (result == 0 && *num_cache_opcodes_ptr >= 0 && p != reg->p + reg->used) {
551 return ONIGERR_UNDEFINED_BYTECODE;
558init_cache_opcodes_inner(
560 MemNumType current_repeat_mem,
int lookaround_nesting,
561 OnigCacheOpcode** cache_opcodes_ptr, UChar** pp,
long* num_cache_points_ptr
565 UChar* pend = reg->p + reg->used;
568 MemNumType repeat_mem;
569 OnigEncoding enc = reg->enc;
570 long cache_point = *num_cache_points_ptr;
574# define INC_CACHE_OPCODES if (cache_opcodes != NULL) {\
575 cache_opcodes->addr = pbegin;\
576 cache_opcodes->cache_point = cache_point;\
577 cache_opcodes->outer_repeat_mem = current_repeat_mem;\
578 cache_opcodes->num_cache_points_at_outer_repeat = 0;\
579 cache_opcodes->num_cache_points_in_outer_repeat = 0;\
580 cache_opcodes->lookaround_nesting = lookaround_nesting;\
581 cache_opcodes->match_addr = NULL;\
582 cache_point += lookaround_nesting != 0 ? 2 : 1;\
593 case OP_EXACT1: p++;
break;
594 case OP_EXACT2: p += 2;
break;
595 case OP_EXACT3: p += 3;
break;
596 case OP_EXACT4: p += 4;
break;
597 case OP_EXACT5: p += 5;
break;
599 GET_LENGTH_INC(
len, p); p +=
len;
break;
600 case OP_EXACTMB2N1: p += 2;
break;
601 case OP_EXACTMB2N2: p += 4;
break;
602 case OP_EXACTMB2N3: p += 6;
break;
604 GET_LENGTH_INC(
len, p); p +=
len * 2;
break;
606 GET_LENGTH_INC(
len, p); p +=
len * 3;
break;
610 GET_LENGTH_INC(mb_len, p);
611 GET_LENGTH_INC(
len, p);
617 len = enclen(enc, p, pend); p +=
len;
break;
619 GET_LENGTH_INC(
len, p); p +=
len;
break;
623 p += SIZE_BITSET;
break;
625 case OP_CCLASS_MB_NOT:
626 GET_LENGTH_INC(
len, p); p +=
len;
break;
628 case OP_CCLASS_MIX_NOT:
630 GET_LENGTH_INC(
len, p);
637 case OP_ANYCHAR_STAR:
638 case OP_ANYCHAR_ML_STAR:
641 case OP_ANYCHAR_STAR_PEEK_NEXT:
642 case OP_ANYCHAR_ML_STAR_PEEK_NEXT:
650 case OP_NOT_WORD_BOUND:
656 case OP_NOT_ASCII_WORD:
657 case OP_ASCII_WORD_BOUND:
658 case OP_NOT_ASCII_WORD_BOUND:
659 case OP_ASCII_WORD_BEGIN:
660 case OP_ASCII_WORD_END:
667 case OP_SEMI_END_BUF:
668 case OP_BEGIN_POSITION:
675 case OP_BACKREF_MULTI:
676 case OP_BACKREF_MULTI_IC:
677 case OP_BACKREF_WITH_LEVEL:
678 goto unexpected_bytecode_error;
680 case OP_MEMORY_START:
681 case OP_MEMORY_START_PUSH:
682 case OP_MEMORY_END_PUSH:
683 case OP_MEMORY_END_PUSH_REC:
685 case OP_MEMORY_END_REC:
687 if (lookaround_nesting != 0) {
688 goto unexpected_bytecode_error;
706 case OP_PUSH_OR_JUMP_EXACT1:
707 case OP_PUSH_IF_PEEK_NEXT:
708 p += SIZE_RELADDR + 1;
713 GET_MEMNUM_INC(repeat_mem, p);
715 if (reg->repeat_range[repeat_mem].lower == 0 && reg->repeat_range[repeat_mem].upper == 0) {
716 long dummy_num_cache_points = 0;
718 result = init_cache_opcodes_inner(reg, repeat_mem, lookaround_nesting, &dummy_cache_opcodes, &p, &dummy_num_cache_points);
723 if (reg->repeat_range[repeat_mem].lower == 0) {
727 long num_cache_points_in_repeat = 0;
728 long num_cache_points_at_repeat = cache_point;
730 result = init_cache_opcodes_inner(reg, repeat_mem, lookaround_nesting, &cache_opcodes, &p, &num_cache_points_in_repeat);
735 if (repeat_range->lower < repeat_range->upper) {
737 cache_point -= lookaround_nesting != 0 ? 2 : 1;
739 int repeat_bounds = repeat_range->upper == 0x7fffffff ? 1 : repeat_range->upper - repeat_range->lower;
740 cache_point += num_cache_points_in_repeat * repeat_range->lower + (num_cache_points_in_repeat + (lookaround_nesting != 0 ? 2 : 1)) * repeat_bounds;
741 for (; cache_opcodes_in_repeat < cache_opcodes; cache_opcodes_in_repeat++) {
742 cache_opcodes_in_repeat->num_cache_points_at_outer_repeat = num_cache_points_at_repeat;
743 cache_opcodes_in_repeat->num_cache_points_in_outer_repeat = num_cache_points_in_repeat;
749 case OP_REPEAT_INC_NG:
752 case OP_REPEAT_INC_SG:
753 case OP_REPEAT_INC_NG_SG:
754 goto unexpected_bytecode_error;
755 case OP_NULL_CHECK_START:
758 case OP_NULL_CHECK_END:
759 case OP_NULL_CHECK_END_MEMST_PUSH:
762 case OP_NULL_CHECK_END_MEMST:
770 result = init_cache_opcodes_inner(reg, current_repeat_mem, lookaround_nesting + 1, &cache_opcodes, &p, &cache_point);
774 UChar* match_addr = p - 1;
775 for (; cache_opcodes_in_lookaround < cache_opcodes; cache_opcodes_in_lookaround++) {
776 if (cache_opcodes_in_lookaround->match_addr == NULL) {
777 cache_opcodes_in_lookaround->match_addr = match_addr;
782 case OP_PUSH_POS_NOT:
785 case OP_PUSH_LOOK_BEHIND_NOT:
789 case OP_PUSH_STOP_BT:
792 result = init_cache_opcodes_inner(reg, current_repeat_mem, -1, &cache_opcodes, &p, &cache_point);
796 UChar* match_addr = p - 1;
797 for (; cache_opcodes_in_atomic < cache_opcodes; cache_opcodes_in_atomic++) {
798 if (cache_opcodes_in_atomic->match_addr == NULL) {
799 cache_opcodes_in_atomic->match_addr = match_addr;
806 case OP_FAIL_LOOK_BEHIND_NOT:
815 goto unexpected_bytecode_error;
819 goto unexpected_bytecode_error;
822 goto unexpected_bytecode_error;
824 case OP_STATE_CHECK_PUSH:
825 case OP_STATE_CHECK_PUSH_OR_JUMP:
827 case OP_STATE_CHECK_ANYCHAR_STAR:
828 case OP_STATE_CHECK_ANYCHAR_ML_STAR:
829 goto unexpected_bytecode_error;
831 case OP_SET_OPTION_PUSH:
842 *cache_opcodes_ptr = cache_opcodes;
844 *num_cache_points_ptr = cache_point;
850unexpected_bytecode_error:
851 return ONIGERR_UNEXPECTED_BYTECODE;
854 return ONIGERR_UNDEFINED_BYTECODE;
859init_cache_opcodes(
const regex_t* reg,
OnigCacheOpcode* cache_opcodes_ptr,
long* num_cache_points_ptr)
862 *num_cache_points_ptr = 0;
863 OnigPosition result = init_cache_opcodes_inner(reg, -1, 0, &cache_opcodes_ptr, &p, num_cache_points_ptr);
864 if (result == 0 && p != reg->p + reg->used) {
865 return ONIGERR_UNDEFINED_BYTECODE;
872count_num_cache_opcodes(regex_t* reg,
long* num_cache_opcodes)
874 *num_cache_opcodes = NUM_CACHE_OPCODES_IMPOSSIBLE;
880onig_check_linear_time(OnigRegexType* reg)
882 long num_cache_opcodes = 0;
883 count_num_cache_opcodes(reg, &num_cache_opcodes);
884 return num_cache_opcodes != NUM_CACHE_OPCODES_IMPOSSIBLE;
888onig_region_clear(OnigRegion* region)
892 for (i = 0; i < region->num_regs; i++) {
893 region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
895#ifdef USE_CAPTURE_HISTORY
896 history_root_free(region);
901onig_region_resize(OnigRegion* region,
int n)
903 region->num_regs = n;
905 if (n < ONIG_NREGION)
908 if (region->allocated == 0) {
909 region->beg = (OnigPosition* )
xmalloc(n *
sizeof(OnigPosition));
910 if (region->beg == 0)
911 return ONIGERR_MEMORY;
913 region->end = (OnigPosition* )
xmalloc(n *
sizeof(OnigPosition));
914 if (region->end == 0) {
916 return ONIGERR_MEMORY;
919 region->allocated = n;
921 else if (region->allocated < n) {
924 region->allocated = 0;
925 tmp = (OnigPosition* )
xrealloc(region->beg, n *
sizeof(OnigPosition));
929 return ONIGERR_MEMORY;
932 tmp = (OnigPosition* )
xrealloc(region->end, n *
sizeof(OnigPosition));
936 return ONIGERR_MEMORY;
940 region->allocated = n;
947onig_region_resize_clear(OnigRegion* region,
int n)
951 r = onig_region_resize(region, n);
952 if (r != 0)
return r;
953 onig_region_clear(region);
958onig_region_set(OnigRegion* region,
int at,
int beg,
int end)
960 if (at < 0)
return ONIGERR_INVALID_ARGUMENT;
962 if (at >= region->allocated) {
963 int r = onig_region_resize(region, at + 1);
967 region->beg[at] = beg;
968 region->end[at] = end;
973onig_region_init(OnigRegion* region)
975 region->num_regs = 0;
976 region->allocated = 0;
977 region->beg = (OnigPosition* )0;
978 region->end = (OnigPosition* )0;
979#ifdef USE_CAPTURE_HISTORY
980 region->history_root = (OnigCaptureTreeNode* )0;
989 r = (OnigRegion* )
xmalloc(
sizeof(OnigRegion));
996onig_region_free(OnigRegion* r,
int free_self)
999 if (r->allocated > 0) {
1003#ifdef USE_CAPTURE_HISTORY
1004 history_root_free(r);
1010 memset(r, 0,
sizeof(OnigRegion));
1016onig_region_copy(OnigRegion* to,
const OnigRegion* from)
1018#define RREGC_SIZE (sizeof(int) * from->num_regs)
1021 if (to == from)
return;
1023 r = onig_region_resize(to, from->num_regs);
1026 for (i = 0; i < from->num_regs; i++) {
1027 to->beg[i] = from->beg[i];
1028 to->end[i] = from->end[i];
1030 to->num_regs = from->num_regs;
1032#ifdef USE_CAPTURE_HISTORY
1033 history_root_free(to);
1035 if (IS_NOT_NULL(from->history_root)) {
1036 to->history_root = history_tree_clone(from->history_root);
1043#define INVALID_STACK_INDEX -1
1047#define STK_ALT 0x0001
1048#define STK_LOOK_BEHIND_NOT 0x0002
1049#define STK_POS_NOT 0x0003
1051#define STK_MEM_START 0x0100
1052#define STK_MEM_END 0x8200
1053#define STK_REPEAT_INC 0x0300
1054#define STK_STATE_CHECK_MARK 0x1000
1056#define STK_NULL_CHECK_START 0x3000
1057#define STK_NULL_CHECK_END 0x5000
1058#define STK_MEM_END_MARK 0x8400
1059#define STK_POS 0x0500
1060#define STK_STOP_BT 0x0600
1061#define STK_REPEAT 0x0700
1062#define STK_CALL_FRAME 0x0800
1063#define STK_RETURN 0x0900
1064#define STK_VOID 0x0a00
1065#define STK_ABSENT_POS 0x0b00
1066#define STK_ABSENT 0x0c00
1067#define STK_MATCH_CACHE_POINT 0x0d00
1068#define STK_ATOMIC_MATCH_CACHE_POINT 0x0e00
1071#define STK_MASK_POP_USED 0x00ff
1072#define STK_MASK_TO_VOID_TARGET 0x10ff
1073#define STK_MASK_MEM_END_OR_MARK 0x8000
1075#ifdef USE_MATCH_CACHE
1076#define MATCH_ARG_INIT_MATCH_CACHE(msa) do {\
1077 (msa).match_cache_status = MATCH_CACHE_STATUS_UNINIT;\
1078 (msa).num_fails = 0;\
1079 (msa).num_cache_opcodes = NUM_CACHE_OPCODES_UNINIT;\
1080 (msa).cache_opcodes = (OnigCacheOpcode*)NULL;\
1081 (msa).num_cache_points = 0;\
1082 (msa).match_cache_buf = (uint8_t*)NULL;\
1084#define MATCH_ARG_FREE_MATCH_CACHE(msa) do {\
1085 xfree((msa).cache_opcodes);\
1086 xfree((msa).match_cache_buf);\
1087 (msa).cache_opcodes = (OnigCacheOpcode*)NULL;\
1088 (msa).match_cache_buf = (uint8_t*)NULL;\
1091#define MATCH_ARG_INIT_MATCH_CACHE(msa)
1092#define MATCH_ARG_FREE_MATCH_CACHE(msa)
1095#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
1096# define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
1097 (msa).stack_p = (void* )0;\
1098 (msa).options = (arg_option);\
1099 (msa).region = (arg_region);\
1100 (msa).start = (arg_start);\
1101 (msa).gpos = (arg_gpos);\
1102 (msa).best_len = ONIG_MISMATCH;\
1104 (msa).end_time = 0;\
1105 MATCH_ARG_INIT_MATCH_CACHE(msa);\
1108# define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
1109 (msa).stack_p = (void* )0;\
1110 (msa).options = (arg_option);\
1111 (msa).region = (arg_region);\
1112 (msa).start = (arg_start);\
1113 (msa).gpos = (arg_gpos);\
1115 (msa).end_time = 0;\
1116 MATCH_ARG_INIT_MATCH_CACHE(msa);\
1120#ifdef USE_COMBINATION_EXPLOSION_CHECK
1122# define STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE 16
1124# define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num) do { \
1125 if ((state_num) > 0 && str_len >= STATE_CHECK_STRING_THRESHOLD_LEN) {\
1126 unsigned int size = (unsigned int )(((str_len) + 1) * (state_num) + 7) >> 3;\
1127 offset = ((offset) * (state_num)) >> 3;\
1128 if (size > 0 && offset < size && size < STATE_CHECK_BUFF_MAX_SIZE) {\
1129 if (size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) {\
1130 (msa).state_check_buff = (void* )xmalloc(size);\
1131 CHECK_NULL_RETURN_MEMERR((msa).state_check_buff);\
1134 (msa).state_check_buff = (void* )xalloca(size);\
1135 xmemset(((char* )((msa).state_check_buff)+(offset)), 0, \
1136 (size_t )(size - (offset))); \
1137 (msa).state_check_buff_size = size;\
1140 (msa).state_check_buff = (void* )0;\
1141 (msa).state_check_buff_size = 0;\
1145 (msa).state_check_buff = (void* )0;\
1146 (msa).state_check_buff_size = 0;\
1150# define MATCH_ARG_FREE(msa) do {\
1151 xfree((msa).stack_p);\
1152 if ((msa).state_check_buff_size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) { \
1153 xfree((msa).state_check_buff);\
1155 MATCH_ARG_FREE_MATCH_CACHE(msa);\
1158# define MATCH_ARG_FREE(msa) do {\
1159 xfree((msa).stack_p);\
1160 MATCH_ARG_FREE_MATCH_CACHE(msa);\
1166#define MAX_PTR_NUM 100
1168#define STACK_INIT(alloc_addr, heap_addr, ptr_num, stack_num) do {\
1169 if (ptr_num > MAX_PTR_NUM) {\
1170 alloc_addr = (char* )xmalloc(sizeof(OnigStackIndex) * (ptr_num));\
1171 heap_addr = alloc_addr;\
1172 if (msa->stack_p) {\
1173 stk_alloc = (OnigStackType* )(msa->stack_p);\
1174 stk_base = stk_alloc;\
1176 stk_end = stk_base + msa->stack_n;\
1179 stk_alloc = (OnigStackType* )xalloca(sizeof(OnigStackType) * (stack_num));\
1180 stk_base = stk_alloc;\
1182 stk_end = stk_base + (stack_num);\
1185 else if (msa->stack_p) {\
1186 alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num));\
1188 stk_alloc = (OnigStackType* )(msa->stack_p);\
1189 stk_base = stk_alloc;\
1191 stk_end = stk_base + msa->stack_n;\
1194 alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num)\
1195 + sizeof(OnigStackType) * (stack_num));\
1197 stk_alloc = (OnigStackType* )(alloc_addr + sizeof(OnigStackIndex) * (ptr_num));\
1198 stk_base = stk_alloc;\
1200 stk_end = stk_base + (stack_num);\
1204#define STACK_SAVE do{\
1205 if (stk_base != stk_alloc) {\
1206 msa->stack_p = stk_base;\
1207 msa->stack_n = stk_end - stk_base; \
1211static unsigned int MatchStackLimitSize = DEFAULT_MATCH_STACK_LIMIT_SIZE;
1214onig_get_match_stack_limit_size(
void)
1216 return MatchStackLimitSize;
1220onig_set_match_stack_limit_size(
unsigned int size)
1222 MatchStackLimitSize = size;
1227stack_double(OnigStackType** arg_stk_base, OnigStackType** arg_stk_end,
1228 OnigStackType** arg_stk, OnigStackType* stk_alloc,
OnigMatchArg* msa)
1231 OnigStackType *x, *stk_base, *stk_end, *stk;
1233 stk_base = *arg_stk_base;
1234 stk_end = *arg_stk_end;
1237 n = stk_end - stk_base;
1238 if (stk_base == stk_alloc && IS_NULL(msa->stack_p)) {
1239 x = (OnigStackType* )
xmalloc(
sizeof(OnigStackType) * n * 2);
1242 return ONIGERR_MEMORY;
1244 xmemcpy(x, stk_base, n *
sizeof(OnigStackType));
1248 unsigned int limit_size = MatchStackLimitSize;
1250 if (limit_size != 0 && n > limit_size) {
1251 if ((
unsigned int )(stk_end - stk_base) == limit_size)
1252 return ONIGERR_MATCH_STACK_LIMIT_OVER;
1256 x = (OnigStackType* )
xrealloc(stk_base,
sizeof(OnigStackType) * n);
1259 return ONIGERR_MEMORY;
1262 *arg_stk = x + (stk - stk_base);
1264 *arg_stk_end = x + n;
1268#define STACK_ENSURE(n) do {\
1269 if (stk_end - stk < (n)) {\
1270 int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\
1273 xfree(xmalloc_base);\
1279#define STACK_AT(index) (stk_base + (index))
1280#define GET_STACK_INDEX(stk) ((stk) - stk_base)
1282#define STACK_PUSH_TYPE(stack_type) do {\
1284 stk->type = (stack_type);\
1285 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1289#define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0)
1291#ifdef USE_COMBINATION_EXPLOSION_CHECK
1292# define STATE_CHECK_POS(s,snum) \
1293 (((s) - str) * num_comb_exp_check + ((snum) - 1))
1294# define STATE_CHECK_VAL(v,snum) do {\
1295 if (state_check_buff != NULL) {\
1296 ptrdiff_t x = STATE_CHECK_POS(s,snum);\
1297 (v) = state_check_buff[x/8] & (1<<(x%8));\
1303# define ELSE_IF_STATE_CHECK_MARK(stk) \
1304 else if ((stk)->type == STK_STATE_CHECK_MARK) { \
1305 ptrdiff_t x = STATE_CHECK_POS(stk->u.state.pstr, stk->u.state.state_check);\
1306 state_check_buff[x/8] |= (1<<(x%8)); \
1309# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
1311 stk->type = (stack_type);\
1312 stk->u.state.pcode = (pat);\
1313 stk->u.state.pstr = (s);\
1314 stk->u.state.pstr_prev = (sprev);\
1315 stk->u.state.state_check = 0;\
1316 stk->u.state.pkeep = (keep);\
1320# define STACK_PUSH_ENSURED(stack_type,pat) do {\
1321 stk->type = (stack_type);\
1322 stk->u.state.pcode = (pat);\
1323 stk->u.state.state_check = 0;\
1327# define STACK_PUSH_ALT_WITH_STATE_CHECK(pat,s,sprev,snum,keep) do {\
1329 stk->type = STK_ALT;\
1330 stk->u.state.pcode = (pat);\
1331 stk->u.state.pstr = (s);\
1332 stk->u.state.pstr_prev = (sprev);\
1333 stk->u.state.state_check = ((state_check_buff != NULL) ? (snum) : 0);\
1334 stk->u.state.pkeep = (keep);\
1338# define STACK_PUSH_STATE_CHECK(s,snum) do {\
1339 if (state_check_buff != NULL) {\
1341 stk->type = STK_STATE_CHECK_MARK;\
1342 stk->u.state.pstr = (s);\
1343 stk->u.state.state_check = (snum);\
1350# define ELSE_IF_STATE_CHECK_MARK(stk)
1352# define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
1354 stk->type = (stack_type);\
1355 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1356 stk->u.state.pcode = (pat);\
1357 stk->u.state.pstr = (s);\
1358 stk->u.state.pstr_prev = (sprev);\
1359 stk->u.state.pkeep = (keep);\
1363# define STACK_PUSH_ENSURED(stack_type,pat) do {\
1364 stk->type = (stack_type);\
1365 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1366 stk->u.state.pcode = (pat);\
1371#define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep)
1372#define STACK_PUSH_POS(s,sprev,keep) STACK_PUSH(STK_POS,NULL_UCHARP,s,sprev,keep)
1373#define STACK_PUSH_POS_NOT(pat,s,sprev,keep) STACK_PUSH(STK_POS_NOT,pat,s,sprev,keep)
1374#define STACK_PUSH_ABSENT STACK_PUSH_TYPE(STK_ABSENT)
1375#define STACK_PUSH_STOP_BT STACK_PUSH_TYPE(STK_STOP_BT)
1376#define STACK_PUSH_LOOK_BEHIND_NOT(pat,s,sprev,keep) \
1377 STACK_PUSH(STK_LOOK_BEHIND_NOT,pat,s,sprev,keep)
1379#define STACK_PUSH_REPEAT(id, pat) do {\
1381 stk->type = STK_REPEAT;\
1382 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1383 stk->u.repeat.num = (id);\
1384 stk->u.repeat.pcode = (pat);\
1385 stk->u.repeat.count = 0;\
1389#define STACK_PUSH_REPEAT_INC(sindex) do {\
1391 stk->type = STK_REPEAT_INC;\
1392 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1393 stk->u.repeat_inc.si = (sindex);\
1397#define STACK_PUSH_MEM_START(mnum, s) do {\
1399 stk->type = STK_MEM_START;\
1400 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1401 stk->u.mem.num = (mnum);\
1402 stk->u.mem.pstr = (s);\
1403 stk->u.mem.start = mem_start_stk[mnum];\
1404 stk->u.mem.end = mem_end_stk[mnum];\
1405 mem_start_stk[mnum] = GET_STACK_INDEX(stk);\
1406 mem_end_stk[mnum] = INVALID_STACK_INDEX;\
1410#define STACK_PUSH_MEM_END(mnum, s) do {\
1412 stk->type = STK_MEM_END;\
1413 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1414 stk->u.mem.num = (mnum);\
1415 stk->u.mem.pstr = (s);\
1416 stk->u.mem.start = mem_start_stk[mnum];\
1417 stk->u.mem.end = mem_end_stk[mnum];\
1418 mem_end_stk[mnum] = GET_STACK_INDEX(stk);\
1422#define STACK_PUSH_MEM_END_MARK(mnum) do {\
1424 stk->type = STK_MEM_END_MARK;\
1425 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1426 stk->u.mem.num = (mnum);\
1430#define STACK_GET_MEM_START(mnum, k) do {\
1433 while (k > stk_base) {\
1435 if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \
1436 && k->u.mem.num == (mnum)) {\
1439 else if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
1440 if (level == 0) break;\
1446#define STACK_GET_MEM_RANGE(k, mnum, start, end) do {\
1449 if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
1450 if (level == 0) (start) = k->u.mem.pstr;\
1453 else if (k->type == STK_MEM_END && k->u.mem.num == (mnum)) {\
1456 (end) = k->u.mem.pstr;\
1464#define STACK_PUSH_NULL_CHECK_START(cnum, s) do {\
1466 stk->type = STK_NULL_CHECK_START;\
1467 stk->null_check = (OnigStackIndex)(stk - stk_base);\
1468 stk->u.null_check.num = (cnum);\
1469 stk->u.null_check.pstr = (s);\
1473#define STACK_PUSH_NULL_CHECK_END(cnum) do {\
1475 stk->type = STK_NULL_CHECK_END;\
1476 stk->null_check = (OnigStackIndex)(stk - stk_base);\
1477 stk->u.null_check.num = (cnum);\
1481#define STACK_PUSH_CALL_FRAME(pat) do {\
1483 stk->type = STK_CALL_FRAME;\
1484 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1485 stk->u.call_frame.ret_addr = (pat);\
1489#define STACK_PUSH_RETURN do {\
1491 stk->type = STK_RETURN;\
1492 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1496#define STACK_PUSH_ABSENT_POS(start, end) do {\
1498 stk->type = STK_ABSENT_POS;\
1499 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1500 stk->u.absent_pos.abs_pstr = (start);\
1501 stk->u.absent_pos.end_pstr = (end);\
1505#define STACK_PUSH_MATCH_CACHE_POINT(match_cache_point_index, match_cache_point_mask) do {\
1507 stk->type = STK_MATCH_CACHE_POINT;\
1508 stk->null_check = stk == stk_base ? 0 : (stk-1)->null_check;\
1509 stk->u.match_cache_point.index = (match_cache_point_index);\
1510 stk->u.match_cache_point.mask = (match_cache_point_mask);\
1516# define STACK_BASE_CHECK(p, at) \
1517 if ((p) < stk_base) {\
1518 fprintf(stderr, "at %s\n", at);\
1522# define STACK_BASE_CHECK(p, at)
1525#ifdef ONIG_DEBUG_MATCH_CACHE
1526# define MATCH_CACHE_DEBUG_MEMOIZE(stkp) fprintf(stderr, "MATCH CACHE: memoize (index=%ld mask=%d)\n", stkp->u.match_cache_point.index, stkp->u.match_cache_point.mask);
1528# define MATCH_CACHE_DEBUG_MEMOIZE(stkp) ((void) 0)
1531#ifdef USE_MATCH_CACHE
1532# define INC_NUM_FAILS msa->num_fails++
1533# define MEMOIZE_MATCH_CACHE_POINT do {\
1534 if (stk->type == STK_MATCH_CACHE_POINT) {\
1535 msa->match_cache_buf[stk->u.match_cache_point.index] |= stk->u.match_cache_point.mask;\
1536 MATCH_CACHE_DEBUG_MEMOIZE(stk);\
1538 else if (stk->type == STK_ATOMIC_MATCH_CACHE_POINT) {\
1539 memoize_extended_match_cache_point(msa->match_cache_buf, stk->u.match_cache_point.index, stk->u.match_cache_point.mask);\
1540 MATCH_CACHE_DEBUG_MEMOIZE(stkp);\
1543# define MEMOIZE_LOOKAROUND_MATCH_CACHE_POINT(stkp) do {\
1544 if (stkp->type == STK_MATCH_CACHE_POINT) {\
1545 stkp->type = STK_VOID;\
1546 memoize_extended_match_cache_point(msa->match_cache_buf, stkp->u.match_cache_point.index, stkp->u.match_cache_point.mask);\
1547 MATCH_CACHE_DEBUG_MEMOIZE(stkp);\
1550# define MEMOIZE_ATOMIC_MATCH_CACHE_POINT do {\
1551 if (stk->type == STK_MATCH_CACHE_POINT) {\
1552 memoize_extended_match_cache_point(msa->match_cache_buf, stk->u.match_cache_point.index, stk->u.match_cache_point.mask);\
1553 MATCH_CACHE_DEBUG_MEMOIZE(stkp);\
1557# define INC_NUM_FAILS ((void) 0)
1558# define MEMOIZE_MATCH_CACHE_POINT ((void) 0)
1559# define MEMOIZE_LOOKAROUND_MATCH_CACHE_POINT(stkp) ((void) 0)
1562#define STACK_POP_ONE do {\
1564 STACK_BASE_CHECK(stk, "STACK_POP_ONE"); \
1567#define STACK_POP do {\
1568 switch (pop_level) {\
1569 case STACK_POP_LEVEL_FREE:\
1572 STACK_BASE_CHECK(stk, "STACK_POP"); \
1573 if ((stk->type & STK_MASK_POP_USED) != 0) break;\
1574 ELSE_IF_STATE_CHECK_MARK(stk);\
1575 MEMOIZE_MATCH_CACHE_POINT;\
1578 case STACK_POP_LEVEL_MEM_START:\
1581 STACK_BASE_CHECK(stk, "STACK_POP 2"); \
1582 if ((stk->type & STK_MASK_POP_USED) != 0) break;\
1583 else if (stk->type == STK_MEM_START) {\
1584 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1585 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1587 ELSE_IF_STATE_CHECK_MARK(stk);\
1588 MEMOIZE_MATCH_CACHE_POINT;\
1594 STACK_BASE_CHECK(stk, "STACK_POP 3"); \
1595 if ((stk->type & STK_MASK_POP_USED) != 0) break;\
1596 else if (stk->type == STK_MEM_START) {\
1597 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1598 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1600 else if (stk->type == STK_REPEAT_INC) {\
1601 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
1603 else if (stk->type == STK_MEM_END) {\
1604 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1605 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1607 ELSE_IF_STATE_CHECK_MARK(stk);\
1608 MEMOIZE_MATCH_CACHE_POINT;\
1614#define STACK_POP_TIL_POS_NOT do {\
1617 STACK_BASE_CHECK(stk, "STACK_POP_TIL_POS_NOT"); \
1618 if (stk->type == STK_POS_NOT) break;\
1619 else if (stk->type == STK_MEM_START) {\
1620 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1621 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1623 else if (stk->type == STK_REPEAT_INC) {\
1624 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
1626 else if (stk->type == STK_MEM_END) {\
1627 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1628 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1630 else if (IS_TO_VOID_TARGET(stk)) {\
1633 ELSE_IF_STATE_CHECK_MARK(stk);\
1634 MEMOIZE_LOOKAROUND_MATCH_CACHE_POINT(stk);\
1638#define STACK_POP_TIL_LOOK_BEHIND_NOT do {\
1641 STACK_BASE_CHECK(stk, "STACK_POP_TIL_LOOK_BEHIND_NOT"); \
1642 if (stk->type == STK_LOOK_BEHIND_NOT) break;\
1643 else if (stk->type == STK_MEM_START) {\
1644 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1645 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1647 else if (stk->type == STK_REPEAT_INC) {\
1648 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
1650 else if (stk->type == STK_MEM_END) {\
1651 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1652 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1654 ELSE_IF_STATE_CHECK_MARK(stk);\
1658#define STACK_POP_TIL_ABSENT do {\
1661 STACK_BASE_CHECK(stk, "STACK_POP_TIL_ABSENT"); \
1662 if (stk->type == STK_ABSENT) break;\
1663 else if (stk->type == STK_MEM_START) {\
1664 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1665 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1667 else if (stk->type == STK_REPEAT_INC) {\
1668 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
1670 else if (stk->type == STK_MEM_END) {\
1671 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
1672 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
1674 ELSE_IF_STATE_CHECK_MARK(stk);\
1678#define STACK_POP_ABSENT_POS(start, end) do {\
1680 STACK_BASE_CHECK(stk, "STACK_POP_ABSENT_POS"); \
1681 (start) = stk->u.absent_pos.abs_pstr;\
1682 (end) = stk->u.absent_pos.end_pstr;\
1685#define STACK_POS_END(k) do {\
1689 STACK_BASE_CHECK(k, "STACK_POS_END"); \
1690 if (IS_TO_VOID_TARGET(k)) {\
1692 k->type = STK_VOID;\
1694 else if (k->type == STK_POS) {\
1695 k->type = STK_VOID;\
1698 MEMOIZE_LOOKAROUND_MATCH_CACHE_POINT(k);\
1702#define STACK_STOP_BT_END do {\
1703 OnigStackType *k = stk;\
1706 STACK_BASE_CHECK(k, "STACK_STOP_BT_END"); \
1707 if (IS_TO_VOID_TARGET(k)) {\
1709 k->type = STK_VOID;\
1711 else if (k->type == STK_STOP_BT) {\
1712 k->type = STK_VOID;\
1715 else if (k->type == STK_MATCH_CACHE_POINT) {\
1716 k->type = STK_ATOMIC_MATCH_CACHE_POINT;\
1721#define STACK_STOP_BT_FAIL do {\
1724 STACK_BASE_CHECK(stk, "STACK_STOP_BT_END"); \
1725 if (stk->type == STK_STOP_BT) {\
1726 stk->type = STK_VOID;\
1729 MEMOIZE_ATOMIC_MATCH_CACHE_POINT;\
1733#define STACK_NULL_CHECK(isnull,id,s) do {\
1734 OnigStackType* k = STACK_AT((stk-1)->null_check)+1;\
1737 STACK_BASE_CHECK(k, "STACK_NULL_CHECK"); \
1738 if (k->type == STK_NULL_CHECK_START) {\
1739 if (k->u.null_check.num == (id)) {\
1740 (isnull) = (k->u.null_check.pstr == (s));\
1747#define STACK_NULL_CHECK_REC(isnull,id,s) do {\
1749 OnigStackType* k = STACK_AT((stk-1)->null_check)+1;\
1752 STACK_BASE_CHECK(k, "STACK_NULL_CHECK_REC"); \
1753 if (k->type == STK_NULL_CHECK_START) {\
1754 if (k->u.null_check.num == (id)) {\
1756 (isnull) = (k->u.null_check.pstr == (s));\
1762 else if (k->type == STK_NULL_CHECK_END) {\
1768#define STACK_NULL_CHECK_MEMST(isnull,id,s,reg) do {\
1769 OnigStackType* k = STACK_AT((stk-1)->null_check)+1;\
1772 STACK_BASE_CHECK(k, "STACK_NULL_CHECK_MEMST"); \
1773 if (k->type == STK_NULL_CHECK_START) {\
1774 if (k->u.null_check.num == (id)) {\
1775 if (k->u.null_check.pstr != (s)) {\
1783 if (k->type == STK_MEM_START) {\
1784 if (k->u.mem.end == INVALID_STACK_INDEX) {\
1785 (isnull) = 0; break;\
1787 if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
1788 endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
1790 endp = (UChar* )k->u.mem.end;\
1791 if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\
1792 (isnull) = 0; break;\
1794 else if (endp != s) {\
1807#define STACK_NULL_CHECK_MEMST_REC(isnull,id,s,reg) do {\
1809 OnigStackType* k = STACK_AT((stk-1)->null_check)+1;\
1812 STACK_BASE_CHECK(k, "STACK_NULL_CHECK_MEMST_REC"); \
1813 if (k->type == STK_NULL_CHECK_START) {\
1814 if (k->u.null_check.num == (id)) {\
1816 if (k->u.null_check.pstr != (s)) {\
1824 if (k->type == STK_MEM_START) {\
1825 if (k->u.mem.end == INVALID_STACK_INDEX) {\
1826 (isnull) = 0; break;\
1828 if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
1829 endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
1831 endp = (UChar* )k->u.mem.end;\
1832 if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\
1833 (isnull) = 0; break;\
1835 else if (endp != s) {\
1849 else if (k->type == STK_NULL_CHECK_END) {\
1850 if (k->u.null_check.num == (id)) level++;\
1855#define STACK_GET_REPEAT(id, k) do {\
1860 STACK_BASE_CHECK(k, "STACK_GET_REPEAT"); \
1861 if (k->type == STK_REPEAT) {\
1863 if (k->u.repeat.num == (id)) {\
1868 else if (k->type == STK_CALL_FRAME) level--;\
1869 else if (k->type == STK_RETURN) level++;\
1873#define STACK_RETURN(addr) do {\
1875 OnigStackType* k = stk;\
1878 STACK_BASE_CHECK(k, "STACK_RETURN"); \
1879 if (k->type == STK_CALL_FRAME) {\
1881 (addr) = k->u.call_frame.ret_addr;\
1886 else if (k->type == STK_RETURN)\
1892#define STRING_CMP(s1,s2,len) do {\
1893 while (len-- > 0) {\
1894 if (*s1++ != *s2++) goto fail;\
1898#define STRING_CMP_IC(case_fold_flag,s1,ps2,len,text_end) do {\
1899 if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \
1903static int string_cmp_ic(OnigEncoding enc,
int case_fold_flag,
1904 UChar* s1, UChar** ps2, OnigDistance mblen,
const UChar* text_end)
1906 UChar buf1[ONIGENC_MBC_CASE_FOLD_MAXLEN];
1907 UChar buf2[ONIGENC_MBC_CASE_FOLD_MAXLEN];
1908 UChar *p1, *p2, *end1, *s2;
1914 if (s2 >= text_end)
return 0;
1915 len1 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s1, text_end, buf1);
1916 len2 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s2, text_end, buf2);
1917 if (len1 != len2)
return 0;
1920 while (len1-- > 0) {
1921 if (*p1 != *p2)
return 0;
1931#define STRING_CMP_VALUE(s1,s2,len,is_fail) do {\
1933 while (len-- > 0) {\
1934 if (*s1++ != *s2++) {\
1935 is_fail = 1; break;\
1940#define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,text_end,is_fail) do {\
1941 if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \
1948#define IS_EMPTY_STR (str == end)
1949#define ON_STR_BEGIN(s) ((s) == str)
1950#define ON_STR_END(s) ((s) == end)
1951#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
1952# define DATA_ENSURE_CHECK1 (s < right_range)
1953# define DATA_ENSURE_CHECK(n) (s + (n) <= right_range)
1954# define DATA_ENSURE(n) if (s + (n) > right_range) goto fail
1955# define DATA_ENSURE_CONTINUE(n) if (s + (n) > right_range) continue
1956# define ABSENT_END_POS right_range
1958# define DATA_ENSURE_CHECK1 (s < end)
1959# define DATA_ENSURE_CHECK(n) (s + (n) <= end)
1960# define DATA_ENSURE(n) if (s + (n) > end) goto fail
1961# define DATA_ENSURE_CONTINUE(n) if (s + (n) > end) continue
1962# define ABSENT_END_POS end
1965int onigenc_mbclen_approximate(
const OnigUChar* p,
const OnigUChar* e,
const struct OnigEncodingTypeST* enc);
1968enclen_approx(OnigEncoding enc,
const OnigUChar* p,
const OnigUChar* e)
1970 if (enc->max_enc_len == enc->min_enc_len) {
1971 return (p < e ? enc->min_enc_len : 0);
1974 return onigenc_mbclen_approximate(p, e, enc);
1979#ifdef USE_CAPTURE_HISTORY
1981make_capture_history_tree(OnigCaptureTreeNode* node, OnigStackType** kp,
1982 OnigStackType* stk_top, UChar* str, regex_t* reg)
1985 OnigCaptureTreeNode* child;
1986 OnigStackType* k = *kp;
1988 while (k < stk_top) {
1989 if (k->type == STK_MEM_START) {
1991 if (n <= ONIG_MAX_CAPTURE_HISTORY_GROUP &&
1992 BIT_STATUS_AT(reg->capture_history, n) != 0) {
1993 child = history_node_new();
1994 CHECK_NULL_RETURN_MEMERR(child);
1996 child->beg = k->u.mem.pstr - str;
1997 r = history_tree_add_child(node, child);
1999 history_tree_free(child);
2003 r = make_capture_history_tree(child, kp, stk_top, str, reg);
2004 if (r != 0)
return r;
2007 child->end = k->u.mem.pstr - str;
2010 else if (k->type == STK_MEM_END) {
2011 if (k->u.mem.num == node->group) {
2012 node->end = k->u.mem.pstr - str;
2024#ifdef USE_BACKREF_WITH_LEVEL
2026mem_is_in_memp(
int mem,
int num, UChar* memp)
2031 for (i = 0; i < num; i++) {
2032 GET_MEMNUM_INC(m, memp);
2033 if (mem == (
int )m)
return 1;
2038static int backref_match_at_nested_level(regex_t* reg,
2039 OnigStackType* top, OnigStackType* stk_base,
2040 int ignore_case,
int case_fold_flag,
2041 int nest,
int mem_num, UChar* memp, UChar** s,
const UChar* send)
2043 UChar *ss, *p, *pstart, *pend = NULL_UCHARP;
2050 while (k >= stk_base) {
2051 if (k->type == STK_CALL_FRAME) {
2054 else if (k->type == STK_RETURN) {
2057 else if (level == nest) {
2058 if (k->type == STK_MEM_START) {
2059 if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
2060 pstart = k->u.mem.pstr;
2061 if (pend != NULL_UCHARP) {
2062 if (pend - pstart > send - *s)
return 0;
2066 if (ignore_case != 0) {
2067 if (string_cmp_ic(reg->enc, case_fold_flag,
2068 pstart, &ss, pend - pstart, send) == 0)
2073 if (*p++ != *ss++)
return 0;
2082 else if (k->type == STK_MEM_END) {
2083 if (mem_is_in_memp(k->u.mem.num, mem_num, memp)) {
2084 pend = k->u.mem.pstr;
2096#ifdef ONIG_DEBUG_STATISTICS
2099# include <windows.h>
2100static LARGE_INTEGER ts, te, freq;
2101# define GETTIME(t) QueryPerformanceCounter(&(t))
2102# define TIMEDIFF(te,ts) (unsigned long )(((te).QuadPart - (ts).QuadPart) \
2103 * 1000000 / freq.QuadPart)
2106# define USE_TIMEOFDAY
2108# ifdef USE_TIMEOFDAY
2109# ifdef HAVE_SYS_TIME_H
2110# include <sys/time.h>
2112# ifdef HAVE_UNISTD_H
2116# define GETTIME(t) gettimeofday(&(t), (struct timezone* )0)
2117# define TIMEDIFF(te,ts) (((te).tv_usec - (ts).tv_usec) + \
2118 (((te).tv_sec - (ts).tv_sec)*1000000))
2120# ifdef HAVE_SYS_TIMES_H
2121# include <sys/times.h>
2123static struct tms ts, te;
2124# define GETTIME(t) times(&(t))
2125# define TIMEDIFF(te,ts) ((te).tms_utime - (ts).tms_utime)
2130static int OpCounter[256];
2131static int OpPrevCounter[256];
2132static unsigned long OpTime[256];
2133static int OpCurr = OP_FINISH;
2134static int OpPrevTarget = OP_FAIL;
2135static int MaxStackDepth = 0;
2137# define MOP_IN(opcode) do {\
2138 if (opcode == OpPrevTarget) OpPrevCounter[OpCurr]++;\
2140 OpCounter[opcode]++;\
2144# define MOP_OUT do {\
2146 OpTime[OpCurr] += TIMEDIFF(te, ts);\
2150onig_statistics_init(
void)
2153 for (i = 0; i < 256; i++) {
2154 OpCounter[i] = OpPrevCounter[i] = 0; OpTime[i] = 0;
2158 QueryPerformanceFrequency(&freq);
2163onig_print_statistics(FILE* f)
2166 fprintf(f,
" count prev time\n");
2167 for (i = 0; OnigOpInfo[i].opcode >= 0; i++) {
2168 fprintf(f,
"%8d: %8d: %10lu: %s\n",
2169 OpCounter[i], OpPrevCounter[i], OpTime[i], OnigOpInfo[i].name);
2171 fprintf(f,
"\nmax stack depth: %d\n", MaxStackDepth);
2174# define STACK_INC do {\
2176 if (stk - stk_base > MaxStackDepth) \
2177 MaxStackDepth = stk - stk_base;\
2181# define STACK_INC stk++
2183# define MOP_IN(opcode)
2188#ifdef ONIG_DEBUG_MATCH
2190stack_type_str(
int stack_type)
2192 switch (stack_type) {
2193 case STK_ALT:
return "Alt ";
2194 case STK_LOOK_BEHIND_NOT:
return "LBNot ";
2195 case STK_POS_NOT:
return "PosNot";
2196 case STK_MEM_START:
return "MemS ";
2197 case STK_MEM_END:
return "MemE ";
2198 case STK_REPEAT_INC:
return "RepInc";
2199 case STK_STATE_CHECK_MARK:
return "StChMk";
2200 case STK_NULL_CHECK_START:
return "NulChS";
2201 case STK_NULL_CHECK_END:
return "NulChE";
2202 case STK_MEM_END_MARK:
return "MemEMk";
2203 case STK_POS:
return "Pos ";
2204 case STK_STOP_BT:
return "StopBt";
2205 case STK_REPEAT:
return "Rep ";
2206 case STK_CALL_FRAME:
return "Call ";
2207 case STK_RETURN:
return "Ret ";
2208 case STK_VOID:
return "Void ";
2209 case STK_ABSENT_POS:
return "AbsPos";
2210 case STK_ABSENT:
return "Absent";
2211 case STK_MATCH_CACHE_POINT:
return "MCache";
2212 default:
return " ";
2216#ifdef USE_MATCH_CACHE
2219bsearch_cache_opcodes(
const OnigCacheOpcode *cache_opcodes,
long num_cache_opcodes,
const UChar* p)
2221 long l = 0, r = num_cache_opcodes - 1, m = 0;
2225 if (cache_opcodes[m].addr == p)
break;
2226 if (cache_opcodes[m].addr < p) l = m + 1;
2233find_cache_point(regex_t* reg,
const OnigCacheOpcode* cache_opcodes,
long num_cache_opcodes,
const UChar* p,
const OnigStackType *stk,
const OnigStackIndex *repeat_stk,
const OnigCacheOpcode **cache_opcode_ptr)
2238 const OnigStackType *stkp;
2240 int is_inc = *p == OP_REPEAT_INC || *p == OP_REPEAT_INC_NG;
2242 long num_cache_points_at_outer_repeat;
2243 long num_cache_points_in_outer_repeat;
2245 m = bsearch_cache_opcodes(cache_opcodes, num_cache_opcodes, p);
2247 if (!(0 <= m && m < num_cache_opcodes && cache_opcodes[m].addr == p)) {
2251 cache_opcode = &cache_opcodes[m];
2252 *cache_opcode_ptr = &cache_opcodes[m];
2253 cache_point = cache_opcode->cache_point;
2254 if (cache_opcode->outer_repeat_mem == -1) {
2258 num_cache_points_at_outer_repeat = cache_opcode->num_cache_points_at_outer_repeat;
2259 num_cache_points_in_outer_repeat = cache_opcode->num_cache_points_in_outer_repeat;
2261 range = ®->repeat_range[cache_opcode->outer_repeat_mem];
2263 stkp = &stk[repeat_stk[cache_opcode->outer_repeat_mem]];
2264 count = is_inc ? stkp->u.repeat.count - 1 : stkp->u.repeat.count;
2266 if (count < range->lower) {
2267 return num_cache_points_at_outer_repeat +
2268 num_cache_points_in_outer_repeat * count +
2272 if (range->upper == 0x7fffffff) {
2273 return num_cache_points_at_outer_repeat +
2274 num_cache_points_in_outer_repeat * (range->lower - (is_inc ? 1 : 0)) + (is_inc ? 0 : 1) +
2278 return num_cache_points_at_outer_repeat +
2279 num_cache_points_in_outer_repeat * (range->lower - 1) +
2280 (num_cache_points_in_outer_repeat + 1) * (count - range->lower + 1) +
2285check_extended_match_cache_point(uint8_t *match_cache_buf,
long match_cache_point_index, uint8_t match_cache_point_mask)
2287 if (match_cache_point_mask & 0x80) {
2288 return (match_cache_buf[match_cache_point_index + 1] & 0x01) > 0;
2291 return (match_cache_buf[match_cache_point_index] & (match_cache_point_mask << 1)) > 0;
2296memoize_extended_match_cache_point(uint8_t *match_cache_buf,
long match_cache_point_index, uint8_t match_cache_point_mask)
2298 match_cache_buf[match_cache_point_index] |= match_cache_point_mask;
2299 if (match_cache_point_mask & 0x80) {
2300 match_cache_buf[match_cache_point_index + 1] |= 0x01;
2303 match_cache_buf[match_cache_point_index] |= match_cache_point_mask << 1;
2312match_at(regex_t* reg,
const UChar* str,
const UChar* end,
2313#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
2314 const UChar* right_range,
2318 static const UChar FinishCode[] = { OP_FINISH };
2320 int i, num_mem, pop_level;
2321 ptrdiff_t n, best_len;
2322 LengthType tlen, tlen2;
2325 OnigOptionType option = reg->options;
2326 OnigEncoding encode = reg->enc;
2327 OnigCaseFoldType case_fold_flag = reg->case_fold_flag;
2328 UChar *s, *q, *sbegin;
2333 char *xmalloc_base = NULL;
2334 OnigStackType *stk_alloc, *stk_base = NULL, *stk, *stk_end;
2335 OnigStackType *stkp;
2337 OnigStackIndex *repeat_stk;
2338 OnigStackIndex *mem_start_stk, *mem_end_stk;
2339#ifdef USE_COMBINATION_EXPLOSION_CHECK
2341 unsigned char* state_check_buff = msa->state_check_buff;
2342 int num_comb_exp_check = reg->num_comb_exp_check;
2345#if USE_TOKEN_THREADED_VM
2347# define VM_LOOP JUMP;
2349# define CASE(x) L_##x: sbegin = s; OPCODE_EXEC_HOOK;
2350# define DEFAULT L_DEFAULT:
2351# define NEXT sprev = sbegin; JUMP
2352# define JUMP pbegin = p; RB_GNUC_EXTENSION_BLOCK(goto *oplabels[*p++])
2378 &&L_OP_CCLASS_MB_NOT,
2379 &&L_OP_CCLASS_MIX_NOT,
2383 &&L_OP_ANYCHAR_STAR,
2384 &&L_OP_ANYCHAR_ML_STAR,
2385 &&L_OP_ANYCHAR_STAR_PEEK_NEXT,
2386 &&L_OP_ANYCHAR_ML_STAR_PEEK_NEXT,
2391 &&L_OP_NOT_WORD_BOUND,
2392# ifdef USE_WORD_BEGIN_END
2400 &&L_OP_NOT_ASCII_WORD,
2401 &&L_OP_ASCII_WORD_BOUND,
2402 &&L_OP_NOT_ASCII_WORD_BOUND,
2403# ifdef USE_WORD_BEGIN_END
2404 &&L_OP_ASCII_WORD_BEGIN,
2405 &&L_OP_ASCII_WORD_END,
2415 &&L_OP_SEMI_END_BUF,
2416 &&L_OP_BEGIN_POSITION,
2422 &&L_OP_BACKREF_MULTI,
2423 &&L_OP_BACKREF_MULTI_IC,
2424# ifdef USE_BACKREF_WITH_LEVEL
2425 &&L_OP_BACKREF_WITH_LEVEL,
2429 &&L_OP_MEMORY_START,
2430 &&L_OP_MEMORY_START_PUSH,
2431 &&L_OP_MEMORY_END_PUSH,
2432# ifdef USE_SUBEXP_CALL
2433 &&L_OP_MEMORY_END_PUSH_REC,
2438# ifdef USE_SUBEXP_CALL
2439 &&L_OP_MEMORY_END_REC,
2450# ifdef USE_OP_PUSH_OR_JUMP_EXACT
2451 &&L_OP_PUSH_OR_JUMP_EXACT1,
2455 &&L_OP_PUSH_IF_PEEK_NEXT,
2459 &&L_OP_REPEAT_INC_NG,
2460 &&L_OP_REPEAT_INC_SG,
2461 &&L_OP_REPEAT_INC_NG_SG,
2462 &&L_OP_NULL_CHECK_START,
2463 &&L_OP_NULL_CHECK_END,
2464# ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
2465 &&L_OP_NULL_CHECK_END_MEMST,
2469# ifdef USE_SUBEXP_CALL
2470 &&L_OP_NULL_CHECK_END_MEMST_PUSH,
2477 &&L_OP_PUSH_POS_NOT,
2479 &&L_OP_PUSH_STOP_BT,
2482 &&L_OP_PUSH_LOOK_BEHIND_NOT,
2483 &&L_OP_FAIL_LOOK_BEHIND_NOT,
2484 &&L_OP_PUSH_ABSENT_POS,
2488# ifdef USE_SUBEXP_CALL
2497# ifdef USE_COMBINATION_EXPLOSION_CHECK
2498 &&L_OP_STATE_CHECK_PUSH,
2499 &&L_OP_STATE_CHECK_PUSH_OR_JUMP,
2506# ifdef USE_COMBINATION_EXPLOSION_CHECK
2507 &&L_OP_STATE_CHECK_ANYCHAR_STAR,
2508 &&L_OP_STATE_CHECK_ANYCHAR_ML_STAR,
2515 &&L_OP_SET_OPTION_PUSH,
2531# define VM_LOOP_END } sprev = sbegin; }
2532# define CASE(x) case x:
2533# define DEFAULT default:
2535# define JUMP continue; break
2539#ifdef USE_SUBEXP_CALL
2542# define ADD_NUMMEM 1
2545# define ADD_NUMMEM 0
2548 n = reg->num_repeat + (reg->num_mem + ADD_NUMMEM) * 2;
2550 STACK_INIT(alloca_base, xmalloc_base, n, INIT_MATCH_STACK_SIZE);
2551 pop_level = reg->stack_pop_level;
2552 num_mem = reg->num_mem;
2553 repeat_stk = (OnigStackIndex* )alloca_base;
2555 mem_start_stk = (OnigStackIndex* )(repeat_stk + reg->num_repeat);
2556 mem_end_stk = mem_start_stk + (num_mem + ADD_NUMMEM);
2558 OnigStackIndex *pp = mem_start_stk;
2559 for (; pp < repeat_stk + n; pp += 2) {
2560 pp[0] = INVALID_STACK_INDEX;
2561 pp[1] = INVALID_STACK_INDEX;
2564#ifndef USE_SUBEXP_CALL
2571#ifdef ONIG_DEBUG_MATCH
2572 fprintf(stderr,
"match_at: str: %"PRIuPTR
" (%p), end: %"PRIuPTR
" (%p), start: %"PRIuPTR
" (%p), sprev: %"PRIuPTR
" (%p)\n",
2573 (uintptr_t )str, str, (uintptr_t )end, end, (uintptr_t )sstart, sstart, (uintptr_t )sprev, sprev);
2574 fprintf(stderr,
"size: %d, start offset: %d\n",
2575 (
int )(end - str), (
int )(sstart - str));
2576 fprintf(stderr,
"\n ofs> str stk:type addr:opcode\n");
2579 STACK_PUSH_ENSURED(STK_ALT, (UChar* )FinishCode);
2580 best_len = ONIG_MISMATCH;
2581 s = (UChar* )sstart;
2582 pkeep = (UChar* )sstart;
2585#ifdef ONIG_DEBUG_MATCH
2586# define OPCODE_EXEC_HOOK \
2588 UChar *op, *q, *bp, buf[50]; \
2590 op = p - OP_OFFSET; \
2591 fprintf(stderr, "%4"PRIdPTR"> \"", (*op == OP_FINISH) ? (ptrdiff_t )-1 : s - str); \
2594 if (*op != OP_FINISH) { \
2595 for (i = 0; i < 7 && q < end; i++) { \
2596 len = enclen(encode, q, end); \
2597 while (len-- > 0) *bp++ = *q++; \
2599 if (q < end) { xmemcpy(bp, "...", 3); bp += 3; } \
2601 xmemcpy(bp, "\"", 1); bp += 1; \
2603 fputs((char* )buf, stderr); \
2604 for (i = 0; i < 20 - (bp - buf); i++) fputc(' ', stderr); \
2605 fprintf(stderr, "%4"PRIdPTR":%s %4"PRIdPTR":", \
2606 stk - stk_base - 1, \
2607 (stk > stk_base) ? stack_type_str(stk[-1].type) : " ", \
2608 (op == FinishCode) ? (ptrdiff_t )-1 : op - reg->p); \
2609 onig_print_compiled_byte_code(stderr, op, reg->p+reg->used, NULL, encode); \
2610 fprintf(stderr, "\n"); \
2613# define OPCODE_EXEC_HOOK ((void) 0)
2616#ifdef USE_MATCH_CACHE
2617#ifdef ONIG_DEBUG_MATCH_CACHE
2618#define MATCH_CACHE_DEBUG fprintf(stderr, "MATCH CACHE: cache %ld (p=%p index=%ld mask=%d)\n", match_cache_point, pbegin, match_cache_point_index, match_cache_point_mask)
2619#define MATCH_CACHE_DEBUG_HIT fprintf(stderr, "MATCH CACHE: cache hit\n")
2621#define MATCH_CACHE_DEBUG ((void) 0)
2622#define MATCH_CACHE_DEBUG_HIT ((void) 0)
2625#define MATCH_CACHE_HIT ((void) 0)
2627# define CHECK_MATCH_CACHE do {\
2628 if (msa->match_cache_status == MATCH_CACHE_STATUS_ENABLED) {\
2629 const OnigCacheOpcode *cache_opcode;\
2630 long cache_point = find_cache_point(reg, msa->cache_opcodes, msa->num_cache_opcodes, pbegin, stk_base, repeat_stk, &cache_opcode);\
2631 if (cache_point >= 0) {\
2632 long match_cache_point = msa->num_cache_points * (long)(s - str) + cache_point;\
2633 long match_cache_point_index = match_cache_point >> 3;\
2634 uint8_t match_cache_point_mask = 1 << (match_cache_point & 7);\
2636 if (msa->match_cache_buf[match_cache_point_index] & match_cache_point_mask) {\
2637 MATCH_CACHE_DEBUG_HIT; MATCH_CACHE_HIT;\
2638 if (cache_opcode->lookaround_nesting == 0) goto fail;\
2639 else if (cache_opcode->lookaround_nesting < 0) {\
2640 if (check_extended_match_cache_point(msa->match_cache_buf, match_cache_point_index, match_cache_point_mask)) {\
2641 STACK_STOP_BT_FAIL;\
2647 if (check_extended_match_cache_point(msa->match_cache_buf, match_cache_point_index, match_cache_point_mask)) {\
2648 p = cache_opcode->match_addr;\
2655 STACK_PUSH_MATCH_CACHE_POINT(match_cache_point_index, match_cache_point_mask);\
2660# define CHECK_MATCH_CACHE ((void) 0)
2664 CASE(OP_END) MOP_IN(OP_END);
2668#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
2669 if (IS_FIND_LONGEST(option)) {
2670 if (n > msa->best_len) {
2672 msa->best_s = (UChar* )sstart;
2679 region = msa->region;
2681 region->beg[0] = ((pkeep > s) ? s : pkeep) - str;
2682 region->end[0] = s - str;
2683 for (i = 1; i <= num_mem; i++) {
2684 if (mem_end_stk[i] != INVALID_STACK_INDEX) {
2685 if (BIT_STATUS_AT(reg->bt_mem_start, i))
2686 region->beg[i] = STACK_AT(mem_start_stk[i])->u.mem.pstr - str;
2688 region->beg[i] = (UChar* )((
void* )mem_start_stk[i]) - str;
2690 region->end[i] = (BIT_STATUS_AT(reg->bt_mem_end, i)
2691 ? STACK_AT(mem_end_stk[i])->u.mem.pstr
2692 : (UChar* )((
void* )mem_end_stk[i])) - str;
2695 region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
2699#ifdef USE_CAPTURE_HISTORY
2700 if (reg->capture_history != 0) {
2702 OnigCaptureTreeNode* node;
2704 if (IS_NULL(region->history_root)) {
2705 region->history_root = node = history_node_new();
2706 CHECK_NULL_RETURN_MEMERR(node);
2709 node = region->history_root;
2710 history_tree_clear(node);
2714 node->beg = ((pkeep > s) ? s : pkeep) - str;
2715 node->end = s - str;
2718 r = make_capture_history_tree(region->history_root, &stkp,
2719 stk, (UChar* )str, reg);
2729#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
2734 if (IS_FIND_CONDITION(option)) {
2735 if (IS_FIND_NOT_EMPTY(option) && s == sstart) {
2736 best_len = ONIG_MISMATCH;
2739 if (IS_FIND_LONGEST(option) && DATA_ENSURE_CHECK1) {
2747 CASE(OP_EXACT1) MOP_IN(OP_EXACT1);
2749 if (*p != *s)
goto fail;
2754 CASE(OP_EXACT1_IC) MOP_IN(OP_EXACT1_IC);
2757 UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
2760 len = ONIGENC_MBC_CASE_FOLD(encode,
2765 if (
len != enclen(encode, p, reg->p + reg->used))
goto fail;
2777 CASE(OP_EXACT2) MOP_IN(OP_EXACT2);
2779 if (*p != *s)
goto fail;
2781 if (*p != *s)
goto fail;
2787 CASE(OP_EXACT3) MOP_IN(OP_EXACT3);
2789 if (*p != *s)
goto fail;
2791 if (*p != *s)
goto fail;
2793 if (*p != *s)
goto fail;
2799 CASE(OP_EXACT4) MOP_IN(OP_EXACT4);
2801 if (*p != *s)
goto fail;
2803 if (*p != *s)
goto fail;
2805 if (*p != *s)
goto fail;
2807 if (*p != *s)
goto fail;
2813 CASE(OP_EXACT5) MOP_IN(OP_EXACT5);
2815 if (*p != *s)
goto fail;
2817 if (*p != *s)
goto fail;
2819 if (*p != *s)
goto fail;
2821 if (*p != *s)
goto fail;
2823 if (*p != *s)
goto fail;
2829 CASE(OP_EXACTN) MOP_IN(OP_EXACTN);
2830 GET_LENGTH_INC(tlen, p);
2832 while (tlen-- > 0) {
2833 if (*p++ != *s++)
goto fail;
2839 CASE(OP_EXACTN_IC) MOP_IN(OP_EXACTN_IC);
2842 UChar *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
2844 GET_LENGTH_INC(tlen, p);
2850 len = ONIGENC_MBC_CASE_FOLD(encode,
2855 if (
len > endp - p)
goto fail;
2858 if (*p != *q)
goto fail;
2867 CASE(OP_EXACTMB2N1) MOP_IN(OP_EXACTMB2N1);
2869 if (*p != *s)
goto fail;
2871 if (*p != *s)
goto fail;
2876 CASE(OP_EXACTMB2N2) MOP_IN(OP_EXACTMB2N2);
2878 if (*p != *s)
goto fail;
2880 if (*p != *s)
goto fail;
2883 if (*p != *s)
goto fail;
2885 if (*p != *s)
goto fail;
2890 CASE(OP_EXACTMB2N3) MOP_IN(OP_EXACTMB2N3);
2892 if (*p != *s)
goto fail;
2894 if (*p != *s)
goto fail;
2896 if (*p != *s)
goto fail;
2898 if (*p != *s)
goto fail;
2901 if (*p != *s)
goto fail;
2903 if (*p != *s)
goto fail;
2908 CASE(OP_EXACTMB2N) MOP_IN(OP_EXACTMB2N);
2909 GET_LENGTH_INC(tlen, p);
2910 DATA_ENSURE(tlen * 2);
2911 while (tlen-- > 0) {
2912 if (*p != *s)
goto fail;
2914 if (*p != *s)
goto fail;
2921 CASE(OP_EXACTMB3N) MOP_IN(OP_EXACTMB3N);
2922 GET_LENGTH_INC(tlen, p);
2923 DATA_ENSURE(tlen * 3);
2924 while (tlen-- > 0) {
2925 if (*p != *s)
goto fail;
2927 if (*p != *s)
goto fail;
2929 if (*p != *s)
goto fail;
2936 CASE(OP_EXACTMBN) MOP_IN(OP_EXACTMBN);
2937 GET_LENGTH_INC(tlen, p);
2938 GET_LENGTH_INC(tlen2, p);
2941 while (tlen2-- > 0) {
2942 if (*p != *s)
goto fail;
2949 CASE(OP_CCLASS) MOP_IN(OP_CCLASS);
2951 if (BITSET_AT(((BitSetRef )p), *s) == 0)
goto fail;
2953 s += enclen(encode, s, end);
2957 CASE(OP_CCLASS_MB) MOP_IN(OP_CCLASS_MB);
2958 if (! ONIGENC_IS_MBC_HEAD(encode, s, end))
goto fail;
2961 GET_LENGTH_INC(tlen, p);
2968 mb_len = enclen_approx(encode, s, end);
2969 DATA_ENSURE(mb_len);
2972 code = ONIGENC_MBC_TO_CODE(encode, ss, s);
2974#ifdef PLATFORM_UNALIGNED_WORD_ACCESS
2975 if (! onig_is_in_code_range(p, code))
goto fail;
2979 if (! onig_is_in_code_range(q, code))
goto fail;
2986 CASE(OP_CCLASS_MIX) MOP_IN(OP_CCLASS_MIX);
2988 if (ONIGENC_IS_MBC_HEAD(encode, s, end)) {
2993 if (BITSET_AT(((BitSetRef )p), *s) == 0)
2997 GET_LENGTH_INC(tlen, p);
3004 CASE(OP_CCLASS_NOT) MOP_IN(OP_CCLASS_NOT);
3006 if (BITSET_AT(((BitSetRef )p), *s) != 0)
goto fail;
3008 s += enclen(encode, s, end);
3012 CASE(OP_CCLASS_MB_NOT) MOP_IN(OP_CCLASS_MB_NOT);
3014 if (! ONIGENC_IS_MBC_HEAD(encode, s, end)) {
3016 GET_LENGTH_INC(tlen, p);
3018 goto cc_mb_not_success;
3022 GET_LENGTH_INC(tlen, p);
3026 int mb_len = enclen(encode, s, end);
3028 if (! DATA_ENSURE_CHECK(mb_len)) {
3032 goto cc_mb_not_success;
3037 code = ONIGENC_MBC_TO_CODE(encode, ss, s);
3039#ifdef PLATFORM_UNALIGNED_WORD_ACCESS
3040 if (onig_is_in_code_range(p, code))
goto fail;
3044 if (onig_is_in_code_range(q, code))
goto fail;
3053 CASE(OP_CCLASS_MIX_NOT) MOP_IN(OP_CCLASS_MIX_NOT);
3055 if (ONIGENC_IS_MBC_HEAD(encode, s, end)) {
3060 if (BITSET_AT(((BitSetRef )p), *s) != 0)
3064 GET_LENGTH_INC(tlen, p);
3071 CASE(OP_ANYCHAR) MOP_IN(OP_ANYCHAR);
3073 n = enclen_approx(encode, s, end);
3075 if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))
goto fail;
3080 CASE(OP_ANYCHAR_ML) MOP_IN(OP_ANYCHAR_ML);
3082 n = enclen_approx(encode, s, end);
3088 CASE(OP_ANYCHAR_STAR) MOP_IN(OP_ANYCHAR_STAR);
3089 while (DATA_ENSURE_CHECK1) {
3091 STACK_PUSH_ALT(p, s, sprev, pkeep);
3092 n = enclen_approx(encode, s, end);
3094 if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))
goto fail;
3101 CASE(OP_ANYCHAR_ML_STAR) MOP_IN(OP_ANYCHAR_ML_STAR);
3102 while (DATA_ENSURE_CHECK1) {
3104 STACK_PUSH_ALT(p, s, sprev, pkeep);
3105 n = enclen_approx(encode, s, end);
3119 CASE(OP_ANYCHAR_STAR_PEEK_NEXT) MOP_IN(OP_ANYCHAR_STAR_PEEK_NEXT);
3120 while (DATA_ENSURE_CHECK1) {
3123 STACK_PUSH_ALT(p + 1, s, sprev, pkeep);
3125#ifdef USE_MATCH_CACHE
3131 n = enclen_approx(encode, s, end);
3133 if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))
goto fail;
3141 CASE(OP_ANYCHAR_ML_STAR_PEEK_NEXT)MOP_IN(OP_ANYCHAR_ML_STAR_PEEK_NEXT);
3142 while (DATA_ENSURE_CHECK1) {
3145 STACK_PUSH_ALT(p + 1, s, sprev, pkeep);
3147#ifdef USE_MATCH_CACHE
3153 n = enclen_approx(encode, s, end);
3168#ifdef USE_COMBINATION_EXPLOSION_CHECK
3169 CASE(OP_STATE_CHECK_ANYCHAR_STAR) MOP_IN(OP_STATE_CHECK_ANYCHAR_STAR);
3170 GET_STATE_CHECK_NUM_INC(mem, p);
3171 while (DATA_ENSURE_CHECK1) {
3172 STATE_CHECK_VAL(scv, mem);
3175 STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep);
3176 n = enclen_approx(encode, s, end);
3178 if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 0))
goto fail;
3185 CASE(OP_STATE_CHECK_ANYCHAR_ML_STAR)
3186 MOP_IN(OP_STATE_CHECK_ANYCHAR_ML_STAR);
3188 GET_STATE_CHECK_NUM_INC(mem, p);
3189 while (DATA_ENSURE_CHECK1) {
3190 STATE_CHECK_VAL(scv, mem);
3193 STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep);
3194 n = enclen_approx(encode, s, end);
3209 CASE(OP_WORD) MOP_IN(OP_WORD);
3211 if (! ONIGENC_IS_MBC_WORD(encode, s, end))
3214 s += enclen(encode, s, end);
3218 CASE(OP_ASCII_WORD) MOP_IN(OP_ASCII_WORD);
3220 if (! ONIGENC_IS_MBC_ASCII_WORD(encode, s, end))
3223 s += enclen(encode, s, end);
3227 CASE(OP_NOT_WORD) MOP_IN(OP_NOT_WORD);
3229 if (ONIGENC_IS_MBC_WORD(encode, s, end))
3232 s += enclen(encode, s, end);
3236 CASE(OP_NOT_ASCII_WORD) MOP_IN(OP_NOT_ASCII_WORD);
3238 if (ONIGENC_IS_MBC_ASCII_WORD(encode, s, end))
3241 s += enclen(encode, s, end);
3245 CASE(OP_WORD_BOUND) MOP_IN(OP_WORD_BOUND);
3246 if (ON_STR_BEGIN(s)) {
3248 if (! ONIGENC_IS_MBC_WORD(encode, s, end))
3251 else if (ON_STR_END(s)) {
3252 if (! ONIGENC_IS_MBC_WORD(encode, sprev, end))
3256 if (ONIGENC_IS_MBC_WORD(encode, s, end)
3257 == ONIGENC_IS_MBC_WORD(encode, sprev, end))
3263 CASE(OP_ASCII_WORD_BOUND) MOP_IN(OP_ASCII_WORD_BOUND);
3264 if (ON_STR_BEGIN(s)) {
3266 if (! ONIGENC_IS_MBC_ASCII_WORD(encode, s, end))
3269 else if (ON_STR_END(s)) {
3270 if (! ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end))
3274 if (ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)
3275 == ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end))
3281 CASE(OP_NOT_WORD_BOUND) MOP_IN(OP_NOT_WORD_BOUND);
3282 if (ON_STR_BEGIN(s)) {
3283 if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end))
3286 else if (ON_STR_END(s)) {
3287 if (ONIGENC_IS_MBC_WORD(encode, sprev, end))
3291 if (ONIGENC_IS_MBC_WORD(encode, s, end)
3292 != ONIGENC_IS_MBC_WORD(encode, sprev, end))
3298 CASE(OP_NOT_ASCII_WORD_BOUND) MOP_IN(OP_NOT_ASCII_WORD_BOUND);
3299 if (ON_STR_BEGIN(s)) {
3300 if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_ASCII_WORD(encode, s, end))
3303 else if (ON_STR_END(s)) {
3304 if (ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end))
3308 if (ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)
3309 != ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end))
3315#ifdef USE_WORD_BEGIN_END
3316 CASE(OP_WORD_BEGIN) MOP_IN(OP_WORD_BEGIN);
3317 if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_WORD(encode, s, end)) {
3318 if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
3325 CASE(OP_ASCII_WORD_BEGIN) MOP_IN(OP_ASCII_WORD_BEGIN);
3326 if (DATA_ENSURE_CHECK1 && ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) {
3327 if (ON_STR_BEGIN(s) || !ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) {
3334 CASE(OP_WORD_END) MOP_IN(OP_WORD_END);
3335 if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_WORD(encode, sprev, end)) {
3336 if (ON_STR_END(s) || !ONIGENC_IS_MBC_WORD(encode, s, end)) {
3343 CASE(OP_ASCII_WORD_END) MOP_IN(OP_ASCII_WORD_END);
3344 if (!ON_STR_BEGIN(s) && ONIGENC_IS_MBC_ASCII_WORD(encode, sprev, end)) {
3345 if (ON_STR_END(s) || !ONIGENC_IS_MBC_ASCII_WORD(encode, s, end)) {
3353 CASE(OP_BEGIN_BUF) MOP_IN(OP_BEGIN_BUF);
3354 if (! ON_STR_BEGIN(s))
goto fail;
3355 if (IS_NOTBOS(msa->options))
goto fail;
3360 CASE(OP_END_BUF) MOP_IN(OP_END_BUF);
3361 if (! ON_STR_END(s))
goto fail;
3362 if (IS_NOTEOS(msa->options))
goto fail;
3367 CASE(OP_BEGIN_LINE) MOP_IN(OP_BEGIN_LINE);
3368 if (ON_STR_BEGIN(s)) {
3369 if (IS_NOTBOL(msa->options))
goto fail;
3373 else if (ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)
3374#ifdef USE_CRNL_AS_LINE_TERMINATOR
3375 && !(IS_NEWLINE_CRLF(option)
3376 && ONIGENC_IS_MBC_CRNL(encode, sprev, end))
3378 && !ON_STR_END(s)) {
3384 CASE(OP_END_LINE) MOP_IN(OP_END_LINE);
3385 if (ON_STR_END(s)) {
3386#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3387 if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE_EX(encode, sprev, str, end, option, 1)) {
3389 if (IS_NOTEOL(msa->options))
goto fail;
3392#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3396 else if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 1)) {
3402 CASE(OP_SEMI_END_BUF) MOP_IN(OP_SEMI_END_BUF);
3403 if (ON_STR_END(s)) {
3404#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3405 if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE_EX(encode, sprev, str, end, option, 1)) {
3407 if (IS_NOTEOL(msa->options))
goto fail;
3410#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3414 else if (ONIGENC_IS_MBC_NEWLINE_EX(encode, s, str, end, option, 1)) {
3415 UChar* ss = s + enclen(encode, s, end);
3416 if (ON_STR_END(ss)) {
3420#ifdef USE_CRNL_AS_LINE_TERMINATOR
3421 else if (IS_NEWLINE_CRLF(option)
3422 && ONIGENC_IS_MBC_CRNL(encode, s, end)) {
3423 ss += enclen(encode, ss, end);
3424 if (ON_STR_END(ss)) {
3433 CASE(OP_BEGIN_POSITION) MOP_IN(OP_BEGIN_POSITION);
3440 CASE(OP_MEMORY_START_PUSH) MOP_IN(OP_MEMORY_START_PUSH);
3441 GET_MEMNUM_INC(mem, p);
3442 STACK_PUSH_MEM_START(mem, s);
3446 CASE(OP_MEMORY_START) MOP_IN(OP_MEMORY_START);
3447 GET_MEMNUM_INC(mem, p);
3448 mem_start_stk[mem] = (OnigStackIndex )((
void* )s);
3449 mem_end_stk[mem] = INVALID_STACK_INDEX;
3453 CASE(OP_MEMORY_END_PUSH) MOP_IN(OP_MEMORY_END_PUSH);
3454 GET_MEMNUM_INC(mem, p);
3455 STACK_PUSH_MEM_END(mem, s);
3459 CASE(OP_MEMORY_END) MOP_IN(OP_MEMORY_END);
3460 GET_MEMNUM_INC(mem, p);
3461 mem_end_stk[mem] = (OnigStackIndex )((
void* )s);
3465 CASE(OP_KEEP) MOP_IN(OP_KEEP);
3470#ifdef USE_SUBEXP_CALL
3471 CASE(OP_MEMORY_END_PUSH_REC) MOP_IN(OP_MEMORY_END_PUSH_REC);
3472 GET_MEMNUM_INC(mem, p);
3473 STACK_GET_MEM_START(mem, stkp);
3474 mem_start_stk[mem] = GET_STACK_INDEX(stkp);
3475 STACK_PUSH_MEM_END(mem, s);
3479 CASE(OP_MEMORY_END_REC) MOP_IN(OP_MEMORY_END_REC);
3480 GET_MEMNUM_INC(mem, p);
3481 mem_end_stk[mem] = (OnigStackIndex )((
void* )s);
3482 STACK_GET_MEM_START(mem, stkp);
3484 if (BIT_STATUS_AT(reg->bt_mem_start, mem))
3485 mem_start_stk[mem] = GET_STACK_INDEX(stkp);
3487 mem_start_stk[mem] = (OnigStackIndex )((
void* )stkp->u.mem.pstr);
3489 STACK_PUSH_MEM_END_MARK(mem);
3494 CASE(OP_BACKREF1) MOP_IN(OP_BACKREF1);
3498 CASE(OP_BACKREF2) MOP_IN(OP_BACKREF2);
3502 CASE(OP_BACKREFN) MOP_IN(OP_BACKREFN);
3503 GET_MEMNUM_INC(mem, p);
3507 UChar *pstart, *pend;
3511 if (mem > num_mem)
goto fail;
3512 if (mem_end_stk[mem] == INVALID_STACK_INDEX)
goto fail;
3513 if (mem_start_stk[mem] == INVALID_STACK_INDEX)
goto fail;
3515 if (BIT_STATUS_AT(reg->bt_mem_start, mem))
3516 pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
3518 pstart = (UChar* )((
void* )mem_start_stk[mem]);
3520 pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
3521 ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
3522 : (UChar* )((
void* )mem_end_stk[mem]));
3526 STRING_CMP(pstart, s, n);
3527 while (sprev + (
len = enclen_approx(encode, sprev, end)) < s)
3534 CASE(OP_BACKREFN_IC) MOP_IN(OP_BACKREFN_IC);
3535 GET_MEMNUM_INC(mem, p);
3538 UChar *pstart, *pend;
3542 if (mem > num_mem)
goto fail;
3543 if (mem_end_stk[mem] == INVALID_STACK_INDEX)
goto fail;
3544 if (mem_start_stk[mem] == INVALID_STACK_INDEX)
goto fail;
3546 if (BIT_STATUS_AT(reg->bt_mem_start, mem))
3547 pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
3549 pstart = (UChar* )((
void* )mem_start_stk[mem]);
3551 pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
3552 ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
3553 : (UChar* )((
void* )mem_end_stk[mem]));
3557 STRING_CMP_IC(case_fold_flag, pstart, &s, n, end);
3558 while (sprev + (
len = enclen_approx(encode, sprev, end)) < s)
3566 CASE(OP_BACKREF_MULTI) MOP_IN(OP_BACKREF_MULTI);
3569 UChar *pstart, *pend, *swork;
3571 GET_LENGTH_INC(tlen, p);
3572 for (i = 0; i < tlen; i++) {
3573 GET_MEMNUM_INC(mem, p);
3575 if (mem_end_stk[mem] == INVALID_STACK_INDEX)
continue;
3576 if (mem_start_stk[mem] == INVALID_STACK_INDEX)
continue;
3578 if (BIT_STATUS_AT(reg->bt_mem_start, mem))
3579 pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
3581 pstart = (UChar* )((
void* )mem_start_stk[mem]);
3583 pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
3584 ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
3585 : (UChar* )((
void* )mem_end_stk[mem]));
3587 DATA_ENSURE_CONTINUE(n);
3590 STRING_CMP_VALUE(pstart, swork, n, is_fail);
3591 if (is_fail)
continue;
3593 while (sprev + (
len = enclen_approx(encode, sprev, end)) < s)
3596 p += (SIZE_MEMNUM * (tlen - i - 1));
3599 if (i == tlen)
goto fail;
3605 CASE(OP_BACKREF_MULTI_IC) MOP_IN(OP_BACKREF_MULTI_IC);
3608 UChar *pstart, *pend, *swork;
3610 GET_LENGTH_INC(tlen, p);
3611 for (i = 0; i < tlen; i++) {
3612 GET_MEMNUM_INC(mem, p);
3614 if (mem_end_stk[mem] == INVALID_STACK_INDEX)
continue;
3615 if (mem_start_stk[mem] == INVALID_STACK_INDEX)
continue;
3617 if (BIT_STATUS_AT(reg->bt_mem_start, mem))
3618 pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;
3620 pstart = (UChar* )((
void* )mem_start_stk[mem]);
3622 pend = (BIT_STATUS_AT(reg->bt_mem_end, mem)
3623 ? STACK_AT(mem_end_stk[mem])->u.mem.pstr
3624 : (UChar* )((
void* )mem_end_stk[mem]));
3626 DATA_ENSURE_CONTINUE(n);
3629 STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, end, is_fail);
3630 if (is_fail)
continue;
3632 while (sprev + (
len = enclen(encode, sprev, end)) < s)
3635 p += (SIZE_MEMNUM * (tlen - i - 1));
3638 if (i == tlen)
goto fail;
3643#ifdef USE_BACKREF_WITH_LEVEL
3644 CASE(OP_BACKREF_WITH_LEVEL)
3650 GET_OPTION_INC(ic, p);
3651 GET_LENGTH_INC(level, p);
3652 GET_LENGTH_INC(tlen, p);
3655 if (backref_match_at_nested_level(reg, stk, stk_base, ic,
3656 case_fold_flag, (
int )level, (
int )tlen, p, &s, end)) {
3657 while (sprev + (
len = enclen(encode, sprev, end)) < s)
3660 p += (SIZE_MEMNUM * tlen);
3672 CASE(OP_SET_OPTION_PUSH) MOP_IN(OP_SET_OPTION_PUSH);
3673 GET_OPTION_INC(option, p);
3674 STACK_PUSH_ALT(p, s, sprev, pkeep);
3675 p += SIZE_OP_SET_OPTION + SIZE_OP_FAIL;
3679 CASE(OP_SET_OPTION) MOP_IN(OP_SET_OPTION);
3680 GET_OPTION_INC(option, p);
3685 CASE(OP_NULL_CHECK_START) MOP_IN(OP_NULL_CHECK_START);
3686 GET_MEMNUM_INC(mem, p);
3687 STACK_PUSH_NULL_CHECK_START(mem, s);
3691 CASE(OP_NULL_CHECK_END) MOP_IN(OP_NULL_CHECK_END);
3695 GET_MEMNUM_INC(mem, p);
3696 STACK_NULL_CHECK(isnull, mem, s);
3698#ifdef ONIG_DEBUG_MATCH
3699 fprintf(stderr,
"NULL_CHECK_END: skip id:%d, s:%"PRIuPTR
" (%p)\n",
3700 (
int )mem, (uintptr_t )s, s);
3710 case OP_REPEAT_INC_NG:
3711 case OP_REPEAT_INC_SG:
3712 case OP_REPEAT_INC_NG_SG:
3716 goto unexpected_bytecode_error;
3724#ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
3725 CASE(OP_NULL_CHECK_END_MEMST) MOP_IN(OP_NULL_CHECK_END_MEMST);
3729 GET_MEMNUM_INC(mem, p);
3730 STACK_NULL_CHECK_MEMST(isnull, mem, s, reg);
3732# ifdef ONIG_DEBUG_MATCH
3733 fprintf(stderr,
"NULL_CHECK_END_MEMST: skip id:%d, s:%"PRIuPTR
" (%p)\n",
3734 (
int )mem, (uintptr_t )s, s);
3736 if (isnull == -1)
goto fail;
3737 goto null_check_found;
3744#ifdef USE_SUBEXP_CALL
3745 CASE(OP_NULL_CHECK_END_MEMST_PUSH)
3746 MOP_IN(OP_NULL_CHECK_END_MEMST_PUSH);
3750 GET_MEMNUM_INC(mem, p);
3751# ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
3752 STACK_NULL_CHECK_MEMST_REC(isnull, mem, s, reg);
3754 STACK_NULL_CHECK_REC(isnull, mem, s);
3757# ifdef ONIG_DEBUG_MATCH
3758 fprintf(stderr,
"NULL_CHECK_END_MEMST_PUSH: skip id:%d, s:%"PRIuPTR
" (%p)\n",
3759 (
int )mem, (uintptr_t )s, s);
3761 if (isnull == -1)
goto fail;
3762 goto null_check_found;
3765 STACK_PUSH_NULL_CHECK_END(mem);
3772 CASE(OP_JUMP) MOP_IN(OP_JUMP);
3773 GET_RELADDR_INC(addr, p);
3776 CHECK_INTERRUPT_IN_MATCH_AT;
3779 CASE(OP_PUSH) MOP_IN(OP_PUSH);
3780 GET_RELADDR_INC(addr, p);
3782 STACK_PUSH_ALT(p + addr, s, sprev, pkeep);
3786#ifdef USE_COMBINATION_EXPLOSION_CHECK
3787 CASE(OP_STATE_CHECK_PUSH) MOP_IN(OP_STATE_CHECK_PUSH);
3788 GET_STATE_CHECK_NUM_INC(mem, p);
3789 STATE_CHECK_VAL(scv, mem);
3792 GET_RELADDR_INC(addr, p);
3793 STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem, pkeep);
3797 CASE(OP_STATE_CHECK_PUSH_OR_JUMP) MOP_IN(OP_STATE_CHECK_PUSH_OR_JUMP);
3798 GET_STATE_CHECK_NUM_INC(mem, p);
3799 GET_RELADDR_INC(addr, p);
3800 STATE_CHECK_VAL(scv, mem);
3805 STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem, pkeep);
3810 CASE(OP_STATE_CHECK) MOP_IN(OP_STATE_CHECK);
3811 GET_STATE_CHECK_NUM_INC(mem, p);
3812 STATE_CHECK_VAL(scv, mem);
3815 STACK_PUSH_STATE_CHECK(s, mem);
3820 CASE(OP_POP) MOP_IN(OP_POP);
3822#ifdef USE_MATCH_CACHE
3830#ifdef USE_OP_PUSH_OR_JUMP_EXACT
3831 CASE(OP_PUSH_OR_JUMP_EXACT1) MOP_IN(OP_PUSH_OR_JUMP_EXACT1);
3832 GET_RELADDR_INC(addr, p);
3833 if (*p == *s && DATA_ENSURE_CHECK1) {
3836 STACK_PUSH_ALT(p + addr, s, sprev, pkeep);
3845 CASE(OP_PUSH_IF_PEEK_NEXT) MOP_IN(OP_PUSH_IF_PEEK_NEXT);
3846 GET_RELADDR_INC(addr, p);
3850 STACK_PUSH_ALT(p + addr, s, sprev, pkeep);
3859 CASE(OP_REPEAT) MOP_IN(OP_REPEAT);
3861 GET_MEMNUM_INC(mem, p);
3862 GET_RELADDR_INC(addr, p);
3865 repeat_stk[mem] = GET_STACK_INDEX(stk);
3866 STACK_PUSH_REPEAT(mem, p);
3868 if (reg->repeat_range[mem].lower == 0) {
3870 STACK_PUSH_ALT(p + addr, s, sprev, pkeep);
3876 CASE(OP_REPEAT_NG) MOP_IN(OP_REPEAT_NG);
3878 GET_MEMNUM_INC(mem, p);
3879 GET_RELADDR_INC(addr, p);
3882 repeat_stk[mem] = GET_STACK_INDEX(stk);
3883 STACK_PUSH_REPEAT(mem, p);
3885 if (reg->repeat_range[mem].lower == 0) {
3887 STACK_PUSH_ALT(p, s, sprev, pkeep);
3894 CASE(OP_REPEAT_INC) MOP_IN(OP_REPEAT_INC);
3895 GET_MEMNUM_INC(mem, p);
3896 si = repeat_stk[mem];
3897 stkp = STACK_AT(si);
3900 stkp->u.repeat.count++;
3901 if (stkp->u.repeat.count >= reg->repeat_range[mem].upper) {
3904 else if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
3905#ifdef USE_MATCH_CACHE
3906 if (*pbegin == OP_REPEAT_INC) {
3907#undef MATCH_CACHE_HIT
3908#define MATCH_CACHE_HIT stkp->u.repeat.count--;
3910#undef MATCH_CACHE_HIT
3911#define MATCH_CACHE_HIT ((void) 0)
3914 STACK_PUSH_ALT(p, s, sprev, pkeep);
3915 p = STACK_AT(si)->u.repeat.pcode;
3918 p = stkp->u.repeat.pcode;
3920 STACK_PUSH_REPEAT_INC(si);
3922 CHECK_INTERRUPT_IN_MATCH_AT;
3925 CASE(OP_REPEAT_INC_SG) MOP_IN(OP_REPEAT_INC_SG);
3926 GET_MEMNUM_INC(mem, p);
3927 STACK_GET_REPEAT(mem, stkp);
3928 si = GET_STACK_INDEX(stkp);
3931 CASE(OP_REPEAT_INC_NG) MOP_IN(OP_REPEAT_INC_NG);
3932 GET_MEMNUM_INC(mem, p);
3933 si = repeat_stk[mem];
3934 stkp = STACK_AT(si);
3937 stkp->u.repeat.count++;
3938 if (stkp->u.repeat.count < reg->repeat_range[mem].upper) {
3939 if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {
3940 UChar* pcode = stkp->u.repeat.pcode;
3942 STACK_PUSH_REPEAT_INC(si);
3943 if (*pbegin == OP_REPEAT_INC_NG) {
3946 STACK_PUSH_ALT(pcode, s, sprev, pkeep);
3949 p = stkp->u.repeat.pcode;
3950 STACK_PUSH_REPEAT_INC(si);
3953 else if (stkp->u.repeat.count == reg->repeat_range[mem].upper) {
3954 STACK_PUSH_REPEAT_INC(si);
3957 CHECK_INTERRUPT_IN_MATCH_AT;
3960 CASE(OP_REPEAT_INC_NG_SG) MOP_IN(OP_REPEAT_INC_NG_SG);
3961 GET_MEMNUM_INC(mem, p);
3962 STACK_GET_REPEAT(mem, stkp);
3963 si = GET_STACK_INDEX(stkp);
3966 CASE(OP_PUSH_POS) MOP_IN(OP_PUSH_POS);
3967 STACK_PUSH_POS(s, sprev, pkeep);
3971 CASE(OP_POP_POS) MOP_IN(OP_POP_POS);
3973 STACK_POS_END(stkp);
3974 s = stkp->u.state.pstr;
3975 sprev = stkp->u.state.pstr_prev;
3980 CASE(OP_PUSH_POS_NOT) MOP_IN(OP_PUSH_POS_NOT);
3981 GET_RELADDR_INC(addr, p);
3982 STACK_PUSH_POS_NOT(p + addr, s, sprev, pkeep);
3986 CASE(OP_FAIL_POS) MOP_IN(OP_FAIL_POS);
3987 STACK_POP_TIL_POS_NOT;
3990 CASE(OP_PUSH_STOP_BT) MOP_IN(OP_PUSH_STOP_BT);
3995 CASE(OP_POP_STOP_BT) MOP_IN(OP_POP_STOP_BT);
4000 CASE(OP_LOOK_BEHIND) MOP_IN(OP_LOOK_BEHIND);
4001 GET_LENGTH_INC(tlen, p);
4002 s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (
int )tlen);
4003 if (IS_NULL(s))
goto fail;
4004 sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end);
4008 CASE(OP_PUSH_LOOK_BEHIND_NOT) MOP_IN(OP_PUSH_LOOK_BEHIND_NOT);
4009 GET_RELADDR_INC(addr, p);
4010 GET_LENGTH_INC(tlen, p);
4011 q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, end, (
int )tlen);
4019 STACK_PUSH_LOOK_BEHIND_NOT(p + addr, s, sprev, pkeep);
4021 sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s, end);
4026 CASE(OP_FAIL_LOOK_BEHIND_NOT) MOP_IN(OP_FAIL_LOOK_BEHIND_NOT);
4027 STACK_POP_TIL_LOOK_BEHIND_NOT;
4030 CASE(OP_PUSH_ABSENT_POS) MOP_IN(OP_PUSH_ABSENT_POS);
4032 STACK_PUSH_ABSENT_POS(s, ABSENT_END_POS);
4036 CASE(OP_ABSENT) MOP_IN(OP_ABSENT);
4038 const UChar* aend = ABSENT_END_POS;
4040 UChar* selfp = p - 1;
4042 STACK_POP_ABSENT_POS(absent, ABSENT_END_POS);
4043 GET_RELADDR_INC(addr, p);
4044#ifdef ONIG_DEBUG_MATCH
4045 fprintf(stderr,
"ABSENT: s:%p, end:%p, absent:%p, aend:%p\n", s, end, absent, aend);
4047 if ((absent > aend) && (s > absent)) {
4053 else if ((s >= aend) && (s > absent)) {
4063 else if (s == end) {
4069 STACK_PUSH_ALT(p + addr, s, sprev, pkeep);
4070 n = enclen(encode, s, end);
4071 STACK_PUSH_ABSENT_POS(absent, ABSENT_END_POS);
4072 STACK_PUSH_ALT(selfp, s + n, s, pkeep);
4074 ABSENT_END_POS = aend;
4080 CASE(OP_ABSENT_END) MOP_IN(OP_ABSENT_END);
4083 if (sprev < ABSENT_END_POS)
4084 ABSENT_END_POS = sprev;
4085#ifdef ONIG_DEBUG_MATCH
4086 fprintf(stderr,
"ABSENT_END: end:%p\n", ABSENT_END_POS);
4088 STACK_POP_TIL_ABSENT;
4091#ifdef USE_SUBEXP_CALL
4092 CASE(OP_CALL) MOP_IN(OP_CALL);
4093 GET_ABSADDR_INC(addr, p);
4094 STACK_PUSH_CALL_FRAME(p);
4099 CASE(OP_RETURN) MOP_IN(OP_RETURN);
4106 CASE(OP_CONDITION) MOP_IN(OP_CONDITION);
4107 GET_MEMNUM_INC(mem, p);
4108 GET_RELADDR_INC(addr, p);
4109 if ((mem > num_mem) ||
4110 (mem_end_stk[mem] == INVALID_STACK_INDEX) ||
4111 (mem_start_stk[mem] == INVALID_STACK_INDEX)) {
4128 p = stk->u.state.pcode;
4129 s = stk->u.state.pstr;
4130 sprev = stk->u.state.pstr_prev;
4131 pkeep = stk->u.state.pkeep;
4133#ifdef USE_MATCH_CACHE
4135 msa->match_cache_status != MATCH_CACHE_STATUS_DISABLED &&
4136 ++msa->num_fails >= (
long)(end - str) * msa->num_cache_opcodes
4138 if (msa->match_cache_status == MATCH_CACHE_STATUS_UNINIT) {
4139 msa->match_cache_status = MATCH_CACHE_STATUS_INIT;
4140 OnigPosition r = count_num_cache_opcodes(reg, &msa->num_cache_opcodes);
4141 if (r < 0)
goto bytecode_error;
4143 if (msa->num_cache_opcodes == NUM_CACHE_OPCODES_IMPOSSIBLE || msa->num_cache_opcodes == 0) {
4144 msa->match_cache_status = MATCH_CACHE_STATUS_DISABLED;
4145 goto fail_match_cache;
4147 if (msa->num_fails < (
long)(end - str) * msa->num_cache_opcodes) {
4148 goto fail_match_cache;
4150 if (msa->cache_opcodes == NULL) {
4151 msa->match_cache_status = MATCH_CACHE_STATUS_ENABLED;
4153 if (cache_opcodes == NULL) {
4156 OnigPosition r = init_cache_opcodes(reg, cache_opcodes, &msa->num_cache_points);
4158 if (r == ONIGERR_UNEXPECTED_BYTECODE)
goto unexpected_bytecode_error;
4159 else goto bytecode_error;
4161 msa->cache_opcodes = cache_opcodes;
4162#ifdef ONIG_DEBUG_MATCH_CACHE
4163 fprintf(stderr,
"MATCH CACHE: #cache opcodes = %ld\n", msa->num_cache_opcodes);
4164 fprintf(stderr,
"MATCH CACHE: #cache points = %ld\n", msa->num_cache_points);
4165 fprintf(stderr,
"MATCH CACHE: cache opcodes (%p):\n", msa->cache_opcodes);
4166 for (
int i = 0; i < msa->num_cache_opcodes; i++) {
4167 fprintf(stderr,
"MATCH CACHE: [%p] cache_point=%ld outer_repeat_mem=%d num_cache_opcodes_at_outer_repeat=%ld num_cache_opcodes_in_outer_repeat=%ld lookaround_nesting=%d match_addr=%p\n", msa->cache_opcodes[i].addr, msa->cache_opcodes[i].cache_point, msa->cache_opcodes[i].outer_repeat_mem, msa->cache_opcodes[i].num_cache_points_at_outer_repeat, msa->cache_opcodes[i].num_cache_points_in_outer_repeat, msa->cache_opcodes[i].lookaround_nesting, msa->cache_opcodes[i].match_addr);
4171 if (msa->match_cache_buf == NULL) {
4172 size_t length = (end - str) + 1;
4173 size_t num_match_cache_points = (size_t)msa->num_cache_points * length;
4174#ifdef ONIG_DEBUG_MATCH_CACHE
4175 fprintf(stderr,
"MATCH CACHE: #match cache points = %zu (length = %zu)\n", num_match_cache_points, length);
4178 if (num_match_cache_points / length != (
size_t)msa->num_cache_points) {
4181 if (num_match_cache_points >= LONG_MAX_LIMIT) {
4184 size_t match_cache_buf_length = (num_match_cache_points >> 3) + (num_match_cache_points & 7 ? 1 : 0) + 1;
4185 uint8_t* match_cache_buf = (uint8_t*)
xmalloc(match_cache_buf_length *
sizeof(uint8_t));
4186 if (match_cache_buf == NULL) {
4189 xmemset(match_cache_buf, 0, match_cache_buf_length *
sizeof(uint8_t));
4190 msa->match_cache_buf = match_cache_buf;
4196#ifdef USE_COMBINATION_EXPLOSION_CHECK
4197 if (stk->u.state.state_check != 0) {
4198 stk->type = STK_STATE_CHECK_MARK;
4204 CHECK_INTERRUPT_IN_MATCH_AT;
4208 goto bytecode_error;
4213 xfree(xmalloc_base);
4219 xfree(xmalloc_base);
4220 return ONIGERR_STACK_BUG;
4225 xfree(xmalloc_base);
4226 return ONIGERR_UNDEFINED_BYTECODE;
4228 unexpected_bytecode_error:
4230 xfree(xmalloc_base);
4231 return ONIGERR_UNEXPECTED_BYTECODE;
4235 xfree(xmalloc_base);
4236 return ONIGERR_TIMEOUT;
4238#ifdef USE_MATCH_CACHE
4241 xfree(xmalloc_base);
4242 return ONIGERR_MEMORY;
4248slow_search(OnigEncoding enc, UChar* target, UChar* target_end,
4249 const UChar* text,
const UChar* text_end, UChar* text_range)
4251 UChar *t, *p, *s, *end;
4253 end = (UChar* )text_end;
4254 end -= target_end - target - 1;
4255 if (end > text_range)
4260 if (enc->max_enc_len == enc->min_enc_len) {
4261 int n = enc->max_enc_len;
4264 if (*s == *target) {
4267 if (target_end == t || memcmp(t, p, target_end - t) == 0)
4272 return (UChar* )NULL;
4275 if (*s == *target) {
4278 if (target_end == t || memcmp(t, p, target_end - t) == 0)
4281 s += enclen(enc, s, text_end);
4284 return (UChar* )NULL;
4288str_lower_case_match(OnigEncoding enc,
int case_fold_flag,
4289 const UChar* t,
const UChar* tend,
4290 const UChar* p,
const UChar* end)
4293 UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];
4296 lowlen = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &p, end, lowbuf);
4297 if (tend - t < lowlen)
return 0;
4299 while (lowlen > 0) {
4300 if (*t++ != *q++)
return 0;
4309slow_search_ic(OnigEncoding enc,
int case_fold_flag,
4310 UChar* target, UChar* target_end,
4311 const UChar* text,
const UChar* text_end, UChar* text_range)
4315 end = (UChar* )text_end;
4316 end -= target_end - target - 1;
4317 if (end > text_range)
4323 if (str_lower_case_match(enc, case_fold_flag, target, target_end,
4327 s += enclen(enc, s, text_end);
4330 return (UChar* )NULL;
4334slow_search_backward(OnigEncoding enc, UChar* target, UChar* target_end,
4335 const UChar* text,
const UChar* adjust_text,
4336 const UChar* text_end,
const UChar* text_start)
4340 s = (UChar* )text_end;
4341 s -= (target_end - target);
4343 s = (UChar* )text_start;
4345 s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s, text_end);
4348 if (*s == *target) {
4351 while (t < target_end) {
4356 if (t == target_end)
4359 s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
4362 return (UChar* )NULL;
4366slow_search_backward_ic(OnigEncoding enc,
int case_fold_flag,
4367 UChar* target, UChar* target_end,
4368 const UChar* text,
const UChar* adjust_text,
4369 const UChar* text_end,
const UChar* text_start)
4373 s = (UChar* )text_end;
4374 s -= (target_end - target);
4376 s = (UChar* )text_start;
4378 s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s, text_end);
4381 if (str_lower_case_match(enc, case_fold_flag,
4382 target, target_end, s, text_end))
4385 s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
4388 return (UChar* )NULL;
4393bm_search_notrev(regex_t* reg,
const UChar* target,
const UChar* target_end,
4394 const UChar* text,
const UChar* text_end,
4395 const UChar* text_range)
4397 const UChar *s, *se, *t, *p, *end;
4399 ptrdiff_t skip, tlen1;
4400 OnigEncoding enc = reg->enc;
4402# ifdef ONIG_DEBUG_SEARCH
4403 fprintf(stderr,
"bm_search_notrev: text: %"PRIuPTR
" (%p), text_end: %"PRIuPTR
" (%p), text_range: %"PRIuPTR
" (%p)\n",
4404 (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
4407 tail = target_end - 1;
4408 tlen1 = tail - target;
4410 if (end + tlen1 > text_end)
4411 end = text_end - tlen1;
4415 if (IS_NULL(reg->int_map)) {
4420 if (t == target)
return (UChar* )s;
4423 if (s + 1 >= end)
break;
4424 skip = reg->map[se[1]];
4427 s += enclen(enc, s, end);
4428 }
while ((s - t) < skip && s < end);
4432# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
4437 if (t == target)
return (UChar* )s;
4440 if (s + 1 >= end)
break;
4441 skip = reg->int_map[se[1]];
4444 s += enclen(enc, s, end);
4445 }
while ((s - t) < skip && s < end);
4450 return (UChar* )NULL;
4455bm_search(regex_t* reg,
const UChar* target,
const UChar* target_end,
4456 const UChar* text,
const UChar* text_end,
const UChar* text_range)
4458 const UChar *s, *t, *p, *end;
4462# ifdef ONIG_DEBUG_SEARCH
4463 fprintf(stderr,
"bm_search: text: %"PRIuPTR
" (%p), text_end: %"PRIuPTR
" (%p), text_range: %"PRIuPTR
" (%p)\n",
4464 (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
4467 tail = target_end - 1;
4468 tlen1 = tail - target;
4469 end = text_range + tlen1;
4474 if (IS_NULL(reg->int_map)) {
4479 if (t == target)
return (UChar* )p;
4482 if (s + 1 >= end)
break;
4483 s += reg->map[s[1]];
4487# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
4492 if (t == target)
return (UChar* )p;
4495 if (s + 1 >= end)
break;
4496 s += reg->int_map[s[1]];
4500 return (UChar* )NULL;
4505bm_search_notrev_ic(regex_t* reg,
const UChar* target,
const UChar* target_end,
4506 const UChar* text,
const UChar* text_end,
4507 const UChar* text_range)
4509 const UChar *s, *se, *t, *end;
4511 ptrdiff_t skip, tlen1;
4512 OnigEncoding enc = reg->enc;
4513 int case_fold_flag = reg->case_fold_flag;
4515# ifdef ONIG_DEBUG_SEARCH
4516 fprintf(stderr,
"bm_search_notrev_ic: text: %"PRIuPTR
" (%p), text_end: %"PRIuPTR
" (%p), text_range: %"PRIuPTR
" (%p)\n",
4517 (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
4520 tail = target_end - 1;
4521 tlen1 = tail - target;
4523 if (end + tlen1 > text_end)
4524 end = text_end - tlen1;
4528 if (IS_NULL(reg->int_map)) {
4531 if (str_lower_case_match(enc, case_fold_flag, target, target_end,
4534 if (s + 1 >= end)
break;
4535 skip = reg->map[se[1]];
4538 s += enclen(enc, s, end);
4539 }
while ((s - t) < skip && s < end);
4543# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
4546 if (str_lower_case_match(enc, case_fold_flag, target, target_end,
4549 if (s + 1 >= end)
break;
4550 skip = reg->int_map[se[1]];
4553 s += enclen(enc, s, end);
4554 }
while ((s - t) < skip && s < end);
4559 return (UChar* )NULL;
4564bm_search_ic(regex_t* reg,
const UChar* target,
const UChar* target_end,
4565 const UChar* text,
const UChar* text_end,
const UChar* text_range)
4567 const UChar *s, *p, *end;
4570 OnigEncoding enc = reg->enc;
4571 int case_fold_flag = reg->case_fold_flag;
4573# ifdef ONIG_DEBUG_SEARCH
4574 fprintf(stderr,
"bm_search_ic: text: %"PRIuPTR
" (%p), text_end: %"PRIuPTR
" (%p), text_range: %"PRIuPTR
" (%p)\n",
4575 (uintptr_t )text, text, (uintptr_t )text_end, text_end, (uintptr_t )text_range, text_range);
4578 tail = target_end - 1;
4579 tlen1 = tail - target;
4580 end = text_range + tlen1;
4585 if (IS_NULL(reg->int_map)) {
4588 if (str_lower_case_match(enc, case_fold_flag, target, target_end,
4591 if (s + 1 >= end)
break;
4592 s += reg->map[s[1]];
4596# if OPT_EXACT_MAXLEN >= ONIG_CHAR_TABLE_SIZE
4599 if (str_lower_case_match(enc, case_fold_flag, target, target_end,
4602 if (s + 1 >= end)
break;
4603 s += reg->int_map[s[1]];
4607 return (UChar* )NULL;
4610#ifdef USE_INT_MAP_BACKWARD
4612set_bm_backward_skip(UChar* s, UChar* end, OnigEncoding enc ARG_UNUSED,
4617 if (IS_NULL(*skip)) {
4618 *skip = (
int* )
xmalloc(
sizeof(
int) * ONIG_CHAR_TABLE_SIZE);
4619 if (IS_NULL(*skip))
return ONIGERR_MEMORY;
4622 len = (int )(end - s);
4623 for (i = 0; i < ONIG_CHAR_TABLE_SIZE; i++)
4626 for (i =
len - 1; i > 0; i--)
4633bm_search_backward(regex_t* reg,
const UChar* target,
const UChar* target_end,
4634 const UChar* text,
const UChar* adjust_text,
4635 const UChar* text_end,
const UChar* text_start)
4637 const UChar *s, *t, *p;
4639 s = text_end - (target_end - target);
4643 s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, adjust_text, s, text_end);
4648 while (t < target_end && *p == *t) {
4651 if (t == target_end)
4654 s -= reg->int_map_backward[*s];
4655 s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, adjust_text, s, text_end);
4658 return (UChar* )NULL;
4663map_search(OnigEncoding enc, UChar map[],
4664 const UChar* text,
const UChar* text_range,
const UChar* text_end)
4666 const UChar *s = text;
4668 while (s < text_range) {
4669 if (map[*s])
return (UChar* )s;
4671 s += enclen(enc, s, text_end);
4673 return (UChar* )NULL;
4677map_search_backward(OnigEncoding enc, UChar map[],
4678 const UChar* text,
const UChar* adjust_text,
4679 const UChar* text_start,
const UChar* text_end)
4681 const UChar *s = text_start;
4684 if (map[*s])
return (UChar* )s;
4686 s = onigenc_get_prev_char_head(enc, adjust_text, s, text_end);
4688 return (UChar* )NULL;
4692onig_match(regex_t* reg,
const UChar* str,
const UChar* end,
const UChar* at, OnigRegion* region,
4693 OnigOptionType option)
4699 MATCH_ARG_INIT(msa, option, region, at, at);
4700#ifdef USE_COMBINATION_EXPLOSION_CHECK
4702 ptrdiff_t offset = at - str;
4703 STATE_CHECK_BUFF_INIT(msa, end - str, offset, reg->num_comb_exp_check);
4708 r = onig_region_resize_clear(region, reg->num_mem + 1);
4714 prev = (UChar* )onigenc_get_prev_char_head(reg->enc, str, at, end);
4715 r = match_at(reg, str, end,
4716#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
4722 MATCH_ARG_FREE(msa);
4727forward_search_range(regex_t* reg,
const UChar* str,
const UChar* end, UChar* s,
4728 UChar* range, UChar** low, UChar** high, UChar** low_prev)
4730 UChar *p, *pprev = (UChar* )NULL;
4731 size_t input_len = end - str;
4733#ifdef ONIG_DEBUG_SEARCH
4734 fprintf(stderr,
"forward_search_range: str: %"PRIuPTR
" (%p), end: %"PRIuPTR
" (%p), s: %"PRIuPTR
" (%p), range: %"PRIuPTR
" (%p)\n",
4735 (uintptr_t )str, str, (uintptr_t )end, end, (uintptr_t )s, s, (uintptr_t )range, range);
4738 if (reg->dmin > input_len) {
4743 if (reg->dmin != 0) {
4744 if ((OnigDistance)(end - p) <= reg->dmin)
return 0;
4745 if (ONIGENC_IS_SINGLEBYTE(reg->enc)) {
4749 UChar *q = p + reg->dmin;
4751 while (p < q) p += enclen(reg->enc, p, end);
4756 switch (reg->optimize) {
4757 case ONIG_OPTIMIZE_EXACT:
4758 p = slow_search(reg->enc, reg->exact, reg->exact_end, p, end, range);
4760 case ONIG_OPTIMIZE_EXACT_IC:
4761 p = slow_search_ic(reg->enc, reg->case_fold_flag,
4762 reg->exact, reg->exact_end, p, end, range);
4765 case ONIG_OPTIMIZE_EXACT_BM:
4766 p = bm_search(reg, reg->exact, reg->exact_end, p, end, range);
4769 case ONIG_OPTIMIZE_EXACT_BM_NOT_REV:
4770 p = bm_search_notrev(reg, reg->exact, reg->exact_end, p, end, range);
4773 case ONIG_OPTIMIZE_EXACT_BM_IC:
4774 p = bm_search_ic(reg, reg->exact, reg->exact_end, p, end, range);
4777 case ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC:
4778 p = bm_search_notrev_ic(reg, reg->exact, reg->exact_end, p, end, range);
4781 case ONIG_OPTIMIZE_MAP:
4782 p = map_search(reg->enc, reg->map, p, range, end);
4786 if (p && p < range) {
4787 if ((OnigDistance)(p - s) < reg->dmin) {
4790 p += enclen(reg->enc, p, end);
4794 if (reg->sub_anchor) {
4797 switch (reg->sub_anchor) {
4798 case ANCHOR_BEGIN_LINE:
4799 if (!ON_STR_BEGIN(p)) {
4800 prev = onigenc_get_prev_char_head(reg->enc,
4801 (pprev ? pprev : str), p, end);
4802 if (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0))
4807 case ANCHOR_END_LINE:
4808 if (ON_STR_END(p)) {
4809#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
4810 prev = (UChar* )onigenc_get_prev_char_head(reg->enc,
4811 (pprev ? pprev : str), p);
4812 if (prev && ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 1))
4816 else if (! ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, p, str, end, reg->options, 1))
4822 if (reg->dmax == 0) {
4826 *low_prev = onigenc_get_prev_char_head(reg->enc, s, p, end);
4828 *low_prev = onigenc_get_prev_char_head(reg->enc,
4829 (pprev ? pprev : str), p, end);
4834 if (reg->dmax != ONIG_INFINITE_DISTANCE) {
4835 if ((OnigDistance)(p - str) < reg->dmax) {
4836 *low = (UChar* )str;
4838 *low_prev = onigenc_get_prev_char_head(reg->enc, str, *low, end);
4841 *low = p - reg->dmax;
4843 *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s,
4844 *low, end, (
const UChar** )low_prev);
4845 if (low_prev && IS_NULL(*low_prev))
4846 *low_prev = onigenc_get_prev_char_head(reg->enc,
4847 (pprev ? pprev : s), *low, end);
4851 *low_prev = onigenc_get_prev_char_head(reg->enc,
4852 (pprev ? pprev : str), *low, end);
4857 if ((OnigDistance)(p - str) < reg->dmin)
4858 *high = (UChar* )str;
4860 *high = p - reg->dmin;
4863#ifdef ONIG_DEBUG_SEARCH
4865 "forward_search_range success: low: %"PRIdPTR
", high: %"PRIdPTR
", dmin: %"PRIdPTR
", dmax: %"PRIdPTR
"\n",
4866 *low - str, *high - str, reg->dmin, reg->dmax);
4874#define BM_BACKWARD_SEARCH_LENGTH_THRESHOLD 100
4877backward_search_range(regex_t* reg,
const UChar* str,
const UChar* end,
4878 UChar* s,
const UChar* range, UChar* adjrange,
4879 UChar** low, UChar** high)
4882 size_t input_len = end - str;
4884 if (reg->dmin > input_len) {
4891 switch (reg->optimize) {
4892 case ONIG_OPTIMIZE_EXACT:
4894 p = slow_search_backward(reg->enc, reg->exact, reg->exact_end,
4895 range, adjrange, end, p);
4898 case ONIG_OPTIMIZE_EXACT_IC:
4899 case ONIG_OPTIMIZE_EXACT_BM_IC:
4900 case ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC:
4901 p = slow_search_backward_ic(reg->enc, reg->case_fold_flag,
4902 reg->exact, reg->exact_end,
4903 range, adjrange, end, p);
4906 case ONIG_OPTIMIZE_EXACT_BM:
4907 case ONIG_OPTIMIZE_EXACT_BM_NOT_REV:
4908#ifdef USE_INT_MAP_BACKWARD
4909 if (IS_NULL(reg->int_map_backward)) {
4911 if (s - range < BM_BACKWARD_SEARCH_LENGTH_THRESHOLD)
4914 r = set_bm_backward_skip(reg->exact, reg->exact_end, reg->enc,
4915 &(reg->int_map_backward));
4918 p = bm_search_backward(reg, reg->exact, reg->exact_end, range, adjrange,
4925 case ONIG_OPTIMIZE_MAP:
4926 p = map_search_backward(reg->enc, reg->map, range, adjrange, p, end);
4931 if (reg->sub_anchor) {
4934 switch (reg->sub_anchor) {
4935 case ANCHOR_BEGIN_LINE:
4936 if (!ON_STR_BEGIN(p)) {
4937 prev = onigenc_get_prev_char_head(reg->enc, str, p, end);
4938 if (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)) {
4945 case ANCHOR_END_LINE:
4946 if (ON_STR_END(p)) {
4947#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
4948 prev = onigenc_get_prev_char_head(reg->enc, adjrange, p);
4949 if (IS_NULL(prev))
goto fail;
4950 if (ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 1)) {
4956 else if (! ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, p, str, end, reg->options, 1)) {
4957 p = onigenc_get_prev_char_head(reg->enc, adjrange, p, end);
4958 if (IS_NULL(p))
goto fail;
4965 if (reg->dmax != ONIG_INFINITE_DISTANCE) {
4966 if ((OnigDistance)(p - str) < reg->dmax)
4967 *low = (UChar* )str;
4969 *low = p - reg->dmax;
4971 if (reg->dmin != 0) {
4972 if ((OnigDistance)(p - str) < reg->dmin)
4973 *high = (UChar* )str;
4975 *high = p - reg->dmin;
4981 *high = onigenc_get_right_adjust_char_head(reg->enc, adjrange, *high, end);
4984#ifdef ONIG_DEBUG_SEARCH
4985 fprintf(stderr,
"backward_search_range: low: %d, high: %d\n",
4986 (
int )(*low - str), (
int )(*high - str));
4992#ifdef ONIG_DEBUG_SEARCH
4993 fprintf(stderr,
"backward_search_range: fail.\n");
5000onig_search(regex_t* reg,
const UChar* str,
const UChar* end,
5001 const UChar* start,
const UChar* range, OnigRegion* region, OnigOptionType option)
5003 return onig_search_gpos(reg, str, end, start, start, range, region, option);
5007onig_search_gpos(regex_t* reg,
const UChar* str,
const UChar* end,
5008 const UChar* global_pos,
5009 const UChar* start,
const UChar* range, OnigRegion* region, OnigOptionType option)
5014#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
5015 const UChar *orig_start = start;
5016 const UChar *orig_range = range;
5019#ifdef ONIG_DEBUG_SEARCH
5021 "onig_search (entry point): str: %"PRIuPTR
" (%p), end: %"PRIuPTR
", start: %"PRIuPTR
", range: %"PRIuPTR
"\n",
5022 (uintptr_t )str, str, end - str, start - str, range - str);
5026 r = onig_region_resize_clear(region, reg->num_mem + 1);
5027 if (r)
goto finish_no_msa;
5030 if (start > end || start < str)
goto mismatch_no_msa;
5033#ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
5034# ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
5035# define MATCH_AND_RETURN_CHECK(upper_range) \
5036 r = match_at(reg, str, end, (upper_range), s, prev, &msa); \
5038 case ONIG_MISMATCH: \
5040 case ONIGERR_TIMEOUT: \
5044 if (! IS_FIND_LONGEST(reg->options)) { \
5051# define MATCH_AND_RETURN_CHECK(upper_range) \
5052 r = match_at(reg, str, end, (upper_range), s, prev, &msa); \
5054 case ONIG_MISMATCH: \
5056 case ONIGERR_TIMEOUT: \
5066# ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
5067# define MATCH_AND_RETURN_CHECK(none) \
5068 r = match_at(reg, str, end, s, prev, &msa);\
5070 case ONIG_MISMATCH: \
5072 case ONIGERR_TIMEOUT: \
5076 if (! IS_FIND_LONGEST(reg->options)) { \
5083# define MATCH_AND_RETURN_CHECK(none) \
5084 r = match_at(reg, str, end, s, prev, &msa);\
5086 case ONIG_MISMATCH: \
5088 case ONIGERR_TIMEOUT: \
5101 if (reg->anchor != 0 && str < end) {
5102 UChar *min_semi_end, *max_semi_end;
5104 if (reg->anchor & ANCHOR_BEGIN_POSITION) {
5109 if (global_pos > start)
5111 if (global_pos < range)
5112 range = global_pos + 1;
5120 else if (reg->anchor & ANCHOR_BEGIN_BUF) {
5122 if (range > start) {
5123 if (start != str)
goto mismatch_no_msa;
5132 goto mismatch_no_msa;
5135 else if (reg->anchor & ANCHOR_END_BUF) {
5136 min_semi_end = max_semi_end = (UChar* )end;
5139 if ((OnigDistance)(max_semi_end - str) < reg->anchor_dmin)
5140 goto mismatch_no_msa;
5142 if (range > start) {
5143 if ((OnigDistance)(min_semi_end - start) > reg->anchor_dmax) {
5144 start = min_semi_end - reg->anchor_dmax;
5146 start = onigenc_get_right_adjust_char_head(reg->enc, str, start, end);
5148 if ((OnigDistance)(max_semi_end - (range - 1)) < reg->anchor_dmin) {
5149 if ((OnigDistance)(max_semi_end - str + 1) < reg->anchor_dmin)
5150 goto mismatch_no_msa;
5152 range = max_semi_end - reg->anchor_dmin + 1;
5155 if (start > range)
goto mismatch_no_msa;
5160 if ((OnigDistance)(min_semi_end - range) > reg->anchor_dmax) {
5161 range = min_semi_end - reg->anchor_dmax;
5163 if ((OnigDistance)(max_semi_end - start) < reg->anchor_dmin) {
5164 if ((OnigDistance)(max_semi_end - str) < reg->anchor_dmin)
5165 goto mismatch_no_msa;
5167 start = max_semi_end - reg->anchor_dmin;
5168 start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start, end);
5171 if (range > start)
goto mismatch_no_msa;
5174 else if (reg->anchor & ANCHOR_SEMI_END_BUF) {
5175 UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, end, 1);
5177 max_semi_end = (UChar* )end;
5178 if (ONIGENC_IS_MBC_NEWLINE(reg->enc, pre_end, end)) {
5179 min_semi_end = pre_end;
5181#ifdef USE_CRNL_AS_LINE_TERMINATOR
5182 pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, end, 1);
5183 if (IS_NOT_NULL(pre_end) &&
5184 IS_NEWLINE_CRLF(reg->options) &&
5185 ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) {
5186 min_semi_end = pre_end;
5189 if (min_semi_end > str && start <= min_semi_end) {
5194 min_semi_end = (UChar* )end;
5198 else if ((reg->anchor & ANCHOR_ANYCHAR_STAR_ML) && range > start) {
5199 goto begin_position;
5202 else if (str == end) {
5203 static const UChar address_for_empty_string[] =
"";
5205#ifdef ONIG_DEBUG_SEARCH
5206 fprintf(stderr,
"onig_search: empty string.\n");
5209 if (reg->threshold_len == 0) {
5210 start = end = str = address_for_empty_string;
5212 prev = (UChar* )NULL;
5214 MATCH_ARG_INIT(msa, option, region, start, start);
5215#ifdef USE_COMBINATION_EXPLOSION_CHECK
5216 msa.state_check_buff = (
void* )0;
5217 msa.state_check_buff_size = 0;
5219 MATCH_AND_RETURN_CHECK(end);
5222 goto mismatch_no_msa;
5225#ifdef ONIG_DEBUG_SEARCH
5226 fprintf(stderr,
"onig_search(apply anchor): end: %d, start: %d, range: %d\n",
5227 (
int )(end - str), (
int )(start - str), (
int )(range - str));
5230 MATCH_ARG_INIT(msa, option, region, start, global_pos);
5231#ifdef USE_COMBINATION_EXPLOSION_CHECK
5233 ptrdiff_t offset = (MIN(start, range) - str);
5234 STATE_CHECK_BUFF_INIT(msa, end - str, offset, reg->num_comb_exp_check);
5239 if (range > start) {
5241 prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
5243 prev = (UChar* )NULL;
5245 if (reg->optimize != ONIG_OPTIMIZE_NONE) {
5246 UChar *sch_range, *low, *high, *low_prev;
5248 if (reg->dmax != 0) {
5249 if (reg->dmax == ONIG_INFINITE_DISTANCE)
5250 sch_range = (UChar* )end;
5252 if ((OnigDistance)(end - range) < reg->dmax)
5253 sch_range = (UChar* )end;
5255 sch_range = (UChar* )range + reg->dmax;
5260 sch_range = (UChar* )range;
5262 if ((end - start) < reg->threshold_len)
5265 if (reg->dmax != ONIG_INFINITE_DISTANCE) {
5267 if (! forward_search_range(reg, str, end, s, sch_range,
5268 &low, &high, &low_prev))
goto mismatch;
5274 MATCH_AND_RETURN_CHECK(orig_range);
5276 s += enclen(reg->enc, s, end);
5278 }
while (s < range);
5282 if (! forward_search_range(reg, str, end, s, sch_range,
5283 &low, &high, (UChar** )NULL))
goto mismatch;
5285 if ((reg->anchor & ANCHOR_ANYCHAR_STAR) != 0) {
5287 MATCH_AND_RETURN_CHECK(orig_range);
5289 s += enclen(reg->enc, s, end);
5291 if ((reg->anchor & (ANCHOR_LOOK_BEHIND | ANCHOR_PREC_READ_NOT)) == 0) {
5292 while (!ONIGENC_IS_MBC_NEWLINE_EX(reg->enc, prev, str, end, reg->options, 0)
5295 s += enclen(reg->enc, s, end);
5298 }
while (s < range);
5305 MATCH_AND_RETURN_CHECK(orig_range);
5307 s += enclen(reg->enc, s, end);
5308 }
while (s < range);
5311 MATCH_AND_RETURN_CHECK(orig_range);
5315 if (reg->optimize != ONIG_OPTIMIZE_NONE) {
5316 UChar *low, *high, *adjrange, *sch_start;
5317 const UChar *min_range;
5320 adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range, end);
5322 adjrange = (UChar* )end;
5324 if ((OnigDistance)(end - range) > reg->dmin)
5325 min_range = range + reg->dmin;
5329 if (reg->dmax != ONIG_INFINITE_DISTANCE &&
5330 end - range >= reg->threshold_len) {
5332 if ((OnigDistance)(end - s) > reg->dmax)
5333 sch_start = s + reg->dmax;
5335 sch_start = (UChar* )end;
5337 if (backward_search_range(reg, str, end, sch_start, min_range, adjrange,
5345 prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
5346 MATCH_AND_RETURN_CHECK(orig_start);
5349 }
while (s >= range);
5353 if (end - range < reg->threshold_len)
goto mismatch;
5355 if (reg->dmax != 0) {
5356 if (reg->dmax == ONIG_INFINITE_DISTANCE)
5357 sch_start = (UChar* )end;
5359 if ((OnigDistance)(end - s) > reg->dmax) {
5360 sch_start = s + reg->dmax;
5361 sch_start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc,
5362 start, sch_start, end);
5364 sch_start = (UChar* )end;
5368 sch_start = (UChar* )s;
5370 if (backward_search_range(reg, str, end, sch_start, min_range, adjrange,
5371 &low, &high) <= 0)
goto mismatch;
5376 prev = onigenc_get_prev_char_head(reg->enc, str, s, end);
5377 MATCH_AND_RETURN_CHECK(orig_start);
5379 }
while (s >= range);
5383#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
5384 if (IS_FIND_LONGEST(reg->options)) {
5385 if (msa.best_len >= 0) {
5394 MATCH_ARG_FREE(msa);
5398 if (IS_FIND_NOT_EMPTY(reg->options) && region) {
5399 onig_region_clear(region);
5403 if (r != ONIG_MISMATCH)
5404 fprintf(stderr,
"onig_search: error %"PRIdPTRDIFF
"\n", r);
5412 if (r != ONIG_MISMATCH)
5413 fprintf(stderr,
"onig_search: error %"PRIdPTRDIFF
"\n", r);
5418 MATCH_ARG_FREE(msa);
5422 MATCH_ARG_FREE(msa);
5423 return ONIGERR_TIMEOUT;
5427onig_scan(regex_t* reg,
const UChar* str,
const UChar* end,
5428 OnigRegion* region, OnigOptionType option,
5429 int (*scan_callback)(OnigPosition, OnigPosition, OnigRegion*,
void*),
5440 r = onig_search(reg, str, end, start, end, region, option);
5442 rs = scan_callback(n, r, region, callback_arg);
5447 if (region->end[0] == start - str) {
5448 if (start >= end)
break;
5449 start += enclen(reg->enc, start, end);
5452 start = str + region->end[0];
5457 else if (r == ONIG_MISMATCH) {
5469onig_get_encoding(
const regex_t* reg)
5474extern OnigOptionType
5475onig_get_options(
const regex_t* reg)
5477 return reg->options;
5480extern OnigCaseFoldType
5481onig_get_case_fold_flag(
const regex_t* reg)
5483 return reg->case_fold_flag;
5487onig_get_syntax(
const regex_t* reg)
5493onig_number_of_captures(
const regex_t* reg)
5495 return reg->num_mem;
5499onig_number_of_capture_histories(
const regex_t* reg)
5501#ifdef USE_CAPTURE_HISTORY
5505 for (i = 0; i <= ONIG_MAX_CAPTURE_HISTORY_GROUP; i++) {
5506 if (BIT_STATUS_AT(reg->capture_history, i) != 0)
5516onig_copy_encoding(OnigEncodingType *to, OnigEncoding from)
#define xfree
Old name of ruby_xfree.
#define xrealloc
Old name of ruby_xrealloc.
#define xmalloc
Old name of ruby_xmalloc.
#define RB_GNUC_EXTENSION
This is expanded to nothing for non-GCC compilers.
int len
Length of the buffer.