dVAR;
U32 i;
char *input;
-
GET_RE_DEBUG_FLAGS_DECL;
+ PERL_ARGS_ASSERT_REGCPPOP;
+
/* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
i = SSPOPINT;
assert(i == SAVEt_REGCONTEXT); /* Check that the magic cookie is there. */
/* minend: end of match must be >=minend after stringarg. */
/* nosave: For optimizations. */
{
+ PERL_ARGS_ASSERT_PREGEXEC;
+
return
regexec_flags(prog, stringarg, strend, strbeg, minend, screamer, NULL,
nosave ? 0 : REXEC_COPY_STR);
#ifdef DEBUGGING
const char * const i_strpos = strpos;
#endif
-
GET_RE_DEBUG_FLAGS_DECL;
+ PERL_ARGS_ASSERT_RE_INTUIT_START;
+
RX_MATCH_UTF8_set(rx,do_utf8);
- if (prog->extflags & RXf_UTF8) {
+ if (RX_UTF8(rx)) {
PL_reg_flags |= RF_utf8;
}
DEBUG_EXECUTE_r(
register I32 tmp = 1; /* Scratch variable? */
register const bool do_utf8 = PL_reg_match_utf8;
RXi_GET_DECL(prog,progi);
+
+ PERL_ARGS_ASSERT_FIND_BYCLASS;
/* We know what class it must start with. */
switch (OP(c)) {
}
static void
-S_swap_match_buff (pTHX_ regexp *prog) {
+S_swap_match_buff (pTHX_ regexp *prog)
+{
regexp_paren_pair *t;
+ PERL_ARGS_ASSERT_SWAP_MATCH_BUFF;
+
if (!prog->swap) {
/* We have to be careful. If the previous successful match
was from this regex we don't want a subsequent paritally
RXi_GET_DECL(prog,progi);
regmatch_info reginfo; /* create some info to pass to regtry etc */
bool swap_on_fail = 0;
-
GET_RE_DEBUG_FLAGS_DECL;
+ PERL_ARGS_ASSERT_REGEXEC_FLAGS;
PERL_UNUSED_ARG(data);
/* Be paranoid... */
PL_reg_eval_set = 0;
PL_reg_maxiter = 0;
- if (prog->extflags & RXf_UTF8)
+ if (RX_UTF8(rx))
PL_reg_flags |= RF_utf8;
/* Mark beginning of line for ^ and lookbehind. */
if (PL_reg_eval_set)
restore_pos(aTHX_ prog);
- if (prog->paren_names)
- (void)hv_iterinit(prog->paren_names);
+ if (RXp_PAREN_NAMES(prog))
+ (void)hv_iterinit(RXp_PAREN_NAMES(prog));
/* make sure $`, $&, $', and $digit will work later */
if ( !(flags & REXEC_NOT_FIRST) ) {
regexp *const prog = (struct regexp *)SvANY(rx);
RXi_GET_DECL(prog,progi);
GET_RE_DEBUG_FLAGS_DECL;
+
+ PERL_ARGS_ASSERT_REGTRY;
+
reginfo->cutpoint=NULL;
if ((prog->extflags & RXf_EVAL_SEEN) && !PL_reg_eval_set) {
Newxz(PL_reg_curpm, 1, PMOP);
#ifdef USE_ITHREADS
{
- SV* const repointer = newSViv(0);
- /* so we know which PL_regex_padav element is PL_reg_curpm */
- SvFLAGS(repointer) |= SVf_BREAK;
- av_push(PL_regex_padav,repointer);
+ SV* const repointer = &PL_sv_undef;
+ /* this regexp is also owned by the new PL_reg_curpm, which
+ will try to free it. */
+ av_push(PL_regex_padav, repointer);
PL_reg_curpm->op_pmoffset = av_len(PL_regex_padav);
PL_regex_pad = AvARRAY(PL_regex_padav);
}
#endif
}
+#ifdef USE_ITHREADS
+ /* It seems that non-ithreads works both with and without this code.
+ So for efficiency reasons it seems best not to have the code
+ compiled when it is not needed. */
+ /* This is safe against NULLs: */
+ ReREFCNT_dec(PM_GETRE(PL_reg_curpm));
+ /* PM_reg_curpm owns a reference to this regexp. */
+ ReREFCNT_inc(rx);
+#endif
PM_SETRE(PL_reg_curpm, rx);
PL_reg_oldcurpm = PL_curpm;
PL_curpm = PL_reg_curpm;
const char *start, const char *end, const char *blurb)
{
const bool utf8_pat = RX_UTF8(prog) ? 1 : 0;
+
+ PERL_ARGS_ASSERT_DEBUG_START_MATCH;
+
if (!PL_colorset)
reginitcolors();
{
? (5 + taill) - l : locinput - loc_bostr;
int pref0_len;
+ PERL_ARGS_ASSERT_DUMP_EXEC_POS;
+
while (do_utf8 && UTF8_IS_CONTINUATION(*(U8*)(locinput - pref_len)))
pref_len++;
pref0_len = pref_len - (locinput - loc_reg_starttry);
* or 0 if non of the buffers matched.
*/
STATIC I32
-S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) {
+S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
+{
I32 n;
RXi_GET_DECL(rex,rexi);
SV *sv_dat=(SV*)rexi->data->data[ ARG( scan ) ];
I32 *nums=(I32*)SvPVX(sv_dat);
+
+ PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED;
+
for ( n=0; n<SvIVX(sv_dat); n++ ) {
if ((I32)*PL_reglastparen >= nums[n] &&
PL_regoffs[nums[n]].end != -1)
dVAR;
register const bool do_utf8 = PL_reg_match_utf8;
const U32 uniflags = UTF8_ALLOW_DEFAULT;
-
REGEXP *rex_sv = reginfo->prog;
regexp *rex = (struct regexp *)SvANY(rex_sv);
RXi_GET_DECL(rex,rexi);
-
I32 oldsave;
-
/* the current state. This is a cached copy of PL_regmatch_state */
register regmatch_state *st;
-
/* cache heavy used fields of st in registers */
register regnode *scan;
register regnode *next;
const U32 max_nochange_depth =
(3 * rex->nparens > MAX_RECURSE_EVAL_NOCHANGE_DEPTH) ?
3 * rex->nparens : MAX_RECURSE_EVAL_NOCHANGE_DEPTH;
-
regmatch_state *yes_state = NULL; /* state to pop to on success of
subpattern */
/* mark_state piggy backs on the yes_state logic so that when we unwind
the stack on success we can update the mark_state as we go */
regmatch_state *mark_state = NULL; /* last mark state we have seen */
-
regmatch_state *cur_eval = NULL; /* most recent EVAL_AB state */
struct regmatch_state *cur_curlyx = NULL; /* most recent curlyx */
U32 state_num;
during a successfull match */
U32 lastopen = 0; /* last open we saw */
bool has_cutgroup = RX_HAS_CUTGROUP(rex) ? 1 : 0;
-
SV* const oreplsv = GvSV(PL_replgv);
-
-
/* these three flags are set by various ops to signal information to
* the very next op. They have a useful lifetime of exactly one loop
* iteration, and are not preserved or restored by state pushes/pops
false: plain (?=foo)
true: used as a condition: (?(?=foo))
*/
-
#ifdef DEBUGGING
GET_RE_DEBUG_FLAGS_DECL;
#endif
+ PERL_ARGS_ASSERT_REGMATCH;
+
DEBUG_OPTIMISE_r( DEBUG_EXECUTE_r({
PerlIO_printf(Perl_debug_log,"regmatch start\n");
}));
#define ST st->u.eval
{
SV *ret;
- SV *re_sv;
+ REGEXP *re_sv;
regexp *re;
regexp_internal *rei;
regnode *startpoint;
SV *const sv = SvRV(ret);
if (SvTYPE(sv) == SVt_REGEXP) {
- rx = sv;
+ rx = (REGEXP*) sv;
} else if (SvSMAGICAL(sv)) {
mg = mg_find(sv, PERL_MAGIC_qr);
assert(mg);
}
} else if (SvTYPE(ret) == SVt_REGEXP) {
- rx = ret;
+ rx = (REGEXP*) ret;
} else if (SvSMAGICAL(ret)) {
if (SvGMAGICAL(ret)) {
/* I don't believe that there is ever qr magic
}
if (mg) {
- rx = mg->mg_obj; /*XXX:dmq*/
- assert(re);
+ rx = (REGEXP *) mg->mg_obj; /*XXX:dmq*/
+ assert(rx);
}
if (rx) {
rx = reg_temp_copy(rx);
U32 pm_flags = 0;
const I32 osize = PL_regsize;
- if (DO_UTF8(ret)) pm_flags |= RXf_UTF8;
+ if (DO_UTF8(ret)) {
+ assert (SvUTF8(ret));
+ } else if (SvUTF8(ret)) {
+ /* Not doing UTF-8, despite what the SV says. Is
+ this only if we're trapped in use 'bytes'? */
+ /* Make a copy of the octet sequence, but without
+ the flag on, as the compiler now honours the
+ SvUTF8 flag on ret. */
+ STRLEN len;
+ const char *const p = SvPV(ret, len);
+ ret = newSVpvn_flags(p, len, SVs_TEMP);
+ }
rx = CALLREGCOMP(ret, pm_flags);
if (!(SvFLAGS(ret)
& (SVs_TEMP | SVs_PADTMP | SVf_READONLY
/* This isn't a first class regexp. Instead, it's
caching a regexp onto an existing, Perl visible
scalar. */
- sv_magic(ret, rx, PERL_MAGIC_qr, 0, 0);
+ sv_magic(ret, (SV*) rx, PERL_MAGIC_qr, 0, 0);
}
PL_regsize = osize;
}
PL_regoffs = re->offs; /* essentially NOOP on GOSUB */
- *PL_reglastparen = 0;
- *PL_reglastcloseparen = 0;
+ /* see regtry, specifically PL_reglast(?:close)?paren is a pointer! (i dont know why) :dmq */
+ PL_reglastparen = &re->lastparen;
+ PL_reglastcloseparen = &re->lastcloseparen;
+ re->lastparen = 0;
+ re->lastcloseparen = 0;
+
PL_reginput = locinput;
PL_regsize = 0;
PL_reg_maxiter = 0;
ST.toggle_reg_flags = PL_reg_flags;
- if (re->extflags & RXf_UTF8)
+ if (RX_UTF8(re_sv))
PL_reg_flags |= RF_utf8;
else
PL_reg_flags &= ~RF_utf8;
regcpblow(ST.cp);
cur_eval = ST.prev_eval;
cur_curlyx = ST.prev_curlyx;
+
+ PL_reglastparen = &rex->lastparen;
+ PL_reglastcloseparen = &rex->lastcloseparen;
+
/* XXXX This is too dramatic a measure... */
PL_reg_maxiter = 0;
if ( nochange_depth )
SETREX(rex_sv,ST.prev_rex);
rex = (struct regexp *)SvANY(rex_sv);
rexi = RXi_GET(rex);
+ PL_reglastparen = &rex->lastparen;
+ PL_reglastcloseparen = &rex->lastcloseparen;
+
PL_reginput = locinput;
REGCP_UNWIND(ST.lastcp);
regcppop(rex);
PERL_UNUSED_ARG(depth);
#endif
+ PERL_ARGS_ASSERT_REGREPEAT;
+
scan = PL_reginput;
if (max == REG_INFTY)
max = I32_MAX;
RXi_GET_DECL(prog,progi);
const struct reg_data * const data = prog ? progi->data : NULL;
+ PERL_ARGS_ASSERT_REGCLASS_SWASH;
+
if (data && data->count) {
const U32 n = ARG(node);
STRLEN len = 0;
STRLEN plen;
+ PERL_ARGS_ASSERT_REGINCLASS;
+
if (do_utf8 && !UTF8_IS_INVARIANT(c)) {
c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &len,
(UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV) | UTF8_CHECK_ONLY);
S_reghop3(U8 *s, I32 off, const U8* lim)
{
dVAR;
+
+ PERL_ARGS_ASSERT_REGHOP3;
+
if (off >= 0) {
while (off-- && s < lim) {
/* XXX could check well-formedness here */
S_reghop4(U8 *s, I32 off, const U8* llim, const U8* rlim)
{
dVAR;
+
+ PERL_ARGS_ASSERT_REGHOP4;
+
if (off >= 0) {
while (off-- && s < rlim) {
/* XXX could check well-formedness here */
S_reghopmaybe3(U8* s, I32 off, const U8* lim)
{
dVAR;
+
+ PERL_ARGS_ASSERT_REGHOPMAYBE3;
+
if (off >= 0) {
while (off-- && s < lim) {
/* XXX could check well-formedness here */
S_to_utf8_substr(pTHX_ register regexp *prog)
{
int i = 1;
+
+ PERL_ARGS_ASSERT_TO_UTF8_SUBSTR;
+
do {
if (prog->substrs->data[i].substr
&& !prog->substrs->data[i].utf8_substr) {
{
dVAR;
int i = 1;
+
+ PERL_ARGS_ASSERT_TO_BYTE_SUBSTR;
+
do {
if (prog->substrs->data[i].utf8_substr
&& !prog->substrs->data[i].substr) {