Lines Matching defs:pRExC_state
299 Perl_reg_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
530 S_pat_upgrade_to_utf8(pTHX_ RExC_state_t * const pRExC_state,
551 assert(pRExC_state->code_blocks);
552 if (!do_end && pRExC_state->code_blocks->cb[n].start == s) {
553 pRExC_state->code_blocks->cb[n].start = d - dst - 1;
557 else if (do_end && pRExC_state->code_blocks->cb[n].end == s) {
558 pRExC_state->code_blocks->cb[n].end = d - dst - 1;
589 S_concat_pat(pTHX_ RExC_state_t * const pRExC_state,
654 pat = S_concat_pat(aTHX_ pRExC_state, pat,
683 assert(n < pRExC_state->code_blocks->count);
684 pRExC_state->code_blocks->cb[n].start = pat ? SvCUR(pat) : 0;
685 pRExC_state->code_blocks->cb[n].block = oplist;
686 pRExC_state->code_blocks->cb[n].src_regex = NULL;
717 pRExC_state->code_blocks->count -= n;
744 S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &dst, &dlen, n);
767 pRExC_state->code_blocks->cb[n-1].end = SvCUR(pat)-1;
783 if (pRExC_state->code_blocks) {
784 int new_count = pRExC_state->code_blocks->count
786 Renew(pRExC_state->code_blocks->cb,
788 pRExC_state->code_blocks->count = new_count;
791 pRExC_state->code_blocks = S_alloc_code_blocks(aTHX_
798 assert(n < pRExC_state->code_blocks->count);
800 dst = &pRExC_state->code_blocks->cb[n];
826 S_has_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
835 if ( pRExC_state->code_blocks
836 && n < pRExC_state->code_blocks->count
837 && s == pRExC_state->code_blocks->cb[n].start)
839 s = pRExC_state->code_blocks->cb[n].end;
878 S_compile_runtime_code(pTHX_ RExC_state_t * const pRExC_state,
885 if (pRExC_state->runtime_code_qr) {
891 qr = pRExC_state->runtime_code_qr;
892 pRExC_state->runtime_code_qr = NULL;
914 if ( pRExC_state->code_blocks
915 && n < pRExC_state->code_blocks->count
916 && s == pRExC_state->code_blocks->cb[n].start)
934 while (s < pRExC_state->code_blocks->cb[n].end) {
947 if (pRExC_state->pm_flags & RXf_PMf_EXTENDED) {
949 if (pRExC_state->pm_flags & RXf_PMf_EXTENDED_MORE) {
996 assert(!pRExC_state->runtime_code_qr);
997 pRExC_state->runtime_code_qr = qr;
1009 RExC_state_t * const r1 = pRExC_state; /* convenient alias */
1073 S_setup_longest(pTHX_ RExC_state_t *pRExC_state,
1127 S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx)
1216 S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc)
1239 set_ANYOF_arg(pRExC_state, (regnode *) ssc, invlist, NULL, NULL);
1257 S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc)
1313 RExC_state_t *pRExC_state = (RExC_state_t *)vstate;
1318 pRExC_state is about to be released.
1326 Safefree(pRExC_state);
1422 RExC_state_t *pRExC_state = NULL;
1423 /* Ensure that all members of the pRExC_state is initialized to 0
1428 Newxz(pRExC_state, 1, RExC_state_t);
1430 SAVEDESTRUCTOR_X(release_RExC_state, pRExC_state);
1436 * the pRExC_state structure, as there were codepaths under -Uusedl
1456 pRExC_state->code_blocks = S_alloc_code_blocks(aTHX_ ncode);
1500 if (pRExC_state->code_blocks && pRExC_state->code_blocks->count
1510 pat = S_concat_pat(aTHX_ pRExC_state, NULL, new_patternp, pat_count,
1563 runtime_code = S_has_runtime_code(aTHX_ pRExC_state, exp, plen);
1573 * ALSO NOTE: After this point we may need to zero members of pRExC_state
1621 if (!S_compile_runtime_code(aTHX_ pRExC_state, exp, plen)) {
1624 S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &exp, &plen,
1625 pRExC_state->code_blocks ? pRExC_state->code_blocks->count : 0);
1629 assert(!pRExC_state->runtime_code_qr);
1650 pRExC_state->code_index = 0;
1654 set_regex_pv(pRExC_state, Rx);
1702 RExC_rxi->code_blocks = pRExC_state->code_blocks;
1727 pRExC_state->code_index = 0;
1733 if (reg(pRExC_state, 0, &flags, 1)) {
1772 S_pat_upgrade_to_utf8(aTHX_ pRExC_state, &exp, &plen,
1773 pRExC_state->code_blocks ? pRExC_state->code_blocks->count : 0);
1825 set_regex_pv(pRExC_state, Rx);
1891 copyRExC_state = *pRExC_state;
1896 *pRExC_state = copyRExC_state;
1990 RExC_rxi->regstclass = construct_ahocorasick_from_trie(pRExC_state, (regnode *)first, 0);
2069 ssc_init(pRExC_state, &ch_class);
2082 minlen = study_chunk(pRExC_state, &first, &minlen, &fake_deltap,
2103 scan_commit(pRExC_state, &data,&minlen, 0);
2119 && S_setup_longest (aTHX_ pRExC_state,
2150 && is_ssc_worth_it(pRExC_state, data.start_class))
2152 const U32 n = reg_add_data(pRExC_state, STR_WITH_LEN("f"));
2154 ssc_finalize(pRExC_state, data.start_class);
2163 regprop(RExC_rx, sv, (regnode*)data.start_class, NULL, pRExC_state);
2205 ssc_init(pRExC_state, &ch_class);
2215 minlen = study_chunk(pRExC_state,
2234 && is_ssc_worth_it(pRExC_state, data.start_class))
2236 const U32 n = reg_add_data(pRExC_state, STR_WITH_LEN("f"));
2238 ssc_finalize(pRExC_state, data.start_class);
2247 regprop(RExC_rx, sv, (regnode*)data.start_class, NULL, pRExC_state);
2286 if (pRExC_state->code_blocks)
2358 RExC_rxi->name_list_idx = reg_add_data( pRExC_state, STR_WITH_LEN("a"));
2456 S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
2555 S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state)
2824 S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state,
2833 SV *sv_dat = reg_scan_name(pRExC_state, REG_RSN_RETURN_DATA);
2849 num = reg_add_data( pRExC_state, STR_WITH_LEN("S"));
2854 ret = reg2node(pRExC_state,
2869 nextchar(pRExC_state);
2897 S_reg_la_NOTHING(pTHX_ RExC_state_t *pRExC_state, U32 flags,
2904 skip_to_be_ignored_text(pRExC_state, &RExC_parse, FALSE);
2913 regnode_offset ret= reg_node(pRExC_state, NOTHING);
2914 nextchar(pRExC_state);
2946 S_reg_la_OPFAIL(pTHX_ RExC_state_t *pRExC_state, U32 flags,
2953 skip_to_be_ignored_text(pRExC_state, &RExC_parse, FALSE);
2959 regnode_offset ret= reg1node(pRExC_state, OPFAIL, 0);
2960 nextchar(pRExC_state);
2993 * pRExC_state is a structure with much information about the current
3028 S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth)
3300 ret = reg_node(pRExC_state, SROPEN);
3310 ret = reg_node(pRExC_state, SROPEN);
3314 atomic = reg(pRExC_state, 'r', &flags, depth);
3320 if (! REGTAIL(pRExC_state, ret, atomic)) {
3324 if (! REGTAIL(pRExC_state, atomic, reg_node(pRExC_state,
3352 ret = reg1node(pRExC_state, OPFAIL, 0);
3353 nextchar(pRExC_state);
3363 ret = reg_node(pRExC_state, NOTHING);
3364 nextchar(pRExC_state);
3401 ret = reg1node(pRExC_state, op, 0);
3403 ret = reg2node(pRExC_state, op, 0, internal_argval);
3408 ARG1u(REGNODE_p(ret)) = reg_add_data( pRExC_state,
3417 nextchar(pRExC_state);
3469 return handle_named_backref(pRExC_state, flagp,
3482 if ((ret= reg_la_OPFAIL(pRExC_state,REG_LB_SEEN,"?<!")))
3490 if ((ret= reg_la_NOTHING(pRExC_state,REG_LB_SEEN,"?<=")))
3503 svname = reg_scan_name(pRExC_state, REG_RSN_RETURN_NAME);
3572 nextchar(pRExC_state);
3578 if ((ret= reg_la_NOTHING(pRExC_state, 0, "?=")))
3582 if ((ret= reg_la_OPFAIL(pRExC_state, 0, "?!")))
3622 SV *sv_dat = reg_scan_name(pRExC_state,
3758 ret = reg2node(pRExC_state, GOSUB, num, RExC_recurse_count);
3769 nextchar(pRExC_state);
3796 if ( !pRExC_state->code_blocks
3797 || pRExC_state->code_index
3798 >= pRExC_state->code_blocks->count
3799 || pRExC_state->code_blocks->cb[pRExC_state->code_index].start
3808 cb = &pRExC_state->code_blocks->cb[pRExC_state->code_index];
3812 n = reg_add_data(pRExC_state, STR_WITH_LEN("rl"));
3818 n = reg_add_data(pRExC_state,
3822 pRExC_state->code_index++;
3823 nextchar(pRExC_state);
3829 ret = reg_node(pRExC_state, LOGICAL);
3832 eval = reg2node(pRExC_state, EVAL,
3840 if (! REGTAIL(pRExC_state, ret, eval)) {
3845 ret = reg2node(pRExC_state, EVAL, n, 0);
3890 ret = reg_node(pRExC_state, LOGICAL);
3893 tail = reg(pRExC_state, 1, &flag, depth+1);
3895 if (! REGTAIL(pRExC_state, ret, tail)) {
3907 SV *sv_dat=reg_scan_name(pRExC_state, REG_RSN_RETURN_DATA);
3917 num = reg_add_data( pRExC_state, STR_WITH_LEN("S"));
3921 ret = reg1node(pRExC_state, GROUPPN, num);
3928 ret = reg1node(pRExC_state, DEFINEP, 0);
3957 sv_dat = reg_scan_name(pRExC_state,
3962 ret = reg1node(pRExC_state, INSUBP, parno);
3979 ret = reg1node(pRExC_state, GROUPP, parno);
3986 nextchar(pRExC_state);
3988 if (! REGTAIL(pRExC_state, ret, reg1node(pRExC_state,
3993 br = regbranch(pRExC_state, &flags, 1, depth+1);
3999 if (! REGTAIL(pRExC_state, br, reg1node(pRExC_state,
4005 nextchar(pRExC_state);
4013 lastbr = reg1node(pRExC_state, IFTHEN, 0);
4015 if (!regbranch(pRExC_state, &flags, 1, depth+1)) {
4020 if (! REGTAIL(pRExC_state, ret, lastbr)) {
4026 nextchar(pRExC_state);
4036 ender = reg_node(pRExC_state, TAIL);
4037 if (! REGTAIL(pRExC_state, br, ender)) {
4041 if (! REGTAIL(pRExC_state, lastbr, ender)) {
4044 if (! REGTAIL(pRExC_state,
4053 if (! REGTAIL(pRExC_state, ret, ender)) {
4067 return handle_regex_sets(pRExC_state, NULL, flagp, depth+1);
4083 parse_lparen_question_flags(pRExC_state);
4086 nextchar(pRExC_state);
4091 nextchar(pRExC_state);
4160 ret = reg1node(pRExC_state, OPEN, parno);
4190 br = regbranch(pRExC_state, &flags, 1, depth+1);
4200 reginsert(pRExC_state, BRANCHJ, br, depth+1);
4205 reginsert(pRExC_state, BRANCH, br, depth+1);
4215 if (! REGTAIL(pRExC_state, ret, br)) { /* OPEN -> first. */
4227 ender = reg1node(pRExC_state, LONGJMP, 0);
4230 shut_gcc_up = REGTAIL(pRExC_state,
4235 nextchar(pRExC_state);
4241 br = regbranch(pRExC_state, &flags, 0, depth+1);
4247 if (! REGTAIL(pRExC_state, lastbr, br)) { /* BRANCH -> BRANCH. */
4276 ender = reg_node(pRExC_state, TAIL);
4279 ender = reg1node(pRExC_state, CLOSE, parno);
4291 ender = reg_node(pRExC_state, SRCLOSE);
4300 ender = reg_node(pRExC_state, LOOKBEHIND_END);
4311 ender = reg_node(pRExC_state, SUCCEED);
4314 ender = reg_node(pRExC_state, END);
4329 regprop(RExC_rx, RExC_mysv1, REGNODE_p(lastbr), NULL, pRExC_state);
4330 regprop(RExC_rx, RExC_mysv2, REGNODE_p(ender), NULL, pRExC_state);
4347 if (! REGTAIL(pRExC_state, lastbr, ender)) {
4361 if (! REGTAIL_STUDY(pRExC_state,
4372 bool shut_gcc_up = REGTAIL_STUDY(pRExC_state,
4392 NULL, pRExC_state);
4394 NULL, pRExC_state);
4431 reginsert(pRExC_state, node, ret, depth+1);
4433 if (! REGTAIL_STUDY(pRExC_state, ret, reg_node(pRExC_state, TAIL)))
4452 nextchar(pRExC_state);
4485 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
4502 ret = reg2node(pRExC_state, BRANCHJ, 0, 0);
4506 ret = reg1node(pRExC_state, BRANCH, 0);
4514 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
4518 latest = regpiece(pRExC_state, &flags, depth+1);
4532 if (! REGTAIL(pRExC_state, chain, latest)) {
4543 chain = reg_node(pRExC_state, NOTHING);
4678 S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state,
4734 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
4753 ret = regatom(pRExC_state, &flags, depth+1);
4765 nextchar(pRExC_state);
4770 nextchar(pRExC_state);
4775 nextchar(pRExC_state);
4788 min = get_quantifier_value(pRExC_state, min_start, min_end);
4803 max = get_quantifier_value(pRExC_state, max_start, max_end);
4807 nextchar(pRExC_state);
4811 reginsert(pRExC_state, OPFAIL, orig_emit, depth+1);
4876 reginsert(pRExC_state, STAR, ret, depth+1);
4881 reginsert(pRExC_state, PLUS, ret, depth+1);
4890 reginsert(pRExC_state, CURLY, ret, depth+1);
4893 const regnode_offset w = reg_node(pRExC_state, WHILEM);
4896 if (! REGTAIL(pRExC_state, ret, w)) {
4900 reginsert(pRExC_state, LONGJMP, ret, depth+1);
4901 reginsert(pRExC_state, NOTHING, ret, depth+1);
4904 reginsert(pRExC_state, CURLYX, ret, depth+1);
4909 if (! REGTAIL(pRExC_state, ret, reg_node(pRExC_state,
4939 nextchar(pRExC_state);
4940 reginsert(pRExC_state, MINMOD, ret, depth+1);
4941 if (! REGTAIL(pRExC_state, ret, ret + NODE_STEP_REGNODE)) {
4947 nextchar(pRExC_state);
4948 ender = reg_node(pRExC_state, SUCCEED);
4949 if (! REGTAIL(pRExC_state, ret, ender)) {
4952 reginsert(pRExC_state, SUSPEND, ret, depth+1);
4953 ender = reg_node(pRExC_state, TAIL);
4954 if (! REGTAIL(pRExC_state, ret, ender)) {
4988 S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state,
5100 skip_to_be_ignored_text(pRExC_state, &p,
5116 *node_p = reg_node(pRExC_state, REG_ANY);
5153 nextchar(pRExC_state);
5158 *node_p = reg_node(pRExC_state, NOTHING);
5244 nextchar(pRExC_state);
5332 nextchar(pRExC_state);
5417 *node_p = reg(pRExC_state, 1, &flags, depth+1);
5435 nextchar(pRExC_state);
5442 S_compute_EXACTish(RExC_state_t *pRExC_state)
5547 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
5569 nextchar(pRExC_state);
5571 ret = reg_node(pRExC_state, MBOL);
5573 ret = reg_node(pRExC_state, SBOL);
5576 nextchar(pRExC_state);
5580 ret = reg_node(pRExC_state, MEOL);
5582 ret = reg_node(pRExC_state, SEOL);
5585 nextchar(pRExC_state);
5587 ret = reg_node(pRExC_state, SANY);
5589 ret = reg_node(pRExC_state, REG_ANY);
5596 ret = regclass(pRExC_state, flagp, depth+1,
5612 nextchar(pRExC_state);
5616 nextchar(pRExC_state);
5617 ret = reg(pRExC_state, 2, &flags, depth+1);
5669 ret = reg_node(pRExC_state, MBOL);
5672 ret = reg_node(pRExC_state, SBOL);
5687 ret = reg_node(pRExC_state, GPOS);
5693 ret = reg_node(pRExC_state, KEEPS);
5708 ret = reg_node(pRExC_state, MEOL);
5711 ret = reg_node(pRExC_state, SEOL);
5718 ret = reg_node(pRExC_state, MEOL);
5721 ret = reg_node(pRExC_state, EOS);
5728 ret = reg_node(pRExC_state, CLUMP);
5846 ret = reg_node(pRExC_state, op);
5853 ret = reg_node(pRExC_state, LNBREAK);
5874 ret = regclass(pRExC_state, flagp, depth+1,
5903 nextchar(pRExC_state);
5918 if (grok_bslash_N(pRExC_state,
5956 ret = handle_named_backref(pRExC_state,
6133 ret = reg2node(pRExC_state,
6151 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
6174 RExC_parse_set( reg_skipcomment( pRExC_state, RExC_parse ) );
6263 ret = REGNODE_GUTS(pRExC_state, node_type, current_string_nodes);
6378 if (! grok_bslash_N(pRExC_state,
6644 skip_to_be_ignored_text(pRExC_state, &p,
6755 node_type = compute_EXACTish(pRExC_state);
6957 change_engine_size(pRExC_state, delta + overhead_expansion);
7400 change_engine_size(pRExC_state,
7524 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
7646 S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state,
8453 S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV** return_invlist,
8580 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
8592 DEBUG_U(dump_regex_sets_structures(pRExC_state,
8634 node = reg(pRExC_state, 2, flagp, depth+1);
8683 if (!regclass(pRExC_state, flagp, depth+1,
8706 < handle_possible_posix(pRExC_state,
8720 if (!regclass(pRExC_state, flagp, depth+1,
9042 node = regpnode(pRExC_state, REGEX_SET, final);
9074 node = regclass(pRExC_state, flagp, depth+1,
9130 nextchar(pRExC_state);
9141 S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state,
9197 Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist)
9287 S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings)
9401 S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth,
9582 int maybe_class = handle_possible_posix(pRExC_state,
9621 output_posix_warnings(pRExC_state, posix_warnings);
9658 namedclass = handle_possible_posix(pRExC_state,
9689 pRExC_state,
9750 if (! grok_bslash_N(pRExC_state,
10657 output_posix_warnings(pRExC_state, posix_warnings);
10753 ret = reg(pRExC_state, 1, ®_flags, depth+1);
10847 add_above_Latin1_folds(pRExC_state,
11183 op = optimize_regclass(pRExC_state, cp_list,
11219 ret = REGNODE_GUTS(pRExC_state, op, REGNODE_ARG_LEN(op));
11257 set_ANYOF_arg(pRExC_state, REGNODE_p(ret), cp_list,
11270 RExC_state_t *pRExC_state,
11404 *ret = reg_node(pRExC_state, op);
11437 *ret = reg_node(pRExC_state, op);
11753 *ret = REGNODE_GUTS(pRExC_state, op, len);
11868 *ret = reg1node(pRExC_state, op, lowest_cp);
12007 *ret = reg_node(pRExC_state, op);
12039 *ret = reg1node(pRExC_state, op,
12123 *ret = REGNODE_GUTS(pRExC_state, op, REGNODE_ARG_LEN(op));
12148 *ret = REGNODE_GUTS(pRExC_state, op,
12157 set_ANYOF_arg(pRExC_state, REGNODE_p(*ret), cp_list,
12196 *ret = reg1node(pRExC_state, op, 0);
12201 *ret = reg_node(pRExC_state, op);
12210 Perl_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state,
12361 n = reg_add_data(pRExC_state, STR_WITH_LEN("s"));
12634 S_reg_skipcomment(RExC_state_t *pRExC_state, char* p)
12653 S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state,
12692 (*p) = reg_skipcomment(pRExC_state, (*p));
12720 S_nextchar(pTHX_ RExC_state_t *pRExC_state)
12731 skip_to_be_ignored_text(pRExC_state, &RExC_parse,
12737 S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size)
12763 S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const STRLEN extra_size)
12776 change_engine_size(pRExC_state, (Ptrdiff_t) 1 + extra_size);
12784 S_regnode_guts_debug(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_size) {
12787 return S_regnode_guts(aTHX_ pRExC_state, extra_size);
12798 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
12800 const regnode_offset ret = REGNODE_GUTS(pRExC_state, op, REGNODE_ARG_LEN(op));
12816 S_reg1node(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
12818 const regnode_offset ret = REGNODE_GUTS(pRExC_state, op, REGNODE_ARG_LEN(op));
12835 S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV * arg)
12837 const regnode_offset ret = REGNODE_GUTS(pRExC_state, op, REGNODE_ARG_LEN(op));
12848 S_reg2node(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2)
12852 const regnode_offset ret = REGNODE_GUTS(pRExC_state, op, REGNODE_ARG_LEN(op));
12879 S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op,
12896 change_engine_size(pRExC_state, (Ptrdiff_t) size);
12952 S_regtail(pTHX_ RExC_state_t * pRExC_state,
12972 regprop(RExC_rx, RExC_mysv, REGNODE_p(scan), NULL, pRExC_state);
13026 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p,
13047 if (join_exact(pRExC_state, scan, &min,
13065 regprop(RExC_rx, RExC_mysv, REGNODE_p(scan), NULL, pRExC_state);
13077 regprop(RExC_rx, RExC_mysv, REGNODE_p(val), NULL, pRExC_state);