#define CHR_SVLEN(sv) (do_utf8 ? sv_len_utf8(sv) : SvCUR(sv))
#define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
-#define reghop_c(pos,off) ((char*)reghop((U8*)pos, off))
-#define reghopmaybe_c(pos,off) ((char*)reghopmaybe((U8*)pos, off))
-#define HOP(pos,off) (PL_reg_match_utf8 ? reghop((U8*)pos, off) : (U8*)(pos + off))
-#define HOPMAYBE(pos,off) (PL_reg_match_utf8 ? reghopmaybe((U8*)pos, off) : (U8*)(pos + off))
-#define HOPc(pos,off) ((char*)HOP(pos,off))
-#define HOPMAYBEc(pos,off) ((char*)HOPMAYBE(pos,off))
-
-#define HOPBACK(pos, off) ( \
- (PL_reg_match_utf8) \
- ? reghopmaybe((U8*)pos, -off) \
+#define HOPc(pos,off) ((char *)(PL_reg_match_utf8 \
+ ? reghop3((U8*)pos, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr)) \
+ : (U8*)(pos + off)))
+#define HOPBACKc(pos, off) ((char*) \
+ ((PL_reg_match_utf8) \
+ ? reghopmaybe3((U8*)pos, -off, ((U8*)(off < 0 ? PL_regeol : PL_bostr))) \
: (pos - off >= PL_bostr) \
? (U8*)(pos - off) \
- : (U8*)NULL \
+ : (U8*)NULL) \
)
-#define HOPBACKc(pos, off) (char*)HOPBACK(pos, off)
-#define reghop3_c(pos,off,lim) ((char*)reghop3((U8*)pos, off, (U8*)lim))
#define reghopmaybe3_c(pos,off,lim) ((char*)reghopmaybe3((U8*)pos, off, (U8*)lim))
#define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
-#define HOPMAYBE3(pos,off,lim) (PL_reg_match_utf8 ? reghopmaybe3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
#define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
-#define HOPMAYBE3c(pos,off,lim) ((char*)HOPMAYBE3(pos,off,lim))
#define LOAD_UTF8_CHARCLASS(class,str) STMT_START { \
if (!CAT2(PL_utf8_,class)) { bool ok; ENTER; save_re_context(); ok=CAT2(is_utf8_,class)((const U8*)str); assert(ok); LEAVE; } } STMT_END
(IV)(cp), (IV)PL_savestack_ix) : 0); regcpblow(cp)
STATIC char *
-S_regcppop(pTHX)
+S_regcppop(pTHX_ const regexp *rex)
{
dVAR;
I32 i;
- U32 paren = 0;
char *input;
GET_RE_DEBUG_FLAGS_DECL;
for (i -= (REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
i > 0; i -= REGCP_PAREN_ELEMS) {
I32 tmps;
- paren = (U32)SSPOPINT;
+ U32 paren = (U32)SSPOPINT;
PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
PL_regstartp[paren] = SSPOPINT;
tmps = SSPOPINT;
);
}
DEBUG_EXECUTE_r(
- if ((I32)(*PL_reglastparen + 1) <= PL_regnpar) {
+ if ((I32)(*PL_reglastparen + 1) <= rex->nparens) {
PerlIO_printf(Perl_debug_log,
" restoring \\%"IVdf"..\\%"IVdf" to undef\n",
- (IV)(*PL_reglastparen + 1), (IV)PL_regnpar);
+ (IV)(*PL_reglastparen + 1), (IV)rex->nparens);
}
);
#if 1
* building DynaLoader will fail:
* "Error: '*' not in typemap in DynaLoader.xs, line 164"
* --jhi */
- for (paren = *PL_reglastparen + 1; (I32)paren <= PL_regnpar; paren++) {
- if ((I32)paren > PL_regsize)
- PL_regstartp[paren] = -1;
- PL_regendp[paren] = -1;
+ for (i = *PL_reglastparen + 1; i <= rex->nparens; i++) {
+ if (i > PL_regsize)
+ PL_regstartp[i] = -1;
+ PL_regendp[i] = -1;
}
#endif
return input;
}
-typedef struct re_cc_state
-{
- I32 ss;
- regnode *node;
- struct re_cc_state *prev;
- CURCUR *cc;
- regexp *re;
-} re_cc_state;
-
#define regcpblow(cp) LEAVE_SCOPE(cp) /* Ignores regcppush()ed data. */
#define TRYPAREN(paren, n, input, where) { \
nosave ? 0 : REXEC_COPY_STR);
}
-STATIC void
-S_cache_re(pTHX_ regexp *prog)
-{
- dVAR;
- PL_regprecomp = prog->precomp; /* Needed for FAIL. */
-#ifdef DEBUGGING
- PL_regprogram = prog->program;
-#endif
- PL_regnpar = prog->nparens;
- PL_regdata = prog->data;
- PL_reg_re = prog;
-}
/*
* Need to implement the following flags for reg_anch:
: strend);
t = s;
- cache_re(prog);
+ PL_reg_re = prog;
s = find_byclass(prog, prog->regstclass, s, endpos, 1);
if (!s) {
#ifdef DEBUGGING
/* We know what class REx starts with. Try to find this position... */
STATIC char *
-S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32 norun)
+S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, I32 norun)
{
dVAR;
const I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
U8 *sm = (U8 *) m;
U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
- const U32 uniflags = ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY;
+ const U32 uniflags = UTF8_ALLOW_DEFAULT;
to_utf8_lower((U8*)m, tmpbuf1, &ulen1);
to_utf8_upper((U8*)m, tmpbuf2, &ulen2);
UV c, f;
U8 tmpbuf [UTF8_MAXBYTES+1];
STRLEN len, foldlen;
- const U32 uniflags = ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY;
+ const U32 uniflags = UTF8_ALLOW_DEFAULT;
if (c1 == c2) {
/* Upper and lower of 1st char are equal -
* probably not a "letter". */
tmp = '\n';
else {
U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);
- tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
+ tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);
}
tmp = ((OP(c) == BOUND ?
isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
tmp = '\n';
else {
U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);
- tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
+ tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);
}
tmp = ((OP(c) == NBOUND ?
isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
GET_RE_DEBUG_FLAGS_DECL;
PERL_UNUSED_ARG(data);
- RX_MATCH_UTF8_set(prog,do_utf8);
-
- cache_re(prog);
-#ifdef DEBUGGING
- PL_regnarrate = DEBUG_r_TEST;
-#endif
/* Be paranoid... */
if (prog == NULL || startpos == NULL) {
return 0;
}
+ PL_reg_re = prog;
+#ifdef DEBUGGING
+ PL_regnarrate = DEBUG_r_TEST;
+#endif
+
+ RX_MATCH_UTF8_set(prog, do_utf8);
+
minlen = prog->minlen;
if (strend - startpos < minlen) {
DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
/* see how far we have to get to not match where we matched before */
PL_regtill = startpos+minend;
- /* We start without call_cc context. */
- PL_reg_call_cc = 0;
-
/* If there is a "must appear" string, look for it. */
s = startpos;
s = HOPc(s, -back_max);
}
else {
- char *t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
+ char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
last1 = HOPc(s, -back_min);
- s = t;
+ s = t;
}
if (do_utf8) {
while (s <= last1) {
sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
restored, the value remains
the same. */
- restore_pos(aTHX_ 0);
+ restore_pos(aTHX_ prog);
}
/* make sure $`, $&, $', and $digit will work later */
DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
PL_colors[4], PL_colors[5]));
if (PL_reg_eval_set)
- restore_pos(aTHX_ 0);
+ restore_pos(aTHX_ prog);
return 0;
}
S_regtry(pTHX_ regexp *prog, char *startpos)
{
dVAR;
- register I32 i;
register I32 *sp;
register I32 *ep;
CHECKPOINT lastcp;
}
PL_reg_magic = mg;
PL_reg_oldpos = mg->mg_len;
- SAVEDESTRUCTOR_X(restore_pos, 0);
+ SAVEDESTRUCTOR_X(restore_pos, prog);
}
if (!PL_reg_curpm) {
Newxz(PL_reg_curpm, 1, PMOP);
sp = prog->startp;
ep = prog->endp;
if (prog->nparens) {
+ register I32 i;
for (i = prog->nparens; i > (I32)*PL_reglastparen; i--) {
*++sp = -1;
*++ep = -1;
}
#endif
REGCP_SET(lastcp);
- if (regmatch(prog->program + 1)) {
+ if (regmatch(prog, prog->program + 1)) {
prog->endp[0] = PL_reginput - PL_bostr;
return 1;
}
#define POSCACHE_SEEN 1 /* we know what we're caching */
#define POSCACHE_START 2 /* the real cache: this bit maps to pos 0 */
#define CACHEsayYES STMT_START { \
- if (cache_offset | cache_bit) { \
+ if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
PL_reg_poscache[0] |= (1<<POSCACHE_SUCCESS) || (1<<POSCACHE_SEEN); \
else if (!(PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
"%*s (remove success from failure cache)\n", \
REPORT_CODE_OFF+PL_regindent*2, "") \
); \
- PL_reg_poscache[cache_offset] &= ~(1<<cache_bit); \
+ PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
} \
} \
sayYES; \
} STMT_END
#define CACHEsayNO STMT_START { \
- if (cache_offset | cache_bit) { \
+ if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
PL_reg_poscache[0] |= (1<<POSCACHE_SEEN); \
else if ((PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
"%*s (remove failure from success cache)\n", \
REPORT_CODE_OFF+PL_regindent*2, "") \
); \
- PL_reg_poscache[cache_offset] &= ~(1<<cache_bit); \
+ PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
} \
} \
sayNO; \
/* Make sure there is a test for this +1 options in re_tests */
#define TRIE_INITAL_ACCEPT_BUFFLEN 4;
+/* grab a new slab and return the first slot in it */
+
+STATIC regmatch_state *
+S_push_slab(pTHX)
+{
+ regmatch_slab *s = PL_regmatch_slab->next;
+ if (!s) {
+ Newx(s, 1, regmatch_slab);
+ s->prev = PL_regmatch_slab;
+ s->next = NULL;
+ PL_regmatch_slab->next = s;
+ }
+ PL_regmatch_slab = s;
+ return &s->states[0];
+}
/* simulate a recursive call to regmatch */
#define REGMATCH(ns, where) \
- new_scan = (ns); \
- resume_state = resume_##where; \
+ st->scan = scan; \
+ scan = (ns); \
+ st->resume_state = resume_##where; \
goto start_recurse; \
resume_point_##where:
-typedef enum {
- resume_TRIE1,
- resume_TRIE2,
- resume_CURLYX,
- resume_WHILEM1,
- resume_WHILEM2,
- resume_WHILEM3,
- resume_WHILEM4,
- resume_WHILEM5,
- resume_WHILEM6,
- resume_CURLYM1,
- resume_CURLYM2,
- resume_CURLYM3,
- resume_CURLYM4,
- resume_IFMATCH,
- resume_PLUS1,
- resume_PLUS2,
- resume_PLUS3,
- resume_PLUS4,
- resume_END
-} resume_states;
-
-
-struct regmatch_state {
- struct regmatch_state *prev_state;
- resume_states resume_state;
- regnode *scan;
- regnode *next;
- bool minmod;
- bool sw;
- int logical;
- I32 unwind;
- CURCUR *cc;
- char *locinput;
- I32 n;
- I32 ln;
- I32 c1, c2, paren;
- CHECKPOINT cp, lastcp;
- CURCUR *oldcc;
- char *lastloc;
- I32 cache_offset, cache_bit;
- I32 curlym_l;
- I32 matches;
- I32 maxwanted;
- char *e;
- char *old;
- int count;
- re_cc_state *cur_call_cc;
- regexp *end_re;
- reg_trie_accepted *accept_buff;
- U32 accepted;
-
- re_cc_state *reg_call_cc; /* saved value of PL_reg_call_cc */
-};
+/* push a new regex state. Set newst to point to it */
+
+#define PUSH_STATE(newst, resume) \
+ depth++; \
+ DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "PUSH STATE(%d)\n", depth)); \
+ st->scan = scan; \
+ st->next = next; \
+ st->n = n; \
+ st->locinput = locinput; \
+ st->resume_state = resume; \
+ newst = st+1; \
+ if (newst > &(PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1])) \
+ newst = S_push_slab(aTHX); \
+ PL_regmatch_state = newst; \
+ newst->cc = 0; \
+ newst->minmod = 0; \
+ newst->sw = 0; \
+ newst->logical = 0; \
+ newst->unwind = 0; \
+ locinput = PL_reginput; \
+ nextchr = UCHARAT(locinput);
+
+#define POP_STATE \
+ DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "POP STATE(%d)\n", depth)); \
+ depth--; \
+ st--; \
+ if (st < &PL_regmatch_slab->states[0]) { \
+ PL_regmatch_slab = PL_regmatch_slab->prev; \
+ st = &PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1]; \
+ } \
+ PL_regmatch_state = st; \
+ scan = st->scan; \
+ next = st->next; \
+ n = st->n; \
+ locinput = st->locinput; \
+ nextchr = UCHARAT(locinput);
/*
- regmatch - main matching routine
int a = 1, b = 2;
...
while (scan != NULL) {
+ a++; // do stuff with a and b
...
switch (OP(scan)) {
case FOO: {
* Now it looks something like this:
- struct regmatch_state {
+ typedef struct {
int a, b, local;
int resume_state;
- };
+ } regmatch_state;
S_regmatch() {
- int a = 1, b = 2;
- int local;
+ regmatch_state *st = new();
+ int depth=0;
+ st->a++; // do stuff with a and b
...
while (scan != NULL) {
...
switch (OP(scan)) {
case FOO: {
- local = 3;
+ st->local = 3;
...
- resume_state = resume_FOO;
- new_scan = ...;
- goto start_recurse;
- resume_point_FOO:
+ st->scan = scan;
+ scan = ...;
+ st->resume_state = resume_FOO;
+ goto start_recurse; // recurse
- if (result) // recurse
+ resume_point_FOO:
+ if (result)
goto yes;
}
...
}
- start_recurse:
- ...push a, b, local onto the heap
- a = 1; b = 2;
- scan = new_scan;
+ start_recurse:
+ st = new(); push a new state
+ st->a = 1; st->b = 2;
+ depth++;
}
- yes:
+ yes:
result = 1;
- if (states pushed on heap) {
- ... restore a, b, local from heap
+ if (depth--) {
+ st = pop();
switch (resume_state) {
case resume_FOO:
goto resume_point_FOO;
* regmatch() using gotos instead. Thus the values of any local variables
* not saved in the regmatch_state structure will have been lost when
* execution resumes on the next line .
+ *
+ * States (ie the st pointer) are allocated in slabs of about 4K in size.
+ * PL_regmatch_state always points to the currently active state, and
+ * PL_regmatch_slab points to the slab currently containing PL_regmatch_state.
+ * The first time regmatch is called, the first slab is allocated, and is
+ * never freed until interpreter desctruction. When the slab is full,
+ * a new one is allocated chained to the end. At exit from regmatch, slabs
+ * allocated since entry are freed.
*/
STATIC I32 /* 0 failure, 1 success */
-S_regmatch(pTHX_ regnode *prog)
+S_regmatch(pTHX_ regexp *rex, regnode *prog)
{
dVAR;
register const bool do_utf8 = PL_reg_match_utf8;
- const U32 uniflags = ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY;
-
- /************************************************************
- * the following variabes are saved and restored on each fake
- * recursive call to regmatch:
- *
- * The first ones contain state that needs to be maintained
- * across the main while loop: */
-
- struct regmatch_state *prev_state = NULL; /* stack of pushed states */
- resume_states resume_state; /* where to jump to on return */
- register regnode *scan; /* Current node. */
- regnode *next; /* Next node. */
- bool minmod = 0; /* the next {n.m} is a {n,m}? */
- bool sw = 0; /* the condition value in (?(cond)a|b) */
- int logical = 0;
- I32 unwind = 0; /* savestack index of current unwind block */
- CURCUR *cc = NULL; /* current innermost curly struct */
- register char *locinput = PL_reginput;
+ const U32 uniflags = UTF8_ALLOW_DEFAULT;
- /* while the rest of these are local to an individual branch, and
- * have only been hoisted into this outer scope to allow for saving and
- * restoration - thus they can be safely reused in other branches.
- * Note that they are only initialized here to silence compiler
- * warnings :-( */
-
- register I32 n = 0; /* no or next */
- register I32 ln = 0; /* len or last */
- register I32 c1 = 0, c2 = 0, paren = 0; /* case fold search, parenth */
- CHECKPOINT cp = 0; /* remember current savestack indexes */
- CHECKPOINT lastcp = 0;
- CURCUR *oldcc = NULL; /* tmp copy of cc */
- char *lastloc = NULL; /* Detection of 0-len. */
- I32 cache_offset = 0;
- I32 cache_bit = 0;
- I32 curlym_l = 0;
- I32 matches = 0;
- I32 maxwanted = 0;
- char *e = NULL;
- char *old = NULL;
- int count = 0;
- re_cc_state *cur_call_cc = NULL;
- regexp *end_re = NULL;
- reg_trie_accepted *accept_buff = NULL;
- U32 accepted = 0; /* how many accepting states we have seen */
-
- /************************************************************
- * these variables are NOT saved: */
+ regmatch_slab *orig_slab;
+ regmatch_state *orig_state;
- register I32 nextchr; /* is always set to UCHARAT(locinput) */
- regnode *new_scan; /* node to begin exedcution at when recursing */
- bool result; /* return value of S_regmatch */
+ /* the current state. This is a cached copy of PL_regmatch_state */
+ register regmatch_state *st;
- regnode *inner; /* Next node in internal branch. */
+ /* cache heavy used fields of st in registers */
+ register regnode *scan;
+ register regnode *next;
+ register I32 n = 0; /* initialize to shut up compiler warning */
+ register char *locinput = PL_reginput;
+
+ /* these variables are NOT saved during a recusive RFEGMATCH: */
+ register I32 nextchr; /* is always set to UCHARAT(locinput) */
+ bool result; /* return value of S_regmatch */
+ regnode *inner; /* Next node in internal branch. */
+ int depth = 0; /* depth of recursion */
+ regmatch_state *newst; /* when pushing a state, this is the new one */
+ regmatch_state *cur_eval = NULL; /* most recent (??{}) state */
#ifdef DEBUGGING
SV *re_debug_flags = NULL;
PL_regindent++;
#endif
+ /* on first ever call to regmatch, allocate first slab */
+ if (!PL_regmatch_slab) {
+ Newx(PL_regmatch_slab, 1, regmatch_slab);
+ PL_regmatch_slab->prev = NULL;
+ PL_regmatch_slab->next = NULL;
+ PL_regmatch_state = &PL_regmatch_slab->states[0] - 1;
+ }
+
+ /* remember current high-water mark for exit */
+ /* XXX this should be done with SAVE* instead */
+ orig_slab = PL_regmatch_slab;
+ orig_state = PL_regmatch_state;
+
+ /* grab next free state slot */
+ st = ++PL_regmatch_state;
+ if (st > &(PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1]))
+ st = PL_regmatch_state = S_push_slab(aTHX);
+
+ st->minmod = 0;
+ st->sw = 0;
+ st->logical = 0;
+ st->unwind = 0;
+ st->cc = NULL;
/* Note that nextchr is a byte even in UTF */
nextchr = UCHARAT(locinput);
scan = prog;
PL_colors[1],
15 - l - pref_len + 1,
"",
- (IV)(scan - PL_regprogram), PL_regindent*2, "",
+ (IV)(scan - rex->program), PL_regindent*2, "",
SvPVX_const(prop));
}
});
(OP(scan) == TRIE ? trie_utf8 : trie_uft8_fold)
: trie_plain;
- reg_trie_data *trie; /* what trie are we using right now */
-
- accepted = 0; /* how many accepting states we have seen */
+ /* what trie are we using right now */
+ reg_trie_data *trie
+ = (reg_trie_data*)PL_reg_re->data->data[ ARG( scan ) ];
+ st->u.trie.accepted = 0; /* how many accepting states we have seen */
result = 0;
- trie = (reg_trie_data*)PL_regdata->data[ ARG( scan ) ];
while ( state && uc <= (U8*)PL_regeol ) {
if (trie->states[ state ].wordnum) {
- if (!accepted ) {
+ if (!st->u.trie.accepted ) {
ENTER;
SAVETMPS;
bufflen = TRIE_INITAL_ACCEPT_BUFFLEN;
sizeof(reg_trie_accepted));
SvPOK_on(sv_accept_buff);
sv_2mortal(sv_accept_buff);
- accept_buff =
+ st->u.trie.accept_buff =
(reg_trie_accepted*)SvPV_nolen(sv_accept_buff );
}
else {
- if (accepted >= bufflen) {
+ if (st->u.trie.accepted >= bufflen) {
bufflen *= 2;
- accept_buff =(reg_trie_accepted*)
+ st->u.trie.accept_buff =(reg_trie_accepted*)
SvGROW(sv_accept_buff,
bufflen * sizeof(reg_trie_accepted));
}
SvCUR_set(sv_accept_buff,SvCUR(sv_accept_buff)
+ sizeof(reg_trie_accepted));
}
- accept_buff[accepted].wordnum = trie->states[state].wordnum;
- accept_buff[accepted].endpos = uc;
- ++accepted;
+ st->u.trie.accept_buff[st->u.trie.accepted].wordnum = trie->states[state].wordnum;
+ st->u.trie.accept_buff[st->u.trie.accepted].endpos = uc;
+ ++st->u.trie.accepted;
}
base = trie->states[ state ].trans.base;
PerlIO_printf( Perl_debug_log,
"%*s %sState: %4"UVxf", Base: %4"UVxf", Accepted: %4"UVxf" ",
REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
- (UV)state, (UV)base, (UV)accepted );
+ (UV)state, (UV)base, (UV)st->u.trie.accepted );
);
if ( base ) {
charid, uvc, (UV)state, PL_colors[5] );
);
}
- if (!accepted )
+ if (!st->u.trie.accepted )
sayNO;
/*
have been tried.
*/
- if ( accepted == 1 ) {
+ if ( st->u.trie.accepted == 1 ) {
DEBUG_EXECUTE_r({
- SV **tmp = av_fetch( trie->words, accept_buff[ 0 ].wordnum-1, 0 );
+ SV ** const tmp = av_fetch( trie->words, st->u.trie.accept_buff[ 0 ].wordnum-1, 0 );
PerlIO_printf( Perl_debug_log,
"%*s %sonly one match : #%d <%s>%s\n",
REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],
- accept_buff[ 0 ].wordnum,
+ st->u.trie.accept_buff[ 0 ].wordnum,
tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",
PL_colors[5] );
});
- PL_reginput = (char *)accept_buff[ 0 ].endpos;
+ PL_reginput = (char *)st->u.trie.accept_buff[ 0 ].endpos;
/* in this case we free tmps/leave before we call regmatch
as we wont be using accept_buff again. */
FREETMPS;
} else {
DEBUG_EXECUTE_r(
PerlIO_printf( Perl_debug_log,"%*s %sgot %"IVdf" possible matches%s\n",
- REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4], (IV)accepted,
+ REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4], (IV)st->u.trie.accepted,
PL_colors[5] );
);
- while ( !result && accepted-- ) {
+ while ( !result && st->u.trie.accepted-- ) {
U32 best = 0;
U32 cur;
- for( cur = 1 ; cur <= accepted ; cur++ ) {
+ for( cur = 1 ; cur <= st->u.trie.accepted ; cur++ ) {
DEBUG_TRIE_EXECUTE_r(
PerlIO_printf( Perl_debug_log,
"%*s %sgot %"IVdf" (%d) as best, looking at %"IVdf" (%d)%s\n",
REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
- (IV)best, accept_buff[ best ].wordnum, (IV)cur,
- accept_buff[ cur ].wordnum, PL_colors[5] );
+ (IV)best, st->u.trie.accept_buff[ best ].wordnum, (IV)cur,
+ st->u.trie.accept_buff[ cur ].wordnum, PL_colors[5] );
);
- if ( accept_buff[ cur ].wordnum < accept_buff[ best ].wordnum )
- best = cur;
+ if (st->u.trie.accept_buff[cur].wordnum <
+ st->u.trie.accept_buff[best].wordnum)
+ best = cur;
}
DEBUG_EXECUTE_r({
- SV ** const tmp = av_fetch( trie->words, accept_buff[ best ].wordnum - 1, 0 );
+ reg_trie_data * const trie = (reg_trie_data*)
+ PL_reg_re->data->data[ARG(scan)];
+ SV ** const tmp = av_fetch( trie->words, st->u.trie.accept_buff[ best ].wordnum - 1, 0 );
PerlIO_printf( Perl_debug_log, "%*s %strying alternation #%d <%s> at 0x%p%s\n",
REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],
- accept_buff[best].wordnum,
+ st->u.trie.accept_buff[best].wordnum,
tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",scan,
PL_colors[5] );
});
- if ( best<accepted ) {
- reg_trie_accepted tmp = accept_buff[ best ];
- accept_buff[ best ] = accept_buff[ accepted ];
- accept_buff[ accepted ] = tmp;
- best = accepted;
+ if ( best<st->u.trie.accepted ) {
+ reg_trie_accepted tmp = st->u.trie.accept_buff[ best ];
+ st->u.trie.accept_buff[ best ] = st->u.trie.accept_buff[ st->u.trie.accepted ];
+ st->u.trie.accept_buff[ st->u.trie.accepted ] = tmp;
+ best = st->u.trie.accepted;
}
- PL_reginput = (char *)accept_buff[ best ].endpos;
+ PL_reginput = (char *)st->u.trie.accept_buff[ best ].endpos;
/*
as far as I can tell we only need the SAVETMPS/FREETMPS
/* unreached codepoint */
case EXACT: {
char *s = STRING(scan);
- ln = STR_LEN(scan);
+ st->ln = STR_LEN(scan);
if (do_utf8 != UTF) {
/* The target and the pattern have differing utf8ness. */
char *l = locinput;
- const char *e = s + ln;
+ const char *e = s + st->ln;
if (do_utf8) {
/* The target is utf8, the pattern is not utf8. */
/* Inline the first character, for speed. */
if (UCHARAT(s) != nextchr)
sayNO;
- if (PL_regeol - locinput < ln)
+ if (PL_regeol - locinput < st->ln)
sayNO;
- if (ln > 1 && memNE(s, locinput, ln))
+ if (st->ln > 1 && memNE(s, locinput, st->ln))
sayNO;
- locinput += ln;
+ locinput += st->ln;
nextchr = UCHARAT(locinput);
break;
}
/* FALL THROUGH */
case EXACTF: {
char *s = STRING(scan);
- ln = STR_LEN(scan);
+ st->ln = STR_LEN(scan);
if (do_utf8 || UTF) {
/* Either target or the pattern are utf8. */
char *l = locinput;
char *e = PL_regeol;
- if (ibcmp_utf8(s, 0, ln, (bool)UTF,
+ if (ibcmp_utf8(s, 0, st->ln, (bool)UTF,
l, &e, 0, do_utf8)) {
/* One more case for the sharp s:
* pack("U0U*", 0xDF) =~ /ss/i,
* byte sequence for the U+00DF. */
if (!(do_utf8 &&
toLOWER(s[0]) == 's' &&
- ln >= 2 &&
+ st->ln >= 2 &&
toLOWER(s[1]) == 's' &&
(U8)l[0] == 0xC3 &&
e - l >= 2 &&
UCHARAT(s) != ((OP(scan) == EXACTF)
? PL_fold : PL_fold_locale)[nextchr])
sayNO;
- if (PL_regeol - locinput < ln)
+ if (PL_regeol - locinput < st->ln)
sayNO;
- if (ln > 1 && (OP(scan) == EXACTF
- ? ibcmp(s, locinput, ln)
- : ibcmp_locale(s, locinput, ln)))
+ if (st->ln > 1 && (OP(scan) == EXACTF
+ ? ibcmp(s, locinput, st->ln)
+ : ibcmp_locale(s, locinput, st->ln)))
sayNO;
- locinput += ln;
+ locinput += st->ln;
nextchr = UCHARAT(locinput);
break;
}
/* was last char in word? */
if (do_utf8) {
if (locinput == PL_bostr)
- ln = '\n';
+ st->ln = '\n';
else {
const U8 * const r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
- ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
+ st->ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, uniflags);
}
if (OP(scan) == BOUND || OP(scan) == NBOUND) {
- ln = isALNUM_uni(ln);
+ st->ln = isALNUM_uni(st->ln);
LOAD_UTF8_CHARCLASS_ALNUM();
n = swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8);
}
else {
- ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(ln));
+ st->ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(st->ln));
n = isALNUM_LC_utf8((U8*)locinput);
}
}
else {
- ln = (locinput != PL_bostr) ?
+ st->ln = (locinput != PL_bostr) ?
UCHARAT(locinput - 1) : '\n';
if (OP(scan) == BOUND || OP(scan) == NBOUND) {
- ln = isALNUM(ln);
+ st->ln = isALNUM(st->ln);
n = isALNUM(nextchr);
}
else {
- ln = isALNUM_LC(ln);
+ st->ln = isALNUM_LC(st->ln);
n = isALNUM_LC(nextchr);
}
}
- if (((!ln) == (!n)) == (OP(scan) == BOUND ||
+ if (((!st->ln) == (!n)) == (OP(scan) == BOUND ||
OP(scan) == BOUNDL))
sayNO;
break;
case REFF: {
char *s;
n = ARG(scan); /* which paren pair */
- ln = PL_regstartp[n];
+ st->ln = PL_regstartp[n];
PL_reg_leftiter = PL_reg_maxiter; /* Void cache */
- if ((I32)*PL_reglastparen < n || ln == -1)
+ if ((I32)*PL_reglastparen < n || st->ln == -1)
sayNO; /* Do not match unless seen CLOSEn. */
- if (ln == PL_regendp[n])
+ if (st->ln == PL_regendp[n])
break;
- s = PL_bostr + ln;
+ s = PL_bostr + st->ln;
if (do_utf8 && OP(scan) != REF) { /* REF can do byte comparison */
char *l = locinput;
const char *e = PL_bostr + PL_regendp[n];
(UCHARAT(s) != ((OP(scan) == REFF
? PL_fold : PL_fold_locale)[nextchr]))))
sayNO;
- ln = PL_regendp[n] - ln;
- if (locinput + ln > PL_regeol)
+ st->ln = PL_regendp[n] - st->ln;
+ if (locinput + st->ln > PL_regeol)
sayNO;
- if (ln > 1 && (OP(scan) == REF
- ? memNE(s, locinput, ln)
+ if (st->ln > 1 && (OP(scan) == REF
+ ? memNE(s, locinput, st->ln)
: (OP(scan) == REFF
- ? ibcmp(s, locinput, ln)
- : ibcmp_locale(s, locinput, ln))))
+ ? ibcmp(s, locinput, st->ln)
+ : ibcmp_locale(s, locinput, st->ln))))
sayNO;
- locinput += ln;
+ locinput += st->ln;
nextchr = UCHARAT(locinput);
break;
}
break;
case EVAL:
{
- dSP;
- OP_4tree * const oop = PL_op;
- COP * const ocurcop = PL_curcop;
- PAD *old_comppad;
SV *ret;
- struct regexp * const oreg = PL_reg_re;
-
- n = ARG(scan);
- PL_op = (OP_4tree*)PL_regdata->data[n];
- DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log, " re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
- PAD_SAVE_LOCAL(old_comppad, (PAD*)PL_regdata->data[n + 2]);
- PL_regendp[0] = PL_reg_magic->mg_len = locinput - PL_bostr;
-
{
+ /* execute the code in the {...} */
+ dSP;
SV ** const before = SP;
+ OP_4tree * const oop = PL_op;
+ COP * const ocurcop = PL_curcop;
+ PAD *old_comppad;
+ struct regexp * const oreg = PL_reg_re;
+
+ n = ARG(scan);
+ PL_op = (OP_4tree*)PL_reg_re->data->data[n];
+ DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log, " re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
+ PAD_SAVE_LOCAL(old_comppad, (PAD*)PL_reg_re->data->data[n + 2]);
+ PL_regendp[0] = PL_reg_magic->mg_len = locinput - PL_bostr;
+
CALLRUNOPS(aTHX); /* Scalar context. */
SPAGAIN;
if (SP == before)
ret = POPs;
PUTBACK;
}
+
+ PL_op = oop;
+ PAD_RESTORE_LOCAL(old_comppad);
+ PL_curcop = ocurcop;
+ PL_reg_re = oreg;
+ if (!st->logical) {
+ /* /(?{...})/ */
+ sv_setsv(save_scalar(PL_replgv), ret);
+ break;
+ }
}
+ if (st->logical == 2) { /* Postponed subexpression: /(??{...})/ */
+ regexp *re;
+ {
+ /* extract RE object from returned value; compiling if
+ * necessary */
- PL_op = oop;
- PAD_RESTORE_LOCAL(old_comppad);
- PL_curcop = ocurcop;
- if (logical) {
- if (logical == 2) { /* Postponed subexpression. */
- regexp *re;
MAGIC *mg = NULL;
- re_cc_state state;
- int toggleutf;
- register SV *sv;
-
+ SV *sv;
if(SvROK(ret) && SvSMAGICAL(sv = SvRV(ret)))
mg = mg_find(sv, PERL_MAGIC_qr);
else if (SvSMAGICAL(ret)) {
STRLEN len;
const char * const t = SvPV_const(ret, len);
PMOP pm;
- char * const oprecomp = PL_regprecomp;
const I32 osize = PL_regsize;
- const I32 onpar = PL_regnpar;
Zero(&pm, 1, PMOP);
- if (DO_UTF8(ret)) pm.op_pmdynflags |= PMdf_DYN_UTF8;
+ if (DO_UTF8(ret)) pm.op_pmdynflags |= PMdf_DYN_UTF8;
re = CALLREGCOMP(aTHX_ (char*)t, (char*)t + len, &pm);
if (!(SvFLAGS(ret)
& (SVs_TEMP | SVs_PADTMP | SVf_READONLY
| SVs_GMG)))
sv_magic(ret,(SV*)ReREFCNT_inc(re),
PERL_MAGIC_qr,0,0);
- PL_regprecomp = oprecomp;
PL_regsize = osize;
- PL_regnpar = onpar;
- }
- DEBUG_EXECUTE_r(
- PerlIO_printf(Perl_debug_log,
- "Entering embedded \"%s%.60s%s%s\"\n",
- PL_colors[0],
- re->precomp,
- PL_colors[1],
- (strlen(re->precomp) > 60 ? "..." : ""))
- );
- state.node = next;
- state.prev = PL_reg_call_cc;
- state.cc = cc;
- state.re = PL_reg_re;
-
- cc = 0;
-
- cp = regcppush(0); /* Save *all* the positions. */
- REGCP_SET(lastcp);
- cache_re(re);
- state.ss = PL_savestack_ix;
- *PL_reglastparen = 0;
- *PL_reglastcloseparen = 0;
- PL_reg_call_cc = &state;
- PL_reginput = locinput;
- toggleutf = ((PL_reg_flags & RF_utf8) != 0) ^
- ((re->reganch & ROPT_UTF8) != 0);
- if (toggleutf) PL_reg_flags ^= RF_utf8;
-
- /* XXXX This is too dramatic a measure... */
- PL_reg_maxiter = 0;
-
- /* XXX the only recursion left in regmatch() */
- if (regmatch(re->program + 1)) {
- /* Even though we succeeded, we need to restore
- global variables, since we may be wrapped inside
- SUSPEND, thus the match may be not finished yet. */
-
- /* XXXX Do this only if SUSPENDed? */
- PL_reg_call_cc = state.prev;
- cc = state.cc;
- PL_reg_re = state.re;
- cache_re(PL_reg_re);
- if (toggleutf) PL_reg_flags ^= RF_utf8;
-
- /* XXXX This is too dramatic a measure... */
- PL_reg_maxiter = 0;
-
- /* These are needed even if not SUSPEND. */
- ReREFCNT_dec(re);
- regcpblow(cp);
- sayYES;
}
- ReREFCNT_dec(re);
- REGCP_UNWIND(lastcp);
- regcppop();
- PL_reg_call_cc = state.prev;
- cc = state.cc;
- PL_reg_re = state.re;
- cache_re(PL_reg_re);
- if (toggleutf) PL_reg_flags ^= RF_utf8;
-
- /* XXXX This is too dramatic a measure... */
- PL_reg_maxiter = 0;
-
- logical = 0;
- sayNO;
}
- sw = SvTRUE(ret);
- logical = 0;
- }
- else {
- sv_setsv(save_scalar(PL_replgv), ret);
- cache_re(oreg);
+
+ /* run the pattern returned from (??{...}) */
+
+ DEBUG_EXECUTE_r(
+ PerlIO_printf(Perl_debug_log,
+ "Entering embedded \"%s%.60s%s%s\"\n",
+ PL_colors[0],
+ re->precomp,
+ PL_colors[1],
+ (strlen(re->precomp) > 60 ? "..." : ""))
+ );
+
+ st->u.eval.cp = regcppush(0); /* Save *all* the positions. */
+ REGCP_SET(st->u.eval.lastcp);
+ *PL_reglastparen = 0;
+ *PL_reglastcloseparen = 0;
+ PL_reginput = locinput;
+
+ /* XXXX This is too dramatic a measure... */
+ PL_reg_maxiter = 0;
+
+ st->logical = 0;
+ st->u.eval.toggleutf = ((PL_reg_flags & RF_utf8) != 0) ^
+ ((re->reganch & ROPT_UTF8) != 0);
+ if (st->u.eval.toggleutf) PL_reg_flags ^= RF_utf8;
+ st->u.eval.prev_rex = rex;
+ assert(rex == PL_reg_re); /* XXX */
+ rex = re;
+ PL_reg_re = rex; /* XXX */
+
+ st->u.eval.prev_eval = cur_eval;
+ st->u.eval.prev_slab = PL_regmatch_slab;
+ st->u.eval.depth = depth;
+ cur_eval = st;
+ PUSH_STATE(newst, resume_EVAL);
+ st = newst;
+
+ /* now continue from first node in postoned RE */
+ next = re->program + 1;
+ break;
+ /* NOTREACHED */
}
+ /* /(?(?{...})X|Y)/ */
+ st->sw = SvTRUE(ret);
+ st->logical = 0;
break;
}
case OPEN:
break;
case GROUPP:
n = ARG(scan); /* which paren pair */
- sw = ((I32)*PL_reglastparen >= n && PL_regendp[n] != -1);
+ st->sw = ((I32)*PL_reglastparen >= n && PL_regendp[n] != -1);
break;
case IFTHEN:
PL_reg_leftiter = PL_reg_maxiter; /* Void cache */
- if (sw)
+ if (st->sw)
next = NEXTOPER(NEXTOPER(scan));
else {
next = scan + ARG(scan);
}
break;
case LOGICAL:
- logical = scan->flags;
+ st->logical = scan->flags;
break;
/*******************************************************************
- cc contains infoblock about the innermost (...)* loop, and
- a pointer to the next outer infoblock.
+ cc points to the regmatch_state associated with the most recent CURLYX.
+ This struct contains info about the innermost (...)* loop (an
+ "infoblock"), and a pointer to the next outer cc.
Here is how Y(A)*Z is processed (if it is compiled into CURLYX/WHILEM):
1) After matching Y, regnode for CURLYX is processed;
- 2) This regnode mallocs an infoblock, and calls regmatch() recursively
+ 2) This regnode populates cc, and calls regmatch() recursively
with the starting point at WHILEM node;
3) Each hit of WHILEM node tries to match A and Z (in the order
depending on the current iteration, min/max of {min,max} and
greediness). The information about where are nodes for "A"
- and "Z" is read from the infoblock, as is info on how many times "A"
+ and "Z" is read from cc, as is info on how many times "A"
was already matched, and greediness.
4) After A matches, the same WHILEM node is hit again.
as in (Y(A)*Z)*. If Z matches, the automaton will hit the WHILEM node
of the external loop.
- Currently present infoblocks form a tree with a stem formed by PL_curcc
+ Currently present infoblocks form a tree with a stem formed by st->cc
and whatever it mentions via ->next, and additional attached trees
corresponding to temporarily unset infoblocks as in "5" above.
/* No need to save/restore up to this paren */
I32 parenfloor = scan->flags;
- {
- CURCUR *newcc;
- Newx(newcc, 1, CURCUR);
- oldcc = cc;
- newcc->oldcc = cc;
- cc = newcc;
- }
- cp = PL_savestack_ix;
if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
next += ARG(next);
/* XXXX Probably it is better to teach regpush to support
parenfloor > PL_regsize... */
if (parenfloor > (I32)*PL_reglastparen)
parenfloor = *PL_reglastparen; /* Pessimization... */
- cc->parenfloor = parenfloor;
- cc->cur = -1;
- cc->min = ARG1(scan);
- cc->max = ARG2(scan);
- cc->scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
- cc->next = next;
- cc->minmod = minmod;
- cc->lastloc = 0;
+
+ st->u.curlyx.cp = PL_savestack_ix;
+ st->u.curlyx.outercc = st->cc;
+ st->cc = st;
+ /* these fields contain the state of the current curly.
+ * they are accessed by subsequent WHILEMs;
+ * cur and lastloc are also updated by WHILEM */
+ st->u.curlyx.parenfloor = parenfloor;
+ st->u.curlyx.cur = -1; /* this will be updated by WHILEM */
+ st->u.curlyx.min = ARG1(scan);
+ st->u.curlyx.max = ARG2(scan);
+ st->u.curlyx.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
+ st->u.curlyx.lastloc = 0;
+ /* st->next and st->minmod are also read by WHILEM */
+
PL_reginput = locinput;
REGMATCH(PREVOPER(next), CURLYX); /* start on the WHILEM */
/*** all unsaved local vars undefined at this point */
- regcpblow(cp);
- Safefree(cc);
- cc = oldcc;
+ regcpblow(st->u.curlyx.cp);
+ st->cc = st->u.curlyx.outercc;
saySAME(result);
}
/* NOTREACHED */
* that we can try again after backing off.
*/
- lastloc = cc->lastloc; /* Detection of 0-len. */
- cache_offset = 0;
- cache_bit = 0;
+ st->u.whilem.lastloc = st->cc->u.curlyx.lastloc; /* Detection of 0-len. */
+ st->u.whilem.cache_offset = 0;
+ st->u.whilem.cache_bit = 0;
- n = cc->cur + 1; /* how many we know we matched */
+ n = st->cc->u.curlyx.cur + 1; /* how many we know we matched */
PL_reginput = locinput;
DEBUG_EXECUTE_r(
PerlIO_printf(Perl_debug_log,
"%*s %ld out of %ld..%ld cc=%"UVxf"\n",
REPORT_CODE_OFF+PL_regindent*2, "",
- (long)n, (long)cc->min,
- (long)cc->max, PTR2UV(cc))
+ (long)n, (long)st->cc->u.curlyx.min,
+ (long)st->cc->u.curlyx.max, PTR2UV(st->cc))
);
/* If degenerate scan matches "", assume scan done. */
- if (locinput == cc->lastloc && n >= cc->min) {
- oldcc = cc;
- cc = cc->oldcc;
- if (cc)
- ln = cc->cur;
+ if (locinput == st->cc->u.curlyx.lastloc && n >= st->cc->u.curlyx.min) {
+ st->u.whilem.savecc = st->cc;
+ st->cc = st->cc->u.curlyx.outercc;
+ if (st->cc)
+ st->ln = st->cc->u.curlyx.cur;
DEBUG_EXECUTE_r(
PerlIO_printf(Perl_debug_log,
"%*s empty match detected, try continuation...\n",
REPORT_CODE_OFF+PL_regindent*2, "")
);
- REGMATCH(oldcc->next, WHILEM1);
+ REGMATCH(st->u.whilem.savecc->next, WHILEM1);
/*** all unsaved local vars undefined at this point */
- cc = oldcc;
+ st->cc = st->u.whilem.savecc;
if (result)
sayYES;
- if (cc->oldcc)
- cc->oldcc->cur = ln;
+ if (st->cc->u.curlyx.outercc)
+ st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
sayNO;
}
/* First just match a string of min scans. */
- if (n < cc->min) {
- cc->cur = n;
- cc->lastloc = locinput;
- REGMATCH(cc->scan, WHILEM2);
+ if (n < st->cc->u.curlyx.min) {
+ st->cc->u.curlyx.cur = n;
+ st->cc->u.curlyx.lastloc = locinput;
+ REGMATCH(st->cc->u.curlyx.scan, WHILEM2);
/*** all unsaved local vars undefined at this point */
if (result)
sayYES;
- cc->cur = n - 1;
- cc->lastloc = lastloc;
+ st->cc->u.curlyx.cur = n - 1;
+ st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
sayNO;
}
);
}
if (PL_reg_leftiter < 0) {
- cache_offset = locinput - PL_bostr;
+ st->u.whilem.cache_offset = locinput - PL_bostr;
- cache_offset = (scan->flags & 0xf) - 1 + POSCACHE_START
- + cache_offset * (scan->flags>>4);
- cache_bit = cache_offset % 8;
- cache_offset /= 8;
- if (PL_reg_poscache[cache_offset] & (1<<cache_bit)) {
+ st->u.whilem.cache_offset = (scan->flags & 0xf) - 1 + POSCACHE_START
+ + st->u.whilem.cache_offset * (scan->flags>>4);
+ st->u.whilem.cache_bit = st->u.whilem.cache_offset % 8;
+ st->u.whilem.cache_offset /= 8;
+ if (PL_reg_poscache[st->u.whilem.cache_offset] & (1<<st->u.whilem.cache_bit)) {
DEBUG_EXECUTE_r(
PerlIO_printf(Perl_debug_log,
"%*s already tried at this position...\n",
/* cache records failure */
sayNO_SILENT;
}
- PL_reg_poscache[cache_offset] |= (1<<cache_bit);
+ PL_reg_poscache[st->u.whilem.cache_offset] |= (1<<st->u.whilem.cache_bit);
}
}
/* Prefer next over scan for minimal matching. */
- if (cc->minmod) {
- oldcc = cc;
- cc = cc->oldcc;
- if (cc)
- ln = cc->cur;
- cp = regcppush(oldcc->parenfloor);
- REGCP_SET(lastcp);
- REGMATCH(oldcc->next, WHILEM3);
+ if (st->cc->minmod) {
+ st->u.whilem.savecc = st->cc;
+ st->cc = st->cc->u.curlyx.outercc;
+ if (st->cc)
+ st->ln = st->cc->u.curlyx.cur;
+ st->u.whilem.cp = regcppush(st->u.whilem.savecc->u.curlyx.parenfloor);
+ REGCP_SET(st->u.whilem.lastcp);
+ REGMATCH(st->u.whilem.savecc->next, WHILEM3);
/*** all unsaved local vars undefined at this point */
- cc = oldcc;
+ st->cc = st->u.whilem.savecc;
if (result) {
- regcpblow(cp);
+ regcpblow(st->u.whilem.cp);
CACHEsayYES; /* All done. */
}
- REGCP_UNWIND(lastcp);
- regcppop();
- if (cc->oldcc)
- cc->oldcc->cur = ln;
+ REGCP_UNWIND(st->u.whilem.lastcp);
+ regcppop(rex);
+ if (st->cc->u.curlyx.outercc)
+ st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
- if (n >= cc->max) { /* Maximum greed exceeded? */
+ if (n >= st->cc->u.curlyx.max) { /* Maximum greed exceeded? */
if (ckWARN(WARN_REGEXP) && n >= REG_INFTY
&& !(PL_reg_flags & RF_warned)) {
PL_reg_flags |= RF_warned;
);
/* Try scanning more and see if it helps. */
PL_reginput = locinput;
- cc->cur = n;
- cc->lastloc = locinput;
- cp = regcppush(cc->parenfloor);
- REGCP_SET(lastcp);
- REGMATCH(cc->scan, WHILEM4);
+ st->cc->u.curlyx.cur = n;
+ st->cc->u.curlyx.lastloc = locinput;
+ st->u.whilem.cp = regcppush(st->cc->u.curlyx.parenfloor);
+ REGCP_SET(st->u.whilem.lastcp);
+ REGMATCH(st->cc->u.curlyx.scan, WHILEM4);
/*** all unsaved local vars undefined at this point */
if (result) {
- regcpblow(cp);
+ regcpblow(st->u.whilem.cp);
CACHEsayYES;
}
- REGCP_UNWIND(lastcp);
- regcppop();
- cc->cur = n - 1;
- cc->lastloc = lastloc;
+ REGCP_UNWIND(st->u.whilem.lastcp);
+ regcppop(rex);
+ st->cc->u.curlyx.cur = n - 1;
+ st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
CACHEsayNO;
}
/* Prefer scan over next for maximal matching. */
- if (n < cc->max) { /* More greed allowed? */
- cp = regcppush(cc->parenfloor);
- cc->cur = n;
- cc->lastloc = locinput;
- REGCP_SET(lastcp);
- REGMATCH(cc->scan, WHILEM5);
+ if (n < st->cc->u.curlyx.max) { /* More greed allowed? */
+ st->u.whilem.cp = regcppush(st->cc->u.curlyx.parenfloor);
+ st->cc->u.curlyx.cur = n;
+ st->cc->u.curlyx.lastloc = locinput;
+ REGCP_SET(st->u.whilem.lastcp);
+ REGMATCH(st->cc->u.curlyx.scan, WHILEM5);
/*** all unsaved local vars undefined at this point */
if (result) {
- regcpblow(cp);
+ regcpblow(st->u.whilem.cp);
CACHEsayYES;
}
- REGCP_UNWIND(lastcp);
- regcppop(); /* Restore some previous $<digit>s? */
+ REGCP_UNWIND(st->u.whilem.lastcp);
+ regcppop(rex); /* Restore some previous $<digit>s? */
PL_reginput = locinput;
DEBUG_EXECUTE_r(
PerlIO_printf(Perl_debug_log,
}
/* Failed deeper matches of scan, so see if this one works. */
- oldcc = cc;
- cc = cc->oldcc;
- if (cc)
- ln = cc->cur;
- REGMATCH(oldcc->next, WHILEM6);
+ st->u.whilem.savecc = st->cc;
+ st->cc = st->cc->u.curlyx.outercc;
+ if (st->cc)
+ st->ln = st->cc->u.curlyx.cur;
+ REGMATCH(st->u.whilem.savecc->next, WHILEM6);
/*** all unsaved local vars undefined at this point */
- cc = oldcc;
+ st->cc = st->u.whilem.savecc;
if (result)
CACHEsayYES;
- if (cc->oldcc)
- cc->oldcc->cur = ln;
- cc->cur = n - 1;
- cc->lastloc = lastloc;
+ if (st->cc->u.curlyx.outercc)
+ st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
+ st->cc->u.curlyx.cur = n - 1;
+ st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
CACHEsayNO;
}
/* NOTREACHED */
inner = NEXTOPER(scan);
do_branch:
{
- c1 = OP(scan);
- if (OP(next) != c1) /* No choice. */
+ I32 type;
+ type = OP(scan);
+ if (OP(next) != type) /* No choice. */
next = inner; /* Avoid recursion. */
else {
const I32 lastparen = *PL_reglastparen;
const I32 unwind1 = SSNEWt(1,re_unwind_branch_t);
re_unwind_branch_t * const uw = SSPTRt(unwind1,re_unwind_branch_t);
- uw->prev = unwind;
- unwind = unwind1;
- uw->type = ((c1 == BRANCH)
+ uw->prev = st->unwind;
+ st->unwind = unwind1;
+ uw->type = ((type == BRANCH)
? RE_UNWIND_BRANCH
: RE_UNWIND_BRANCHJ);
uw->lastparen = lastparen;
}
break;
case MINMOD:
- minmod = 1;
+ st->minmod = 1;
break;
case CURLYM:
{
- curlym_l = matches = 0;
+ st->u.curlym.l = st->u.curlym.matches = 0;
/* We suppose that the next guy does not need
backtracking: in particular, it is of constant non-zero length,
and has no parenths to influence future backrefs. */
- ln = ARG1(scan); /* min to match */
+ st->ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
- paren = scan->flags;
- if (paren) {
- if (paren > PL_regsize)
- PL_regsize = paren;
- if (paren > (I32)*PL_reglastparen)
- *PL_reglastparen = paren;
+ st->u.curlym.paren = scan->flags;
+ if (st->u.curlym.paren) {
+ if (st->u.curlym.paren > PL_regsize)
+ PL_regsize = st->u.curlym.paren;
+ if (st->u.curlym.paren > (I32)*PL_reglastparen)
+ *PL_reglastparen = st->u.curlym.paren;
}
scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
- if (paren)
+ if (st->u.curlym.paren)
scan += NEXT_OFF(scan); /* Skip former OPEN. */
PL_reginput = locinput;
- maxwanted = minmod ? ln : n;
- if (maxwanted) {
- while (PL_reginput < PL_regeol && matches < maxwanted) {
+ st->u.curlym.maxwanted = st->minmod ? st->ln : n;
+ if (st->u.curlym.maxwanted) {
+ while (PL_reginput < PL_regeol && st->u.curlym.matches < st->u.curlym.maxwanted) {
REGMATCH(scan, CURLYM1);
/*** all unsaved local vars undefined at this point */
if (!result)
break;
- /* on first match, determine length, curlym_l */
- if (!matches++) {
+ /* on first match, determine length, u.curlym.l */
+ if (!st->u.curlym.matches++) {
if (PL_reg_match_utf8) {
char *s = locinput;
while (s < PL_reginput) {
- curlym_l++;
+ st->u.curlym.l++;
s += UTF8SKIP(s);
}
}
else {
- curlym_l = PL_reginput - locinput;
+ st->u.curlym.l = PL_reginput - locinput;
}
- if (curlym_l == 0) {
- matches = maxwanted;
+ if (st->u.curlym.l == 0) {
+ st->u.curlym.matches = st->u.curlym.maxwanted;
break;
}
}
PL_reginput = locinput;
- if (minmod) {
- minmod = 0;
- if (ln && matches < ln)
+ if (st->minmod) {
+ st->minmod = 0;
+ if (st->ln && st->u.curlym.matches < st->ln)
sayNO;
if (HAS_TEXT(next) || JUMPABLE(next)) {
regnode *text_node = next;
if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
- if (! HAS_TEXT(text_node)) c1 = c2 = -1000;
+ if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
else {
if (PL_regkind[(U8)OP(text_node)] == REF) {
- c1 = c2 = -1000;
+ st->u.curlym.c1 = st->u.curlym.c2 = -1000;
goto assume_ok_MM;
}
- else { c1 = (U8)*STRING(text_node); }
+ else { st->u.curlym.c1 = (U8)*STRING(text_node); }
if (OP(text_node) == EXACTF || OP(text_node) == REFF)
- c2 = PL_fold[c1];
+ st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
- c2 = PL_fold_locale[c1];
+ st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
else
- c2 = c1;
+ st->u.curlym.c2 = st->u.curlym.c1;
}
}
else
- c1 = c2 = -1000;
+ st->u.curlym.c1 = st->u.curlym.c2 = -1000;
assume_ok_MM:
- REGCP_SET(lastcp);
- while (n >= ln || (n == REG_INFTY && ln > 0)) { /* ln overflow ? */
+ REGCP_SET(st->u.curlym.lastcp);
+ while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
/* If it could work, try it. */
- if (c1 == -1000 ||
- UCHARAT(PL_reginput) == c1 ||
- UCHARAT(PL_reginput) == c2)
+ if (st->u.curlym.c1 == -1000 ||
+ UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+ UCHARAT(PL_reginput) == st->u.curlym.c2)
{
- if (paren) {
- if (ln) {
- PL_regstartp[paren] =
- HOPc(PL_reginput, -curlym_l) - PL_bostr;
- PL_regendp[paren] = PL_reginput - PL_bostr;
+ if (st->u.curlym.paren) {
+ if (st->ln) {
+ PL_regstartp[st->u.curlym.paren] =
+ HOPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+ PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
}
else
- PL_regendp[paren] = -1;
+ PL_regendp[st->u.curlym.paren] = -1;
}
REGMATCH(next, CURLYM2);
/*** all unsaved local vars undefined at this point */
if (result)
sayYES;
- REGCP_UNWIND(lastcp);
+ REGCP_UNWIND(st->u.curlym.lastcp);
}
/* Couldn't or didn't -- move forward. */
PL_reginput = locinput;
REGMATCH(scan, CURLYM3);
/*** all unsaved local vars undefined at this point */
if (result) {
- ln++;
+ st->ln++;
locinput = PL_reginput;
}
else
PerlIO_printf(Perl_debug_log,
"%*s matched %"IVdf" times, len=%"IVdf"...\n",
(int)(REPORT_CODE_OFF+PL_regindent*2), "",
- (IV) matches, (IV)curlym_l)
+ (IV) st->u.curlym.matches, (IV)st->u.curlym.l)
);
- if (matches >= ln) {
+ if (st->u.curlym.matches >= st->ln) {
if (HAS_TEXT(next) || JUMPABLE(next)) {
regnode *text_node = next;
if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
- if (! HAS_TEXT(text_node)) c1 = c2 = -1000;
+ if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
else {
if (PL_regkind[(U8)OP(text_node)] == REF) {
- c1 = c2 = -1000;
+ st->u.curlym.c1 = st->u.curlym.c2 = -1000;
goto assume_ok_REG;
}
- else { c1 = (U8)*STRING(text_node); }
+ else { st->u.curlym.c1 = (U8)*STRING(text_node); }
if (OP(text_node) == EXACTF || OP(text_node) == REFF)
- c2 = PL_fold[c1];
+ st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
- c2 = PL_fold_locale[c1];
+ st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
else
- c2 = c1;
+ st->u.curlym.c2 = st->u.curlym.c1;
}
}
else
- c1 = c2 = -1000;
+ st->u.curlym.c1 = st->u.curlym.c2 = -1000;
}
assume_ok_REG:
- REGCP_SET(lastcp);
- while (matches >= ln) {
+ REGCP_SET(st->u.curlym.lastcp);
+ while (st->u.curlym.matches >= st->ln) {
/* If it could work, try it. */
- if (c1 == -1000 ||
- UCHARAT(PL_reginput) == c1 ||
- UCHARAT(PL_reginput) == c2)
+ if (st->u.curlym.c1 == -1000 ||
+ UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+ UCHARAT(PL_reginput) == st->u.curlym.c2)
{
DEBUG_EXECUTE_r(
PerlIO_printf(Perl_debug_log,
"%*s trying tail with matches=%"IVdf"...\n",
(int)(REPORT_CODE_OFF+PL_regindent*2),
- "", (IV)matches)
+ "", (IV)st->u.curlym.matches)
);
- if (paren) {
- if (matches) {
- PL_regstartp[paren]
- = HOPc(PL_reginput, -curlym_l) - PL_bostr;
- PL_regendp[paren] = PL_reginput - PL_bostr;
+ if (st->u.curlym.paren) {
+ if (st->u.curlym.matches) {
+ PL_regstartp[st->u.curlym.paren]
+ = HOPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+ PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
}
else
- PL_regendp[paren] = -1;
+ PL_regendp[st->u.curlym.paren] = -1;
}
REGMATCH(next, CURLYM4);
/*** all unsaved local vars undefined at this point */
if (result)
sayYES;
- REGCP_UNWIND(lastcp);
+ REGCP_UNWIND(st->u.curlym.lastcp);
}
/* Couldn't or didn't -- back up. */
- matches--;
- locinput = HOPc(locinput, -curlym_l);
+ st->u.curlym.matches--;
+ locinput = HOPc(locinput, -st->u.curlym.l);
PL_reginput = locinput;
}
}
break;
}
case CURLYN:
- paren = scan->flags; /* Which paren to set */
- if (paren > PL_regsize)
- PL_regsize = paren;
- if (paren > (I32)*PL_reglastparen)
- *PL_reglastparen = paren;
- ln = ARG1(scan); /* min to match */
+ st->u.plus.paren = scan->flags; /* Which paren to set */
+ if (st->u.plus.paren > PL_regsize)
+ PL_regsize = st->u.plus.paren;
+ if (st->u.plus.paren > (I32)*PL_reglastparen)
+ *PL_reglastparen = st->u.plus.paren;
+ st->ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
goto repeat;
case CURLY:
- paren = 0;
- ln = ARG1(scan); /* min to match */
+ st->u.plus.paren = 0;
+ st->ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
goto repeat;
case STAR:
- ln = 0;
+ st->ln = 0;
n = REG_INFTY;
scan = NEXTOPER(scan);
- paren = 0;
+ st->u.plus.paren = 0;
goto repeat;
case PLUS:
- ln = 1;
+ st->ln = 1;
n = REG_INFTY;
scan = NEXTOPER(scan);
- paren = 0;
+ st->u.plus.paren = 0;
repeat:
/*
* Lookahead to avoid useless match attempts
if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
- if (! HAS_TEXT(text_node)) c1 = c2 = -1000;
+ if (! HAS_TEXT(text_node)) st->u.plus.c1 = st->u.plus.c2 = -1000;
else {
if (PL_regkind[(U8)OP(text_node)] == REF) {
- c1 = c2 = -1000;
+ st->u.plus.c1 = st->u.plus.c2 = -1000;
goto assume_ok_easy;
}
else { s = (U8*)STRING(text_node); }
if (!UTF) {
- c2 = c1 = *s;
+ st->u.plus.c2 = st->u.plus.c1 = *s;
if (OP(text_node) == EXACTF || OP(text_node) == REFF)
- c2 = PL_fold[c1];
+ st->u.plus.c2 = PL_fold[st->u.plus.c1];
else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
- c2 = PL_fold_locale[c1];
+ st->u.plus.c2 = PL_fold_locale[st->u.plus.c1];
}
else { /* UTF */
if (OP(text_node) == EXACTF || OP(text_node) == REFF) {
to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
- c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
+ st->u.plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
uniflags);
- c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
+ st->u.plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
uniflags);
}
else {
- c2 = c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
+ st->u.plus.c2 = st->u.plus.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
uniflags);
}
}
}
}
else
- c1 = c2 = -1000;
+ st->u.plus.c1 = st->u.plus.c2 = -1000;
assume_ok_easy:
PL_reginput = locinput;
- if (minmod) {
- minmod = 0;
- if (ln && regrepeat(scan, ln) < ln)
+ if (st->minmod) {
+ st->minmod = 0;
+ if (st->ln && regrepeat(scan, st->ln) < st->ln)
sayNO;
locinput = PL_reginput;
- REGCP_SET(lastcp);
- if (c1 != -1000) {
- old = locinput;
- count = 0;
+ REGCP_SET(st->u.plus.lastcp);
+ if (st->u.plus.c1 != -1000) {
+ st->u.plus.old = locinput;
+ st->u.plus.count = 0;
if (n == REG_INFTY) {
- e = PL_regeol - 1;
+ st->u.plus.e = PL_regeol - 1;
if (do_utf8)
- while (UTF8_IS_CONTINUATION(*(U8*)e))
- e--;
+ while (UTF8_IS_CONTINUATION(*(U8*)st->u.plus.e))
+ st->u.plus.e--;
}
else if (do_utf8) {
- int m = n - ln;
- for (e = locinput;
- m >0 && e + UTF8SKIP(e) <= PL_regeol; m--)
- e += UTF8SKIP(e);
+ int m = n - st->ln;
+ for (st->u.plus.e = locinput;
+ m >0 && st->u.plus.e + UTF8SKIP(st->u.plus.e) <= PL_regeol; m--)
+ st->u.plus.e += UTF8SKIP(st->u.plus.e);
}
else {
- e = locinput + n - ln;
- if (e >= PL_regeol)
- e = PL_regeol - 1;
+ st->u.plus.e = locinput + n - st->ln;
+ if (st->u.plus.e >= PL_regeol)
+ st->u.plus.e = PL_regeol - 1;
}
while (1) {
/* Find place 'next' could work */
if (!do_utf8) {
- if (c1 == c2) {
- while (locinput <= e &&
- UCHARAT(locinput) != c1)
+ if (st->u.plus.c1 == st->u.plus.c2) {
+ while (locinput <= st->u.plus.e &&
+ UCHARAT(locinput) != st->u.plus.c1)
locinput++;
} else {
- while (locinput <= e
- && UCHARAT(locinput) != c1
- && UCHARAT(locinput) != c2)
+ while (locinput <= st->u.plus.e
+ && UCHARAT(locinput) != st->u.plus.c1
+ && UCHARAT(locinput) != st->u.plus.c2)
locinput++;
}
- count = locinput - old;
+ st->u.plus.count = locinput - st->u.plus.old;
}
else {
- if (c1 == c2) {
+ if (st->u.plus.c1 == st->u.plus.c2) {
STRLEN len;
/* count initialised to
* utf8_distance(old, locinput) */
- while (locinput <= e &&
+ while (locinput <= st->u.plus.e &&
utf8n_to_uvchr((U8*)locinput,
UTF8_MAXBYTES, &len,
- uniflags) != (UV)c1) {
+ uniflags) != (UV)st->u.plus.c1) {
locinput += len;
- count++;
+ st->u.plus.count++;
}
} else {
STRLEN len;
/* count initialised to
* utf8_distance(old, locinput) */
- while (locinput <= e) {
+ while (locinput <= st->u.plus.e) {
UV c = utf8n_to_uvchr((U8*)locinput,
UTF8_MAXBYTES, &len,
uniflags);
- if (c == (UV)c1 || c == (UV)c2)
+ if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
break;
locinput += len;
- count++;
+ st->u.plus.count++;
}
}
}
- if (locinput > e)
+ if (locinput > st->u.plus.e)
sayNO;
/* PL_reginput == old now */
- if (locinput != old) {
- ln = 1; /* Did some */
- if (regrepeat(scan, count) < count)
+ if (locinput != st->u.plus.old) {
+ st->ln = 1; /* Did some */
+ if (regrepeat(scan, st->u.plus.count) < st->u.plus.count)
sayNO;
}
/* PL_reginput == locinput now */
- TRYPAREN(paren, ln, locinput, PLUS1);
+ TRYPAREN(st->u.plus.paren, st->ln, locinput, PLUS1);
/*** all unsaved local vars undefined at this point */
PL_reginput = locinput; /* Could be reset... */
- REGCP_UNWIND(lastcp);
+ REGCP_UNWIND(st->u.plus.lastcp);
/* Couldn't or didn't -- move forward. */
- old = locinput;
+ st->u.plus.old = locinput;
if (do_utf8)
locinput += UTF8SKIP(locinput);
else
locinput++;
- count = 1;
+ st->u.plus.count = 1;
}
}
else
- while (n >= ln || (n == REG_INFTY && ln > 0)) { /* ln overflow ? */
+ while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
UV c;
- if (c1 != -1000) {
+ if (st->u.plus.c1 != -1000) {
if (do_utf8)
c = utf8n_to_uvchr((U8*)PL_reginput,
UTF8_MAXBYTES, 0,
else
c = UCHARAT(PL_reginput);
/* If it could work, try it. */
- if (c == (UV)c1 || c == (UV)c2)
+ if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
{
- TRYPAREN(paren, ln, PL_reginput, PLUS2);
+ TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS2);
/*** all unsaved local vars undefined at this point */
- REGCP_UNWIND(lastcp);
+ REGCP_UNWIND(st->u.plus.lastcp);
}
}
/* If it could work, try it. */
- else if (c1 == -1000)
+ else if (st->u.plus.c1 == -1000)
{
- TRYPAREN(paren, ln, PL_reginput, PLUS3);
+ TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS3);
/*** all unsaved local vars undefined at this point */
- REGCP_UNWIND(lastcp);
+ REGCP_UNWIND(st->u.plus.lastcp);
}
/* Couldn't or didn't -- move forward. */
PL_reginput = locinput;
if (regrepeat(scan, 1)) {
- ln++;
+ st->ln++;
locinput = PL_reginput;
}
else
else {
n = regrepeat(scan, n);
locinput = PL_reginput;
- if (ln < n && PL_regkind[(U8)OP(next)] == EOL &&
+ if (st->ln < n && PL_regkind[(U8)OP(next)] == EOL &&
(OP(next) != MEOL ||
OP(next) == SEOL || OP(next) == EOS))
{
- ln = n; /* why back off? */
+ st->ln = n; /* why back off? */
/* ...because $ and \Z can match before *and* after
newline at the end. Consider "\n\n" =~ /\n+\Z\n/.
We should back off by one in this case. */
if (UCHARAT(PL_reginput - 1) == '\n' && OP(next) != EOS)
- ln--;
+ st->ln--;
}
- REGCP_SET(lastcp);
+ REGCP_SET(st->u.plus.lastcp);
{
UV c = 0;
- while (n >= ln) {
- if (c1 != -1000) {
+ while (n >= st->ln) {
+ if (st->u.plus.c1 != -1000) {
if (do_utf8)
c = utf8n_to_uvchr((U8*)PL_reginput,
UTF8_MAXBYTES, 0,
c = UCHARAT(PL_reginput);
}
/* If it could work, try it. */
- if (c1 == -1000 || c == (UV)c1 || c == (UV)c2)
+ if (st->u.plus.c1 == -1000 || c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
{
- TRYPAREN(paren, n, PL_reginput, PLUS4);
+ TRYPAREN(st->u.plus.paren, n, PL_reginput, PLUS4);
/*** all unsaved local vars undefined at this point */
- REGCP_UNWIND(lastcp);
+ REGCP_UNWIND(st->u.plus.lastcp);
}
/* Couldn't or didn't -- back up. */
n--;
sayNO;
break;
case END:
- if (PL_reg_call_cc) {
- cur_call_cc = PL_reg_call_cc;
- end_re = PL_reg_re;
-
- /* Save *all* the positions. */
- cp = regcppush(0);
- REGCP_SET(lastcp);
+ if (cur_eval) {
+ /* we have successfully completed the execution of a
+ * postponed re. Pop all states back to the last EVAL
+ * then continue with the node following the (??{...})
+ */
- /* Restore parens of the caller. */
+ /* this simulates a POP_STATE, except that it pops several
+ * levels, and doesn't restore locinput */
+
+ st = cur_eval;
+ PL_regmatch_slab = st->u.eval.prev_slab;
+ cur_eval = st->u.eval.prev_eval;
+ depth = st->u.eval.depth;
+
+ PL_regmatch_state = st;
+ scan = st->scan;
+ next = st->next;
+ n = st->n;
+
+ if (st->u.eval.toggleutf)
+ PL_reg_flags ^= RF_utf8;
+ ReREFCNT_dec(rex);
+ rex = st->u.eval.prev_rex;
+ PL_reg_re = rex; /* XXX */
+ /* XXXX This is too dramatic a measure... */
+ PL_reg_maxiter = 0;
+
+ /* Restore parens of the caller without popping the
+ * savestack */
{
I32 tmp = PL_savestack_ix;
- PL_savestack_ix = PL_reg_call_cc->ss;
- regcppop();
+ PL_savestack_ix = st->u.eval.lastcp;
+ regcppop(rex);
PL_savestack_ix = tmp;
}
- /* Make position available to the callcc. */
- PL_reginput = locinput;
- cache_re(PL_reg_call_cc->re);
- oldcc = cc;
- cc = PL_reg_call_cc->cc;
- PL_reg_call_cc = PL_reg_call_cc->prev;
- REGMATCH(cur_call_cc->node, END);
- /*** all unsaved local vars undefined at this point */
- if (result) {
- PL_reg_call_cc = cur_call_cc;
- regcpblow(cp);
- sayYES;
- }
- REGCP_UNWIND(lastcp);
- regcppop();
- PL_reg_call_cc = cur_call_cc;
- cc = oldcc;
- PL_reg_re = end_re;
- cache_re(end_re);
+ PL_reginput = locinput;
+ /* resume at node following the (??{...}) */
+ break;
- DEBUG_EXECUTE_r(
- PerlIO_printf(Perl_debug_log,
- "%*s continuation failed...\n",
- REPORT_CODE_OFF+PL_regindent*2, "")
- );
- sayNO_SILENT;
}
+
if (locinput < PL_regtill) {
DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
"%sMatch possible, but length=%ld is smaller than requested=%ld, failing!%s\n",
case UNLESSM:
n = 0;
if (scan->flags) {
- char *s = HOPBACKc(locinput, scan->flags);
+ char * const s = HOPBACKc(locinput, scan->flags);
if (!s)
goto say_yes;
PL_reginput = s;
case IFMATCH:
n = 1;
if (scan->flags) {
- char *s = HOPBACKc(locinput, scan->flags);
+ char * const s = HOPBACKc(locinput, scan->flags);
if (!s)
goto say_no;
PL_reginput = s;
/*** all unsaved local vars undefined at this point */
if (result != n) {
say_no:
- if (logical) {
- logical = 0;
- sw = 0;
+ if (st->logical) {
+ st->logical = 0;
+ st->sw = 0;
goto do_longjump;
}
else
sayNO;
}
say_yes:
- if (logical) {
- logical = 0;
- sw = 1;
+ if (st->logical) {
+ st->logical = 0;
+ st->sw = 1;
}
if (OP(scan) == SUSPEND) {
locinput = PL_reginput;
start_recurse:
{
- /* save existing local variables */
- struct regmatch_state *p;
-
- Newx(p, 1, struct regmatch_state);
- p->prev_state = prev_state;
- prev_state = p;
- p->resume_state = resume_state;
- p->scan = scan;
- p->next = next;
- p->minmod = minmod;
- p->sw = sw;
- p->logical = logical;
- p->unwind = unwind;
- p->cc = cc;
- p->locinput = locinput;
- p->n = n;
- p->ln = ln;
- p->c1 = c1;
- p->c2 = c2;
- p->paren = paren;
- p->cp = cp;
- p->lastcp = lastcp;
- p->oldcc = oldcc;
- p->lastloc = lastloc;
- p->cache_offset = cache_offset;
- p->cache_bit = cache_bit;
- p->curlym_l = curlym_l;
- p->matches = matches;
- p->maxwanted = maxwanted;
- p->e = e;
- p->old = old;
- p->count = count;
- p->cur_call_cc = cur_call_cc;
- p->end_re = end_re;
- p->accept_buff = accept_buff;
- p->accepted = accepted;
- p->reg_call_cc = PL_reg_call_cc;
-
- scan = new_scan;
+ /* push new state */
+ regmatch_state *oldst = st;
+
+ depth++;
+
+ /* grab the next free state slot */
+ st++;
+ if (st > &(PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1]))
+ st = S_push_slab(aTHX);
+ PL_regmatch_state = st;
+
+ oldst->next = next;
+ oldst->n = n;
+ oldst->locinput = locinput;
+
+ st->cc = oldst->cc;
locinput = PL_reginput;
nextchr = UCHARAT(locinput);
- minmod = 0;
- sw = 0;
- logical = 0;
- unwind = 0;
+ st->minmod = 0;
+ st->sw = 0;
+ st->logical = 0;
+ st->unwind = 0;
#ifdef DEBUGGING
PL_regindent++;
#endif
}
}
+
+
/*
* We get here only if there's trouble -- normally "case END" is
* the terminating point.
#endif
result = 1;
- goto exit_level;
+ /* XXX this is duplicate(ish) code to that in the do_no section.
+ * eventually a yes should just pop the whole stack */
+ if (depth) {
+ /* restore previous state and re-enter */
+ POP_STATE;
+
+ switch (st->resume_state) {
+ case resume_TRIE1:
+ goto resume_point_TRIE1;
+ case resume_TRIE2:
+ goto resume_point_TRIE2;
+ case resume_EVAL:
+ break;
+ case resume_CURLYX:
+ goto resume_point_CURLYX;
+ case resume_WHILEM1:
+ goto resume_point_WHILEM1;
+ case resume_WHILEM2:
+ goto resume_point_WHILEM2;
+ case resume_WHILEM3:
+ goto resume_point_WHILEM3;
+ case resume_WHILEM4:
+ goto resume_point_WHILEM4;
+ case resume_WHILEM5:
+ goto resume_point_WHILEM5;
+ case resume_WHILEM6:
+ goto resume_point_WHILEM6;
+ case resume_CURLYM1:
+ goto resume_point_CURLYM1;
+ case resume_CURLYM2:
+ goto resume_point_CURLYM2;
+ case resume_CURLYM3:
+ goto resume_point_CURLYM3;
+ case resume_CURLYM4:
+ goto resume_point_CURLYM4;
+ case resume_IFMATCH:
+ goto resume_point_IFMATCH;
+ case resume_PLUS1:
+ goto resume_point_PLUS1;
+ case resume_PLUS2:
+ goto resume_point_PLUS2;
+ case resume_PLUS3:
+ goto resume_point_PLUS3;
+ case resume_PLUS4:
+ goto resume_point_PLUS4;
+ default:
+ Perl_croak(aTHX_ "regexp resume memory corruption");
+ }
+ }
+ goto final_exit;
no:
DEBUG_EXECUTE_r(
goto do_no;
no_final:
do_no:
- if (unwind) {
- re_unwind_t * const uw = SSPTRt(unwind,re_unwind_t);
+ if (st->unwind) {
+ re_unwind_t * const uw = SSPTRt(st->unwind,re_unwind_t);
switch (uw->type) {
case RE_UNWIND_BRANCH:
if ( !scan ||
OP(scan) != (uwb->type == RE_UNWIND_BRANCH
? BRANCH : BRANCHJ) ) { /* Failure */
- unwind = uwb->prev;
+ st->unwind = uwb->prev;
#ifdef DEBUGGING
PL_regindent--;
#endif
}
/* NOTREACHED */
}
+
#ifdef DEBUGGING
PL_regindent--;
#endif
result = 0;
-exit_level:
- if (prev_state) {
- /* restore previous state and re-enter */
- struct regmatch_state *p = prev_state;
- resume_state = p->resume_state;
- scan = p->scan;
- next = p->next;
- minmod = p->minmod;
- sw = p->sw;
- logical = p->logical;
- unwind = p->unwind;
- cc = p->cc;
- locinput = p->locinput;
- nextchr = UCHARAT(locinput);
- n = p->n;
- ln = p->ln;
- c1 = p->c1;
- c2 = p->c2;
- paren = p->paren;
- cp = p->cp;
- lastcp = p->lastcp;
- oldcc = p->oldcc;
- lastloc = p->lastloc;
- cache_offset = p->cache_offset;
- cache_bit = p->cache_bit;
- curlym_l = p->curlym_l;
- matches = p->matches;
- maxwanted = p->maxwanted;
- e = p->e;
- old = p->old;
- count = p->count;
- cur_call_cc = p->cur_call_cc;
- end_re = p->end_re;
- accept_buff = p->accept_buff;
- accepted = p->accepted;
- PL_reg_call_cc = p->reg_call_cc;
- prev_state = p->prev_state;
- Safefree(p);
-
- switch (resume_state) {
+ if (depth) {
+ /* there's a previous state to backtrack to */
+ POP_STATE;
+ switch (st->resume_state) {
case resume_TRIE1:
goto resume_point_TRIE1;
case resume_TRIE2:
goto resume_point_TRIE2;
+ case resume_EVAL:
+ /* we have failed an (??{...}). Restore state to the outer re
+ * then re-throw the failure */
+ if (st->u.eval.toggleutf)
+ PL_reg_flags ^= RF_utf8;
+ ReREFCNT_dec(rex);
+ rex = st->u.eval.prev_rex;
+ PL_reg_re = rex; /* XXX */
+ cur_eval = st->u.eval.prev_eval;
+
+ /* XXXX This is too dramatic a measure... */
+ PL_reg_maxiter = 0;
+
+ PL_reginput = locinput;
+ REGCP_UNWIND(st->u.eval.lastcp);
+ regcppop(rex);
+ goto do_no;
+
case resume_CURLYX:
goto resume_point_CURLYX;
case resume_WHILEM1:
goto resume_point_PLUS3;
case resume_PLUS4:
goto resume_point_PLUS4;
- case resume_END:
- goto resume_point_END;
default:
Perl_croak(aTHX_ "regexp resume memory corruption");
}
- /* NOTREACHED */
}
+
+final_exit:
+
+ /* restore original high-water mark */
+ PL_regmatch_slab = orig_slab;
+ PL_regmatch_state = orig_state;
+
+ /* free all slabs above current one */
+ if (orig_slab->next) {
+ regmatch_slab *osl, *sl = orig_slab->next;
+ orig_slab->next = NULL;
+ while (sl) {
+ osl = sl;
+ sl = sl->next;
+ Safefree(osl);
+ }
+ }
+
return result;
}
if (max == REG_INFTY)
max = I32_MAX;
else if (max < loceol - scan)
- loceol = scan + max;
+ loceol = scan + max;
switch (OP(p)) {
case REG_ANY:
if (do_utf8) {
SV *sw = NULL;
SV *si = NULL;
SV *alt = NULL;
+ const struct reg_data *data = PL_reg_re ? PL_reg_re->data : NULL;
- if (PL_regdata && PL_regdata->count) {
+ if (data && data->count) {
const U32 n = ARG(node);
- if (PL_regdata->what[n] == 's') {
- SV * const rv = (SV*)PL_regdata->data[n];
+ if (data->what[n] == 's') {
+ SV * const rv = (SV*)data->data[n];
AV * const av = (AV*)SvRV((SV*)rv);
SV **const ary = AvARRAY(av);
SV **a, **b;
if (do_utf8 && !UTF8_IS_INVARIANT(c)) {
c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &len,
- ckWARN(WARN_UTF8) ? UTF8_CHECK_ONLY :
- UTF8_ALLOW_ANYUV|UTF8_CHECK_ONLY);
+ (UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV) | UTF8_CHECK_ONLY);
+ /* see [perl #37836] for UTF8_ALLOW_ANYUV */
if (len == (STRLEN)-1)
Perl_croak(aTHX_ "Malformed UTF-8 character (fatal)");
}
}
STATIC U8 *
-S_reghop(pTHX_ U8 *s, I32 off)
-{
- dVAR;
- return S_reghop3(s, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr));
-}
-
-STATIC U8 *
S_reghop3(U8 *s, I32 off, U8* lim)
{
dVAR;
}
STATIC U8 *
-S_reghopmaybe(pTHX_ U8 *s, I32 off)
-{
- dVAR;
- return S_reghopmaybe3(s, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr));
-}
-
-STATIC U8 *
S_reghopmaybe3(U8* s, I32 off, U8* lim)
{
dVAR;
restore_pos(pTHX_ void *arg)
{
dVAR;
- PERL_UNUSED_ARG(arg);
+ regexp * const rex = (regexp *)arg;
if (PL_reg_eval_set) {
if (PL_reg_oldsaved) {
- PL_reg_re->subbeg = PL_reg_oldsaved;
- PL_reg_re->sublen = PL_reg_oldsavedlen;
+ rex->subbeg = PL_reg_oldsaved;
+ rex->sublen = PL_reg_oldsavedlen;
#ifdef PERL_OLD_COPY_ON_WRITE
- PL_reg_re->saved_copy = PL_nrs;
+ rex->saved_copy = PL_nrs;
#endif
- RX_MATCH_COPIED_on(PL_reg_re);
+ RX_MATCH_COPIED_on(rex);
}
PL_reg_magic->mg_len = PL_reg_oldpos;
PL_reg_eval_set = 0;
S_to_utf8_substr(pTHX_ register regexp *prog)
{
if (prog->float_substr && !prog->float_utf8) {
- SV* sv;
- prog->float_utf8 = sv = newSVsv(prog->float_substr);
+ SV* const sv = newSVsv(prog->float_substr);
+ prog->float_utf8 = sv;
sv_utf8_upgrade(sv);
if (SvTAIL(prog->float_substr))
SvTAIL_on(sv);
prog->check_utf8 = sv;
}
if (prog->anchored_substr && !prog->anchored_utf8) {
- SV* sv;
- prog->anchored_utf8 = sv = newSVsv(prog->anchored_substr);
+ SV* const sv = newSVsv(prog->anchored_substr);
+ prog->anchored_utf8 = sv;
sv_utf8_upgrade(sv);
if (SvTAIL(prog->anchored_substr))
SvTAIL_on(sv);
{
dVAR;
if (prog->float_utf8 && !prog->float_substr) {
- SV* sv;
- prog->float_substr = sv = newSVsv(prog->float_utf8);
+ SV* sv = newSVsv(prog->float_utf8);
+ prog->float_substr = sv;
if (sv_utf8_downgrade(sv, TRUE)) {
if (SvTAIL(prog->float_utf8))
SvTAIL_on(sv);
prog->check_substr = sv;
}
if (prog->anchored_utf8 && !prog->anchored_substr) {
- SV* sv;
- prog->anchored_substr = sv = newSVsv(prog->anchored_utf8);
+ SV* sv = newSVsv(prog->anchored_utf8);
+ prog->anchored_substr = sv;
if (sv_utf8_downgrade(sv, TRUE)) {
if (SvTAIL(prog->anchored_utf8))
SvTAIL_on(sv);