35 #ifdef USE_CRNL_AS_LINE_TERMINATOR
36 #define ONIGENC_IS_MBC_CRNL(enc,p,end) \
37 (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \
38 ONIGENC_MBC_TO_CODE(enc,(p+enclen(enc,p,end)),end) == 10)
39 #define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
40 is_mbc_newline_ex((enc),(p),(start),(end),(option),(check_prev))
73 #define ONIGENC_IS_MBC_NEWLINE_EX(enc,p,start,end,option,check_prev) \
74 ONIGENC_IS_MBC_NEWLINE((enc), (p), (end))
77 #ifdef USE_CAPTURE_HISTORY
88 history_tree_free(node->
childs[i]);
106 history_tree_clear(node);
120 history_node_new(
void)
139 #define HISTORY_TREE_INIT_ALLOC_SIZE 8
145 n = HISTORY_TREE_INIT_ALLOC_SIZE;
157 history_tree_clear(parent);
162 for (i = parent->
allocated; i < n; i++) {
179 clone = history_node_new();
185 child = history_tree_clone(node->
childs[i]);
187 history_tree_free(clone);
190 r = history_tree_add_child(clone, child);
192 history_tree_free(child);
193 history_tree_free(clone);
213 for (i = 0; i < region->
num_regs; i++) {
216 #ifdef USE_CAPTURE_HISTORY
217 history_root_free(region);
231 if (region->
beg == 0)
235 if (region->
end == 0) {
273 if (r != 0)
return r;
288 region->
beg[at] = beg;
323 #ifdef USE_CAPTURE_HISTORY
324 history_root_free(r);
326 if (free_self)
xfree(r);
333 #define RREGC_SIZE (sizeof(int) * from->num_regs)
336 if (to == from)
return;
341 for (i = 0; i < from->
num_regs; i++) {
347 #ifdef USE_CAPTURE_HISTORY
348 history_root_free(to);
358 #define INVALID_STACK_INDEX -1
362 #define STK_ALT 0x0001
363 #define STK_LOOK_BEHIND_NOT 0x0002
364 #define STK_POS_NOT 0x0003
366 #define STK_MEM_START 0x0100
367 #define STK_MEM_END 0x8200
368 #define STK_REPEAT_INC 0x0300
369 #define STK_STATE_CHECK_MARK 0x1000
371 #define STK_NULL_CHECK_START 0x3000
372 #define STK_NULL_CHECK_END 0x5000
373 #define STK_MEM_END_MARK 0x8400
374 #define STK_POS 0x0500
375 #define STK_STOP_BT 0x0600
376 #define STK_REPEAT 0x0700
377 #define STK_CALL_FRAME 0x0800
378 #define STK_RETURN 0x0900
379 #define STK_VOID 0x0a00
382 #define STK_MASK_POP_USED 0x00ff
383 #define STK_MASK_TO_VOID_TARGET 0x10ff
384 #define STK_MASK_MEM_END_OR_MARK 0x8000
386 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
387 #define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
388 (msa).stack_p = (void* )0;\
389 (msa).options = (arg_option);\
390 (msa).region = (arg_region);\
391 (msa).start = (arg_start);\
392 (msa).gpos = (arg_gpos);\
393 (msa).best_len = ONIG_MISMATCH;\
396 #define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos) do {\
397 (msa).stack_p = (void* )0;\
398 (msa).options = (arg_option);\
399 (msa).region = (arg_region);\
400 (msa).start = (arg_start);\
401 (msa).gpos = (arg_gpos);\
405 #ifdef USE_COMBINATION_EXPLOSION_CHECK
407 #define STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE 16
409 #define STATE_CHECK_BUFF_INIT(msa, str_len, offset, state_num) do { \
410 if ((state_num) > 0 && str_len >= STATE_CHECK_STRING_THRESHOLD_LEN) {\
411 unsigned int size = (unsigned int )(((str_len) + 1) * (state_num) + 7) >> 3;\
412 offset = ((offset) * (state_num)) >> 3;\
413 if (size > 0 && offset < size && size < STATE_CHECK_BUFF_MAX_SIZE) {\
414 if (size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) {\
415 (msa).state_check_buff = (void* )xmalloc(size);\
416 CHECK_NULL_RETURN_MEMERR((msa).state_check_buff);\
419 (msa).state_check_buff = (void* )xalloca(size);\
420 xmemset(((char* )((msa).state_check_buff)+(offset)), 0, \
421 (size_t )(size - (offset))); \
422 (msa).state_check_buff_size = size;\
425 (msa).state_check_buff = (void* )0;\
426 (msa).state_check_buff_size = 0;\
430 (msa).state_check_buff = (void* )0;\
431 (msa).state_check_buff_size = 0;\
435 #define MATCH_ARG_FREE(msa) do {\
436 if ((msa).stack_p) xfree((msa).stack_p);\
437 if ((msa).state_check_buff_size >= STATE_CHECK_BUFF_MALLOC_THRESHOLD_SIZE) { \
438 if ((msa).state_check_buff) xfree((msa).state_check_buff);\
442 #define MATCH_ARG_FREE(msa) if ((msa).stack_p) xfree((msa).stack_p)
447 #define STACK_INIT(alloc_addr, ptr_num, stack_num) do {\
449 alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num));\
450 stk_alloc = (OnigStackType* )(msa->stack_p);\
451 stk_base = stk_alloc;\
453 stk_end = stk_base + msa->stack_n;\
456 alloc_addr = (char* )xalloca(sizeof(OnigStackIndex) * (ptr_num)\
457 + sizeof(OnigStackType) * (stack_num));\
458 stk_alloc = (OnigStackType* )(alloc_addr + sizeof(OnigStackIndex) * (ptr_num));\
459 stk_base = stk_alloc;\
461 stk_end = stk_base + (stack_num);\
465 #define STACK_SAVE do{\
466 if (stk_base != stk_alloc) {\
467 msa->stack_p = stk_base;\
468 msa->stack_n = stk_end - stk_base; \
483 MatchStackLimitSize =
size;
494 stk_base = *arg_stk_base;
495 stk_end = *arg_stk_end;
498 n = stk_end - stk_base;
511 if (limit_size != 0 && n > limit_size) {
512 if ((
unsigned int )(stk_end - stk_base) == limit_size)
523 *arg_stk = x + (stk - stk_base);
525 *arg_stk_end = x +
n;
529 #define STACK_ENSURE(n) do {\
530 if (stk_end - stk < (n)) {\
531 int r = stack_double(&stk_base, &stk_end, &stk, stk_alloc, msa);\
532 if (r != 0) { STACK_SAVE; return r; } \
536 #define STACK_AT(index) (stk_base + (index))
537 #define GET_STACK_INDEX(stk) ((stk) - stk_base)
539 #define STACK_PUSH_TYPE(stack_type) do {\
541 stk->type = (stack_type);\
545 #define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0)
547 #ifdef USE_COMBINATION_EXPLOSION_CHECK
548 #define STATE_CHECK_POS(s,snum) \
549 (((s) - str) * num_comb_exp_check + ((snum) - 1))
550 #define STATE_CHECK_VAL(v,snum) do {\
551 if (state_check_buff != NULL) {\
552 int x = STATE_CHECK_POS(s,snum);\
553 (v) = state_check_buff[x/8] & (1<<(x%8));\
559 #define ELSE_IF_STATE_CHECK_MARK(stk) \
560 else if ((stk)->type == STK_STATE_CHECK_MARK) { \
561 int x = STATE_CHECK_POS(stk->u.state.pstr, stk->u.state.state_check);\
562 state_check_buff[x/8] |= (1<<(x%8)); \
565 #define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
567 stk->type = (stack_type);\
568 stk->u.state.pcode = (pat);\
569 stk->u.state.pstr = (s);\
570 stk->u.state.pstr_prev = (sprev);\
571 stk->u.state.state_check = 0;\
572 stk->u.state.pkeep = (keep);\
576 #define STACK_PUSH_ENSURED(stack_type,pat) do {\
577 stk->type = (stack_type);\
578 stk->u.state.pcode = (pat);\
579 stk->u.state.state_check = 0;\
583 #define STACK_PUSH_ALT_WITH_STATE_CHECK(pat,s,sprev,snum,keep) do {\
585 stk->type = STK_ALT;\
586 stk->u.state.pcode = (pat);\
587 stk->u.state.pstr = (s);\
588 stk->u.state.pstr_prev = (sprev);\
589 stk->u.state.state_check = ((state_check_buff != NULL) ? (snum) : 0);\
590 stk->u.state.pkeep = (keep);\
594 #define STACK_PUSH_STATE_CHECK(s,snum) do {\
595 if (state_check_buff != NULL) {\
597 stk->type = STK_STATE_CHECK_MARK;\
598 stk->u.state.pstr = (s);\
599 stk->u.state.state_check = (snum);\
606 #define ELSE_IF_STATE_CHECK_MARK(stk)
608 #define STACK_PUSH(stack_type,pat,s,sprev,keep) do {\
610 stk->type = (stack_type);\
611 stk->u.state.pcode = (pat);\
612 stk->u.state.pstr = (s);\
613 stk->u.state.pstr_prev = (sprev);\
614 stk->u.state.pkeep = (keep);\
618 #define STACK_PUSH_ENSURED(stack_type,pat) do {\
619 stk->type = (stack_type);\
620 stk->u.state.pcode = (pat);\
625 #define STACK_PUSH_ALT(pat,s,sprev,keep) STACK_PUSH(STK_ALT,pat,s,sprev,keep)
626 #define STACK_PUSH_POS(s,sprev,keep) STACK_PUSH(STK_POS,NULL_UCHARP,s,sprev,keep)
627 #define STACK_PUSH_POS_NOT(pat,s,sprev,keep) STACK_PUSH(STK_POS_NOT,pat,s,sprev,keep)
628 #define STACK_PUSH_STOP_BT STACK_PUSH_TYPE(STK_STOP_BT)
629 #define STACK_PUSH_LOOK_BEHIND_NOT(pat,s,sprev,keep) \
630 STACK_PUSH(STK_LOOK_BEHIND_NOT,pat,s,sprev,keep)
632 #define STACK_PUSH_REPEAT(id, pat) do {\
634 stk->type = STK_REPEAT;\
635 stk->u.repeat.num = (id);\
636 stk->u.repeat.pcode = (pat);\
637 stk->u.repeat.count = 0;\
641 #define STACK_PUSH_REPEAT_INC(sindex) do {\
643 stk->type = STK_REPEAT_INC;\
644 stk->u.repeat_inc.si = (sindex);\
648 #define STACK_PUSH_MEM_START(mnum, s) do {\
650 stk->type = STK_MEM_START;\
651 stk->u.mem.num = (mnum);\
652 stk->u.mem.pstr = (s);\
653 stk->u.mem.start = mem_start_stk[mnum];\
654 stk->u.mem.end = mem_end_stk[mnum];\
655 mem_start_stk[mnum] = GET_STACK_INDEX(stk);\
656 mem_end_stk[mnum] = INVALID_STACK_INDEX;\
660 #define STACK_PUSH_MEM_END(mnum, s) do {\
662 stk->type = STK_MEM_END;\
663 stk->u.mem.num = (mnum);\
664 stk->u.mem.pstr = (s);\
665 stk->u.mem.start = mem_start_stk[mnum];\
666 stk->u.mem.end = mem_end_stk[mnum];\
667 mem_end_stk[mnum] = GET_STACK_INDEX(stk);\
671 #define STACK_PUSH_MEM_END_MARK(mnum) do {\
673 stk->type = STK_MEM_END_MARK;\
674 stk->u.mem.num = (mnum);\
678 #define STACK_GET_MEM_START(mnum, k) do {\
681 while (k > stk_base) {\
683 if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \
684 && k->u.mem.num == (mnum)) {\
687 else if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
688 if (level == 0) break;\
694 #define STACK_GET_MEM_RANGE(k, mnum, start, end) do {\
697 if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\
698 if (level == 0) (start) = k->u.mem.pstr;\
701 else if (k->type == STK_MEM_END && k->u.mem.num == (mnum)) {\
704 (end) = k->u.mem.pstr;\
712 #define STACK_PUSH_NULL_CHECK_START(cnum, s) do {\
714 stk->type = STK_NULL_CHECK_START;\
715 stk->u.null_check.num = (cnum);\
716 stk->u.null_check.pstr = (s);\
720 #define STACK_PUSH_NULL_CHECK_END(cnum) do {\
722 stk->type = STK_NULL_CHECK_END;\
723 stk->u.null_check.num = (cnum);\
727 #define STACK_PUSH_CALL_FRAME(pat) do {\
729 stk->type = STK_CALL_FRAME;\
730 stk->u.call_frame.ret_addr = (pat);\
734 #define STACK_PUSH_RETURN do {\
736 stk->type = STK_RETURN;\
742 #define STACK_BASE_CHECK(p, at) \
743 if ((p) < stk_base) {\
744 fprintf(stderr, "at %s\n", at);\
748 #define STACK_BASE_CHECK(p, at)
751 #define STACK_POP_ONE do {\
753 STACK_BASE_CHECK(stk, "STACK_POP_ONE"); \
756 #define STACK_POP do {\
757 switch (pop_level) {\
758 case STACK_POP_LEVEL_FREE:\
761 STACK_BASE_CHECK(stk, "STACK_POP"); \
762 if ((stk->type & STK_MASK_POP_USED) != 0) break;\
763 ELSE_IF_STATE_CHECK_MARK(stk);\
766 case STACK_POP_LEVEL_MEM_START:\
769 STACK_BASE_CHECK(stk, "STACK_POP 2"); \
770 if ((stk->type & STK_MASK_POP_USED) != 0) break;\
771 else if (stk->type == STK_MEM_START) {\
772 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
773 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
775 ELSE_IF_STATE_CHECK_MARK(stk);\
781 STACK_BASE_CHECK(stk, "STACK_POP 3"); \
782 if ((stk->type & STK_MASK_POP_USED) != 0) break;\
783 else if (stk->type == STK_MEM_START) {\
784 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
785 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
787 else if (stk->type == STK_REPEAT_INC) {\
788 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
790 else if (stk->type == STK_MEM_END) {\
791 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
792 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
794 ELSE_IF_STATE_CHECK_MARK(stk);\
800 #define STACK_POP_TIL_POS_NOT do {\
803 STACK_BASE_CHECK(stk, "STACK_POP_TIL_POS_NOT"); \
804 if (stk->type == STK_POS_NOT) break;\
805 else if (stk->type == STK_MEM_START) {\
806 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
807 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
809 else if (stk->type == STK_REPEAT_INC) {\
810 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
812 else if (stk->type == STK_MEM_END) {\
813 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
814 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
816 ELSE_IF_STATE_CHECK_MARK(stk);\
820 #define STACK_POP_TIL_LOOK_BEHIND_NOT do {\
823 STACK_BASE_CHECK(stk, "STACK_POP_TIL_LOOK_BEHIND_NOT"); \
824 if (stk->type == STK_LOOK_BEHIND_NOT) break;\
825 else if (stk->type == STK_MEM_START) {\
826 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
827 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
829 else if (stk->type == STK_REPEAT_INC) {\
830 STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\
832 else if (stk->type == STK_MEM_END) {\
833 mem_start_stk[stk->u.mem.num] = stk->u.mem.start;\
834 mem_end_stk[stk->u.mem.num] = stk->u.mem.end;\
836 ELSE_IF_STATE_CHECK_MARK(stk);\
840 #define STACK_POS_END(k) do {\
844 STACK_BASE_CHECK(k, "STACK_POS_END"); \
845 if (IS_TO_VOID_TARGET(k)) {\
848 else if (k->type == STK_POS) {\
855 #define STACK_STOP_BT_END do {\
856 OnigStackType *k = stk;\
859 STACK_BASE_CHECK(k, "STACK_STOP_BT_END"); \
860 if (IS_TO_VOID_TARGET(k)) {\
863 else if (k->type == STK_STOP_BT) {\
870 #define STACK_NULL_CHECK(isnull,id,s) do {\
871 OnigStackType* k = stk;\
874 STACK_BASE_CHECK(k, "STACK_NULL_CHECK"); \
875 if (k->type == STK_NULL_CHECK_START) {\
876 if (k->u.null_check.num == (id)) {\
877 (isnull) = (k->u.null_check.pstr == (s));\
884 #define STACK_NULL_CHECK_REC(isnull,id,s) do {\
886 OnigStackType* k = stk;\
889 STACK_BASE_CHECK(k, "STACK_NULL_CHECK_REC"); \
890 if (k->type == STK_NULL_CHECK_START) {\
891 if (k->u.null_check.num == (id)) {\
893 (isnull) = (k->u.null_check.pstr == (s));\
899 else if (k->type == STK_NULL_CHECK_END) {\
905 #define STACK_NULL_CHECK_MEMST(isnull,id,s,reg) do {\
906 OnigStackType* k = stk;\
909 STACK_BASE_CHECK(k, "STACK_NULL_CHECK_MEMST"); \
910 if (k->type == STK_NULL_CHECK_START) {\
911 if (k->u.null_check.num == (id)) {\
912 if (k->u.null_check.pstr != (s)) {\
920 if (k->type == STK_MEM_START) {\
921 if (k->u.mem.end == INVALID_STACK_INDEX) {\
922 (isnull) = 0; break;\
924 if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
925 endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
927 endp = (UChar* )k->u.mem.end;\
928 if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\
929 (isnull) = 0; break;\
931 else if (endp != s) {\
944 #define STACK_NULL_CHECK_MEMST_REC(isnull,id,s,reg) do {\
946 OnigStackType* k = stk;\
949 STACK_BASE_CHECK(k, "STACK_NULL_CHECK_MEMST_REC"); \
950 if (k->type == STK_NULL_CHECK_START) {\
951 if (k->u.null_check.num == (id)) {\
953 if (k->u.null_check.pstr != (s)) {\
961 if (k->type == STK_MEM_START) {\
962 if (k->u.mem.end == INVALID_STACK_INDEX) {\
963 (isnull) = 0; break;\
965 if (BIT_STATUS_AT(reg->bt_mem_end, k->u.mem.num))\
966 endp = STACK_AT(k->u.mem.end)->u.mem.pstr;\
968 endp = (UChar* )k->u.mem.end;\
969 if (STACK_AT(k->u.mem.start)->u.mem.pstr != endp) {\
970 (isnull) = 0; break;\
972 else if (endp != s) {\
986 else if (k->type == STK_NULL_CHECK_END) {\
987 if (k->u.null_check.num == (id)) level++;\
992 #define STACK_GET_REPEAT(id, k) do {\
997 STACK_BASE_CHECK(k, "STACK_GET_REPEAT"); \
998 if (k->type == STK_REPEAT) {\
1000 if (k->u.repeat.num == (id)) {\
1005 else if (k->type == STK_CALL_FRAME) level--;\
1006 else if (k->type == STK_RETURN) level++;\
1010 #define STACK_RETURN(addr) do {\
1012 OnigStackType* k = stk;\
1015 STACK_BASE_CHECK(k, "STACK_RETURN"); \
1016 if (k->type == STK_CALL_FRAME) {\
1018 (addr) = k->u.call_frame.ret_addr;\
1023 else if (k->type == STK_RETURN)\
1029 #define STRING_CMP(s1,s2,len) do {\
1030 while (len-- > 0) {\
1031 if (*s1++ != *s2++) goto fail;\
1035 #define STRING_CMP_IC(case_fold_flag,s1,ps2,len,text_end) do {\
1036 if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \
1045 UChar *p1, *p2, *end1, *s2;
1053 if (len1 != len2)
return 0;
1056 while (len1-- > 0) {
1057 if (*p1 != *p2)
return 0;
1067 #define STRING_CMP_VALUE(s1,s2,len,is_fail) do {\
1069 while (len-- > 0) {\
1070 if (*s1++ != *s2++) {\
1071 is_fail = 1; break;\
1076 #define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,text_end,is_fail) do {\
1077 if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len, text_end) == 0) \
1084 #define IS_EMPTY_STR (str == end)
1085 #define ON_STR_BEGIN(s) ((s) == str)
1086 #define ON_STR_END(s) ((s) == end)
1087 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
1088 #define DATA_ENSURE_CHECK1 (s < right_range)
1089 #define DATA_ENSURE_CHECK(n) (s + (n) <= right_range)
1090 #define DATA_ENSURE(n) if (s + (n) > right_range) goto fail
1092 #define DATA_ENSURE_CHECK1 (s < end)
1093 #define DATA_ENSURE_CHECK(n) (s + (n) <= end)
1094 #define DATA_ENSURE(n) if (s + (n) > end) goto fail
1098 #ifdef USE_CAPTURE_HISTORY
1107 while (k < stk_top) {
1112 child = history_node_new();
1116 r = history_tree_add_child(node, child);
1118 history_tree_free(child);
1122 r = make_capture_history_tree(child, kp, stk_top, str, reg);
1123 if (r != 0)
return r;
1143 #ifdef USE_BACKREF_WITH_LEVEL
1149 for (i = 0; i < num; i++) {
1151 if (mem == (
int )m)
return 1;
1158 ,
int ignore_case,
int case_fold_flag
1168 while (k >= stk_base) {
1175 else if (level == nest) {
1178 pstart = k->
u.
mem.pstr;
1180 if (pend - pstart > send - *s)
return 0;
1184 if (ignore_case != 0) {
1186 pstart, &ss, pend - pstart, send) == 0)
1191 if (*p++ != *ss++)
return 0;
1202 pend = k->
u.
mem.pstr;
1214 #ifdef ONIG_DEBUG_STATISTICS
1216 #define USE_TIMEOFDAY
1218 #ifdef USE_TIMEOFDAY
1219 #ifdef HAVE_SYS_TIME_H
1220 #include <sys/time.h>
1222 #ifdef HAVE_UNISTD_H
1226 #define GETTIME(t) gettimeofday(&(t), (struct timezone* )0)
1227 #define TIMEDIFF(te,ts) (((te).tv_usec - (ts).tv_usec) + \
1228 (((te).tv_sec - (ts).tv_sec)*1000000))
1230 #ifdef HAVE_SYS_TIMES_H
1231 #include <sys/times.h>
1233 static struct tms ts, te;
1234 #define GETTIME(t) times(&(t))
1235 #define TIMEDIFF(te,ts) ((te).tms_utime - (ts).tms_utime)
1238 static int OpCounter[256];
1239 static int OpPrevCounter[256];
1240 static unsigned long OpTime[256];
1242 static int OpPrevTarget =
OP_FAIL;
1243 static int MaxStackDepth = 0;
1245 #define MOP_IN(opcode) do {\
1246 if (opcode == OpPrevTarget) OpPrevCounter[OpCurr]++;\
1248 OpCounter[opcode]++;\
1252 #define MOP_OUT do {\
1254 OpTime[OpCurr] += TIMEDIFF(te, ts);\
1258 onig_statistics_init(
void)
1261 for (i = 0; i < 256; i++) {
1262 OpCounter[
i] = OpPrevCounter[
i] = 0; OpTime[
i] = 0;
1268 onig_print_statistics(
FILE*
f)
1271 fprintf(f,
" count prev time\n");
1272 for (i = 0; OnigOpInfo[
i].opcode >= 0; i++) {
1273 fprintf(f,
"%8d: %8d: %10ld: %s\n",
1274 OpCounter[i], OpPrevCounter[i], OpTime[i], OnigOpInfo[i].
name);
1276 fprintf(f,
"\nmax stack depth: %d\n", MaxStackDepth);
1279 #define STACK_INC do {\
1281 if (stk - stk_base > MaxStackDepth) \
1282 MaxStackDepth = stk - stk_base;\
1286 #define STACK_INC stk++
1288 #define MOP_IN(opcode)
1309 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
1310 const UChar* right_range,
1316 int i, num_mem, pop_level;
1317 ptrdiff_t
n, best_len;
1333 #ifdef USE_COMBINATION_EXPLOSION_CHECK
1335 unsigned char* state_check_buff = msa->state_check_buff;
1339 #ifdef USE_SUBEXP_CALL
1349 mem_end_stk = mem_start_stk + (num_mem + 1);
1350 for (i = 0; i <= num_mem; i++) {
1363 mem_end_stk = mem_start_stk + num_mem;
1368 for (i = 1; i <= num_mem; i++) {
1373 #ifdef ONIG_DEBUG_MATCH
1374 fprintf(stderr,
"match_at: str: %"PRIdPTR
" (%p), end: %"PRIdPTR
" (%p), start: %"PRIdPTR
" (%p), sprev: %"PRIdPTR
" (%p)\n",
1376 fprintf(stderr,
"size: %d, start offset: %d\n",
1377 (
int )(end - str), (
int )(sstart - str));
1382 s = (
UChar* )sstart;
1383 pkeep = (
UChar* )sstart;
1385 #ifdef ONIG_DEBUG_MATCH
1389 fprintf(stderr,
"%4d> \"", (
int )(s - str));
1392 for (i = 0, q = s; i < 7 && q <
end; i++) {
1393 len =
enclen(encode, q, end);
1394 while (len-- > 0) *bp++ = *q++;
1397 if (q < end) {
xmemcpy(bp,
"...\"", 4); bp += 4; }
1398 else {
xmemcpy(bp,
"\"", 1); bp += 1; }
1400 fputs((
char* )buf, stderr);
1401 for (i = 0; i < 20 - (bp -
buf); i++) fputc(
' ', stderr);
1403 fprintf(stderr,
"\n");
1413 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
1426 #ifdef USE_POSIX_API_REGION_OPTION
1430 rmt[0].
rm_so = (
regoff_t )(((pkeep > s) ? s : pkeep) - str);
1432 for (i = 1; i <= num_mem; i++) {
1435 rmt[i].rm_so = (regoff_t )(
STACK_AT(mem_start_stk[i])->u.mem.pstr -
str);
1440 ?
STACK_AT(mem_end_stk[i])->u.mem.pstr
1441 : (
UChar* )((
void* )mem_end_stk[
i])) -
str);
1450 region->
beg[0] = ((pkeep >
s) ? s : pkeep) -
str;
1451 region->
end[0] = s -
str;
1452 for (i = 1; i <= num_mem; i++) {
1457 region->
beg[
i] = (
UChar* )((
void* )mem_start_stk[
i]) - str;
1460 ?
STACK_AT(mem_end_stk[i])->u.mem.pstr
1461 : (
UChar* )((
void* )mem_end_stk[
i])) -
str;
1468 #ifdef USE_CAPTURE_HISTORY
1479 history_tree_clear(node);
1483 node->
beg = ((pkeep >
s) ? s : pkeep) -
str;
1487 r = make_capture_history_tree(region->
history_root, &stkp,
1488 stk, (
UChar* )str, reg);
1495 #ifdef USE_POSIX_API_REGION_OPTION
1501 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
1523 if (*p != *s)
goto fail;
1526 if (*p != *s++)
goto fail;
1556 if (*p != *s)
goto fail;
1558 if (*p != *s)
goto fail;
1567 if (*p != *s)
goto fail;
1569 if (*p != *s)
goto fail;
1571 if (*p != *s)
goto fail;
1580 if (*p != *s)
goto fail;
1582 if (*p != *s)
goto fail;
1584 if (*p != *s)
goto fail;
1586 if (*p != *s)
goto fail;
1595 if (*p != *s)
goto fail;
1597 if (*p != *s)
goto fail;
1599 if (*p != *s)
goto fail;
1601 if (*p != *s)
goto fail;
1603 if (*p != *s)
goto fail;
1613 while (tlen-- > 0) {
1614 if (*p++ != *s++)
goto fail;
1639 if (*p != *q)
goto fail;
1651 if (*p != *s)
goto fail;
1653 if (*p != *s)
goto fail;
1660 if (*p != *s)
goto fail;
1662 if (*p != *s)
goto fail;
1665 if (*p != *s)
goto fail;
1667 if (*p != *s)
goto fail;
1675 if (*p != *s)
goto fail;
1677 if (*p != *s)
goto fail;
1679 if (*p != *s)
goto fail;
1681 if (*p != *s)
goto fail;
1684 if (*p != *s)
goto fail;
1686 if (*p != *s)
goto fail;
1695 while (tlen-- > 0) {
1696 if (*p != *s)
goto fail;
1698 if (*p != *s)
goto fail;
1709 while (tlen-- > 0) {
1710 if (*p != *s)
goto fail;
1712 if (*p != *s)
goto fail;
1714 if (*p != *s)
goto fail;
1727 while (tlen2-- > 0) {
1728 if (*p != *s)
goto fail;
1740 s +=
enclen(encode, s, end);
1755 mb_len =
enclen(encode, s, end);
1761 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
1795 s +=
enclen(encode, s, end);
1805 goto cc_mb_not_success;
1813 int mb_len =
enclen(encode, s, end);
1819 goto cc_mb_not_success;
1826 #ifdef PLATFORM_UNALIGNED_WORD_ACCESS
1867 mb_len =
enclen(encode, s, end);
1879 n =
enclen(encode, s, end);
1888 n =
enclen(encode, s, end);
1897 n =
enclen(encode, s, end);
1909 n =
enclen(encode, s, end);
1928 n =
enclen(encode, s, end);
1943 n =
enclen(encode, s, end);
1958 #ifdef USE_COMBINATION_EXPLOSION_CHECK
1962 STATE_CHECK_VAL(scv, mem);
1965 STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep);
1966 n =
enclen(encode, s, end);
1980 STATE_CHECK_VAL(scv, mem);
1983 STACK_PUSH_ALT_WITH_STATE_CHECK(p, s, sprev, mem, pkeep);
1984 n =
enclen(encode, s, end);
2004 s +=
enclen(encode, s, end);
2013 s +=
enclen(encode, s, end);
2022 s +=
enclen(encode, s, end);
2031 s +=
enclen(encode, s, end);
2109 #ifdef USE_WORD_BEGIN_END
2186 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2192 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2205 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2211 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
2221 #ifdef USE_CRNL_AS_LINE_TERMINATOR
2224 ss +=
enclen(encode, ss, end);
2285 #ifdef USE_SUBEXP_CALL
2326 UChar *pstart, *pend;
2330 if (mem > num_mem)
goto fail;
2335 pstart =
STACK_AT(mem_start_stk[mem])->u.mem.pstr;
2337 pstart = (
UChar* )((
void* )mem_start_stk[mem]);
2340 ?
STACK_AT(mem_end_stk[mem])->u.mem.pstr
2341 : (
UChar* )((
void* )mem_end_stk[mem]));
2346 while (sprev + (len =
enclen(encode, sprev, end)) < s)
2358 UChar *pstart, *pend;
2362 if (mem > num_mem)
goto fail;
2367 pstart =
STACK_AT(mem_start_stk[mem])->u.mem.pstr;
2369 pstart = (
UChar* )((
void* )mem_start_stk[mem]);
2372 ?
STACK_AT(mem_end_stk[mem])->u.mem.pstr
2373 : (
UChar* )((
void* )mem_end_stk[mem]));
2378 while (sprev + (len =
enclen(encode, sprev, end)) < s)
2389 UChar *pstart, *pend, *swork;
2392 for (i = 0; i < tlen; i++) {
2399 pstart =
STACK_AT(mem_start_stk[mem])->u.mem.pstr;
2401 pstart = (
UChar* )((
void* )mem_start_stk[mem]);
2404 ?
STACK_AT(mem_end_stk[mem])->u.mem.pstr
2405 : (
UChar* )((
void* )mem_end_stk[mem]));
2411 if (is_fail)
continue;
2413 while (sprev + (len =
enclen(encode, sprev, end)) < s)
2419 if (i == tlen)
goto fail;
2428 UChar *pstart, *pend, *swork;
2431 for (i = 0; i < tlen; i++) {
2438 pstart =
STACK_AT(mem_start_stk[mem])->u.mem.pstr;
2440 pstart = (
UChar* )((
void* )mem_start_stk[mem]);
2443 ?
STACK_AT(mem_end_stk[mem])->u.mem.pstr
2444 : (
UChar* )((
void* )mem_end_stk[mem]));
2450 if (is_fail)
continue;
2452 while (sprev + (len =
enclen(encode, sprev, end)) < s)
2458 if (i == tlen)
goto fail;
2464 #ifdef USE_BACKREF_WITH_LEVEL
2477 , case_fold_flag, (
int )level, (
int )tlen, p, &s, end)) {
2478 while (sprev + (len =
enclen(encode, sprev, end)) < s)
2523 #ifdef ONIG_DEBUG_MATCH
2524 fprintf(stderr,
"NULL_CHECK_END: skip id:%d, s:%"PRIdPTR
" (%p)\n",
2541 goto unexpected_bytecode_error;
2550 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
2558 #ifdef ONIG_DEBUG_MATCH
2559 fprintf(stderr,
"NULL_CHECK_END_MEMST: skip id:%d, s:%"PRIdPTR
" (%p)\n",
2562 if (isnull == -1)
goto fail;
2563 goto null_check_found;
2571 #ifdef USE_SUBEXP_CALL
2578 #ifdef USE_MONOMANIAC_CHECK_CAPTURES_IN_ENDLESS_REPEAT
2584 #ifdef ONIG_DEBUG_MATCH
2585 fprintf(stderr,
"NULL_CHECK_END_MEMST_PUSH: skip id:%d, s:%"PRIdPTR
" (%p)\n",
2588 if (isnull == -1)
goto fail;
2589 goto null_check_found;
2615 #ifdef USE_COMBINATION_EXPLOSION_CHECK
2618 STATE_CHECK_VAL(scv, mem);
2622 STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem, pkeep);
2630 STATE_CHECK_VAL(scv, mem);
2635 STACK_PUSH_ALT_WITH_STATE_CHECK(p + addr, s, sprev, mem, pkeep);
2643 STATE_CHECK_VAL(scv, mem);
2646 STACK_PUSH_STATE_CHECK(s, mem);
2721 si = repeat_stk[mem];
2751 si = repeat_stk[mem];
2793 sprev = stkp->
u.
state.pstr_prev;
2856 #ifdef USE_SUBEXP_CALL
2876 if ((mem > num_mem) ||
2896 sprev = stk->
u.
state.pstr_prev;
2897 pkeep = stk->
u.
state.pkeep;
2899 #ifdef USE_COMBINATION_EXPLOSION_CHECK
2900 if (stk->
u.
state.state_check != 0) {
2911 goto bytecode_error;
2931 unexpected_bytecode_error:
2943 end = (
UChar* )text_end;
2944 end -= target_end - target - 1;
2945 if (end > text_range)
2954 if (*s == *target) {
2957 if (target_end == t ||
memcmp(t, p, target_end - t) == 0)
2965 if (*s == *target) {
2968 if (target_end == t ||
memcmp(t, p, target_end - t) == 0)
2971 s +=
enclen(enc, s, text_end);
2988 while (lowlen > 0) {
2989 if (*t++ != *q++)
return 0;
3004 end = (
UChar* )text_end;
3005 end -= target_end - target - 1;
3006 if (end > text_range)
3016 s +=
enclen(enc, s, text_end);
3025 const UChar* text_end,
const UChar* text_start)
3029 s = (
UChar* )text_end;
3030 s -= (target_end -
target);
3032 s = (
UChar* )text_start;
3037 if (*s == *target) {
3040 while (t < target_end) {
3045 if (t == target_end)
3058 const UChar* text_end,
const UChar* text_start)
3062 s = (
UChar* )text_end;
3063 s -= (target_end -
target);
3065 s = (
UChar* )text_start;
3071 target, target_end, s, text_end))
3080 #ifndef USE_SUNDAY_QUICK_SEARCH
3085 const UChar* text_range)
3089 ptrdiff_t skip, tlen1;
3091 #ifdef ONIG_DEBUG_SEARCH
3092 fprintf(stderr,
"bm_search_notrev: text: %"PRIuPTR
" (%p), text_end: %"PRIuPTR
" (%p), text_range: %"PRIuPTR
" (%p)\n",
3093 text, text, text_end, text_end, text_range, text_range);
3096 tail = target_end - 1;
3099 if (end + tlen1 > text_end)
3100 end = text_end - tlen1;
3109 if (t == target)
return (
UChar* )
s;
3112 skip = reg->
map[*se];
3116 }
while ((s - t) < skip && s < end);
3124 if (t == target)
return (
UChar* )
s;
3131 }
while ((s - t) < skip && s < end);
3146 #ifdef ONIG_DEBUG_SEARCH
3147 fprintf(stderr,
"bm_search: text: %"PRIuPTR
", text_end: %"PRIuPTR
", text_range: %"PRIuPTR
"\n",
3148 text, text_end, text_range);
3151 end = text_range + (target_end -
target) - 1;
3155 tail = target_end - 1;
3156 s = text + (target_end -
target) - 1;
3161 #ifdef ONIG_DEBUG_SEARCH
3162 fprintf(stderr,
"bm_search_loop: pos: %d %s\n",
3163 (
int)(s - text), s);
3166 if (t == target)
return (
UChar* )
p;
3177 if (t == target)
return (
UChar* )
p;
3190 const UChar* text_range)
3194 ptrdiff_t skip, tlen1;
3198 #ifdef ONIG_DEBUG_SEARCH
3199 fprintf(stderr,
"bm_search_notrev_ic: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
3200 (
int )text, text, (
int )text_end, text_end, (
int )text_range, text_range);
3203 tail = target_end - 1;
3206 if (end + tlen1 > text_end)
3207 end = text_end - tlen1;
3217 skip = reg->
map[*se];
3221 }
while ((s - t) < skip && s < end);
3234 }
while ((s - t) < skip && s < end);
3251 #ifdef ONIG_DEBUG_SEARCH
3252 fprintf(stderr,
"bm_search_ic: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
3253 (
int )text, text, (
int )text_end, text_end, (
int )text_range, text_range);
3256 end = text_range + (target_end -
target) - 1;
3260 tail = target_end - 1;
3261 s = text + (target_end -
target) - 1;
3264 p = s - (target_end -
target) + 1;
3273 p = s - (target_end -
target) + 1;
3289 const UChar* text_range)
3293 ptrdiff_t skip, tlen1;
3296 #ifdef ONIG_DEBUG_SEARCH
3297 fprintf(stderr,
"bm_search_notrev: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
3298 (
int )text, text, (
int )text_end, text_end, (
int )text_range, text_range);
3301 tail = target_end - 1;
3304 if (end + tlen1 > text_end)
3305 end = text_end - tlen1;
3314 if (t == target)
return (
UChar* )
s;
3317 if (s + 1 >= end)
break;
3318 skip = reg->
map[se[1]];
3321 s +=
enclen(enc, s, end);
3322 }
while ((s - t) < skip && s < end);
3330 if (t == target)
return (
UChar* )
s;
3333 if (s + 1 >= end)
break;
3337 s +=
enclen(enc, s, end);
3338 }
while ((s - t) < skip && s < end);
3354 tail = target_end - 1;
3356 end = text_range + tlen1;
3366 if (t == target)
return (
UChar* )
p;
3369 if (s + 1 >= end)
break;
3370 s += reg->
map[s[1]];
3378 if (t == target)
return (
UChar* )
p;
3381 if (s + 1 >= end)
break;
3392 const UChar* text_range)
3396 ptrdiff_t skip, tlen1;
3400 #ifdef ONIG_DEBUG_SEARCH
3401 fprintf(stderr,
"bm_search_notrev_ic: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
3402 (
int )text, text, (
int )text_end, text_end, (
int )text_range, text_range);
3405 tail = target_end - 1;
3408 if (end + tlen1 > text_end)
3409 end = text_end - tlen1;
3419 if (s + 1 >= end)
break;
3420 skip = reg->
map[se[1]];
3423 s +=
enclen(enc, s, end);
3424 }
while ((s - t) < skip && s < end);
3433 if (s + 1 >= end)
break;
3437 s +=
enclen(enc, s, end);
3438 }
while ((s - t) < skip && s < end);
3456 #ifdef ONIG_DEBUG_SEARCH
3457 fprintf(stderr,
"bm_search_ic: text: %d (%p), text_end: %d (%p), text_range: %d (%p)\n",
3458 (
int )text, text, (
int )text_end, text_end, (
int )text_range, text_range);
3461 tail = target_end - 1;
3463 end = text_range + tlen1;
3474 if (s + 1 >= end)
break;
3475 s += reg->
map[s[1]];
3484 if (s + 1 >= end)
break;
3503 len = (
int )(end - s);
3507 for (i = len - 1; i > 0; i--)
3516 const UChar* text_end,
const UChar* text_start)
3520 s = text_end - (target_end -
target);
3529 while (t < target_end && *p == *t) {
3532 if (t == target_end)
3546 const UChar *s = text;
3548 while (s < text_range) {
3549 if (map[*s])
return (
UChar* )
s;
3551 s +=
enclen(enc, s, text_end);
3559 const UChar* text_start,
const UChar* text_end)
3561 const UChar *s = text_start;
3564 if (map[*s])
return (
UChar* )
s;
3579 #if defined(USE_RECOMPILE_API) && defined(USE_MULTI_THREAD_SYSTEM)
3605 #ifdef USE_COMBINATION_EXPLOSION_CHECK
3607 int offset = at -
str;
3625 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
3642 #ifdef ONIG_DEBUG_SEARCH
3643 fprintf(stderr,
"forward_search_range: str: %"PRIuPTR
" (%p), end: %"PRIuPTR
" (%p), s: %"PRIuPTR
" (%p), range: %"PRIuPTR
" (%p)\n",
3644 str, str, end, end, s, s, range, range);
3648 if (reg->
dmin > 0) {
3654 while (p < q) p +=
enclen(reg->
enc, p, end);
3689 if (p && p < range) {
3690 if (p - reg->
dmin < s) {
3704 (pprev ? pprev : str), p, end);
3712 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3714 (pprev ? pprev : str),
p);
3725 if (reg->
dmax == 0) {
3732 (pprev ? pprev : str), p, end);
3737 *low = p - reg->
dmax;
3740 *low, end, (
const UChar** )low_prev);
3741 if (low_prev &&
IS_NULL(*low_prev))
3743 (pprev ? pprev : s), *low, end);
3748 (pprev ? pprev : str), *low, end);
3753 *high = p - reg->
dmin;
3755 #ifdef ONIG_DEBUG_SEARCH
3757 "forward_search_range success: low: %d, high: %d, dmin: %d, dmax: %d\n",
3758 (
int )(*low - str), (
int )(*high - str), reg->
dmin, reg->
dmax);
3769 #define BM_BACKWARD_SEARCH_LENGTH_THRESHOLD 100
3787 range, adjrange, end, p);
3795 range, adjrange, end, p);
3834 #ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
3854 *low = p - reg->
dmax;
3855 *high = p - reg->
dmin;
3859 #ifdef ONIG_DEBUG_SEARCH
3860 fprintf(stderr,
"backward_search_range: low: %d, high: %d\n",
3861 (
int )(*low - str), (
int )(*high - str));
3867 #ifdef ONIG_DEBUG_SEARCH
3868 fprintf(stderr,
"backward_search_range: fail.\n");
3878 return onig_search_gpos(reg, str, end, start, start, range, region, option);
3883 const UChar* global_pos,
3889 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
3890 const UChar *orig_start = start;
3894 #if defined(USE_RECOMPILE_API) && defined(USE_MULTI_THREAD_SYSTEM)
3919 #ifdef ONIG_DEBUG_SEARCH
3921 "onig_search (entry point): str: %"PRIuPTR
" (%p), end: %"PRIuPTR
", start: %"PRIuPTR
", range: %"PRIuPTR
"\n",
3922 str, str, end - str, start - str, range - str);
3931 if (r)
goto finish_no_msa;
3934 if (start > end || start < str)
goto mismatch_no_msa;
3937 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
3938 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
3939 #define MATCH_AND_RETURN_CHECK(upper_range) \
3940 r = match_at(reg, str, end, (upper_range), s, prev, &msa); \
3941 if (r != ONIG_MISMATCH) {\
3943 if (! IS_FIND_LONGEST(reg->options)) {\
3950 #define MATCH_AND_RETURN_CHECK(upper_range) \
3951 r = match_at(reg, str, end, (upper_range), s, prev, &msa); \
3952 if (r != ONIG_MISMATCH) {\
3960 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
3961 #define MATCH_AND_RETURN_CHECK(none) \
3962 r = match_at(reg, str, end, s, prev, &msa);\
3963 if (r != ONIG_MISMATCH) {\
3965 if (! IS_FIND_LONGEST(reg->options)) {\
3972 #define MATCH_AND_RETURN_CHECK(none) \
3973 r = match_at(reg, str, end, s, prev, &msa);\
3974 if (r != ONIG_MISMATCH) {\
3985 if (reg->
anchor != 0 && str < end) {
3986 UChar *min_semi_end, *max_semi_end;
3998 if (range > start) {
3999 if (start != str)
goto mismatch_no_msa;
4008 goto mismatch_no_msa;
4012 min_semi_end = max_semi_end = (
UChar* )end;
4016 goto mismatch_no_msa;
4018 if (range > start) {
4028 if (start > range)
goto mismatch_no_msa;
4040 if (range > start)
goto mismatch_no_msa;
4046 max_semi_end = (
UChar* )end;
4048 min_semi_end = pre_end;
4050 #ifdef USE_CRNL_AS_LINE_TERMINATOR
4055 min_semi_end = pre_end;
4058 if (min_semi_end > str && start <= min_semi_end) {
4063 min_semi_end = (
UChar* )end;
4069 goto begin_position;
4073 else if (str == end) {
4074 static const UChar address_for_empty_string[] =
"";
4076 #ifdef ONIG_DEBUG_SEARCH
4077 fprintf(stderr,
"onig_search: empty string.\n");
4081 start = end = str = address_for_empty_string;
4086 #ifdef USE_COMBINATION_EXPLOSION_CHECK
4087 msa.state_check_buff = (
void* )0;
4088 msa.state_check_buff_size = 0;
4093 goto mismatch_no_msa;
4096 #ifdef ONIG_DEBUG_SEARCH
4097 fprintf(stderr,
"onig_search(apply anchor): end: %d, start: %d, range: %d\n",
4098 (
int )(end - str), (
int )(start - str), (
int )(range - str));
4102 #ifdef USE_COMBINATION_EXPLOSION_CHECK
4104 int offset = (
MIN(start, range) -
str);
4110 if (range > start) {
4117 UChar *sch_range, *low, *high, *low_prev;
4119 sch_range = (
UChar* )range;
4120 if (reg->
dmax != 0) {
4122 sch_range = (
UChar* )end;
4124 sch_range += reg->
dmax;
4125 if (sch_range > end) sch_range = (
UChar* )end;
4135 &low, &high, &low_prev))
goto mismatch;
4145 }
while (s < range);
4150 &low, &high, (
UChar** )
NULL))
goto mismatch;
4167 }
while (s < range);
4177 }
while (s < range);
4184 #ifdef USE_MATCH_RANGE_MUST_BE_INSIDE_OF_SPECIFIED_RANGE
4185 if (orig_start < end)
4186 orig_start +=
enclen(reg->
enc, orig_start, end);
4190 UChar *low, *high, *adjrange, *sch_start;
4195 adjrange = (
UChar* )end;
4200 sch_start = s + reg->
dmax;
4201 if (sch_start > end) sch_start = (
UChar* )end;
4214 }
while (s >= range);
4221 if (reg->
dmax != 0) {
4223 sch_start = (
UChar* )end;
4225 sch_start += reg->
dmax;
4226 if (sch_start > end) sch_start = (
UChar* )end;
4229 start, sch_start, end);
4233 &low, &high) <= 0)
goto mismatch;
4241 }
while (s >= range);
4245 #ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
4271 fprintf(stderr,
"onig_search: error %d\n", r);
4281 fprintf(stderr,
"onig_search: error %d\n", r);
4324 #ifdef USE_CAPTURE_HISTORY
#define STACK_PUSH_POS_NOT(pat, s, sprev, keep)
int onig_region_resize(OnigRegion *region, int n)
#define ANCHOR_ANYCHAR_STAR_ML
#define IS_POSIX_REGION(option)
#define BIT_STATUS_AT(stats, n)
static int mem_is_in_memp(int mem, int num, UChar *memp)
union _OnigStackType::@121 u
unsigned int onig_get_match_stack_limit_size(void)
#define STACK_RETURN(addr)
static UChar * slow_search_backward(OnigEncoding enc, UChar *target, UChar *target_end, const UChar *text, const UChar *adjust_text, const UChar *text_end, const UChar *text_start)
unsigned int OnigOptionType
static int str_lower_case_match(OnigEncoding enc, int case_fold_flag, const UChar *t, const UChar *tend, const UChar *p, const UChar *end)
#define STACK_GET_MEM_START(mnum, k)
#define DATA_ENSURE_CHECK(n)
unsigned char * exact_end
#define IS_NOTEOL(option)
#define STACK_PUSH_STOP_BT
size_t strlen(const char *)
#define STACK_PUSH_MEM_END_MARK(mnum)
static int forward_search_range(regex_t *reg, const UChar *str, const UChar *end, UChar *s, UChar *range, UChar **low, UChar **high, UChar **low_prev)
void onig_print_compiled_byte_code(FILE *f, UChar *bp, UChar *bpend, UChar **nextp, OnigEncoding enc)
#define ONIG_OPTIMIZE_EXACT
#define STACK_POP_TIL_POS_NOT
#define ONIGERR_MATCH_STACK_LIMIT_OVER
static int onig_region_resize_clear(OnigRegion *region, int n)
UChar * onigenc_get_right_adjust_char_head(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end)
unsigned int OnigCodePoint
#define STACK_PUSH_ENSURED(stack_type, pat)
#define ONIGENC_IS_MBC_NEWLINE(enc, p, end)
#define ANCHOR_BEGIN_LINE
#define ONIGENC_IS_SINGLEBYTE(enc)
int onig_set_match_stack_limit_size(unsigned int size)
void onig_region_copy(OnigRegion *to, OnigRegion *from)
int onig_is_in_code_range(const UChar *p, OnigCodePoint code)
#define GET_STATE_CHECK_NUM_INC(num, p)
#define ONIG_CHAR_TABLE_SIZE
static int backref_match_at_nested_level(regex_t *reg, OnigStackType *top, OnigStackType *stk_base, int ignore_case, int case_fold_flag, int nest, int mem_num, UChar *memp, UChar **s, const UChar *send)
#define ONIGENC_IS_MBC_HEAD(enc, p, e)
#define MATCH_ARG_INIT(msa, arg_option, arg_region, arg_start, arg_gpos)
OnigOptionType onig_get_options(regex_t *reg)
OnigRepeatRange * repeat_range
static OnigPosition match_at(regex_t *reg, const UChar *str, const UChar *end, const UChar *sstart, UChar *sprev, OnigMatchArg *msa)
#define ONIG_STATE_NORMAL
#define USE_POSIX_API_REGION_OPTION
#define ONIGENC_MBC_CASE_FOLD(enc, flag, pp, end, buf)
#define STACK_PUSH_MEM_END(mnum, s)
static int set_bm_backward_skip(UChar *s, UChar *end, OnigEncoding enc ARG_UNUSED, int **skip)
void onig_region_clear(OnigRegion *region)
#define ONIGERR_INVALID_ARGUMENT
#define STACK_NULL_CHECK_MEMST(isnull, id, s, reg)
#define STACK_PUSH_NULL_CHECK_END(cnum)
#define ONIG_OPTIMIZE_EXACT_IC
#define MATCH_AND_RETURN_CHECK(none)
UChar * onigenc_get_right_adjust_char_head_with_prev(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end, const UChar **prev)
#define GET_OPTION_INC(option, p)
#define ANCHOR_BEGIN_POSITION
#define GET_LENGTH_INC(len, p)
#define ONIGENC_IS_MBC_WORD(enc, s, end)
unsigned int OnigCaseFoldType
int onig_number_of_captures(regex_t *reg)
unsigned int bt_mem_start
#define STACK_PUSH_LOOK_BEHIND_NOT(pat, s, sprev, keep)
#define INIT_MATCH_STACK_SIZE
#define STACK_STOP_BT_END
static UChar * map_search(OnigEncoding enc, UChar map[], const UChar *text, const UChar *text_range, const UChar *text_end)
#define STACK_GET_REPEAT(id, k)
#define MATCH_ARG_FREE(msa)
UChar * onigenc_get_prev_char_head(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end)
static unsigned int MatchStackLimitSize
void onig_chain_reduce(regex_t *reg)
#define ONIGENC_IS_MBC_CRNL(enc, p, end)
#define ONIGERR_STACK_BUG
#define GET_MEMNUM_INC(num, p)
#define enclen(enc, p, e)
#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV_IC
#define THREAD_ATOMIC_END
int onig_region_set(OnigRegion *region, int at, int beg, int end)
void onig_region_init(OnigRegion *region)
#define CHECK_INTERRUPT_IN_MATCH_AT
OnigCaseFoldType case_fold_flag
static UChar * bm_search_notrev(regex_t *reg, const UChar *target, const UChar *target_end, const UChar *text, const UChar *text_end, const UChar *text_range)
struct _OnigStackType::@121::@123 repeat
#define IS_FIND_LONGEST(option)
#define DATA_ENSURE_CHECK1
OnigEncoding onig_get_encoding(regex_t *reg)
#define ALIGNMENT_RIGHT(addr)
#define ONIG_REGION_NOTPOS
struct OnigCaptureTreeNodeStruct ** childs
#define BITSET_AT(bs, pos)
unsigned char map[ONIG_CHAR_TABLE_SIZE]
#define CHECK_NULL_RETURN_MEMERR(p)
void onig_region_free(OnigRegion *r, int free_self)
#define ONIG_OPTIMIZE_MAP
#define ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s, end)
#define STACK_INIT(alloc_addr, ptr_num, stack_num)
struct _OnigStackType::@121::@122 state
#define GET_STACK_INDEX(stk)
#define range(low, item, hi)
static UChar * bm_search_ic(regex_t *reg, const UChar *target, const UChar *target_end, const UChar *text, const UChar *text_end, const UChar *text_range)
unsigned char buf[MIME_BUF_SIZE]
#define DEFAULT_MATCH_STACK_LIMIT_SIZE
static int stack_double(OnigStackType **arg_stk_base, OnigStackType **arg_stk_end, OnigStackType **arg_stk, OnigStackType *stk_alloc, OnigMatchArg *msa)
static UChar * slow_search_ic(OnigEncoding enc, int case_fold_flag, UChar *target, UChar *target_end, const UChar *text, const UChar *text_end, UChar *text_range)
#define ONIG_OPTIMIZE_EXACT_BM_IC
#define STACK_PUSH_CALL_FRAME(pat)
#define ONIG_INFINITE_DISTANCE
OnigPosition onig_search_gpos(regex_t *reg, const UChar *str, const UChar *end, const UChar *global_pos, const UChar *start, const UChar *range, OnigRegion *region, OnigOptionType option)
#define THREAD_ATOMIC_START
#define STRING_CMP_IC(case_fold_flag, s1, ps2, len, text_end)
#define STRING_CMP(s1, s2, len)
#define ONIGENC_IS_MBC_ASCII_WORD(enc, s, end)
#define STACK_PUSH_RETURN
#define ONIGENC_IS_MBC_NEWLINE_EX(enc, p, start, end, option, check_prev)
#define THREAD_PASS_LIMIT_COUNT
#define ONIG_STATE_INC(reg)
OnigCaptureTreeNode * history_root
#define STRING_CMP_VALUE(s1, s2, len, is_fail)
#define STACK_NULL_CHECK(isnull, id, s)
#define ANCHOR_SEMI_END_BUF
#define ONIG_OPTIMIZE_NONE
int memcmp(const void *s1, const void *s2, size_t len)
#define STACK_PUSH_POS(s, sprev, keep)
static UChar * bm_search_backward(regex_t *reg, const UChar *target, const UChar *target_end, const UChar *text, const UChar *adjust_text, const UChar *text_end, const UChar *text_start)
const OnigSyntaxType * syntax
#define ANCHOR_ANYCHAR_STAR
#define CHECK_NULL_RETURN(p)
#define ONIG_MAX_CAPTURE_HISTORY_GROUP
static int backward_search_range(regex_t *reg, const UChar *str, const UChar *end, UChar *s, const UChar *range, UChar *adjrange, UChar **low, UChar **high)
static UChar * map_search_backward(OnigEncoding enc, UChar map[], const UChar *text, const UChar *adjust_text, const UChar *text_start, const UChar *text_end)
OnigPosition onig_search(regex_t *reg, const UChar *str, const UChar *end, const UChar *start, const UChar *range, OnigRegion *region, OnigOptionType option)
#define STACK_PUSH_NULL_CHECK_START(cnum, s)
#define SIZE_OP_SET_OPTION
OnigPosition onig_match(regex_t *reg, const UChar *str, const UChar *end, const UChar *at, OnigRegion *region, OnigOptionType option)
#define ONIGENC_MBC_TO_CODE(enc, p, end)
#define GET_RELADDR_INC(addr, p)
#define STACK_PUSH_MEM_START(mnum, s)
static UChar * bm_search(regex_t *reg, const UChar *target, const UChar *target_end, const UChar *text, const UChar *text_end, const UChar *text_range)
static UChar * slow_search(OnigEncoding enc, UChar *target, UChar *target_end, const UChar *text, const UChar *text_end, UChar *text_range)
#define IS_NEWLINE_CRLF(option)
#define ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT
unsigned int capture_history
int onig_number_of_capture_histories(regex_t *reg)
#define IS_FIND_CONDITION(option)
void onig_copy_encoding(OnigEncoding to, OnigEncoding from)
#define USE_CRNL_AS_LINE_TERMINATOR
#define ONIGERR_UNEXPECTED_BYTECODE
OnigCaseFoldType onig_get_case_fold_flag(regex_t *reg)
#define STRING_CMP_VALUE_IC(case_fold_flag, s1, ps2, len, text_end, is_fail)
#define ONIGENC_MBC_CASE_FOLD_MAXLEN
#define STACK_PUSH_ALT(pat, s, sprev, keep)
#define IS_NOTBOL(option)
int onig_is_code_in_cc_len(int elen, OnigCodePoint code, CClassNode *cc)
static UChar * slow_search_backward_ic(OnigEncoding enc, int case_fold_flag, UChar *target, UChar *target_end, const UChar *text, const UChar *adjust_text, const UChar *text_end, const UChar *text_start)
#define ONIG_OPTIMIZE_EXACT_BM_NOT_REV
struct _OnigStackType::@121::@125 mem
OnigRegion * onig_region_new(void)
#define ANCHOR_LOOK_BEHIND
#define ONIGENC_STEP_BACK(enc, start, s, end, n)
#define STACK_PUSH_REPEAT_INC(sindex)
#define GET_POINTER_INC(ptr, p)
static UChar * bm_search_notrev_ic(regex_t *reg, const UChar *target, const UChar *target_end, const UChar *text, const UChar *text_end, const UChar *text_range)
#define STK_STATE_CHECK_MARK
#define BM_BACKWARD_SEARCH_LENGTH_THRESHOLD
#define ONIG_OPTIMIZE_EXACT_BM
#define STACK_POP_TIL_LOOK_BEHIND_NOT
const OnigSyntaxType * onig_get_syntax(regex_t *reg)
#define INVALID_STACK_INDEX
stack
#define STACK_NULL_CHECK_REC(isnull, id, s)
#define IS_FIND_NOT_EMPTY(option)
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
static int is_mbc_newline_ex(OnigEncoding enc, const UChar *p, const UChar *start, const UChar *end, OnigOptionType option, int check_prev)
static int string_cmp_ic(OnigEncoding enc, int case_fold_flag, UChar *s1, UChar **ps2, OnigDistance mblen, const UChar *text_end)
#define GET_ABSADDR_INC(addr, p)
#define ONIGERR_UNDEFINED_BYTECODE
struct re_pattern_buffer * chain
#define STACK_PUSH_REPEAT(id, pat)
#define ONIG_STATE_DEC_THREAD(reg)
#define STACK_NULL_CHECK_MEMST_REC(isnull, id, s, reg)