Change 27694 by davem@davem-splatty on 2006/04/03 01:31:12
anonymous unions aren't legal ANSI c
Affected files
//depot/perl/regexec.c#391 edit
//depot/perl/regexp.h#39 edit
Differences
//depot/perl/regexec.c#391 (text)
Index: perl/regexec.c
perl/regexec.c#390~27692~2006-04-02 16:50:25.000000000 -0700
perl/regexec.c2006-04-02 18:31:12.000000000 -0700
@@ -2250,7 +2250,7 @@
#define PSCACHE_SEEN 1/* we know what we're caching */
#define PSCACHE_START 2/* the real cache: this bit maps to pos 0 */
#define CACHEsayYES STMT_START { \
- if (st->whilem.cache_offset | st->whilem.cache_bit) { \
+ if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
if (!(PL_reg_poscache[0] & (1<<PSCACHE_SEEN))) \
PL_reg_poscache[0] |= (1<<PSCACHE_SUCCESS) || (1<<PSCACHE_SEEN); \
else if (!(PL_reg_poscache[0] & (1<<PSCACHE_SUCCESS))) { \
@@ -2260,13 +2260,13 @@
"%*s (remove success from failure cache)\n", \
REPRT_CDEFF+PL_regindent*2, "") \
); \
- PL_reg_poscache[st->whilem.cache_offset] &= ~(1<<st->whilem.cache_bit); \
+ PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
} \
} \
sayYES; \
} STMT_END
#define CACHEsayN STMT_START { \
- if (st->whilem.cache_offset | st->whilem.cache_bit) { \
+ if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
if (!(PL_reg_poscache[0] & (1<<PSCACHE_SEEN))) \
PL_reg_poscache[0] |= (1<<PSCACHE_SEEN); \
else if ((PL_reg_poscache[0] & (1<<PSCACHE_SUCCESS))) { \
@@ -2276,7 +2276,7 @@
"%*s (remove failure from success cache)\n", \
REPRT_CDEFF+PL_regindent*2, "") \
); \
- PL_reg_poscache[st->whilem.cache_offset] &= ~(1<<st->whilem.cache_bit); \
+ PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
} \
} \
sayN; \
@@ -2654,13 +2654,13 @@
/* what trie are we using right now */
reg_trie_data *trie
= (reg_trie_data*)PL_regdata->data[ ARG( scan ) ];
- st->trie.accepted = 0; /* how many accepting states we have seen */
+ st->u.trie.accepted = 0; /* how many accepting states we have seen */
result = 0;
while ( state && uc <= (U8*)PL_regeol ) {
if (trie->states[ state ].wordnum) {
-if (!st->trie.accepted ) {
+if (!st->u.trie.accepted ) {
ENTER;
SAVETMPS;
bufflen = TRIE_INITAL_ACCEPT_BUFFLEN;
@@ -2670,22 +2670,22 @@
sizeof(reg_trie_accepted));
SvPK_on(sv_accept_buff);
sv_2mortal(sv_accept_buff);
- st->trie.accept_buff =
+ st->u.trie.accept_buff =
(reg_trie_accepted*)SvPV_nolen(sv_accept_buff );
}
else {
- if (st->trie.accepted >= bufflen) {
+ if (st->u.trie.accepted >= bufflen) {
bufflen *= 2;
-st->trie.accept_buff =(reg_trie_accepted*)
+st->u.trie.accept_buff =(reg_trie_accepted*)
SvGRW(sv_accept_buff,
bufflen * sizeof(reg_trie_accepted));
}
SvCUR_set(sv_accept_buff,SvCUR(sv_accept_buff)
+ sizeof(reg_trie_accepted));
}
-st->trie.accept_buff[st->trie.accepted].wordnum = trie->states[state].wordnum;
-st->trie.accept_buff[st->trie.accepted].endpos = uc;
-++st->trie.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;
@@ -2694,7 +2694,7 @@
PerlI( Perl_debug_log,
"%*s %sState: %4"UVxf", Base: %4"UVxf", Accepted: %4"UVxf" ",
REPRT_CDEFF + PL_regindent * 2, "", PL_colors[4],
- (UV)state, (UV)base, (UV)st->trie.accepted );
+ (UV)state, (UV)base, (UV)st->u.trie.accepted );
);
if ( base ) {
@@ -2761,7 +2761,7 @@
charid, uvc, (UV)state, PL_colors[5] );
);
}
-if (!st->trie.accepted )
+if (!st->u.trie.accepted )
sayN;
/*
@@ -2777,17 +2777,17 @@
have been tried.
*/
-if ( st->trie.accepted == 1 ) {
+if ( st->u.trie.accepted == 1 ) {
DEBUG_EXECUTE_r({
- SV **tmp = av_fetch( trie->words, st->trie.accept_buff[ 0 ].wordnum-1, 0 );
+ SV **tmp = av_fetch( trie->words, st->u.trie.accept_buff[ 0 ].wordnum-1, 0 );
PerlI( Perl_debug_log,
"%*s %sonly one match : #%d <%s>%s\n",
REPRT_CDEFF+PL_regindent*2, "", PL_colors[4],
- st->trie.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 *)st->trie.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;
@@ -2797,40 +2797,40 @@
} else {
DEBUG_EXECUTE_r(
PerlI( Perl_debug_log,"%*s %sgot %"IVdf" possible matches%s\n",
- REPRT_CDEFF + PL_regindent * 2, "", PL_colors[4], (IV)st->trie.accepted,
+ REPRT_CDEFF + PL_regindent * 2, "", PL_colors[4], (IV)st->u.trie.accepted,
PL_colors[5] );
);
- while ( !result && st->trie.accepted-- ) {
+ while ( !result && st->u.trie.accepted-- ) {
U32 best = 0;
U32 cur;
-for( cur = 1 ; cur <= st->trie.accepted ; cur++ ) {
+for( cur = 1 ; cur <= st->u.trie.accepted ; cur++ ) {
DEBUG_TRIE_EXECUTE_r(
PerlI( Perl_debug_log,
"%*s %sgot %"IVdf" (%d) as best, looking at %"IVdf" (%d)%s\n",
REPRT_CDEFF + PL_regindent * 2, "", PL_colors[4],
- (IV)best, st->trie.accept_buff[ best ].wordnum, (IV)cur,
- st->trie.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 (st->trie.accept_buff[cur].wordnum <
- st->trie.accept_buff[best].wordnum)
+ 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, st->trie.accept_buff[ best ].wordnum - 1, 0 );
+ SV ** const tmp = av_fetch( trie->words, st->u.trie.accept_buff[ best ].wordnum - 1, 0 );
PerlI( Perl_debug_log, "%*s %strying alternation #%d <%sat 0x%p%s\n",
REPRT_CDEFF+PL_regindent*2, "", PL_colors[4],
- st->trie.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<st->trie.accepted ) {
- reg_trie_accepted tmp = st->trie.accept_buff[ best ];
- st->trie.accept_buff[ best ] = st->trie.accept_buff[ st->trie.accepted ];
- st->trie.accept_buff[ st->trie.accepted ] = tmp;
- best = st->trie.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 *)st->trie.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
@@ -3347,8 +3347,8 @@
st->cc = 0;
- st->eval.cp = regcppush(0);/* Save *all* the positions. */
- REGCP_SET(st->eval.lastcp);
+ st->u.eval.cp = regcppush(0);/* Save *all* the positions. */
+ REGCP_SET(st->u.eval.lastcp);
cache_re(re);
state.ss = PL_savestack_ix;
*PL_reglastparen = 0;
@@ -3380,11 +3380,11 @@
/* These are needed even if not SUSPEND. */
ReREFCNT_dec(re);
-regcpblow(st->eval.cp);
+regcpblow(st->u.eval.cp);
sayYES;
}
ReREFCNT_dec(re);
- REGCP_UNWIND(st->eval.lastcp);
+ REGCP_UNWIND(st->u.eval.lastcp);
regcppop();
PL_reg_call_cc = state.prev;
st->cc = state.cc;
@@ -3526,25 +3526,25 @@
if (parenfloor (I32)*PL_reglastparen)
parenfloor = *PL_reglastparen; /* Pessimization */
-st->curlyx.cp = PL_savestack_ix;
-st->curlyx.outercc = st->cc;
+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->curlyx.parenfloor = parenfloor;
-st->curlyx.cur = -1; /* this will be updated by WHILEM */
-st->curlyx.min = ARG1(scan);
-st->curlyx.max = ARG2(scan);
-st->curlyx.scan = NEXTPER(scan) + EXTRA_STEP_2ARGS;
-st->curlyx.lastloc = 0;
+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 = NEXTPER(scan) + EXTRA_STEP_2ARGS;
+st->u.curlyx.lastloc = 0;
/* st->next and st->minmod are also read by WHILEM */
PL_reginput = locinput;
REGMATCH(PREVPER(next), CURLYX); /* start on the WHILEM */
/ all unsaved local vars undefined at this point */
-regcpblow(st->curlyx.cp);
-st->cc = st->curlyx.outercc;
+regcpblow(st->u.curlyx.cp);
+st->cc = st->u.curlyx.outercc;
saySAME(result);
}
/* NTREACHED */
@@ -3558,54 +3558,54 @@
* that we can try again after backing off.
*/
-st->whilem.lastloc = st->cc->curlyx.lastloc; /* Detection of 0-len. */
-st->whilem.cache_offset = 0;
-st->whilem.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 = st->cc->curlyx.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(
PerlI(Perl_debug_log,
"%*s %ld out of %ld%ld cc=%"UVxf"\n",
REPRT_CDEFF+PL_regindent*2, "",
- (long)n, (long)st->cc->curlyx.min,
- (long)st->cc->curlyx.max, PTR2UV(st->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 == st->cc->curlyx.lastloc && n >= st->cc->curlyx.min) {
- st->whilem.savecc = st->cc;
- st->cc = st->cc->curlyx.outercc;
+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->curlyx.cur;
+st->ln = st->cc->u.curlyx.cur;
DEBUG_EXECUTE_r(
PerlI(Perl_debug_log,
"%*s empty match detected, try continuation\n",
REPRT_CDEFF+PL_regindent*2, "")
);
- REGMATCH(st->whilem.savecc->next, WHILEM1);
+ REGMATCH(st->u.whilem.savecc->next, WHILEM1);
/ all unsaved local vars undefined at this point */
- st->cc = st->whilem.savecc;
+ st->cc = st->u.whilem.savecc;
if (result)
sayYES;
- if (st->cc->curlyx.outercc)
-st->cc->curlyx.outercc->curlyx.cur = st->ln;
+ if (st->cc->u.curlyx.outercc)
+st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
sayN;
}
/* First just match a string of min scans. */
-if (n < st->cc->curlyx.min) {
- st->cc->curlyx.cur = n;
- st->cc->curlyx.lastloc = locinput;
- REGMATCH(st->cc->curlyx.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;
- st->cc->curlyx.cur = n - 1;
- st->cc->curlyx.lastloc = st->whilem.lastloc;
+ st->cc->u.curlyx.cur = n - 1;
+ st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
sayN;
}
@@ -3637,13 +3637,13 @@
);
}
if (PL_reg_leftiter < 0) {
- st->whilem.cache_offset = locinput - PL_bostr;
+ st->u.whilem.cache_offset = locinput - PL_bostr;
- st->whilem.cache_offset = (scan->flags & 0xf) - 1 + PSCACHE_START
- + st->whilem.cache_offset * (scan->flags>>4);
- st->whilem.cache_bit = st->whilem.cache_offset % 8;
- st->whilem.cache_offset /= 8;
- if (PL_reg_poscache[st->whilem.cache_offset] & (1<<st->whilem.cache_bit)) {
+ st->u.whilem.cache_offset = (scan->flags & 0xf) - 1 + PSCACHE_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(
PerlI(Perl_debug_log,
"%*s already tried at this position\n",
@@ -3656,32 +3656,32 @@
/* cache records failure */
sayNSILENT;
}
- PL_reg_poscache[st->whilem.cache_offset] |= (1<<st->whilem.cache_bit);
+ PL_reg_poscache[st->u.whilem.cache_offset] |= (1<<st->u.whilem.cache_bit);
}
}
/* Prefer next over scan for minimal matching. */
if (st->cc->minmod) {
- st->whilem.savecc = st->cc;
- st->cc = st->cc->curlyx.outercc;
+ st->u.whilem.savecc = st->cc;
+ st->cc = st->cc->u.curlyx.outercc;
if (st->cc)
-st->ln = st->cc->curlyx.cur;
- st->whilem.cp = regcppush(st->whilem.savecc->curlyx.parenfloor);
- REGCP_SET(st->whilem.lastcp);
- REGMATCH(st->whilem.savecc->next, WHILEM3);
+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 */
- st->cc = st->whilem.savecc;
+ st->cc = st->u.whilem.savecc;
if (result) {
-regcpblow(st->whilem.cp);
+regcpblow(st->u.whilem.cp);
CACHEsayYES;/* All done. */
}
- REGCP_UNWIND(st->whilem.lastcp);
+ REGCP_UNWIND(st->u.whilem.lastcp);
regcppop();
- if (st->cc->curlyx.outercc)
-st->cc->curlyx.outercc->curlyx.cur = st->ln;
+ if (st->cc->u.curlyx.outercc)
+st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
- if (n >= st->cc->curlyx.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;
@@ -3699,37 +3699,37 @@
);
/* Try scanning more and see if it helps. */
PL_reginput = locinput;
- st->cc->curlyx.cur = n;
- st->cc->curlyx.lastloc = locinput;
- st->whilem.cp = regcppush(st->cc->curlyx.parenfloor);
- REGCP_SET(st->whilem.lastcp);
- REGMATCH(st->cc->curlyx.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(st->whilem.cp);
+regcpblow(st->u.whilem.cp);
CACHEsayYES;
}
- REGCP_UNWIND(st->whilem.lastcp);
+ REGCP_UNWIND(st->u.whilem.lastcp);
regcppop();
- st->cc->curlyx.cur = n - 1;
- st->cc->curlyx.lastloc = st->whilem.lastloc;
+ st->cc->u.curlyx.cur = n - 1;
+ st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
CACHEsayN;
}
/* Prefer scan over next for maximal matching. */
-if (n < st->cc->curlyx.max) {/* More greed allowed? */
- st->whilem.cp = regcppush(st->cc->curlyx.parenfloor);
- st->cc->curlyx.cur = n;
- st->cc->curlyx.lastloc = locinput;
- REGCP_SET(st->whilem.lastcp);
- REGMATCH(st->cc->curlyx.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(st->whilem.cp);
+regcpblow(st->u.whilem.cp);
CACHEsayYES;
}
- REGCP_UNWIND(st->whilem.lastcp);
+ REGCP_UNWIND(st->u.whilem.lastcp);
regcppop();/* Restore some previous $<digit>s? */
PL_reginput = locinput;
DEBUG_EXECUTE_r(
@@ -3747,19 +3747,19 @@
}
/* Failed deeper matches of scan, so see if this one works. */
-st->whilem.savecc = st->cc;
-st->cc = st->cc->curlyx.outercc;
+st->u.whilem.savecc = st->cc;
+st->cc = st->cc->u.curlyx.outercc;
if (st->cc)
- st->ln = st->cc->curlyx.cur;
-REGMATCH(st->whilem.savecc->next, WHILEM6);
+ st->ln = st->cc->u.curlyx.cur;
+REGMATCH(st->u.whilem.savecc->next, WHILEM6);
/ all unsaved local vars undefined at this point */
-st->cc = st->whilem.savecc;
+st->cc = st->u.whilem.savecc;
if (result)
CACHEsayYES;
-if (st->cc->curlyx.outercc)
- st->cc->curlyx.outercc->curlyx.cur = st->ln;
-st->cc->curlyx.cur = n - 1;
-st->cc->curlyx.lastloc = st->whilem.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;
CACHEsayN;
}
/* NTREACHED */
@@ -3808,45 +3808,45 @@
break;
case CURLYM:
{
- st->curlym.l = st->curlym.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. */
st->ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
- st->curlym.paren = scan->flags;
- if (st->curlym.paren) {
-if (st->curlym.paren PL_regsize)
- PL_regsize = st->curlym.paren;
-if (st->curlym.paren (I32)*PL_reglastparen)
- *PL_reglastparen = st->curlym.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 = NEXTPER(scan) + NDE_STEP_REGNDE;
- if (st->curlym.paren)
+ if (st->u.curlym.paren)
scan += NEXTFF(scan); /* Skip former PEN. */
PL_reginput = locinput;
- st->curlym.maxwanted = st->minmod ? st->ln : n;
- if (st->curlym.maxwanted) {
-while (PL_reginput < PL_regeol && st->curlym.matches < st->curlym.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 (!st->curlym.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) {
-st->curlym.l++;
+st->u.curlym.l++;
s += UTF8SKIP(s);
}
}
else {
- st->curlym.l = PL_reginput - locinput;
+ st->u.curlym.l = PL_reginput - locinput;
}
-if (st->curlym.l == 0) {
- st->curlym.matches = st->curlym.maxwanted;
+if (st->u.curlym.l == 0) {
+ st->u.curlym.matches = st->u.curlym.maxwanted;
break;
}
}
@@ -3858,52 +3858,52 @@
if (st->minmod) {
st->minmod = 0;
-if (st->ln && st->curlym.matches < st->ln)
+if (st->ln && st->u.curlym.matches < st->ln)
sayN;
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)) st->curlym.c1 = st->curlym.c2 = -1000;
+ if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
else {
if (PL_regkind[(U8)P(text_node)] == REF) {
- st->curlym.c1 = st->curlym.c2 = -1000;
+ st->u.curlym.c1 = st->u.curlym.c2 = -1000;
goto assume_ok_MM;
}
-else { st->curlym.c1 = (U8)*STRING(text_node); }
+else { st->u.curlym.c1 = (U8)*STRING(text_node); }
if (P(text_node) == EXACTF || P(text_node) == REFF)
- st->curlym.c2 = PL_fold[st->curlym.c1];
+ st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
else if (P(text_node) == EXACTFL || P(text_node) == REFFL)
- st->curlym.c2 = PL_fold_locale[st->curlym.c1];
+ st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
else
- st->curlym.c2 = st->curlym.c1;
+ st->u.curlym.c2 = st->u.curlym.c1;
}
}
else
- st->curlym.c1 = st->curlym.c2 = -1000;
+ st->u.curlym.c1 = st->u.curlym.c2 = -1000;
assume_ok_MM:
-REGCP_SET(st->curlym.lastcp);
+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 (st->curlym.c1 == -1000 ||
-UCHARAT(PL_reginput) == st->curlym.c1 ||
-UCHARAT(PL_reginput) == st->curlym.c2)
+ if (st->u.curlym.c1 == -1000 ||
+UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+UCHARAT(PL_reginput) == st->u.curlym.c2)
{
-if (st->curlym.paren) {
+if (st->u.curlym.paren) {
if (st->ln) {
-PL_regstartp[st->curlym.paren] =
- HPc(PL_reginput, -st->curlym.l) - PL_bostr;
-PL_regendp[st->curlym.paren] = PL_reginput - PL_bostr;
+PL_regstartp[st->u.curlym.paren] =
+ HPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
}
else
-PL_regendp[st->curlym.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(st->curlym.lastcp);
+REGCP_UNWIND(st->u.curlym.lastcp);
}
/* Couldn't or didn't -- move forward. */
PL_reginput = locinput;
@@ -3922,65 +3922,65 @@
PerlI(Perl_debug_log,
"%*s matched %"IVdf" times, len=%"IVdf"\n",
(int)(REPRT_CDEFF+PL_regindent*2), "",
- (IV) st->curlym.matches, (IV)st->curlym.l)
+ (IV) st->u.curlym.matches, (IV)st->u.curlym.l)
);
-if (st->curlym.matches >= st->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)) st->curlym.c1 = st->curlym.c2 = -1000;
+if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
else {
if (PL_regkind[(U8)P(text_node)] == REF) {
-st->curlym.c1 = st->curlym.c2 = -1000;
+st->u.curlym.c1 = st->u.curlym.c2 = -1000;
goto assume_ok_REG;
}
- else { st->curlym.c1 = (U8)*STRING(text_node); }
+ else { st->u.curlym.c1 = (U8)*STRING(text_node); }
if (P(text_node) == EXACTF || P(text_node) == REFF)
-st->curlym.c2 = PL_fold[st->curlym.c1];
+st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
else if (P(text_node) == EXACTFL || P(text_node) == REFFL)
-st->curlym.c2 = PL_fold_locale[st->curlym.c1];
+st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
else
-st->curlym.c2 = st->curlym.c1;
+st->u.curlym.c2 = st->u.curlym.c1;
}
}
else
-st->curlym.c1 = st->curlym.c2 = -1000;
+st->u.curlym.c1 = st->u.curlym.c2 = -1000;
}
assume_ok_REG:
-REGCP_SET(st->curlym.lastcp);
-while (st->curlym.matches >= st->ln) {
+REGCP_SET(st->u.curlym.lastcp);
+while (st->u.curlym.matches >= st->ln) {
/* If it could work, try it. */
- if (st->curlym.c1 == -1000 ||
-UCHARAT(PL_reginput) == st->curlym.c1 ||
-UCHARAT(PL_reginput) == st->curlym.c2)
+ if (st->u.curlym.c1 == -1000 ||
+UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+UCHARAT(PL_reginput) == st->u.curlym.c2)
{
DEBUG_EXECUTE_r(
PerlI(Perl_debug_log,
"%*s trying tail with matches=%"IVdf"\n",
(int)(REPRT_CDEFF+PL_regindent*2),
-"", (IV)st->curlym.matches)
+"", (IV)st->u.curlym.matches)
);
-if (st->curlym.paren) {
- if (st->curlym.matches) {
-PL_regstartp[st->curlym.paren]
- = HPc(PL_reginput, -st->curlym.l) - PL_bostr;
-PL_regendp[st->curlym.paren] = PL_reginput - PL_bostr;
+if (st->u.curlym.paren) {
+ if (st->u.curlym.matches) {
+PL_regstartp[st->u.curlym.paren]
+ = HPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
}
else
-PL_regendp[st->curlym.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(st->curlym.lastcp);
+REGCP_UNWIND(st->u.curlym.lastcp);
}
/* Couldn't or didn't -- back up. */
- st->curlym.matches--;
- locinput = HPc(locinput, -st->curlym.l);
+ st->u.curlym.matches--;
+ locinput = HPc(locinput, -st->u.curlym.l);
PL_reginput = locinput;
}
}
@@ -3989,17 +3989,17 @@
break;
}
case CURLYN:
- st->plus.paren = scan->flags;/* Which paren to set */
- if (st->plus.paren PL_regsize)
-PL_regsize = st->plus.paren;
- if (st->plus.paren (I32)*PL_reglastparen)
-*PL_reglastparen = st->plus.paren;
+ 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(NEXTPER(scan) + NDE_STEP_REGNDE);
goto repeat;
case CURLY:
- st->plus.paren = 0;
+ st->u.plus.paren = 0;
st->ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
scan = NEXTPER(scan) + NDE_STEP_REGNDE;
@@ -4008,13 +4008,13 @@
st->ln = 0;
n = REG_INFTY;
scan = NEXTPER(scan);
- st->plus.paren = 0;
+ st->u.plus.paren = 0;
goto repeat;
case PLUS:
st->ln = 1;
n = REG_INFTY;
scan = NEXTPER(scan);
- st->plus.paren = 0;
+ st->u.plus.paren = 0;
repeat:
/*
* Lookahead to avoid useless match attempts
@@ -4033,20 +4033,20 @@
if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
-if (! HAS_TEXT(text_node)) st->plus.c1 = st->plus.c2 = -1000;
+if (! HAS_TEXT(text_node)) st->u.plus.c1 = st->u.plus.c2 = -1000;
else {
if (PL_regkind[(U8)P(text_node)] == REF) {
-st->plus.c1 = st->plus.c2 = -1000;
+st->u.plus.c1 = st->u.plus.c2 = -1000;
goto assume_ok_easy;
}
else { s = (U8*)STRING(text_node); }
if (!UTF) {
-st->plus.c2 = st->plus.c1 = *s;
+st->u.plus.c2 = st->u.plus.c1 = *s;
if (P(text_node) == EXACTF || P(text_node) == REFF)
- st->plus.c2 = PL_fold[st->plus.c1];
+ st->u.plus.c2 = PL_fold[st->u.plus.c1];
else if (P(text_node) == EXACTFL || P(text_node) == REFFL)
- st->plus.c2 = PL_fold_locale[st->plus.c1];
+ st->u.plus.c2 = PL_fold_locale[st->u.plus.c1];
}
else { /* UTF */
if (P(text_node) == EXACTF || P(text_node) == REFF) {
@@ -4057,20 +4057,20 @@
to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
- st->plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
+ st->u.plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
uniflags);
- st->plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
+ st->u.plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
uniflags);
}
else {
- st->plus.c2 = st->plus.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
-st->plus.c1 = st->plus.c2 = -1000;
+st->u.plus.c1 = st->u.plus.c2 = -1000;
assume_ok_easy:
PL_reginput = locinput;
if (st->minmod) {
@@ -4078,96 +4078,96 @@
if (st->ln && regrepeat(scan, st->ln) < st->ln)
sayN;
locinput = PL_reginput;
-REGCP_SET(st->plus.lastcp);
-if (st->plus.c1 != -1000) {
- st->plus.old = locinput;
- st->plus.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) {
-st->plus.e = PL_regeol - 1;
+st->u.plus.e = PL_regeol - 1;
if (do_utf8)
- while (UTF8_IS_CNTINUATIN(*(U8*)st->plus.e))
-st->plus.e--;
+ while (UTF8_IS_CNTINUATIN(*(U8*)st->u.plus.e))
+st->u.plus.e--;
}
else if (do_utf8) {
int m = n - st->ln;
-for (st->plus.e = locinput;
- m >0 && st->plus.e + UTF8SKIP(st->plus.e) <= PL_regeol; m--)
- st->plus.e += UTF8SKIP(st->plus.e);
+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 {
-st->plus.e = locinput + n - st->ln;
-if (st->plus.e >= PL_regeol)
- st->plus.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 (st->plus.c1 == st->plus.c2) {
-while (locinput <= st->plus.e &&
- UCHARAT(locinput) != st->plus.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 <= st->plus.e
- && UCHARAT(locinput) != st->plus.c1
- && UCHARAT(locinput) != st->plus.c2)
+while (locinput <= st->u.plus.e
+ && UCHARAT(locinput) != st->u.plus.c1
+ && UCHARAT(locinput) != st->u.plus.c2)
locinput++;
}
- st->plus.count = locinput - st->plus.old;
+ st->u.plus.count = locinput - st->u.plus.old;
}
else {
- if (st->plus.c1 == st->plus.c2) {
+ if (st->u.plus.c1 == st->u.plus.c2) {
STRLEN len;
/* count initialised to
* utf8_distance(old, locinput) */
-while (locinput <= st->plus.e &&
+while (locinput <= st->u.plus.e &&
utf8n_to_uvchr((U8*)locinput,
UTF8_MAXBYTES, &len,
- uniflags) != (UV)st->plus.c1) {
+ uniflags) != (UV)st->u.plus.c1) {
locinput += len;
- st->plus.count++;
+ st->u.plus.count++;
}
} else {
STRLEN len;
/* count initialised to
* utf8_distance(old, locinput) */
-while (locinput <= st->plus.e) {
+while (locinput <= st->u.plus.e) {
UV c = utf8n_to_uvchr((U8*)locinput,
UTF8_MAXBYTES, &len,
uniflags);
- if (c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+ if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
break;
locinput += len;
- st->plus.count++;
+ st->u.plus.count++;
}
}
}
-if (locinput st->plus.e)
+if (locinput st->u.plus.e)
sayN;
/* PL_reginput == old now */
-if (locinput != st->plus.old) {
+if (locinput != st->u.plus.old) {
st->ln = 1;/* Did some */
- if (regrepeat(scan, st->plus.count) < st->plus.count)
+ if (regrepeat(scan, st->u.plus.count) < st->u.plus.count)
sayN;
}
/* PL_reginput == locinput now */
-TRYPAREN(st->plus.paren, st->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(st->plus.lastcp);
+REGCP_UNWIND(st->u.plus.lastcp);
/* Couldn't or didn't -- move forward. */
-st->plus.old = locinput;
+st->u.plus.old = locinput;
if (do_utf8)
locinput += UTF8SKIP(locinput);
else
locinput++;
-st->plus.count = 1;
+st->u.plus.count = 1;
}
}
else
while (n >= st->ln || (n == REG_INFTY && st->ln 0)) { /* ln overflow ? */
UV c;
- if (st->plus.c1 != -1000) {
+ if (st->u.plus.c1 != -1000) {
if (do_utf8)
c = utf8n_to_uvchr((U8*)PL_reginput,
UTF8_MAXBYTES, 0,
@@ -4175,19 +4175,19 @@
else
c = UCHARAT(PL_reginput);
/* If it could work, try it. */
- if (c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+ if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
{
- TRYPAREN(st->plus.paren, st->ln, PL_reginput, PLUS2);
+ TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS2);
/ all unsaved local vars undefined at this point */
- REGCP_UNWIND(st->plus.lastcp);
+ REGCP_UNWIND(st->u.plus.lastcp);
}
}
/* If it could work, try it. */
- else if (st->plus.c1 == -1000)
+ else if (st->u.plus.c1 == -1000)
{
-TRYPAREN(st->plus.paren, st->ln, PL_reginput, PLUS3);
+TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS3);
/ all unsaved local vars undefined at this point */
-REGCP_UNWIND(st->plus.lastcp);
+REGCP_UNWIND(st->u.plus.lastcp);
}
/* Couldn't or didn't -- move forward. */
PL_reginput = locinput;
@@ -4213,11 +4213,11 @@
if (UCHARAT(PL_reginput - 1) == '\n' && P(next) != ES)
st->ln--;
}
-REGCP_SET(st->plus.lastcp);
+REGCP_SET(st->u.plus.lastcp);
{
UV c = 0;
while (n >= st->ln) {
-if (st->plus.c1 != -1000) {
+if (st->u.plus.c1 != -1000) {
if (do_utf8)
c = utf8n_to_uvchr((U8*)PL_reginput,
UTF8_MAXBYTES, 0,
@@ -4226,11 +4226,11 @@
c = UCHARAT(PL_reginput);
}
/* If it could work, try it. */
-if (st->plus.c1 == -1000 || c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+if (st->u.plus.c1 == -1000 || c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
{
-TRYPAREN(st->plus.paren, n, PL_reginput, PLUS4);
+TRYPAREN(st->u.plus.paren, n, PL_reginput, PLUS4);
/ all unsaved local vars undefined at this point */
-REGCP_UNWIND(st->plus.lastcp);
+REGCP_UNWIND(st->u.plus.lastcp);
}
/* Couldn't or didn't -- back up. */
n--;
@@ -4242,12 +4242,12 @@
break;
case END:
if (PL_reg_call_cc) {
-st->end.cur_call_cc = PL_reg_call_cc;
-st->end.end_re = PL_reg_re;
+st->u.end.cur_call_cc = PL_reg_call_cc;
+st->u.end.end_re = PL_reg_re;
/* Save *all* the positions. */
-st->end.cp = regcppush(0);
-REGCP_SET(st->end.lastcp);
+st->u.end.cp = regcppush(0);
+REGCP_SET(st->u.end.lastcp);
/* Restore parens of the caller. */
{
@@ -4261,22 +4261,22 @@
PL_reginput = locinput;
cache_re(PL_reg_call_cc->re);
-st->end.savecc = st->cc;
+st->u.end.savecc = st->cc;
st->cc = PL_reg_call_cc->cc;
PL_reg_call_cc = PL_reg_call_cc->prev;
-REGMATCH(st->end.cur_call_cc->node, END);
+REGMATCH(st->u.end.cur_call_cc->node, END);
/ all unsaved local vars undefined at this point */
if (result) {
- PL_reg_call_cc = st->end.cur_call_cc;
- regcpblow(st->end.cp);
+ PL_reg_call_cc = st->u.end.cur_call_cc;
+ regcpblow(st->u.end.cp);
sayYES;
}
-REGCP_UNWIND(st->end.lastcp);
+REGCP_UNWIND(st->u.end.lastcp);
regcppop();
-PL_reg_call_cc = st->end.cur_call_cc;
-st->cc = st->end.savecc;
-PL_reg_re = st->end.end_re;
-cache_re(st->end.end_re);
+PL_reg_call_cc = st->u.end.cur_call_cc;
+st->cc = st->u.end.savecc;
+PL_reg_re = st->u.end.end_re;
+cache_re(st->u.end.end_re);
DEBUG_EXECUTE_r(
PerlI(Perl_debug_log,
//depot/perl/regexp.h#39 (text)
Index: perl/regexp.h
perl/regexp.h#38~27691~2006-04-02 15:37:57.000000000 -0700
perl/regexp.h2006-04-02 18:31:12.000000000 -0700
@@ -271,7 +271,7 @@
re_cc_state *cur_call_cc;
regexp *end_re;
} end;
- };
+ } u;
re_cc_state *reg_call_cc;/* saved value of PL_reg_call_cc */
} regmatch_state;
End of Patch.