mirror of
https://github.com/rizonesoft/Notepad3.git
synced 2026-06-17 21:03:19 +08:00
+ upd: Oniguruma RegEx engine to current (2021-03-01) version [7dabf247]
This commit is contained in:
Rainer Kottenhoff
parent
5e648a5816
commit
d90cebec49
1
scintilla/oniguruma/.gitignore
vendored
1
scintilla/oniguruma/.gitignore
vendored
@ -68,6 +68,7 @@ m4/*.m4
|
||||
/sample/bug_fix
|
||||
/sample/regset
|
||||
/sample/scan
|
||||
/sample/each_match
|
||||
/sample/log*
|
||||
|
||||
/harnesses/utf16*.dict
|
||||
|
||||
@ -2432,4 +2432,13 @@ cvs rtag "VERSION_X_X_X" oniguruma
|
||||
age: number of supported previous interfaces
|
||||
(if current only supported then age == 0)
|
||||
|
||||
|
||||
<add SHA256 checksum>
|
||||
MacOS X
|
||||
$ shasum -a 256 -b onig-X.Y.Z.tar.gz > onig-X.Y.Z.tar.gz.sha256
|
||||
|
||||
<check SHA256 checksum>
|
||||
MacOS X
|
||||
$ shasum -a 256 -c onig-X.Y.Z.tar.gz.sha256
|
||||
|
||||
//END
|
||||
|
||||
@ -415,8 +415,9 @@ typedef unsigned int OnigOptionType;
|
||||
#define ONIG_OPTION_NOT_BEGIN_STRING (ONIG_OPTION_TEXT_SEGMENT_WORD << 1)
|
||||
#define ONIG_OPTION_NOT_END_STRING (ONIG_OPTION_NOT_BEGIN_STRING << 1)
|
||||
#define ONIG_OPTION_NOT_BEGIN_POSITION (ONIG_OPTION_NOT_END_STRING << 1)
|
||||
#define ONIG_OPTION_CALLBACK_EACH_MATCH (ONIG_OPTION_NOT_BEGIN_POSITION << 1)
|
||||
|
||||
#define ONIG_OPTION_MAXBIT ONIG_OPTION_NOT_BEGIN_POSITION
|
||||
#define ONIG_OPTION_MAXBIT ONIG_OPTION_CALLBACK_EACH_MATCH
|
||||
|
||||
#define ONIG_OPTION_ON(options,regopt) ((options) |= (regopt))
|
||||
#define ONIG_OPTION_OFF(options,regopt) ((options) &= ~(regopt))
|
||||
@ -739,6 +740,8 @@ typedef struct {
|
||||
OnigCaseFoldType case_fold_flag;
|
||||
} OnigCompileInfo;
|
||||
|
||||
typedef int (*OnigCallbackEachMatchFunc)(const UChar* str, const UChar* end, const UChar* range, const UChar* match_start, OnigRegion* region, void* user_data);
|
||||
|
||||
|
||||
/* types for callout */
|
||||
typedef enum {
|
||||
@ -962,6 +965,12 @@ const char* onig_version P_((void));
|
||||
ONIG_EXTERN
|
||||
const char* onig_copyright P_((void));
|
||||
|
||||
/* for callback each match */
|
||||
ONIG_EXTERN
|
||||
OnigCallbackEachMatchFunc onig_get_callback_each_match P_((void));
|
||||
ONIG_EXTERN
|
||||
int onig_set_callback_each_match P_((OnigCallbackEachMatchFunc f));
|
||||
|
||||
/* for OnigMatchParam */
|
||||
ONIG_EXTERN
|
||||
OnigMatchParam* onig_new_match_param P_((void));
|
||||
|
||||
@ -47,7 +47,7 @@ typedef struct {
|
||||
|
||||
OnigCaseFoldType OnigDefaultCaseFoldFlag = ONIGENC_CASE_FOLD_MIN;
|
||||
|
||||
static OnigLen node_min_byte_len(Node* node, ScanEnv* env);
|
||||
static OnigLen node_min_byte_len(Node* node, ParseEnv* env);
|
||||
|
||||
#if 0
|
||||
typedef struct {
|
||||
@ -714,7 +714,7 @@ mml_alt_merge(MinMaxLen* to, MinMaxLen* alt)
|
||||
|
||||
/* fixed size pattern node only */
|
||||
static int
|
||||
node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ScanEnv* env,
|
||||
node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env,
|
||||
int level)
|
||||
{
|
||||
MinMaxCharLen tci;
|
||||
@ -921,7 +921,7 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ScanEnv* env,
|
||||
{
|
||||
int i;
|
||||
int* backs;
|
||||
MemEnv* mem_env = SCANENV_MEMENV(env);
|
||||
MemEnv* mem_env = PARSEENV_MEMENV(env);
|
||||
BackRefNode* br = BACKREF_(node);
|
||||
|
||||
backs = BACKREFS_P(br);
|
||||
@ -947,7 +947,7 @@ node_char_len1(Node* node, regex_t* reg, MinMaxCharLen* ci, ScanEnv* env,
|
||||
}
|
||||
|
||||
static int
|
||||
node_char_len(Node* node, regex_t* reg, MinMaxCharLen* ci, ScanEnv* env)
|
||||
node_char_len(Node* node, regex_t* reg, MinMaxCharLen* ci, ParseEnv* env)
|
||||
{
|
||||
return node_char_len1(node, reg, ci, env, 0);
|
||||
}
|
||||
@ -971,7 +971,7 @@ add_op(regex_t* reg, int opcode)
|
||||
}
|
||||
|
||||
static int compile_length_tree(Node* node, regex_t* reg);
|
||||
static int compile_tree(Node* node, regex_t* reg, ScanEnv* env);
|
||||
static int compile_tree(Node* node, regex_t* reg, ParseEnv* env);
|
||||
|
||||
|
||||
#define IS_NEED_STR_LEN_OP(op) \
|
||||
@ -1039,7 +1039,7 @@ is_strict_real_node(Node* node)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_quant_body_with_empty_check(QuantNode* qn, regex_t* reg, ScanEnv* env)
|
||||
compile_quant_body_with_empty_check(QuantNode* qn, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int saved_num_empty_check;
|
||||
@ -1088,7 +1088,7 @@ compile_quant_body_with_empty_check(QuantNode* qn, regex_t* reg, ScanEnv* env)
|
||||
|
||||
#ifdef USE_CALL
|
||||
static int
|
||||
compile_call(CallNode* node, regex_t* reg, ScanEnv* env)
|
||||
compile_call(CallNode* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int offset;
|
||||
@ -1108,7 +1108,7 @@ compile_call(CallNode* node, regex_t* reg, ScanEnv* env)
|
||||
#endif
|
||||
|
||||
static int
|
||||
compile_tree_n_times(Node* node, int n, regex_t* reg, ScanEnv* env)
|
||||
compile_tree_n_times(Node* node, int n, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int i, r;
|
||||
|
||||
@ -1366,7 +1366,7 @@ entry_repeat_range(regex_t* reg, int id, int lower, int upper, int ops_index)
|
||||
|
||||
static int
|
||||
compile_range_repeat_node(QuantNode* qn, int target_len, int emptiness,
|
||||
regex_t* reg, ScanEnv* env)
|
||||
regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int num_repeat = reg->num_repeat++;
|
||||
@ -1479,7 +1479,7 @@ compile_length_quantifier_node(QuantNode* qn, regex_t* reg)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_quantifier_node(QuantNode* qn, regex_t* reg, ScanEnv* env)
|
||||
compile_quantifier_node(QuantNode* qn, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int i, r, mod_tlen;
|
||||
int infinite = IS_INFINITE_REPEAT(qn->upper);
|
||||
@ -1659,7 +1659,7 @@ compile_length_option_node(BagNode* node, regex_t* reg)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_option_node(BagNode* node, regex_t* reg, ScanEnv* env)
|
||||
compile_option_node(BagNode* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -1775,7 +1775,7 @@ compile_length_bag_node(BagNode* node, regex_t* reg)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_bag_memory_node(BagNode* node, regex_t* reg, ScanEnv* env)
|
||||
compile_bag_memory_node(BagNode* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -1855,7 +1855,7 @@ compile_bag_memory_node(BagNode* node, regex_t* reg, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_bag_node(BagNode* node, regex_t* reg, ScanEnv* env)
|
||||
compile_bag_node(BagNode* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r, len;
|
||||
|
||||
@ -2046,7 +2046,7 @@ compile_length_anchor_node(AnchorNode* node, regex_t* reg)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ScanEnv* env)
|
||||
compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -2160,7 +2160,7 @@ compile_anchor_look_behind_node(AnchorNode* node, regex_t* reg, ScanEnv* env)
|
||||
|
||||
static int
|
||||
compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int len;
|
||||
@ -2289,7 +2289,7 @@ compile_anchor_look_behind_not_node(AnchorNode* node, regex_t* reg,
|
||||
}
|
||||
|
||||
static int
|
||||
compile_anchor_node(AnchorNode* node, regex_t* reg, ScanEnv* env)
|
||||
compile_anchor_node(AnchorNode* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r, len;
|
||||
enum OpCode op;
|
||||
@ -2583,7 +2583,7 @@ compile_length_tree(Node* node, regex_t* reg)
|
||||
}
|
||||
|
||||
static int
|
||||
compile_tree(Node* node, regex_t* reg, ScanEnv* env)
|
||||
compile_tree(Node* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int n, len, pos, r = 0;
|
||||
|
||||
@ -2993,7 +2993,7 @@ numbered_ref_check(Node* node)
|
||||
}
|
||||
|
||||
static int
|
||||
disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)
|
||||
disable_noname_group_capture(Node** root, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r, i, pos, counter;
|
||||
MemStatusType loc;
|
||||
@ -3013,7 +3013,7 @@ disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)
|
||||
|
||||
for (i = 1, pos = 1; i <= env->num_mem; i++) {
|
||||
if (map[i].new_val > 0) {
|
||||
SCANENV_MEMENV(env)[pos] = SCANENV_MEMENV(env)[i];
|
||||
PARSEENV_MEMENV(env)[pos] = PARSEENV_MEMENV(env)[i];
|
||||
pos++;
|
||||
}
|
||||
}
|
||||
@ -3610,7 +3610,7 @@ check_node_in_look_behind(Node* node, int not, int* used)
|
||||
}
|
||||
|
||||
static OnigLen
|
||||
node_min_byte_len(Node* node, ScanEnv* env)
|
||||
node_min_byte_len(Node* node, ParseEnv* env)
|
||||
{
|
||||
OnigLen len;
|
||||
OnigLen tmin;
|
||||
@ -3621,7 +3621,7 @@ node_min_byte_len(Node* node, ScanEnv* env)
|
||||
if (! NODE_IS_CHECKER(node)) {
|
||||
int i;
|
||||
int* backs;
|
||||
MemEnv* mem_env = SCANENV_MEMENV(env);
|
||||
MemEnv* mem_env = PARSEENV_MEMENV(env);
|
||||
BackRefNode* br = BACKREF_(node);
|
||||
if (NODE_IS_RECURSION(node)) break;
|
||||
|
||||
@ -3750,7 +3750,7 @@ node_min_byte_len(Node* node, ScanEnv* env)
|
||||
}
|
||||
|
||||
static OnigLen
|
||||
node_max_byte_len(Node* node, ScanEnv* env)
|
||||
node_max_byte_len(Node* node, ParseEnv* env)
|
||||
{
|
||||
OnigLen len;
|
||||
OnigLen tmax;
|
||||
@ -3787,7 +3787,7 @@ node_max_byte_len(Node* node, ScanEnv* env)
|
||||
if (! NODE_IS_CHECKER(node)) {
|
||||
int i;
|
||||
int* backs;
|
||||
MemEnv* mem_env = SCANENV_MEMENV(env);
|
||||
MemEnv* mem_env = PARSEENV_MEMENV(env);
|
||||
BackRefNode* br = BACKREF_(node);
|
||||
if (NODE_IS_RECURSION(node)) {
|
||||
#ifdef USE_BACKREF_WITH_LEVEL
|
||||
@ -3885,7 +3885,7 @@ node_max_byte_len(Node* node, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
check_backrefs(Node* node, ScanEnv* env)
|
||||
check_backrefs(Node* node, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -3930,7 +3930,7 @@ check_backrefs(Node* node, ScanEnv* env)
|
||||
int i;
|
||||
BackRefNode* br = BACKREF_(node);
|
||||
int* backs = BACKREFS_P(br);
|
||||
MemEnv* mem_env = SCANENV_MEMENV(env);
|
||||
MemEnv* mem_env = PARSEENV_MEMENV(env);
|
||||
|
||||
for (i = 0; i < br->back_num; i++) {
|
||||
if (backs[i] > env->num_mem)
|
||||
@ -3951,7 +3951,7 @@ check_backrefs(Node* node, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
set_empty_repeat_node_trav(Node* node, Node* empty, ScanEnv* env)
|
||||
set_empty_repeat_node_trav(Node* node, Node* empty, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -4005,7 +4005,7 @@ set_empty_repeat_node_trav(Node* node, Node* empty, ScanEnv* env)
|
||||
if (en->type == BAG_MEMORY) {
|
||||
if (NODE_IS_BACKREF(node)) {
|
||||
if (IS_NOT_NULL(empty))
|
||||
SCANENV_MEMENV(env)[en->m.regnum].empty_repeat_node = empty;
|
||||
PARSEENV_MEMENV(env)[en->m.regnum].empty_repeat_node = empty;
|
||||
}
|
||||
}
|
||||
else if (en->type == BAG_IF_ELSE) {
|
||||
@ -4041,7 +4041,7 @@ is_ancestor_node(Node* node, Node* me)
|
||||
}
|
||||
|
||||
static void
|
||||
set_empty_status_check_trav(Node* node, ScanEnv* env)
|
||||
set_empty_status_check_trav(Node* node, ParseEnv* env)
|
||||
{
|
||||
switch (NODE_TYPE(node)) {
|
||||
case NODE_LIST:
|
||||
@ -4085,7 +4085,7 @@ set_empty_status_check_trav(Node* node, ScanEnv* env)
|
||||
{
|
||||
int i;
|
||||
int* backs;
|
||||
MemEnv* mem_env = SCANENV_MEMENV(env);
|
||||
MemEnv* mem_env = PARSEENV_MEMENV(env);
|
||||
BackRefNode* br = BACKREF_(node);
|
||||
backs = BACKREFS_P(br);
|
||||
for (i = 0; i < br->back_num; i++) {
|
||||
@ -4157,7 +4157,7 @@ set_parent_node_trav(Node* node, Node* parent)
|
||||
#define RECURSION_INFINITE (1<<2)
|
||||
|
||||
static int
|
||||
infinite_recursive_call_check(Node* node, ScanEnv* env, int head)
|
||||
infinite_recursive_call_check(Node* node, ParseEnv* env, int head)
|
||||
{
|
||||
int ret;
|
||||
int r = 0;
|
||||
@ -4274,7 +4274,7 @@ infinite_recursive_call_check(Node* node, ScanEnv* env, int head)
|
||||
}
|
||||
|
||||
static int
|
||||
infinite_recursive_call_check_trav(Node* node, ScanEnv* env)
|
||||
infinite_recursive_call_check_trav(Node* node, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -4412,7 +4412,7 @@ recursive_call_check(Node* node)
|
||||
#define FOUND_CALLED_NODE 1
|
||||
|
||||
static int
|
||||
recursive_call_check_trav(Node* node, ScanEnv* env, int state)
|
||||
recursive_call_check_trav(Node* node, ParseEnv* env, int state)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
@ -4718,7 +4718,7 @@ list_reduce_in_look_behind(Node* node)
|
||||
}
|
||||
|
||||
static int
|
||||
alt_reduce_in_look_behind(Node* node, regex_t* reg, ScanEnv* env)
|
||||
alt_reduce_in_look_behind(Node* node, regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -4737,10 +4737,10 @@ alt_reduce_in_look_behind(Node* node, regex_t* reg, ScanEnv* env)
|
||||
return r;
|
||||
}
|
||||
|
||||
static int tune_tree(Node* node, regex_t* reg, int state, ScanEnv* env);
|
||||
static int tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env);
|
||||
|
||||
static int
|
||||
tune_look_behind(Node* node, regex_t* reg, int state, ScanEnv* env)
|
||||
tune_look_behind(Node* node, regex_t* reg, int state, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int state1;
|
||||
@ -5286,9 +5286,9 @@ quantifiers_memory_node_info(Node* node)
|
||||
__inline
|
||||
#endif
|
||||
static int
|
||||
check_call_reference(CallNode* cn, ScanEnv* env, int state)
|
||||
check_call_reference(CallNode* cn, ParseEnv* env, int state)
|
||||
{
|
||||
MemEnv* mem_env = SCANENV_MEMENV(env);
|
||||
MemEnv* mem_env = PARSEENV_MEMENV(env);
|
||||
|
||||
if (cn->by_number != 0) {
|
||||
int gnum = cn->called_gnum;
|
||||
@ -5405,7 +5405,7 @@ tune_call2_call(Node* node)
|
||||
}
|
||||
|
||||
static int
|
||||
tune_call(Node* node, ScanEnv* env, int state)
|
||||
tune_call(Node* node, ParseEnv* env, int state)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -5730,7 +5730,7 @@ tune_called_state(Node* node, int state)
|
||||
__inline
|
||||
#endif
|
||||
static int
|
||||
tune_anchor(Node* node, regex_t* reg, int state, ScanEnv* env)
|
||||
tune_anchor(Node* node, regex_t* reg, int state, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
AnchorNode* an = ANCHOR_(node);
|
||||
@ -5761,7 +5761,7 @@ tune_anchor(Node* node, regex_t* reg, int state, ScanEnv* env)
|
||||
__inline
|
||||
#endif
|
||||
static int
|
||||
tune_quant(Node* node, regex_t* reg, int state, ScanEnv* env)
|
||||
tune_quant(Node* node, regex_t* reg, int state, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
QuantNode* qn = QUANT_(node);
|
||||
@ -5838,7 +5838,7 @@ tune_quant(Node* node, regex_t* reg, int state, ScanEnv* env)
|
||||
6. expand repeated string.
|
||||
*/
|
||||
static int
|
||||
tune_tree(Node* node, regex_t* reg, int state, ScanEnv* env)
|
||||
tune_tree(Node* node, regex_t* reg, int state, ParseEnv* env)
|
||||
{
|
||||
int r = 0;
|
||||
|
||||
@ -6053,7 +6053,7 @@ typedef struct {
|
||||
MinMaxLen mm;
|
||||
OnigEncoding enc;
|
||||
OnigCaseFoldType case_fold_flag;
|
||||
ScanEnv* scan_env;
|
||||
ParseEnv* scan_env;
|
||||
} OptEnv;
|
||||
|
||||
typedef struct {
|
||||
@ -6964,7 +6964,7 @@ static void print_optimize_info(FILE* f, regex_t* reg);
|
||||
#endif
|
||||
|
||||
static int
|
||||
set_optimize_info_from_tree(Node* node, regex_t* reg, ScanEnv* scan_env)
|
||||
set_optimize_info_from_tree(Node* node, regex_t* reg, ParseEnv* scan_env)
|
||||
{
|
||||
int r;
|
||||
OptNode opt;
|
||||
@ -7093,6 +7093,7 @@ print_options(FILE* fp, OnigOptionType o)
|
||||
if ((o & ONIG_OPTION_NOT_BEGIN_STRING) != 0) fprintf(fp, " NOT_BIGIN_STRING");
|
||||
if ((o & ONIG_OPTION_NOT_END_STRING) != 0) fprintf(fp, " NOT_END_STRING");
|
||||
if ((o & ONIG_OPTION_NOT_BEGIN_POSITION) != 0) fprintf(fp, " NOT_BEGIN_POSITION");
|
||||
if ((o & ONIG_OPTION_CALLBACK_EACH_MATCH) != 0) fprintf(fp, " CALLBACK_EACH_MATCH");
|
||||
}
|
||||
|
||||
#endif /* ONIG_DEBUG */
|
||||
@ -7320,7 +7321,7 @@ static void print_tree P_((FILE* f, Node* node));
|
||||
extern int onig_init_for_match_at(regex_t* reg);
|
||||
|
||||
static int parse_and_tune(regex_t* reg, const UChar* pattern,
|
||||
const UChar* pattern_end, ScanEnv *scan_env, Node** rroot,
|
||||
const UChar* pattern_end, ParseEnv *scan_env, Node** rroot,
|
||||
OnigErrorInfo* einfo
|
||||
#ifdef USE_CALL
|
||||
, UnsetAddrList* uslist
|
||||
@ -7428,10 +7429,10 @@ onig_compile(regex_t* reg, const UChar* pattern, const UChar* pattern_end,
|
||||
OnigErrorInfo* einfo)
|
||||
{
|
||||
int r;
|
||||
Node* root;
|
||||
ScanEnv scan_env;
|
||||
Node* root;
|
||||
ParseEnv scan_env;
|
||||
#ifdef USE_CALL
|
||||
UnsetAddrList uslist = {0};
|
||||
UnsetAddrList uslist = {0};
|
||||
#endif
|
||||
|
||||
#ifdef ONIG_DEBUG
|
||||
@ -8112,7 +8113,7 @@ onig_detect_can_be_slow_pattern(const UChar* pattern,
|
||||
int r;
|
||||
regex_t* reg;
|
||||
Node* root;
|
||||
ScanEnv scan_env;
|
||||
ParseEnv scan_env;
|
||||
SlowElementCount count;
|
||||
int calls[MAX_CALLS_IN_DETECT];
|
||||
#ifdef USE_CALL
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
regexec.c - Oniguruma (regular expression library)
|
||||
**********************************************************************/
|
||||
/*-
|
||||
* Copyright (c) 2002-2020 K.Kosako
|
||||
* Copyright (c) 2002-2021 K.Kosako
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
@ -880,6 +880,23 @@ onig_get_capture_tree(OnigRegion* region)
|
||||
}
|
||||
#endif /* USE_CAPTURE_HISTORY */
|
||||
|
||||
|
||||
static OnigCallbackEachMatchFunc CallbackEachMatch;
|
||||
|
||||
extern OnigCallbackEachMatchFunc
|
||||
onig_get_callback_each_match(void)
|
||||
{
|
||||
return CallbackEachMatch;
|
||||
}
|
||||
|
||||
extern int
|
||||
onig_set_callback_each_match(OnigCallbackEachMatchFunc f)
|
||||
{
|
||||
CallbackEachMatch = f;
|
||||
return ONIG_NORMAL;
|
||||
}
|
||||
|
||||
|
||||
extern void
|
||||
onig_region_clear(OnigRegion* region)
|
||||
{
|
||||
@ -1245,7 +1262,7 @@ struct OnigCalloutArgsStruct {
|
||||
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
|
||||
#define MATCH_ARG_INIT(msa, reg, arg_option, arg_region, arg_start, mpv) do { \
|
||||
(msa).stack_p = (void* )0;\
|
||||
(msa).options = (arg_option);\
|
||||
(msa).options = (arg_option)|(reg)->options;\
|
||||
(msa).region = (arg_region);\
|
||||
(msa).start = (arg_start);\
|
||||
(msa).match_stack_limit = (mpv)->match_stack_limit;\
|
||||
@ -1258,7 +1275,7 @@ struct OnigCalloutArgsStruct {
|
||||
#else
|
||||
#define MATCH_ARG_INIT(msa, reg, arg_option, arg_region, arg_start, mpv) do { \
|
||||
(msa).stack_p = (void* )0;\
|
||||
(msa).options = (arg_option);\
|
||||
(msa).options = (arg_option)|(reg)->options;\
|
||||
(msa).region = (arg_region);\
|
||||
(msa).start = (arg_start);\
|
||||
(msa).match_stack_limit = (mpv)->match_stack_limit;\
|
||||
@ -1412,6 +1429,7 @@ onig_set_subexp_call_limit_in_search(unsigned long n)
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef USE_CALLOUT
|
||||
static OnigCalloutFunc DefaultProgressCallout;
|
||||
static OnigCalloutFunc DefaultRetractionCallout;
|
||||
@ -2919,6 +2937,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
StackType *stkp; /* used as any purpose. */
|
||||
StkPtrType *mem_start_stk, *mem_end_stk;
|
||||
UChar* keep;
|
||||
OnigRegion* region;
|
||||
|
||||
#ifdef USE_REPEAT_AND_EMPTY_CHECK_LOCAL_VAR
|
||||
StackIndex *repeat_stk;
|
||||
@ -2936,8 +2955,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
unsigned long subexp_call_counters[MAX_SUBEXP_CALL_COUNTERS];
|
||||
#endif
|
||||
|
||||
OnigOptionType options;
|
||||
Operation* p = reg->ops;
|
||||
OnigOptionType option = reg->options;
|
||||
OnigEncoding encode = reg->enc;
|
||||
OnigCaseFoldType case_fold_flag = reg->case_fold_flag;
|
||||
|
||||
@ -2967,6 +2986,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
}
|
||||
#endif
|
||||
|
||||
options = msa->options;
|
||||
|
||||
#ifdef USE_CALLOUT
|
||||
msa->mp->match_at_call_counter++;
|
||||
#endif
|
||||
@ -3007,102 +3028,114 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
BYTECODE_INTERPRETER_START {
|
||||
CASE_OP(END)
|
||||
n = (int )(s - sstart);
|
||||
if (n == 0 && OPTON_FIND_NOT_EMPTY(options)) {
|
||||
best_len = ONIG_MISMATCH;
|
||||
goto fail; /* for retry */
|
||||
}
|
||||
|
||||
if (n > best_len) {
|
||||
OnigRegion* region;
|
||||
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
|
||||
if (OPTON_FIND_LONGEST(option)) {
|
||||
if (OPTON_FIND_LONGEST(options)) {
|
||||
if (n > msa->best_len) {
|
||||
msa->best_len = n;
|
||||
msa->best_s = (UChar* )sstart;
|
||||
goto set_region;
|
||||
}
|
||||
else
|
||||
goto end_best_len;
|
||||
}
|
||||
#endif
|
||||
best_len = n;
|
||||
|
||||
set_region:
|
||||
region = msa->region;
|
||||
if (region) {
|
||||
if (keep > s) keep = s;
|
||||
|
||||
#ifdef USE_POSIX_API
|
||||
if (OPTON_POSIX_REGION(msa->options)) {
|
||||
posix_regmatch_t* rmt = (posix_regmatch_t* )region;
|
||||
|
||||
rmt[0].rm_so = (regoff_t )(keep - str);
|
||||
rmt[0].rm_eo = (regoff_t )(s - str);
|
||||
for (i = 1; i <= num_mem; i++) {
|
||||
if (mem_end_stk[i].i != INVALID_STACK_INDEX) {
|
||||
rmt[i].rm_so = (regoff_t )(STACK_MEM_START(reg, i) - str);
|
||||
rmt[i].rm_eo = (regoff_t )(STACK_MEM_END(reg, i) - str);
|
||||
}
|
||||
else {
|
||||
rmt[i].rm_so = rmt[i].rm_eo = ONIG_REGION_NOTPOS;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
#endif /* USE_POSIX_API */
|
||||
region->beg[0] = (int )(keep - str);
|
||||
region->end[0] = (int )(s - str);
|
||||
for (i = 1; i <= num_mem; i++) {
|
||||
if (mem_end_stk[i].i != INVALID_STACK_INDEX) {
|
||||
region->beg[i] = (int )(STACK_MEM_START(reg, i) - str);
|
||||
region->end[i] = (int )(STACK_MEM_END(reg, i) - str);
|
||||
}
|
||||
else {
|
||||
region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
|
||||
}
|
||||
if (s >= in_right_range && msa->best_s == sstart) {
|
||||
best_len = msa->best_len; /* end of find */
|
||||
}
|
||||
else {
|
||||
SOP_OUT;
|
||||
goto fail; /* for retry */
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
best_len = n;
|
||||
}
|
||||
#else
|
||||
best_len = n;
|
||||
#endif
|
||||
}
|
||||
|
||||
/* set region */
|
||||
region = msa->region;
|
||||
if (region) {
|
||||
if (keep > s) keep = s;
|
||||
|
||||
#ifdef USE_POSIX_API
|
||||
if (OPTON_POSIX_REGION(options)) {
|
||||
posix_regmatch_t* rmt = (posix_regmatch_t* )region;
|
||||
|
||||
rmt[0].rm_so = (regoff_t )(keep - str);
|
||||
rmt[0].rm_eo = (regoff_t )(s - str);
|
||||
for (i = 1; i <= num_mem; i++) {
|
||||
if (mem_end_stk[i].i != INVALID_STACK_INDEX) {
|
||||
rmt[i].rm_so = (regoff_t )(STACK_MEM_START(reg, i) - str);
|
||||
rmt[i].rm_eo = (regoff_t )(STACK_MEM_END(reg, i) - str);
|
||||
}
|
||||
else {
|
||||
rmt[i].rm_so = rmt[i].rm_eo = ONIG_REGION_NOTPOS;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
#endif /* USE_POSIX_API */
|
||||
region->beg[0] = (int )(keep - str);
|
||||
region->end[0] = (int )(s - str);
|
||||
for (i = 1; i <= num_mem; i++) {
|
||||
if (mem_end_stk[i].i != INVALID_STACK_INDEX) {
|
||||
region->beg[i] = (int )(STACK_MEM_START(reg, i) - str);
|
||||
region->end[i] = (int )(STACK_MEM_END(reg, i) - str);
|
||||
}
|
||||
else {
|
||||
region->beg[i] = region->end[i] = ONIG_REGION_NOTPOS;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef USE_CAPTURE_HISTORY
|
||||
if (reg->capture_history != 0) {
|
||||
int r;
|
||||
OnigCaptureTreeNode* node;
|
||||
if (reg->capture_history != 0) {
|
||||
int r;
|
||||
OnigCaptureTreeNode* node;
|
||||
|
||||
if (IS_NULL(region->history_root)) {
|
||||
region->history_root = node = history_node_new();
|
||||
CHECK_NULL_RETURN_MEMERR(node);
|
||||
}
|
||||
else {
|
||||
node = region->history_root;
|
||||
history_tree_clear(node);
|
||||
}
|
||||
|
||||
node->group = 0;
|
||||
node->beg = (int )(keep - str);
|
||||
node->end = (int )(s - str);
|
||||
|
||||
stkp = stk_base;
|
||||
r = make_capture_history_tree(region->history_root, &stkp,
|
||||
stk, (UChar* )str, reg);
|
||||
if (r < 0) MATCH_AT_ERROR_RETURN(r);
|
||||
if (IS_NULL(region->history_root)) {
|
||||
region->history_root = node = history_node_new();
|
||||
CHECK_NULL_RETURN_MEMERR(node);
|
||||
}
|
||||
else {
|
||||
node = region->history_root;
|
||||
history_tree_clear(node);
|
||||
}
|
||||
|
||||
node->group = 0;
|
||||
node->beg = (int )(keep - str);
|
||||
node->end = (int )(s - str);
|
||||
|
||||
stkp = stk_base;
|
||||
r = make_capture_history_tree(region->history_root, &stkp,
|
||||
stk, (UChar* )str, reg);
|
||||
if (r < 0) MATCH_AT_ERROR_RETURN(r);
|
||||
}
|
||||
#endif /* USE_CAPTURE_HISTORY */
|
||||
#ifdef USE_POSIX_API
|
||||
} /* else OPTON_POSIX_REGION() */
|
||||
} /* else OPTON_POSIX_REGION() */
|
||||
#endif
|
||||
} /* if (region) */
|
||||
} /* n > best_len */
|
||||
} /* if (region) */
|
||||
|
||||
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
|
||||
end_best_len:
|
||||
#endif
|
||||
SOP_OUT;
|
||||
|
||||
if (OPTON_FIND_CONDITION(option)) {
|
||||
if (OPTON_FIND_NOT_EMPTY(option) && s == sstart) {
|
||||
if (OPTON_CALLBACK_EACH_MATCH(options) &&
|
||||
IS_NOT_NULL(CallbackEachMatch)) {
|
||||
int r = CallbackEachMatch(str, end, in_right_range, sstart, region,
|
||||
msa->mp->callout_user_data);
|
||||
if (r < 0) MATCH_AT_ERROR_RETURN(r);
|
||||
|
||||
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
|
||||
if (! OPTON_FIND_LONGEST(options))
|
||||
#endif
|
||||
best_len = ONIG_MISMATCH;
|
||||
goto fail; /* for retry */
|
||||
}
|
||||
if (OPTON_FIND_LONGEST(option)) {
|
||||
if (s >= in_right_range && msa->best_s == sstart)
|
||||
best_len = msa->best_len;
|
||||
else
|
||||
goto fail; /* for retry */
|
||||
}
|
||||
|
||||
goto fail;
|
||||
}
|
||||
|
||||
/* default behavior: return first-matching result. */
|
||||
@ -3595,23 +3628,23 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
|
||||
CASE_OP(BEGIN_BUF)
|
||||
if (! ON_STR_BEGIN(s)) goto fail;
|
||||
if (OPTON_NOTBOL(msa->options)) goto fail;
|
||||
if (OPTON_NOT_BEGIN_STRING(msa->options)) goto fail;
|
||||
if (OPTON_NOTBOL(options)) goto fail;
|
||||
if (OPTON_NOT_BEGIN_STRING(options)) goto fail;
|
||||
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
|
||||
CASE_OP(END_BUF)
|
||||
if (! ON_STR_END(s)) goto fail;
|
||||
if (OPTON_NOTEOL(msa->options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(msa->options)) goto fail;
|
||||
if (OPTON_NOTEOL(options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(options)) goto fail;
|
||||
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
|
||||
CASE_OP(BEGIN_LINE)
|
||||
if (ON_STR_BEGIN(s)) {
|
||||
if (OPTON_NOTBOL(msa->options)) goto fail;
|
||||
if (OPTON_NOTBOL(options)) goto fail;
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
}
|
||||
@ -3632,7 +3665,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);
|
||||
if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
|
||||
#endif
|
||||
if (OPTON_NOTEOL(msa->options)) goto fail;
|
||||
if (OPTON_NOTEOL(options)) goto fail;
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
|
||||
@ -3659,8 +3692,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
UChar* sprev = (UChar* )onigenc_get_prev_char_head(encode, str, s);
|
||||
if (IS_EMPTY_STR || !ONIGENC_IS_MBC_NEWLINE(encode, sprev, end)) {
|
||||
#endif
|
||||
if (OPTON_NOTEOL(msa->options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(msa->options)) goto fail;
|
||||
if (OPTON_NOTEOL(options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(options)) goto fail;
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
#ifndef USE_NEWLINE_AT_END_OF_STRING_HAS_EMPTY_LINE
|
||||
@ -3669,8 +3702,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
}
|
||||
else if (ONIGENC_IS_MBC_NEWLINE(encode, s, end) &&
|
||||
ON_STR_END(s + enclen(encode, s))) {
|
||||
if (OPTON_NOTEOL(msa->options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(msa->options)) goto fail;
|
||||
if (OPTON_NOTEOL(options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(options)) goto fail;
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
}
|
||||
@ -3679,8 +3712,8 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
UChar* ss = s + enclen(encode, s);
|
||||
ss += enclen(encode, ss);
|
||||
if (ON_STR_END(ss)) {
|
||||
if (OPTON_NOTEOL(msa->options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(msa->options)) goto fail;
|
||||
if (OPTON_NOTEOL(options)) goto fail;
|
||||
if (OPTON_NOT_END_STRING(options)) goto fail;
|
||||
INC_OP;
|
||||
JUMP_OUT;
|
||||
}
|
||||
@ -3692,7 +3725,7 @@ match_at(regex_t* reg, const UChar* str, const UChar* end,
|
||||
switch (p->check_position.type) {
|
||||
case CHECK_POSITION_SEARCH_START:
|
||||
if (s != msa->start) goto fail;
|
||||
if (OPTON_NOT_BEGIN_POSITION(msa->options)) goto fail;
|
||||
if (OPTON_NOT_BEGIN_POSITION(options)) goto fail;
|
||||
break;
|
||||
case CHECK_POSITION_CURRENT_RIGHT_RANGE:
|
||||
if (s != right_range) goto fail;
|
||||
@ -4647,7 +4680,7 @@ onig_regset_search_with_param(OnigRegSet* set,
|
||||
if (set->n == 0)
|
||||
return ONIG_MISMATCH;
|
||||
|
||||
if (OPTON_POSIX_REGION(option))
|
||||
if (OPTON_POSIX_REGION(option) || OPTON_CALLBACK_EACH_MATCH(option))
|
||||
return ONIGERR_INVALID_ARGUMENT;
|
||||
|
||||
r = 0;
|
||||
@ -5942,8 +5975,10 @@ onig_regset_add(OnigRegSet* set, regex_t* reg)
|
||||
{
|
||||
OnigRegion* region;
|
||||
|
||||
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
|
||||
if (OPTON_FIND_LONGEST(reg->options))
|
||||
return ONIGERR_INVALID_ARGUMENT;
|
||||
#endif
|
||||
|
||||
if (set->n != 0 && reg->enc != set->enc)
|
||||
return ONIGERR_INVALID_ARGUMENT;
|
||||
@ -5988,8 +6023,10 @@ onig_regset_replace(OnigRegSet* set, int at, regex_t* reg)
|
||||
set->n--;
|
||||
}
|
||||
else {
|
||||
#ifdef USE_FIND_LONGEST_SEARCH_ALL_OF_RANGE
|
||||
if (OPTON_FIND_LONGEST(reg->options))
|
||||
return ONIGERR_INVALID_ARGUMENT;
|
||||
#endif
|
||||
|
||||
if (set->n > 1 && reg->enc != set->enc)
|
||||
return ONIGERR_INVALID_ARGUMENT;
|
||||
|
||||
@ -390,10 +390,10 @@ typedef unsigned int MemStatusType;
|
||||
(IS_CODE_DIGIT_ASCII(enc,code) ? DIGITVAL(code) \
|
||||
: (ONIGENC_IS_CODE_UPPER(enc,code) ? (code) - 'A' + 10 : (code) - 'a' + 10))
|
||||
|
||||
#define OPTON_CALLBACK_EACH_MATCH(option) \
|
||||
((option) & ONIG_OPTION_CALLBACK_EACH_MATCH)
|
||||
#define OPTON_FIND_LONGEST(option) ((option) & ONIG_OPTION_FIND_LONGEST)
|
||||
#define OPTON_FIND_NOT_EMPTY(option) ((option) & ONIG_OPTION_FIND_NOT_EMPTY)
|
||||
#define OPTON_FIND_CONDITION(option) ((option) & \
|
||||
(ONIG_OPTION_FIND_LONGEST | ONIG_OPTION_FIND_NOT_EMPTY))
|
||||
#define OPTON_NEGATE_SINGLELINE(option) ((option) & \
|
||||
ONIG_OPTION_NEGATE_SINGLELINE)
|
||||
#define OPTON_DONT_CAPTURE_GROUP(option) ((option) & \
|
||||
|
||||
@ -300,7 +300,7 @@ bbuf_clone(BBuf** rto, BBuf* from)
|
||||
}
|
||||
|
||||
static int
|
||||
backref_rel_to_abs(int rel_no, ScanEnv* env)
|
||||
backref_rel_to_abs(int rel_no, ParseEnv* env)
|
||||
{
|
||||
if (rel_no > 0) {
|
||||
if (rel_no > ONIG_INT_MAX - env->num_mem)
|
||||
@ -981,7 +981,7 @@ onig_number_of_names(regex_t* reg)
|
||||
#endif /* else USE_ST_LIBRARY */
|
||||
|
||||
static int
|
||||
name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
|
||||
name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int alloc;
|
||||
@ -1115,7 +1115,7 @@ onig_name_to_group_numbers(regex_t* reg, const UChar* name,
|
||||
}
|
||||
|
||||
static int
|
||||
name_to_group_numbers(ScanEnv* env, const UChar* name, const UChar* name_end,
|
||||
name_to_group_numbers(ParseEnv* env, const UChar* name, const UChar* name_end,
|
||||
int** nums)
|
||||
{
|
||||
regex_t* reg;
|
||||
@ -1920,7 +1920,7 @@ callout_tag_table_new(CalloutTagTable** rt)
|
||||
}
|
||||
|
||||
static int
|
||||
callout_tag_entry_raw(ScanEnv* env, CalloutTagTable* t, UChar* name,
|
||||
callout_tag_entry_raw(ParseEnv* env, CalloutTagTable* t, UChar* name,
|
||||
UChar* name_end, CalloutTagVal entry_val)
|
||||
{
|
||||
int r;
|
||||
@ -1963,7 +1963,7 @@ ext_ensure_tag_table(regex_t* reg)
|
||||
}
|
||||
|
||||
static int
|
||||
callout_tag_entry(ScanEnv* env, regex_t* reg, UChar* name, UChar* name_end,
|
||||
callout_tag_entry(ParseEnv* env, regex_t* reg, UChar* name, UChar* name_end,
|
||||
CalloutTagVal entry_val)
|
||||
{
|
||||
int r;
|
||||
@ -1988,10 +1988,10 @@ callout_tag_entry(ScanEnv* env, regex_t* reg, UChar* name, UChar* name_end,
|
||||
#endif /* USE_CALLOUT */
|
||||
|
||||
|
||||
#define INIT_SCANENV_MEMENV_ALLOC_SIZE 16
|
||||
#define INIT_PARSEENV_MEMENV_ALLOC_SIZE 16
|
||||
|
||||
static void
|
||||
scan_env_clear(ScanEnv* env)
|
||||
scan_env_clear(ParseEnv* env)
|
||||
{
|
||||
MEM_STATUS_CLEAR(env->cap_history);
|
||||
MEM_STATUS_CLEAR(env->backtrack_mem);
|
||||
@ -2024,7 +2024,7 @@ scan_env_clear(ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
scan_env_add_mem_entry(ScanEnv* env)
|
||||
scan_env_add_mem_entry(ParseEnv* env)
|
||||
{
|
||||
int i, need, alloc;
|
||||
MemEnv* p;
|
||||
@ -2033,10 +2033,10 @@ scan_env_add_mem_entry(ScanEnv* env)
|
||||
if (need > MaxCaptureNum && MaxCaptureNum != 0)
|
||||
return ONIGERR_TOO_MANY_CAPTURES;
|
||||
|
||||
if (need >= SCANENV_MEMENV_SIZE) {
|
||||
if (need >= PARSEENV_MEMENV_SIZE) {
|
||||
if (env->mem_alloc <= need) {
|
||||
if (IS_NULL(env->mem_env_dynamic)) {
|
||||
alloc = INIT_SCANENV_MEMENV_ALLOC_SIZE;
|
||||
alloc = INIT_PARSEENV_MEMENV_ALLOC_SIZE;
|
||||
p = (MemEnv* )xmalloc(sizeof(MemEnv) * alloc);
|
||||
CHECK_NULL_RETURN_MEMERR(p);
|
||||
xmemcpy(p, env->mem_env_static, sizeof(env->mem_env_static));
|
||||
@ -2062,10 +2062,10 @@ scan_env_add_mem_entry(ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
scan_env_set_mem_node(ScanEnv* env, int num, Node* node)
|
||||
scan_env_set_mem_node(ParseEnv* env, int num, Node* node)
|
||||
{
|
||||
if (env->num_mem >= num)
|
||||
SCANENV_MEMENV(env)[num].mem_node = node;
|
||||
PARSEENV_MEMENV(env)[num].mem_node = node;
|
||||
else
|
||||
return ONIGERR_PARSER_BUG;
|
||||
return 0;
|
||||
@ -2285,7 +2285,7 @@ node_new_anychar(OnigOptionType options)
|
||||
}
|
||||
|
||||
static int
|
||||
node_new_no_newline(Node** node, ScanEnv* env)
|
||||
node_new_no_newline(Node** node, ParseEnv* env)
|
||||
{
|
||||
Node* n;
|
||||
|
||||
@ -2425,7 +2425,7 @@ node_new_backref(int back_num, int* backrefs, int by_name,
|
||||
#ifdef USE_BACKREF_WITH_LEVEL
|
||||
int exist_level, int nest_level,
|
||||
#endif
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int i;
|
||||
Node* node;
|
||||
@ -2451,7 +2451,7 @@ node_new_backref(int back_num, int* backrefs, int by_name,
|
||||
|
||||
for (i = 0; i < back_num; i++) {
|
||||
if (backrefs[i] <= env->num_mem &&
|
||||
IS_NULL(SCANENV_MEMENV(env)[backrefs[i]].mem_node)) {
|
||||
IS_NULL(PARSEENV_MEMENV(env)[backrefs[i]].mem_node)) {
|
||||
NODE_STATUS_ADD(node, RECURSION); /* /...(\1).../ */
|
||||
break;
|
||||
}
|
||||
@ -2481,7 +2481,7 @@ node_new_backref_checker(int back_num, int* backrefs, int by_name,
|
||||
#ifdef USE_BACKREF_WITH_LEVEL
|
||||
int exist_level, int nest_level,
|
||||
#endif
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
Node* node;
|
||||
|
||||
@ -2641,7 +2641,7 @@ node_set_fail(Node* node)
|
||||
}
|
||||
|
||||
static int
|
||||
node_new_fail(Node** node, ScanEnv* env)
|
||||
node_new_fail(Node** node, ParseEnv* env)
|
||||
{
|
||||
*node = node_new();
|
||||
CHECK_NULL_RETURN_MEMERR(*node);
|
||||
@ -2657,7 +2657,7 @@ onig_node_reset_fail(Node* node)
|
||||
}
|
||||
|
||||
static int
|
||||
node_new_save_gimmick(Node** node, enum SaveType save_type, ScanEnv* env)
|
||||
node_new_save_gimmick(Node** node, enum SaveType save_type, ParseEnv* env)
|
||||
{
|
||||
int id;
|
||||
|
||||
@ -2676,7 +2676,7 @@ node_new_save_gimmick(Node** node, enum SaveType save_type, ScanEnv* env)
|
||||
|
||||
static int
|
||||
node_new_update_var_gimmick(Node** node, enum UpdateVarType update_var_type,
|
||||
int id, ScanEnv* env)
|
||||
int id, ParseEnv* env)
|
||||
{
|
||||
*node = node_new();
|
||||
CHECK_NULL_RETURN_MEMERR(*node);
|
||||
@ -2690,7 +2690,7 @@ node_new_update_var_gimmick(Node** node, enum UpdateVarType update_var_type,
|
||||
}
|
||||
|
||||
static int
|
||||
node_new_keep(Node** node, ScanEnv* env)
|
||||
node_new_keep(Node** node, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -2744,7 +2744,7 @@ onig_reg_callout_list_at(regex_t* reg, int num)
|
||||
}
|
||||
|
||||
static int
|
||||
reg_callout_list_entry(ScanEnv* env, int* rnum)
|
||||
reg_callout_list_entry(ParseEnv* env, int* rnum)
|
||||
{
|
||||
#define INIT_CALLOUT_LIST_NUM 3
|
||||
|
||||
@ -2796,7 +2796,7 @@ reg_callout_list_entry(ScanEnv* env, int* rnum)
|
||||
|
||||
static int
|
||||
node_new_callout(Node** node, OnigCalloutOf callout_of, int num, int id,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
*node = node_new();
|
||||
CHECK_NULL_RETURN_MEMERR(*node);
|
||||
@ -2812,7 +2812,7 @@ node_new_callout(Node** node, OnigCalloutOf callout_of, int num, int id,
|
||||
#endif
|
||||
|
||||
static int
|
||||
make_text_segment(Node** node, ScanEnv* env)
|
||||
make_text_segment(Node** node, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
@ -2869,7 +2869,7 @@ make_text_segment(Node** node, ScanEnv* env)
|
||||
static int
|
||||
make_absent_engine(Node** node, int pre_save_right_id, Node* absent,
|
||||
Node* step_one, int lower, int upper, int possessive,
|
||||
int is_range_cutter, ScanEnv* env)
|
||||
int is_range_cutter, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
@ -2951,7 +2951,7 @@ make_absent_engine(Node** node, int pre_save_right_id, Node* absent,
|
||||
|
||||
static int
|
||||
make_absent_tail(Node** node1, Node** node2, int pre_save_right_id,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int id;
|
||||
@ -2999,7 +2999,7 @@ make_absent_tail(Node** node1, Node** node2, int pre_save_right_id,
|
||||
}
|
||||
|
||||
static int
|
||||
make_range_clear(Node** node, ScanEnv* env)
|
||||
make_range_clear(Node** node, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int id;
|
||||
@ -3058,7 +3058,7 @@ make_range_clear(Node** node, ScanEnv* env)
|
||||
|
||||
static int
|
||||
is_simple_one_char_repeat(Node* node, Node** rquant, Node** rbody,
|
||||
int* is_possessive, ScanEnv* env)
|
||||
int* is_possessive, ParseEnv* env)
|
||||
{
|
||||
Node* quant;
|
||||
Node* body;
|
||||
@ -3124,8 +3124,8 @@ is_simple_one_char_repeat(Node* node, Node** rquant, Node** rbody,
|
||||
}
|
||||
|
||||
static int
|
||||
make_absent_tree_for_simple_one_char_repeat(Node** node, Node* absent, Node* quant,
|
||||
Node* body, int possessive, ScanEnv* env)
|
||||
make_absent_tree_for_simple_one_char_repeat(Node** node,
|
||||
Node* absent, Node* quant, Node* body, int possessive, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
@ -3172,7 +3172,7 @@ make_absent_tree_for_simple_one_char_repeat(Node** node, Node* absent, Node* qua
|
||||
|
||||
static int
|
||||
make_absent_tree(Node** node, Node* absent, Node* expr, int is_range_cutter,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
@ -3845,7 +3845,7 @@ add_code_range_to_buf(BBuf** pbuf, OnigCodePoint from, OnigCodePoint to)
|
||||
}
|
||||
|
||||
static int
|
||||
add_code_range(BBuf** pbuf, ScanEnv* env, OnigCodePoint from, OnigCodePoint to)
|
||||
add_code_range(BBuf** pbuf, ParseEnv* env, OnigCodePoint from, OnigCodePoint to)
|
||||
{
|
||||
if (from > to) {
|
||||
if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
|
||||
@ -4173,7 +4173,7 @@ or_cclass(CClassNode* dest, CClassNode* cc, OnigEncoding enc)
|
||||
}
|
||||
|
||||
static OnigCodePoint
|
||||
conv_backslash_value(OnigCodePoint c, ScanEnv* env)
|
||||
conv_backslash_value(OnigCodePoint c, ParseEnv* env)
|
||||
{
|
||||
if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_CONTROL_CHARS)) {
|
||||
switch (c) {
|
||||
@ -4342,7 +4342,7 @@ onig_reduce_nested_quantifier(Node* pnode)
|
||||
}
|
||||
|
||||
static int
|
||||
node_new_general_newline(Node** node, ScanEnv* env)
|
||||
node_new_general_newline(Node** node, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int dlen, alen;
|
||||
@ -4474,7 +4474,7 @@ ptoken_init(PToken* tok)
|
||||
}
|
||||
|
||||
static int
|
||||
fetch_interval(UChar** src, UChar* end, PToken* tok, ScanEnv* env)
|
||||
fetch_interval(UChar** src, UChar* end, PToken* tok, ParseEnv* env)
|
||||
{
|
||||
int low, up, syn_allow, non_low = 0;
|
||||
int r = 0;
|
||||
@ -4577,7 +4577,8 @@ fetch_interval(UChar** src, UChar* end, PToken* tok, ScanEnv* env)
|
||||
|
||||
/* \M-, \C-, \c, or \... */
|
||||
static int
|
||||
fetch_escaped_value_raw(UChar** src, UChar* end, ScanEnv* env, OnigCodePoint* val)
|
||||
fetch_escaped_value_raw(UChar** src, UChar* end, ParseEnv* env,
|
||||
OnigCodePoint* val)
|
||||
{
|
||||
int v;
|
||||
OnigCodePoint c;
|
||||
@ -4648,7 +4649,7 @@ fetch_escaped_value_raw(UChar** src, UChar* end, ScanEnv* env, OnigCodePoint* va
|
||||
}
|
||||
|
||||
static int
|
||||
fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env, OnigCodePoint* val)
|
||||
fetch_escaped_value(UChar** src, UChar* end, ParseEnv* env, OnigCodePoint* val)
|
||||
{
|
||||
int r;
|
||||
int len;
|
||||
@ -4662,7 +4663,7 @@ fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env, OnigCodePoint* val)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int fetch_token(PToken* tok, UChar** src, UChar* end, ScanEnv* env);
|
||||
static int fetch_token(PToken* tok, UChar** src, UChar* end, ParseEnv* env);
|
||||
|
||||
static OnigCodePoint
|
||||
get_name_end_code_point(OnigCodePoint start)
|
||||
@ -4693,7 +4694,7 @@ enum REF_NUM {
|
||||
*/
|
||||
static int
|
||||
fetch_name_with_level(OnigCodePoint start_code, UChar** src, UChar* end,
|
||||
UChar** rname_end, ScanEnv* env,
|
||||
UChar** rname_end, ParseEnv* env,
|
||||
int* rback_num, int* rlevel, enum REF_NUM* num_type)
|
||||
{
|
||||
int r, sign, exist_level;
|
||||
@ -4827,7 +4828,7 @@ fetch_name_with_level(OnigCodePoint start_code, UChar** src, UChar* end,
|
||||
*/
|
||||
static int
|
||||
fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
|
||||
UChar** rname_end, ScanEnv* env, int* rback_num,
|
||||
UChar** rname_end, ParseEnv* env, int* rback_num,
|
||||
enum REF_NUM* num_type, int is_ref)
|
||||
{
|
||||
int r, sign;
|
||||
@ -4959,7 +4960,7 @@ fetch_name(OnigCodePoint start_code, UChar** src, UChar* end,
|
||||
}
|
||||
|
||||
static void
|
||||
CC_ESC_WARN(ScanEnv* env, UChar *c)
|
||||
CC_ESC_WARN(ParseEnv* env, UChar *c)
|
||||
{
|
||||
if (onig_warn == onig_null_warn) return ;
|
||||
|
||||
@ -4975,7 +4976,7 @@ CC_ESC_WARN(ScanEnv* env, UChar *c)
|
||||
}
|
||||
|
||||
static void
|
||||
CLOSE_BRACKET_WITHOUT_ESC_WARN(ScanEnv* env, UChar* c)
|
||||
CLOSE_BRACKET_WITHOUT_ESC_WARN(ParseEnv* env, UChar* c)
|
||||
{
|
||||
if (onig_warn == onig_null_warn) return ;
|
||||
|
||||
@ -5056,7 +5057,7 @@ str_exist_check_with_esc(OnigCodePoint s[], int n, UChar* from, UChar* to,
|
||||
}
|
||||
|
||||
static int
|
||||
fetch_token_cc(PToken* tok, UChar** src, UChar* end, ScanEnv* env, int state)
|
||||
fetch_token_cc(PToken* tok, UChar** src, UChar* end, ParseEnv* env, int state)
|
||||
{
|
||||
int r;
|
||||
OnigCodePoint code;
|
||||
@ -5340,7 +5341,7 @@ fetch_token_cc(PToken* tok, UChar** src, UChar* end, ScanEnv* env, int state)
|
||||
}
|
||||
|
||||
static int
|
||||
fetch_token(PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
fetch_token(PToken* tok, UChar** src, UChar* end, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
OnigCodePoint code;
|
||||
@ -5732,7 +5733,7 @@ fetch_token(PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_DECIMAL_BACKREF) &&
|
||||
(r <= env->num_mem || r <= 9)) { /* This spec. from GNU regex */
|
||||
if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
|
||||
if (r > env->num_mem || IS_NULL(SCANENV_MEMENV(env)[r].mem_node))
|
||||
if (r > env->num_mem || IS_NULL(PARSEENV_MEMENV(env)[r].mem_node))
|
||||
return ONIGERR_INVALID_BACKREF;
|
||||
}
|
||||
|
||||
@ -5808,7 +5809,7 @@ fetch_token(PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
|
||||
if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
|
||||
if (back_num > env->num_mem ||
|
||||
IS_NULL(SCANENV_MEMENV(env)[back_num].mem_node))
|
||||
IS_NULL(PARSEENV_MEMENV(env)[back_num].mem_node))
|
||||
return ONIGERR_INVALID_BACKREF;
|
||||
}
|
||||
tok->type = TK_BACKREF;
|
||||
@ -5825,7 +5826,7 @@ fetch_token(PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
int i;
|
||||
for (i = 0; i < num; i++) {
|
||||
if (backs[i] > env->num_mem ||
|
||||
IS_NULL(SCANENV_MEMENV(env)[backs[i]].mem_node))
|
||||
IS_NULL(PARSEENV_MEMENV(env)[backs[i]].mem_node))
|
||||
return ONIGERR_INVALID_BACKREF;
|
||||
}
|
||||
}
|
||||
@ -6368,7 +6369,7 @@ add_ctype_to_cc_by_range_limit(CClassNode* cc, int ctype ARG_UNUSED, int not,
|
||||
}
|
||||
|
||||
static int
|
||||
add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
|
||||
add_ctype_to_cc(CClassNode* cc, int ctype, int not, ParseEnv* env)
|
||||
{
|
||||
int c, r;
|
||||
int ascii_mode;
|
||||
@ -6471,7 +6472,7 @@ add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
prs_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ScanEnv* env)
|
||||
prs_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ParseEnv* env)
|
||||
{
|
||||
#define POSIX_BRACKET_CHECK_LIMIT_LENGTH 20
|
||||
#define POSIX_BRACKET_NAME_MIN_LEN 4
|
||||
@ -6545,7 +6546,7 @@ prs_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
fetch_char_property_to_ctype(UChar** src, UChar* end, ScanEnv* env)
|
||||
fetch_char_property_to_ctype(UChar** src, UChar* end, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
OnigCodePoint c;
|
||||
@ -6580,7 +6581,8 @@ fetch_char_property_to_ctype(UChar** src, UChar* end, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int
|
||||
prs_char_property(Node** np, PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
prs_char_property(Node** np, PToken* tok, UChar** src, UChar* end,
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r, ctype;
|
||||
CClassNode* cc;
|
||||
@ -6601,7 +6603,7 @@ prs_char_property(Node** np, PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
|
||||
static int
|
||||
cc_cprop_next(CClassNode* cc, OnigCodePoint* pcode, CVAL* val, CSTATE* state,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -6625,7 +6627,7 @@ cc_cprop_next(CClassNode* cc, OnigCodePoint* pcode, CVAL* val, CSTATE* state,
|
||||
static int
|
||||
cc_char_next(CClassNode* cc, OnigCodePoint *from, OnigCodePoint to,
|
||||
int* from_raw, int to_raw, CVAL intype, CVAL* type,
|
||||
CSTATE* state, ScanEnv* env)
|
||||
CSTATE* state, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -6694,7 +6696,7 @@ cc_char_next(CClassNode* cc, OnigCodePoint *from, OnigCodePoint to,
|
||||
|
||||
static int
|
||||
code_exist_check(OnigCodePoint c, UChar* from, UChar* end, int ignore_escaped,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int in_esc;
|
||||
OnigCodePoint code;
|
||||
@ -6716,7 +6718,7 @@ code_exist_check(OnigCodePoint c, UChar* from, UChar* end, int ignore_escaped,
|
||||
}
|
||||
|
||||
static int
|
||||
prs_cc(Node** np, PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
prs_cc(Node** np, PToken* tok, UChar** src, UChar* end, ParseEnv* env)
|
||||
{
|
||||
int r, neg, len, fetched, and_start;
|
||||
OnigCodePoint in_code, curr_code;
|
||||
@ -7068,13 +7070,14 @@ prs_cc(Node** np, PToken* tok, UChar** src, UChar* end, ScanEnv* env)
|
||||
}
|
||||
|
||||
static int prs_alts(Node** top, PToken* tok, int term,
|
||||
UChar** src, UChar* end, ScanEnv* env, int group_head);
|
||||
UChar** src, UChar* end, ParseEnv* env, int group_head);
|
||||
|
||||
#ifdef USE_CALLOUT
|
||||
|
||||
/* (?{...}[tag][+-]) (?{{...}}[tag][+-]) */
|
||||
static int
|
||||
prs_callout_of_contents(Node** np, int cterm, UChar** src, UChar* end, ScanEnv* env)
|
||||
prs_callout_of_contents(Node** np, int cterm, UChar** src, UChar* end,
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
@ -7257,7 +7260,7 @@ clear_callout_args(int n, unsigned int types[], OnigValue vals[])
|
||||
static int
|
||||
prs_callout_args(int skip_mode, int cterm, UChar** src, UChar* end,
|
||||
int max_arg_num, unsigned int types[], OnigValue vals[],
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
#define MAX_CALLOUT_ARG_BYTE_LENGTH 128
|
||||
|
||||
@ -7420,7 +7423,8 @@ prs_callout_args(int skip_mode, int cterm, UChar** src, UChar* end,
|
||||
|
||||
/* (*name[TAG]) (*name[TAG]{a,b,..}) */
|
||||
static int
|
||||
prs_callout_of_name(Node** np, int cterm, UChar** src, UChar* end, ScanEnv* env)
|
||||
prs_callout_of_name(Node** np, int cterm, UChar** src, UChar* end,
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
int i;
|
||||
@ -7587,7 +7591,7 @@ prs_callout_of_name(Node** np, int cterm, UChar** src, UChar* end, ScanEnv* env)
|
||||
|
||||
static int
|
||||
prs_bag(Node** np, PToken* tok, int term, UChar** src, UChar* end,
|
||||
ScanEnv* env)
|
||||
ParseEnv* env)
|
||||
{
|
||||
int r, num;
|
||||
Node *target;
|
||||
@ -7820,7 +7824,7 @@ prs_bag(Node** np, PToken* tok, int term, UChar** src, UChar* end,
|
||||
|
||||
if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_STRICT_CHECK_BACKREF)) {
|
||||
if (back_num > env->num_mem ||
|
||||
IS_NULL(SCANENV_MEMENV(env)[back_num].mem_node))
|
||||
IS_NULL(PARSEENV_MEMENV(env)[back_num].mem_node))
|
||||
return ONIGERR_INVALID_BACKREF;
|
||||
}
|
||||
|
||||
@ -7842,7 +7846,7 @@ prs_bag(Node** np, PToken* tok, int term, UChar** src, UChar* end,
|
||||
int i;
|
||||
for (i = 0; i < num; i++) {
|
||||
if (backs[i] > env->num_mem ||
|
||||
IS_NULL(SCANENV_MEMENV(env)[backs[i]].mem_node))
|
||||
IS_NULL(PARSEENV_MEMENV(env)[backs[i]].mem_node))
|
||||
return ONIGERR_INVALID_BACKREF;
|
||||
}
|
||||
}
|
||||
@ -8222,7 +8226,7 @@ static const char* ReduceQStr[] = {
|
||||
};
|
||||
|
||||
static int
|
||||
assign_quantifier_body(Node* qnode, Node* target, int group, ScanEnv* env)
|
||||
assign_quantifier_body(Node* qnode, Node* target, int group, ParseEnv* env)
|
||||
{
|
||||
QuantNode* qn;
|
||||
|
||||
@ -8370,7 +8374,7 @@ onig_new_cclass_with_code_list(Node** rnode, OnigEncoding enc,
|
||||
}
|
||||
|
||||
typedef struct {
|
||||
ScanEnv* env;
|
||||
ParseEnv* env;
|
||||
CClassNode* cc;
|
||||
Node* alt_root;
|
||||
Node** ptail;
|
||||
@ -8381,7 +8385,7 @@ i_apply_case_fold(OnigCodePoint from, OnigCodePoint to[], int to_len,
|
||||
void* arg)
|
||||
{
|
||||
IApplyCaseFoldArg* iarg;
|
||||
ScanEnv* env;
|
||||
ParseEnv* env;
|
||||
OnigEncoding enc;
|
||||
CClassNode* cc;
|
||||
|
||||
@ -8490,7 +8494,7 @@ i_apply_case_fold(OnigCodePoint from, OnigCodePoint to[], int to_len,
|
||||
|
||||
static int
|
||||
prs_exp(Node** np, PToken* tok, int term, UChar** src, UChar* end,
|
||||
ScanEnv* env, int group_head)
|
||||
ParseEnv* env, int group_head)
|
||||
{
|
||||
int r, len, group;
|
||||
Node* qn;
|
||||
@ -8896,7 +8900,7 @@ prs_exp(Node** np, PToken* tok, int term, UChar** src, UChar* end,
|
||||
|
||||
static int
|
||||
prs_branch(Node** top, PToken* tok, int term, UChar** src, UChar* end,
|
||||
ScanEnv* env, int group_head)
|
||||
ParseEnv* env, int group_head)
|
||||
{
|
||||
int r;
|
||||
Node *node, **headp;
|
||||
@ -8947,7 +8951,7 @@ prs_branch(Node** top, PToken* tok, int term, UChar** src, UChar* end,
|
||||
/* term_tok: TK_EOT or TK_SUBEXP_CLOSE */
|
||||
static int
|
||||
prs_alts(Node** top, PToken* tok, int term, UChar** src, UChar* end,
|
||||
ScanEnv* env, int group_head)
|
||||
ParseEnv* env, int group_head)
|
||||
{
|
||||
int r;
|
||||
Node *node, **headp;
|
||||
@ -9010,7 +9014,7 @@ prs_alts(Node** top, PToken* tok, int term, UChar** src, UChar* end,
|
||||
}
|
||||
|
||||
static int
|
||||
prs_regexp(Node** top, UChar** src, UChar* end, ScanEnv* env)
|
||||
prs_regexp(Node** top, UChar** src, UChar* end, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
PToken tok;
|
||||
@ -9026,7 +9030,7 @@ prs_regexp(Node** top, UChar** src, UChar* end, ScanEnv* env)
|
||||
|
||||
#ifdef USE_CALL
|
||||
static int
|
||||
make_call_zero_body(Node* node, ScanEnv* env, Node** rnode)
|
||||
make_call_zero_body(Node* node, ParseEnv* env, Node** rnode)
|
||||
{
|
||||
int r;
|
||||
|
||||
@ -9048,7 +9052,7 @@ make_call_zero_body(Node* node, ScanEnv* env, Node** rnode)
|
||||
|
||||
extern int
|
||||
onig_parse_tree(Node** root, const UChar* pattern, const UChar* end,
|
||||
regex_t* reg, ScanEnv* env)
|
||||
regex_t* reg, ParseEnv* env)
|
||||
{
|
||||
int r;
|
||||
UChar* p;
|
||||
@ -9107,7 +9111,7 @@ onig_parse_tree(Node** root, const UChar* pattern, const UChar* end,
|
||||
}
|
||||
|
||||
extern void
|
||||
onig_scan_env_set_error_string(ScanEnv* env, int ecode ARG_UNUSED,
|
||||
onig_scan_env_set_error_string(ParseEnv* env, int ecode ARG_UNUSED,
|
||||
UChar* arg, UChar* arg_end)
|
||||
{
|
||||
env->error = arg;
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
regparse.h - Oniguruma (regular expression library)
|
||||
**********************************************************************/
|
||||
/*-
|
||||
* Copyright (c) 2002-2020 K.Kosako
|
||||
* Copyright (c) 2002-2021 K.Kosako
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
@ -387,8 +387,8 @@ typedef struct {
|
||||
#define NODE_CALL_BODY(node) ((node)->body)
|
||||
#define NODE_ANCHOR_BODY(node) ((node)->body)
|
||||
|
||||
#define SCANENV_MEMENV_SIZE 8
|
||||
#define SCANENV_MEMENV(senv) \
|
||||
#define PARSEENV_MEMENV_SIZE 8
|
||||
#define PARSEENV_MEMENV(senv) \
|
||||
(IS_NOT_NULL((senv)->mem_env_dynamic) ? \
|
||||
(senv)->mem_env_dynamic : (senv)->mem_env_static)
|
||||
|
||||
@ -427,7 +427,7 @@ typedef struct {
|
||||
int num_mem;
|
||||
int num_named;
|
||||
int mem_alloc;
|
||||
MemEnv mem_env_static[SCANENV_MEMENV_SIZE];
|
||||
MemEnv mem_env_static[PARSEENV_MEMENV_SIZE];
|
||||
MemEnv* mem_env_dynamic;
|
||||
int backref_num;
|
||||
int keep_num;
|
||||
@ -442,14 +442,14 @@ typedef struct {
|
||||
#ifdef ONIG_DEBUG_PARSE
|
||||
unsigned int max_parse_depth;
|
||||
#endif
|
||||
} ScanEnv;
|
||||
} ParseEnv;
|
||||
|
||||
|
||||
extern int onig_renumber_name_table P_((regex_t* reg, GroupNumMap* map));
|
||||
|
||||
extern int onig_strncmp P_((const UChar* s1, const UChar* s2, int n));
|
||||
extern void onig_strcpy P_((UChar* dest, const UChar* src, const UChar* end));
|
||||
extern void onig_scan_env_set_error_string P_((ScanEnv* env, int ecode, UChar* arg, UChar* arg_end));
|
||||
extern void onig_scan_env_set_error_string P_((ParseEnv* env, int ecode, UChar* arg, UChar* arg_end));
|
||||
extern int onig_reduce_nested_quantifier P_((Node* pnode));
|
||||
extern int onig_node_copy(Node** rcopy, Node* from);
|
||||
extern int onig_node_str_cat P_((Node* node, const UChar* s, const UChar* end));
|
||||
@ -463,7 +463,7 @@ extern Node* onig_node_new_str P_((const UChar* s, const UChar* end));
|
||||
extern Node* onig_node_new_list P_((Node* left, Node* right));
|
||||
extern Node* onig_node_new_alt P_((Node* left, Node* right));
|
||||
extern int onig_names_free P_((regex_t* reg));
|
||||
extern int onig_parse_tree P_((Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ScanEnv* env));
|
||||
extern int onig_parse_tree P_((Node** root, const UChar* pattern, const UChar* end, regex_t* reg, ParseEnv* env));
|
||||
extern int onig_free_shared_cclass_table P_((void));
|
||||
extern int onig_is_code_in_cc P_((OnigEncoding enc, OnigCodePoint code, CClassNode* cc));
|
||||
extern int onig_new_cclass_with_code_list(Node** rnode, OnigEncoding enc, int n, OnigCodePoint codes[]);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user