Lines Matching defs:prog
850 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char *strend,
863 regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
944 struct regexp *const prog = ReANY(rx);
945 SSize_t start_shift = prog->check_offset_min;
952 U8 other_ix = 1 - prog->substrs->check_ix;
956 const I32 multiline = prog->extflags & RXf_PMf_MULTILINE;
957 RXi_GET_DECL(prog,progi);
975 assert(prog->substrs->data[0].min_offset >= 0);
976 assert(prog->substrs->data[0].max_offset >= 0);
977 assert(prog->substrs->data[1].min_offset >= 0);
978 assert(prog->substrs->data[1].max_offset >= 0);
979 assert(prog->substrs->data[2].min_offset >= 0);
980 assert(prog->substrs->data[2].max_offset >= 0);
989 ! ( (prog->anchored_utf8 || prog->anchored_substr)
990 && (prog->float_utf8 || prog->float_substr))
991 || (prog->float_min_offset >= prog->anchored_offset));
996 if (prog->minlen > strend - strpos) {
1002 RXp_MATCH_UTF8_set(prog, utf8_target);
1013 if ((!prog->anchored_utf8 && prog->anchored_substr)
1014 || (!prog->float_utf8 && prog->float_substr))
1015 to_utf8_substr(prog);
1016 check = prog->check_utf8;
1018 if (!prog->check_substr && prog->check_utf8) {
1019 if (! to_byte_substr(prog)) {
1023 check = prog->check_substr;
1030 SV *sv = (utf8_target ? prog->substrs->data[i].utf8_substr
1031 : prog->substrs->data[i].substr);
1039 (IV)prog->substrs->data[i].min_offset,
1040 (IV)prog->substrs->data[i].max_offset,
1041 (IV)prog->substrs->data[i].end_shift,
1048 if (prog->intflags & PREGf_ANCH) { /* Match at \G, beg-of-str or after \n */
1058 ml_anch = (prog->intflags & PREGf_ANCH_MBOL)
1059 && !(prog->intflags & PREGf_IMPLICIT);
1061 if (!ml_anch && !(prog->intflags & PREGf_IMPLICIT)) {
1073 && (prog->intflags & PREGf_ANCH_SBOL))
1090 if (prog->check_offset_min == prog->check_offset_max) {
1093 char *s = HOP3c(strpos, prog->check_offset_min, strend);
1097 (IV)prog->check_offset_min));
1131 end_shift = prog->check_end_shift;
1176 (IV)prog->check_offset_min,
1179 (IV)prog->check_end_shift);
1199 && prog->intflags & PREGf_ANCH
1200 && prog->check_offset_max != SSize_t_MAX)
1204 (prog->intflags & PREGf_ANCH_GPOS ? strpos : strbeg);
1218 if (prog->check_offset_max + check_len < targ_len) {
1220 prog->check_offset_max,
1247 (check == (utf8_target ? prog->anchored_utf8 : prog->anchored_substr)
1261 if (check_at - rx_origin > prog->check_offset_max)
1262 rx_origin = HOP3c(check_at, -prog->check_offset_max, rx_origin);
1274 if (prog->substrs->data[other_ix].utf8_substr
1275 || prog->substrs->data[other_ix].substr)
1284 other = &prog->substrs->data[other_ix];
1286 if (!to_byte_substr(prog)) {
1308 * strend - prog->minlen (in chars) is the absolute latest
1337 * to CHR_SVLEN(must) - !!SvTAIL(must) + prog->float_end_shift
1340 assert(prog->minlen >= other->min_offset);
1342 other->min_offset - prog->minlen, strbeg);
1472 (IV)prog->check_offset_min,
1473 (IV)prog->check_offset_max,
1505 s = HOP3c(strend, - prog->minlen, strpos);
1520 if (prog->substrs->check_ix == 0 /* check is anchored */
1521 || rx_origin >= HOP3c(check_at, - prog->check_offset_min, strpos))
1535 assert(prog->substrs->check_ix); /* check is float */
1537 if (utf8_target ? prog->anchored_utf8 : prog->anchored_substr) {
1545 (IV)(rx_origin - strbeg + prog->anchored_offset),
1607 if (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
1608 endpos = HOP3clim(rx_origin, (prog->minlen ? cl_l : 0), strend);
1609 else if (prog->float_substr || prog->float_utf8) {
1622 s = find_byclass(prog, progi->regstclass, rx_origin, endpos,
1632 if ((prog->intflags & PREGf_ANCH) && !ml_anch
1633 && !(prog->intflags & PREGf_IMPLICIT))
1637 if (prog->anchored_substr || prog->anchored_utf8) {
1638 if (prog->substrs->check_ix == 1) { /* check is float */
1681 if (!(utf8_target ? prog->float_utf8 : prog->float_substr))
1702 (prog->substrs->check_ix ? "floating" : "anchored"),
1731 ++BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr); /* hooray/5 */
1738 if (!(prog->intflags & PREGf_NAUGHTY)
1740 prog->check_utf8 /* Could be deleted already */
1741 && --BmUSEFUL(prog->check_utf8) < 0
1742 && (prog->check_utf8 == prog->float_utf8)
1744 prog->check_substr /* Could be deleted already */
1745 && --BmUSEFUL(prog->check_substr) < 0
1746 && (prog->check_substr == prog->float_substr)
1752 SvREFCNT_dec(utf8_target ? prog->check_utf8 : prog->check_substr);
1753 SvREFCNT_dec(utf8_target ? prog->check_substr : prog->check_utf8);
1754 prog->check_substr = prog->check_utf8 = NULL; /* disable */
1755 prog->float_substr = prog->float_utf8 = NULL; /* clear */
1760 prog->extflags &= ~RXf_USE_INTUIT;
1771 if (prog->check_substr || prog->check_utf8) /* could be removed already */
1772 BmUSEFUL(utf8_target ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
1884 #define GET_ANYOFH_INVLIST(prog, n) \
1885 GET_REGCLASS_AUX_DATA(prog, n, TRUE, 0, NULL, NULL)
2263 S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
2268 const I32 doevery = (prog->intflags & PREGf_SKIP) == 0;
2296 RXi_GET_DECL(prog,progi);
2321 reginclass(prog, c, (U8*)s, (U8*) strend, 1 /* is utf8 */));
2344 REXEC_FBC_NON_UTF8_CLASS_SCAN(reginclass(prog,c, (U8*)s, (U8*)s+1,
2398 anyofh_list = GET_ANYOFH_INVLIST(prog, c);
2413 anyofh_list = GET_ANYOFH_INVLIST(prog, c);
2438 anyofh_list = GET_ANYOFH_INVLIST(prog, c);
2451 anyofh_list = GET_ANYOFH_INVLIST(prog, c);
3510 struct regexp *const prog = ReANY(rx);
3521 if (( RXp_SAVED_COPY(prog)
3522 && SvIsCOW(RXp_SAVED_COPY(prog))
3523 && SvPOKp(RXp_SAVED_COPY(prog))
3526 && SvPVX(sv) == SvPVX(RXp_SAVED_COPY(prog))))
3529 if (RXp_MATCH_COPIED(prog)) {
3530 Safefree(RXp_SUBBEG(prog));
3531 RXp_MATCH_COPIED_off(prog);
3536 RXp_MATCH_COPY_FREE(prog);
3537 RXp_SAVED_COPY(prog) = sv_setsv_cow(RXp_SAVED_COPY(prog), sv);
3539 RXp_SUBBEG(prog) = (char *)SvPVX_const(RXp_SAVED_COPY(prog));
3540 assert (SvPOKp(RXp_SAVED_COPY(prog)));
3541 RXp_SUBLEN(prog) = strend - strbeg;
3542 RXp_SUBOFFSET(prog) = 0;
3543 RXp_SUBCOFFSET(prog) = 0;
3556 && !(prog->extflags & RXf_PMf_KEEPCOPY) /* //p */
3565 while (n <= RXp_LASTPAREN(prog)) {
3566 if ((offs_end = RXp_OFFS_END(prog,n)) > max)
3572 ? RXp_OFFS_START(prog,0)
3581 && !(prog->extflags & RXf_PMf_KEEPCOPY) /* //p */
3589 while (min && n <= RXp_LASTPAREN(prog)) {
3590 SSize_t start = RXp_OFFS_START(prog,n);
3599 SSize_t end = RXp_OFFS_END(prog,0);
3608 if (RXp_MATCH_COPIED(prog)) {
3609 if (sublen > RXp_SUBLEN(prog))
3610 RXp_SUBBEG(prog) =
3611 (char*)saferealloc(RXp_SUBBEG(prog), sublen+1);
3614 RXp_SUBBEG(prog) = (char*)safemalloc(sublen+1);
3615 Copy(strbeg + min, RXp_SUBBEG(prog), sublen, char);
3616 RXp_SUBBEG(prog)[sublen] = '\0';
3617 RXp_SUBOFFSET(prog) = min;
3618 RXp_SUBLEN(prog) = sublen;
3619 RXp_MATCH_COPIED_on(prog);
3621 RXp_SUBCOFFSET(prog) = RXp_SUBOFFSET(prog);
3622 if (RXp_SUBOFFSET(prog) && utf8_target) {
3638 RXp_SUBCOFFSET(prog) = sv_pos_b2u_flags(sv, RXp_SUBCOFFSET(prog),
3641 RXp_SUBCOFFSET(prog) = utf8_length((U8*)strbeg,
3642 (U8*)(strbeg+RXp_SUBOFFSET(prog)));
3646 RXp_MATCH_COPY_FREE(prog);
3647 RXp_SUBBEG(prog) = strbeg;
3648 RXp_SUBOFFSET(prog) = 0;
3649 RXp_SUBCOFFSET(prog) = 0;
3650 RXp_SUBLEN(prog) = strend - strbeg;
3674 struct regexp *const prog = ReANY(rx);
3682 RXi_GET_DECL(prog,progi);
3693 if (prog == NULL) {
3709 if (prog->intflags & PREGf_GPOS_SEEN) {
3727 * if prog->gofs is set, then that's a known, fixed minimum
3735 if (prog->intflags & PREGf_ANCH_GPOS) {
3736 if (prog->gofs) {
3737 startpos = HOPBACKc(reginfo->ganch, prog->gofs);
3749 else if (prog->gofs) {
3750 startpos = HOPBACKc(startpos, prog->gofs);
3754 else if (prog->intflags & PREGf_GPOS_FLOAT)
3758 minlen = prog->minlen;
3774 if ((prog->extflags & RXf_USE_INTUIT)
3782 if (prog->extflags & RXf_CHECK_ALL) {
3786 assert(!prog->nparens);
3794 assert(prog->intflags & PREGf_GPOS_SEEN);
3802 RXp_LASTPAREN(prog) = RXp_LASTCLOSEPAREN(prog) = 0;
3803 RXp_MATCH_UTF8_set(prog, utf8_target);
3806 ? (char*)utf8_hop_forward((U8*)s, prog->minlenret, (U8 *) strend) - strbeg
3807 : s - strbeg + prog->minlenret;
3808 CLOSE_ANY_CAPTURE(prog, 0, match_start, match_end);
3818 multiline = prog->extflags & RXf_PMf_MULTILINE;
3820 if (strend - s < (minlen+(prog->check_offset_min<0?prog->check_offset_min:0))) {
3831 RXp_MATCH_TAINTED_off(prog);
3832 RXp_MATCH_UTF8_set(prog, utf8_target);
3834 reginfo->prog = rx; /* Yes, sorry that this is confusing. */
3843 if (prog->extflags & RXf_EVAL_SEEN && SvPADTMP(sv)) {
3865 int i, max = (prog->extflags & RXf_EVAL_SEEN) ? 2 : 1;
3899 if ((prog->extflags & RXf_EVAL_SEEN))
3913 swap = RXp_OFFSp(prog);
3916 Newxz(RXp_OFFSp(prog), (prog->nparens + 1), regexp_paren_pair);
3920 PTR2UV(prog),
3922 PTR2UV(RXp_OFFSp(prog))
3926 if (prog->recurse_locinput)
3927 Zero(prog->recurse_locinput,prog->nparens + 1, char *);
3938 if (prog->intflags & (PREGf_ANCH & ~PREGf_ANCH_GPOS)) {
3944 if (!(prog->intflags & PREGf_ANCH_MBOL))
3959 if (prog->check_substr || prog->check_utf8) {
3975 if (prog->intflags & PREGf_ANCH_GPOS)
3978 assert(prog->intflags & PREGf_GPOS_SEEN);
3982 assert(startpos == HOPBACKc(reginfo->ganch, prog->gofs));
3990 if ((prog->anchored_substr || prog->anchored_utf8) && prog->intflags & PREGf_SKIP) {
3998 if (! prog->anchored_utf8) {
3999 to_utf8_substr(prog);
4001 ch = SvPVX_const(prog->anchored_utf8)[0];
4014 if (! prog->anchored_substr) {
4015 if (! to_byte_substr(prog)) {
4019 ch = SvPVX_const(prog->anchored_substr)[0];
4035 else if (prog->anchored_substr != NULL
4036 || prog->anchored_utf8 != NULL
4037 || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
4038 && prog->float_max_offset < strend - s)) {
4047 if (prog->anchored_substr || prog->anchored_utf8) {
4049 if (! prog->anchored_utf8) {
4050 to_utf8_substr(prog);
4052 must = prog->anchored_utf8;
4055 if (! prog->anchored_substr) {
4056 if (! to_byte_substr(prog)) {
4060 must = prog->anchored_substr;
4062 back_max = back_min = prog->anchored_offset;
4065 if (! prog->float_utf8) {
4066 to_utf8_substr(prog);
4068 must = prog->float_utf8;
4071 if (! prog->float_substr) {
4072 if (! to_byte_substr(prog)) {
4076 must = prog->float_substr;
4078 back_max = prog->float_max_offset;
4079 back_min = prog->float_min_offset;
4137 ((must == prog->anchored_substr || must == prog->anchored_utf8)
4152 regprop(prog, prop, c, reginfo, NULL);
4162 if (find_byclass(prog, c, s, strend, reginfo))
4168 if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
4176 if (! prog->float_utf8) {
4177 to_utf8_substr(prog);
4179 float_real = prog->float_utf8;
4182 if (! prog->float_substr) {
4183 if (! to_byte_substr(prog)) {
4187 float_real = prog->float_substr;
4263 dontbother = strend - last + prog->float_min_offset;
4293 && (RXp_OFFS_START(prog,0) < stringarg - strbeg))
4296 assert(prog->intflags & PREGf_GPOS_SEEN);
4308 if (RXp_PAREN_NAMES(prog))
4309 (void)hv_iterinit(RXp_PAREN_NAMES(prog));
4332 PTR2UV(prog),
4333 PTR2UV(RXp_OFFSp(prog)),
4337 Copy(swap, RXp_OFFSp(prog), prog->nparens + 1, regexp_paren_pair);
4373 REGEXP *const rx = reginfo->prog;
4374 regexp *const prog = ReANY(rx);
4379 RXi_GET_DECL(prog,progi);
4386 RXp_OFFSp(prog)[0].start = *startposp - reginfo->strbeg;
4387 RXp_LASTPAREN(prog) = 0;
4388 RXp_LASTCLOSEPAREN(prog) = 0;
4391 to do this again and again, RXp_LASTPAREN(prog) should take care of
4396 * RXp_LASTPAREN(prog)), is not needed at all by the test suite
4412 if (prog->nparens) {
4413 regexp_paren_pair *pp = RXp_OFFSp(prog);
4415 for (i = prog->nparens; i > (I32)RXp_LASTPAREN(prog); i--) {
4425 RXp_OFFSp(prog)[0].end = result;
4476 S_debug_start_match(pTHX_ const REGEXP *prog, const bool utf8_target,
4479 const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
4487 RX_PRECOMP_const(prog), RX_PRELEN(prog), PL_dump_re_max_len);
6440 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
6444 REGEXP *rex_sv = reginfo->prog;
6543 scan = prog;
10227 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p,
10491 && reginclass(prog, p, (U8*)scan, (U8*) this_eol, TRUE))
10508 && reginclass(prog, p, (U8*)scan, (U8*)scan+1, 0))
10555 anyofh_list = GET_ANYOFH_INVLIST(prog, p);
10571 anyofh_list = GET_ANYOFH_INVLIST(prog, p);
10598 anyofh_list = GET_ANYOFH_INVLIST(prog, p);
10616 anyofh_list = GET_ANYOFH_INVLIST(prog, p);
10878 regprop(prog, prop, p, reginfo, NULL);
10905 S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const p, const U8* const p_end, const bool utf8_target)
11034 SV * const definition = GET_REGCLASS_AUX_DATA(prog, n, TRUE, 0,
11223 regexp *const rex = ReANY(reginfo->prog);
11267 SET_reg_curpm(reginfo->prog);
11351 S_to_utf8_substr(pTHX_ regexp *prog)
11353 /* Converts substr fields in prog from bytes to UTF-8, calling fbm_compile
11361 if (prog->substrs->data[i].substr
11362 && !prog->substrs->data[i].utf8_substr) {
11363 SV* const sv = newSVsv(prog->substrs->data[i].substr);
11364 prog->substrs->data[i].utf8_substr = sv;
11366 if (SvVALID(prog->substrs->data[i].substr)) {
11367 if (SvTAIL(prog->substrs->data[i].substr)) {
11378 if (prog->substrs->data[i].substr == prog->check_substr)
11379 prog->check_utf8 = sv;
11385 S_to_byte_substr(pTHX_ regexp *prog)
11387 /* Converts substr fields in prog from UTF-8 to bytes, calling fbm_compile
11395 if (prog->substrs->data[i].utf8_substr
11396 && !prog->substrs->data[i].substr) {
11397 SV* sv = newSVsv(prog->substrs->data[i].utf8_substr);
11402 if (SvVALID(prog->substrs->data[i].utf8_substr)) {
11403 if (SvTAIL(prog->substrs->data[i].utf8_substr)) {
11411 prog->substrs->data[i].substr = sv;
11412 if (prog->substrs->data[i].utf8_substr == prog->check_utf8)
11413 prog->check_substr = sv;