From: Gurusamy Sarathy Date: Fri, 3 Dec 1999 04:02:39 +0000 (+0000) Subject: revert change#4618 (breaks C<$_ = 'A:B'; s/^[a-z]:/x/>) X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=34baa6c30415f54e9b8c2e622de1e229cf36d781;p=p5sagit%2Fp5-mst-13.2.git revert change#4618 (breaks C<$_ = 'A:B'; s/^[a-z]:/x/>) p4raw-link: @4618 on //depot/perl: f9d9cdce9cbb41baf3d0716ebac8540732d59bf8 p4raw-id: //depot/perl@4622 --- diff --git a/Changes b/Changes index 6409d35..2bb5cbd 100644 --- a/Changes +++ b/Changes @@ -79,6 +79,107 @@ Version 5.005_63 Development release working toward 5.6 ---------------- ____________________________________________________________________________ +[ 4621] By: gsar on 1999/12/02 22:24:53 + Log: caveat about thread-safety of extensions + Branch: perl + ! pod/perlfork.pod +____________________________________________________________________________ +[ 4620] By: gsar on 1999/12/02 20:31:02 + Log: XS documentation patches suggested by Ilya, severally adjusted + Branch: perl + ! pod/perlxs.pod pod/perlxstut.pod +____________________________________________________________________________ +[ 4619] By: gsar on 1999/12/02 17:52:50 + Log: re-add missing Unicode database master + Branch: perl + + lib/unicode/Unicode.300 +____________________________________________________________________________ +[ 4618] By: gsar on 1999/12/02 06:56:18 + Log: applied suggested patch with prototype changes + From: Ilya Zakharevich + Date: Tue, 23 Nov 1999 22:55:55 EST + Message-Id: <199911240355.WAA23033@monk.mps.ohio-state.edu> + Subject: [PATCH 5.005_62] First char cognizance + Branch: perl + ! embed.h embed.pl perl.h proto.h regcomp.c regcomp.h +____________________________________________________________________________ +[ 4617] By: gsar on 1999/12/02 06:04:57 + Log: fixes for bugs in change#4586 and OS/2 pod tweak, from Ilya + Branch: perl + ! os2/OS2/REXX/REXX.pm regexec.c t/op/re_tests +____________________________________________________________________________ +[ 4616] By: gsar on 1999/12/02 04:30:22 + Log: various documentation tweaks suggested by M. J. T. Guy + Branch: perl + ! INSTALL lib/strict.pm pod/perlfunc.pod pod/perlsyn.pod +____________________________________________________________________________ +[ 4615] By: gsar on 1999/12/02 04:17:43 + Log: various File::Glob fixes for DOSISH platforms + From: "Moore, Paul" + Date: Tue, 02 Nov 1999 11:11:25 GMT + Message-Id: <714DFA46B9BBD0119CD000805FC1F53BDC38E3@UKRUX002.rundc.uk.origin-it.com> + Subject: File::Glob again. Final patch, honest! + Branch: perl + + t/lib/glob-case.t + ! MANIFEST ext/File/Glob/Changes ext/File/Glob/Glob.pm + ! ext/File/Glob/Glob.xs ext/File/Glob/bsd_glob.c + ! ext/File/Glob/bsd_glob.h op.c t/lib/glob-global.t +____________________________________________________________________________ +[ 4614] By: gsar on 1999/12/02 03:42:55 + Log: allow XSUBs and prototyped subroutines to be used with sort() (tweaked + variant of patch suggested by Peter Haworth ) + Branch: perl + ! pod/perldelta.pod pod/perlfunc.pod pp_ctl.c t/op/sort.t +____________________________________________________________________________ +[ 4613] By: gsar on 1999/12/02 01:59:19 + Log: ignore yet another known scalar leak + Branch: perl + ! t/pragma/warn/regcomp +____________________________________________________________________________ +[ 4612] By: gsar on 1999/12/02 01:15:02 + Log: avoid potential stack extension bug in pp_unpack() (spotted by Ilya) + Branch: perl + ! pp.c +____________________________________________________________________________ +[ 4611] By: gsar on 1999/12/02 00:31:43 + Log: a somewhat tweaked version of suggested patch + From: Ilya Zakharevich + Date: Wed, 27 Oct 1999 18:57:41 -0400 (EDT) + Message-Id: <199910272257.SAA29928@monk.mps.ohio-state.edu> + Subject: [PATCH 5.005_62] Another round of pack/vec docs patches + Branch: perl + ! pod/perlfunc.pod +____________________________________________________________________________ +[ 4610] By: gsar on 1999/12/01 19:09:31 + Log: more accurate require() pseudocode (from James P. Williams + ) + Branch: perl + ! pod/perlfunc.pod +____________________________________________________________________________ +[ 4609] By: gsar on 1999/12/01 18:43:49 + Log: avoid "Callback called exit" error on intentional exit() + Branch: perl + ! embedvar.h intrpvar.h objXSUB.h perl.c perl.h pp_ctl.c +____________________________________________________________________________ +[ 4608] By: gsar on 1999/12/01 18:42:38 + Log: find_byclass() prototype was incoherent + Branch: perl + ! regexec.c +____________________________________________________________________________ +[ 4607] By: gsar on 1999/12/01 05:45:10 + Log: better documentation for goto &NAME (from M. J. T. Guy) + Branch: perl + ! pod/perlfunc.pod +____________________________________________________________________________ +[ 4606] By: gsar on 1999/12/01 05:33:14 + Log: integrate cfgperl contents into mainline + Branch: perl + +> lib/unicode/Jamo.txt lib/unicode/NamesList.html + +> lib/unicode/UCD300.html lib/unicode/Unicode3.html + - lib/unicode/Jamo-2.txt lib/unicode/Unicode.html + ! Changes + !> (integrate 210 files) +____________________________________________________________________________ [ 4605] By: gsar on 1999/12/01 05:15:27 Log: avoid PTR->IV cast warnings Branch: perl diff --git a/embed.h b/embed.h index 92a3c2c..f007287 100644 --- a/embed.h +++ b/embed.h @@ -934,14 +934,7 @@ #define regwhite S_regwhite #define nextchar S_nextchar #define dumpuntil S_dumpuntil -#define put_byte S_put_byte #define scan_commit S_scan_commit -#define cl_anything S_cl_anything -#define cl_is_anything S_cl_is_anything -#define cl_init S_cl_init -#define cl_init_zero S_cl_init_zero -#define cl_and S_cl_and -#define cl_or S_cl_or #define study_chunk S_study_chunk #define add_data S_add_data #define re_croak2 S_re_croak2 @@ -2326,14 +2319,7 @@ #define regwhite(a,b) S_regwhite(aTHX_ a,b) #define nextchar() S_nextchar(aTHX) #define dumpuntil(a,b,c,d,e) S_dumpuntil(aTHX_ a,b,c,d,e) -#define put_byte(a,b) S_put_byte(aTHX_ a,b) #define scan_commit(a) S_scan_commit(aTHX_ a) -#define cl_anything(a) S_cl_anything(aTHX_ a) -#define cl_is_anything(a) S_cl_is_anything(aTHX_ a) -#define cl_init(a) S_cl_init(aTHX_ a) -#define cl_init_zero(a) S_cl_init_zero(aTHX_ a) -#define cl_and(a,b) S_cl_and(aTHX_ a,b) -#define cl_or(a,b) S_cl_or(aTHX_ a,b) #define study_chunk(a,b,c,d,e) S_study_chunk(aTHX_ a,b,c,d,e) #define add_data(a,b) S_add_data(aTHX_ a,b) #define regpposixcc(a) S_regpposixcc(aTHX_ a) @@ -4535,22 +4521,8 @@ #define nextchar S_nextchar #define S_dumpuntil CPerlObj::S_dumpuntil #define dumpuntil S_dumpuntil -#define S_put_byte CPerlObj::S_put_byte -#define put_byte S_put_byte #define S_scan_commit CPerlObj::S_scan_commit #define scan_commit S_scan_commit -#define S_cl_anything CPerlObj::S_cl_anything -#define cl_anything S_cl_anything -#define S_cl_is_anything CPerlObj::S_cl_is_anything -#define cl_is_anything S_cl_is_anything -#define S_cl_init CPerlObj::S_cl_init -#define cl_init S_cl_init -#define S_cl_init_zero CPerlObj::S_cl_init_zero -#define cl_init_zero S_cl_init_zero -#define S_cl_and CPerlObj::S_cl_and -#define cl_and S_cl_and -#define S_cl_or CPerlObj::S_cl_or -#define cl_or S_cl_or #define S_study_chunk CPerlObj::S_study_chunk #define study_chunk S_study_chunk #define S_add_data CPerlObj::S_add_data diff --git a/embed.pl b/embed.pl index 2ed6e10..7ce28d5 100755 --- a/embed.pl +++ b/embed.pl @@ -2013,16 +2013,7 @@ s |char*|regwhite |char *|char * s |char*|nextchar s |regnode*|dumpuntil |regnode *start|regnode *node \ |regnode *last|SV* sv|I32 l -s |void |put_byte |SV* sv|int c s |void |scan_commit |struct scan_data_t *data -s |void |cl_anything |struct regnode_charclass_class *cl -s |int |cl_is_anything |struct regnode_charclass_class *cl -s |void |cl_init |struct regnode_charclass_class *cl -s |void |cl_init_zero |struct regnode_charclass_class *cl -s |void |cl_and |struct regnode_charclass_class *cl \ - |struct regnode_charclass_class *and_with -s |void |cl_or |struct regnode_charclass_class *cl \ - |struct regnode_charclass_class *or_with s |I32 |study_chunk |regnode **scanp|I32 *deltap \ |regnode *last|struct scan_data_t *data \ |U32 flags diff --git a/perl.h b/perl.h index 06b398c..7197dcc 100644 --- a/perl.h +++ b/perl.h @@ -1748,7 +1748,6 @@ struct _sublex_info { typedef struct magic_state MGS; /* struct magic_state defined in mg.c */ struct scan_data_t; /* Used in S_* functions in regcomp.c */ -struct regnode_charclass_class; /* Used in S_* functions in regcomp.c */ typedef I32 CHECKPOINT; diff --git a/proto.h b/proto.h index 9f225f6..d950e9e 100644 --- a/proto.h +++ b/proto.h @@ -947,14 +947,7 @@ STATIC void S_regtail(pTHX_ regnode *, regnode *); STATIC char* S_regwhite(pTHX_ char *, char *); STATIC char* S_nextchar(pTHX); STATIC regnode* S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l); -STATIC void S_put_byte(pTHX_ SV* sv, int c); STATIC void S_scan_commit(pTHX_ struct scan_data_t *data); -STATIC void S_cl_anything(pTHX_ struct regnode_charclass_class *cl); -STATIC int S_cl_is_anything(pTHX_ struct regnode_charclass_class *cl); -STATIC void S_cl_init(pTHX_ struct regnode_charclass_class *cl); -STATIC void S_cl_init_zero(pTHX_ struct regnode_charclass_class *cl); -STATIC void S_cl_and(pTHX_ struct regnode_charclass_class *cl, struct regnode_charclass_class *and_with); -STATIC void S_cl_or(pTHX_ struct regnode_charclass_class *cl, struct regnode_charclass_class *or_with); STATIC I32 S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, struct scan_data_t *data, U32 flags); STATIC I32 S_add_data(pTHX_ I32 n, char *s); STATIC void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...) __attribute__((noreturn)); diff --git a/regcomp.c b/regcomp.c index 353155b..65db009 100644 --- a/regcomp.c +++ b/regcomp.c @@ -151,7 +151,6 @@ typedef struct scan_data_t { I32 offset_float_max; I32 flags; I32 whilem_c; - struct regnode_charclass_class *start_class; } scan_data_t; /* @@ -159,7 +158,7 @@ typedef struct scan_data_t { */ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0 }; + 0, 0, 0, 0 }; #define SF_BEFORE_EOL (SF_BEFORE_SEOL|SF_BEFORE_MEOL) #define SF_BEFORE_SEOL 0x1 @@ -185,9 +184,6 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #define SF_IN_PAR 0x100 #define SF_HAS_EVAL 0x200 #define SCF_DO_SUBSTR 0x400 -#define SCF_DO_STCLASS_AND 0x0800 -#define SCF_DO_STCLASS_OR 0x1000 -#define SCF_DO_STCLASS (SCF_DO_STCLASS_AND|SCF_DO_STCLASS_OR) #define RF_utf8 8 #define UTF (PL_reg_flags & RF_utf8) @@ -206,10 +202,6 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, static void clear_re(pTHXo_ void *r); -/* Mark that we cannot extend a found fixed substring at this point. - Updata the longest found anchored substring and the longest found - floating substrings if needed. */ - STATIC void S_scan_commit(pTHX_ scan_data_t *data) { @@ -244,135 +236,6 @@ S_scan_commit(pTHX_ scan_data_t *data) data->flags &= ~SF_BEFORE_EOL; } -/* Can match anything (initialization) */ -STATIC void -S_cl_anything(pTHX_ struct regnode_charclass_class *cl) -{ - int value; - - ANYOF_CLASS_ZERO(cl); - for (value = 0; value < 256; ++value) - ANYOF_BITMAP_SET(cl, value); - cl->flags = ANYOF_EOS; - if (LOC) - cl->flags |= ANYOF_LOCALE; -} - -/* Can match anything (initialization) */ -STATIC int -S_cl_is_anything(pTHX_ struct regnode_charclass_class *cl) -{ - int value; - - for (value = 0; value < ANYOF_MAX; value += 2) - if (ANYOF_CLASS_TEST(cl, value) && ANYOF_CLASS_TEST(cl, value + 1)) - return 1; - for (value = 0; value < 256; ++value) - if (!ANYOF_BITMAP_TEST(cl, value)) - return 0; - return 1; -} - -/* Can match anything (initialization) */ -STATIC void -S_cl_init(pTHX_ struct regnode_charclass_class *cl) -{ - cl->type = ANYOF; - cl_anything(cl); -} - -STATIC void -S_cl_init_zero(pTHX_ struct regnode_charclass_class *cl) -{ - cl->type = ANYOF; - cl_anything(cl); - ANYOF_CLASS_ZERO(cl); - ANYOF_BITMAP_ZERO(cl); - if (LOC) - cl->flags |= ANYOF_LOCALE; -} - -/* 'And' a given class with another one. Can create false positives */ -/* We assume that cl is not inverted */ -STATIC void -S_cl_and(pTHX_ struct regnode_charclass_class *cl, - struct regnode_charclass_class *and_with) -{ - int value; - - if (!(and_with->flags & ANYOF_CLASS) - && !(cl->flags & ANYOF_CLASS) - && (and_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE) - && !(and_with->flags & ANYOF_FOLD) - && !(cl->flags & ANYOF_FOLD)) { - int i; - - if (and_with->flags & ANYOF_INVERT) - for (i = 0; i < ANYOF_BITMAP_SIZE; i++) - cl->bitmap[i] &= ~and_with->bitmap[i]; - else - for (i = 0; i < ANYOF_BITMAP_SIZE; i++) - cl->bitmap[i] &= and_with->bitmap[i]; - } /* XXXX: logic is complicated otherwise, leave it along for a moment. */ - if (!(and_with->flags & ANYOF_EOS)) - cl->flags &= ~ANYOF_EOS; -} - -/* 'OR' a given class with another one. Can create false positives */ -/* We assume that cl is not inverted */ -STATIC void -S_cl_or(pTHX_ struct regnode_charclass_class *cl, struct regnode_charclass_class *or_with) -{ - int value; - - if (or_with->flags & ANYOF_INVERT) { - /* We do not use - * (B1 | CL1) | (!B2 & !CL2) = (B1 | !B2 & !CL2) | (CL1 | (!B2 & !CL2)) - * <= (B1 | !B2) | (CL1 | !CL2) - * which is wasteful if CL2 is small, but we ignore CL2: - * (B1 | CL1) | (!B2 & !CL2) <= (B1 | CL1) | !B2 = (B1 | !B2) | CL1 - * XXXX Can we handle case-fold? Unclear: - * (OK1(i) | OK1(i')) | !(OK1(i) | OK1(i')) = - * (OK1(i) | OK1(i')) | (!OK1(i) & !OK1(i')) - */ - if ( (or_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE) - && !(or_with->flags & ANYOF_FOLD) - && !(cl->flags & ANYOF_FOLD) ) { - int i; - - for (i = 0; i < ANYOF_BITMAP_SIZE; i++) - cl->bitmap[i] |= ~or_with->bitmap[i]; - } /* XXXX: logic is complicated otherwise */ - else { - cl_anything(cl); - } - } else { - /* (B1 | CL1) | (B2 | CL2) = (B1 | B2) | (CL1 | CL2)) */ - if ( (or_with->flags & ANYOF_LOCALE) == (cl->flags & ANYOF_LOCALE) - && (!(or_with->flags & ANYOF_FOLD) - || (cl->flags & ANYOF_FOLD)) ) { - int i; - - /* OR char bitmap and class bitmap separately */ - for (i = 0; i < ANYOF_BITMAP_SIZE; i++) - cl->bitmap[i] |= or_with->bitmap[i]; - if (or_with->flags & ANYOF_CLASS) { - for (i = 0; i < ANYOF_CLASSBITMAP_SIZE; i++) - cl->classflags[i] |= or_with->classflags[i]; - cl->flags |= ANYOF_CLASS; - } - } - else { /* XXXX: logic is complicated, leave it along for a moment. */ - cl_anything(cl); - } - } - if (or_with->flags & ANYOF_EOS) - cl->flags |= ANYOF_EOS; -} - -/* REx optimizer. Converts nodes into quickier variants "in place". - Finds fixed substrings. */ - /* Stops at toplevel WHILEM as well as at `last'. At end *scanp is set to the position after last scanned or to NULL. */ @@ -390,13 +253,11 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da int is_inf_internal = 0; /* The studied chunk is infinite */ I32 is_par = OP(scan) == OPEN ? ARG(scan) : 0; scan_data_t data_fake; - struct regnode_charclass_class and_with; /* Valid if flags & SCF_DO_STCLASS_OR */ while (scan && OP(scan) != END && scan < last) { /* Peephole optimizer: */ if (PL_regkind[(U8)OP(scan)] == EXACT) { - /* Merge several consecutive EXACTish nodes into one. */ regnode *n = regnext(scan); U32 stringok = 1; #ifdef DEBUGGING @@ -444,16 +305,19 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da /* Allow dumping */ n = scan + NODE_SZ_STR(scan); while (n <= stop) { + /* Purify reports a benign UMR here sometimes, because we + * don't initialize the OP() slot of a node when that node + * is occupied by just the trailing null of the string in + * an EXACT node */ if (PL_regkind[(U8)OP(n)] != NOTHING || OP(n) == NOTHING) { OP(n) = OPTIMIZED; NEXT_OFF(n) = 0; } n++; } -#endif +#endif + } - /* Follow the next-chain of the current node and optimize - away all the NOTHINGs from it. */ if (OP(scan) != CURLYX) { int max = (reg_off_by_arg[OP(scan)] ? I32_MAX @@ -474,8 +338,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da else NEXT_OFF(scan) = off; } - /* The principal pseudo-switch. Cannot be a switch, since we - look into several different things. */ if (OP(scan) == BRANCH || OP(scan) == BRANCHJ || OP(scan) == IFTHEN || OP(scan) == SUSPEND) { next = regnext(scan); @@ -483,15 +345,11 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da if (OP(next) == code || code == IFTHEN || code == SUSPEND) { I32 max1 = 0, min1 = I32_MAX, num = 0; - struct regnode_charclass_class accum; - if (flags & SCF_DO_SUBSTR) /* XXXX Add !SUSPEND? */ - scan_commit(data); /* Cannot merge strings after this. */ - if (flags & SCF_DO_STCLASS) - cl_init_zero(&accum); + if (flags & SCF_DO_SUBSTR) + scan_commit(data); while (OP(scan) == code) { - I32 deltanext, minnext, f = 0; - struct regnode_charclass_class this_class; + I32 deltanext, minnext; num++; data_fake.flags = 0; @@ -501,14 +359,9 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da scan = NEXTOPER(scan); if (code != BRANCH) scan = NEXTOPER(scan); - if (flags & SCF_DO_STCLASS) { - cl_init(&this_class); - data_fake.start_class = &this_class; - f = SCF_DO_STCLASS_AND; - } - /* we suppose the run is continuous, last=next...*/ + /* We suppose the run is continuous, last=next...*/ minnext = study_chunk(&scan, &deltanext, next, - &data_fake, f); + &data_fake, 0); if (min1 > minnext) min1 = minnext; if (max1 < minnext + deltanext) @@ -522,8 +375,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da data->flags |= SF_HAS_EVAL; if (data) data->whilem_c = data_fake.whilem_c; - if (flags & SCF_DO_STCLASS) - cl_or(&accum, &this_class); if (code == SUSPEND) break; } @@ -537,18 +388,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da } min += min1; delta += max1 - min1; - if (flags & SCF_DO_STCLASS_OR) { - cl_or(data->start_class, &accum); - if (min1) { - cl_and(data->start_class, &and_with); - flags &= ~SCF_DO_STCLASS; - } - } - else if (flags & SCF_DO_STCLASS_AND) { - cl_and(data->start_class, &accum); - if (min1) - flags &= ~SCF_DO_STCLASS; - } } else if (code == BRANCHJ) /* single branch is optimized. */ scan = NEXTOPER(NEXTOPER(scan)); @@ -582,34 +421,9 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da data->pos_min += l; /* As in the first entry. */ data->flags &= ~SF_BEFORE_EOL; } - if (flags & SCF_DO_STCLASS_AND) { - /* Check whether it is compatible with what we know already! */ - int compat = 1; - - if (!(data->start_class->flags & (ANYOF_CLASS | ANYOF_LOCALE)) - && !ANYOF_BITMAP_TEST(data->start_class, *STRING(scan)) - && (!(data->start_class->flags & ANYOF_FOLD) - || !ANYOF_BITMAP_TEST(data->start_class, - PL_fold[*STRING(scan)]))) - compat = 0; - ANYOF_CLASS_ZERO(data->start_class); - ANYOF_BITMAP_ZERO(data->start_class); - if (compat) - ANYOF_BITMAP_SET(data->start_class, *STRING(scan)); - data->start_class->flags &= ~ANYOF_EOS; - } - else if (flags & SCF_DO_STCLASS_OR) { - /* false positive possible if the class is case-folded */ - ANYOF_BITMAP_SET(data->start_class, *STRING(scan)); - data->start_class->flags &= ~ANYOF_EOS; - cl_and(data->start_class, &and_with); - } - flags &= ~SCF_DO_STCLASS; } - else if (PL_regkind[(U8)OP(scan)] == EXACT) { /* But OP != EXACT! */ + else if (PL_regkind[(U8)OP(scan)] == EXACT) { I32 l = STR_LEN(scan); - - /* Search for fixed substrings supports EXACT only. */ if (flags & SCF_DO_SUBSTR) scan_commit(data); if (UTF) { @@ -625,51 +439,19 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da min += l; if (data && (flags & SCF_DO_SUBSTR)) data->pos_min += l; - if (flags & SCF_DO_STCLASS_AND) { - /* Check whether it is compatible with what we know already! */ - int compat = 1; - - if (!(data->start_class->flags & (ANYOF_CLASS | ANYOF_LOCALE)) - && !ANYOF_BITMAP_TEST(data->start_class, *STRING(scan)) - && !ANYOF_BITMAP_TEST(data->start_class, - PL_fold[*STRING(scan)])) - compat = 0; - ANYOF_CLASS_ZERO(data->start_class); - ANYOF_BITMAP_ZERO(data->start_class); - if (compat) { - ANYOF_BITMAP_SET(data->start_class, *STRING(scan)); - data->start_class->flags &= ~ANYOF_EOS; - data->start_class->flags |= ANYOF_FOLD; - if (OP(scan) == EXACTFL) - data->start_class->flags |= ANYOF_LOCALE; - } - } - else if (flags & SCF_DO_STCLASS_OR) { - if (data->start_class->flags & ANYOF_FOLD) { - /* false positive possible if the class is case-folded. - Assume that the locale settings are the same... */ - ANYOF_BITMAP_SET(data->start_class, *STRING(scan)); - data->start_class->flags &= ~ANYOF_EOS; - } - cl_and(data->start_class, &and_with); - } - flags &= ~SCF_DO_STCLASS; } else if (strchr((char*)PL_varies,OP(scan))) { I32 mincount, maxcount, minnext, deltanext, pos_before, fl; - I32 f = flags; regnode *oscan = scan; - struct regnode_charclass_class this_class; - struct regnode_charclass_class *oclass = NULL; - + switch (PL_regkind[(U8)OP(scan)]) { - case WHILEM: /* End of (?:...)* . */ + case WHILEM: scan = NEXTOPER(scan); goto finish; case PLUS: - if (flags & (SCF_DO_SUBSTR | SCF_DO_STCLASS)) { + if (flags & SCF_DO_SUBSTR) { next = NEXTOPER(scan); - if (OP(next) == EXACT || (flags & SCF_DO_STCLASS)) { + if (OP(next) == EXACT) { mincount = 1; maxcount = REG_INFTY; next = regnext(scan); @@ -682,17 +464,10 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da min++; /* Fall through. */ case STAR: - if (flags & SCF_DO_STCLASS) { - mincount = 0; - maxcount = REG_INFTY; - next = regnext(scan); - scan = NEXTOPER(scan); - goto do_curly; - } is_inf = is_inf_internal = 1; scan = regnext(scan); if (flags & SCF_DO_SUBSTR) { - scan_commit(data); /* Cannot extend fixed substrings */ + scan_commit(data); data->longest = &(data->longest_float); } goto optimize_curly_tail; @@ -703,7 +478,7 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS; do_curly: if (flags & SCF_DO_SUBSTR) { - if (mincount == 0) scan_commit(data); /* Cannot extend fixed substrings */ + if (mincount == 0) scan_commit(data); pos_before = data->pos_min; } if (data) { @@ -712,45 +487,10 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da if (is_inf) data->flags |= SF_IS_INF; } - if (flags & SCF_DO_STCLASS) { - cl_init(&this_class); - oclass = data->start_class; - data->start_class = &this_class; - f |= SCF_DO_STCLASS_AND; - f &= ~SCF_DO_STCLASS_OR; - } - /* This will finish on WHILEM, setting scan, or on NULL: */ minnext = study_chunk(&scan, &deltanext, last, data, mincount == 0 - ? (f & ~SCF_DO_SUBSTR) : f); - - if (flags & SCF_DO_STCLASS) - data->start_class = oclass; - if (mincount == 0 || minnext == 0) { - if (flags & SCF_DO_STCLASS_OR) { - cl_or(data->start_class, &this_class); - } - else if (flags & SCF_DO_STCLASS_AND) { - /* Switch to OR mode: cache the old value of - * data->start_class */ - StructCopy(data->start_class, &and_with, - struct regnode_charclass_class); - flags &= ~SCF_DO_STCLASS_AND; - StructCopy(&this_class, data->start_class, - struct regnode_charclass_class); - flags |= SCF_DO_STCLASS_OR; - data->start_class->flags |= ANYOF_EOS; - } - } else { /* Non-zero len */ - if (flags & SCF_DO_STCLASS_OR) { - cl_or(data->start_class, &this_class); - cl_and(data->start_class, &and_with); - } - else if (flags & SCF_DO_STCLASS_AND) - cl_and(data->start_class, &this_class); - flags &= ~SCF_DO_STCLASS; - } + ? (flags & ~SCF_DO_SUBSTR) : flags); if (!scan) /* It was not CURLYX, but CURLY. */ scan = next; if (ckWARN(WARN_UNSAFE) && (minnext + deltanext == 0) @@ -900,8 +640,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da data->pos_delta += - counted * deltanext + (minnext + deltanext) * maxcount - minnext * mincount; if (mincount != maxcount) { - /* Cannot extend fixed substrings found inside - the group. */ scan_commit(data); if (mincount && last_str) { sv_setsv(data->last_found, last_str); @@ -926,258 +664,39 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da NEXT_OFF(oscan) += NEXT_OFF(next); } continue; - default: /* REF and CLUMP only? */ + default: /* REF only? */ if (flags & SCF_DO_SUBSTR) { - scan_commit(data); /* Cannot expect anything... */ + scan_commit(data); data->longest = &(data->longest_float); } is_inf = is_inf_internal = 1; - if (flags & SCF_DO_STCLASS_OR) - cl_anything(data->start_class); - flags &= ~SCF_DO_STCLASS; break; } } else if (strchr((char*)PL_simple,OP(scan)) || PL_regkind[(U8)OP(scan)] == ANYUTF8) { - int value; - if (flags & SCF_DO_SUBSTR) { scan_commit(data); data->pos_min++; } min++; - if (flags & SCF_DO_STCLASS) { - data->start_class->flags &= ~ANYOF_EOS; /* No match on empty */ - - /* Some of the logic below assumes that switching - locale on will only add false positives. */ - switch (PL_regkind[(U8)OP(scan)]) { - case ANYUTF8: - case SANY: - case SANYUTF8: - case ALNUMUTF8: - case ANYOFUTF8: - case ALNUMLUTF8: - case NALNUMUTF8: - case NALNUMLUTF8: - case SPACEUTF8: - case NSPACEUTF8: - case SPACELUTF8: - case NSPACELUTF8: - case DIGITUTF8: - case NDIGITUTF8: - default: - do_default: - /* Perl_croak(aTHX_ "panic: unexpected simple REx opcode %d", OP(scan)); */ - if (flags & SCF_DO_STCLASS_OR) /* Allow everything */ - cl_anything(data->start_class); - break; - case REG_ANY: - if (OP(scan) == SANY) - goto do_default; - if (flags & SCF_DO_STCLASS_OR) { /* Everything but \n */ - value = (ANYOF_BITMAP_TEST(data->start_class,'\n') - || (data->start_class->flags & ANYOF_CLASS)); - cl_anything(data->start_class); - } - if (flags & SCF_DO_STCLASS_AND || !value) - ANYOF_BITMAP_CLEAR(data->start_class,'\n'); - break; - case ANYOF: - if (flags & SCF_DO_STCLASS_AND) - cl_and(data->start_class, - (struct regnode_charclass_class*)scan); - else - cl_or(data->start_class, - (struct regnode_charclass_class*)scan); - break; - case ALNUM: - if (flags & SCF_DO_STCLASS_AND) { - if (!(data->start_class->flags & ANYOF_LOCALE)) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NALNUM); - for (value = 0; value < 256; value++) - if (!isALNUM(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - } - else { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_SET(data->start_class,ANYOF_ALNUM); - else { - for (value = 0; value < 256; value++) - if (isALNUM(value)) - ANYOF_BITMAP_SET(data->start_class, value); - } - } - break; - case ALNUML: - if (flags & SCF_DO_STCLASS_AND) { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NALNUM); - } - else { - ANYOF_CLASS_SET(data->start_class,ANYOF_ALNUM); - data->start_class->flags |= ANYOF_LOCALE; - } - break; - case NALNUM: - if (flags & SCF_DO_STCLASS_AND) { - if (!(data->start_class->flags & ANYOF_LOCALE)) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_ALNUM); - for (value = 0; value < 256; value++) - if (isALNUM(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - } - else { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_SET(data->start_class,ANYOF_NALNUM); - else { - for (value = 0; value < 256; value++) - if (!isALNUM(value)) - ANYOF_BITMAP_SET(data->start_class, value); - } - } - break; - case NALNUML: - if (flags & SCF_DO_STCLASS_AND) { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_ALNUM); - } - else { - data->start_class->flags |= ANYOF_LOCALE; - ANYOF_CLASS_SET(data->start_class,ANYOF_NALNUM); - } - break; - case SPACE: - if (flags & SCF_DO_STCLASS_AND) { - if (!(data->start_class->flags & ANYOF_LOCALE)) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NSPACE); - for (value = 0; value < 256; value++) - if (!isSPACE(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - } - else { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_SET(data->start_class,ANYOF_SPACE); - else { - for (value = 0; value < 256; value++) - if (isSPACE(value)) - ANYOF_BITMAP_SET(data->start_class, value); - } - } - break; - case SPACEL: - if (flags & SCF_DO_STCLASS_AND) { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NSPACE); - } - else { - data->start_class->flags |= ANYOF_LOCALE; - ANYOF_CLASS_SET(data->start_class,ANYOF_SPACE); - } - break; - case NSPACE: - if (flags & SCF_DO_STCLASS_AND) { - if (!(data->start_class->flags & ANYOF_LOCALE)) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_SPACE); - for (value = 0; value < 256; value++) - if (isSPACE(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - } - else { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_SET(data->start_class,ANYOF_NSPACE); - else { - for (value = 0; value < 256; value++) - if (!isSPACE(value)) - ANYOF_BITMAP_SET(data->start_class, value); - } - } - break; - case NSPACEL: - if (flags & SCF_DO_STCLASS_AND) { - if (data->start_class->flags & ANYOF_LOCALE) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_SPACE); - for (value = 0; value < 256; value++) - if (!isSPACE(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - } - else { - data->start_class->flags |= ANYOF_LOCALE; - ANYOF_CLASS_SET(data->start_class,ANYOF_NSPACE); - } - break; - case DIGIT: - if (flags & SCF_DO_STCLASS_AND) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_NDIGIT); - for (value = 0; value < 256; value++) - if (!isDIGIT(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - else { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_SET(data->start_class,ANYOF_DIGIT); - else { - for (value = 0; value < 256; value++) - if (isDIGIT(value)) - ANYOF_BITMAP_SET(data->start_class, value); - } - } - break; - case NDIGIT: - if (flags & SCF_DO_STCLASS_AND) { - ANYOF_CLASS_CLEAR(data->start_class,ANYOF_DIGIT); - for (value = 0; value < 256; value++) - if (isDIGIT(value)) - ANYOF_BITMAP_CLEAR(data->start_class, value); - } - else { - if (data->start_class->flags & ANYOF_LOCALE) - ANYOF_CLASS_SET(data->start_class,ANYOF_NDIGIT); - else { - for (value = 0; value < 256; value++) - if (!isDIGIT(value)) - ANYOF_BITMAP_SET(data->start_class, value); - } - } - break; - } - if (flags & SCF_DO_STCLASS_OR) - cl_and(data->start_class, &and_with); - flags &= ~SCF_DO_STCLASS; - } } else if (PL_regkind[(U8)OP(scan)] == EOL && flags & SCF_DO_SUBSTR) { data->flags |= (OP(scan) == MEOL ? SF_BEFORE_MEOL : SF_BEFORE_SEOL); } - else if ( PL_regkind[(U8)OP(scan)] == BRANCHJ - /* Lookbehind, or need to calculate parens/evals/stclass: */ - && (scan->flags || data || (flags & SCF_DO_STCLASS)) + else if (PL_regkind[(U8)OP(scan)] == BRANCHJ + && (scan->flags || data) && (OP(scan) == IFMATCH || OP(scan) == UNLESSM)) { - /* Lookahead/lookbehind */ I32 deltanext, minnext; regnode *nscan; - struct regnode_charclass_class intrnl; - int f = 0; data_fake.flags = 0; if (data) data_fake.whilem_c = data->whilem_c; - if ( flags & SCF_DO_STCLASS && !scan->flags - && OP(scan) == IFMATCH ) { /* Lookahead */ - cl_init(&intrnl); - data_fake.start_class = &intrnl; - f = SCF_DO_STCLASS_AND; - } next = regnext(scan); nscan = NEXTOPER(NEXTOPER(scan)); - minnext = study_chunk(&nscan, &deltanext, last, &data_fake, f); + minnext = study_chunk(&nscan, &deltanext, last, &data_fake, 0); if (scan->flags) { if (deltanext) { FAIL("variable length lookbehind not implemented"); @@ -1193,13 +712,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da data->flags |= SF_HAS_EVAL; if (data) data->whilem_c = data_fake.whilem_c; - if (f) { - int was = (data->start_class->flags & ANYOF_EOS); - - cl_and(data->start_class, &intrnl); - if (was) - data->start_class->flags |= ANYOF_EOS; - } } else if (OP(scan) == OPEN) { pars++; @@ -1220,8 +732,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da data->longest = &(data->longest_float); } is_inf = is_inf_internal = 1; - if (flags & SCF_DO_STCLASS_OR) /* Allow everything */ - cl_anything(data->start_class); } /* Else: zero-length, ignore. */ scan = regnext(scan); @@ -1242,8 +752,6 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da data->flags |= SF_HAS_PAR; data->flags &= ~SF_IN_PAR; } - if (flags & SCF_DO_STCLASS_OR) - cl_and(data->start_class, &and_with); return min; } @@ -1416,21 +924,16 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) Newz(1004, r->substrs, 1, struct reg_substr_data); StructCopy(&zero_scan_data, &data, scan_data_t); - /* XXXX Should not we check for something else? Usually it is OPEN1... */ if (OP(scan) != BRANCH) { /* Only one top-level choice. */ I32 fake; STRLEN longest_float_length, longest_fixed_length; - struct regnode_charclass_class ch_class; - int stclass_flag; first = scan; /* Skip introductions and multiplicators >= 1. */ while ((OP(first) == OPEN && (sawopen = 1)) || - /* An OR of *one* alternative - should not happen now. */ (OP(first) == BRANCH && OP(regnext(first)) != BRANCH) || (OP(first) == PLUS) || (OP(first) == MINMOD) || - /* An {n,m} with n>0 */ (PL_regkind[(U8)OP(first)] == CURLY && ARG1(first) > 0) ) { if (OP(first) == PLUS) sawplus = 1; @@ -1441,13 +944,13 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) /* Starting-point info. */ again: - if (PL_regkind[(U8)OP(first)] == EXACT) { + if (PL_regkind[(U8)OP(first) == EXACT]) { if (OP(first) == EXACT); /* Empty, get anchored substr later. */ else if ((OP(first) == EXACTF || OP(first) == EXACTFL) && !UTF) r->regstclass = first; } - else if (strchr((char*)PL_simple,OP(first))) + else if (strchr((char*)PL_simple+4,OP(first))) r->regstclass = first; else if (PL_regkind[(U8)OP(first)] == BOUND || PL_regkind[(U8)OP(first)] == NBOUND) @@ -1508,15 +1011,9 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) data.last_found = newSVpvn("",0); data.longest = &(data.longest_fixed); first = scan; - if (!r->regstclass) { - cl_init(&ch_class); - data.start_class = &ch_class; - stclass_flag = SCF_DO_STCLASS_AND; - } else /* XXXX Check for BOUND? */ - stclass_flag = 0; - + minlen = study_chunk(&first, &fake, scan + PL_regsize, /* Up to end */ - &data, SCF_DO_SUBSTR | stclass_flag); + &data, SCF_DO_SUBSTR); if ( PL_regnpar == 1 && data.longest == &(data.longest_fixed) && data.last_start_min == 0 && data.last_end > 0 && !PL_seen_zerolen @@ -1571,28 +1068,6 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) SvREFCNT_dec(data.longest_fixed); longest_fixed_length = 0; } - if (r->regstclass - && (OP(r->regstclass) == REG_ANY || OP(r->regstclass) == ANYUTF8 - || OP(r->regstclass) == SANYUTF8 || OP(r->regstclass) == SANY)) - r->regstclass = NULL; - if ((!r->anchored_substr || r->anchored_offset) && stclass_flag - && !(data.start_class->flags & ANYOF_EOS) - && !cl_is_anything(data.start_class)) { - SV *sv; - I32 n = add_data(1, "f"); - - New(1006, PL_regcomp_rx->data->data[n], 1, - struct regnode_charclass_class); - StructCopy(data.start_class, - (struct regnode_charclass_class*)PL_regcomp_rx->data->data[n], - struct regnode_charclass_class); - r->regstclass = (regnode*)PL_regcomp_rx->data->data[n]; - r->reganch &= ~ROPT_SKIP; /* Used in find_byclass(). */ - DEBUG_r((sv = sv_newmortal(), - regprop(sv, (regnode*)data.start_class), - PerlIO_printf(Perl_debug_log, "synthetic stclass.\n", - SvPVX(sv)))); - } /* A temporary algorithm prefers floated substr to fixed one to dig more info. */ if (longest_fixed_length > longest_float_length) { @@ -1617,31 +1092,11 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm) else { /* Several toplevels. Best we can is to set minlen. */ I32 fake; - struct regnode_charclass_class ch_class; DEBUG_r(PerlIO_printf(Perl_debug_log, "\n")); scan = r->program + 1; - cl_init(&ch_class); - data.start_class = &ch_class; - minlen = study_chunk(&scan, &fake, scan + PL_regsize, &data, SCF_DO_STCLASS_AND); + minlen = study_chunk(&scan, &fake, scan + PL_regsize, &data, 0); r->check_substr = r->anchored_substr = r->float_substr = Nullsv; - if (!(data.start_class->flags & ANYOF_EOS) - && !cl_is_anything(data.start_class)) { - SV *sv; - I32 n = add_data(1, "f"); - - New(1006, PL_regcomp_rx->data->data[n], 1, - struct regnode_charclass_class); - StructCopy(data.start_class, - (struct regnode_charclass_class*)PL_regcomp_rx->data->data[n], - struct regnode_charclass_class); - r->regstclass = (regnode*)PL_regcomp_rx->data->data[n]; - r->reganch &= ~ROPT_SKIP; /* Used in find_byclass(). */ - DEBUG_r((sv = sv_newmortal(), - regprop(sv, (regnode*)data.start_class), - PerlIO_printf(Perl_debug_log, "synthetic stclass.\n", - SvPVX(sv)))); - } } r->minlen = minlen; @@ -3855,17 +3310,6 @@ Perl_regdump(pTHX_ regexp *r) #endif /* DEBUGGING */ } -STATIC void -S_put_byte(pTHX_ SV *sv, int c) -{ - if (c <= ' ' || c == 127 || c == 255) - Perl_sv_catpvf(aTHX_ sv, "\\%o", c); - else if (c == '-' || c == ']' || c == '\\' || c == '^') - Perl_sv_catpvf(aTHX_ sv, "\\%c", c); - else - Perl_sv_catpvf(aTHX_ sv, "%c", c); -} - /* - regprop - printable representation of opcode */ @@ -3897,67 +3341,6 @@ Perl_regprop(pTHX_ SV *sv, regnode *o) Perl_sv_catpvf(aTHX_ sv, "%d", ARG(o)); /* Parenth number */ else if (k == LOGICAL) Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags); /* 2: embedded, otherwise 1 */ - else if (k == ANYOF) { - int i, rangestart = -1; - const char * const out[] = { /* Should be syncronized with - a table in regcomp.h */ - "\\w", - "\\W", - "\\s", - "\\S", - "\\d", - "\\D", - "[:alnum:]", - "[:^alnum:]", - "[:alpha:]", - "[:^alpha:]", - "[:ascii:]", - "[:^ascii:]", - "[:ctrl:]", - "[:^ctrl:]", - "[:graph:]", - "[:^graph:]", - "[:lower:]", - "[:^lower:]", - "[:print:]", - "[:^print:]", - "[:punct:]", - "[:^punct:]", - "[:upper:]", - "[:!upper:]", - "[:xdigit:]", - "[:^xdigit:]" - }; - - if (o->flags & ANYOF_LOCALE) - sv_catpv(sv, "{loc}"); - if (o->flags & ANYOF_FOLD) - sv_catpv(sv, "{i}"); - Perl_sv_catpvf(aTHX_ sv, "[%s", PL_colors[0]); - if (o->flags & ANYOF_INVERT) - sv_catpv(sv, "^"); - for (i = 0; i <= 256; i++) { - if (i < 256 && ANYOF_BITMAP_TEST(o,i)) { - if (rangestart == -1) - rangestart = i; - } else if (rangestart != -1) { - if (i <= rangestart + 3) - for (; rangestart < i; rangestart++) - put_byte(sv, rangestart); - else { - put_byte(sv, rangestart); - sv_catpv(sv, "-"); - put_byte(sv, i - 1); - } - rangestart = -1; - } - } - if (o->flags & ANYOF_CLASS) - for (i = 0; i < sizeof(out)/sizeof(char*); i++) - if (ANYOF_CLASS_TEST(o,i)) - sv_catpv(sv, out[i]); - Perl_sv_catpvf(aTHX_ sv, "%s]", PL_colors[1]); - } else if (k == BRANCHJ && (OP(o) == UNLESSM || OP(o) == IFMATCH)) Perl_sv_catpvf(aTHX_ sv, "[-%d]", o->flags); #endif /* DEBUGGING */ @@ -4019,9 +3402,6 @@ Perl_pregfree(pTHX_ struct regexp *r) case 's': SvREFCNT_dec((SV*)r->data->data[n]); break; - case 'f': - Safefree(r->data->data[n]); - break; case 'p': new_comppad = (AV*)r->data->data[n]; break; diff --git a/regcomp.h b/regcomp.h index 3624917..2fcf7a9 100644 --- a/regcomp.h +++ b/regcomp.h @@ -185,12 +185,7 @@ struct regnode_charclass_class { #define ANYOF_FOLD 0x02 #define ANYOF_LOCALE 0x01 -/* Used for regstclass only */ -#define ANYOF_EOS 0x10 /* Can match an empty string too */ - /* Character classes for node->classflags of ANYOF */ -/* Should be synchronized with a table in regprop() */ -/* 2n should pair with 2n+1 */ #define ANYOF_ALNUM 0 /* \w, utf8::IsWord, isALNUM() */ #define ANYOF_NALNUM 1