+++ /dev/null
-/**********************************************************************\r
- regexec.c - Oniguruma (regular expression library)\r
-**********************************************************************/\r
-/*-\r
- * Copyright (c) 2002-2019 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>\r
- * All rights reserved.\r
- *\r
- * Redistribution and use in source and binary forms, with or without\r
- * modification, are permitted provided that the following conditions\r
- * are met:\r
- * 1. Redistributions of source code must retain the above copyright\r
- * notice, this list of conditions and the following disclaimer.\r
- * 2. Redistributions in binary form must reproduce the above copyright\r
- * notice, this list of conditions and the following disclaimer in the\r
- * documentation and/or other materials provided with the distribution.\r
- *\r
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
- * SUCH DAMAGE.\r
- */\r
-#include "regint.h"\r
-\r
-#define IS_MBC_WORD_ASCII_MODE(enc,s,end,mode) \\r
- ((mode) == 0 ? ONIGENC_IS_MBC_WORD(enc,s,end) : ONIGENC_IS_MBC_WORD_ASCII(enc,s,end))\r
-\r
-#ifdef USE_CRNL_AS_LINE_TERMINATOR\r
-#define ONIGENC_IS_MBC_CRNL(enc,p,end) \\r
- (ONIGENC_MBC_TO_CODE(enc,p,end) == 13 && \\r
- ONIGENC_IS_MBC_NEWLINE(enc,(p+enclen(enc,p)),end))\r
-#endif\r
-\r
-#define CHECK_INTERRUPT_IN_MATCH\r
-\r
-#ifdef USE_CALLOUT\r
-typedef struct {\r
- int last_match_at_call_counter;\r
- struct {\r
- OnigType type;\r
- OnigValue val;\r
- } slot[ONIG_CALLOUT_DATA_SLOT_NUM];\r
-} CalloutData;\r
-#endif\r
-\r
-struct OnigMatchParamStruct {\r
- unsigned int match_stack_limit;\r
- unsigned long retry_limit_in_match;\r
-#ifdef USE_CALLOUT\r
- OnigCalloutFunc progress_callout_of_contents;\r
- OnigCalloutFunc retraction_callout_of_contents;\r
- int match_at_call_counter;\r
- void* callout_user_data;\r
- CalloutData* callout_data;\r
- int callout_data_alloc_num;\r
-#endif\r
-};\r
-\r
-extern int\r
-onig_set_match_stack_limit_size_of_match_param(OnigMatchParam* param,\r
- unsigned int limit)\r
-{\r
- param->match_stack_limit = limit;\r
- return ONIG_NORMAL;\r
-}\r
-\r
-extern int\r
-onig_set_retry_limit_in_match_of_match_param(OnigMatchParam* param,\r
- unsigned long limit)\r
-{\r
- param->retry_limit_in_match = limit;\r
- return ONIG_NORMAL;\r
-}\r
-\r
-extern int\r
-onig_set_progress_callout_of_match_param(OnigMatchParam* param, OnigCalloutFunc f)\r
-{\r
-#ifdef USE_CALLOUT\r
- param->progress_callout_of_contents = f;\r
- return ONIG_NORMAL;\r
-#else\r
- return ONIG_NO_SUPPORT_CONFIG;\r
-#endif\r
-}\r
-\r
-extern int\r
-onig_set_retraction_callout_of_match_param(OnigMatchParam* param, OnigCalloutFunc f)\r
-{\r
-#ifdef USE_CALLOUT\r
- param->retraction_callout_of_contents = f;\r
- return ONIG_NORMAL;\r
-#else\r
- return ONIG_NO_SUPPORT_CONFIG;\r
-#endif\r
-}\r
-\r
-extern int\r
-onig_set_callout_user_data_of_match_param(OnigMatchParam* param, void* user_data)\r
-{\r
-#ifdef USE_CALLOUT\r
- param->callout_user_data = user_data;\r
- return ONIG_NORMAL;\r
-#else\r
- return ONIG_NO_SUPPORT_CONFIG;\r
-#endif\r
-}\r
-\r
-\r
-typedef struct {\r
- void* stack_p;\r
- int stack_n;\r
- OnigOptionType options;\r
- OnigRegion* region;\r
- int ptr_num;\r
- const UChar* start; /* search start position (for \G: BEGIN_POSITION) */\r
- unsigned int match_stack_limit;\r
- unsigned long retry_limit_in_match;\r
- OnigMatchParam* mp;\r
-#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE\r
- int best_len; /* for ONIG_OPTION_FIND_LONGEST */\r
- UChar* best_s;\r
-#endif\r
-} MatchArg;\r
-\r
-\r
-#ifdef ONIG_DEBUG\r
-\r
-/* arguments type */\r
-typedef enum {\r
- ARG_SPECIAL = -1,\r
- ARG_NON = 0,\r
- ARG_RELADDR = 1,\r
- ARG_ABSADDR = 2,\r
- ARG_LENGTH = 3,\r
- ARG_MEMNUM = 4,\r
- ARG_OPTION = 5,\r
- ARG_MODE = 6\r
-} OpArgType;\r
-\r
-typedef struct {\r
- short int opcode;\r
- char* name;\r
-} OpInfoType;\r
-\r
-static OpInfoType OpInfo[] = {\r
- { OP_FINISH, "finish" },\r
- { OP_END, "end" },\r
- { OP_EXACT1, "exact1" },\r
- { OP_EXACT2, "exact2" },\r
- { OP_EXACT3, "exact3" },\r
- { OP_EXACT4, "exact4" },\r
- { OP_EXACT5, "exact5" },\r
- { OP_EXACTN, "exactn" },\r
- { OP_EXACTMB2N1, "exactmb2-n1" },\r
- { OP_EXACTMB2N2, "exactmb2-n2" },\r
- { OP_EXACTMB2N3, "exactmb2-n3" },\r
- { OP_EXACTMB2N, "exactmb2-n" },\r
- { OP_EXACTMB3N, "exactmb3n" },\r
- { OP_EXACTMBN, "exactmbn" },\r
- { OP_EXACT1_IC, "exact1-ic" },\r
- { OP_EXACTN_IC, "exactn-ic" },\r
- { OP_CCLASS, "cclass" },\r
- { OP_CCLASS_MB, "cclass-mb" },\r
- { OP_CCLASS_MIX, "cclass-mix" },\r
- { OP_CCLASS_NOT, "cclass-not" },\r
- { OP_CCLASS_MB_NOT, "cclass-mb-not" },\r
- { OP_CCLASS_MIX_NOT, "cclass-mix-not" },\r
- { OP_ANYCHAR, "anychar" },\r
- { OP_ANYCHAR_ML, "anychar-ml" },\r
- { OP_ANYCHAR_STAR, "anychar*" },\r
- { OP_ANYCHAR_ML_STAR, "anychar-ml*" },\r
- { OP_ANYCHAR_STAR_PEEK_NEXT, "anychar*-peek-next" },\r
- { OP_ANYCHAR_ML_STAR_PEEK_NEXT, "anychar-ml*-peek-next" },\r
- { OP_WORD, "word" },\r
- { OP_WORD_ASCII, "word-ascii" },\r
- { OP_NO_WORD, "not-word" },\r
- { OP_NO_WORD_ASCII, "not-word-ascii" },\r
- { OP_WORD_BOUNDARY, "word-boundary" },\r
- { OP_NO_WORD_BOUNDARY, "not-word-boundary" },\r
- { OP_WORD_BEGIN, "word-begin" },\r
- { OP_WORD_END, "word-end" },\r
- { OP_TEXT_SEGMENT_BOUNDARY, "text-segment-boundary" },\r
- { OP_BEGIN_BUF, "begin-buf" },\r
- { OP_END_BUF, "end-buf" },\r
- { OP_BEGIN_LINE, "begin-line" },\r
- { OP_END_LINE, "end-line" },\r
- { OP_SEMI_END_BUF, "semi-end-buf" },\r
- { OP_BEGIN_POSITION, "begin-position" },\r
- { OP_BACKREF1, "backref1" },\r
- { OP_BACKREF2, "backref2" },\r
- { OP_BACKREF_N, "backref-n" },\r
- { OP_BACKREF_N_IC, "backref-n-ic" },\r
- { OP_BACKREF_MULTI, "backref_multi" },\r
- { OP_BACKREF_MULTI_IC, "backref_multi-ic" },\r
- { OP_BACKREF_WITH_LEVEL, "backref_with_level" },\r
- { OP_BACKREF_WITH_LEVEL_IC, "backref_with_level-c" },\r
- { OP_BACKREF_CHECK, "backref_check" },\r
- { OP_BACKREF_CHECK_WITH_LEVEL, "backref_check_with_level" },\r
- { OP_MEMORY_START_PUSH, "mem-start-push" },\r
- { OP_MEMORY_START, "mem-start" },\r
- { OP_MEMORY_END_PUSH, "mem-end-push" },\r
- { OP_MEMORY_END_PUSH_REC, "mem-end-push-rec" },\r
- { OP_MEMORY_END, "mem-end" },\r
- { OP_MEMORY_END_REC, "mem-end-rec" },\r
- { OP_FAIL, "fail" },\r
- { OP_JUMP, "jump" },\r
- { OP_PUSH, "push" },\r
- { OP_PUSH_SUPER, "push-super" },\r
- { OP_POP_OUT, "pop-out" },\r
-#ifdef USE_OP_PUSH_OR_JUMP_EXACT\r
- { OP_PUSH_OR_JUMP_EXACT1, "push-or-jump-e1" },\r
-#endif\r
- { OP_PUSH_IF_PEEK_NEXT, "push-if-peek-next" },\r
- { OP_REPEAT, "repeat" },\r
- { OP_REPEAT_NG, "repeat-ng" },\r
- { OP_REPEAT_INC, "repeat-inc" },\r
- { OP_REPEAT_INC_NG, "repeat-inc-ng" },\r
- { OP_REPEAT_INC_SG, "repeat-inc-sg" },\r
- { OP_REPEAT_INC_NG_SG, "repeat-inc-ng-sg" },\r
- { OP_EMPTY_CHECK_START, "empty-check-start" },\r
- { OP_EMPTY_CHECK_END, "empty-check-end" },\r
- { OP_EMPTY_CHECK_END_MEMST, "empty-check-end-memst" },\r
- { OP_EMPTY_CHECK_END_MEMST_PUSH,"empty-check-end-memst-push" },\r
- { OP_PREC_READ_START, "push-pos" },\r
- { OP_PREC_READ_END, "pop-pos" },\r
- { OP_PREC_READ_NOT_START, "prec-read-not-start" },\r
- { OP_PREC_READ_NOT_END, "prec-read-not-end" },\r
- { OP_ATOMIC_START, "atomic-start" },\r
- { OP_ATOMIC_END, "atomic-end" },\r
- { OP_LOOK_BEHIND, "look-behind" },\r
- { OP_LOOK_BEHIND_NOT_START, "look-behind-not-start" },\r
- { OP_LOOK_BEHIND_NOT_END, "look-behind-not-end" },\r
- { OP_CALL, "call" },\r
- { OP_RETURN, "return" },\r
- { OP_PUSH_SAVE_VAL, "push-save-val" },\r
- { OP_UPDATE_VAR, "update-var" },\r
-#ifdef USE_CALLOUT\r
- { OP_CALLOUT_CONTENTS, "callout-contents" },\r
- { OP_CALLOUT_NAME, "callout-name" },\r
-#endif\r
- { -1, "" }\r
-};\r
-\r
-static char*\r
-op2name(int opcode)\r
-{\r
- int i;\r
-\r
- for (i = 0; OpInfo[i].opcode >= 0; i++) {\r
- if (opcode == OpInfo[i].opcode) return OpInfo[i].name;\r
- }\r
-\r
- return "";\r
-}\r
-\r
-static void\r
-p_string(FILE* f, int len, UChar* s)\r
-{\r
- fputs(":", f);\r
- while (len-- > 0) { fputc(*s++, f); }\r
-}\r
-\r
-static void\r
-p_len_string(FILE* f, LengthType len, int mb_len, UChar* s)\r
-{\r
- int x = len * mb_len;\r
-\r
- fprintf(f, ":%d:", len);\r
- while (x-- > 0) { fputc(*s++, f); }\r
-}\r
-\r
-static void\r
-p_rel_addr(FILE* f, RelAddrType rel_addr, Operation* p, Operation* start)\r
-{\r
- RelAddrType curr = (RelAddrType )(p - start);\r
-\r
- fprintf(f, "{%d/%d}", rel_addr, curr + rel_addr);\r
-}\r
-\r
-static int\r
-bitset_on_num(BitSetRef bs)\r
-{\r
- int i, n;\r
-\r
- n = 0;\r
- for (i = 0; i < SINGLE_BYTE_SIZE; i++) {\r
- if (BITSET_AT(bs, i)) n++;\r
- }\r
-\r
- return n;\r
-}\r
-\r
-static void\r
-print_compiled_byte_code(FILE* f, regex_t* reg, int index,\r
- Operation* start, OnigEncoding enc)\r
-{\r
- int i, n;\r
- RelAddrType addr;\r
- LengthType len;\r
- MemNumType mem;\r
- OnigCodePoint code;\r
- ModeType mode;\r
- UChar *q;\r
- Operation* p;\r
- enum OpCode opcode;\r
-\r
- p = reg->ops + index;\r
-\r
-#ifdef USE_DIRECT_THREADED_CODE\r
- opcode = reg->ocs[index];\r
-#else\r
- opcode = p->opcode;\r
-#endif\r
-\r
- fprintf(f, "%s", op2name(opcode));\r
- switch (opcode) {\r
- case OP_EXACT1:\r
- p_string(f, 1, p->exact.s); break;\r
- case OP_EXACT2:\r
- p_string(f, 2, p->exact.s); break;\r
- case OP_EXACT3:\r
- p_string(f, 3, p->exact.s); break;\r
- case OP_EXACT4:\r
- p_string(f, 4, p->exact.s); break;\r
- case OP_EXACT5:\r
- p_string(f, 5, p->exact.s); break;\r
- case OP_EXACTN:\r
- len = p->exact_n.n;\r
- p_string(f, len, p->exact_n.s); break;\r
- case OP_EXACTMB2N1:\r
- p_string(f, 2, p->exact.s); break;\r
- case OP_EXACTMB2N2:\r
- p_string(f, 4, p->exact.s); break;\r
- case OP_EXACTMB2N3:\r
- p_string(f, 3, p->exact.s); break;\r
- case OP_EXACTMB2N:\r
- len = p->exact_n.n;\r
- p_len_string(f, len, 2, p->exact_n.s); break;\r
- case OP_EXACTMB3N:\r
- len = p->exact_n.n;\r
- p_len_string(f, len, 3, p->exact_n.s); break;\r
- case OP_EXACTMBN:\r
- {\r
- int mb_len;\r
-\r
- mb_len = p->exact_len_n.len;\r
- len = p->exact_len_n.n;\r
- q = p->exact_len_n.s;\r
- fprintf(f, ":%d:%d:", mb_len, len);\r
- n = len * mb_len;\r
- while (n-- > 0) { fputc(*q++, f); }\r
- }\r
- break;\r
- case OP_EXACT1_IC:\r
- len = enclen(enc, p->exact.s);\r
- p_string(f, len, p->exact.s);\r
- break;\r
- case OP_EXACTN_IC:\r
- len = p->exact_n.n;\r
- p_len_string(f, len, 1, p->exact_n.s);\r
- break;\r
-\r
- case OP_CCLASS:\r
- case OP_CCLASS_NOT:\r
- n = bitset_on_num(p->cclass.bsp);\r
- fprintf(f, ":%d", n);\r
- break;\r
- case OP_CCLASS_MB:\r
- case OP_CCLASS_MB_NOT:\r
- {\r
- OnigCodePoint ncode;\r
- OnigCodePoint* codes;\r
-\r
- codes = (OnigCodePoint* )p->cclass_mb.mb;\r
- GET_CODE_POINT(ncode, codes);\r
- codes++;\r
- GET_CODE_POINT(code, codes);\r
- fprintf(f, ":%u:%u", code, ncode);\r
- }\r
- break;\r
- case OP_CCLASS_MIX:\r
- case OP_CCLASS_MIX_NOT:\r
- {\r
- OnigCodePoint ncode;\r
- OnigCodePoint* codes;\r
-\r
- codes = (OnigCodePoint* )p->cclass_mix.mb;\r
- n = bitset_on_num(p->cclass_mix.bsp);\r
-\r
- GET_CODE_POINT(ncode, codes);\r
- codes++;\r
- GET_CODE_POINT(code, codes);\r
- fprintf(f, ":%d:%u:%u", n, code, ncode);\r
- }\r
- break;\r
-\r
- case OP_ANYCHAR_STAR_PEEK_NEXT:\r
- case OP_ANYCHAR_ML_STAR_PEEK_NEXT:\r
- p_string(f, 1, &(p->anychar_star_peek_next.c));\r
- break;\r
-\r
- case OP_WORD_BOUNDARY:\r
- case OP_NO_WORD_BOUNDARY:\r
- case OP_WORD_BEGIN:\r
- case OP_WORD_END:\r
- mode = p->word_boundary.mode;\r
- fprintf(f, ":%d", mode);\r
- break;\r
-\r
- case OP_BACKREF_N:\r
- case OP_BACKREF_N_IC:\r
- mem = p->backref_n.n1;\r
- fprintf(f, ":%d", mem);\r
- break;\r
- case OP_BACKREF_MULTI_IC:\r
- case OP_BACKREF_MULTI:\r
- case OP_BACKREF_CHECK:\r
- fputs(" ", f);\r
- n = p->backref_general.num;\r
- for (i = 0; i < n; i++) {\r
- mem = (n == 1) ? p->backref_general.n1 : p->backref_general.ns[i];\r
- if (i > 0) fputs(", ", f);\r
- fprintf(f, "%d", mem);\r
- }\r
- break;\r
- case OP_BACKREF_WITH_LEVEL:\r
- case OP_BACKREF_WITH_LEVEL_IC:\r
- case OP_BACKREF_CHECK_WITH_LEVEL:\r
- {\r
- LengthType level;\r
-\r
- level = p->backref_general.nest_level;\r
- fprintf(f, ":%d", level);\r
- fputs(" ", f);\r
- n = p->backref_general.num;\r
- for (i = 0; i < n; i++) {\r
- mem = (n == 1) ? p->backref_general.n1 : p->backref_general.ns[i];\r
- if (i > 0) fputs(", ", f);\r
- fprintf(f, "%d", mem);\r
- }\r
- }\r
- break;\r
-\r
- case OP_MEMORY_START:\r
- case OP_MEMORY_START_PUSH:\r
- mem = p->memory_start.num;\r
- fprintf(f, ":%d", mem);\r
- break;\r
- case OP_MEMORY_END_PUSH:\r
- case OP_MEMORY_END_PUSH_REC:\r
- case OP_MEMORY_END:\r
- case OP_MEMORY_END_REC:\r
- mem = p->memory_end.num;\r
- fprintf(f, ":%d", mem);\r
- break;\r
-\r
- case OP_JUMP:\r
- addr = p->jump.addr;\r
- fputc(':', f);\r
- p_rel_addr(f, addr, p, start);\r
- break;\r
-\r
- case OP_PUSH:\r
- case OP_PUSH_SUPER:\r
- addr = p->push.addr;\r
- fputc(':', f);\r
- p_rel_addr(f, addr, p, start);\r
- break;\r
-\r
-#ifdef USE_OP_PUSH_OR_JUMP_EXACT\r
- case OP_PUSH_OR_JUMP_EXACT1:\r
- addr = p->push_or_jump_exact1.addr;\r
- fputc(':', f);\r
- p_rel_addr(f, addr, p, start);\r
- p_string(f, 1, &(p->push_or_jump_exact1.c));\r
- break;\r
-#endif\r
-\r
- case OP_PUSH_IF_PEEK_NEXT:\r
- addr = p->push_if_peek_next.addr;\r
- fputc(':', f);\r
- p_rel_addr(f, addr, p, start);\r
- p_string(f, 1, &(p->push_if_peek_next.c));\r
- break;\r
-\r
- case OP_REPEAT:\r
- case OP_REPEAT_NG:\r
- mem = p->repeat.id;\r
- addr = p->repeat.addr;\r
- fprintf(f, ":%d:", mem);\r
- p_rel_addr(f, addr, p, start);\r
- break;\r
-\r
- case OP_REPEAT_INC:\r
- case OP_REPEAT_INC_NG:\r
- case OP_REPEAT_INC_SG:\r
- case OP_REPEAT_INC_NG_SG:\r
- mem = p->repeat.id;\r
- fprintf(f, ":%d", mem);\r
- break;\r
-\r
- case OP_EMPTY_CHECK_START:\r
- mem = p->empty_check_start.mem;\r
- fprintf(f, ":%d", mem);\r
- break;\r
- case OP_EMPTY_CHECK_END:\r
- case OP_EMPTY_CHECK_END_MEMST:\r
- case OP_EMPTY_CHECK_END_MEMST_PUSH:\r
- mem = p->empty_check_end.mem;\r
- fprintf(f, ":%d", mem);\r
- break;\r
-\r
- case OP_PREC_READ_NOT_START:\r
- addr = p->prec_read_not_start.addr;\r
- fputc(':', f);\r
- p_rel_addr(f, addr, p, start);\r
- break;\r
-\r
- case OP_LOOK_BEHIND:\r
- len = p->look_behind.len;\r
- fprintf(f, ":%d", len);\r
- break;\r
-\r
- case OP_LOOK_BEHIND_NOT_START:\r
- addr = p->look_behind_not_start.addr;\r
- len = p->look_behind_not_start.len;\r
- fprintf(f, ":%d:", len);\r
- p_rel_addr(f, addr, p, start);\r
- break;\r
-\r
- case OP_CALL:\r
- addr = p->call.addr;\r
- fprintf(f, ":{/%d}", addr);\r
- break;\r
-\r
- case OP_PUSH_SAVE_VAL:\r
- {\r
- SaveType type;\r
-\r
- type = p->push_save_val.type;\r
- mem = p->push_save_val.id;\r
- fprintf(f, ":%d:%d", type, mem);\r
- }\r
- break;\r
-\r
- case OP_UPDATE_VAR:\r
- {\r
- UpdateVarType type;\r
-\r
- type = p->update_var.type;\r
- mem = p->update_var.id;\r
- fprintf(f, ":%d:%d", type, mem);\r
- }\r
- break;\r
-\r
-#ifdef USE_CALLOUT\r
- case OP_CALLOUT_CONTENTS:\r
- mem = p->callout_contents.num;\r
- fprintf(f, ":%d", mem);\r
- break;\r
-\r
- case OP_CALLOUT_NAME:\r
- {\r
- int id;\r
-\r
- id = p->callout_name.id;\r
- mem = p->callout_name.num;\r
- fprintf(f, ":%d:%d", id, mem);\r
- }\r
- break;\r
-#endif\r
-\r
- case OP_TEXT_SEGMENT_BOUNDARY:\r
- if (p->text_segment_boundary.not != 0)\r
- fprintf(f, ":not");\r
- break;\r
-\r
- case OP_FINISH:\r
- case OP_END:\r
- case OP_ANYCHAR:\r
- case OP_ANYCHAR_ML:\r
- case OP_ANYCHAR_STAR:\r
- case OP_ANYCHAR_ML_STAR:\r
- case OP_WORD:\r
- case OP_WORD_ASCII:\r
- case OP_NO_WORD:\r
- case OP_NO_WORD_ASCII:\r
- case OP_BEGIN_BUF:\r
- case OP_END_BUF:\r
- case OP_BEGIN_LINE:\r
- case OP_END_LINE:\r
- case OP_SEMI_END_BUF:\r
- case OP_BEGIN_POSITION:\r
- case OP_BACKREF1:\r
- case OP_BACKREF2:\r
- case OP_FAIL:\r
- case OP_POP_OUT:\r
- case OP_PREC_READ_START:\r
- case OP_PREC_READ_END:\r
- case OP_PREC_READ_NOT_END:\r
- case OP_ATOMIC_START:\r
- case OP_ATOMIC_END:\r
- case OP_LOOK_BEHIND_NOT_END:\r
- case OP_RETURN:\r
- break;\r
-\r
- default:\r
- fprintf(stderr, "print_compiled_byte_code: undefined code %d\n", opcode);\r
- break;\r
- }\r
-}\r
-#endif /* ONIG_DEBUG */\r
-\r
-#ifdef ONIG_DEBUG_COMPILE\r
-extern void\r
-onig_print_compiled_byte_code_list(FILE* f, regex_t* reg)\r
-{\r
- Operation* bp;\r
- Operation* start = reg->ops;\r
- Operation* end = reg->ops + reg->ops_used;\r
-\r
- fprintf(f, "bt_mem_start: 0x%x, bt_mem_end: 0x%x\n",\r
- reg->bt_mem_start, reg->bt_mem_end);\r
- fprintf(f, "code-length: %d\n", reg->ops_used);\r
-\r
- bp = start;\r
- while (bp < end) {\r
- int pos = bp - start;\r
-\r
- fprintf(f, "%4d: ", pos);\r
- print_compiled_byte_code(f, reg, pos, start, reg->enc);\r
- fprintf(f, "\n");\r
- bp++;\r
- }\r
- fprintf(f, "\n");\r
-}\r
-#endif\r
-\r
-\r
-#ifdef USE_CAPTURE_HISTORY\r
-static void history_tree_free(OnigCaptureTreeNode* node);\r
-\r
-static void\r
-history_tree_clear(OnigCaptureTreeNode* node)\r
-{\r
- int i;\r
-\r
- if (IS_NULL(node)) return ;\r
-\r
- for (i = 0; i < node->num_childs; i++) {\r
- if (IS_NOT_NULL(node->childs[i])) {\r
- history_tree_free(node->childs[i]);\r
- }\r
- }\r
- for (i = 0; i < node->allocated; i++) {\r
- node->childs[i] = (OnigCaptureTreeNode* )0;\r
- }\r
- node->num_childs = 0;\r
- node->beg = ONIG_REGION_NOTPOS;\r
- node->end = ONIG_REGION_NOTPOS;\r
- node->group = -1;\r
-}\r
-\r
-static void\r
-history_tree_free(OnigCaptureTreeNode* node)\r
-{\r
- history_tree_clear(node);\r
- if (IS_NOT_NULL(node->childs)) xfree(node->childs);\r
-\r
- xfree(node);\r
-}\r
-\r
-static void\r
-history_root_free(OnigRegion* r)\r
-{\r
- if (IS_NULL(r->history_root)) return ;\r
-\r
- history_tree_free(r->history_root);\r
- r->history_root = (OnigCaptureTreeNode* )0;\r
-}\r
-\r
-static OnigCaptureTreeNode*\r
-history_node_new(void)\r
-{\r
- OnigCaptureTreeNode* node;\r
-\r
- node = (OnigCaptureTreeNode* )xmalloc(sizeof(OnigCaptureTreeNode));\r
- CHECK_NULL_RETURN(node);\r
-\r
- node->childs = (OnigCaptureTreeNode** )0;\r
- node->allocated = 0;\r
- node->num_childs = 0;\r
- node->group = -1;\r
- node->beg = ONIG_REGION_NOTPOS;\r
- node->end = ONIG_REGION_NOTPOS;\r
-\r
- return node;\r
-}\r
-\r
-static int\r
-history_tree_add_child(OnigCaptureTreeNode* parent, OnigCaptureTreeNode* child)\r
-{\r
-#define HISTORY_TREE_INIT_ALLOC_SIZE 8\r
-\r
- if (parent->num_childs >= parent->allocated) {\r
- int n, i;\r
-\r
- if (IS_NULL(parent->childs)) {\r
- n = HISTORY_TREE_INIT_ALLOC_SIZE;\r
- parent->childs =\r
- (OnigCaptureTreeNode** )xmalloc(sizeof(parent->childs[0]) * n);\r
- }\r
- else {\r
- n = parent->allocated * 2;\r
- parent->childs =\r
- (OnigCaptureTreeNode** )xrealloc(parent->childs,\r
- sizeof(parent->childs[0]) * n,\r
- sizeof(parent->childs[0]) * parent->allocated);\r
- }\r
- CHECK_NULL_RETURN_MEMERR(parent->childs);\r
- for (i = parent->allocated; i < n; i++) {\r
- parent->childs[i] = (OnigCaptureTreeNode* )0;\r
- }\r
- parent->allocated = n;\r
- }\r
-\r
- parent->childs[parent->num_childs] = child;\r
- parent->num_childs++;\r
- return 0;\r
-}\r
-\r
-static OnigCaptureTreeNode*\r
-history_tree_clone(OnigCaptureTreeNode* node)\r
-{\r
- int i;\r
- OnigCaptureTreeNode *clone, *child;\r
-\r
- clone = history_node_new();\r
- CHECK_NULL_RETURN(clone);\r
-\r
- clone->beg = node->beg;\r
- clone->end = node->end;\r
- for (i = 0; i < node->num_childs; i++) {\r
- child = history_tree_clone(node->childs[i]);\r
- if (IS_NULL(child)) {\r
- history_tree_free(clone);\r
- return (OnigCaptureTreeNode* )0;\r
- }\r
- history_tree_add_child(clone, child);\r
- }\r
-\r
- return clone;\r
-}\r
-\r
-extern OnigCaptureTreeNode*\r
-onig_get_capture_tree(OnigRegion* region)\r
-{\r
- return region->history_root;\r
-}\r
-#endif /* USE_CAPTURE_HISTORY */\r
-\r
-extern void\r
-onig_region_clear(OnigRegion* region)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < region->num_regs; i++) {\r
- region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;\r
- }\r
-#ifdef USE_CAPTURE_HISTORY\r
- history_root_free(region);\r
-#endif\r
-}\r
-\r
-extern int\r
-onig_region_resize(OnigRegion* region, int n)\r
-{\r
- region->num_regs = n;\r
-\r
- if (n < ONIG_NREGION)\r
- n = ONIG_NREGION;\r
-\r
- if (region->allocated == 0) {\r
- region->beg = (int* )xmalloc(n * sizeof(int));\r
- region->end = (int* )xmalloc(n * sizeof(int));\r
-\r
- if (region->beg == 0 || region->end == 0)\r
- return ONIGERR_MEMORY;\r
-\r
- region->allocated = n;\r
- }\r
- else if (region->allocated < n) {\r
- region->beg = (int* )xrealloc(region->beg, n * sizeof(int), region->allocated * sizeof(int));\r
- region->end = (int* )xrealloc(region->end, n * sizeof(int), region->allocated * sizeof(int));\r
-\r
- if (region->beg == 0 || region->end == 0)\r
- return ONIGERR_MEMORY;\r
-\r
- region->allocated = n;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-static int\r
-onig_region_resize_clear(OnigRegion* region, int n)\r
-{\r
- int r;\r
-\r
- r = onig_region_resize(region, n);\r
- if (r != 0) return r;\r
- onig_region_clear(region);\r
- return 0;\r
-}\r
-\r
-extern int\r
-onig_region_set(OnigRegion* region, int at, int beg, int end)\r
-{\r
- if (at < 0) return ONIGERR_INVALID_ARGUMENT;\r
-\r
- if (at >= region->allocated) {\r
- int r = onig_region_resize(region, at + 1);\r
- if (r < 0) return r;\r
- }\r
-\r
- region->beg[at] = beg;\r
- region->end[at] = end;\r
- return 0;\r
-}\r
-\r
-extern void\r
-onig_region_init(OnigRegion* region)\r
-{\r
- region->num_regs = 0;\r
- region->allocated = 0;\r
- region->beg = (int* )0;\r
- region->end = (int* )0;\r
- region->history_root = (OnigCaptureTreeNode* )0;\r
-}\r
-\r
-extern OnigRegion*\r
-onig_region_new(void)\r
-{\r
- OnigRegion* r;\r
-\r
- r = (OnigRegion* )xmalloc(sizeof(OnigRegion));\r
- CHECK_NULL_RETURN(r);\r
- onig_region_init(r);\r
- return r;\r
-}\r
-\r
-extern void\r
-onig_region_free(OnigRegion* r, int free_self)\r
-{\r
- if (r != 0) {\r
- if (r->allocated > 0) {\r
- if (r->beg) xfree(r->beg);\r
- if (r->end) xfree(r->end);\r
- r->allocated = 0;\r
- }\r
-#ifdef USE_CAPTURE_HISTORY\r
- history_root_free(r);\r
-#endif\r
- if (free_self) xfree(r);\r
- }\r
-}\r
-\r
-extern void\r
-onig_region_copy(OnigRegion* to, OnigRegion* from)\r
-{\r
-#define RREGC_SIZE (sizeof(int) * from->num_regs)\r
- int i;\r
-\r
- if (to == from) return;\r
-\r
- if (to->allocated == 0) {\r
- if (from->num_regs > 0) {\r
- to->beg = (int* )xmalloc(RREGC_SIZE);\r
- if (IS_NULL(to->beg)) return;\r
- to->end = (int* )xmalloc(RREGC_SIZE);\r
- if (IS_NULL(to->end)) return;\r
- to->allocated = from->num_regs;\r
- }\r
- }\r
- else if (to->allocated < from->num_regs) {\r
- to->beg = (int* )xrealloc(to->beg, RREGC_SIZE, sizeof(int) * to->allocated);\r
- if (IS_NULL(to->beg)) return;\r
- to->end = (int* )xrealloc(to->end, RREGC_SIZE, sizeof(int) * to->allocated);\r
- if (IS_NULL(to->end)) return;\r
- to->allocated = from->num_regs;\r
- }\r
-\r
- for (i = 0; i < from->num_regs; i++) {\r
- to->beg[i] = from->beg[i];\r
- to->end[i] = from->end[i];\r
- }\r
- to->num_regs = from->num_regs;\r
-\r
-#ifdef USE_CAPTURE_HISTORY\r
- history_root_free(to);\r
-\r
- if (IS_NOT_NULL(from->history_root)) {\r
- to->history_root = history_tree_clone(from->history_root);\r
- }\r
-#endif\r
-}\r
-\r
-#ifdef USE_CALLOUT\r
-#define CALLOUT_BODY(func, ain, aname_id, anum, user, args, result) do { \\r
- args.in = (ain);\\r
- args.name_id = (aname_id);\\r
- args.num = anum;\\r
- args.regex = reg;\\r
- args.string = str;\\r
- args.string_end = end;\\r
- args.start = sstart;\\r
- args.right_range = right_range;\\r
- args.current = s;\\r
- args.retry_in_match_counter = retry_in_match_counter;\\r
- args.msa = msa;\\r
- args.stk_base = stk_base;\\r
- args.stk = stk;\\r
- args.mem_start_stk = mem_start_stk;\\r
- args.mem_end_stk = mem_end_stk;\\r
- result = (func)(&args, user);\\r
-} while (0)\r
-\r
-#define RETRACTION_CALLOUT(func, aname_id, anum, user) do {\\r
- int result;\\r
- OnigCalloutArgs args;\\r
- CALLOUT_BODY(func, ONIG_CALLOUT_IN_RETRACTION, aname_id, anum, user, args, result);\\r
- switch (result) {\\r
- case ONIG_CALLOUT_FAIL:\\r
- case ONIG_CALLOUT_SUCCESS:\\r
- break;\\r
- default:\\r
- if (result > 0) {\\r
- result = ONIGERR_INVALID_ARGUMENT;\\r
- }\\r
- best_len = result;\\r
- goto finish;\\r
- break;\\r
- }\\r
-} while(0)\r
-#endif\r
-\r
-\r
-/** stack **/\r
-#define INVALID_STACK_INDEX -1\r
-\r
-#define STK_ALT_FLAG 0x0001\r
-\r
-/* stack type */\r
-/* used by normal-POP */\r
-#define STK_SUPER_ALT STK_ALT_FLAG\r
-#define STK_ALT (0x0002 | STK_ALT_FLAG)\r
-#define STK_ALT_PREC_READ_NOT (0x0004 | STK_ALT_FLAG)\r
-#define STK_ALT_LOOK_BEHIND_NOT (0x0006 | STK_ALT_FLAG)\r
-\r
-/* handled by normal-POP */\r
-#define STK_MEM_START 0x0010\r
-#define STK_MEM_END 0x8030\r
-#define STK_REPEAT_INC 0x0050\r
-#ifdef USE_CALLOUT\r
-#define STK_CALLOUT 0x0070\r
-#endif\r
-\r
-/* avoided by normal-POP */\r
-#define STK_VOID 0x0000 /* for fill a blank */\r
-#define STK_EMPTY_CHECK_START 0x3000\r
-#define STK_EMPTY_CHECK_END 0x5000 /* for recursive call */\r
-#define STK_MEM_END_MARK 0x8100\r
-#define STK_TO_VOID_START 0x1200 /* mark for "(?>...)" */\r
-#define STK_REPEAT 0x0300\r
-#define STK_CALL_FRAME 0x0400\r
-#define STK_RETURN 0x0500\r
-#define STK_SAVE_VAL 0x0600\r
-#define STK_PREC_READ_START 0x0700\r
-#define STK_PREC_READ_END 0x0800\r
-\r
-/* stack type check mask */\r
-#define STK_MASK_POP_USED STK_ALT_FLAG\r
-#define STK_MASK_POP_HANDLED 0x0010\r
-#define STK_MASK_POP_HANDLED_TIL (STK_MASK_POP_HANDLED | 0x0004)\r
-#define STK_MASK_TO_VOID_TARGET 0x100e\r
-#define STK_MASK_MEM_END_OR_MARK 0x8000 /* MEM_END or MEM_END_MARK */\r
-\r
-typedef intptr_t StackIndex;\r
-\r
-typedef struct _StackType {\r
- unsigned int type;\r
- int zid;\r
- union {\r
- struct {\r
- Operation* pcode; /* byte code position */\r
- UChar* pstr; /* string position */\r
- UChar* pstr_prev; /* previous char position of pstr */\r
- } state;\r
- struct {\r
- int count; /* for OP_REPEAT_INC, OP_REPEAT_INC_NG */\r
- Operation* pcode; /* byte code position (head of repeated target) */\r
- } repeat;\r
- struct {\r
- StackIndex si; /* index of stack */\r
- } repeat_inc;\r
- struct {\r
- UChar *pstr; /* start/end position */\r
- /* Following information is set, if this stack type is MEM-START */\r
- StackIndex prev_start; /* prev. info (for backtrack "(...)*" ) */\r
- StackIndex prev_end; /* prev. info (for backtrack "(...)*" ) */\r
- } mem;\r
- struct {\r
- UChar *pstr; /* start position */\r
- } empty_check;\r
-#ifdef USE_CALL\r
- struct {\r
- Operation *ret_addr; /* byte code position */\r
- UChar *pstr; /* string position */\r
- } call_frame;\r
-#endif\r
- struct {\r
- enum SaveType type;\r
- UChar* v;\r
- UChar* v2;\r
- } val;\r
-#ifdef USE_CALLOUT\r
- struct {\r
- int num;\r
- OnigCalloutFunc func;\r
- } callout;\r
-#endif\r
- } u;\r
-} StackType;\r
-\r
-#ifdef USE_CALLOUT\r
-\r
-struct OnigCalloutArgsStruct {\r
- OnigCalloutIn in;\r
- int name_id; /* name id or ONIG_NON_NAME_ID */\r
- int num;\r
- OnigRegex regex;\r
- const OnigUChar* string;\r
- const OnigUChar* string_end;\r
- const OnigUChar* start;\r
- const OnigUChar* right_range;\r
- const OnigUChar* current; /* current matching position */\r
- unsigned long retry_in_match_counter;\r
-\r
- /* invisible to users */\r
- MatchArg* msa;\r
- StackType* stk_base;\r
- StackType* stk;\r
- StackIndex* mem_start_stk;\r
- StackIndex* mem_end_stk;\r
-};\r
-\r
-#endif\r
-\r
-\r
-#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE\r
-#define MATCH_ARG_INIT(msa, reg, arg_option, arg_region, arg_start, mp) do { \\r
- (msa).stack_p = (void* )0;\\r
- (msa).options = (arg_option);\\r
- (msa).region = (arg_region);\\r
- (msa).start = (arg_start);\\r
- (msa).match_stack_limit = (mp)->match_stack_limit;\\r
- (msa).retry_limit_in_match = (mp)->retry_limit_in_match;\\r
- (msa).mp = mp;\\r
- (msa).best_len = ONIG_MISMATCH;\\r
- (msa).ptr_num = (reg)->num_repeat + ((reg)->num_mem + 1) * 2; \\r
-} while(0)\r
-#else\r
-#define MATCH_ARG_INIT(msa, reg, arg_option, arg_region, arg_start, mp) do { \\r
- (msa).stack_p = (void* )0;\\r
- (msa).options = (arg_option);\\r
- (msa).region = (arg_region);\\r
- (msa).start = (arg_start);\\r
- (msa).match_stack_limit = (mp)->match_stack_limit;\\r
- (msa).retry_limit_in_match = (mp)->retry_limit_in_match;\\r
- (msa).mp = mp;\\r
- (msa).ptr_num = (reg)->num_repeat + ((reg)->num_mem + 1) * 2; \\r
-} while(0)\r
-#endif\r
-\r
-#define MATCH_ARG_FREE(msa) if ((msa).stack_p) xfree((msa).stack_p)\r
-\r
-\r
-#define ALLOCA_PTR_NUM_LIMIT 50\r
-\r
-#define STACK_INIT(stack_num) do {\\r
- if (msa->stack_p) {\\r
- is_alloca = 0;\\r
- alloc_base = msa->stack_p;\\r
- stk_base = (StackType* )(alloc_base\\r
- + (sizeof(StackIndex) * msa->ptr_num));\\r
- stk = stk_base;\\r
- stk_end = stk_base + msa->stack_n;\\r
- }\\r
- else if (msa->ptr_num > ALLOCA_PTR_NUM_LIMIT) {\\r
- is_alloca = 0;\\r
- alloc_base = (char* )xmalloc(sizeof(StackIndex) * msa->ptr_num\\r
- + sizeof(StackType) * (stack_num));\\r
- CHECK_NULL_RETURN_MEMERR(alloc_base);\\r
- stk_base = (StackType* )(alloc_base\\r
- + (sizeof(StackIndex) * msa->ptr_num));\\r
- stk = stk_base;\\r
- stk_end = stk_base + (stack_num);\\r
- }\\r
- else {\\r
- is_alloca = 1;\\r
- alloc_base = (char* )xmalloc(sizeof(StackIndex) * msa->ptr_num\\r
- + sizeof(StackType) * (stack_num));\\r
- CHECK_NULL_RETURN_MEMERR(alloc_base);\\r
- stk_base = (StackType* )(alloc_base\\r
- + (sizeof(StackIndex) * msa->ptr_num));\\r
- stk = stk_base;\\r
- stk_end = stk_base + (stack_num);\\r
- }\\r
-} while(0);\r
-\r
-\r
-#define STACK_SAVE do{\\r
- msa->stack_n = (int )(stk_end - stk_base);\\r
- if (is_alloca != 0) {\\r
- size_t size = sizeof(StackIndex) * msa->ptr_num \\r
- + sizeof(StackType) * msa->stack_n;\\r
- msa->stack_p = xmalloc(size);\\r
- CHECK_NULL_RETURN_MEMERR(msa->stack_p);\\r
- xmemcpy(msa->stack_p, alloc_base, size);\\r
- }\\r
- else {\\r
- msa->stack_p = alloc_base;\\r
- };\\r
-} while(0)\r
-\r
-#define UPDATE_FOR_STACK_REALLOC do{\\r
- repeat_stk = (StackIndex* )alloc_base;\\r
- mem_start_stk = (StackIndex* )(repeat_stk + reg->num_repeat);\\r
- mem_end_stk = mem_start_stk + num_mem + 1;\\r
-} while(0)\r
-\r
-static unsigned int MatchStackLimit = DEFAULT_MATCH_STACK_LIMIT_SIZE;\r
-\r
-extern unsigned int\r
-onig_get_match_stack_limit_size(void)\r
-{\r
- return MatchStackLimit;\r
-}\r
-\r
-extern int\r
-onig_set_match_stack_limit_size(unsigned int size)\r
-{\r
- MatchStackLimit = size;\r
- return 0;\r
-}\r
-\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
-\r
-static unsigned long RetryLimitInMatch = DEFAULT_RETRY_LIMIT_IN_MATCH;\r
-\r
-#define CHECK_RETRY_LIMIT_IN_MATCH do {\\r
- if (retry_in_match_counter++ > retry_limit_in_match) goto retry_limit_in_match_over;\\r
-} while (0)\r
-\r
-#else\r
-\r
-#define CHECK_RETRY_LIMIT_IN_MATCH\r
-\r
-#endif /* USE_RETRY_LIMIT_IN_MATCH */\r
-\r
-extern unsigned long\r
-onig_get_retry_limit_in_match(void)\r
-{\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- return RetryLimitInMatch;\r
-#else\r
- /* return ONIG_NO_SUPPORT_CONFIG; */\r
- return 0;\r
-#endif\r
-}\r
-\r
-extern int\r
-onig_set_retry_limit_in_match(unsigned long size)\r
-{\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- RetryLimitInMatch = size;\r
- return 0;\r
-#else\r
- return ONIG_NO_SUPPORT_CONFIG;\r
-#endif\r
-}\r
-\r
-#ifdef USE_CALLOUT\r
-static OnigCalloutFunc DefaultProgressCallout;\r
-static OnigCalloutFunc DefaultRetractionCallout;\r
-#endif\r
-\r
-extern OnigMatchParam*\r
-onig_new_match_param(void)\r
-{\r
- OnigMatchParam* p;\r
-\r
- p = (OnigMatchParam* )xmalloc(sizeof(*p));\r
- if (IS_NOT_NULL(p)) {\r
- onig_initialize_match_param(p);\r
- }\r
-\r
- return p;\r
-}\r
-\r
-extern void\r
-onig_free_match_param_content(OnigMatchParam* p)\r
-{\r
-#ifdef USE_CALLOUT\r
- if (IS_NOT_NULL(p->callout_data)) {\r
- xfree(p->callout_data);\r
- p->callout_data = 0;\r
- }\r
-#endif\r
-}\r
-\r
-extern void\r
-onig_free_match_param(OnigMatchParam* p)\r
-{\r
- if (IS_NOT_NULL(p)) {\r
- onig_free_match_param_content(p);\r
- xfree(p);\r
- }\r
-}\r
-\r
-extern int\r
-onig_initialize_match_param(OnigMatchParam* mp)\r
-{\r
- mp->match_stack_limit = MatchStackLimit;\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- mp->retry_limit_in_match = RetryLimitInMatch;\r
-#endif\r
-\r
-#ifdef USE_CALLOUT\r
- mp->progress_callout_of_contents = DefaultProgressCallout;\r
- mp->retraction_callout_of_contents = DefaultRetractionCallout;\r
- mp->match_at_call_counter = 0;\r
- mp->callout_user_data = 0;\r
- mp->callout_data = 0;\r
- mp->callout_data_alloc_num = 0;\r
-#endif\r
-\r
- return ONIG_NORMAL;\r
-}\r
-\r
-#ifdef USE_CALLOUT\r
-\r
-static int\r
-adjust_match_param(regex_t* reg, OnigMatchParam* mp)\r
-{\r
- RegexExt* ext = reg->extp;\r
-\r
- mp->match_at_call_counter = 0;\r
-\r
- if (IS_NULL(ext) || ext->callout_num == 0) return ONIG_NORMAL;\r
-\r
- if (ext->callout_num > mp->callout_data_alloc_num) {\r
- CalloutData* d;\r
- size_t n = ext->callout_num * sizeof(*d);\r
- if (IS_NOT_NULL(mp->callout_data))\r
- d = (CalloutData* )xrealloc(mp->callout_data, n, mp->callout_data_alloc_num * sizeof(*d));\r
- else\r
- d = (CalloutData* )xmalloc(n);\r
- CHECK_NULL_RETURN_MEMERR(d);\r
-\r
- mp->callout_data = d;\r
- mp->callout_data_alloc_num = ext->callout_num;\r
- }\r
-\r
- xmemset(mp->callout_data, 0, mp->callout_data_alloc_num * sizeof(CalloutData));\r
- return ONIG_NORMAL;\r
-}\r
-\r
-#define ADJUST_MATCH_PARAM(reg, mp) \\r
- r = adjust_match_param(reg, mp);\\r
- if (r != ONIG_NORMAL) return r;\r
-\r
-#define CALLOUT_DATA_AT_NUM(mp, num) ((mp)->callout_data + ((num) - 1))\r
-\r
-extern int\r
-onig_check_callout_data_and_clear_old_values(OnigCalloutArgs* args)\r
-{\r
- OnigMatchParam* mp;\r
- int num;\r
- CalloutData* d;\r
-\r
- mp = args->msa->mp;\r
- num = args->num;\r
-\r
- d = CALLOUT_DATA_AT_NUM(mp, num);\r
- if (d->last_match_at_call_counter != mp->match_at_call_counter) {\r
- xmemset(d, 0, sizeof(*d));\r
- d->last_match_at_call_counter = mp->match_at_call_counter;\r
- return d->last_match_at_call_counter;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-extern int\r
-onig_get_callout_data_dont_clear_old(regex_t* reg, OnigMatchParam* mp,\r
- int callout_num, int slot,\r
- OnigType* type, OnigValue* val)\r
-{\r
- OnigType t;\r
- CalloutData* d;\r
-\r
- if (callout_num <= 0) return ONIGERR_INVALID_ARGUMENT;\r
-\r
- d = CALLOUT_DATA_AT_NUM(mp, callout_num);\r
- t = d->slot[slot].type;\r
- if (IS_NOT_NULL(type)) *type = t;\r
- if (IS_NOT_NULL(val)) *val = d->slot[slot].val;\r
- return (t == ONIG_TYPE_VOID ? 1 : ONIG_NORMAL);\r
-}\r
-\r
-extern int\r
-onig_get_callout_data_by_callout_args_self_dont_clear_old(OnigCalloutArgs* args,\r
- int slot, OnigType* type,\r
- OnigValue* val)\r
-{\r
- return onig_get_callout_data_dont_clear_old(args->regex, args->msa->mp,\r
- args->num, slot, type, val);\r
-}\r
-\r
-extern int\r
-onig_get_callout_data(regex_t* reg, OnigMatchParam* mp,\r
- int callout_num, int slot,\r
- OnigType* type, OnigValue* val)\r
-{\r
- OnigType t;\r
- CalloutData* d;\r
-\r
- if (callout_num <= 0) return ONIGERR_INVALID_ARGUMENT;\r
-\r
- d = CALLOUT_DATA_AT_NUM(mp, callout_num);\r
- if (d->last_match_at_call_counter != mp->match_at_call_counter) {\r
- xmemset(d, 0, sizeof(*d));\r
- d->last_match_at_call_counter = mp->match_at_call_counter;\r
- }\r
-\r
- t = d->slot[slot].type;\r
- if (IS_NOT_NULL(type)) *type = t;\r
- if (IS_NOT_NULL(val)) *val = d->slot[slot].val;\r
- return (t == ONIG_TYPE_VOID ? 1 : ONIG_NORMAL);\r
-}\r
-\r
-extern int\r
-onig_get_callout_data_by_tag(regex_t* reg, OnigMatchParam* mp,\r
- const UChar* tag, const UChar* tag_end, int slot,\r
- OnigType* type, OnigValue* val)\r
-{\r
- int num;\r
-\r
- num = onig_get_callout_num_by_tag(reg, tag, tag_end);\r
- if (num < 0) return num;\r
- if (num == 0) return ONIGERR_INVALID_CALLOUT_TAG_NAME;\r
-\r
- return onig_get_callout_data(reg, mp, num, slot, type, val);\r
-}\r
-\r
-extern int\r
-onig_get_callout_data_by_callout_args(OnigCalloutArgs* args,\r
- int callout_num, int slot,\r
- OnigType* type, OnigValue* val)\r
-{\r
- return onig_get_callout_data(args->regex, args->msa->mp, callout_num, slot,\r
- type, val);\r
-}\r
-\r
-extern int\r
-onig_get_callout_data_by_callout_args_self(OnigCalloutArgs* args,\r
- int slot, OnigType* type, OnigValue* val)\r
-{\r
- return onig_get_callout_data(args->regex, args->msa->mp, args->num, slot,\r
- type, val);\r
-}\r
-\r
-extern int\r
-onig_set_callout_data(regex_t* reg, OnigMatchParam* mp,\r
- int callout_num, int slot,\r
- OnigType type, OnigValue* val)\r
-{\r
- CalloutData* d;\r
-\r
- if (callout_num <= 0) return ONIGERR_INVALID_ARGUMENT;\r
-\r
- d = CALLOUT_DATA_AT_NUM(mp, callout_num);\r
- d->slot[slot].type = type;\r
- d->slot[slot].val = *val;\r
- d->last_match_at_call_counter = mp->match_at_call_counter;\r
-\r
- return ONIG_NORMAL;\r
-}\r
-\r
-extern int\r
-onig_set_callout_data_by_tag(regex_t* reg, OnigMatchParam* mp,\r
- const UChar* tag, const UChar* tag_end, int slot,\r
- OnigType type, OnigValue* val)\r
-{\r
- int num;\r
-\r
- num = onig_get_callout_num_by_tag(reg, tag, tag_end);\r
- if (num < 0) return num;\r
- if (num == 0) return ONIGERR_INVALID_CALLOUT_TAG_NAME;\r
-\r
- return onig_set_callout_data(reg, mp, num, slot, type, val);\r
-}\r
-\r
-extern int\r
-onig_set_callout_data_by_callout_args(OnigCalloutArgs* args,\r
- int callout_num, int slot,\r
- OnigType type, OnigValue* val)\r
-{\r
- return onig_set_callout_data(args->regex, args->msa->mp, callout_num, slot,\r
- type, val);\r
-}\r
-\r
-extern int\r
-onig_set_callout_data_by_callout_args_self(OnigCalloutArgs* args,\r
- int slot, OnigType type, OnigValue* val)\r
-{\r
- return onig_set_callout_data(args->regex, args->msa->mp, args->num, slot,\r
- type, val);\r
-}\r
-\r
-#else\r
-#define ADJUST_MATCH_PARAM(reg, mp)\r
-#endif /* USE_CALLOUT */\r
-\r
-\r
-static int\r
-stack_double(int is_alloca, char** arg_alloc_base,\r
- StackType** arg_stk_base, StackType** arg_stk_end, StackType** arg_stk,\r
- MatchArg* msa)\r
-{\r
- unsigned int n;\r
- int used;\r
- size_t size;\r
- size_t new_size;\r
- char* alloc_base;\r
- char* new_alloc_base;\r
- StackType *stk_base, *stk_end, *stk;\r
-\r
- alloc_base = *arg_alloc_base;\r
- stk_base = *arg_stk_base;\r
- stk_end = *arg_stk_end;\r
- stk = *arg_stk;\r
-\r
- n = (unsigned int )(stk_end - stk_base);\r
- size = sizeof(StackIndex) * msa->ptr_num + sizeof(StackType) * n;\r
- n *= 2;\r
- new_size = sizeof(StackIndex) * msa->ptr_num + sizeof(StackType) * n;\r
- if (is_alloca != 0) {\r
- new_alloc_base = (char* )xmalloc(new_size);\r
- if (IS_NULL(new_alloc_base)) {\r
- STACK_SAVE;\r
- return ONIGERR_MEMORY;\r
- }\r
- xmemcpy(new_alloc_base, alloc_base, size);\r
- }\r
- else {\r
- if (msa->match_stack_limit != 0 && n > msa->match_stack_limit) {\r
- if ((unsigned int )(stk_end - stk_base) == msa->match_stack_limit)\r
- return ONIGERR_MATCH_STACK_LIMIT_OVER;\r
- else\r
- n = msa->match_stack_limit;\r
- }\r
- new_alloc_base = (char* )xrealloc(alloc_base, new_size, size);\r
- if (IS_NULL(new_alloc_base)) {\r
- STACK_SAVE;\r
- return ONIGERR_MEMORY;\r
- }\r
- }\r
-\r
- alloc_base = new_alloc_base;\r
- used = (int )(stk - stk_base);\r
- *arg_alloc_base = alloc_base;\r
- *arg_stk_base = (StackType* )(alloc_base\r
- + (sizeof(StackIndex) * msa->ptr_num));\r
- *arg_stk = *arg_stk_base + used;\r
- *arg_stk_end = *arg_stk_base + n;\r
- return 0;\r
-}\r
-\r
-#define STACK_ENSURE(n) do {\\r
- if ((int )(stk_end - stk) < (n)) {\\r
- int r = stack_double(is_alloca, &alloc_base, &stk_base, &stk_end, &stk, msa);\\r
- if (r != 0) { STACK_SAVE; return r; } \\r
- is_alloca = 0;\\r
- UPDATE_FOR_STACK_REALLOC;\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_AT(index) (stk_base + (index))\r
-#define GET_STACK_INDEX(stk) ((stk) - stk_base)\r
-\r
-#define STACK_PUSH_TYPE(stack_type) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = (stack_type);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define IS_TO_VOID_TARGET(stk) (((stk)->type & STK_MASK_TO_VOID_TARGET) != 0)\r
-\r
-#define STACK_PUSH(stack_type,pat,s,sprev) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = (stack_type);\\r
- stk->u.state.pcode = (pat);\\r
- stk->u.state.pstr = (s);\\r
- stk->u.state.pstr_prev = (sprev);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_ENSURED(stack_type,pat) do {\\r
- stk->type = (stack_type);\\r
- stk->u.state.pcode = (pat);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#ifdef ONIG_DEBUG_MATCH\r
-#define STACK_PUSH_BOTTOM(stack_type,pat) do {\\r
- stk->type = (stack_type);\\r
- stk->u.state.pcode = (pat);\\r
- stk->u.state.pstr = s;\\r
- stk->u.state.pstr_prev = sprev;\\r
- STACK_INC;\\r
-} while (0)\r
-#else\r
-#define STACK_PUSH_BOTTOM(stack_type,pat) do {\\r
- stk->type = (stack_type);\\r
- stk->u.state.pcode = (pat);\\r
- STACK_INC;\\r
-} while (0)\r
-#endif\r
-\r
-#define STACK_PUSH_ALT(pat,s,sprev) STACK_PUSH(STK_ALT,pat,s,sprev)\r
-#define STACK_PUSH_SUPER_ALT(pat,s,sprev) STACK_PUSH(STK_SUPER_ALT,pat,s,sprev)\r
-#define STACK_PUSH_PREC_READ_START(s,sprev) \\r
- STACK_PUSH(STK_PREC_READ_START,(Operation* )0,s,sprev)\r
-#define STACK_PUSH_ALT_PREC_READ_NOT(pat,s,sprev) \\r
- STACK_PUSH(STK_ALT_PREC_READ_NOT,pat,s,sprev)\r
-#define STACK_PUSH_TO_VOID_START STACK_PUSH_TYPE(STK_TO_VOID_START)\r
-#define STACK_PUSH_ALT_LOOK_BEHIND_NOT(pat,s,sprev) \\r
- STACK_PUSH(STK_ALT_LOOK_BEHIND_NOT,pat,s,sprev)\r
-\r
-#define STACK_PUSH_REPEAT(sid, pat) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_REPEAT;\\r
- stk->zid = (sid);\\r
- stk->u.repeat.pcode = (pat);\\r
- stk->u.repeat.count = 0;\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_REPEAT_INC(sindex) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_REPEAT_INC;\\r
- stk->u.repeat_inc.si = (sindex);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_MEM_START(mnum, s) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_MEM_START;\\r
- stk->zid = (mnum);\\r
- stk->u.mem.pstr = (s);\\r
- stk->u.mem.prev_start = mem_start_stk[mnum];\\r
- stk->u.mem.prev_end = mem_end_stk[mnum];\\r
- mem_start_stk[mnum] = GET_STACK_INDEX(stk);\\r
- mem_end_stk[mnum] = INVALID_STACK_INDEX;\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_MEM_END(mnum, s) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_MEM_END;\\r
- stk->zid = (mnum);\\r
- stk->u.mem.pstr = (s);\\r
- stk->u.mem.prev_start = mem_start_stk[mnum];\\r
- stk->u.mem.prev_end = mem_end_stk[mnum];\\r
- mem_end_stk[mnum] = GET_STACK_INDEX(stk);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_MEM_END_MARK(mnum) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_MEM_END_MARK;\\r
- stk->zid = (mnum);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_GET_MEM_START(mnum, k) do {\\r
- int level = 0;\\r
- k = stk;\\r
- while (k > stk_base) {\\r
- k--;\\r
- if ((k->type & STK_MASK_MEM_END_OR_MARK) != 0 \\r
- && k->zid == (mnum)) {\\r
- level++;\\r
- }\\r
- else if (k->type == STK_MEM_START && k->zid == (mnum)) {\\r
- if (level == 0) break;\\r
- level--;\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_GET_MEM_RANGE(k, mnum, start, end) do {\\r
- int level = 0;\\r
- while (k < stk) {\\r
- if (k->type == STK_MEM_START && k->u.mem.num == (mnum)) {\\r
- if (level == 0) (start) = k->u.mem.pstr;\\r
- level++;\\r
- }\\r
- else if (k->type == STK_MEM_END && k->u.mem.num == (mnum)) {\\r
- level--;\\r
- if (level == 0) {\\r
- (end) = k->u.mem.pstr;\\r
- break;\\r
- }\\r
- }\\r
- k++;\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_PUSH_EMPTY_CHECK_START(cnum, s) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_EMPTY_CHECK_START;\\r
- stk->zid = (cnum);\\r
- stk->u.empty_check.pstr = (s);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_EMPTY_CHECK_END(cnum) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_EMPTY_CHECK_END;\\r
- stk->zid = (cnum);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_CALL_FRAME(pat) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_CALL_FRAME;\\r
- stk->u.call_frame.ret_addr = (pat);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_RETURN do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_RETURN;\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_SAVE_VAL(sid, stype, sval) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_SAVE_VAL;\\r
- stk->zid = (sid);\\r
- stk->u.val.type = (stype);\\r
- stk->u.val.v = (UChar* )(sval);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_SAVE_VAL_WITH_SPREV(sid, stype, sval) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_SAVE_VAL;\\r
- stk->zid = (sid);\\r
- stk->u.val.type = (stype);\\r
- stk->u.val.v = (UChar* )(sval);\\r
- stk->u.val.v2 = sprev;\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_GET_SAVE_VAL_TYPE_LAST(stype, sval) do {\\r
- StackType *k = stk;\\r
- while (k > stk_base) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST"); \\r
- if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)) {\\r
- (sval) = k->u.val.v;\\r
- break;\\r
- }\\r
- }\\r
-} while (0)\r
-\r
-#define STACK_GET_SAVE_VAL_TYPE_LAST_ID(stype, sid, sval) do { \\r
- int level = 0;\\r
- StackType *k = stk;\\r
- while (k > stk_base) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST_ID"); \\r
- if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)\\r
- && k->zid == (sid)) {\\r
- if (level == 0) {\\r
- (sval) = k->u.val.v;\\r
- break;\\r
- }\\r
- }\\r
- else if (k->type == STK_CALL_FRAME)\\r
- level--;\\r
- else if (k->type == STK_RETURN)\\r
- level++;\\r
- }\\r
-} while (0)\r
-\r
-#define STACK_GET_SAVE_VAL_TYPE_LAST_ID_WITH_SPREV(stype, sid, sval) do { \\r
- int level = 0;\\r
- StackType *k = stk;\\r
- while (k > stk_base) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST_ID"); \\r
- if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)\\r
- && k->zid == (sid)) {\\r
- if (level == 0) {\\r
- (sval) = k->u.val.v;\\r
- sprev = k->u.val.v2;\\r
- break;\\r
- }\\r
- }\\r
- else if (k->type == STK_CALL_FRAME)\\r
- level--;\\r
- else if (k->type == STK_RETURN)\\r
- level++;\\r
- }\\r
-} while (0)\r
-\r
-#define STACK_GET_SAVE_VAL_TYPE_LAST_ID_FROM(stype, sid, sval, stk_from) do { \\r
- int level = 0;\\r
- StackType *k = (stk_from);\\r
- while (k > stk_base) {\\r
- STACK_BASE_CHECK(k, "STACK_GET_SAVE_VAL_TYPE_LAST_ID_FROM"); \\r
- if (k->type == STK_SAVE_VAL && k->u.val.type == (stype)\\r
- && k->u.val.id == (sid)) {\\r
- if (level == 0) {\\r
- (sval) = k->u.val.v;\\r
- break;\\r
- }\\r
- }\\r
- else if (k->type == STK_CALL_FRAME)\\r
- level--;\\r
- else if (k->type == STK_RETURN)\\r
- level++;\\r
- k--;\\r
- }\\r
-} while (0)\r
-\r
-#define STACK_PUSH_CALLOUT_CONTENTS(anum, func) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_CALLOUT;\\r
- stk->zid = ONIG_NON_NAME_ID;\\r
- stk->u.callout.num = (anum);\\r
- stk->u.callout.func = (func);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#define STACK_PUSH_CALLOUT_NAME(aid, anum, func) do {\\r
- STACK_ENSURE(1);\\r
- stk->type = STK_CALLOUT;\\r
- stk->zid = (aid);\\r
- stk->u.callout.num = (anum);\\r
- stk->u.callout.func = (func);\\r
- STACK_INC;\\r
-} while(0)\r
-\r
-#ifdef ONIG_DEBUG\r
-#define STACK_BASE_CHECK(p, at) \\r
- if ((p) < stk_base) {\\r
- fprintf(stderr, "at %s\n", at);\\r
- goto stack_error;\\r
- }\r
-#else\r
-#define STACK_BASE_CHECK(p, at)\r
-#endif\r
-\r
-#define STACK_POP_ONE do {\\r
- stk--;\\r
- STACK_BASE_CHECK(stk, "STACK_POP_ONE"); \\r
-} while(0)\r
-\r
-\r
-#ifdef USE_CALLOUT\r
-#define POP_CALLOUT_CASE \\r
- else if (stk->type == STK_CALLOUT) {\\r
- RETRACTION_CALLOUT(stk->u.callout.func, stk->zid, stk->u.callout.num, msa->mp->callout_user_data);\\r
- }\r
-#else\r
-#define POP_CALLOUT_CASE\r
-#endif\r
-\r
-#define STACK_POP do {\\r
- switch (pop_level) {\\r
- case STACK_POP_LEVEL_FREE:\\r
- while (1) {\\r
- stk--;\\r
- STACK_BASE_CHECK(stk, "STACK_POP"); \\r
- if ((stk->type & STK_MASK_POP_USED) != 0) break;\\r
- }\\r
- break;\\r
- case STACK_POP_LEVEL_MEM_START:\\r
- while (1) {\\r
- stk--;\\r
- STACK_BASE_CHECK(stk, "STACK_POP 2"); \\r
- if ((stk->type & STK_MASK_POP_USED) != 0) break;\\r
- else if (stk->type == STK_MEM_START) {\\r
- mem_start_stk[stk->zid] = stk->u.mem.prev_start;\\r
- mem_end_stk[stk->zid] = stk->u.mem.prev_end;\\r
- }\\r
- }\\r
- break;\\r
- default:\\r
- while (1) {\\r
- stk--;\\r
- STACK_BASE_CHECK(stk, "STACK_POP 3"); \\r
- if ((stk->type & STK_MASK_POP_USED) != 0) break;\\r
- else if ((stk->type & STK_MASK_POP_HANDLED) != 0) {\\r
- if (stk->type == STK_MEM_START) {\\r
- mem_start_stk[stk->zid] = stk->u.mem.prev_start;\\r
- mem_end_stk[stk->zid] = stk->u.mem.prev_end;\\r
- }\\r
- else if (stk->type == STK_REPEAT_INC) {\\r
- STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\\r
- }\\r
- else if (stk->type == STK_MEM_END) {\\r
- mem_start_stk[stk->zid] = stk->u.mem.prev_start;\\r
- mem_end_stk[stk->zid] = stk->u.mem.prev_end;\\r
- }\\r
- POP_CALLOUT_CASE\\r
- }\\r
- }\\r
- break;\\r
- }\\r
-} while(0)\r
-\r
-#define POP_TIL_BODY(aname, til_type) do {\\r
- while (1) {\\r
- stk--;\\r
- STACK_BASE_CHECK(stk, (aname));\\r
- if ((stk->type & STK_MASK_POP_HANDLED_TIL) != 0) {\\r
- if (stk->type == (til_type)) break;\\r
- else {\\r
- if (stk->type == STK_MEM_START) {\\r
- mem_start_stk[stk->zid] = stk->u.mem.prev_start;\\r
- mem_end_stk[stk->zid] = stk->u.mem.prev_end;\\r
- }\\r
- else if (stk->type == STK_REPEAT_INC) {\\r
- STACK_AT(stk->u.repeat_inc.si)->u.repeat.count--;\\r
- }\\r
- else if (stk->type == STK_MEM_END) {\\r
- mem_start_stk[stk->zid] = stk->u.mem.prev_start;\\r
- mem_end_stk[stk->zid] = stk->u.mem.prev_end;\\r
- }\\r
- /* Don't call callout here because negation of total success by (?!..) (?<!..) */\\r
- }\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_POP_TIL_ALT_PREC_READ_NOT do {\\r
- POP_TIL_BODY("STACK_POP_TIL_ALT_PREC_READ_NOT", STK_ALT_PREC_READ_NOT);\\r
-} while(0)\r
-\r
-#define STACK_POP_TIL_ALT_LOOK_BEHIND_NOT do {\\r
- POP_TIL_BODY("STACK_POP_TIL_ALT_LOOK_BEHIND_NOT", STK_ALT_LOOK_BEHIND_NOT);\\r
-} while(0)\r
-\r
-\r
-#define STACK_EXEC_TO_VOID(k) do {\\r
- k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_EXEC_TO_VOID"); \\r
- if (IS_TO_VOID_TARGET(k)) {\\r
- if (k->type == STK_TO_VOID_START) {\\r
- k->type = STK_VOID;\\r
- break;\\r
- }\\r
- k->type = STK_VOID;\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_GET_PREC_READ_START(k) do {\\r
- int level = 0;\\r
- k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_GET_PREC_READ_START");\\r
- if (IS_TO_VOID_TARGET(k)) {\\r
- k->type = STK_VOID;\\r
- }\\r
- else if (k->type == STK_PREC_READ_START) {\\r
- if (level == 0) {\\r
- break;\\r
- }\\r
- level--;\\r
- }\\r
- else if (k->type == STK_PREC_READ_END) {\\r
- level++;\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_EMPTY_CHECK(isnull,sid,s) do {\\r
- StackType* k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_EMPTY_CHECK"); \\r
- if (k->type == STK_EMPTY_CHECK_START) {\\r
- if (k->zid == (sid)) {\\r
- (isnull) = (k->u.empty_check.pstr == (s));\\r
- break;\\r
- }\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_MEM_START_GET_PREV_END_ADDR(k /* STK_MEM_START*/, reg, addr) do {\\r
- if (k->u.mem.prev_end == INVALID_STACK_INDEX) {\\r
- (addr) = 0;\\r
- }\\r
- else {\\r
- if (MEM_STATUS_AT((reg)->bt_mem_end, k->zid))\\r
- (addr) = STACK_AT(k->u.mem.prev_end)->u.mem.pstr;\\r
- else\\r
- (addr) = (UChar* )k->u.mem.prev_end;\\r
- }\\r
-} while (0)\r
-\r
-#ifdef USE_STUBBORN_CHECK_CAPTURES_IN_EMPTY_REPEAT\r
-#define STACK_EMPTY_CHECK_MEM(isnull,sid,s,reg) do {\\r
- StackType* k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_EMPTY_CHECK_MEM"); \\r
- if (k->type == STK_EMPTY_CHECK_START) {\\r
- if (k->zid == (sid)) {\\r
- if (k->u.empty_check.pstr != (s)) {\\r
- (isnull) = 0;\\r
- break;\\r
- }\\r
- else {\\r
- UChar* endp;\\r
- int level = 0;\\r
- (isnull) = 1;\\r
- while (k < stk) {\\r
- if (k->type == STK_MEM_START && level == 0) {\\r
- STACK_MEM_START_GET_PREV_END_ADDR(k, reg, endp);\\r
- if (endp == 0) {\\r
- (isnull) = 0; break;\\r
- }\\r
- else if (STACK_AT(k->u.mem.prev_start)->u.mem.pstr != endp) {\\r
- (isnull) = 0; break;\\r
- }\\r
- else if (endp != s) {\\r
- (isnull) = -1; /* empty, but position changed */ \\r
- }\\r
- }\\r
- else if (k->type == STK_PREC_READ_START) {\\r
- level++;\\r
- }\\r
- else if (k->type == STK_PREC_READ_END) {\\r
- level--;\\r
- }\\r
- k++;\\r
- }\\r
- break;\\r
- }\\r
- }\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_EMPTY_CHECK_MEM_REC(isnull,sid,s,reg) do {\\r
- int level = 0;\\r
- StackType* k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_EMPTY_CHECK_MEM_REC");\\r
- if (k->type == STK_EMPTY_CHECK_START) {\\r
- if (k->zid == (sid)) {\\r
- if (level == 0) {\\r
- if (k->u.empty_check.pstr != (s)) {\\r
- (isnull) = 0;\\r
- break;\\r
- }\\r
- else {\\r
- UChar* endp;\\r
- int prec_level = 0;\\r
- (isnull) = 1;\\r
- while (k < stk) {\\r
- if (k->type == STK_MEM_START) {\\r
- if (level == 0 && prec_level == 0) {\\r
- STACK_MEM_START_GET_PREV_END_ADDR(k, reg, endp);\\r
- if (endp == 0) {\\r
- (isnull) = 0; break;\\r
- }\\r
- else if (STACK_AT(k->u.mem.prev_start)->u.mem.pstr != endp) { \\r
- (isnull) = 0; break;\\r
- }\\r
- else if (endp != s) {\\r
- (isnull) = -1; /* empty, but position changed */\\r
- }\\r
- }\\r
- }\\r
- else if (k->type == STK_EMPTY_CHECK_START) {\\r
- if (k->zid == (sid)) level++;\\r
- }\\r
- else if (k->type == STK_EMPTY_CHECK_END) {\\r
- if (k->zid == (sid)) level--;\\r
- }\\r
- else if (k->type == STK_PREC_READ_START) {\\r
- prec_level++;\\r
- }\\r
- else if (k->type == STK_PREC_READ_END) {\\r
- prec_level--;\\r
- }\\r
- k++;\\r
- }\\r
- break;\\r
- }\\r
- }\\r
- else {\\r
- level--;\\r
- }\\r
- }\\r
- }\\r
- else if (k->type == STK_EMPTY_CHECK_END) {\\r
- if (k->zid == (sid)) level++;\\r
- }\\r
- }\\r
-} while(0)\r
-#else\r
-#define STACK_EMPTY_CHECK_REC(isnull,id,s) do {\\r
- int level = 0;\\r
- StackType* k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_EMPTY_CHECK_REC"); \\r
- if (k->type == STK_EMPTY_CHECK_START) {\\r
- if (k->u.empty_check.num == (id)) {\\r
- if (level == 0) {\\r
- (isnull) = (k->u.empty_check.pstr == (s));\\r
- break;\\r
- }\\r
- }\\r
- level--;\\r
- }\\r
- else if (k->type == STK_EMPTY_CHECK_END) {\\r
- level++;\\r
- }\\r
- }\\r
-} while(0)\r
-#endif /* USE_STUBBORN_CHECK_CAPTURES_IN_EMPTY_REPEAT */\r
-\r
-#define STACK_GET_REPEAT(sid, k) do {\\r
- int level = 0;\\r
- k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_GET_REPEAT"); \\r
- if (k->type == STK_REPEAT) {\\r
- if (level == 0) {\\r
- if (k->zid == (sid)) {\\r
- break;\\r
- }\\r
- }\\r
- }\\r
- else if (k->type == STK_CALL_FRAME) level--;\\r
- else if (k->type == STK_RETURN) level++;\\r
- }\\r
-} while(0)\r
-\r
-#define STACK_RETURN(addr) do {\\r
- int level = 0;\\r
- StackType* k = stk;\\r
- while (1) {\\r
- k--;\\r
- STACK_BASE_CHECK(k, "STACK_RETURN"); \\r
- if (k->type == STK_CALL_FRAME) {\\r
- if (level == 0) {\\r
- (addr) = k->u.call_frame.ret_addr;\\r
- break;\\r
- }\\r
- else level--;\\r
- }\\r
- else if (k->type == STK_RETURN)\\r
- level++;\\r
- }\\r
-} while(0)\r
-\r
-\r
-#define STRING_CMP(s1,s2,len) do {\\r
- while (len-- > 0) {\\r
- if (*s1++ != *s2++) goto fail;\\r
- }\\r
-} while(0)\r
-\r
-#define STRING_CMP_IC(case_fold_flag,s1,ps2,len) do {\\r
- if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len) == 0) \\r
- goto fail; \\r
-} while(0)\r
-\r
-static int string_cmp_ic(OnigEncoding enc, int case_fold_flag,\r
- UChar* s1, UChar** ps2, int mblen)\r
-{\r
- UChar buf1[ONIGENC_MBC_CASE_FOLD_MAXLEN];\r
- UChar buf2[ONIGENC_MBC_CASE_FOLD_MAXLEN];\r
- UChar *p1, *p2, *end1, *s2, *end2;\r
- int len1, len2;\r
-\r
- s2 = *ps2;\r
- end1 = s1 + mblen;\r
- end2 = s2 + mblen;\r
- while (s1 < end1) {\r
- len1 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s1, end1, buf1);\r
- len2 = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &s2, end2, buf2);\r
- if (len1 != len2) return 0;\r
- p1 = buf1;\r
- p2 = buf2;\r
- while (len1-- > 0) {\r
- if (*p1 != *p2) return 0;\r
- p1++;\r
- p2++;\r
- }\r
- }\r
-\r
- *ps2 = s2;\r
- return 1;\r
-}\r
-\r
-#define STRING_CMP_VALUE(s1,s2,len,is_fail) do {\\r
- is_fail = 0;\\r
- while (len-- > 0) {\\r
- if (*s1++ != *s2++) {\\r
- is_fail = 1; break;\\r
- }\\r
- }\\r
-} while(0)\r
-\r
-#define STRING_CMP_VALUE_IC(case_fold_flag,s1,ps2,len,is_fail) do {\\r
- if (string_cmp_ic(encode, case_fold_flag, s1, ps2, len) == 0) \\r
- is_fail = 1; \\r
- else \\r
- is_fail = 0; \\r
-} while(0)\r
-\r
-\r
-#define IS_EMPTY_STR (str == end)\r
-#define ON_STR_BEGIN(s) ((s) == str)\r
-#define ON_STR_END(s) ((s) == end)\r
-#define DATA_ENSURE_CHECK1 (s < right_range)\r
-#define DATA_ENSURE_CHECK(n) (s + (n) <= right_range)\r
-#define DATA_ENSURE(n) if (s + (n) > right_range) goto fail\r
-\r
-#define INIT_RIGHT_RANGE right_range = (UChar* )in_right_range\r
-\r
-#ifdef USE_CAPTURE_HISTORY\r
-static int\r
-make_capture_history_tree(OnigCaptureTreeNode* node, StackType** kp,\r
- StackType* stk_top, UChar* str, regex_t* reg)\r
-{\r
- int n, r;\r
- OnigCaptureTreeNode* child;\r
- StackType* k = *kp;\r
-\r
- while (k < stk_top) {\r
- if (k->type == STK_MEM_START) {\r
- n = k->zid;\r
- if (n <= ONIG_MAX_CAPTURE_HISTORY_GROUP &&\r
- MEM_STATUS_AT(reg->capture_history, n) != 0) {\r
- child = history_node_new();\r
- CHECK_NULL_RETURN_MEMERR(child);\r
- child->group = n;\r
- child->beg = (int )(k->u.mem.pstr - str);\r
- r = history_tree_add_child(node, child);\r
- if (r != 0) return r;\r
- *kp = (k + 1);\r
- r = make_capture_history_tree(child, kp, stk_top, str, reg);\r
- if (r != 0) return r;\r
-\r
- k = *kp;\r
- child->end = (int )(k->u.mem.pstr - str);\r
- }\r
- }\r
- else if (k->type == STK_MEM_END) {\r
- if (k->zid == node->group) {\r
- node->end = (int )(k->u.mem.pstr - str);\r
- *kp = k;\r
- return 0;\r
- }\r
- }\r
- k++;\r
- }\r
-\r
- return 1; /* 1: root node ending. */\r
-}\r
-#endif\r
-\r
-#ifdef USE_BACKREF_WITH_LEVEL\r
-static int mem_is_in_memp(int mem, int num, MemNumType* memp)\r
-{\r
- int i;\r
-\r
- for (i = 0; i < num; i++) {\r
- if (mem == (int )memp[i]) return 1;\r
- }\r
- return 0;\r
-}\r
-\r
-static int\r
-backref_match_at_nested_level(regex_t* reg,\r
- StackType* top, StackType* stk_base,\r
- int ignore_case, int case_fold_flag,\r
- int nest, int mem_num, MemNumType* memp,\r
- UChar** s, const UChar* send)\r
-{\r
- UChar *ss, *p, *pstart, *pend = NULL_UCHARP;\r
- int level;\r
- StackType* k;\r
-\r
- level = 0;\r
- k = top;\r
- k--;\r
- while (k >= stk_base) {\r
- if (k->type == STK_CALL_FRAME) {\r
- level--;\r
- }\r
- else if (k->type == STK_RETURN) {\r
- level++;\r
- }\r
- else if (level == nest) {\r
- if (k->type == STK_MEM_START) {\r
- if (mem_is_in_memp(k->zid, mem_num, memp)) {\r
- pstart = k->u.mem.pstr;\r
- if (IS_NOT_NULL(pend)) {\r
- if (pend - pstart > send - *s) return 0; /* or goto next_mem; */\r
- p = pstart;\r
- ss = *s;\r
-\r
- if (ignore_case != 0) {\r
- if (string_cmp_ic(reg->enc, case_fold_flag,\r
- pstart, &ss, (int )(pend - pstart)) == 0)\r
- return 0; /* or goto next_mem; */\r
- }\r
- else {\r
- while (p < pend) {\r
- if (*p++ != *ss++) return 0; /* or goto next_mem; */\r
- }\r
- }\r
-\r
- *s = ss;\r
- return 1;\r
- }\r
- }\r
- }\r
- else if (k->type == STK_MEM_END) {\r
- if (mem_is_in_memp(k->zid, mem_num, memp)) {\r
- pend = k->u.mem.pstr;\r
- }\r
- }\r
- }\r
- k--;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-static int\r
-backref_check_at_nested_level(regex_t* reg,\r
- StackType* top, StackType* stk_base,\r
- int nest, int mem_num, MemNumType* memp)\r
-{\r
- int level;\r
- StackType* k;\r
-\r
- level = 0;\r
- k = top;\r
- k--;\r
- while (k >= stk_base) {\r
- if (k->type == STK_CALL_FRAME) {\r
- level--;\r
- }\r
- else if (k->type == STK_RETURN) {\r
- level++;\r
- }\r
- else if (level == nest) {\r
- if (k->type == STK_MEM_END) {\r
- if (mem_is_in_memp(k->zid, mem_num, memp)) {\r
- return 1;\r
- }\r
- }\r
- }\r
- k--;\r
- }\r
-\r
- return 0;\r
-}\r
-#endif /* USE_BACKREF_WITH_LEVEL */\r
-\r
-\r
-#ifdef ONIG_DEBUG_STATISTICS\r
-\r
-#define USE_TIMEOFDAY\r
-\r
-#ifdef USE_TIMEOFDAY\r
-#ifdef HAVE_SYS_TIME_H\r
-#include <sys/time.h>\r
-#endif\r
-#ifdef HAVE_UNISTD_H\r
-#include <unistd.h>\r
-#endif\r
-static struct timeval ts, te;\r
-#define GETTIME(t) gettimeofday(&(t), (struct timezone* )0)\r
-#define TIMEDIFF(te,ts) (((te).tv_usec - (ts).tv_usec) + \\r
- (((te).tv_sec - (ts).tv_sec)*1000000))\r
-#else\r
-#ifdef HAVE_SYS_TIMES_H\r
-#include <sys/times.h>\r
-#endif\r
-static struct tms ts, te;\r
-#define GETTIME(t) times(&(t))\r
-#define TIMEDIFF(te,ts) ((te).tms_utime - (ts).tms_utime)\r
-#endif\r
-\r
-static int OpCounter[256];\r
-static int OpPrevCounter[256];\r
-static unsigned long OpTime[256];\r
-static int OpCurr = OP_FINISH;\r
-static int OpPrevTarget = OP_FAIL;\r
-static int MaxStackDepth = 0;\r
-\r
-#define SOP_IN(opcode) do {\\r
- if (opcode == OpPrevTarget) OpPrevCounter[OpCurr]++;\\r
- OpCurr = opcode;\\r
- OpCounter[opcode]++;\\r
- GETTIME(ts);\\r
-} while(0)\r
-\r
-#define SOP_OUT do {\\r
- GETTIME(te);\\r
- OpTime[OpCurr] += TIMEDIFF(te, ts);\\r
-} while(0)\r
-\r
-extern void\r
-onig_statistics_init(void)\r
-{\r
- int i;\r
- for (i = 0; i < 256; i++) {\r
- OpCounter[i] = OpPrevCounter[i] = 0; OpTime[i] = 0;\r
- }\r
- MaxStackDepth = 0;\r
-}\r
-\r
-extern int\r
-onig_print_statistics(FILE* f)\r
-{\r
- int r;\r
- int i;\r
-\r
- r = fprintf(f, " count prev time\n");\r
- if (r < 0) return -1;\r
-\r
- for (i = 0; OpInfo[i].opcode >= 0; i++) {\r
- r = fprintf(f, "%8d: %8d: %10ld: %s\n",\r
- OpCounter[i], OpPrevCounter[i], OpTime[i], OpInfo[i].name);\r
- if (r < 0) return -1;\r
- }\r
- r = fprintf(f, "\nmax stack depth: %d\n", MaxStackDepth);\r
- if (r < 0) return -1;\r
-\r
- return 0;\r
-}\r
-\r
-#define STACK_INC do {\\r
- stk++;\\r
- if (stk - stk_base > MaxStackDepth) \\r
- MaxStackDepth = stk - stk_base;\\r
-} while(0)\r
-\r
-#else\r
-#define STACK_INC stk++\r
-\r
-#define SOP_IN(opcode)\r
-#define SOP_OUT\r
-#endif\r
-\r
-\r
-/* matching region of POSIX API */\r
-typedef int regoff_t;\r
-\r
-typedef struct {\r
- regoff_t rm_so;\r
- regoff_t rm_eo;\r
-} posix_regmatch_t;\r
-\r
-\r
-\r
-#ifdef USE_THREADED_CODE\r
-\r
-#define BYTECODE_INTERPRETER_START GOTO_OP;\r
-#define BYTECODE_INTERPRETER_END\r
-#define CASE_OP(x) L_##x: SOP_IN(OP_##x); sbegin = s; MATCH_DEBUG_OUT(0)\r
-#define DEFAULT_OP /* L_DEFAULT: */\r
-#define NEXT_OP sprev = sbegin; JUMP_OP\r
-#define JUMP_OP GOTO_OP\r
-#ifdef USE_DIRECT_THREADED_CODE\r
-#define GOTO_OP goto *(p->opaddr)\r
-#else\r
-#define GOTO_OP goto *opcode_to_label[p->opcode]\r
-#endif\r
-#define BREAK_OP /* Nothing */\r
-\r
-#else\r
-\r
-#define BYTECODE_INTERPRETER_START \\r
- while (1) {\\r
- MATCH_DEBUG_OUT(0)\\r
- sbegin = s;\\r
- switch (p->opcode) {\r
-#define BYTECODE_INTERPRETER_END } sprev = sbegin; }\r
-#define CASE_OP(x) case OP_##x: SOP_IN(OP_##x);\r
-#define DEFAULT_OP default:\r
-#define NEXT_OP break\r
-#define JUMP_OP GOTO_OP\r
-#define GOTO_OP continue; break\r
-#define BREAK_OP break\r
-\r
-#endif /* USE_THREADED_CODE */\r
-\r
-#define INC_OP p++\r
-#define NEXT_OUT SOP_OUT; NEXT_OP\r
-#define JUMP_OUT SOP_OUT; JUMP_OP\r
-#define BREAK_OUT SOP_OUT; BREAK_OP\r
-#define CHECK_INTERRUPT_JUMP_OUT SOP_OUT; CHECK_INTERRUPT_IN_MATCH; JUMP_OP\r
-\r
-\r
-#ifdef ONIG_DEBUG_MATCH\r
-#define MATCH_DEBUG_OUT(offset) do {\\r
- Operation *xp;\\r
- UChar *q, *bp, buf[50];\\r
- int len, spos;\\r
- spos = IS_NOT_NULL(s) ? (int )(s - str) : -1;\\r
- xp = p - (offset);\\r
- fprintf(stderr, "%7u: %7ld: %4d> \"",\\r
- counter, GET_STACK_INDEX(stk), spos);\\r
- counter++;\\r
- bp = buf;\\r
- if (IS_NOT_NULL(s)) {\\r
- for (i = 0, q = s; i < 7 && q < end; i++) {\\r
- len = enclen(encode, q);\\r
- while (len-- > 0) *bp++ = *q++;\\r
- }\\r
- if (q < end) { xmemcpy(bp, "...\"", 4); bp += 4; }\\r
- else { xmemcpy(bp, "\"", 1); bp += 1; }\\r
- }\\r
- else {\\r
- xmemcpy(bp, "\"", 1); bp += 1;\\r
- }\\r
- *bp = 0;\\r
- fputs((char* )buf, stderr);\\r
- for (i = 0; i < 20 - (bp - buf); i++) fputc(' ', stderr);\\r
- if (xp == FinishCode)\\r
- fprintf(stderr, "----: finish");\\r
- else {\\r
- fprintf(stderr, "%4d: ", (int )(xp - reg->ops));\\r
- print_compiled_byte_code(stderr, reg, (int )(xp - reg->ops), reg->ops, encode);\\r
- }\\r
- fprintf(stderr, "\n");\\r
- } while(0);\r
-#else\r
-#define MATCH_DEBUG_OUT(offset)\r
-#endif\r
-\r
-\r
-/* match data(str - end) from position (sstart). */\r
-/* if sstart == str then set sprev to NULL. */\r
-static int\r
-match_at(regex_t* reg, const UChar* str, const UChar* end,\r
- const UChar* in_right_range, const UChar* sstart, UChar* sprev,\r
- MatchArg* msa)\r
-{\r
-\r
-#if defined(USE_DIRECT_THREADED_CODE)\r
- static Operation FinishCode[] = { { .opaddr=&&L_FINISH } };\r
-#else\r
- static Operation FinishCode[] = { { OP_FINISH } };\r
-#endif\r
-\r
-#ifdef USE_THREADED_CODE\r
- static const void *opcode_to_label[] = {\r
- &&L_FINISH,\r
- &&L_END,\r
- &&L_EXACT1,\r
- &&L_EXACT2,\r
- &&L_EXACT3,\r
- &&L_EXACT4,\r
- &&L_EXACT5,\r
- &&L_EXACTN,\r
- &&L_EXACTMB2N1,\r
- &&L_EXACTMB2N2,\r
- &&L_EXACTMB2N3,\r
- &&L_EXACTMB2N,\r
- &&L_EXACTMB3N,\r
- &&L_EXACTMBN,\r
- &&L_EXACT1_IC,\r
- &&L_EXACTN_IC,\r
- &&L_CCLASS,\r
- &&L_CCLASS_MB,\r
- &&L_CCLASS_MIX,\r
- &&L_CCLASS_NOT,\r
- &&L_CCLASS_MB_NOT,\r
- &&L_CCLASS_MIX_NOT,\r
- &&L_ANYCHAR,\r
- &&L_ANYCHAR_ML,\r
- &&L_ANYCHAR_STAR,\r
- &&L_ANYCHAR_ML_STAR,\r
- &&L_ANYCHAR_STAR_PEEK_NEXT,\r
- &&L_ANYCHAR_ML_STAR_PEEK_NEXT,\r
- &&L_WORD,\r
- &&L_WORD_ASCII,\r
- &&L_NO_WORD,\r
- &&L_NO_WORD_ASCII,\r
- &&L_WORD_BOUNDARY,\r
- &&L_NO_WORD_BOUNDARY,\r
- &&L_WORD_BEGIN,\r
- &&L_WORD_END,\r
- &&L_TEXT_SEGMENT_BOUNDARY,\r
- &&L_BEGIN_BUF,\r
- &&L_END_BUF,\r
- &&L_BEGIN_LINE,\r
- &&L_END_LINE,\r
- &&L_SEMI_END_BUF,\r
- &&L_BEGIN_POSITION,\r
- &&L_BACKREF1,\r
- &&L_BACKREF2,\r
- &&L_BACKREF_N,\r
- &&L_BACKREF_N_IC,\r
- &&L_BACKREF_MULTI,\r
- &&L_BACKREF_MULTI_IC,\r
- &&L_BACKREF_WITH_LEVEL,\r
- &&L_BACKREF_WITH_LEVEL_IC,\r
- &&L_BACKREF_CHECK,\r
- &&L_BACKREF_CHECK_WITH_LEVEL,\r
- &&L_MEMORY_START,\r
- &&L_MEMORY_START_PUSH,\r
- &&L_MEMORY_END_PUSH,\r
- &&L_MEMORY_END_PUSH_REC,\r
- &&L_MEMORY_END,\r
- &&L_MEMORY_END_REC,\r
- &&L_FAIL,\r
- &&L_JUMP,\r
- &&L_PUSH,\r
- &&L_PUSH_SUPER,\r
- &&L_POP_OUT,\r
-#ifdef USE_OP_PUSH_OR_JUMP_EXACT\r
- &&L_PUSH_OR_JUMP_EXACT1,\r
-#endif\r
- &&L_PUSH_IF_PEEK_NEXT,\r
- &&L_REPEAT,\r
- &&L_REPEAT_NG,\r
- &&L_REPEAT_INC,\r
- &&L_REPEAT_INC_NG,\r
- &&L_REPEAT_INC_SG,\r
- &&L_REPEAT_INC_NG_SG,\r
- &&L_EMPTY_CHECK_START,\r
- &&L_EMPTY_CHECK_END,\r
- &&L_EMPTY_CHECK_END_MEMST,\r
- &&L_EMPTY_CHECK_END_MEMST_PUSH,\r
- &&L_PREC_READ_START,\r
- &&L_PREC_READ_END,\r
- &&L_PREC_READ_NOT_START,\r
- &&L_PREC_READ_NOT_END,\r
- &&L_ATOMIC_START,\r
- &&L_ATOMIC_END,\r
- &&L_LOOK_BEHIND,\r
- &&L_LOOK_BEHIND_NOT_START,\r
- &&L_LOOK_BEHIND_NOT_END,\r
- &&L_CALL,\r
- &&L_RETURN,\r
- &&L_PUSH_SAVE_VAL,\r
- &&L_UPDATE_VAR,\r
-#ifdef USE_CALLOUT\r
- &&L_CALLOUT_CONTENTS,\r
- &&L_CALLOUT_NAME,\r
-#endif\r
- };\r
-#endif\r
-\r
- int i, n, num_mem, best_len, pop_level;\r
- LengthType tlen, tlen2;\r
- MemNumType mem;\r
- RelAddrType addr;\r
- UChar *s, *q, *ps, *sbegin;\r
- UChar *right_range;\r
- int is_alloca;\r
- char *alloc_base;\r
- StackType *stk_base, *stk, *stk_end;\r
- StackType *stkp; /* used as any purpose. */\r
- StackIndex si;\r
- StackIndex *repeat_stk;\r
- StackIndex *mem_start_stk, *mem_end_stk;\r
- UChar* keep;\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- unsigned long retry_limit_in_match;\r
- unsigned long retry_in_match_counter;\r
-#endif\r
-\r
-#ifdef USE_CALLOUT\r
- int of;\r
-#endif\r
-\r
- Operation* p = reg->ops;\r
- OnigOptionType option = reg->options;\r
- OnigEncoding encode = reg->enc;\r
- OnigCaseFoldType case_fold_flag = reg->case_fold_flag;\r
-\r
-#ifdef ONIG_DEBUG_MATCH\r
- static unsigned int counter = 1;\r
-#endif\r
-\r
-#ifdef USE_DIRECT_THREADED_CODE\r
- if (IS_NULL(msa)) {\r
- for (i = 0; i < reg->ops_used; i++) {\r
- const void* addr;\r
- addr = opcode_to_label[reg->ocs[i]];\r
- p->opaddr = addr;\r
- p++;\r
- }\r
- return ONIG_NORMAL;\r
- }\r
-#endif\r
-\r
-#ifdef USE_CALLOUT\r
- msa->mp->match_at_call_counter++;\r
-#endif\r
-\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- retry_limit_in_match = msa->retry_limit_in_match;\r
-#endif\r
-\r
- pop_level = reg->stack_pop_level;\r
- num_mem = reg->num_mem;\r
- STACK_INIT(INIT_MATCH_STACK_SIZE);\r
- UPDATE_FOR_STACK_REALLOC;\r
- for (i = 1; i <= num_mem; i++) {\r
- mem_start_stk[i] = mem_end_stk[i] = INVALID_STACK_INDEX;\r
- }\r
-\r
-#ifdef ONIG_DEBUG_MATCH\r
- fprintf(stderr, "match_at: str: %p, end: %p, start: %p, sprev: %p\n",\r
- str, end, sstart, sprev);\r
- fprintf(stderr, "size: %d, start offset: %d\n",\r
- (int )(end - str), (int )(sstart - str));\r
-#endif\r
-\r
- best_len = ONIG_MISMATCH;\r
- keep = s = (UChar* )sstart;\r
- STACK_PUSH_BOTTOM(STK_ALT, FinishCode); /* bottom stack */\r
- INIT_RIGHT_RANGE;\r
-\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- retry_in_match_counter = 0;\r
-#endif\r
-\r
- BYTECODE_INTERPRETER_START {\r
- CASE_OP(END)\r
- n = (int )(s - sstart);\r
- if (n > best_len) {\r
- OnigRegion* region;\r
-#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE\r
- if (IS_FIND_LONGEST(option)) {\r
- if (n > msa->best_len) {\r
- msa->best_len = n;\r
- msa->best_s = (UChar* )sstart;\r
- }\r
- else\r
- goto end_best_len;\r
- }\r
-#endif\r
- best_len = n;\r
- region = msa->region;\r
- if (region) {\r
- if (keep > s) keep = s;\r
-\r
-#ifdef USE_POSIX_API_REGION_OPTION\r
- if (IS_POSIX_REGION(msa->options)) {\r
- posix_regmatch_t* rmt = (posix_regmatch_t* )region;\r
-\r
- rmt[0].rm_so = (regoff_t )(keep - str);\r
- rmt[0].rm_eo = (regoff_t )(s - str);\r
- for (i = 1; i <= num_mem; i++) {\r
- if (mem_end_stk[i] != INVALID_STACK_INDEX) {\r
- if (MEM_STATUS_AT(reg->bt_mem_start, i))\r
- rmt[i].rm_so = (regoff_t )(STACK_AT(mem_start_stk[i])->u.mem.pstr - str);\r
- else\r
- rmt[i].rm_so = (regoff_t )((UChar* )((void* )(mem_start_stk[i])) - str);\r
-\r
- rmt[i].rm_eo = (regoff_t )((MEM_STATUS_AT(reg->bt_mem_end, i)\r
- ? STACK_AT(mem_end_stk[i])->u.mem.pstr\r
- : (UChar* )((void* )mem_end_stk[i]))\r
- - str);\r
- }\r
- else {\r
- rmt[i].rm_so = rmt[i].rm_eo = ONIG_REGION_NOTPOS;\r
- }\r
- }\r
- }\r
- else {\r
-#endif /* USE_POSIX_API_REGION_OPTION */\r
- region->beg[0] = (int )(keep - str);\r
- region->end[0] = (int )(s - str);\r
- for (i = 1; i <= num_mem; i++) {\r
- if (mem_end_stk[i] != INVALID_STACK_INDEX) {\r
- if (MEM_STATUS_AT(reg->bt_mem_start, i))\r
- region->beg[i] = (int )(STACK_AT(mem_start_stk[i])->u.mem.pstr - str);\r
- else\r
- region->beg[i] = (int )((UChar* )((void* )mem_start_stk[i]) - str);\r
-\r
- region->end[i] = (int )((MEM_STATUS_AT(reg->bt_mem_end, i)\r
- ? STACK_AT(mem_end_stk[i])->u.mem.pstr\r
- : (UChar* )((void* )mem_end_stk[i])) - str);\r
- }\r
- else {\r
- region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;\r
- }\r
- }\r
-\r
-#ifdef USE_CAPTURE_HISTORY\r
- if (reg->capture_history != 0) {\r
- int r;\r
- OnigCaptureTreeNode* node;\r
-\r
- if (IS_NULL(region->history_root)) {\r
- region->history_root = node = history_node_new();\r
- CHECK_NULL_RETURN_MEMERR(node);\r
- }\r
- else {\r
- node = region->history_root;\r
- history_tree_clear(node);\r
- }\r
-\r
- node->group = 0;\r
- node->beg = (int )(keep - str);\r
- node->end = (int )(s - str);\r
-\r
- stkp = stk_base;\r
- r = make_capture_history_tree(region->history_root, &stkp,\r
- stk, (UChar* )str, reg);\r
- if (r < 0) {\r
- best_len = r; /* error code */\r
- goto finish;\r
- }\r
- }\r
-#endif /* USE_CAPTURE_HISTORY */\r
-#ifdef USE_POSIX_API_REGION_OPTION\r
- } /* else IS_POSIX_REGION() */\r
-#endif\r
- } /* if (region) */\r
- } /* n > best_len */\r
-\r
-#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE\r
- end_best_len:\r
-#endif\r
- SOP_OUT;\r
-\r
- if (IS_FIND_CONDITION(option)) {\r
- if (IS_FIND_NOT_EMPTY(option) && s == sstart) {\r
- best_len = ONIG_MISMATCH;\r
- goto fail; /* for retry */\r
- }\r
- if (IS_FIND_LONGEST(option) && DATA_ENSURE_CHECK1) {\r
- goto fail; /* for retry */\r
- }\r
- }\r
-\r
- /* default behavior: return first-matching result. */\r
- goto finish;\r
-\r
- CASE_OP(EXACT1)\r
- DATA_ENSURE(1);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- s++;\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(EXACT1_IC)\r
- {\r
- int len;\r
- UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];\r
-\r
- DATA_ENSURE(1);\r
- len = ONIGENC_MBC_CASE_FOLD(encode,\r
- /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */\r
- case_fold_flag,\r
- &s, end, lowbuf);\r
- DATA_ENSURE(0);\r
- q = lowbuf;\r
- ps = p->exact.s;\r
- while (len-- > 0) {\r
- if (*ps != *q) goto fail;\r
- ps++; q++;\r
- }\r
- }\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(EXACT2)\r
- DATA_ENSURE(2);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- sprev = s;\r
- s++;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACT3)\r
- DATA_ENSURE(3);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- sprev = s;\r
- s++;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACT4)\r
- DATA_ENSURE(4);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- sprev = s;\r
- s++;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACT5)\r
- DATA_ENSURE(5);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- sprev = s;\r
- s++;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTN)\r
- tlen = p->exact_n.n;\r
- DATA_ENSURE(tlen);\r
- ps = p->exact_n.s;\r
- while (tlen-- > 0) {\r
- if (*ps++ != *s++) goto fail;\r
- }\r
- sprev = s - 1;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTN_IC)\r
- {\r
- int len;\r
- UChar *q, *endp, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];\r
-\r
- tlen = p->exact_n.n;\r
- ps = p->exact_n.s;\r
- endp = ps + tlen;\r
- while (ps < endp) {\r
- sprev = s;\r
- DATA_ENSURE(1);\r
- len = ONIGENC_MBC_CASE_FOLD(encode,\r
- /* DISABLE_CASE_FOLD_MULTI_CHAR(case_fold_flag), */\r
- case_fold_flag,\r
- &s, end, lowbuf);\r
- DATA_ENSURE(0);\r
- q = lowbuf;\r
- while (len-- > 0) {\r
- if (*ps != *q) goto fail;\r
- ps++; q++;\r
- }\r
- }\r
- }\r
-\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTMB2N1)\r
- DATA_ENSURE(2);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- s++;\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(EXACTMB2N2)\r
- DATA_ENSURE(4);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- sprev = s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- s++;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTMB2N3)\r
- DATA_ENSURE(6);\r
- ps = p->exact.s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- sprev = s;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTMB2N)\r
- tlen = p->exact_n.n;\r
- DATA_ENSURE(tlen * 2);\r
- ps = p->exact_n.s;\r
- while (tlen-- > 0) {\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- }\r
- sprev = s - 2;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTMB3N)\r
- tlen = p->exact_n.n;\r
- DATA_ENSURE(tlen * 3);\r
- ps = p->exact_n.s;\r
- while (tlen-- > 0) {\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- }\r
- sprev = s - 3;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EXACTMBN)\r
- tlen = p->exact_len_n.len; /* mb byte len */\r
- tlen2 = p->exact_len_n.n; /* number of chars */\r
- tlen2 *= tlen;\r
- DATA_ENSURE(tlen2);\r
- ps = p->exact_len_n.s;\r
- while (tlen2-- > 0) {\r
- if (*ps != *s) goto fail;\r
- ps++; s++;\r
- }\r
- sprev = s - tlen;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(CCLASS)\r
- DATA_ENSURE(1);\r
- if (BITSET_AT(p->cclass.bsp, *s) == 0) goto fail;\r
- s++;\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(CCLASS_MB)\r
- DATA_ENSURE(1);\r
- if (! ONIGENC_IS_MBC_HEAD(encode, s)) goto fail;\r
-\r
- cclass_mb:\r
- {\r
- OnigCodePoint code;\r
- UChar *ss;\r
- int mb_len;\r
-\r
- DATA_ENSURE(1);\r
- mb_len = enclen(encode, s);\r
- DATA_ENSURE(mb_len);\r
- ss = s;\r
- s += mb_len;\r
- code = ONIGENC_MBC_TO_CODE(encode, ss, s);\r
- if (! onig_is_in_code_range(p->cclass_mb.mb, code)) goto fail;\r
- }\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(CCLASS_MIX)\r
- DATA_ENSURE(1);\r
- if (ONIGENC_IS_MBC_HEAD(encode, s)) {\r
- goto cclass_mb;\r
- }\r
- else {\r
- if (BITSET_AT(p->cclass_mix.bsp, *s) == 0)\r
- goto fail;\r
-\r
- s++;\r
- }\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(CCLASS_NOT)\r
- DATA_ENSURE(1);\r
- if (BITSET_AT(p->cclass.bsp, *s) != 0) goto fail;\r
- s += enclen(encode, s);\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(CCLASS_MB_NOT)\r
- DATA_ENSURE(1);\r
- if (! ONIGENC_IS_MBC_HEAD(encode, s)) {\r
- s++;\r
- goto cc_mb_not_success;\r
- }\r
-\r
- cclass_mb_not:\r
- {\r
- OnigCodePoint code;\r
- UChar *ss;\r
- int mb_len = enclen(encode, s);\r
-\r
- if (! DATA_ENSURE_CHECK(mb_len)) {\r
- DATA_ENSURE(1);\r
- s = (UChar* )end;\r
- goto cc_mb_not_success;\r
- }\r
-\r
- ss = s;\r
- s += mb_len;\r
- code = ONIGENC_MBC_TO_CODE(encode, ss, s);\r
- if (onig_is_in_code_range(p->cclass_mb.mb, code)) goto fail;\r
- }\r
-\r
- cc_mb_not_success:\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(CCLASS_MIX_NOT)\r
- DATA_ENSURE(1);\r
- if (ONIGENC_IS_MBC_HEAD(encode, s)) {\r
- goto cclass_mb_not;\r
- }\r
- else {\r
- if (BITSET_AT(p->cclass_mix.bsp, *s) != 0)\r
- goto fail;\r
-\r
- s++;\r
- }\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(ANYCHAR)\r
- DATA_ENSURE(1);\r
- n = enclen(encode, s);\r
- DATA_ENSURE(n);\r
- if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail;\r
- s += n;\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(ANYCHAR_ML)\r
- DATA_ENSURE(1);\r
- n = enclen(encode, s);\r
- DATA_ENSURE(n);\r
- s += n;\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(ANYCHAR_STAR)\r
- INC_OP;\r
- while (DATA_ENSURE_CHECK1) {\r
- STACK_PUSH_ALT(p, s, sprev);\r
- n = enclen(encode, s);\r
- DATA_ENSURE(n);\r
- if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail;\r
- sprev = s;\r
- s += n;\r
- }\r
- JUMP_OUT;\r
-\r
- CASE_OP(ANYCHAR_ML_STAR)\r
- INC_OP;\r
- while (DATA_ENSURE_CHECK1) {\r
- STACK_PUSH_ALT(p, s, sprev);\r
- n = enclen(encode, s);\r
- if (n > 1) {\r
- DATA_ENSURE(n);\r
- sprev = s;\r
- s += n;\r
- }\r
- else {\r
- sprev = s;\r
- s++;\r
- }\r
- }\r
- JUMP_OUT;\r
-\r
- CASE_OP(ANYCHAR_STAR_PEEK_NEXT)\r
- {\r
- UChar c;\r
-\r
- c = p->anychar_star_peek_next.c;\r
- INC_OP;\r
- while (DATA_ENSURE_CHECK1) {\r
- if (c == *s) {\r
- STACK_PUSH_ALT(p, s, sprev);\r
- }\r
- n = enclen(encode, s);\r
- DATA_ENSURE(n);\r
- if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) goto fail;\r
- sprev = s;\r
- s += n;\r
- }\r
- }\r
- NEXT_OUT;\r
-\r
- CASE_OP(ANYCHAR_ML_STAR_PEEK_NEXT)\r
- {\r
- UChar c;\r
-\r
- c = p->anychar_star_peek_next.c;\r
- INC_OP;\r
- while (DATA_ENSURE_CHECK1) {\r
- if (c == *s) {\r
- STACK_PUSH_ALT(p, s, sprev);\r
- }\r
- n = enclen(encode, s);\r
- if (n > 1) {\r
- DATA_ENSURE(n);\r
- sprev = s;\r
- s += n;\r
- }\r
- else {\r
- sprev = s;\r
- s++;\r
- }\r
- }\r
- }\r
- NEXT_OUT;\r
-\r
- CASE_OP(WORD)\r
- DATA_ENSURE(1);\r
- if (! ONIGENC_IS_MBC_WORD(encode, s, end))\r
- goto fail;\r
-\r
- s += enclen(encode, s);\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(WORD_ASCII)\r
- DATA_ENSURE(1);\r
- if (! ONIGENC_IS_MBC_WORD_ASCII(encode, s, end))\r
- goto fail;\r
-\r
- s += enclen(encode, s);\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(NO_WORD)\r
- DATA_ENSURE(1);\r
- if (ONIGENC_IS_MBC_WORD(encode, s, end))\r
- goto fail;\r
-\r
- s += enclen(encode, s);\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(NO_WORD_ASCII)\r
- DATA_ENSURE(1);\r
- if (ONIGENC_IS_MBC_WORD_ASCII(encode, s, end))\r
- goto fail;\r
-\r
- s += enclen(encode, s);\r
- INC_OP;\r
- NEXT_OUT;\r
-\r
- CASE_OP(WORD_BOUNDARY)\r
- {\r
- ModeType mode;\r
-\r
- mode = p->word_boundary.mode;\r
- if (ON_STR_BEGIN(s)) {\r
- DATA_ENSURE(1);\r
- if (! IS_MBC_WORD_ASCII_MODE(encode, s, end, mode))\r
- goto fail;\r
- }\r
- else if (ON_STR_END(s)) {\r
- if (! IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode))\r
- goto fail;\r
- }\r
- else {\r
- if (IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)\r
- == IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode))\r
- goto fail;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(NO_WORD_BOUNDARY)\r
- {\r
- ModeType mode;\r
-\r
- mode = p->word_boundary.mode;\r
- if (ON_STR_BEGIN(s)) {\r
- if (DATA_ENSURE_CHECK1 && IS_MBC_WORD_ASCII_MODE(encode, s, end, mode))\r
- goto fail;\r
- }\r
- else if (ON_STR_END(s)) {\r
- if (IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode))\r
- goto fail;\r
- }\r
- else {\r
- if (IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)\r
- != IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode))\r
- goto fail;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
-#ifdef USE_WORD_BEGIN_END\r
- CASE_OP(WORD_BEGIN)\r
- {\r
- ModeType mode;\r
-\r
- mode = p->word_boundary.mode;\r
- if (DATA_ENSURE_CHECK1 && IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) {\r
- if (ON_STR_BEGIN(s) || !IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- }\r
- }\r
- goto fail;\r
-\r
- CASE_OP(WORD_END)\r
- {\r
- ModeType mode;\r
-\r
- mode = p->word_boundary.mode;\r
- if (!ON_STR_BEGIN(s) && IS_MBC_WORD_ASCII_MODE(encode, sprev, end, mode)) {\r
- if (ON_STR_END(s) || ! IS_MBC_WORD_ASCII_MODE(encode, s, end, mode)) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- }\r
- }\r
- goto fail;\r
-#endif\r
-\r
- CASE_OP(TEXT_SEGMENT_BOUNDARY)\r
- {\r
- int is_break;\r
-\r
- switch (p->text_segment_boundary.type) {\r
- case EXTENDED_GRAPHEME_CLUSTER_BOUNDARY:\r
- is_break = onigenc_egcb_is_break_position(encode, s, sprev, str, end);\r
- break;\r
-#ifdef USE_UNICODE_WORD_BREAK\r
- case WORD_BOUNDARY:\r
- is_break = onigenc_wb_is_break_position(encode, s, sprev, str, end);\r
- break;\r
-#endif\r
- default:\r
- goto bytecode_error;\r
- break;\r
- }\r
-\r
- if (p->text_segment_boundary.not != 0)\r
- is_break = ! is_break;\r
-\r
- if (is_break != 0) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- else {\r
- goto fail;\r
- }\r
- }\r
-\r
- CASE_OP(BEGIN_BUF)\r
- if (! ON_STR_BEGIN(s)) goto fail;\r
-\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(END_BUF)\r
- if (! ON_STR_END(s)) goto fail;\r
-\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(BEGIN_LINE)\r
- if (ON_STR_BEGIN(s)) {\r
- if (IS_NOTBOL(msa->options)) goto fail;\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- else if (ONIGENC_IS_MBC_NEWLINE(encode, sprev, end) && !ON_STR_END(s)) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- goto fail;\r
-\r
- CASE_OP(END_LINE)\r
- if (ON_STR_END(s)) {\r
-#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE\r
- if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {\r
-#endif\r
- if (IS_NOTEOL(msa->options)) goto fail;\r
- INC_OP;\r
- JUMP_OUT;\r
-#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE\r
- }\r
-#endif\r
- }\r
- else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end)) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
-#ifdef USE_CRNL_AS_LINE_TERMINATOR\r
- else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
-#endif\r
- goto fail;\r
-\r
- CASE_OP(SEMI_END_BUF)\r
- if (ON_STR_END(s)) {\r
-#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE\r
- if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {\r
-#endif\r
- if (IS_NOTEOL(msa->options)) goto fail;\r
- INC_OP;\r
- JUMP_OUT;\r
-#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE\r
- }\r
-#endif\r
- }\r
- else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end) &&\r
- ON_STR_END(s + enclen(encode, s))) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
-#ifdef USE_CRNL_AS_LINE_TERMINATOR\r
- else if (ONIGENC_IS_MBC_CRNL(encode, s, end)) {\r
- UChar* ss = s + enclen(encode, s);\r
- ss += enclen(encode, ss);\r
- if (ON_STR_END(ss)) {\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- }\r
-#endif\r
- goto fail;\r
-\r
- CASE_OP(BEGIN_POSITION)\r
- if (s != msa->start)\r
- goto fail;\r
-\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(MEMORY_START_PUSH)\r
- mem = p->memory_start.num;\r
- STACK_PUSH_MEM_START(mem, s);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(MEMORY_START)\r
- mem = p->memory_start.num;\r
- mem_start_stk[mem] = (StackIndex )((void* )s);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(MEMORY_END_PUSH)\r
- mem = p->memory_end.num;\r
- STACK_PUSH_MEM_END(mem, s);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(MEMORY_END)\r
- mem = p->memory_end.num;\r
- mem_end_stk[mem] = (StackIndex )((void* )s);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
-#ifdef USE_CALL\r
- CASE_OP(MEMORY_END_PUSH_REC)\r
- mem = p->memory_end.num;\r
- STACK_GET_MEM_START(mem, stkp); /* should be before push mem-end. */\r
- si = GET_STACK_INDEX(stkp);\r
- STACK_PUSH_MEM_END(mem, s);\r
- mem_start_stk[mem] = si;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(MEMORY_END_REC)\r
- mem = p->memory_end.num;\r
- mem_end_stk[mem] = (StackIndex )((void* )s);\r
- STACK_GET_MEM_START(mem, stkp);\r
-\r
- if (MEM_STATUS_AT(reg->bt_mem_start, mem))\r
- mem_start_stk[mem] = GET_STACK_INDEX(stkp);\r
- else\r
- mem_start_stk[mem] = (StackIndex )((void* )stkp->u.mem.pstr);\r
-\r
- STACK_PUSH_MEM_END_MARK(mem);\r
- INC_OP;\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(BACKREF1)\r
- mem = 1;\r
- goto backref;\r
-\r
- CASE_OP(BACKREF2)\r
- mem = 2;\r
- goto backref;\r
-\r
- CASE_OP(BACKREF_N)\r
- mem = p->backref_n.n1;\r
- backref:\r
- {\r
- int len;\r
- UChar *pstart, *pend;\r
-\r
- if (mem_end_stk[mem] == INVALID_STACK_INDEX) goto fail;\r
- if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;\r
-\r
- if (MEM_STATUS_AT(reg->bt_mem_start, mem))\r
- pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;\r
- else\r
- pstart = (UChar* )((void* )mem_start_stk[mem]);\r
-\r
- pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)\r
- ? STACK_AT(mem_end_stk[mem])->u.mem.pstr\r
- : (UChar* )((void* )mem_end_stk[mem]));\r
- n = (int )(pend - pstart);\r
- if (n != 0) {\r
- DATA_ENSURE(n);\r
- sprev = s;\r
- STRING_CMP(s, pstart, n);\r
- while (sprev + (len = enclen(encode, sprev)) < s)\r
- sprev += len;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(BACKREF_N_IC)\r
- mem = p->backref_n.n1;\r
- {\r
- int len;\r
- UChar *pstart, *pend;\r
-\r
- if (mem_end_stk[mem] == INVALID_STACK_INDEX) goto fail;\r
- if (mem_start_stk[mem] == INVALID_STACK_INDEX) goto fail;\r
-\r
- if (MEM_STATUS_AT(reg->bt_mem_start, mem))\r
- pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;\r
- else\r
- pstart = (UChar* )((void* )mem_start_stk[mem]);\r
-\r
- pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)\r
- ? STACK_AT(mem_end_stk[mem])->u.mem.pstr\r
- : (UChar* )((void* )mem_end_stk[mem]));\r
- n = (int )(pend - pstart);\r
- if (n != 0) {\r
- DATA_ENSURE(n);\r
- sprev = s;\r
- STRING_CMP_IC(case_fold_flag, pstart, &s, n);\r
- while (sprev + (len = enclen(encode, sprev)) < s)\r
- sprev += len;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(BACKREF_MULTI)\r
- {\r
- int len, is_fail;\r
- UChar *pstart, *pend, *swork;\r
-\r
- tlen = p->backref_general.num;\r
- for (i = 0; i < tlen; i++) {\r
- mem = tlen == 1 ? p->backref_general.n1 : p->backref_general.ns[i];\r
-\r
- if (mem_end_stk[mem] == INVALID_STACK_INDEX) continue;\r
- if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;\r
-\r
- if (MEM_STATUS_AT(reg->bt_mem_start, mem))\r
- pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;\r
- else\r
- pstart = (UChar* )((void* )mem_start_stk[mem]);\r
-\r
- pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)\r
- ? STACK_AT(mem_end_stk[mem])->u.mem.pstr\r
- : (UChar* )((void* )mem_end_stk[mem]));\r
- n = (int )(pend - pstart);\r
- if (n != 0) {\r
- DATA_ENSURE(n);\r
- sprev = s;\r
- swork = s;\r
- STRING_CMP_VALUE(swork, pstart, n, is_fail);\r
- if (is_fail) continue;\r
- s = swork;\r
- while (sprev + (len = enclen(encode, sprev)) < s)\r
- sprev += len;\r
- }\r
- break; /* success */\r
- }\r
- if (i == tlen) goto fail;\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(BACKREF_MULTI_IC)\r
- {\r
- int len, is_fail;\r
- UChar *pstart, *pend, *swork;\r
-\r
- tlen = p->backref_general.num;\r
- for (i = 0; i < tlen; i++) {\r
- mem = tlen == 1 ? p->backref_general.n1 : p->backref_general.ns[i];\r
-\r
- if (mem_end_stk[mem] == INVALID_STACK_INDEX) continue;\r
- if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;\r
-\r
- if (MEM_STATUS_AT(reg->bt_mem_start, mem))\r
- pstart = STACK_AT(mem_start_stk[mem])->u.mem.pstr;\r
- else\r
- pstart = (UChar* )((void* )mem_start_stk[mem]);\r
-\r
- pend = (MEM_STATUS_AT(reg->bt_mem_end, mem)\r
- ? STACK_AT(mem_end_stk[mem])->u.mem.pstr\r
- : (UChar* )((void* )mem_end_stk[mem]));\r
- n = (int )(pend - pstart);\r
- if (n != 0) {\r
- DATA_ENSURE(n);\r
- sprev = s;\r
- swork = s;\r
- STRING_CMP_VALUE_IC(case_fold_flag, pstart, &swork, n, is_fail);\r
- if (is_fail) continue;\r
- s = swork;\r
- while (sprev + (len = enclen(encode, sprev)) < s)\r
- sprev += len;\r
- }\r
- break; /* success */\r
- }\r
- if (i == tlen) goto fail;\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
-#ifdef USE_BACKREF_WITH_LEVEL\r
- CASE_OP(BACKREF_WITH_LEVEL_IC)\r
- n = 1; /* ignore case */\r
- goto backref_with_level;\r
- CASE_OP(BACKREF_WITH_LEVEL)\r
- {\r
- int len;\r
- int level;\r
- MemNumType* mems;\r
- UChar* ssave;\r
-\r
- n = 0;\r
- backref_with_level:\r
- level = p->backref_general.nest_level;\r
- tlen = p->backref_general.num;\r
- mems = tlen == 1 ? &(p->backref_general.n1) : p->backref_general.ns;\r
-\r
- ssave = s;\r
- if (backref_match_at_nested_level(reg, stk, stk_base, n,\r
- case_fold_flag, level, (int )tlen, mems, &s, end)) {\r
- if (ssave != s) {\r
- sprev = ssave;\r
- while (sprev + (len = enclen(encode, sprev)) < s)\r
- sprev += len;\r
- }\r
- }\r
- else\r
- goto fail;\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(BACKREF_CHECK)\r
- {\r
- MemNumType* mems;\r
-\r
- tlen = p->backref_general.num;\r
- mems = tlen == 1 ? &(p->backref_general.n1) : p->backref_general.ns;\r
-\r
- for (i = 0; i < tlen; i++) {\r
- mem = mems[i];\r
- if (mem_end_stk[mem] == INVALID_STACK_INDEX) continue;\r
- if (mem_start_stk[mem] == INVALID_STACK_INDEX) continue;\r
- break; /* success */\r
- }\r
- if (i == tlen) goto fail;\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
-#ifdef USE_BACKREF_WITH_LEVEL\r
- CASE_OP(BACKREF_CHECK_WITH_LEVEL)\r
- {\r
- LengthType level;\r
- MemNumType* mems;\r
-\r
- level = p->backref_general.nest_level;\r
- tlen = p->backref_general.num;\r
- mems = tlen == 1 ? &(p->backref_general.n1) : p->backref_general.ns;\r
-\r
- if (backref_check_at_nested_level(reg, stk, stk_base,\r
- (int )level, (int )tlen, mems) == 0)\r
- goto fail;\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(EMPTY_CHECK_START)\r
- mem = p->empty_check_start.mem; /* mem: null check id */\r
- STACK_PUSH_EMPTY_CHECK_START(mem, s);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(EMPTY_CHECK_END)\r
- {\r
- int is_empty;\r
-\r
- mem = p->empty_check_end.mem; /* mem: null check id */\r
- STACK_EMPTY_CHECK(is_empty, mem, s);\r
- INC_OP;\r
- if (is_empty) {\r
-#ifdef ONIG_DEBUG_MATCH\r
- fprintf(stderr, "EMPTY_CHECK_END: skip id:%d, s:%p\n", (int )mem, s);\r
-#endif\r
- empty_check_found:\r
- /* empty loop founded, skip next instruction */\r
-#if defined(ONIG_DEBUG) && !defined(USE_DIRECT_THREADED_CODE)\r
- switch (p->opcode) {\r
- case OP_JUMP:\r
- case OP_PUSH:\r
- case OP_REPEAT_INC:\r
- case OP_REPEAT_INC_NG:\r
- case OP_REPEAT_INC_SG:\r
- case OP_REPEAT_INC_NG_SG:\r
- INC_OP;\r
- break;\r
- default:\r
- goto unexpected_bytecode_error;\r
- break;\r
- }\r
-#else\r
- INC_OP;\r
-#endif\r
- }\r
- }\r
- JUMP_OUT;\r
-\r
-#ifdef USE_STUBBORN_CHECK_CAPTURES_IN_EMPTY_REPEAT\r
- CASE_OP(EMPTY_CHECK_END_MEMST)\r
- {\r
- int is_empty;\r
-\r
- mem = p->empty_check_end.mem; /* mem: null check id */\r
- STACK_EMPTY_CHECK_MEM(is_empty, mem, s, reg);\r
- INC_OP;\r
- if (is_empty) {\r
-#ifdef ONIG_DEBUG_MATCH\r
- fprintf(stderr, "EMPTY_CHECK_END_MEM: skip id:%d, s:%p\n", (int)mem, s);\r
-#endif\r
- if (is_empty == -1) goto fail;\r
- goto empty_check_found;\r
- }\r
- }\r
- JUMP_OUT;\r
-#endif\r
-\r
-#ifdef USE_CALL\r
- CASE_OP(EMPTY_CHECK_END_MEMST_PUSH)\r
- {\r
- int is_empty;\r
-\r
- mem = p->empty_check_end.mem; /* mem: null check id */\r
-#ifdef USE_STUBBORN_CHECK_CAPTURES_IN_EMPTY_REPEAT\r
- STACK_EMPTY_CHECK_MEM_REC(is_empty, mem, s, reg);\r
-#else\r
- STACK_EMPTY_CHECK_REC(is_empty, mem, s);\r
-#endif\r
- INC_OP;\r
- if (is_empty) {\r
-#ifdef ONIG_DEBUG_MATCH\r
- fprintf(stderr, "EMPTY_CHECK_END_MEM_PUSH: skip id:%d, s:%p\n",\r
- (int )mem, s);\r
-#endif\r
- if (is_empty == -1) goto fail;\r
- goto empty_check_found;\r
- }\r
- else {\r
- STACK_PUSH_EMPTY_CHECK_END(mem);\r
- }\r
- }\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(JUMP)\r
- addr = p->jump.addr;\r
- p += addr;\r
- CHECK_INTERRUPT_JUMP_OUT;\r
-\r
- CASE_OP(PUSH)\r
- addr = p->push.addr;\r
- STACK_PUSH_ALT(p + addr, s, sprev);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(PUSH_SUPER)\r
- addr = p->push.addr;\r
- STACK_PUSH_SUPER_ALT(p + addr, s, sprev);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(POP_OUT)\r
- STACK_POP_ONE;\r
- /* for stop backtrack */\r
- /* CHECK_RETRY_LIMIT_IN_MATCH; */\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- #ifdef USE_OP_PUSH_OR_JUMP_EXACT\r
- CASE_OP(PUSH_OR_JUMP_EXACT1)\r
- {\r
- UChar c;\r
-\r
- addr = p->push_or_jump_exact1.addr;\r
- c = p->push_or_jump_exact1.c;\r
- if (DATA_ENSURE_CHECK1 && c == *s) {\r
- STACK_PUSH_ALT(p + addr, s, sprev);\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- }\r
- p += addr;\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(PUSH_IF_PEEK_NEXT)\r
- {\r
- UChar c;\r
-\r
- addr = p->push_if_peek_next.addr;\r
- c = p->push_if_peek_next.c;\r
- if (c == *s) {\r
- STACK_PUSH_ALT(p + addr, s, sprev);\r
- INC_OP;\r
- JUMP_OUT;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(REPEAT)\r
- mem = p->repeat.id; /* mem: OP_REPEAT ID */\r
- addr = p->repeat.addr;\r
-\r
- STACK_ENSURE(1);\r
- repeat_stk[mem] = GET_STACK_INDEX(stk);\r
- STACK_PUSH_REPEAT(mem, p + 1);\r
-\r
- if (reg->repeat_range[mem].lower == 0) {\r
- STACK_PUSH_ALT(p + addr, s, sprev);\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(REPEAT_NG)\r
- mem = p->repeat.id; /* mem: OP_REPEAT ID */\r
- addr = p->repeat.addr;\r
-\r
- STACK_ENSURE(1);\r
- repeat_stk[mem] = GET_STACK_INDEX(stk);\r
- STACK_PUSH_REPEAT(mem, p + 1);\r
-\r
- if (reg->repeat_range[mem].lower == 0) {\r
- STACK_PUSH_ALT(p + 1, s, sprev);\r
- p += addr;\r
- }\r
- else\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(REPEAT_INC)\r
- mem = p->repeat_inc.id; /* mem: OP_REPEAT ID */\r
- si = repeat_stk[mem];\r
- stkp = STACK_AT(si);\r
-\r
- repeat_inc:\r
- stkp->u.repeat.count++;\r
- if (stkp->u.repeat.count >= reg->repeat_range[mem].upper) {\r
- /* end of repeat. Nothing to do. */\r
- INC_OP;\r
- }\r
- else if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {\r
- INC_OP;\r
- STACK_PUSH_ALT(p, s, sprev);\r
- p = STACK_AT(si)->u.repeat.pcode; /* Don't use stkp after PUSH. */\r
- }\r
- else {\r
- p = stkp->u.repeat.pcode;\r
- }\r
- STACK_PUSH_REPEAT_INC(si);\r
- CHECK_INTERRUPT_JUMP_OUT;\r
-\r
- CASE_OP(REPEAT_INC_SG)\r
- mem = p->repeat_inc.id; /* mem: OP_REPEAT ID */\r
- STACK_GET_REPEAT(mem, stkp);\r
- si = GET_STACK_INDEX(stkp);\r
- goto repeat_inc;\r
-\r
- CASE_OP(REPEAT_INC_NG)\r
- mem = p->repeat_inc.id; /* mem: OP_REPEAT ID */\r
- si = repeat_stk[mem];\r
- stkp = STACK_AT(si);\r
-\r
- repeat_inc_ng:\r
- stkp->u.repeat.count++;\r
- if (stkp->u.repeat.count < reg->repeat_range[mem].upper) {\r
- if (stkp->u.repeat.count >= reg->repeat_range[mem].lower) {\r
- Operation* pcode = stkp->u.repeat.pcode;\r
-\r
- STACK_PUSH_REPEAT_INC(si);\r
- STACK_PUSH_ALT(pcode, s, sprev);\r
- INC_OP;\r
- }\r
- else {\r
- p = stkp->u.repeat.pcode;\r
- STACK_PUSH_REPEAT_INC(si);\r
- }\r
- }\r
- else if (stkp->u.repeat.count == reg->repeat_range[mem].upper) {\r
- STACK_PUSH_REPEAT_INC(si);\r
- INC_OP;\r
- }\r
- CHECK_INTERRUPT_JUMP_OUT;\r
-\r
- CASE_OP(REPEAT_INC_NG_SG)\r
- mem = p->repeat_inc.id; /* mem: OP_REPEAT ID */\r
- STACK_GET_REPEAT(mem, stkp);\r
- si = GET_STACK_INDEX(stkp);\r
- goto repeat_inc_ng;\r
-\r
- CASE_OP(PREC_READ_START)\r
- STACK_PUSH_PREC_READ_START(s, sprev);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(PREC_READ_END)\r
- STACK_GET_PREC_READ_START(stkp);\r
- s = stkp->u.state.pstr;\r
- sprev = stkp->u.state.pstr_prev;\r
- STACK_PUSH(STK_PREC_READ_END,0,0,0);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(PREC_READ_NOT_START)\r
- addr = p->prec_read_not_start.addr;\r
- STACK_PUSH_ALT_PREC_READ_NOT(p + addr, s, sprev);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(PREC_READ_NOT_END)\r
- STACK_POP_TIL_ALT_PREC_READ_NOT;\r
- goto fail;\r
-\r
- CASE_OP(ATOMIC_START)\r
- STACK_PUSH_TO_VOID_START;\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(ATOMIC_END)\r
- STACK_EXEC_TO_VOID(stkp);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(LOOK_BEHIND)\r
- tlen = p->look_behind.len;\r
- s = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen);\r
- if (IS_NULL(s)) goto fail;\r
- sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(LOOK_BEHIND_NOT_START)\r
- addr = p->look_behind_not_start.addr;\r
- tlen = p->look_behind_not_start.len;\r
- q = (UChar* )ONIGENC_STEP_BACK(encode, str, s, (int )tlen);\r
- if (IS_NULL(q)) {\r
- /* too short case -> success. ex. /(?<!XXX)a/.match("a")\r
- If you want to change to fail, replace following line. */\r
- p += addr;\r
- /* goto fail; */\r
- }\r
- else {\r
- STACK_PUSH_ALT_LOOK_BEHIND_NOT(p + addr, s, sprev);\r
- s = q;\r
- sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);\r
- INC_OP;\r
- }\r
- JUMP_OUT;\r
-\r
- CASE_OP(LOOK_BEHIND_NOT_END)\r
- STACK_POP_TIL_ALT_LOOK_BEHIND_NOT;\r
- INC_OP;\r
- goto fail;\r
-\r
-#ifdef USE_CALL\r
- CASE_OP(CALL)\r
- addr = p->call.addr;\r
- INC_OP; STACK_PUSH_CALL_FRAME(p);\r
- p = reg->ops + addr;\r
- JUMP_OUT;\r
-\r
- CASE_OP(RETURN)\r
- STACK_RETURN(p);\r
- STACK_PUSH_RETURN;\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(PUSH_SAVE_VAL)\r
- {\r
- SaveType type;\r
-\r
- type = p->push_save_val.type;\r
- mem = p->push_save_val.id; /* mem: save id */\r
- switch ((enum SaveType )type) {\r
- case SAVE_KEEP:\r
- STACK_PUSH_SAVE_VAL(mem, type, s);\r
- break;\r
-\r
- case SAVE_S:\r
- STACK_PUSH_SAVE_VAL_WITH_SPREV(mem, type, s);\r
- break;\r
-\r
- case SAVE_RIGHT_RANGE:\r
- STACK_PUSH_SAVE_VAL(mem, SAVE_RIGHT_RANGE, right_range);\r
- break;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
- CASE_OP(UPDATE_VAR)\r
- {\r
- UpdateVarType type;\r
- enum SaveType save_type;\r
-\r
- type = p->update_var.type;\r
- mem = p->update_var.id; /* mem: save id */\r
-\r
- switch ((enum UpdateVarType )type) {\r
- case UPDATE_VAR_KEEP_FROM_STACK_LAST:\r
- STACK_GET_SAVE_VAL_TYPE_LAST(SAVE_KEEP, keep);\r
- break;\r
- case UPDATE_VAR_S_FROM_STACK:\r
- STACK_GET_SAVE_VAL_TYPE_LAST_ID_WITH_SPREV(SAVE_S, mem, s);\r
- break;\r
- case UPDATE_VAR_RIGHT_RANGE_FROM_S_STACK:\r
- save_type = SAVE_S;\r
- goto get_save_val_type_last_id;\r
- break;\r
- case UPDATE_VAR_RIGHT_RANGE_FROM_STACK:\r
- save_type = SAVE_RIGHT_RANGE;\r
- get_save_val_type_last_id:\r
- STACK_GET_SAVE_VAL_TYPE_LAST_ID(save_type, mem, right_range);\r
- break;\r
- case UPDATE_VAR_RIGHT_RANGE_INIT:\r
- INIT_RIGHT_RANGE;\r
- break;\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-\r
-#ifdef USE_CALLOUT\r
- CASE_OP(CALLOUT_CONTENTS)\r
- of = ONIG_CALLOUT_OF_CONTENTS;\r
- mem = p->callout_contents.num;\r
- goto callout_common_entry;\r
- BREAK_OUT;\r
-\r
- CASE_OP(CALLOUT_NAME)\r
- {\r
- int call_result;\r
- int name_id;\r
- int in;\r
- CalloutListEntry* e;\r
- OnigCalloutFunc func;\r
- OnigCalloutArgs args;\r
-\r
- of = ONIG_CALLOUT_OF_NAME;\r
- name_id = p->callout_name.id;\r
- mem = p->callout_name.num;\r
-\r
- callout_common_entry:\r
- e = onig_reg_callout_list_at(reg, mem);\r
- in = e->in;\r
- if (of == ONIG_CALLOUT_OF_NAME) {\r
- func = onig_get_callout_start_func(reg, mem);\r
- }\r
- else {\r
- name_id = ONIG_NON_NAME_ID;\r
- func = msa->mp->progress_callout_of_contents;\r
- }\r
-\r
- if (IS_NOT_NULL(func) && (in & ONIG_CALLOUT_IN_PROGRESS) != 0) {\r
- CALLOUT_BODY(func, ONIG_CALLOUT_IN_PROGRESS, name_id,\r
- (int )mem, msa->mp->callout_user_data, args, call_result);\r
- switch (call_result) {\r
- case ONIG_CALLOUT_FAIL:\r
- goto fail;\r
- break;\r
- case ONIG_CALLOUT_SUCCESS:\r
- goto retraction_callout2;\r
- break;\r
- default: /* error code */\r
- if (call_result > 0) {\r
- call_result = ONIGERR_INVALID_ARGUMENT;\r
- }\r
- best_len = call_result;\r
- goto finish;\r
- break;\r
- }\r
- }\r
- else {\r
- retraction_callout2:\r
- if ((in & ONIG_CALLOUT_IN_RETRACTION) != 0) {\r
- if (of == ONIG_CALLOUT_OF_NAME) {\r
- if (IS_NOT_NULL(func)) {\r
- STACK_PUSH_CALLOUT_NAME(name_id, mem, func);\r
- }\r
- }\r
- else {\r
- func = msa->mp->retraction_callout_of_contents;\r
- if (IS_NOT_NULL(func)) {\r
- STACK_PUSH_CALLOUT_CONTENTS(mem, func);\r
- }\r
- }\r
- }\r
- }\r
- }\r
- INC_OP;\r
- JUMP_OUT;\r
-#endif\r
-\r
- CASE_OP(FINISH)\r
- goto finish;\r
-\r
-#ifdef ONIG_DEBUG_STATISTICS\r
- fail:\r
- SOP_OUT;\r
- goto fail2;\r
-#endif\r
- CASE_OP(FAIL)\r
-#ifdef ONIG_DEBUG_STATISTICS\r
- fail2:\r
-#else\r
- fail:\r
-#endif\r
- STACK_POP;\r
- p = stk->u.state.pcode;\r
- s = stk->u.state.pstr;\r
- sprev = stk->u.state.pstr_prev;\r
- CHECK_RETRY_LIMIT_IN_MATCH;\r
- JUMP_OUT;\r
-\r
- DEFAULT_OP\r
- goto bytecode_error;\r
-\r
- } BYTECODE_INTERPRETER_END;\r
-\r
- finish:\r
- STACK_SAVE;\r
- return best_len;\r
-\r
-#ifdef ONIG_DEBUG\r
- stack_error:\r
- STACK_SAVE;\r
- return ONIGERR_STACK_BUG;\r
-#endif\r
-\r
- bytecode_error:\r
- STACK_SAVE;\r
- return ONIGERR_UNDEFINED_BYTECODE;\r
-\r
-#if defined(ONIG_DEBUG) && !defined(USE_DIRECT_THREADED_CODE)\r
- unexpected_bytecode_error:\r
- STACK_SAVE;\r
- return ONIGERR_UNEXPECTED_BYTECODE;\r
-#endif\r
-\r
-#ifdef USE_RETRY_LIMIT_IN_MATCH\r
- retry_limit_in_match_over:\r
- STACK_SAVE;\r
- return ONIGERR_RETRY_LIMIT_IN_MATCH_OVER;\r
-#endif\r
-}\r
-\r
-\r
-static UChar*\r
-slow_search(OnigEncoding enc, UChar* target, UChar* target_end,\r
- const UChar* text, const UChar* text_end, UChar* text_range)\r
-{\r
- UChar *t, *p, *s, *end;\r
-\r
- end = (UChar* )text_end;\r
- end -= target_end - target - 1;\r
- if (end > text_range)\r
- end = text_range;\r
-\r
- s = (UChar* )text;\r
-\r
- while (s < end) {\r
- if (*s == *target) {\r
- p = s + 1;\r
- t = target + 1;\r
- while (t < target_end) {\r
- if (*t != *p++)\r
- break;\r
- t++;\r
- }\r
- if (t == target_end)\r
- return s;\r
- }\r
- s += enclen(enc, s);\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-static int\r
-str_lower_case_match(OnigEncoding enc, int case_fold_flag,\r
- const UChar* t, const UChar* tend,\r
- const UChar* p, const UChar* end)\r
-{\r
- int lowlen;\r
- UChar *q, lowbuf[ONIGENC_MBC_CASE_FOLD_MAXLEN];\r
-\r
- while (t < tend) {\r
- lowlen = ONIGENC_MBC_CASE_FOLD(enc, case_fold_flag, &p, end, lowbuf);\r
- q = lowbuf;\r
- while (lowlen > 0) {\r
- if (*t++ != *q++) return 0;\r
- lowlen--;\r
- }\r
- }\r
-\r
- return 1;\r
-}\r
-\r
-static UChar*\r
-slow_search_ic(OnigEncoding enc, int case_fold_flag,\r
- UChar* target, UChar* target_end,\r
- const UChar* text, const UChar* text_end, UChar* text_range)\r
-{\r
- UChar *s, *end;\r
-\r
- end = (UChar* )text_end;\r
- end -= target_end - target - 1;\r
- if (end > text_range)\r
- end = text_range;\r
-\r
- s = (UChar* )text;\r
-\r
- while (s < end) {\r
- if (str_lower_case_match(enc, case_fold_flag, target, target_end,\r
- s, text_end))\r
- return s;\r
-\r
- s += enclen(enc, s);\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-static UChar*\r
-slow_search_backward(OnigEncoding enc, UChar* target, UChar* target_end,\r
- const UChar* text, const UChar* adjust_text,\r
- const UChar* text_end, const UChar* text_start)\r
-{\r
- UChar *t, *p, *s;\r
-\r
- s = (UChar* )text_end;\r
- s -= (target_end - target);\r
- if (s > text_start)\r
- s = (UChar* )text_start;\r
- else\r
- s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s);\r
-\r
- while (s >= text) {\r
- //if text is not null,the logic is correct.\r
- //this function is only invoked by backward_search_range,parameter text come\r
- //from range, which is checked by "if (range == 0) goto fail" in line 4512\r
- //so the check is just for passing static analysis.\r
- if(IS_NULL(s))break;\r
- if (*s == *target) {\r
- p = s + 1;\r
- t = target + 1;\r
- while (t < target_end) {\r
- if (*t != *p++)\r
- break;\r
- t++;\r
- }\r
- if (t == target_end)\r
- return s;\r
- }\r
- s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s);\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-static UChar*\r
-slow_search_backward_ic(OnigEncoding enc, int case_fold_flag,\r
- UChar* target, UChar* target_end,\r
- const UChar* text, const UChar* adjust_text,\r
- const UChar* text_end, const UChar* text_start)\r
-{\r
- UChar *s;\r
-\r
- s = (UChar* )text_end;\r
- s -= (target_end - target);\r
- if (s > text_start)\r
- s = (UChar* )text_start;\r
- else\r
- s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, adjust_text, s);\r
-\r
- while (s >= text) {\r
- if (str_lower_case_match(enc, case_fold_flag,\r
- target, target_end, s, text_end))\r
- return s;\r
-\r
- s = (UChar* )onigenc_get_prev_char_head(enc, adjust_text, s);\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-\r
-static UChar*\r
-sunday_quick_search_step_forward(regex_t* reg,\r
- const UChar* target, const UChar* target_end,\r
- const UChar* text, const UChar* text_end,\r
- const UChar* text_range)\r
-{\r
- const UChar *s, *se, *t, *p, *end;\r
- const UChar *tail;\r
- int skip, tlen1;\r
- int map_offset;\r
- OnigEncoding enc;\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr,\r
- "sunday_quick_search_step_forward: text: %p, text_end: %p, text_range: %p\n", text, text_end, text_range);\r
-#endif\r
-\r
- enc = reg->enc;\r
-\r
- tail = target_end - 1;\r
- tlen1 = (int )(tail - target);\r
- end = text_range;\r
- if (end + tlen1 > text_end)\r
- end = text_end - tlen1;\r
-\r
- map_offset = reg->map_offset;\r
- s = text;\r
-\r
- while (s < end) {\r
- p = se = s + tlen1;\r
- t = tail;\r
- while (*p == *t) {\r
- if (t == target) return (UChar* )s;\r
- p--; t--;\r
- }\r
- if (se + map_offset >= text_end) break;\r
- skip = reg->map[*(se + map_offset)];\r
-#if 0\r
- t = s;\r
- do {\r
- s += enclen(enc, s);\r
- } while ((s - t) < skip && s < end);\r
-#else\r
- s += skip;\r
- if (s < end)\r
- s = onigenc_get_right_adjust_char_head(enc, text, s);\r
-#endif\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-static UChar*\r
-sunday_quick_search(regex_t* reg, const UChar* target, const UChar* target_end,\r
- const UChar* text, const UChar* text_end,\r
- const UChar* text_range)\r
-{\r
- const UChar *s, *t, *p, *end;\r
- const UChar *tail;\r
- int map_offset;\r
-\r
- end = text_range + (target_end - target);\r
- if (end > text_end)\r
- end = text_end;\r
-\r
- map_offset = reg->map_offset;\r
- tail = target_end - 1;\r
- s = text + (tail - target);\r
-\r
- while (s < end) {\r
- p = s;\r
- t = tail;\r
- while (*p == *t) {\r
- if (t == target) return (UChar* )p;\r
- p--; t--;\r
- }\r
- if (s + map_offset >= text_end) break;\r
- s += reg->map[*(s + map_offset)];\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-static UChar*\r
-sunday_quick_search_case_fold(regex_t* reg,\r
- const UChar* target, const UChar* target_end,\r
- const UChar* text, const UChar* text_end,\r
- const UChar* text_range)\r
-{\r
- const UChar *s, *se, *end;\r
- const UChar *tail;\r
- int skip, tlen1;\r
- int map_offset;\r
- int case_fold_flag;\r
- OnigEncoding enc;\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr,\r
- "sunday_quick_search_case_fold: text: %p, text_end: %p, text_range: %p\n", text, text_end, text_range);\r
-#endif\r
-\r
- enc = reg->enc;\r
- case_fold_flag = reg->case_fold_flag;\r
-\r
- tail = target_end - 1;\r
- tlen1 = (int )(tail - target);\r
- end = text_range;\r
- if (end + tlen1 > text_end)\r
- end = text_end - tlen1;\r
-\r
- map_offset = reg->map_offset;\r
- s = text;\r
-\r
- while (s < end) {\r
- if (str_lower_case_match(enc, case_fold_flag, target, target_end,\r
- s, text_end))\r
- return (UChar* )s;\r
-\r
- se = s + tlen1;\r
- if (se + map_offset >= text_end) break;\r
- skip = reg->map[*(se + map_offset)];\r
-#if 0\r
- p = s;\r
- do {\r
- s += enclen(enc, s);\r
- } while ((s - p) < skip && s < end);\r
-#else\r
- /* This is faster than prev code for long text. ex: /(?i)Twain/ */\r
- s += skip;\r
- if (s < end)\r
- s = onigenc_get_right_adjust_char_head(enc, text, s);\r
-#endif\r
- }\r
-\r
- return (UChar* )NULL;\r
-}\r
-\r
-static UChar*\r
-map_search(OnigEncoding enc, UChar map[],\r
- const UChar* text, const UChar* text_range)\r
-{\r
- const UChar *s = text;\r
-\r
- while (s < text_range) {\r
- if (map[*s]) return (UChar* )s;\r
-\r
- s += enclen(enc, s);\r
- }\r
- return (UChar* )NULL;\r
-}\r
-\r
-static UChar*\r
-map_search_backward(OnigEncoding enc, UChar map[],\r
- const UChar* text, const UChar* adjust_text,\r
- const UChar* text_start)\r
-{\r
- const UChar *s = text_start;\r
-\r
- while (s >= text) {\r
- //if text is not null,the logic is correct.\r
- //this function is only invoked by backward_search_range,parameter text come\r
- //from range, which is checked by "if (range == 0) goto fail" in line 4512\r
- //so the check is just for passing static analysis.\r
- if(IS_NULL(s))break;\r
- if (map[*s]) return (UChar* )s;\r
-\r
- s = onigenc_get_prev_char_head(enc, adjust_text, s);\r
- }\r
- return (UChar* )NULL;\r
-}\r
-extern int\r
-onig_match(regex_t* reg, const UChar* str, const UChar* end, const UChar* at,\r
- OnigRegion* region, OnigOptionType option)\r
-{\r
- int r;\r
- OnigMatchParam mp;\r
-\r
- onig_initialize_match_param(&mp);\r
- r = onig_match_with_param(reg, str, end, at, region, option, &mp);\r
- onig_free_match_param_content(&mp);\r
- return r;\r
-}\r
-\r
-extern int\r
-onig_match_with_param(regex_t* reg, const UChar* str, const UChar* end,\r
- const UChar* at, OnigRegion* region, OnigOptionType option,\r
- OnigMatchParam* mp)\r
-{\r
- int r;\r
- UChar *prev;\r
- MatchArg msa;\r
-\r
- ADJUST_MATCH_PARAM(reg, mp);\r
- MATCH_ARG_INIT(msa, reg, option, region, at, mp);\r
- if (region\r
-#ifdef USE_POSIX_API_REGION_OPTION\r
- && !IS_POSIX_REGION(option)\r
-#endif\r
- ) {\r
- r = onig_region_resize_clear(region, reg->num_mem + 1);\r
- }\r
- else\r
- r = 0;\r
-\r
- if (r == 0) {\r
- if (ONIG_IS_OPTION_ON(option, ONIG_OPTION_CHECK_VALIDITY_OF_STRING)) {\r
- if (! ONIGENC_IS_VALID_MBC_STRING(reg->enc, str, end)) {\r
- r = ONIGERR_INVALID_WIDE_CHAR_VALUE;\r
- goto end;\r
- }\r
- }\r
-\r
- prev = (UChar* )onigenc_get_prev_char_head(reg->enc, str, at);\r
- r = match_at(reg, str, end, end, at, prev, &msa);\r
- }\r
-\r
- end:\r
- MATCH_ARG_FREE(msa);\r
- return r;\r
-}\r
-\r
-static int\r
-forward_search_range(regex_t* reg, const UChar* str, const UChar* end, UChar* s,\r
- UChar* range, UChar** low, UChar** high, UChar** low_prev)\r
-{\r
- UChar *p, *pprev = (UChar* )NULL;\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr, "forward_search_range: str: %p, end: %p, s: %p, range: %p\n",\r
- str, end, s, range);\r
-#endif\r
-\r
- p = s;\r
- if (reg->dmin > 0) {\r
- if (ONIGENC_IS_SINGLEBYTE(reg->enc)) {\r
- p += reg->dmin;\r
- }\r
- else {\r
- UChar *q = p + reg->dmin;\r
-\r
- if (q >= end) return 0; /* fail */\r
- while (p < q) p += enclen(reg->enc, p);\r
- }\r
- }\r
-\r
- retry:\r
- switch (reg->optimize) {\r
- case OPTIMIZE_STR:\r
- p = slow_search(reg->enc, reg->exact, reg->exact_end, p, end, range);\r
- break;\r
- case OPTIMIZE_STR_CASE_FOLD:\r
- p = slow_search_ic(reg->enc, reg->case_fold_flag,\r
- reg->exact, reg->exact_end, p, end, range);\r
- break;\r
-\r
- case OPTIMIZE_STR_CASE_FOLD_FAST:\r
- p = sunday_quick_search_case_fold(reg, reg->exact, reg->exact_end, p, end,\r
- range);\r
- break;\r
-\r
- case OPTIMIZE_STR_FAST:\r
- p = sunday_quick_search(reg, reg->exact, reg->exact_end, p, end, range);\r
- break;\r
-\r
- case OPTIMIZE_STR_FAST_STEP_FORWARD:\r
- p = sunday_quick_search_step_forward(reg, reg->exact, reg->exact_end,\r
- p, end, range);\r
- break;\r
-\r
- case OPTIMIZE_MAP:\r
- p = map_search(reg->enc, reg->map, p, range);\r
- break;\r
- }\r
-\r
- if (p && p < range) {\r
- if (p - reg->dmin < s) {\r
- retry_gate:\r
- pprev = p;\r
- p += enclen(reg->enc, p);\r
- goto retry;\r
- }\r
-\r
- if (reg->sub_anchor) {\r
- UChar* prev;\r
-\r
- switch (reg->sub_anchor) {\r
- case ANCR_BEGIN_LINE:\r
- if (!ON_STR_BEGIN(p)) {\r
- prev = onigenc_get_prev_char_head(reg->enc,\r
- (pprev ? pprev : str), p);\r
- if (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))\r
- goto retry_gate;\r
- }\r
- break;\r
-\r
- case ANCR_END_LINE:\r
- if (ON_STR_END(p)) {\r
-#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE\r
- prev = (UChar* )onigenc_get_prev_char_head(reg->enc,\r
- (pprev ? pprev : str), p);\r
- if (prev && ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end))\r
- goto retry_gate;\r
-#endif\r
- }\r
- else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)\r
-#ifdef USE_CRNL_AS_LINE_TERMINATOR\r
- && ! ONIGENC_IS_MBC_CRNL(reg->enc, p, end)\r
-#endif\r
- )\r
- goto retry_gate;\r
- break;\r
- }\r
- }\r
-\r
- if (reg->dmax == 0) {\r
- *low = p;\r
- if (low_prev) {\r
- if (*low > s)\r
- *low_prev = onigenc_get_prev_char_head(reg->enc, s, p);\r
- else\r
- *low_prev = onigenc_get_prev_char_head(reg->enc,\r
- (pprev ? pprev : str), p);\r
- }\r
- }\r
- else {\r
- if (reg->dmax != INFINITE_LEN) {\r
- if (p - str < reg->dmax) {\r
- *low = (UChar* )str;\r
- if (low_prev)\r
- *low_prev = onigenc_get_prev_char_head(reg->enc, str, *low);\r
- }\r
- else {\r
- *low = p - reg->dmax;\r
- if (*low > s) {\r
- *low = onigenc_get_right_adjust_char_head_with_prev(reg->enc, s,\r
- *low, (const UChar** )low_prev);\r
- if (low_prev && IS_NULL(*low_prev))\r
- *low_prev = onigenc_get_prev_char_head(reg->enc,\r
- (pprev ? pprev : s), *low);\r
- }\r
- else {\r
- if (low_prev)\r
- *low_prev = onigenc_get_prev_char_head(reg->enc,\r
- (pprev ? pprev : str), *low);\r
- }\r
- }\r
- }\r
- }\r
- /* no needs to adjust *high, *high is used as range check only */\r
- *high = p - reg->dmin;\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr,\r
- "forward_search_range success: low: %d, high: %d, dmin: %d, dmax: %d\n",\r
- (int )(*low - str), (int )(*high - str), reg->dmin, reg->dmax);\r
-#endif\r
- return 1; /* success */\r
- }\r
-\r
- return 0; /* fail */\r
-}\r
-\r
-\r
-static int\r
-backward_search_range(regex_t* reg, const UChar* str, const UChar* end,\r
- UChar* s, const UChar* range, UChar* adjrange,\r
- UChar** low, UChar** high)\r
-{\r
- UChar *p;\r
-\r
- if (range == 0) goto fail;\r
-\r
- range += reg->dmin;\r
- p = s;\r
-\r
- retry:\r
- switch (reg->optimize) {\r
- case OPTIMIZE_STR:\r
- exact_method:\r
- p = slow_search_backward(reg->enc, reg->exact, reg->exact_end,\r
- range, adjrange, end, p);\r
- break;\r
-\r
- case OPTIMIZE_STR_CASE_FOLD:\r
- case OPTIMIZE_STR_CASE_FOLD_FAST:\r
- p = slow_search_backward_ic(reg->enc, reg->case_fold_flag,\r
- reg->exact, reg->exact_end,\r
- range, adjrange, end, p);\r
- break;\r
-\r
- case OPTIMIZE_STR_FAST:\r
- case OPTIMIZE_STR_FAST_STEP_FORWARD:\r
- goto exact_method;\r
- break;\r
-\r
- case OPTIMIZE_MAP:\r
- p = map_search_backward(reg->enc, reg->map, range, adjrange, p);\r
- break;\r
- }\r
-\r
- if (p) {\r
- if (reg->sub_anchor) {\r
- UChar* prev;\r
-\r
- switch (reg->sub_anchor) {\r
- case ANCR_BEGIN_LINE:\r
- if (!ON_STR_BEGIN(p)) {\r
- prev = onigenc_get_prev_char_head(reg->enc, str, p);\r
- if (IS_NOT_NULL(prev) && !ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {\r
- p = prev;\r
- goto retry;\r
- }\r
- }\r
- break;\r
-\r
- case ANCR_END_LINE:\r
- if (ON_STR_END(p)) {\r
-#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE\r
- prev = onigenc_get_prev_char_head(reg->enc, adjrange, p);\r
- if (IS_NULL(prev)) goto fail;\r
- if (ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end)) {\r
- p = prev;\r
- goto retry;\r
- }\r
-#endif\r
- }\r
- else if (! ONIGENC_IS_MBC_NEWLINE(reg->enc, p, end)\r
-#ifdef USE_CRNL_AS_LINE_TERMINATOR\r
- && ! ONIGENC_IS_MBC_CRNL(reg->enc, p, end)\r
-#endif\r
- ) {\r
- p = onigenc_get_prev_char_head(reg->enc, adjrange, p);\r
- if (IS_NULL(p)) goto fail;\r
- goto retry;\r
- }\r
- break;\r
- }\r
- }\r
-\r
- /* no needs to adjust *high, *high is used as range check only */\r
- if (reg->dmax != INFINITE_LEN) {\r
- *low = p - reg->dmax;\r
- *high = p - reg->dmin;\r
- *high = onigenc_get_right_adjust_char_head(reg->enc, adjrange, *high);\r
- }\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr, "backward_search_range: low: %d, high: %d\n",\r
- (int )(*low - str), (int )(*high - str));\r
-#endif\r
- return 1; /* success */\r
- }\r
-\r
- fail:\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr, "backward_search_range: fail.\n");\r
-#endif\r
- return 0; /* fail */\r
-}\r
-\r
-\r
-extern int\r
-onig_search(regex_t* reg, const UChar* str, const UChar* end,\r
- const UChar* start, const UChar* range, OnigRegion* region,\r
- OnigOptionType option)\r
-{\r
- int r;\r
- OnigMatchParam mp;\r
-\r
- onig_initialize_match_param(&mp);\r
- r = onig_search_with_param(reg, str, end, start, range, region, option, &mp);\r
- onig_free_match_param_content(&mp);\r
- return r;\r
-\r
-}\r
-\r
-extern int\r
-onig_search_with_param(regex_t* reg, const UChar* str, const UChar* end,\r
- const UChar* start, const UChar* range, OnigRegion* region,\r
- OnigOptionType option, OnigMatchParam* mp)\r
-{\r
- int r;\r
- UChar *s, *prev;\r
- MatchArg msa;\r
- const UChar *orig_start = start;\r
- const UChar *orig_range = range;\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr,\r
- "onig_search (entry point): str: %p, end: %d, start: %d, range: %d\n",\r
- str, (int )(end - str), (int )(start - str), (int )(range - str));\r
-#endif\r
-\r
- ADJUST_MATCH_PARAM(reg, mp);\r
-\r
- if (region\r
-#ifdef USE_POSIX_API_REGION_OPTION\r
- && !IS_POSIX_REGION(option)\r
-#endif\r
- ) {\r
- r = onig_region_resize_clear(region, reg->num_mem + 1);\r
- if (r != 0) goto finish_no_msa;\r
- }\r
-\r
- if (start > end || start < str) goto mismatch_no_msa;\r
-\r
- if (ONIG_IS_OPTION_ON(option, ONIG_OPTION_CHECK_VALIDITY_OF_STRING)) {\r
- if (! ONIGENC_IS_VALID_MBC_STRING(reg->enc, str, end)) {\r
- r = ONIGERR_INVALID_WIDE_CHAR_VALUE;\r
- goto finish_no_msa;\r
- }\r
- }\r
-\r
-\r
-#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE\r
-#define MATCH_AND_RETURN_CHECK(upper_range) \\r
- r = match_at(reg, str, end, (upper_range), s, prev, &msa); \\r
- if (r != ONIG_MISMATCH) {\\r
- if (r >= 0) {\\r
- if (! IS_FIND_LONGEST(reg->options)) {\\r
- goto match;\\r
- }\\r
- }\\r
- else goto finish; /* error */ \\r
- }\r
-#else\r
-#define MATCH_AND_RETURN_CHECK(upper_range) \\r
- r = match_at(reg, str, end, (upper_range), s, prev, &msa); \\r
- if (r != ONIG_MISMATCH) {\\r
- if (r >= 0) {\\r
- goto match;\\r
- }\\r
- else goto finish; /* error */ \\r
- }\r
-#endif /* USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE */\r
-\r
-\r
- /* anchor optimize: resume search range */\r
- if (reg->anchor != 0 && str < end) {\r
- UChar *min_semi_end, *max_semi_end;\r
-\r
- if (reg->anchor & ANCR_BEGIN_POSITION) {\r
- /* search start-position only */\r
- begin_position:\r
- if (range > start)\r
- range = start + 1;\r
- else\r
- range = start;\r
- }\r
- else if (reg->anchor & ANCR_BEGIN_BUF) {\r
- /* search str-position only */\r
- if (range > start) {\r
- if (start != str) goto mismatch_no_msa;\r
- range = str + 1;\r
- }\r
- else {\r
- if (range <= str) {\r
- start = str;\r
- range = str;\r
- }\r
- else\r
- goto mismatch_no_msa;\r
- }\r
- }\r
- else if (reg->anchor & ANCR_END_BUF) {\r
- min_semi_end = max_semi_end = (UChar* )end;\r
-\r
- end_buf:\r
- if ((OnigLen )(max_semi_end - str) < reg->anchor_dmin)\r
- goto mismatch_no_msa;\r
-\r
- if (range > start) {\r
- if ((OnigLen )(min_semi_end - start) > reg->anchor_dmax) {\r
- start = min_semi_end - reg->anchor_dmax;\r
- if (start < end)\r
- start = onigenc_get_right_adjust_char_head(reg->enc, str, start);\r
- }\r
- if ((OnigLen )(max_semi_end - (range - 1)) < reg->anchor_dmin) {\r
- range = max_semi_end - reg->anchor_dmin + 1;\r
- }\r
-\r
- if (start > range) goto mismatch_no_msa;\r
- /* If start == range, match with empty at end.\r
- Backward search is used. */\r
- }\r
- else {\r
- if ((OnigLen )(min_semi_end - range) > reg->anchor_dmax) {\r
- range = min_semi_end - reg->anchor_dmax;\r
- }\r
- if ((OnigLen )(max_semi_end - start) < reg->anchor_dmin) {\r
- start = max_semi_end - reg->anchor_dmin;\r
- start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, start);\r
- }\r
- if (range > start) goto mismatch_no_msa;\r
- }\r
- }\r
- else if (reg->anchor & ANCR_SEMI_END_BUF) {\r
- UChar* pre_end = ONIGENC_STEP_BACK(reg->enc, str, end, 1);\r
-\r
- max_semi_end = (UChar* )end;\r
- // only when str > end, pre_end will be null\r
- // line 4659 "if (start > end || start < str) goto mismatch_no_msa"\r
- // will guarantee str alwayls less than end\r
- // so pre_end won't be null,this check is just for passing staic analysis\r
- if (IS_NOT_NULL(pre_end) && ONIGENC_IS_MBC_NEWLINE(reg->enc, pre_end, end)) {\r
- min_semi_end = pre_end;\r
-\r
-#ifdef USE_CRNL_AS_LINE_TERMINATOR\r
- pre_end = ONIGENC_STEP_BACK(reg->enc, str, pre_end, 1);\r
- if (IS_NOT_NULL(pre_end) &&\r
- ONIGENC_IS_MBC_CRNL(reg->enc, pre_end, end)) {\r
- min_semi_end = pre_end;\r
- }\r
-#endif\r
- if (min_semi_end > str && start <= min_semi_end) {\r
- goto end_buf;\r
- }\r
- }\r
- else {\r
- min_semi_end = (UChar* )end;\r
- goto end_buf;\r
- }\r
- }\r
- else if ((reg->anchor & ANCR_ANYCHAR_INF_ML)) {\r
- goto begin_position;\r
- }\r
- }\r
- else if (str == end) { /* empty string */\r
- static const UChar* address_for_empty_string = (UChar* )"";\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr, "onig_search: empty string.\n");\r
-#endif\r
-\r
- if (reg->threshold_len == 0) {\r
- start = end = str = address_for_empty_string;\r
- s = (UChar* )start;\r
- prev = (UChar* )NULL;\r
-\r
- MATCH_ARG_INIT(msa, reg, option, region, start, mp);\r
- MATCH_AND_RETURN_CHECK(end);\r
- goto mismatch;\r
- }\r
- goto mismatch_no_msa;\r
- }\r
-\r
-#ifdef ONIG_DEBUG_SEARCH\r
- fprintf(stderr, "onig_search(apply anchor): end: %d, start: %d, range: %d\n",\r
- (int )(end - str), (int )(start - str), (int )(range - str));\r
-#endif\r
-\r
- MATCH_ARG_INIT(msa, reg, option, region, orig_start, mp);\r
-\r
- s = (UChar* )start;\r
- if (range > start) { /* forward search */\r
- if (s > str)\r
- prev = onigenc_get_prev_char_head(reg->enc, str, s);\r
- else\r
- prev = (UChar* )NULL;\r
-\r
- if (reg->optimize != OPTIMIZE_NONE) {\r
- UChar *sch_range, *low, *high, *low_prev;\r
-\r
- sch_range = (UChar* )range;\r
- if (reg->dmax != 0) {\r
- if (reg->dmax == INFINITE_LEN)\r
- sch_range = (UChar* )end;\r
- else {\r
- sch_range += reg->dmax;\r
- if (sch_range > end) sch_range = (UChar* )end;\r
- }\r
- }\r
-\r
- if ((end - start) < reg->threshold_len)\r
- goto mismatch;\r
-\r
- if (reg->dmax != INFINITE_LEN) {\r
- do {\r
- if (! forward_search_range(reg, str, end, s, sch_range,\r
- &low, &high, &low_prev)) goto mismatch;\r
- if (s < low) {\r
- s = low;\r
- prev = low_prev;\r
- }\r
- while (s <= high) {\r
- MATCH_AND_RETURN_CHECK(orig_range);\r
- prev = s;\r
- s += enclen(reg->enc, s);\r
- }\r
- } while (s < range);\r
- goto mismatch;\r
- }\r
- else { /* check only. */\r
- if (! forward_search_range(reg, str, end, s, sch_range,\r
- &low, &high, (UChar** )NULL)) goto mismatch;\r
-\r
- if ((reg->anchor & ANCR_ANYCHAR_INF) != 0) {\r
- do {\r
- MATCH_AND_RETURN_CHECK(orig_range);\r
- prev = s;\r
- s += enclen(reg->enc, s);\r
-\r
- if ((reg->anchor & (ANCR_LOOK_BEHIND | ANCR_PREC_READ_NOT)) == 0) {\r
- while (!ONIGENC_IS_MBC_NEWLINE(reg->enc, prev, end) && s < range) {\r
- prev = s;\r
- s += enclen(reg->enc, s);\r
- }\r
- }\r
- } while (s < range);\r
- goto mismatch;\r
- }\r
- }\r
- }\r
-\r
- do {\r
- MATCH_AND_RETURN_CHECK(orig_range);\r
- prev = s;\r
- s += enclen(reg->enc, s);\r
- } while (s < range);\r
-\r
- if (s == range) { /* because empty match with /$/. */\r
- MATCH_AND_RETURN_CHECK(orig_range);\r
- }\r
- }\r
- else { /* backward search */\r
- if (range < str) goto mismatch;\r
-\r
- if (orig_start < end)\r
- orig_start += enclen(reg->enc, orig_start); /* is upper range */\r
-\r
- if (reg->optimize != OPTIMIZE_NONE) {\r
- UChar *low, *high, *adjrange, *sch_start;\r
-\r
- if (range < end)\r
- adjrange = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc, str, range);\r
- else\r
- adjrange = (UChar* )end;\r
-\r
- if (reg->dmax != INFINITE_LEN &&\r
- (end - range) >= reg->threshold_len) {\r
- do {\r
- sch_start = s + reg->dmax;\r
- if (sch_start > end) sch_start = (UChar* )end;\r
- if (backward_search_range(reg, str, end, sch_start, range, adjrange,\r
- &low, &high) <= 0)\r
- goto mismatch;\r
-\r
- if (s > high)\r
- s = high;\r
-\r
- while (s >= low) {\r
- prev = onigenc_get_prev_char_head(reg->enc, str, s);\r
- MATCH_AND_RETURN_CHECK(orig_start);\r
- s = prev;\r
- }\r
- // if range is not null,the check is not necessary.\r
- // the range is actually the pointer of the end of the matched string\r
- // or assigned by "range = str" in line 4708. In RegularExpressionMatch\r
- // protocol, the matched string is the parameter String. And str in\r
- // line 4708 is the String,too. and the range is calculated from\r
- // "Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start)" in\r
- // line 146 in RegularExpressionDxe.c. RegularExpressionMatch ensure\r
- // the String is not null,So in both situation, the range can not be NULL.\r
- // This check is just for passing static analysis.\r
- if(IS_NULL(s))break;\r
- } while (s >= range);\r
- goto mismatch;\r
- }\r
- else { /* check only. */\r
- if ((end - range) < reg->threshold_len) goto mismatch;\r
-\r
- sch_start = s;\r
- if (reg->dmax != 0) {\r
- if (reg->dmax == INFINITE_LEN)\r
- sch_start = (UChar* )end;\r
- else {\r
- sch_start += reg->dmax;\r
- if (sch_start > end) sch_start = (UChar* )end;\r
- else\r
- sch_start = ONIGENC_LEFT_ADJUST_CHAR_HEAD(reg->enc,\r
- start, sch_start);\r
- }\r
- }\r
- if (backward_search_range(reg, str, end, sch_start, range, adjrange,\r
- &low, &high) <= 0) goto mismatch;\r
- }\r
- }\r
-\r
- do {\r
- prev = onigenc_get_prev_char_head(reg->enc, str, s);\r
- MATCH_AND_RETURN_CHECK(orig_start);\r
- s = prev;\r
- } while (s >= range);\r
- }\r
-\r
- mismatch:\r
-#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE\r
- if (IS_FIND_LONGEST(reg->options)) {\r
- if (msa.best_len >= 0) {\r
- s = msa.best_s;\r
- goto match;\r
- }\r
- }\r
-#endif\r
- r = ONIG_MISMATCH;\r
-\r
- finish:\r
- MATCH_ARG_FREE(msa);\r
-\r
- /* If result is mismatch and no FIND_NOT_EMPTY option,\r
- then the region is not set in match_at(). */\r
- if (IS_FIND_NOT_EMPTY(reg->options) && region\r
-#ifdef USE_POSIX_API_REGION_OPTION\r
- && !IS_POSIX_REGION(option)\r
-#endif\r
- ) {\r
- onig_region_clear(region);\r
- }\r
-\r
-#ifdef ONIG_DEBUG\r
- if (r != ONIG_MISMATCH)\r
- fprintf(stderr, "onig_search: error %d\n", r);\r
-#endif\r
- return r;\r
-\r
- mismatch_no_msa:\r
- r = ONIG_MISMATCH;\r
- finish_no_msa:\r
-#ifdef ONIG_DEBUG\r
- if (r != ONIG_MISMATCH)\r
- fprintf(stderr, "onig_search: error %d\n", r);\r
-#endif\r
- return r;\r
-\r
- match:\r
- MATCH_ARG_FREE(msa);\r
- return (int )(s - str);\r
-}\r
-\r
-extern int\r
-onig_scan(regex_t* reg, const UChar* str, const UChar* end,\r
- OnigRegion* region, OnigOptionType option,\r
- int (*scan_callback)(int, int, OnigRegion*, void*),\r
- void* callback_arg)\r
-{\r
- int r;\r
- int n;\r
- int rs;\r
- const UChar* start;\r
-\r
- if (ONIG_IS_OPTION_ON(option, ONIG_OPTION_CHECK_VALIDITY_OF_STRING)) {\r
- if (! ONIGENC_IS_VALID_MBC_STRING(reg->enc, str, end))\r
- return ONIGERR_INVALID_WIDE_CHAR_VALUE;\r
-\r
- ONIG_OPTION_OFF(option, ONIG_OPTION_CHECK_VALIDITY_OF_STRING);\r
- }\r
-\r
- n = 0;\r
- start = str;\r
- while (1) {\r
- r = onig_search(reg, str, end, start, end, region, option);\r
- if (r >= 0) {\r
- rs = scan_callback(n, r, region, callback_arg);\r
- n++;\r
- if (rs != 0)\r
- return rs;\r
-\r
- if (region->end[0] == start - str) {\r
- if (start >= end) break;\r
- start += enclen(reg->enc, start);\r
- }\r
- else\r
- start = str + region->end[0];\r
-\r
- if (start > end)\r
- break;\r
- }\r
- else if (r == ONIG_MISMATCH) {\r
- break;\r
- }\r
- else { /* error */\r
- return r;\r
- }\r
- }\r
-\r
- return n;\r
-}\r
-\r
-extern OnigEncoding\r
-onig_get_encoding(regex_t* reg)\r
-{\r
- return reg->enc;\r
-}\r
-\r
-extern OnigOptionType\r
-onig_get_options(regex_t* reg)\r
-{\r
- return reg->options;\r
-}\r
-\r
-extern OnigCaseFoldType\r
-onig_get_case_fold_flag(regex_t* reg)\r
-{\r
- return reg->case_fold_flag;\r
-}\r
-\r
-extern OnigSyntaxType*\r
-onig_get_syntax(regex_t* reg)\r
-{\r
- return reg->syntax;\r
-}\r
-\r
-extern int\r
-onig_number_of_captures(regex_t* reg)\r
-{\r
- return reg->num_mem;\r
-}\r
-\r
-extern int\r
-onig_number_of_capture_histories(regex_t* reg)\r
-{\r
-#ifdef USE_CAPTURE_HISTORY\r
- int i, n;\r
-\r
- n = 0;\r
- for (i = 0; i <= ONIG_MAX_CAPTURE_HISTORY_GROUP; i++) {\r
- if (MEM_STATUS_AT(reg->capture_history, i) != 0)\r
- n++;\r
- }\r
- return n;\r
-#else\r
- return 0;\r
-#endif\r
-}\r
-\r
-extern void\r
-onig_copy_encoding(OnigEncoding to, OnigEncoding from)\r
-{\r
- *to = *from;\r
-}\r
-\r
-#ifdef USE_DIRECT_THREADED_CODE\r
-extern int\r
-onig_init_for_match_at(regex_t* reg)\r
-{\r
- return match_at(reg, (const UChar* )NULL, (const UChar* )NULL,\r
- (const UChar* )NULL, (const UChar* )NULL, (UChar* )NULL,\r
- (MatchArg* )NULL);\r
-}\r
-#endif\r
-\r
-\r
-/* for callout functions */\r
-\r
-#ifdef USE_CALLOUT\r
-\r
-extern OnigCalloutFunc\r
-onig_get_progress_callout(void)\r
-{\r
- return DefaultProgressCallout;\r
-}\r
-\r
-extern int\r
-onig_set_progress_callout(OnigCalloutFunc f)\r
-{\r
- DefaultProgressCallout = f;\r
- return ONIG_NORMAL;\r
-}\r
-\r
-extern OnigCalloutFunc\r
-onig_get_retraction_callout(void)\r
-{\r
- return DefaultRetractionCallout;\r
-}\r
-\r
-extern int\r
-onig_set_retraction_callout(OnigCalloutFunc f)\r
-{\r
- DefaultRetractionCallout = f;\r
- return ONIG_NORMAL;\r
-}\r
-\r
-extern int\r
-onig_get_callout_num_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->num;\r
-}\r
-\r
-extern OnigCalloutIn\r
-onig_get_callout_in_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->in;\r
-}\r
-\r
-extern int\r
-onig_get_name_id_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->name_id;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_contents_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- int num;\r
- CalloutListEntry* e;\r
-\r
- num = args->num;\r
- e = onig_reg_callout_list_at(args->regex, num);\r
- if (IS_NULL(e)) return 0;\r
- if (e->of == ONIG_CALLOUT_OF_CONTENTS) {\r
- return e->u.content.start;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_contents_end_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- int num;\r
- CalloutListEntry* e;\r
-\r
- num = args->num;\r
- e = onig_reg_callout_list_at(args->regex, num);\r
- if (IS_NULL(e)) return 0;\r
- if (e->of == ONIG_CALLOUT_OF_CONTENTS) {\r
- return e->u.content.end;\r
- }\r
-\r
- return 0;\r
-}\r
-\r
-extern int\r
-onig_get_args_num_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- int num;\r
- CalloutListEntry* e;\r
-\r
- num = args->num;\r
- e = onig_reg_callout_list_at(args->regex, num);\r
- if (IS_NULL(e)) return ONIGERR_INVALID_ARGUMENT;\r
- if (e->of == ONIG_CALLOUT_OF_NAME) {\r
- return e->u.arg.num;\r
- }\r
-\r
- return ONIGERR_INVALID_ARGUMENT;\r
-}\r
-\r
-extern int\r
-onig_get_passed_args_num_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- int num;\r
- CalloutListEntry* e;\r
-\r
- num = args->num;\r
- e = onig_reg_callout_list_at(args->regex, num);\r
- if (IS_NULL(e)) return ONIGERR_INVALID_ARGUMENT;\r
- if (e->of == ONIG_CALLOUT_OF_NAME) {\r
- return e->u.arg.passed_num;\r
- }\r
-\r
- return ONIGERR_INVALID_ARGUMENT;\r
-}\r
-\r
-extern int\r
-onig_get_arg_by_callout_args(OnigCalloutArgs* args, int index,\r
- OnigType* type, OnigValue* val)\r
-{\r
- int num;\r
- CalloutListEntry* e;\r
-\r
- num = args->num;\r
- e = onig_reg_callout_list_at(args->regex, num);\r
- if (IS_NULL(e)) return ONIGERR_INVALID_ARGUMENT;\r
- if (e->of == ONIG_CALLOUT_OF_NAME) {\r
- if (IS_NOT_NULL(type)) *type = e->u.arg.types[index];\r
- if (IS_NOT_NULL(val)) *val = e->u.arg.vals[index];\r
- return ONIG_NORMAL;\r
- }\r
-\r
- return ONIGERR_INVALID_ARGUMENT;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_string_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->string;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_string_end_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->string_end;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_start_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->start;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_right_range_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->right_range;\r
-}\r
-\r
-extern const UChar*\r
-onig_get_current_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->current;\r
-}\r
-\r
-extern OnigRegex\r
-onig_get_regex_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->regex;\r
-}\r
-\r
-extern unsigned long\r
-onig_get_retry_counter_by_callout_args(OnigCalloutArgs* args)\r
-{\r
- return args->retry_in_match_counter;\r
-}\r
-\r
-\r
-extern int\r
-onig_get_capture_range_in_callout(OnigCalloutArgs* a, int mem_num, int* begin, int* end)\r
-{\r
- OnigRegex reg;\r
- const UChar* str;\r
- StackType* stk_base;\r
- int i;\r
-\r
- i = mem_num;\r
- reg = a->regex;\r
- str = a->string;\r
- stk_base = a->stk_base;\r
-\r
- if (i > 0) {\r
- if (a->mem_end_stk[i] != INVALID_STACK_INDEX) {\r
- if (MEM_STATUS_AT(reg->bt_mem_start, i))\r
- *begin = (int )(STACK_AT(a->mem_start_stk[i])->u.mem.pstr - str);\r
- else\r
- *begin = (int )((UChar* )((void* )a->mem_start_stk[i]) - str);\r
-\r
- *end = (int )((MEM_STATUS_AT(reg->bt_mem_end, i)\r
- ? STACK_AT(a->mem_end_stk[i])->u.mem.pstr\r
- : (UChar* )((void* )a->mem_end_stk[i])) - str);\r
- }\r
- else {\r
- *begin = *end = ONIG_REGION_NOTPOS;\r
- }\r
- }\r
- else if (i == 0) {\r
-#if 0\r
- *begin = a->start - str;\r
- *end = a->current - str;\r
-#else\r
- return ONIGERR_INVALID_ARGUMENT;\r
-#endif\r
- }\r
- else\r
- return ONIGERR_INVALID_ARGUMENT;\r
-\r
- return ONIG_NORMAL;\r
-}\r
-\r
-extern int\r
-onig_get_used_stack_size_in_callout(OnigCalloutArgs* a, int* used_num, int* used_bytes)\r
-{\r
- int n;\r
-\r
- n = (int )(a->stk - a->stk_base);\r
-\r
- if (used_num != 0)\r
- *used_num = n;\r
-\r
- if (used_bytes != 0)\r
- *used_bytes = n * sizeof(StackType);\r
-\r
- return ONIG_NORMAL;\r
-}\r
-\r
-\r
-/* builtin callout functions */\r
-\r
-extern int\r
-onig_builtin_fail(OnigCalloutArgs* args ARG_UNUSED, void* user_data ARG_UNUSED)\r
-{\r
- return ONIG_CALLOUT_FAIL;\r
-}\r
-\r
-extern int\r
-onig_builtin_mismatch(OnigCalloutArgs* args ARG_UNUSED, void* user_data ARG_UNUSED)\r
-{\r
- return ONIG_MISMATCH;\r
-}\r
-\r
-#if 0\r
-extern int\r
-onig_builtin_success(OnigCalloutArgs* args ARG_UNUSED, void* user_data ARG_UNUSED)\r
-{\r
- return ONIG_CALLOUT_SUCCESS;\r
-}\r
-#endif\r
-\r
-extern int\r
-onig_builtin_error(OnigCalloutArgs* args, void* user_data ARG_UNUSED)\r
-{\r
- int r;\r
- int n;\r
- OnigValue val;\r
-\r
- r = onig_get_arg_by_callout_args(args, 0, 0, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- n = (int )val.l;\r
- if (n >= 0) {\r
- n = ONIGERR_INVALID_CALLOUT_BODY;\r
- }\r
- else if (onig_is_error_code_needs_param(n)) {\r
- n = ONIGERR_INVALID_CALLOUT_BODY;\r
- }\r
-\r
- return n;\r
-}\r
-\r
-extern int\r
-onig_builtin_count(OnigCalloutArgs* args, void* user_data)\r
-{\r
- (void )onig_check_callout_data_and_clear_old_values(args);\r
-\r
- return onig_builtin_total_count(args, user_data);\r
-}\r
-\r
-extern int\r
-onig_builtin_total_count(OnigCalloutArgs* args, void* user_data ARG_UNUSED)\r
-{\r
- int r;\r
- int slot;\r
- OnigType type;\r
- OnigValue val;\r
- OnigValue aval;\r
- OnigCodePoint count_type;\r
-\r
- r = onig_get_arg_by_callout_args(args, 0, &type, &aval);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- count_type = aval.c;\r
- if (count_type != '>' && count_type != 'X' && count_type != '<')\r
- return ONIGERR_INVALID_CALLOUT_ARG;\r
-\r
- r = onig_get_callout_data_by_callout_args_self_dont_clear_old(args, 0,\r
- &type, &val);\r
- if (r < ONIG_NORMAL)\r
- return r;\r
- else if (r > ONIG_NORMAL) {\r
- /* type == void: initial state */\r
- val.l = 0;\r
- }\r
-\r
- if (args->in == ONIG_CALLOUT_IN_RETRACTION) {\r
- slot = 2;\r
- if (count_type == '<')\r
- val.l++;\r
- else if (count_type == 'X')\r
- val.l--;\r
- }\r
- else {\r
- slot = 1;\r
- if (count_type != '<')\r
- val.l++;\r
- }\r
-\r
- r = onig_set_callout_data_by_callout_args_self(args, 0, ONIG_TYPE_LONG, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- /* slot 1: in progress counter, slot 2: in retraction counter */\r
- r = onig_get_callout_data_by_callout_args_self_dont_clear_old(args, slot,\r
- &type, &val);\r
- if (r < ONIG_NORMAL)\r
- return r;\r
- else if (r > ONIG_NORMAL) {\r
- val.l = 0;\r
- }\r
-\r
- val.l++;\r
- r = onig_set_callout_data_by_callout_args_self(args, slot, ONIG_TYPE_LONG, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- return ONIG_CALLOUT_SUCCESS;\r
-}\r
-\r
-extern int\r
-onig_builtin_max(OnigCalloutArgs* args, void* user_data ARG_UNUSED)\r
-{\r
- int r;\r
- int slot;\r
- long max_val;\r
- OnigCodePoint count_type;\r
- OnigType type;\r
- OnigValue val;\r
- OnigValue aval;\r
-\r
- (void )onig_check_callout_data_and_clear_old_values(args);\r
-\r
- slot = 0;\r
- r = onig_get_callout_data_by_callout_args_self(args, slot, &type, &val);\r
- if (r < ONIG_NORMAL)\r
- return r;\r
- else if (r > ONIG_NORMAL) {\r
- /* type == void: initial state */\r
- type = ONIG_TYPE_LONG;\r
- val.l = 0;\r
- }\r
-\r
- r = onig_get_arg_by_callout_args(args, 0, &type, &aval);\r
- if (r != ONIG_NORMAL) return r;\r
- if (type == ONIG_TYPE_TAG) {\r
- r = onig_get_callout_data_by_callout_args(args, aval.tag, 0, &type, &aval);\r
- if (r < ONIG_NORMAL) return r;\r
- else if (r > ONIG_NORMAL)\r
- max_val = 0L;\r
- else\r
- max_val = aval.l;\r
- }\r
- else { /* LONG */\r
- max_val = aval.l;\r
- }\r
-\r
- r = onig_get_arg_by_callout_args(args, 1, &type, &aval);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- count_type = aval.c;\r
- if (count_type != '>' && count_type != 'X' && count_type != '<')\r
- return ONIGERR_INVALID_CALLOUT_ARG;\r
-\r
- if (args->in == ONIG_CALLOUT_IN_RETRACTION) {\r
- if (count_type == '<') {\r
- if (val.l >= max_val) return ONIG_CALLOUT_FAIL;\r
- val.l++;\r
- }\r
- else if (count_type == 'X')\r
- val.l--;\r
- }\r
- else {\r
- if (count_type != '<') {\r
- if (val.l >= max_val) return ONIG_CALLOUT_FAIL;\r
- val.l++;\r
- }\r
- }\r
-\r
- r = onig_set_callout_data_by_callout_args_self(args, slot, ONIG_TYPE_LONG, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- return ONIG_CALLOUT_SUCCESS;\r
-}\r
-\r
-enum OP_CMP {\r
- OP_EQ,\r
- OP_NE,\r
- OP_LT,\r
- OP_GT,\r
- OP_LE,\r
- OP_GE\r
-};\r
-\r
-extern int\r
-onig_builtin_cmp(OnigCalloutArgs* args, void* user_data ARG_UNUSED)\r
-{\r
- int r;\r
- int slot;\r
- long lv;\r
- long rv;\r
- OnigType type;\r
- OnigValue val;\r
- regex_t* reg;\r
- enum OP_CMP op;\r
-\r
- reg = args->regex;\r
-\r
- r = onig_get_arg_by_callout_args(args, 0, &type, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- if (type == ONIG_TYPE_TAG) {\r
- r = onig_get_callout_data_by_callout_args(args, val.tag, 0, &type, &val);\r
- if (r < ONIG_NORMAL) return r;\r
- else if (r > ONIG_NORMAL)\r
- lv = 0L;\r
- else\r
- lv = val.l;\r
- }\r
- else { /* ONIG_TYPE_LONG */\r
- lv = val.l;\r
- }\r
-\r
- r = onig_get_arg_by_callout_args(args, 2, &type, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- if (type == ONIG_TYPE_TAG) {\r
- r = onig_get_callout_data_by_callout_args(args, val.tag, 0, &type, &val);\r
- if (r < ONIG_NORMAL) return r;\r
- else if (r > ONIG_NORMAL)\r
- rv = 0L;\r
- else\r
- rv = val.l;\r
- }\r
- else { /* ONIG_TYPE_LONG */\r
- rv = val.l;\r
- }\r
-\r
- slot = 0;\r
- r = onig_get_callout_data_by_callout_args_self(args, slot, &type, &val);\r
- if (r < ONIG_NORMAL)\r
- return r;\r
- else if (r > ONIG_NORMAL) {\r
- /* type == void: initial state */\r
- OnigCodePoint c1, c2;\r
- UChar* p;\r
-\r
- r = onig_get_arg_by_callout_args(args, 1, &type, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- p = val.s.start;\r
- c1 = ONIGENC_MBC_TO_CODE(reg->enc, p, val.s.end);\r
- p += ONIGENC_MBC_ENC_LEN(reg->enc, p);\r
- if (p < val.s.end) {\r
- c2 = ONIGENC_MBC_TO_CODE(reg->enc, p, val.s.end);\r
- p += ONIGENC_MBC_ENC_LEN(reg->enc, p);\r
- if (p != val.s.end) return ONIGERR_INVALID_CALLOUT_ARG;\r
- }\r
- else\r
- c2 = 0;\r
-\r
- switch (c1) {\r
- case '=':\r
- if (c2 != '=') return ONIGERR_INVALID_CALLOUT_ARG;\r
- op = OP_EQ;\r
- break;\r
- case '!':\r
- if (c2 != '=') return ONIGERR_INVALID_CALLOUT_ARG;\r
- op = OP_NE;\r
- break;\r
- case '<':\r
- if (c2 == '=') op = OP_LE;\r
- else if (c2 == 0) op = OP_LT;\r
- else return ONIGERR_INVALID_CALLOUT_ARG;\r
- break;\r
- case '>':\r
- if (c2 == '=') op = OP_GE;\r
- else if (c2 == 0) op = OP_GT;\r
- else return ONIGERR_INVALID_CALLOUT_ARG;\r
- break;\r
- default:\r
- return ONIGERR_INVALID_CALLOUT_ARG;\r
- break;\r
- }\r
- val.l = (long )op;\r
- r = onig_set_callout_data_by_callout_args_self(args, slot, ONIG_TYPE_LONG, &val);\r
- if (r != ONIG_NORMAL) return r;\r
- }\r
- else {\r
- op = (enum OP_CMP )val.l;\r
- }\r
-\r
- switch (op) {\r
- case OP_EQ: r = (lv == rv); break;\r
- case OP_NE: r = (lv != rv); break;\r
- case OP_LT: r = (lv < rv); break;\r
- case OP_GT: r = (lv > rv); break;\r
- case OP_LE: r = (lv <= rv); break;\r
- case OP_GE: r = (lv >= rv); break;\r
- }\r
-\r
- return r == 0 ? ONIG_CALLOUT_FAIL : ONIG_CALLOUT_SUCCESS;\r
-}\r
-\r
-\r
-//#include <stdio.h>\r
-\r
-static FILE* OutFp;\r
-\r
-/* name start with "onig_" for macros. */\r
-static int\r
-onig_builtin_monitor(OnigCalloutArgs* args, void* user_data)\r
-{\r
- int r;\r
- int num;\r
- size_t tag_len;\r
- // const UChar* start;\r
- // const UChar* right;\r
- // const UChar* current;\r
- // const UChar* string;\r
- // const UChar* strend;\r
- const UChar* tag_start;\r
- const UChar* tag_end;\r
- regex_t* reg;\r
- OnigCalloutIn in;\r
- OnigType type;\r
- OnigValue val;\r
- char buf[20];\r
- // FILE* fp;\r
-\r
- // fp = OutFp;\r
-\r
- r = onig_get_arg_by_callout_args(args, 0, &type, &val);\r
- if (r != ONIG_NORMAL) return r;\r
-\r
- in = onig_get_callout_in_by_callout_args(args);\r
- if (in == ONIG_CALLOUT_IN_PROGRESS) {\r
- if (val.c == '<')\r
- return ONIG_CALLOUT_SUCCESS;\r
- }\r
- else {\r
- if (val.c != 'X' && val.c != '<')\r
- return ONIG_CALLOUT_SUCCESS;\r
- }\r
-\r
- num = onig_get_callout_num_by_callout_args(args);\r
- // start = onig_get_start_by_callout_args(args);\r
- // right = onig_get_right_range_by_callout_args(args);\r
- // current = onig_get_current_by_callout_args(args);\r
- // string = onig_get_string_by_callout_args(args);\r
- // strend = onig_get_string_end_by_callout_args(args);\r
- reg = onig_get_regex_by_callout_args(args);\r
- tag_start = onig_get_callout_tag_start(reg, num);\r
- tag_end = onig_get_callout_tag_end(reg, num);\r
-\r
- if (tag_start == 0)\r
- sprintf_s(buf, sizeof(buf), "#%d", num);\r
- else {\r
- /* CAUTION: tag string is not terminated with NULL. */\r
- int i;\r
-\r
- tag_len = tag_end - tag_start;\r
- if (tag_len >= sizeof(buf)) tag_len = sizeof(buf) - 1;\r
- for (i = 0; i < tag_len; i++) buf[i] = tag_start[i];\r
- buf[tag_len] = '\0';\r
- }\r
-/*\r
- fprintf(fp, "ONIG-MONITOR: %-4s %s at: %d [%d - %d] len: %d\n",\r
- buf,\r
- in == ONIG_CALLOUT_IN_PROGRESS ? "=>" : "<=",\r
- (int )(current - string),\r
- (int )(start - string),\r
- (int )(right - string),\r
- (int )(strend - string));\r
- //fflush(fp);\r
-*/\r
- return ONIG_CALLOUT_SUCCESS;\r
-}\r
-\r
-extern int\r
-onig_setup_builtin_monitors_by_ascii_encoded_name(void* fp /* FILE* */)\r
-{\r
- int id;\r
- char* name;\r
- OnigEncoding enc;\r
- unsigned int ts[4];\r
- OnigValue opts[4];\r
-\r
- if (IS_NOT_NULL(fp))\r
- OutFp = (FILE* )fp;\r
- else\r
- OutFp = stdout;\r
-\r
- enc = ONIG_ENCODING_ASCII;\r
-\r
- name = "MON";\r
- ts[0] = ONIG_TYPE_CHAR;\r
- opts[0].c = '>';\r
- BC_B_O(name, monitor, 1, ts, 1, opts);\r
-\r
- return ONIG_NORMAL;\r
-}\r
-\r
-#endif /* USE_CALLOUT */\r
projects / mirror_edk2.git / blobdiff