Lines Matching defs:env
126 #define BACKREF_REL_TO_ABS(rel_no, env) \
127 ((env)->num_mem + 1 + (rel_no))
722 name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
799 ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME)) {
800 onig_scan_env_set_error_string(env, ONIGERR_MULTIPLEX_DEFINED_NAME,
928 scan_env_clear(ScanEnv* env)
932 BIT_STATUS_CLEAR(env->capture_history);
933 BIT_STATUS_CLEAR(env->bt_mem_start);
934 BIT_STATUS_CLEAR(env->bt_mem_end);
935 BIT_STATUS_CLEAR(env->backrefed_mem);
936 env->error = (UChar* )NULL;
937 env->error_end = (UChar* )NULL;
938 env->num_call = 0;
939 env->num_mem = 0;
941 env->num_named = 0;
943 env->mem_alloc = 0;
944 env->mem_nodes_dynamic = (Node** )NULL;
947 env->mem_nodes_static[i] = NULL_NODE;
950 env->num_comb_exp_check = 0;
951 env->comb_exp_max_regnum = 0;
952 env->curr_max_regnum = 0;
953 env->has_recursion = 0;
958 scan_env_add_mem_entry(ScanEnv* env)
963 need = env->num_mem + 1;
965 if (env->mem_alloc <= need) {
966 if (IS_NULL(env->mem_nodes_dynamic)) {
971 xmemcpy(p, env->mem_nodes_static,
975 alloc = env->mem_alloc * 2;
976 p = (Node** )xrealloc(env->mem_nodes_dynamic, sizeof(Node*) * alloc, sizeof(Node*) * env->mem_alloc);
980 for (i = env->num_mem + 1; i < alloc; i++)
983 env->mem_nodes_dynamic = p;
984 env->mem_alloc = alloc;
988 env->num_mem++;
989 return env->num_mem;
993 scan_env_set_mem_node(ScanEnv* env, int num, Node* node)
995 if (env->num_mem >= num)
996 SCANENV_MEM_NODES(env)[num] = node;
1290 ScanEnv* env)
1312 if (backrefs[i] <= env->num_mem &&
1313 IS_NULL(SCANENV_MEM_NODES(env)[backrefs[i]])) {
1780 add_code_range(BBuf** pbuf, ScanEnv* env, OnigCodePoint from, OnigCodePoint to)
1783 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
2106 conv_backslash_value(int c, ScanEnv* env)
2108 if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_CONTROL_CHARS)) {
2118 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_V_VTAB))
2326 fetch_range_quantifier(UChar** src, UChar* end, OnigToken* tok, ScanEnv* env)
2331 OnigEncoding enc = env->enc;
2335 syn_allow = IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_INVALID_INTERVAL);
2351 low = onig_scan_unsigned_number(&p, end, env->enc);
2357 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV)) {
2370 up = onig_scan_unsigned_number(&p, end, env->enc);
2392 if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) {
2393 if (c != MC_ESC(env->syntax)) goto invalid;
2417 fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env)
2421 OnigEncoding enc = env->enc;
2429 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META)) {
2435 if (c == MC_ESC(env->syntax)) {
2436 v = fetch_escaped_value(&p, end, env);
2447 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL)) {
2457 if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_C_CONTROL)) {
2465 if (c == MC_ESC(env->syntax)) {
2466 v = fetch_escaped_value(&p, end, env);
2479 c = conv_backslash_value(c, env);
2488 static int fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env);
2512 UChar** rname_end, ScanEnv* env,
2518 OnigEncoding enc = env->enc;
2614 onig_scan_env_set_error_string(env, r, *src, name_end);
2626 UChar** rname_end, ScanEnv* env, int* rback_num, int ref)
2631 OnigEncoding enc = env->enc;
2736 onig_scan_env_set_error_string(env, r, *src, name_end);
2743 UChar** rname_end, ScanEnv* env, int* rback_num, int ref)
2749 OnigEncoding enc = env->enc;
2813 onig_scan_env_set_error_string(env, r, *src, name_end);
2820 CC_ESC_WARN(ScanEnv* env, UChar *c)
2824 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED) &&
2825 IS_SYNTAX_BV(env->syntax, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC)) {
2827 onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
2828 env->pattern, env->pattern_end,
2835 CLOSE_BRACKET_WITHOUT_ESC_WARN(ScanEnv* env, UChar* c)
2839 if (IS_SYNTAX_BV((env)->syntax, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED)) {
2841 onig_snprintf_with_pattern(buf, WARN_BUFSIZE, (env)->enc,
2842 (env)->pattern, (env)->pattern_end,
2916 fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
2920 OnigSyntaxType* syn = env->syntax;
2921 OnigEncoding enc = env->enc;
3087 num = fetch_escaped_value(&p, end, env);
3116 CC_ESC_WARN(env, (UChar* )"[");
3134 fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
3138 OnigEncoding enc = env->enc;
3139 OnigSyntaxType* syn = env->syntax;
3212 r = fetch_range_quantifier(&p, end, tok, env);
3418 (num <= env->num_mem || num <= 9)) { /* This spec. from GNU regex */
3420 if (num > env->num_mem || IS_NULL(SCANENV_MEM_NODES(env)[num]))
3474 env, &back_num, &tok->u.backref.level);
3478 r = fetch_name(&p, end, &name_end, env, &back_num, 1);
3484 back_num = BACKREF_REL_TO_ABS(back_num, env);
3490 if (back_num > env->num_mem ||
3491 IS_NULL(SCANENV_MEM_NODES(env)[back_num]))
3500 num = onig_name_to_group_numbers(env->reg, prev, name_end, &backs);
3502 onig_scan_env_set_error_string(env,
3509 if (backs[i] > env->num_mem ||
3510 IS_NULL(SCANENV_MEM_NODES(env)[backs[i]]))
3542 r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &gnum, 1);
3583 num = fetch_escaped_value(&p, end, env);
3662 r = fetch_range_quantifier(&p, end, tok, env);
3712 tok->u.subtype = (IS_SINGLELINE(env->option)
3719 tok->u.subtype = (IS_SINGLELINE(env->option)
3729 if (*src > env->pattern) /* /].../ is allowed. */
3730 CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]");
3734 if (IS_EXTEND(env->option)) {
3746 if (IS_EXTEND(env->option))
3838 add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
3843 OnigEncoding enc = env->enc;
3847 return add_ctype_to_cc_by_range(cc, ctype, not, env->enc, sb_out, ranges);
3923 parse_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ScanEnv* env)
3949 OnigEncoding enc = env->enc;
3968 r = add_ctype_to_cc(cc, pb->ctype, not, env);
3997 fetch_char_property_to_ctype(UChar** src, UChar* end, ScanEnv* env)
4001 OnigEncoding enc = env->enc;
4023 onig_scan_env_set_error_string(env, r, *src, prev);
4029 ScanEnv* env)
4034 ctype = fetch_char_property_to_ctype(src, end, env);
4040 r = add_ctype_to_cc(cc, ctype, 0, env);
4063 enum CCSTATE* state, ScanEnv* env)
4074 r = add_code_range(&(cc->mbuf), env, *vs, *vs);
4088 enum CCSTATE* state, ScanEnv* env)
4097 r = add_code_range(&(cc->mbuf), env, *vs, *vs);
4109 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
4117 r = add_code_range(&(cc->mbuf), env, *vs, v);
4126 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
4132 r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*vs, v);
4161 ScanEnv* env)
4165 OnigEncoding enc = env->enc;
4176 if (code == MC_ESC(env->syntax)) in_esc = 1;
4184 ScanEnv* env)
4199 r = fetch_token_in_cc(tok, src, end, env);
4202 r = fetch_token_in_cc(tok, src, end, env);
4211 *src, env->pattern_end, 1, env))
4214 CC_ESC_WARN(env, (UChar* )"]");
4229 len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c);
4248 if (! ONIGENC_IS_SINGLEBYTE(env->enc) && tok->base != 0) {
4255 for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) {
4256 r = fetch_token_in_cc(tok, &p, end, env);
4265 if (i < ONIGENC_MBC_MINLEN(env->enc)) {
4270 len = enclen(env->enc, buf);
4278 r = fetch_token_in_cc(tok, &p, end, env);
4288 v = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe);
4305 len = ONIGENC_CODE_TO_MBCLEN(env->enc, v);
4313 &state, env);
4318 r = parse_posix_bracket(cc, &p, end, env);
4321 CC_ESC_WARN(env, (UChar* )"[");
4331 r = add_ctype_to_cc(cc, tok->u.prop.ctype, tok->u.prop.not, env);
4335 r = next_state_class(cc, &vs, &val_type, &state, env);
4343 ctype = fetch_char_property_to_ctype(&p, end, env);
4345 r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, env);
4353 r = fetch_token_in_cc(tok, &p, end, env);
4363 CC_ESC_WARN(env, (UChar* )"-");
4373 r = fetch_token_in_cc(tok, &p, end, env);
4378 CC_ESC_WARN(env, (UChar* )"-");
4383 CC_ESC_WARN(env, (UChar* )"-");
4387 r = fetch_token_in_cc(tok, &p, end, env);
4392 CC_ESC_WARN(env, (UChar* )"-");
4396 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) {
4397 CC_ESC_WARN(env, (UChar* )"-");
4410 r = parse_char_class(&anode, tok, &p, end, env);
4413 r = or_cclass(cc, acc, env->enc);
4425 &val_type, &state, env);
4433 r = and_cclass(prev_cc, cc, env->enc);
4458 r = fetch_token_in_cc(tok, &p, end, env);
4465 &val_type, &state, env);
4470 r = and_cclass(prev_cc, cc, env->enc);
4481 IS_SYNTAX_BV(env->syntax, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC)) {
4491 if (ONIGENC_IS_CODE_NEWLINE(env->enc, NEWLINE_CODE)) {
4492 if (ONIGENC_CODE_TO_MBCLEN(env->enc, NEWLINE_CODE) == 1)
4495 add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE);
4510 UChar** src, UChar* end, ScanEnv* env);
4514 ScanEnv* env)
4520 OnigEncoding enc = env->enc;
4532 option = env->option;
4534 IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) {
4542 r = fetch_token(tok, &p, end, env);
4544 r = parse_subexp(np, tok, term, &p, end, env);
4562 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
4578 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
4590 r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 0);
4593 num = scan_env_add_mem_entry(env);
4598 r = name_add(env->reg, name, name_end, num, env);
4600 *np = node_new_enclose_memory(env->option, 1);
4604 BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
4605 env->num_named++;
4619 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY)) {
4621 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
4630 *np = node_new_enclose_memory(env->option, 0);
4632 num = scan_env_add_mem_entry(env);
4642 BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
4666 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
4674 if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
4677 else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) {
4699 OnigOptionType prev = env->option;
4701 env->option = option;
4702 r = fetch_token(tok, &p, end, env);
4704 r = parse_subexp(&target, tok, term, &p, end, env);
4705 env->option = prev;
4725 if (ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_DONT_CAPTURE_GROUP))
4728 *np = node_new_enclose_memory(env->option, 0);
4730 num = scan_env_add_mem_entry(env);
4736 r = fetch_token(tok, &p, end, env);
4738 r = parse_subexp(&target, tok, term, &p, end, env);
4747 r = scan_env_set_mem_node(env, NENCLOSE(*np)->regnum, *np);
4765 set_quantifier(Node* qnode, Node* target, int group, ScanEnv* env)
4778 if (str_node_can_be_split(sn, env->enc)) {
4779 Node* n = str_node_split_last_char(sn, env->enc);
4800 IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) {
4809 onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
4810 env->pattern, env->pattern_end,
4819 onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
4820 env->pattern, env->pattern_end,
4961 ScanEnv* env;
4972 ScanEnv* env;
4977 env = iarg->env;
4982 int is_in = onig_is_code_in_cc(env->enc, from, cc);
4986 if (ONIGENC_MBC_MINLEN(env->enc) > 1 || *to >= SINGLE_BYTE_SIZE) {
4987 add_code_range(&(cc->mbuf), env, *to, *to);
4995 if (ONIGENC_MBC_MINLEN(env->enc) > 1 || *to >= SINGLE_BYTE_SIZE) {
4996 if (IS_NCCLASS_NOT(cc)) clear_not_flag_cclass(cc, env->enc);
4997 add_code_range(&(cc->mbuf), env, *to, *to);
5014 if (onig_is_code_in_cc(env->enc, from, cc)
5020 len = ONIGENC_CODE_TO_MBC(env->enc, to[i], buf);
5049 UChar** src, UChar* end, ScanEnv* env)
5068 r = parse_enclose(np, tok, TK_SUBEXP_CLOSE, src, end, env);
5073 OnigOptionType prev = env->option;
5075 env->option = NENCLOSE(*np)->option;
5076 r = fetch_token(tok, src, end, env);
5078 r = parse_subexp(&target, tok, term, src, end, env);
5079 env->option = prev;
5087 if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP))
5101 r = fetch_token(tok, src, end, env);
5122 if (len >= ONIGENC_MBC_MINLEN(env->enc)) {
5123 if (len == enclen(env->enc, NSTR(*np)->s)) {
5124 r = fetch_token(tok, src, end, env);
5130 r = fetch_token(tok, src, end, env);
5136 if (len < ONIGENC_MBC_MINLEN(env->enc)) {
5137 rem = ONIGENC_MBC_MINLEN(env->enc) - len;
5139 if (len + rem == enclen(env->enc, NSTR(*np)->s)) {
5159 int num = ONIGENC_CODE_TO_MBC(env->enc, tok->u.code, buf);
5175 end_op[0] = (OnigCodePoint )MC_ESC(env->syntax);
5178 qend = find_str_position(end_op, 2, qstart, end, &nextp, env->enc);
5206 r = ONIGENC_GET_CTYPE_CODE_RANGE(env->enc, tok->u.prop.ctype,
5214 key.enc = env->enc;
5258 add_ctype_to_cc(cc, tok->u.prop.ctype, 0, env);
5274 r = parse_char_property(np, tok, src, end, env);
5282 r = parse_char_class(np, tok, src, end, env);
5286 if (IS_IGNORECASE(env->option)) {
5289 iarg.env = env;
5294 r = ONIGENC_APPLY_ALL_CASE_FOLD(env->enc, env->case_fold_flag,
5335 env);
5345 gnum = BACKREF_REL_TO_ABS(gnum, env);
5351 env->num_call++;
5363 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) {
5364 if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS))
5384 r = fetch_token(tok, src, end, env);
5396 r = set_quantifier(qn, *targetp, group, env);
5443 UChar** src, UChar* end, ScanEnv* env)
5449 r = parse_exp(&node, tok, term, src, end, env);
5460 r = parse_exp(&node, tok, term, src, end, env);
5482 UChar** src, UChar* end, ScanEnv* env)
5488 r = parse_branch(&node, tok, term, src, end, env);
5502 r = fetch_token(tok, src, end, env);
5504 r = parse_branch(&node, tok, term, src, end, env);
5526 parse_regexp(Node** top, UChar** src, UChar* end, ScanEnv* env)
5531 r = fetch_token(&tok, src, end, env);
5533 r = parse_subexp(top, &tok, TK_EOT, src, end, env);
5540 regex_t* reg, ScanEnv* env)
5549 scan_env_clear(env);
5550 env->option = reg->options;
5551 env->case_fold_flag = reg->case_fold_flag;
5552 env->enc = reg->enc;
5553 env->syntax = reg->syntax;
5554 env->pattern = (UChar* )pattern;
5555 env->pattern_end = (UChar* )end;
5556 env->reg = reg;
5560 r = parse_regexp(root, &p, (UChar* )end, env);
5561 reg->num_mem = env->num_mem;
5566 onig_scan_env_set_error_string(ScanEnv* env, int ecode ARG_UNUSED,
5569 env->error = arg;
5570 env->error_end = arg_end;