1905 disable_noname_group_capture(Node** root, regex_t* reg, ScanEnv* env)

1912   map = (GroupNumRemap* )xmalloc(sizeof(GroupNumRemap) * (env->num_mem + 1));

1914   for (i = 1; i <= env->num_mem; i++) {

1924   for (i = 1, pos = 1; i <= env->num_mem; i++) {

1926       SCANENV_MEM_NODES(env)[pos] = SCANENV_MEM_NODES(env)[i];

1931   loc = env->capture_history;

1932   BIT_STATUS_CLEAR(env->capture_history);

1935       BIT_STATUS_ON_AT_SIMPLE(env->capture_history, map[i].new_val);

1939   env->num_mem = env->num_named;

1940   reg->num_mem = env->num_named;

2038 get_min_match_length(Node* node, OnigDistance *min, ScanEnv* env)

2049       Node** nodes = SCANENV_MEM_NODES(env);

2054       if (backs[0] > env->num_mem)  return ONIGERR_INVALID_BACKREF;

2055       r = get_min_match_length(nodes[backs[0]], min, env);

2058 	if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;

2059 	r = get_min_match_length(nodes[backs[i]], &tmin, env);

2074       r = get_min_match_length(NCALL(node)->target, min, env);

2080       r = get_min_match_length(NCAR(node), &tmin, env);

2091 	r = get_min_match_length(x, &tmin, env);

2120 	r = get_min_match_length(qn->target, min, env);

2136 	  r = get_min_match_length(en->target, min, env);

2146 	r = get_min_match_length(en->target, min, env);

2161 get_max_match_length(Node* node, OnigDistance *max, ScanEnv* env)

2170       r = get_max_match_length(NCAR(node), &tmax, env);

2178       r = get_max_match_length(NCAR(node), &tmax, env);

2191     *max = ONIGENC_MBC_MAXLEN_DIST(env->enc);

2196     *max = ONIGENC_MBC_MAXLEN_DIST(env->enc);

2203       Node** nodes = SCANENV_MEM_NODES(env);

2211 	if (backs[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;

2212 	r = get_max_match_length(nodes[backs[i]], &tmax, env);

2222       r = get_max_match_length(NCALL(node)->target, max, env);

2233 	r = get_max_match_length(qn->target, max, env);

2253 	  r = get_max_match_length(en->target, max, env);

2263 	r = get_max_match_length(en->target, max, env);

2728 subexp_inf_recursive_check(Node* node, ScanEnv* env, int head)

2743 	ret = subexp_inf_recursive_check(NCAR(x), env, head);

2747 	  ret = get_min_match_length(NCAR(x), &min, env);

2760 	ret = subexp_inf_recursive_check(NCAR(node), env, head);

2768     r = subexp_inf_recursive_check(NQTFR(node)->target, env, head);

2782 	r = subexp_inf_recursive_check(an->target, env, head);

2789     r = subexp_inf_recursive_check(NCALL(node)->target, env, head);

2799       r = subexp_inf_recursive_check(NENCLOSE(node)->target, env, head);

2812 subexp_inf_recursive_check_trav(Node* node, ScanEnv* env)

2822       r = subexp_inf_recursive_check_trav(NCAR(node), env);

2827     r = subexp_inf_recursive_check_trav(NQTFR(node)->target, env);

2838 	r = subexp_inf_recursive_check_trav(an->target, env);

2850 	r = subexp_inf_recursive_check(en->target, env, 1);

2854       r = subexp_inf_recursive_check_trav(en->target, env);

2923 subexp_recursive_check_trav(Node* node, ScanEnv* env)

2937 	ret = subexp_recursive_check_trav(NCAR(node), env);

2945     r = subexp_recursive_check_trav(NQTFR(node)->target, env);

2960 	r = subexp_recursive_check_trav(an->target, env);

2978       r = subexp_recursive_check_trav(en->target, env);

2992 setup_subexp_call(Node* node, ScanEnv* env)

3001       r = setup_subexp_call(NCAR(node), env);

3007       r = setup_subexp_call(NCAR(node), env);

3012     r = setup_subexp_call(NQTFR(node)->target, env);

3015     r = setup_subexp_call(NENCLOSE(node)->target, env);

3021       Node** nodes = SCANENV_MEM_NODES(env);

3027 	if (env->num_named > 0 &&

3028 	    IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&

3029 	    !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {

3033 	if (gnum > env->num_mem) {

3034 	  onig_scan_env_set_error_string(env,

3044 	  onig_scan_env_set_error_string(env,

3049 	BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);

3050 	cn->unset_addr_list = env->unset_addr_list;

3056 	int n = onig_name_to_group_numbers(env->reg, cn->name, cn->name_end,

3059 	  onig_scan_env_set_error_string(env,

3064 	  onig_scan_env_set_error_string(env,

3086 	r = setup_subexp_call(an->target, env);

3135 setup_look_behind(Node* node, regex_t* reg, ScanEnv* env)

3146     if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND))

3532 setup_comb_exp_check(Node* node, int state, ScanEnv* env)

3543 	r = setup_comb_exp_check(NCAR(node), r, env);

3553 	ret = setup_comb_exp_check(NCAR(node), state, env);

3573 	  if (env->backrefed_mem == 0) {

3611 	    env->num_comb_exp_check++;

3612 	    qn->comb_exp_check_num = env->num_comb_exp_check;

3613 	    if (env->curr_max_regnum > env->comb_exp_max_regnum)

3614 	      env->comb_exp_max_regnum = env->curr_max_regnum;

3619       r = setup_comb_exp_check(target, child_state, env);

3631 	  if (env->curr_max_regnum < en->regnum)

3632 	    env->curr_max_regnum = en->regnum;

3634 	  r = setup_comb_exp_check(en->target, state, env);

3639 	r = setup_comb_exp_check(en->target, state, env);

3648       env->has_recursion = 1;

3650       r = setup_comb_exp_check(NCALL(node)->target, state, env);

3676 setup_tree(Node* node, regex_t* reg, int state, ScanEnv* env)

3687 	r = setup_tree(NCAR(node), reg, state, env);

3698       r = setup_tree(NCAR(node), reg, (state | IN_ALT), env);

3724       Node** nodes = SCANENV_MEM_NODES(env);

3728 	if (p[i] > env->num_mem)  return ONIGERR_INVALID_BACKREF;

3729 	BIT_STATUS_ON_AT(env->backrefed_mem, p[i]);

3730 	BIT_STATUS_ON_AT(env->bt_mem_start, p[i]);

3733 	  BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);

3752 	r = get_min_match_length(target, &d, env);

3764 	  r = get_max_match_length(target, &d, env);

3780       r = setup_tree(target, reg, state, env);

3830 	  r = setup_tree(NENCLOSE(node)->target, reg, state, env);

3837 	  BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);

3840         r = setup_tree(en->target, reg, state, env);

3846 	  r = setup_tree(target, reg, state, env);

3868 	r = setup_tree(an->target, reg, state, env);

3871 	r = setup_tree(an->target, reg, (state | IN_NOT), env);

3893 	  r = setup_look_behind(node, reg, env);

3895 	  r = setup_tree(an->target, reg, state, env);

3905 	  r = setup_look_behind(node, reg, env);

3907 	  r = setup_tree(an->target, reg, (state | IN_NOT), env);

4269 alt_merge_opt_exact_info(OptExactInfo* to, OptExactInfo* add, OptEnv* env)

4285     len = enclen(env->enc, to->s + i);

4544 alt_merge_node_opt_info(NodeOptInfo* to, NodeOptInfo* add, OptEnv* env)

4547   alt_merge_opt_exact_info(&to->exb,  &add->exb, env);

4548   alt_merge_opt_exact_info(&to->exm,  &add->exm, env);

4549   alt_merge_opt_exact_info(&to->expr, &add->expr, env);

4550   alt_merge_opt_map_info(env->enc, &to->map,  &add->map);

4559 optimize_node_left(Node* node, NodeOptInfo* opt, OptEnv* env)

4565   set_bound_node_opt_info(opt, &env->mmd);

4575       copy_opt_env(&nenv, env);

4580 	  concat_left_node_opt_info(env->enc, opt, &nopt);

4592 	r = optimize_node_left(NCAR(nd), &nopt, env);

4595 	  else            alt_merge_node_opt_info(opt, &nopt, env);

4609 				  NSTRING_IS_RAW(node), env->enc);

4611 	  add_char_opt_map_info(&opt->map, *(sn->s), env->enc);

4619           int n = onigenc_strlen(env->enc, sn->s, sn->end);

4620           max = ONIGENC_MBC_MAXLEN_DIST(env->enc) * n;

4624 				    is_raw, env->enc);

4629 					  env->enc, env->case_fold_flag);

4652         OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);

4653 	OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);

4661             add_char_opt_map_info(&opt->map, (UChar )i, env->enc);

4673       max = ONIGENC_MBC_MAXLEN_DIST(env->enc);

4682 	      if (! ONIGENC_IS_CODE_WORD(env->enc, i)) {

4683 		add_char_opt_map_info(&opt->map, (UChar )i, env->enc);

4689 	      if (ONIGENC_IS_CODE_WORD(env->enc, i)) {

4690 		add_char_opt_map_info(&opt->map, (UChar )i, env->enc);

4698         min = ONIGENC_MBC_MINLEN(env->enc);

4706       OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);

4707       OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);

4727 	r = optimize_node_left(NANCHOR(node)->target, &nopt, env);

4754       Node** nodes = SCANENV_MEM_NODES(env->scan_env);

4762       r = get_min_match_length(nodes[backs[0]], &min, env->scan_env);

4764       r = get_max_match_length(nodes[backs[0]], &max, env->scan_env);

4767 	r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env);

4769 	r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env);

4783       OnigOptionType save = env->options;

4784       env->options = NENCLOSE(NCALL(node)->target)->option;

4785       r = optimize_node_left(NCALL(node)->target, opt, env);

4786       env->options = save;

4798       r = optimize_node_left(qn->target, &nopt, env);

4802 	if (env->mmd.max == 0 &&

4804 	  if (IS_MULTILINE(env->options))

4817 		concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);

4851 	  OnigOptionType save = env->options;

4853 	  env->options = en->option;

4854 	  r = optimize_node_left(en->target, opt, env);

4855 	  env->options = save;

4874 	  r = optimize_node_left(en->target, opt, env);

4877 	    if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum))

4884 	r = optimize_node_left(en->target, opt, env);

4983   OptEnv env;

4985   env.enc            = reg->enc;

4986   env.options        = reg->options;

4987   env.case_fold_flag = reg->case_fold_flag;

4988   env.scan_env   = scan_env;

4989   clear_mml(&env.mmd);

4991   r = optimize_node_left(node, &opt, &env);

Indexes created Sun Sep 10 09:05:34 CEST 2017