env 384 .ext/include/x86_64-linux/ruby/config.h #define RUBY_SETJMP(env) __builtin_setjmp((env))
env 385 .ext/include/x86_64-linux/ruby/config.h #define RUBY_LONGJMP(env,val) __builtin_longjmp((env),val)
env 49 eval_intern.h #define ruby_setjmp(env) RUBY_SETJMP(env)
env 50 eval_intern.h #define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
env 89 gc.c #define rb_setjmp(env) RUBY_SETJMP(env)
env 3047 hash.c const char *nam, *env;
env 3050 hash.c env = getenv(nam);
env 3051 hash.c if (env) {
env 3052 hash.c if (ENVMATCH(nam, PATH_ENV) && !env_path_tainted(env)) {
env 3053 hash.c return env_path_str_new(env);
env 3055 hash.c return env_str_new2(env);
env 3079 hash.c const char *nam, *env;
env 3088 hash.c env = getenv(nam);
env 3089 hash.c if (!env) {
env 3096 hash.c if (ENVMATCH(nam, PATH_ENV) && !env_path_tainted(env))
env 3097 hash.c return env_path_str_new(env);
env 3098 hash.c return env_str_new2(env);
env 3130 hash.c char **env;
env 3131 hash.c for (env = origenviron; *env; ++env) {
env 3132 hash.c if (*env == str) return 1;
env 3141 hash.c char **env;
env 3143 hash.c env = GET_ENVIRON(environ);
env 3144 hash.c for (i = 0; env[i]; i++) {
env 3145 hash.c if (ENVNMATCH(env[i],nam,len) && env[i][len] == '=')
env 3391 hash.c char **env;
env 3395 hash.c env = GET_ENVIRON(environ);
env 3396 hash.c while (*env) {
env 3397 hash.c char *s = strchr(*env, '=');
env 3399 hash.c rb_ary_push(ary, env_str_new(*env, s-*env));
env 3401 hash.c env++;
env 3410 hash.c char **env;
env 3413 hash.c env = GET_ENVIRON(environ);
env 3414 hash.c for (; *env ; ++env) {
env 3415 hash.c if (strchr(*env, '=')) {
env 3456 hash.c char **env;
env 3459 hash.c env = GET_ENVIRON(environ);
env 3460 hash.c while (*env) {
env 3461 hash.c char *s = strchr(*env, '=');
env 3465 hash.c env++;
env 3508 hash.c char **env;
env 3515 hash.c env = GET_ENVIRON(environ);
env 3516 hash.c while (*env) {
env 3517 hash.c char *s = strchr(*env, '=');
env 3519 hash.c rb_ary_push(ary, env_str_new(*env, s-*env));
env 3522 hash.c env++;
env 3736 hash.c char **env;
env 3740 hash.c env = GET_ENVIRON(environ);
env 3741 hash.c while (*env) {
env 3742 hash.c char *s = strchr(*env, '=');
env 3744 hash.c if (env != environ) {
env 3749 hash.c rb_str_buf_cat(str, *env, s-*env);
env 3754 hash.c env++;
env 3775 hash.c char **env;
env 3779 hash.c env = GET_ENVIRON(environ);
env 3780 hash.c while (*env) {
env 3781 hash.c char *s = strchr(*env, '=');
env 3783 hash.c rb_ary_push(ary, rb_assoc_new(env_str_new(*env, s-*env),
env 3786 hash.c env++;
env 3816 hash.c char **env;
env 3818 hash.c env = GET_ENVIRON(environ);
env 3819 hash.c for (i=0; env[i]; i++)
env 3834 hash.c char **env;
env 3836 hash.c env = GET_ENVIRON(environ);
env 3837 hash.c if (env[0] == 0) {
env 3892 hash.c char **env;
env 3897 hash.c env = GET_ENVIRON(environ);
env 3898 hash.c while (*env) {
env 3899 hash.c char *s = strchr(*env, '=');
env 3907 hash.c env++;
env 3923 hash.c char **env;
env 3928 hash.c env = GET_ENVIRON(environ);
env 3929 hash.c while (*env) {
env 3930 hash.c char *s = strchr(*env, '=');
env 3934 hash.c VALUE result = rb_assoc_new(rb_tainted_str_new(*env, s-*env-1), obj);
env 3939 hash.c env++;
env 3955 hash.c char **env;
env 3959 hash.c env = GET_ENVIRON(environ);
env 3960 hash.c while (*env) {
env 3961 hash.c char *s = strchr(*env, '=');
env 3965 hash.c str = env_str_new(*env, s-*env-1);
env 3970 hash.c env++;
env 4000 hash.c char **env;
env 4004 hash.c env = GET_ENVIRON(environ);
env 4005 hash.c while (*env) {
env 4006 hash.c char *s = strchr(*env, '=');
env 4008 hash.c rb_hash_aset(hash, env_str_new(*env, s-*env),
env 4011 hash.c env++;
env 4041 hash.c char **env;
env 4044 hash.c env = GET_ENVIRON(environ);
env 4045 hash.c if (*env) {
env 4046 hash.c char *s = strchr(*env, '=');
env 4048 hash.c VALUE key = env_str_new(*env, s-*env);
env 4095 hash.c if (env == hash) return env;
env 4100 hash.c env_delete(env, RARRAY_AREF(keys, i));
env 4103 hash.c return env;
env 4129 hash.c if (env == hash) return env;
env 4132 hash.c return env;
env 6252 io.c VALUE pname, pmode = Qnil, port, tmp, opt = Qnil, env = Qnil, execarg_obj = Qnil;
env 6257 io.c if (argc > 1 && !NIL_P(env = rb_check_hash_type(argv[0]))) --argc, ++argv;
env 6291 io.c if (!NIL_P(env))
env 6292 io.c rb_execarg_setenv(execarg_obj, env);
env 71 proc.c VALUE env[3]; /* me, specval, envval */
env 78 proc.c if (proc->block.ep == ((const cfunc_proc_t *)ptr)->env+1)
env 269 proc.c RUBY_MARK_UNLESS_NULL(bind->env);
env 308 proc.c dst->env = src->env;
env 381 proc.c rb_env_t *env;
env 387 proc.c GetEnvPtr(envval, env);
env 388 proc.c iseq = env->block.iseq;
env 393 proc.c return &env->env[i];
env 400 proc.c } while ((envval = rb_vm_env_prev_envval(env)) != Qfalse);
env 454 proc.c const rb_env_t *env;
env 457 proc.c GetEnvPtr(bind->env, env);
env 459 proc.c return rb_vm_env_local_variables(env);
env 490 proc.c if ((ptr = get_local_variable_ptr(bind->env, lid)) == NULL) {
env 534 proc.c if ((ptr = get_local_variable_ptr(bind->env, lid)) == NULL) {
env 570 proc.c return get_local_variable_ptr(bind->env, lid) ? Qtrue : Qfalse;
env 583 proc.c const rb_env_t *env;
env 586 proc.c GetEnvPtr(bind->env, env);
env 587 proc.c return env->block.self;
env 596 proc.c sproc->env[1] = VM_ENVVAL_BLOCK_PTR(0);
env 598 proc.c proc->block.ep = sproc->env+1;
env 2631 proc.c rb_env_t *env, *newenv;
env 2638 proc.c GetEnvPtr(envval, env);
env 2639 proc.c envsize = sizeof(rb_env_t) + (env->env_size - 1) * sizeof(VALUE);
env 2641 proc.c memcpy(newenv, env, envsize);
env 2690 proc.c bind->env = envval;
env 1928 process.c VALUE env = (VALUE)arg;
env 1941 process.c rb_ary_push(env, hide_obj(rb_assoc_new(key, val)));
env 1949 process.c VALUE env;
env 1951 process.c env = hide_obj(rb_ary_new());
env 1952 process.c st_foreach(rb_hash_tbl_raw(hash), check_exec_env_i, (st_data_t)env);
env 1954 process.c return env;
env 2059 process.c if (!NIL_P(env)) {
env 2060 process.c env = rb_check_exec_env(env);
env 2061 process.c eargp->env_modification = env;
env 2249 process.c VALUE env = Qnil, opthash = Qnil;
env 2253 process.c prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash);
env 2254 process.c rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj);
env 2265 process.c env = !NIL_P(env) ? rb_check_exec_env(env) : Qfalse;
env 2266 process.c eargp->env_modification = env;
env 2970 process.c VALUE env = rb_const_get(rb_cObject, id_ENV);
env 2971 process.c if (RTEST(env)) {
env 2973 process.c rb_block_call(env, idEach, 0, 0, save_env_i,
env 2023 regcomp.c map = (GroupNumRemap* )xalloca(sizeof(GroupNumRemap) * (env->num_mem + 1));
env 2025 regcomp.c for (i = 1; i <= env->num_mem; i++) {
env 2035 regcomp.c for (i = 1, pos = 1; i <= env->num_mem; i++) {
env 2037 regcomp.c SCANENV_MEM_NODES(env)[pos] = SCANENV_MEM_NODES(env)[i];
env 2042 regcomp.c loc = env->capture_history;
env 2043 regcomp.c BIT_STATUS_CLEAR(env->capture_history);
env 2046 regcomp.c BIT_STATUS_ON_AT_SIMPLE(env->capture_history, map[i].new_val);
env 2050 regcomp.c env->num_mem = env->num_named;
env 2051 regcomp.c reg->num_mem = env->num_named;
env 2159 regcomp.c Node** nodes = SCANENV_MEM_NODES(env);
env 2164 regcomp.c if (backs[0] > env->num_mem) return ONIGERR_INVALID_BACKREF;
env 2165 regcomp.c r = get_min_match_length(nodes[backs[0]], min, env);
env 2168 regcomp.c if (backs[i] > env->num_mem) return ONIGERR_INVALID_BACKREF;
env 2169 regcomp.c r = get_min_match_length(nodes[backs[i]], &tmin, env);
env 2184 regcomp.c r = get_min_match_length(NCALL(node)->target, min, env);
env 2190 regcomp.c r = get_min_match_length(NCAR(node), &tmin, env);
env 2201 regcomp.c r = get_min_match_length(x, &tmin, env);
env 2230 regcomp.c r = get_min_match_length(qn->target, min, env);
env 2246 regcomp.c r = get_min_match_length(en->target, min, env);
env 2257 regcomp.c r = get_min_match_length(en->target, min, env);
env 2281 regcomp.c r = get_max_match_length(NCAR(node), &tmax, env);
env 2289 regcomp.c r = get_max_match_length(NCAR(node), &tmax, env);
env 2302 regcomp.c *max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
env 2307 regcomp.c *max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
env 2314 regcomp.c Node** nodes = SCANENV_MEM_NODES(env);
env 2322 regcomp.c if (backs[i] > env->num_mem) return ONIGERR_INVALID_BACKREF;
env 2323 regcomp.c r = get_max_match_length(nodes[backs[i]], &tmax, env);
env 2333 regcomp.c r = get_max_match_length(NCALL(node)->target, max, env);
env 2344 regcomp.c r = get_max_match_length(qn->target, max, env);
env 2364 regcomp.c r = get_max_match_length(en->target, max, env);
env 2375 regcomp.c r = get_max_match_length(en->target, max, env);
env 2877 regcomp.c ret = subexp_inf_recursive_check(NCAR(x), env, head);
env 2881 regcomp.c ret = get_min_match_length(NCAR(x), &min, env);
env 2894 regcomp.c ret = subexp_inf_recursive_check(NCAR(node), env, head);
env 2902 regcomp.c r = subexp_inf_recursive_check(NQTFR(node)->target, env, head);
env 2916 regcomp.c r = subexp_inf_recursive_check(an->target, env, head);
env 2923 regcomp.c r = subexp_inf_recursive_check(NCALL(node)->target, env, head);
env 2933 regcomp.c r = subexp_inf_recursive_check(NENCLOSE(node)->target, env, head);
env 2956 regcomp.c r = subexp_inf_recursive_check_trav(NCAR(node), env);
env 2961 regcomp.c r = subexp_inf_recursive_check_trav(NQTFR(node)->target, env);
env 2972 regcomp.c r = subexp_inf_recursive_check_trav(an->target, env);
env 2984 regcomp.c r = subexp_inf_recursive_check(en->target, env, 1);
env 2988 regcomp.c r = subexp_inf_recursive_check_trav(en->target, env);
env 3071 regcomp.c ret = subexp_recursive_check_trav(NCAR(node), env);
env 3079 regcomp.c r = subexp_recursive_check_trav(NQTFR(node)->target, env);
env 3094 regcomp.c r = subexp_recursive_check_trav(an->target, env);
env 3112 regcomp.c r = subexp_recursive_check_trav(en->target, env);
env 3135 regcomp.c r = setup_subexp_call(NCAR(node), env);
env 3141 regcomp.c r = setup_subexp_call(NCAR(node), env);
env 3146 regcomp.c r = setup_subexp_call(NQTFR(node)->target, env);
env 3149 regcomp.c r = setup_subexp_call(NENCLOSE(node)->target, env);
env 3155 regcomp.c Node** nodes = SCANENV_MEM_NODES(env);
env 3161 regcomp.c if (env->num_named > 0 &&
env 3162 regcomp.c IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
env 3163 regcomp.c !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {
env 3167 regcomp.c if (gnum > env->num_mem) {
env 3168 regcomp.c onig_scan_env_set_error_string(env,
env 3178 regcomp.c onig_scan_env_set_error_string(env,
env 3183 regcomp.c BIT_STATUS_ON_AT(env->bt_mem_start, cn->group_num);
env 3184 regcomp.c cn->unset_addr_list = env->unset_addr_list;
env 3195 regcomp.c int n = onig_name_to_group_numbers(env->reg, cn->name, cn->name_end,
env 3198 regcomp.c onig_scan_env_set_error_string(env,
env 3203 regcomp.c ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME_CALL)) {
env 3204 regcomp.c onig_scan_env_set_error_string(env,
env 3226 regcomp.c r = setup_subexp_call(an->target, env);
env 3286 regcomp.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND))
env 3734 regcomp.c r = setup_comb_exp_check(NCAR(node), r, env);
env 3744 regcomp.c ret = setup_comb_exp_check(NCAR(node), state, env);
env 3764 regcomp.c if (env->backrefed_mem == 0) {
env 3802 regcomp.c env->num_comb_exp_check++;
env 3803 regcomp.c qn->comb_exp_check_num = env->num_comb_exp_check;
env 3804 regcomp.c if (env->curr_max_regnum > env->comb_exp_max_regnum)
env 3805 regcomp.c env->comb_exp_max_regnum = env->curr_max_regnum;
env 3810 regcomp.c r = setup_comb_exp_check(target, child_state, env);
env 3822 regcomp.c if (env->curr_max_regnum < en->regnum)
env 3823 regcomp.c env->curr_max_regnum = en->regnum;
env 3825 regcomp.c r = setup_comb_exp_check(en->target, state, env);
env 3830 regcomp.c r = setup_comb_exp_check(en->target, state, env);
env 3839 regcomp.c env->has_recursion = 1;
env 3841 regcomp.c r = setup_comb_exp_check(NCALL(node)->target, state, env);
env 3884 regcomp.c r = setup_tree(NCAR(node), reg, state, env);
env 3897 regcomp.c r = setup_tree(NCAR(node), reg, (state | IN_ALT), env);
env 3923 regcomp.c Node** nodes = SCANENV_MEM_NODES(env);
env 3927 regcomp.c if (p[i] > env->num_mem) return ONIGERR_INVALID_BACKREF;
env 3928 regcomp.c BIT_STATUS_ON_AT(env->backrefed_mem, p[i]);
env 3929 regcomp.c BIT_STATUS_ON_AT(env->bt_mem_start, p[i]);
env 3932 regcomp.c BIT_STATUS_ON_AT(env->bt_mem_end, p[i]);
env 3951 regcomp.c r = get_min_match_length(target, &d, env);
env 3963 regcomp.c r = get_max_match_length(target, &d, env);
env 3979 regcomp.c r = setup_tree(target, reg, state, env);
env 4056 regcomp.c r = setup_tree(NENCLOSE(node)->target, reg, state, env);
env 4063 regcomp.c BIT_STATUS_ON_AT(env->bt_mem_start, en->regnum);
env 4066 regcomp.c r = setup_tree(en->target, reg, state, env);
env 4072 regcomp.c r = setup_tree(target, reg, state, env);
env 4088 regcomp.c env->num_named > 0 &&
env 4089 regcomp.c IS_SYNTAX_BV(env->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
env 4090 regcomp.c !ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_CAPTURE_GROUP)) {
env 4094 regcomp.c r = setup_tree(NENCLOSE(node)->target, reg, state, env);
env 4106 regcomp.c r = setup_tree(an->target, reg, state, env);
env 4109 regcomp.c r = setup_tree(an->target, reg, (state | IN_NOT), env);
env 4137 regcomp.c r = setup_look_behind(node, reg, env);
env 4140 regcomp.c r = setup_tree(an->target, reg, state, env);
env 4150 regcomp.c r = setup_look_behind(node, reg, env);
env 4153 regcomp.c r = setup_tree(an->target, reg, (state | IN_NOT), env);
env 4652 regcomp.c len = enclen(env->enc, to->s + i, to->s + to->len);
env 4917 regcomp.c alt_merge_opt_exact_info(&to->exb, &add->exb, env);
env 4918 regcomp.c alt_merge_opt_exact_info(&to->exm, &add->exm, env);
env 4919 regcomp.c alt_merge_opt_exact_info(&to->expr, &add->expr, env);
env 4920 regcomp.c alt_merge_opt_map_info(env->enc, &to->map, &add->map);
env 4935 regcomp.c set_bound_node_opt_info(opt, &env->mmd);
env 4945 regcomp.c copy_opt_env(&nenv, env);
env 4950 regcomp.c concat_left_node_opt_info(env->enc, opt, &nopt);
env 4962 regcomp.c r = optimize_node_left(NCAR(nd), &nopt, env);
env 4965 regcomp.c else alt_merge_node_opt_info(opt, &nopt, env);
env 4979 regcomp.c is_raw, env->enc);
env 4982 regcomp.c add_char_opt_map_info(&opt->map, *(sn->s), env->enc);
env 4990 regcomp.c int n = onigenc_strlen(env->enc, sn->s, sn->end);
env 4991 regcomp.c max = ONIGENC_MBC_MAXLEN_DIST(env->enc) * n;
env 4995 regcomp.c is_raw, env->enc);
env 5000 regcomp.c env->enc, env->case_fold_flag);
env 5023 regcomp.c OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
env 5024 regcomp.c OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
env 5032 regcomp.c add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
env 5045 regcomp.c max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
env 5055 regcomp.c if (! ONIGENC_IS_CODE_WORD(env->enc, i) || i >= maxcode) {
env 5056 regcomp.c add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
env 5062 regcomp.c if (ONIGENC_IS_CODE_WORD(env->enc, i)) {
env 5063 regcomp.c add_char_opt_map_info(&opt->map, (UChar )i, env->enc);
env 5071 regcomp.c min = ONIGENC_MBC_MINLEN(env->enc);
env 5079 regcomp.c OnigDistance min = ONIGENC_MBC_MINLEN(env->enc);
env 5080 regcomp.c OnigDistance max = ONIGENC_MBC_MAXLEN_DIST(env->enc);
env 5102 regcomp.c r = optimize_node_left(NANCHOR(node)->target, &nopt, env);
env 5127 regcomp.c Node** nodes = SCANENV_MEM_NODES(env->scan_env);
env 5135 regcomp.c r = get_min_match_length(nodes[backs[0]], &min, env->scan_env);
env 5137 regcomp.c r = get_max_match_length(nodes[backs[0]], &max, env->scan_env);
env 5140 regcomp.c r = get_min_match_length(nodes[backs[i]], &tmin, env->scan_env);
env 5142 regcomp.c r = get_max_match_length(nodes[backs[i]], &tmax, env->scan_env);
env 5156 regcomp.c OnigOptionType save = env->options;
env 5157 regcomp.c env->options = NENCLOSE(NCALL(node)->target)->option;
env 5158 regcomp.c r = optimize_node_left(NCALL(node)->target, opt, env);
env 5159 regcomp.c env->options = save;
env 5171 regcomp.c r = optimize_node_left(qn->target, &nopt, env);
env 5175 regcomp.c if (env->mmd.max == 0 &&
env 5177 regcomp.c if (IS_MULTILINE(env->options))
env 5191 regcomp.c concat_opt_exact_info(&opt->exb, &nopt.exb, env->enc);
env 5225 regcomp.c OnigOptionType save = env->options;
env 5227 regcomp.c env->options = en->option;
env 5228 regcomp.c r = optimize_node_left(en->target, opt, env);
env 5229 regcomp.c env->options = save;
env 5248 regcomp.c r = optimize_node_left(en->target, opt, env);
env 5251 regcomp.c if (BIT_STATUS_AT(env->scan_env->backrefed_mem, en->regnum))
env 5259 regcomp.c r = optimize_node_left(en->target, opt, env);
env 5367 regcomp.c OptEnv env;
env 5369 regcomp.c env.enc = reg->enc;
env 5370 regcomp.c env.options = reg->options;
env 5371 regcomp.c env.case_fold_flag = reg->case_fold_flag;
env 5372 regcomp.c env.scan_env = scan_env;
env 5373 regcomp.c clear_mml(&env.mmd);
env 5375 regcomp.c r = optimize_node_left(node, &opt, &env);
env 133 regparse.c ((env)->num_mem + 1 + (rel_no))
env 141 regparse.c add_code_range_to_buf(pbuf, env, MBCODE_START_POS(enc), ONIG_LAST_CODE_POINT)
env 152 regparse.c if (BITSET_AT(bs, pos)) CC_DUP_WARN(env); \
env 820 regparse.c ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME)) {
env 821 regparse.c onig_scan_env_set_error_string(env, ONIGERR_MULTIPLEX_DEFINED_NAME,
env 956 regparse.c BIT_STATUS_CLEAR(env->capture_history);
env 957 regparse.c BIT_STATUS_CLEAR(env->bt_mem_start);
env 958 regparse.c BIT_STATUS_CLEAR(env->bt_mem_end);
env 959 regparse.c BIT_STATUS_CLEAR(env->backrefed_mem);
env 960 regparse.c env->error = (UChar* )NULL;
env 961 regparse.c env->error_end = (UChar* )NULL;
env 962 regparse.c env->num_call = 0;
env 963 regparse.c env->num_mem = 0;
env 965 regparse.c env->num_named = 0;
env 967 regparse.c env->mem_alloc = 0;
env 968 regparse.c env->mem_nodes_dynamic = (Node** )NULL;
env 971 regparse.c env->mem_nodes_static[i] = NULL_NODE;
env 974 regparse.c env->num_comb_exp_check = 0;
env 975 regparse.c env->comb_exp_max_regnum = 0;
env 976 regparse.c env->curr_max_regnum = 0;
env 977 regparse.c env->has_recursion = 0;
env 979 regparse.c env->warnings_flag = 0;
env 988 regparse.c need = env->num_mem + 1;
env 992 regparse.c if (env->mem_alloc <= need) {
env 993 regparse.c if (IS_NULL(env->mem_nodes_dynamic)) {
env 996 regparse.c xmemcpy(p, env->mem_nodes_static,
env 1000 regparse.c alloc = env->mem_alloc * 2;
env 1001 regparse.c p = (Node** )xrealloc(env->mem_nodes_dynamic, sizeof(Node*) * alloc);
env 1005 regparse.c for (i = env->num_mem + 1; i < alloc; i++)
env 1008 regparse.c env->mem_nodes_dynamic = p;
env 1009 regparse.c env->mem_alloc = alloc;
env 1013 regparse.c env->num_mem++;
env 1014 regparse.c return env->num_mem;
env 1020 regparse.c if (env->num_mem >= num)
env 1021 regparse.c SCANENV_MEM_NODES(env)[num] = node;
env 1377 regparse.c if (backrefs[i] <= env->num_mem &&
env 1378 regparse.c IS_NULL(SCANENV_MEM_NODES(env)[backrefs[i]])) {
env 1835 regparse.c CC_DUP_WARN(env);
env 1870 regparse.c return add_code_range_to_buf0(pbuf, env, from, to, 1);
env 1877 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
env 1883 regparse.c return add_code_range_to_buf0(pbuf, env, from, to, checkdup);
env 1889 regparse.c return add_code_range0(pbuf, env, from, to, 1);
env 1915 regparse.c r = add_code_range_to_buf(pbuf, env, pre, from - 1);
env 1922 regparse.c r = add_code_range_to_buf(pbuf, env, to + 1, ONIG_LAST_CODE_POINT);
env 1962 regparse.c return not_code_range_buf(enc, bbuf2, pbuf, env);
env 1978 regparse.c r = not_code_range_buf(enc, bbuf2, pbuf, env);
env 1985 regparse.c r = add_code_range_to_buf(pbuf, env, from, to);
env 2010 regparse.c r = add_code_range_to_buf(pbuf, env, from1, from2-1);
env 2025 regparse.c r = add_code_range_to_buf(pbuf, env, from1, to1);
env 2071 regparse.c r = add_code_range_to_buf(pbuf, env, from, to);
env 2080 regparse.c r = and_code_range1(pbuf, env, from1, to1, data2, n2);
env 2091 regparse.c OnigEncoding enc = env->enc;
env 2123 regparse.c r = or_code_range_buf(enc, buf1, 0, buf2, 0, &pbuf, env);
env 2126 regparse.c r = and_code_range_buf(buf1, not1, buf2, not2, &pbuf, env);
env 2129 regparse.c r = not_code_range_buf(enc, pbuf, &tbuf, env);
env 2149 regparse.c OnigEncoding enc = env->enc;
env 2181 regparse.c r = and_code_range_buf(buf1, 0, buf2, 0, &pbuf, env);
env 2184 regparse.c r = or_code_range_buf(enc, buf1, not1, buf2, not2, &pbuf, env);
env 2187 regparse.c r = not_code_range_buf(enc, pbuf, &tbuf, env);
env 2210 regparse.c if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_CONTROL_CHARS)) {
env 2220 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_V_VTAB))
env 2226 regparse.c UNKNOWN_ESC_WARN(env, c);
env 2445 regparse.c OnigEncoding enc = env->enc;
env 2449 regparse.c syn_allow = IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_INVALID_INTERVAL);
env 2465 regparse.c low = onig_scan_unsigned_number(&p, end, env->enc);
env 2471 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV)) {
env 2484 regparse.c up = onig_scan_unsigned_number(&p, end, env->enc);
env 2506 regparse.c if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) {
env 2507 regparse.c if (c != MC_ESC(env->syntax)) goto invalid;
env 2535 regparse.c OnigEncoding enc = env->enc;
env 2543 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META)) {
env 2549 regparse.c if (c == MC_ESC(env->syntax)) {
env 2550 regparse.c v = fetch_escaped_value(&p, end, env);
env 2561 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL)) {
env 2571 regparse.c if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_C_CONTROL)) {
env 2579 regparse.c if (c == MC_ESC(env->syntax)) {
env 2580 regparse.c v = fetch_escaped_value(&p, end, env);
env 2593 regparse.c c = conv_backslash_value(c, env);
env 2635 regparse.c OnigEncoding enc = env->enc;
env 2731 regparse.c onig_scan_env_set_error_string(env, r, *src, name_end);
env 2748 regparse.c OnigEncoding enc = env->enc;
env 2859 regparse.c onig_scan_env_set_error_string(env, r, *src, name_end);
env 2872 regparse.c OnigEncoding enc = env->enc;
env 2936 regparse.c onig_scan_env_set_error_string(env, r, *src, name_end);
env 2951 regparse.c onig_vsnprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
env 2952 regparse.c env->pattern, env->pattern_end,
env 2955 regparse.c if (env->sourcefile == NULL)
env 2958 regparse.c rb_compile_warn(env->sourcefile, env->sourceline, "%s", (char *)buf);
env 2966 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED) &&
env 2967 regparse.c IS_SYNTAX_BV(env->syntax, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC)) {
env 2968 regparse.c onig_syntax_warn(env, "character class has '%s' without escape", c);
env 2977 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED)) {
env 2978 regparse.c onig_syntax_warn(env, "regular expression has '%s' without escape", c);
env 2987 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_CC_DUP) &&
env 2988 regparse.c !(env->warnings_flag & ONIG_SYN_WARN_CC_DUP)) {
env 2989 regparse.c env->warnings_flag |= ONIG_SYN_WARN_CC_DUP;
env 2990 regparse.c onig_syntax_warn(env, "character class has duplicated range");
env 2998 regparse.c onig_syntax_warn(env, "Unknown escape \\%c is ignored", c);
env 3073 regparse.c const OnigSyntaxType* syn = env->syntax;
env 3074 regparse.c OnigEncoding enc = env->enc;
env 3168 regparse.c onig_syntax_warn(env, "invalid Unicode Property \\%c", c);
env 3244 regparse.c num = fetch_escaped_value(&p, end, env);
env 3273 regparse.c CC_ESC_WARN(env, (UChar* )"[");
env 3296 regparse.c const OnigSyntaxType* syn = env->syntax;
env 3308 regparse.c env, &back_num, &tok->u.backref.level);
env 3312 regparse.c r = fetch_name(&p, end, &name_end, env, &back_num, 1);
env 3318 regparse.c back_num = BACKREF_REL_TO_ABS(back_num, env);
env 3324 regparse.c if (back_num > env->num_mem ||
env 3325 regparse.c IS_NULL(SCANENV_MEM_NODES(env)[back_num]))
env 3334 regparse.c num = onig_name_to_group_numbers(env->reg, prev, name_end, &backs);
env 3336 regparse.c onig_scan_env_set_error_string(env,
env 3343 regparse.c if (backs[i] > env->num_mem ||
env 3344 regparse.c IS_NULL(SCANENV_MEM_NODES(env)[backs[i]]))
env 3370 regparse.c OnigEncoding enc = env->enc;
env 3371 regparse.c const OnigSyntaxType* syn = env->syntax;
env 3444 regparse.c r = fetch_range_quantifier(&p, end, tok, env);
env 3489 regparse.c tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option)
env 3490 regparse.c && ! IS_WORD_BOUND_ALL_RANGE(env->option);
env 3497 regparse.c tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option)
env 3498 regparse.c && ! IS_WORD_BOUND_ALL_RANGE(env->option);
env 3506 regparse.c tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option);
env 3513 regparse.c tok->u.anchor.ascii_range = IS_ASCII_RANGE(env->option);
env 3657 regparse.c (num <= env->num_mem || num <= 9)) { /* This spec. from GNU regex */
env 3659 regparse.c if (num > env->num_mem || IS_NULL(SCANENV_MEM_NODES(env)[num]))
env 3704 regparse.c r = fetch_named_backref_token(c, tok, &p, end, env);
env 3709 regparse.c onig_syntax_warn(env, "invalid back reference");
env 3721 regparse.c r = fetch_named_backref_token(c, tok, &p, end, env);
env 3751 regparse.c r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &gnum, 1);
env 3762 regparse.c onig_syntax_warn(env, "invalid subexp call");
env 3794 regparse.c onig_syntax_warn(env, "invalid Unicode Property \\%c", c);
env 3818 regparse.c num = fetch_escaped_value(&p, end, env);
env 3897 regparse.c r = fetch_range_quantifier(&p, end, tok, env);
env 3936 regparse.c IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_SUBEXP_CALL)) {
env 3956 regparse.c r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &gnum, numref);
env 3968 regparse.c IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_SUBEXP_CALL)) {
env 3981 regparse.c r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &gnum, 1);
env 3995 regparse.c IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_CAPITAL_P_NAMED_GROUP)) {
env 4004 regparse.c r = fetch_named_backref_token((OnigCodePoint )'(', tok, &p, end, env);
env 4010 regparse.c r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &gnum, 0);
env 4038 regparse.c tok->u.anchor.subtype = (IS_SINGLELINE(env->option)
env 4045 regparse.c tok->u.anchor.subtype = (IS_SINGLELINE(env->option)
env 4055 regparse.c if (*src > env->pattern) /* /].../ is allowed. */
env 4056 regparse.c CLOSE_BRACKET_WITHOUT_ESC_WARN(env, (UChar* )"]");
env 4060 regparse.c if (IS_EXTEND(env->option)) {
env 4072 regparse.c if (IS_EXTEND(env->option))
env 4105 regparse.c r = add_code_range_to_buf(&(cc->mbuf), env, j,
env 4119 regparse.c r = add_code_range_to_buf(&(cc->mbuf), env,
env 4147 regparse.c r = add_code_range_to_buf(&(cc->mbuf), env, prev,
env 4154 regparse.c r = add_code_range_to_buf(&(cc->mbuf), env, prev, 0x7fffffff);
env 4169 regparse.c OnigEncoding enc = env->enc;
env 4176 regparse.c r = add_ctype_to_cc_by_range(&ccwork, ctype, not, env, sb_out,
env 4180 regparse.c r = add_code_range_to_buf0(&(ccwork.mbuf), env, 0x80, ONIG_LAST_CODE_POINT, FALSE);
env 4185 regparse.c if (ONIGENC_MBC_MINLEN(env->enc) > 1) {
env 4186 regparse.c add_code_range(&(ccascii.mbuf), env, 0x00, 0x7F);
env 4189 regparse.c bitset_set_range(env, ccascii.bs, 0x00, 0x7F);
env 4191 regparse.c r = and_cclass(&ccwork, &ccascii, env);
env 4195 regparse.c r = or_cclass(cc, &ccwork, env);
env 4201 regparse.c r = add_ctype_to_cc_by_range(cc, ctype, not, env, sb_out, ranges);
env 4314 regparse.c OnigEncoding enc = env->enc;
env 4327 regparse.c ascii_range = IS_ASCII_RANGE(env->option) &&
env 4328 regparse.c ! IS_POSIX_BRACKET_ALL_RANGE(env->option);
env 4335 regparse.c r = add_ctype_to_cc(cc, pb->ctype, not, ascii_range, env);
env 4342 regparse.c r = add_ctype_to_cc(asc_cc, pb->ctype, not, ascii_range, env);
env 4376 regparse.c OnigEncoding enc = env->enc;
env 4398 regparse.c onig_scan_env_set_error_string(env, r, *src, prev);
env 4411 regparse.c ctype = fetch_char_property_to_ctype(src, end, env);
env 4417 regparse.c r = add_ctype_to_cc(cc, ctype, 0, 0, env);
env 4421 regparse.c if (IS_IGNORECASE(env->option)) {
env 4423 regparse.c r = cclass_case_fold(np, cc, cc, env);
env 4459 regparse.c r = add_code_range(&(cc->mbuf), env, *vs, *vs);
env 4462 regparse.c r = add_code_range0(&(asc_cc->mbuf), env, *vs, *vs, 0);
env 4490 regparse.c r = add_code_range(&(cc->mbuf), env, *vs, *vs);
env 4493 regparse.c r = add_code_range0(&(asc_cc->mbuf), env, *vs, *vs, 0);
env 4506 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
env 4511 regparse.c bitset_set_range(env, cc->bs, (int )*vs, (int )v);
env 4513 regparse.c bitset_set_range(env, asc_cc->bs, (int )*vs, (int )v);
env 4516 regparse.c r = add_code_range(&(cc->mbuf), env, *vs, v);
env 4519 regparse.c r = add_code_range0(&(asc_cc->mbuf), env, *vs, v, 0);
env 4529 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
env 4534 regparse.c bitset_set_range(env, cc->bs, (int )*vs, (int )(v < 0xff ? v : 0xff));
env 4535 regparse.c r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*vs, v);
env 4538 regparse.c bitset_set_range(env, asc_cc->bs, (int )*vs, (int )(v < 0xff ? v : 0xff));
env 4539 regparse.c r = add_code_range0(&(asc_cc->mbuf), env, (OnigCodePoint )*vs, v, 0);
env 4573 regparse.c OnigEncoding enc = env->enc;
env 4584 regparse.c if (code == MC_ESC(env->syntax)) in_esc = 1;
env 4609 regparse.c r = fetch_token_in_cc(tok, src, end, env);
env 4612 regparse.c r = fetch_token_in_cc(tok, src, end, env);
env 4621 regparse.c *src, env->pattern_end, 1, env))
env 4624 regparse.c CC_ESC_WARN(env, (UChar* )"]");
env 4632 regparse.c if (IS_IGNORECASE(env->option)) {
env 4650 regparse.c (len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c)) > 1) {
env 4668 regparse.c if (! ONIGENC_IS_SINGLEBYTE(env->enc) && tok->base != 0) {
env 4675 regparse.c for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) {
env 4676 regparse.c r = fetch_token_in_cc(tok, &p, end, env);
env 4685 regparse.c if (i < ONIGENC_MBC_MINLEN(env->enc)) {
env 4690 regparse.c len = enclen(env->enc, buf, buf+i);
env 4698 regparse.c r = fetch_token_in_cc(tok, &p, end, env);
env 4708 regparse.c v = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe);
env 4725 regparse.c len = ONIGENC_CODE_TO_MBCLEN(env->enc, v);
env 4733 regparse.c &state, env);
env 4738 regparse.c r = parse_posix_bracket(cc, asc_cc, &p, end, env);
env 4741 regparse.c CC_ESC_WARN(env, (UChar* )"[");
env 4752 regparse.c IS_ASCII_RANGE(env->option), env);
env 4757 regparse.c IS_ASCII_RANGE(env->option), env);
env 4762 regparse.c r = next_state_class(cc, asc_cc, &vs, &val_type, &state, env);
env 4770 regparse.c ctype = fetch_char_property_to_ctype(&p, end, env);
env 4772 regparse.c r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, 0, env);
env 4776 regparse.c r = add_ctype_to_cc(asc_cc, ctype, tok->u.prop.not, 0, env);
env 4785 regparse.c r = fetch_token_in_cc(tok, &p, end, env);
env 4795 regparse.c CC_ESC_WARN(env, (UChar* )"-");
env 4805 regparse.c r = fetch_token_in_cc(tok, &p, end, env);
env 4810 regparse.c CC_ESC_WARN(env, (UChar* )"-");
env 4815 regparse.c CC_ESC_WARN(env, (UChar* )"-");
env 4819 regparse.c r = fetch_token_in_cc(tok, &p, end, env);
env 4824 regparse.c CC_ESC_WARN(env, (UChar* )"-");
env 4828 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) {
env 4829 regparse.c CC_ESC_WARN(env, (UChar* )"-");
env 4842 regparse.c r = parse_char_class(&anode, &aasc_node, tok, &p, end, env);
env 4845 regparse.c r = or_cclass(cc, acc, env);
env 4849 regparse.c r = or_cclass(asc_cc, acc, env);
env 4861 regparse.c &val_type, &state, env);
env 4869 regparse.c r = and_cclass(prev_cc, cc, env);
env 4873 regparse.c r = and_cclass(asc_prev_cc, asc_cc, env);
env 4905 regparse.c r = fetch_token_in_cc(tok, &p, end, env);
env 4912 regparse.c &val_type, &state, env);
env 4917 regparse.c r = and_cclass(prev_cc, cc, env);
env 4922 regparse.c r = and_cclass(asc_prev_cc, asc_cc, env);
env 4940 regparse.c IS_SYNTAX_BV(env->syntax, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC)) {
env 4950 regparse.c if (ONIGENC_IS_CODE_NEWLINE(env->enc, NEWLINE_CODE)) {
env 4951 regparse.c if (ONIGENC_CODE_TO_MBCLEN(env->enc, NEWLINE_CODE) == 1)
env 4954 regparse.c r = add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE);
env 4982 regparse.c OnigEncoding enc = env->enc;
env 4994 regparse.c option = env->option;
env 4996 regparse.c IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) {
env 5004 regparse.c r = fetch_token(tok, &p, end, env);
env 5006 regparse.c r = parse_subexp(np, tok, term, &p, end, env);
env 5024 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
env 5033 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_CAPITAL_P_NAMED_GROUP)) {
env 5050 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
env 5062 regparse.c r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 0);
env 5065 regparse.c num = scan_env_add_mem_entry(env);
env 5070 regparse.c r = name_add(env->reg, name, name_end, num, env);
env 5072 regparse.c *np = node_new_enclose_memory(env->option, 1);
env 5076 regparse.c BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
env 5077 regparse.c env->num_named++;
env 5091 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY)) {
env 5093 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
env 5102 regparse.c *np = node_new_enclose_memory(env->option, 0);
env 5104 regparse.c num = scan_env_add_mem_entry(env);
env 5110 regparse.c BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
env 5118 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LPAREN_CONDITION)) {
env 5124 regparse.c r = fetch_name((OnigCodePoint )'(', &p, end, &name_end, env, &num, 1);
env 5129 regparse.c num = BACKREF_REL_TO_ABS(num, env);
env 5134 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_STRICT_CHECK_BACKREF)) {
env 5135 regparse.c if (num > env->num_mem ||
env 5136 regparse.c IS_NULL(SCANENV_MEM_NODES(env)[num]))
env 5146 regparse.c r = fetch_name((OnigCodePoint )c, &p, end, &name_end, env, &num, 0);
env 5151 regparse.c nums = onig_name_to_group_numbers(env->reg, name, name_end, &backs);
env 5153 regparse.c onig_scan_env_set_error_string(env,
env 5157 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_STRICT_CHECK_BACKREF)) {
env 5160 regparse.c if (backs[i] > env->num_mem ||
env 5161 regparse.c IS_NULL(SCANENV_MEM_NODES(env)[backs[i]]))
env 5181 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_VBAR_BRANCH_RESET)) {
env 5190 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
env 5200 regparse.c else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) {
env 5233 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
env 5241 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
env 5244 regparse.c else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) {
env 5257 regparse.c if ((IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) ||
env 5258 regparse.c IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) &&
env 5269 regparse.c if ((IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) ||
env 5270 regparse.c IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) &&
env 5281 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) &&
env 5285 regparse.c else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY) &&
env 5296 regparse.c if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL) && (neg == 0)) {
env 5314 regparse.c OnigOptionType prev = env->option;
env 5316 regparse.c env->option = option;
env 5317 regparse.c r = fetch_token(tok, &p, end, env);
env 5319 regparse.c r = parse_subexp(&target, tok, term, &p, end, env);
env 5320 regparse.c env->option = prev;
env 5340 regparse.c if (ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_DONT_CAPTURE_GROUP))
env 5343 regparse.c *np = node_new_enclose_memory(env->option, 0);
env 5345 regparse.c num = scan_env_add_mem_entry(env);
env 5351 regparse.c r = fetch_token(tok, &p, end, env);
env 5353 regparse.c r = parse_subexp(&target, tok, term, &p, end, env);
env 5365 regparse.c r = scan_env_set_mem_node(env, NENCLOSE(*np)->regnum, *np);
env 5415 regparse.c if (str_node_can_be_split(sn, env->enc)) {
env 5416 regparse.c Node* n = str_node_split_last_char(sn, env->enc);
env 5434 regparse.c IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) {
env 5441 regparse.c onig_syntax_warn(env, "regular expression has redundant nested repeat operator '%s'",
env 5449 regparse.c onig_syntax_warn(env, "nested repeat operator '%s' and '%s' was replaced with '%s' in regular expression",
env 5590 regparse.c ScanEnv* env;
env 5602 regparse.c ScanEnv* env;
env 5609 regparse.c env = iarg->env;
env 5621 regparse.c add_flag = onig_is_code_in_cc(env->enc, from, asc_cc);
env 5627 regparse.c int is_in = onig_is_code_in_cc(env->enc, from, cc);
env 5632 regparse.c if (ONIGENC_MBC_MINLEN(env->enc) > 1 || *to >= SINGLE_BYTE_SIZE) {
env 5633 regparse.c add_code_range0(&(cc->mbuf), env, *to, *to, 0);
env 5643 regparse.c if (ONIGENC_MBC_MINLEN(env->enc) > 1 || *to >= SINGLE_BYTE_SIZE) {
env 5644 regparse.c if (IS_NCCLASS_NOT(cc)) clear_not_flag_cclass(cc, env->enc);
env 5645 regparse.c add_code_range0(&(cc->mbuf), env, *to, *to, 0);
env 5664 regparse.c if (onig_is_code_in_cc(env->enc, from, cc)
env 5670 regparse.c len = ONIGENC_CODE_TO_MBC(env->enc, to[i], buf);
env 5703 regparse.c iarg.env = env;
env 5709 regparse.c r = ONIGENC_APPLY_ALL_CASE_FOLD(env->enc, env->case_fold_flag,
env 5739 regparse.c num1 = ONIGENC_CODE_TO_MBC(env->enc, 0x0D, buf);
env 5741 regparse.c num2 = ONIGENC_CODE_TO_MBC(env->enc, 0x0A, buf + num1);
env 5750 regparse.c if (ONIGENC_MBC_MINLEN(env->enc) > 1) {
env 5751 regparse.c add_code_range(&(cc->mbuf), env, 0x0A, 0x0D);
env 5754 regparse.c bitset_set_range(env, cc->bs, 0x0A, 0x0D);
env 5758 regparse.c if (ONIGENC_IS_UNICODE(env->enc)) {
env 5760 regparse.c add_code_range(&(cc->mbuf), env, 0x85, 0x85);
env 5761 regparse.c add_code_range(&(cc->mbuf), env, 0x2028, 0x2029);
env 5799 regparse.c if (ONIGENC_IS_UNICODE(env->enc)) {
env 5804 regparse.c int ctype = env->enc->property_name_to_ctype(ONIG_ENCODING_ASCII,
env 5811 regparse.c r = add_ctype_to_cc(cc1, ctype, 0, 0, env);
env 5819 regparse.c r = add_ctype_to_cc(cc2, ctype, 0, 0, env);
env 5850 regparse.c option = env->option;
env 5948 regparse.c r = parse_enclose(np, tok, TK_SUBEXP_CLOSE, src, end, env);
env 5953 regparse.c OnigOptionType prev = env->option;
env 5955 regparse.c env->option = NENCLOSE(*np)->option;
env 5956 regparse.c r = fetch_token(tok, src, end, env);
env 5958 regparse.c r = parse_subexp(&target, tok, term, src, end, env);
env 5959 regparse.c env->option = prev;
env 5970 regparse.c if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP))
env 5978 regparse.c r = node_linebreak(np, env);
env 5983 regparse.c r = node_extended_grapheme_cluster(np, env);
env 6000 regparse.c r = fetch_token(tok, src, end, env);
env 6007 regparse.c r = node_str_cat_codepoint(*np, env->enc, tok->u.code);
env 6029 regparse.c if (len >= ONIGENC_MBC_MINLEN(env->enc)) {
env 6030 regparse.c if (len == enclen(env->enc, NSTR(*np)->s, NSTR(*np)->end)) {
env 6031 regparse.c r = fetch_token(tok, src, end, env);
env 6037 regparse.c r = fetch_token(tok, src, end, env);
env 6043 regparse.c if (len < ONIGENC_MBC_MINLEN(env->enc)) {
env 6044 regparse.c rem = ONIGENC_MBC_MINLEN(env->enc) - len;
env 6046 regparse.c if (len + rem == enclen(env->enc, NSTR(*np)->s)) {
env 6067 regparse.c r = node_str_cat_codepoint(*np, env->enc, tok->u.code);
env 6082 regparse.c end_op[0] = (OnigCodePoint )MC_ESC(env->syntax);
env 6085 regparse.c qend = find_str_position(end_op, 2, qstart, end, &nextp, env->enc);
env 6100 regparse.c IS_ASCII_RANGE(env->option));
env 6114 regparse.c r = ONIGENC_GET_CTYPE_CODE_RANGE(env->enc, tok->u.prop.ctype,
env 6117 regparse.c ! IS_ASCII_RANGE(env->option) &&
env 6123 regparse.c key.enc = env->enc;
env 6167 regparse.c IS_ASCII_RANGE(env->option), env);
env 6184 regparse.c r = parse_char_property(np, tok, src, end, env);
env 6194 regparse.c r = parse_char_class(np, &asc_node, tok, src, end, env);
env 6206 regparse.c r = node_str_cat_codepoint(*np, env->enc, code);
env 6210 regparse.c if (IS_IGNORECASE(env->option)) {
env 6211 regparse.c r = cclass_case_fold(np, cc, NCCLASS(asc_node), env);
env 6244 regparse.c env);
env 6255 regparse.c gnum = BACKREF_REL_TO_ABS(gnum, env);
env 6261 regparse.c env->num_call++;
env 6274 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) {
env 6275 regparse.c if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS))
env 6294 regparse.c r = fetch_token(tok, src, end, env);
env 6306 regparse.c r = set_quantifier(qn, *targetp, group, env);
env 6359 regparse.c r = parse_exp(&node, tok, term, src, end, env);
env 6372 regparse.c r = parse_exp(&node, tok, term, src, end, env);
env 6402 regparse.c r = parse_branch(&node, tok, term, src, end, env);
env 6415 regparse.c r = fetch_token(tok, src, end, env);
env 6417 regparse.c r = parse_branch(&node, tok, term, src, end, env);
env 6448 regparse.c r = fetch_token(&tok, src, end, env);
env 6450 regparse.c r = parse_subexp(top, &tok, TK_EOT, src, end, env);
env 6454 regparse.c if (env->num_call > 0) {
env 6458 regparse.c np = node_new_enclose_memory(env->option, 0);
env 6462 regparse.c r = scan_env_set_mem_node(env, num, np);
env 6484 regparse.c scan_env_clear(env);
env 6485 regparse.c env->option = reg->options;
env 6486 regparse.c env->case_fold_flag = reg->case_fold_flag;
env 6487 regparse.c env->enc = reg->enc;
env 6488 regparse.c env->syntax = reg->syntax;
env 6489 regparse.c env->pattern = (UChar* )pattern;
env 6490 regparse.c env->pattern_end = (UChar* )end;
env 6491 regparse.c env->reg = reg;
env 6495 regparse.c r = parse_regexp(root, &p, (UChar* )end, env);
env 6496 regparse.c reg->num_mem = env->num_mem;
env 6504 regparse.c env->error = arg;
env 6505 regparse.c env->error_end = arg_end;
env 645 ruby.c rb_env_t *env;
env 647 ruby.c GetEnvPtr(bind->env, env);
env 648 ruby.c return &env->block;
env 374 vm.c rb_env_t *env;
env 377 vm.c GetEnvPtr(bind->env, env);
env 379 vm.c vm_set_eval_stack(th, iseq, 0, &env->block);
env 383 vm.c bind->env = vm_make_env_object(th, th->cfp);
env 506 vm.c const rb_env_t * const env = ptr;
env 510 vm.c rb_gc_mark_values((long)env->env_size, env->env);
env 512 vm.c RUBY_MARK_UNLESS_NULL(rb_vm_env_prev_envval(env));
env 513 vm.c RUBY_MARK_UNLESS_NULL(env->block.self);
env 514 vm.c RUBY_MARK_UNLESS_NULL(env->block.proc);
env 515 vm.c RUBY_MARK_UNLESS_NULL((VALUE)env->block.iseq);
env 522 vm.c const rb_env_t * const env = ptr;
env 525 vm.c size += (env->env_size - 1) * sizeof(VALUE);
env 544 vm.c fprintf(stderr, "envptr: %p\n", (void *)&env->block.ep[0]);
env 545 vm.c fprintf(stderr, "envval: %10p ", (void *)env->block.ep[1]);
env 546 vm.c dp(env->block.ep[1]);
env 547 vm.c fprintf(stderr, "ep: %10p\n", (void *)env->block.ep);
env 548 vm.c if (rb_vm_env_prev_envval(env)) {
env 550 vm.c check_env_value(rb_vm_env_prev_envval(env));
env 559 vm.c rb_env_t *env;
env 560 vm.c GetEnvPtr(envval, env);
env 562 vm.c if (check_env(env)) {
env 592 vm.c rb_env_t *env;
env 650 vm.c env = xmalloc(sizeof(rb_env_t) + (env_size - 1 /* rb_env_t::env[1] */) * sizeof(VALUE));
env 651 vm.c env->env_size = env_size;
env 653 vm.c MEMCPY(env->env, ep - local_size, VALUE, local_size + 1 /* specval */);
env 665 vm.c RTYPEDDATA_DATA(envval) = env;
env 673 vm.c new_ep = &env->env[local_size];
env 678 vm.c env->block.self = cfp->self;
env 679 vm.c env->block.ep = cfp->ep = new_ep;
env 680 vm.c env->block.iseq = cfp->iseq;
env 681 vm.c env->block.proc = 0;
env 685 vm.c env->block.iseq = 0;
env 716 vm.c const VALUE *ep = env->block.ep;
env 742 vm.c while (collect_local_variables_in_iseq(env->block.iseq, vars), (prev_envval = rb_vm_env_prev_envval(env)) != Qfalse) {
env 743 vm.c GetEnvPtr(prev_envval, env);
env 751 vm.c rb_env_t *env;
env 752 vm.c GetEnvPtr(VM_ENV_EP_ENVVAL(ep), env);
env 753 vm.c collect_local_variables_in_env(env, vars);
env 766 vm.c collect_local_variables_in_env(env, &vars);
env 859 vm.c bind->env = envval;
env 869 vm.c VALUE envval = bind->env, path = bind->path;
env 870 vm.c rb_env_t *env;
env 880 vm.c GetEnvPtr(envval, env);
env 882 vm.c base_block = &env->block;
env 902 vm.c bind->env = vm_make_env_object(th, th->cfp);
env 904 vm.c GetEnvPtr(bind->env, env);
env 906 vm.c return env->env;
env 856 vm_core.h VALUE env[1]; /* flexible array */
env 865 vm_core.h VALUE env;
env 193 vm_dump.c while (env) {
env 197 vm_dump.c for (i = 0; i < env->env_size; i++) {
env 198 vm_dump.c fprintf(stderr, "%04d: %08"PRIxVALUE" (%p)", i, env->env[i], (void *)&env->env[i]);
env 199 vm_dump.c if (&env->env[i] == ep) fprintf(stderr, " <- ep");
env 203 vm_dump.c if ((prev_envval = rb_vm_env_prev_envval(env)) != Qfalse) {
env 204 vm_dump.c GetEnvPtr(prev_envval, env);
env 207 vm_dump.c env = NULL;
env 216 vm_dump.c rb_env_t *env;
env 223 vm_dump.c GetEnvPtr(rb_vm_proc_envval(proc), env);
env 224 vm_dump.c rb_vmdebug_env_dump_raw(env, proc->block.ep);
env 1299 vm_eval.c rb_env_t *env = NULL;
env 1321 vm_eval.c envval = bind->env;
env 1328 vm_eval.c GetEnvPtr(envval, env);
env 1329 vm_eval.c base_block = &env->block;
env 1379 vm_eval.c bind->env = vm_make_env_object(th, th->cfp);
env 543 win32/win32.c if (!GetEnvironmentVariableW(L"HOME", env, numberof(env))) {
env 545 win32/win32.c if (GetEnvironmentVariableW(L"HOMEDRIVE", env, numberof(env)))
env 546 win32/win32.c len = lstrlenW(env);
env 549 win32/win32.c if (GetEnvironmentVariableW(L"HOMEPATH", env + len, numberof(env) - len) || len) {
env 552 win32/win32.c else if (GetEnvironmentVariableW(L"USERPROFILE", env, numberof(env))) {
env 555 win32/win32.c else if (get_special_folder(CSIDL_PROFILE, env, numberof(env))) {
env 558 win32/win32.c else if (get_special_folder(CSIDL_PERSONAL, env, numberof(env))) {
env 562 win32/win32.c regulate_path(env);
env 567 win32/win32.c if (!GetEnvironmentVariableW(L"USER", env, numberof(env))) {
env 568 win32/win32.c if (!GetEnvironmentVariableW(L"USERNAME", env, numberof(env)) &&
env 569 win32/win32.c !GetUserNameW(env, (len = numberof(env), &len))) {
env 574 win32/win32.c NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL);
env 578 win32/win32.c NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL);
env 581 win32/win32.c if (!GetEnvironmentVariableW(TMPDIR, env, numberof(env)) &&
env 582 win32/win32.c !GetEnvironmentVariableW(L"TMP", env, numberof(env)) &&
env 583 win32/win32.c !GetEnvironmentVariableW(L"TEMP", env, numberof(env)) &&
env 584 win32/win32.c rb_w32_system_tmpdir(env, numberof(env))) {
env 5007 win32/win32.c char *env;
env 5028 win32/win32.c for (env = uenvarea; *env; env += strlen(env) + 1)
env 5029 win32/win32.c if (strncasecmp(env, name, len) == 0 && *(env + len) == '=')
env 5030 win32/win32.c return env + len + 1;
env 5899 win32/win32.c WCHAR *envtop, *env;
env 5914 win32/win32.c for (env = envtop, num = 0; *env; env += lstrlenW(env) + 1)
env 5915 win32/win32.c if (*env != '=') num++;
env 5918 win32/win32.c for (env = envtop, myenv = myenvtop; *env; env += lstrlenW(env) + 1) {
env 5919 win32/win32.c if (*env != '=') {
env 5920 win32/win32.c if (!(*myenv = wstr_to_utf8(env, NULL))) {
env 5936 win32/win32.c char **t = env;
env 5939 win32/win32.c free(env);