#undef op
#endif /* op */
-static regnode regdummy;
-static char * regparse; /* Input-scan pointer. */
-static char * regxend; /* End of input for compile */
-static regnode * regcode; /* Code-emit pointer; ®dummy = don't. */
-static I32 regnaughty; /* How bad is this pattern? */
-static I32 regsawback; /* Did we see \1, ...? */
-
-/* This guys appear both in regcomp.c and regexec.c, but there is no
- other reason to have them global. */
-static char * regprecomp; /* uncompiled string. */
-static I32 regnpar; /* () count. */
-static I32 regsize; /* Code size. */
-static U16 regflags; /* are we folding, multilining? */
-
#ifdef MSDOS
# if defined(BUGGY_MSC6)
/* MSC 6.00A breaks on op/regexp.t test 85 unless we turn this off */
* Forward declarations for pregcomp()'s friends.
*/
+#ifndef PERL_OBJECT
static regnode *reg _((I32, I32 *));
static regnode *reganode _((U8, U32));
static regnode *regatom _((I32 *));
static regnode *regpiece _((I32 *));
static void reginsert _((U8, regnode *));
static void regoptail _((regnode *, regnode *));
-static void regset _((char *, I32));
static void regtail _((regnode *, regnode *));
static char* regwhite _((char *, char *));
static char* nextchar _((void));
-
-static U32 regseen;
-static I32 seen_zerolen;
-static regexp *rx;
-static I32 extralen;
-
-#ifdef DEBUGGING
-static int colorset;
-char *colors[4];
-#endif
+static void re_croak2 _((const char* pat1,const char* pat2,...)) __attribute__((noreturn));
+#endif
/* Length of a variant. */
+#ifndef PERL_OBJECT
typedef struct {
I32 len_min;
I32 len_delta;
I32 offset_float_max;
I32 flags;
} scan_data_t;
+#endif
static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
#define SF_FIX_BEFORE_EOL (SF_FIX_BEFORE_SEOL|SF_FIX_BEFORE_MEOL)
#define SF_FL_BEFORE_EOL (SF_FL_BEFORE_SEOL|SF_FL_BEFORE_MEOL)
-#define SF_FIX_SHIFT_EOL (+2)
-#define SF_FL_SHIFT_EOL (+4)
+#ifdef NO_UNARY_PLUS
+# define SF_FIX_SHIFT_EOL (0+2)
+# define SF_FL_SHIFT_EOL (0+4)
+#else
+# define SF_FIX_SHIFT_EOL (+2)
+# define SF_FL_SHIFT_EOL (+4)
+#endif
#define SF_FIX_BEFORE_SEOL (SF_BEFORE_SEOL << SF_FIX_SHIFT_EOL)
#define SF_FIX_BEFORE_MEOL (SF_BEFORE_MEOL << SF_FIX_SHIFT_EOL)
#define SF_HAS_PAR 0x80
#define SF_IN_PAR 0x100
#define SF_HAS_EVAL 0x200
+#define SCF_DO_SUBSTR 0x400
-static void
+STATIC void
scan_commit(scan_data_t *data)
{
STRLEN l = SvCUR(data->last_found);
data->flags &= ~SF_BEFORE_EOL;
}
-#define SCF_DO_SUBSTR 1
-
/* Stops at toplevel WHILEM as well as at `last'. At end *scanp is set
to the position after last scanned or to NULL. */
-static I32
+STATIC I32
study_chunk(regnode **scanp, I32 *deltap, regnode *last, scan_data_t *data, U32 flags)
/* scanp: Start here (read-write). */
/* deltap: Write maxlen-minlen here. */
scan = next;
if (data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
pars++;
- if (data_fake.flags & SF_HAS_EVAL)
+ if (data && (data_fake.flags & SF_HAS_EVAL))
data->flags |= SF_HAS_EVAL;
if (code == SUSPEND)
break;
data->longest = &(data->longest_float);
}
}
- if (fl & SF_HAS_EVAL)
+ if (data && (fl & SF_HAS_EVAL))
data->flags |= SF_HAS_EVAL;
optimize_curly_tail:
#ifdef REGALIGN
}
if (data && data_fake.flags & (SF_HAS_PAR|SF_IN_PAR))
pars++;
- if (data_fake.flags & SF_HAS_EVAL)
+ if (data && (data_fake.flags & SF_HAS_EVAL))
data->flags |= SF_HAS_EVAL;
} else if (OP(scan) == OPEN) {
pars++;
return min;
}
-static I32
+STATIC I32
add_data(I32 n, char *s)
{
- if (rx->data) {
- Renewc(rx->data,
- sizeof(*rx->data) + sizeof(void*) * (rx->data->count + n - 1),
+ if (regcomp_rx->data) {
+ Renewc(regcomp_rx->data,
+ sizeof(*regcomp_rx->data) + sizeof(void*) * (regcomp_rx->data->count + n - 1),
char, struct reg_data);
- Renew(rx->data->what, rx->data->count + n, U8);
- rx->data->count += n;
+ Renew(regcomp_rx->data->what, regcomp_rx->data->count + n, U8);
+ regcomp_rx->data->count += n;
} else {
- Newc(1207, rx->data, sizeof(*rx->data) + sizeof(void*) * (n - 1),
+ Newc(1207, regcomp_rx->data, sizeof(*regcomp_rx->data) + sizeof(void*) * (n - 1),
char, struct reg_data);
- New(1208, rx->data->what, n, U8);
- rx->data->count = n;
+ New(1208, regcomp_rx->data->what, n, U8);
+ regcomp_rx->data->count = n;
}
- Copy(s, rx->data->what + rx->data->count - n, n, U8);
- return rx->data->count - n;
+ Copy(s, regcomp_rx->data->what + regcomp_rx->data->count - n, n, U8);
+ return regcomp_rx->data->count - n;
}
/*
extralen = 0;
/* First pass: determine size, legality. */
- regparse = exp;
+ regcomp_parse = exp;
regxend = xend;
regnaughty = 0;
regnpar = 1;
DEBUG_r(
if (!colorset) {
int i = 0;
- char *s = PerlENV_getenv("TERMCAP_COLORS");
+ char *s = PerlEnv_getenv("TERMCAP_COLORS");
colorset = 1;
if (s) {
r->prelen = xend - exp;
r->precomp = regprecomp;
r->subbeg = r->subbase = NULL;
- rx = r;
+ regcomp_rx = r;
/* Second pass: emit code. */
- regparse = exp;
+ regcomp_parse = exp;
regxend = xend;
regnaughty = 0;
regnpar = 1;
r->regstclass = NULL;
r->naughty = regnaughty >= 10; /* Probably an expensive pattern. */
scan = r->program + 1; /* First BRANCH. */
+
+ /* XXXX To minimize changes to RE engine we always allocate
+ 3-units-long substrs field. */
+ Newz(1004, r->substrs, 1, struct reg_substr_data);
+
if (OP(scan) != BRANCH) { /* Only one top-level choice. */
scan_data_t data;
I32 fake;
r->float_substr = data.longest_float;
r->float_min_offset = data.offset_float_min;
r->float_max_offset = data.offset_float_max;
- fbm_compile(r->float_substr);
+ fbm_compile(r->float_substr, 0);
BmUSEFUL(r->float_substr) = 100;
if (data.flags & SF_FL_BEFORE_EOL /* Cannot have SEOL and MULTI */
&& (!(data.flags & SF_FL_BEFORE_MEOL)
|| (regflags & PMf_MULTILINE)))) {
r->anchored_substr = data.longest_fixed;
r->anchored_offset = data.offset_fixed;
- fbm_compile(r->anchored_substr);
+ fbm_compile(r->anchored_substr, 0);
BmUSEFUL(r->anchored_substr) = 100;
if (data.flags & SF_FIX_BEFORE_EOL /* Cannot have SEOL and MULTI */
&& (!(data.flags & SF_FIX_BEFORE_MEOL)
r->reganch |= ROPT_GPOS_SEEN;
if (regseen & REG_SEEN_LOOKBEHIND)
r->reganch |= ROPT_LOOKBEHIND_SEEN;
+ if (regseen & REG_SEEN_EVAL)
+ r->reganch |= ROPT_EVAL_SEEN;
Newz(1002, r->startp, regnpar, char*);
Newz(1002, r->endp, regnpar, char*);
DEBUG_r(regdump(r));
* is a trifle forced, but the need to tie the tails of the branches to what
* follows makes it hard to avoid.
*/
-static regnode *
+STATIC regnode *
reg(I32 paren, I32 *flagp)
/* paren: Parenthesized? 0=top, 1=(, inside: changed to letter. */
{
/* Make an OPEN node, if parenthesized. */
if (paren) {
- if (*regparse == '?') {
- regparse++;
- paren = *regparse++;
+ if (*regcomp_parse == '?') {
+ regcomp_parse++;
+ paren = *regcomp_parse++;
ret = NULL; /* For look-ahead/behind. */
switch (paren) {
case '<':
FAIL("lookbehind non-implemented without REGALIGN_STRUCT");
#endif
regseen |= REG_SEEN_LOOKBEHIND;
- if (*regparse == '!')
+ if (*regcomp_parse == '!')
paren = ',';
- if (*regparse != '=' && *regparse != '!')
+ if (*regcomp_parse != '=' && *regcomp_parse != '!')
goto unknown;
- regparse++;
+ regcomp_parse++;
case '=':
case '!':
seen_zerolen++;
FAIL2("Sequence (?%c...) not implemented", (int)paren);
break;
case '#':
- while (*regparse && *regparse != ')')
- regparse++;
- if (*regparse != ')')
+ while (*regcomp_parse && *regcomp_parse != ')')
+ regcomp_parse++;
+ if (*regcomp_parse != ')')
FAIL("Sequence (?#... not terminated");
nextchar();
*flagp = TRYAGAIN;
dTHR;
I32 count = 1, n = 0;
char c;
- char *s = regparse;
+ char *s = regcomp_parse;
SV *sv;
OP_4tree *sop, *rop;
seen_zerolen++;
- while (count && (c = *regparse)) {
- if (c == '\\' && regparse[1])
- regparse++;
+ regseen |= REG_SEEN_EVAL;
+ while (count && (c = *regcomp_parse)) {
+ if (c == '\\' && regcomp_parse[1])
+ regcomp_parse++;
else if (c == '{')
count++;
else if (c == '}')
count--;
- regparse++;
+ regcomp_parse++;
}
- if (*regparse != ')')
+ if (*regcomp_parse != ')')
FAIL("Sequence (?{...}) not terminated or not {}-balanced");
if (!SIZE_ONLY) {
AV *av;
- if (regparse - 1 - s)
- sv = newSVpv(s, regparse - 1 - s);
+ if (regcomp_parse - 1 - s)
+ sv = newSVpv(s, regcomp_parse - 1 - s);
else
sv = newSVpv("", 0);
rop = sv_compile_2op(sv, &sop, "re", &av);
n = add_data(3, "nso");
- rx->data->data[n] = (void*)rop;
- rx->data->data[n+1] = (void*)av;
- rx->data->data[n+2] = (void*)sop;
+ regcomp_rx->data->data[n] = (void*)rop;
+ regcomp_rx->data->data[n+1] = (void*)av;
+ regcomp_rx->data->data[n+2] = (void*)sop;
SvREFCNT_dec(sv);
+ } else { /* First pass */
+ if (tainted)
+ FAIL("Eval-group in insecure regular expression");
}
nextchar();
- if (tainted)
- FAIL("Eval-group in insecure regular expression");
return reganode(EVAL, n);
}
case '(':
{
- if (regparse[0] == '?') {
- if (regparse[1] == '=' || regparse[1] == '!'
- || regparse[1] == '<'
- || regparse[1] == '{') { /* Lookahead or eval. */
+ if (regcomp_parse[0] == '?') {
+ if (regcomp_parse[1] == '=' || regcomp_parse[1] == '!'
+ || regcomp_parse[1] == '<'
+ || regcomp_parse[1] == '{') { /* Lookahead or eval. */
I32 flag;
ret = reg_node(LOGICAL);
regtail(ret, reg(1, &flag));
goto insert_if;
}
- } else if (regparse[0] >= '1' && regparse[0] <= '9' ) {
- parno = atoi(regparse++);
+ } else if (regcomp_parse[0] >= '1' && regcomp_parse[0] <= '9' ) {
+ parno = atoi(regcomp_parse++);
- while (isDIGIT(*regparse))
- regparse++;
+ while (isDIGIT(*regcomp_parse))
+ regcomp_parse++;
ret = reganode(GROUPP, parno);
if ((c = *nextchar()) != ')')
FAIL2("Switch (?(number%c not recognized", c);
regtail(ret, ender);
return ret;
} else {
- FAIL2("Unknown condition for (?(%.2s", regparse);
+ FAIL2("Unknown condition for (?(%.2s", regcomp_parse);
}
}
case 0:
FAIL("Sequence (? incomplete");
break;
default:
- --regparse;
- while (*regparse && strchr("iogcmsx", *regparse))
- pmflag(®flags, *regparse++);
+ --regcomp_parse;
+ while (*regcomp_parse && strchr("iogcmsx", *regcomp_parse)) {
+ if (*regcomp_parse != 'o')
+ pmflag(®flags, *regcomp_parse);
+ ++regcomp_parse;
+ }
unknown:
- if (*regparse != ')')
- FAIL2("Sequence (?%c...) not recognized", *regparse);
+ if (*regcomp_parse != ')')
+ FAIL2("Sequence (?%c...) not recognized", *regcomp_parse);
nextchar();
*flagp = TRYAGAIN;
return NULL;
br = regbranch(&flags, 1);
if (br == NULL)
return(NULL);
- if (*regparse == '|') {
+ if (*regcomp_parse == '|') {
if (!SIZE_ONLY && extralen) {
reginsert(BRANCHJ, br);
} else
*flagp &= ~HASWIDTH;
*flagp |= flags&SPSTART;
lastbr = br;
- while (*regparse == '|') {
+ while (*regcomp_parse == '|') {
if (!SIZE_ONLY && extralen) {
ender = reganode(LONGJMP,0);
regtail(NEXTOPER(NEXTOPER(lastbr)), ender); /* Append to the previous. */
}
/* Check for proper termination. */
- if (paren && (regparse >= regxend || *nextchar() != ')')) {
+ if (paren && (regcomp_parse >= regxend || *nextchar() != ')')) {
FAIL("unmatched () in regexp");
- } else if (!paren && regparse < regxend) {
- if (*regparse == ')') {
+ } else if (!paren && regcomp_parse < regxend) {
+ if (*regcomp_parse == ')') {
FAIL("unmatched () in regexp");
} else
FAIL("junk on end of regexp"); /* "Can't happen". */
*
* Implements the concatenation operator.
*/
-static regnode *
+STATIC regnode *
regbranch(I32 *flagp, I32 first)
{
register regnode *ret;
*flagp = WORST; /* Tentatively. */
- regparse--;
+ regcomp_parse--;
nextchar();
- while (regparse < regxend && *regparse != '|' && *regparse != ')') {
+ while (regcomp_parse < regxend && *regcomp_parse != '|' && *regcomp_parse != ')') {
flags &= ~TRYAGAIN;
latest = regpiece(&flags);
if (latest == NULL) {
* It might seem that this node could be dispensed with entirely, but the
* endmarker role is not redundant.
*/
-static regnode *
+STATIC regnode *
regpiece(I32 *flagp)
{
register regnode *ret;
register char op;
register char *next;
I32 flags;
- char *origparse = regparse;
+ char *origparse = regcomp_parse;
char *maxpos;
I32 min;
I32 max = REG_INFTY;
return(NULL);
}
- op = *regparse;
+ op = *regcomp_parse;
- if (op == '{' && regcurly(regparse)) {
- next = regparse + 1;
+ if (op == '{' && regcurly(regcomp_parse)) {
+ next = regcomp_parse + 1;
maxpos = Nullch;
while (isDIGIT(*next) || *next == ',') {
if (*next == ',') {
if (*next == '}') { /* got one */
if (!maxpos)
maxpos = next;
- regparse++;
- min = atoi(regparse);
+ regcomp_parse++;
+ min = atoi(regcomp_parse);
if (*maxpos == ',')
maxpos++;
else
- maxpos = regparse;
+ maxpos = regcomp_parse;
max = atoi(maxpos);
if (!max && *maxpos != '0')
max = REG_INFTY; /* meaning "infinity" */
else if (max >= REG_INFTY)
FAIL2("Quantifier in {,} bigger than %d", REG_INFTY - 1);
- regparse = next;
+ regcomp_parse = next;
nextchar();
do_curly:
nest_check:
if (dowarn && !SIZE_ONLY && !(flags&HASWIDTH) && max > 10000) {
warn("%.*s matches null string many times",
- regparse - origparse, origparse);
+ regcomp_parse - origparse, origparse);
}
- if (*regparse == '?') {
+ if (*regcomp_parse == '?') {
nextchar();
reginsert(MINMOD, ret);
#ifdef REGALIGN
regtail(ret, ret + 3);
#endif
}
- if (ISMULT2(regparse))
+ if (ISMULT2(regcomp_parse))
FAIL("nested *?+ in regexp");
return(ret);
*
* [Yes, it is worth fixing, some scripts can run twice the speed.]
*/
-static regnode *
+STATIC regnode *
regatom(I32 *flagp)
{
register regnode *ret = 0;
*flagp = WORST; /* Tentatively. */
tryagain:
- switch (*regparse) {
+ switch (*regcomp_parse) {
case '^':
seen_zerolen++;
nextchar();
ret = reg_node(BOL);
break;
case '$':
- if (regparse[1])
+ if (regcomp_parse[1])
seen_zerolen++;
nextchar();
if (regflags & PMf_MULTILINE)
*flagp |= HASWIDTH|SIMPLE;
break;
case '[':
- regparse++;
+ regcomp_parse++;
ret = regclass();
*flagp |= HASWIDTH|SIMPLE;
break;
*flagp |= TRYAGAIN;
return NULL;
}
- FAIL2("internal urp in regexp at /%s/", regparse);
+ FAIL2("internal urp in regexp at /%s/", regcomp_parse);
/* Supposed to be caught earlier. */
break;
case '{':
- if (!regcurly(regparse)) {
- regparse++;
+ if (!regcurly(regcomp_parse)) {
+ regcomp_parse++;
goto defchar;
}
/* FALL THROUGH */
FAIL("?+*{} follows nothing in regexp");
break;
case '\\':
- switch (*++regparse) {
+ switch (*++regcomp_parse) {
case 'A':
seen_zerolen++;
ret = reg_node(SBOL);
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
{
- I32 num = atoi(regparse);
+ I32 num = atoi(regcomp_parse);
if (num > 9 && num >= regnpar)
goto defchar;
? ((regflags & PMf_LOCALE) ? REFFL : REFF)
: REF, num);
*flagp |= HASWIDTH;
- while (isDIGIT(*regparse))
- regparse++;
- regparse--;
+ while (isDIGIT(*regcomp_parse))
+ regcomp_parse++;
+ regcomp_parse--;
nextchar();
}
}
break;
case '\0':
- if (regparse >= regxend)
+ if (regcomp_parse >= regxend)
FAIL("trailing \\ in regexp");
/* FALL THROUGH */
default:
case '#':
if (regflags & PMf_EXTENDED) {
- while (regparse < regxend && *regparse != '\n') regparse++;
- if (regparse < regxend)
+ while (regcomp_parse < regxend && *regcomp_parse != '\n') regcomp_parse++;
+ if (regcomp_parse < regxend)
goto tryagain;
}
/* FALL THROUGH */
char *oldp, *s;
I32 numlen;
- regparse++;
+ regcomp_parse++;
defchar:
ret = reg_node((regflags & PMf_FOLD)
: EXACT);
s = (char *) OPERAND(ret);
regc(0, s++); /* save spot for len */
- for (len = 0, p = regparse - 1;
+ for (len = 0, p = regcomp_parse - 1;
len < 127 && p < regxend;
len++)
{
regc(ender, s++);
}
loopdone:
- regparse = p - 1;
+ regcomp_parse = p - 1;
nextchar();
if (len < 0)
FAIL("internal disaster in regexp");
return(ret);
}
-static char *
+STATIC char *
regwhite(char *p, char *e)
{
while (p < e) {
return p;
}
-static void
-regset(char *opnd, register I32 c)
-{
- if (SIZE_ONLY)
- return;
- c &= 0xFF;
- opnd[1 + (c >> 3)] |= (1 << (c & 7));
-}
-
-static regnode *
+STATIC regnode *
regclass(void)
{
register char *opnd, *s;
ret = reg_node(ANYOF);
for (Class = 0; Class < 33; Class++)
regc(0, s++);
- if (*regparse == '^') { /* Complement of range. */
+ if (*regcomp_parse == '^') { /* Complement of range. */
regnaughty++;
- regparse++;
+ regcomp_parse++;
if (!SIZE_ONLY)
*opnd |= ANYOF_INVERT;
}
} else {
regsize += ANY_SKIP;
}
- if (*regparse == ']' || *regparse == '-')
+ if (*regcomp_parse == ']' || *regcomp_parse == '-')
goto skipcond; /* allow 1st char to be ] or - */
- while (regparse < regxend && *regparse != ']') {
+ while (regcomp_parse < regxend && *regcomp_parse != ']') {
skipcond:
- Class = UCHARAT(regparse++);
+ Class = UCHARAT(regcomp_parse++);
+ if (Class == '[' && regcomp_parse + 1 < regxend &&
+ /* I smell either [: or [= or [. -- POSIX has been here, right? */
+ (*regcomp_parse == ':' || *regcomp_parse == '=' || *regcomp_parse == '.')) {
+ char posixccc = *regcomp_parse;
+ char* posixccs = regcomp_parse++;
+
+ while (regcomp_parse < regxend && *regcomp_parse != posixccc)
+ regcomp_parse++;
+ if (regcomp_parse == regxend)
+ /* Grandfather lone [:, [=, [. */
+ regcomp_parse = posixccs;
+ else {
+ regcomp_parse++; /* skip over the posixccc */
+ if (*regcomp_parse == ']') {
+ /* Not Implemented Yet.
+ * (POSIX Extended Character Classes, that is)
+ * The text between e.g. [: and :] would start
+ * at posixccs + 1 and stop at regcomp_parse - 2. */
+ if (dowarn && !SIZE_ONLY)
+ warn("Character class syntax [%c %c] is reserved for future extensions", posixccc, posixccc);
+ regcomp_parse++; /* skip over the ending ] */
+ }
+ }
+ }
if (Class == '\\') {
- Class = UCHARAT(regparse++);
+ Class = UCHARAT(regcomp_parse++);
switch (Class) {
case 'w':
- if (regflags & PMf_LOCALE) {
- if (!SIZE_ONLY)
+ if (!SIZE_ONLY) {
+ if (regflags & PMf_LOCALE)
*opnd |= ANYOF_ALNUML;
- }
- else {
- for (Class = 0; Class < 256; Class++)
- if (isALNUM(Class))
- regset(opnd, Class);
+ else {
+ for (Class = 0; Class < 256; Class++)
+ if (isALNUM(Class))
+ ANYOF_SET(opnd, Class);
+ }
}
lastclass = 1234;
continue;
case 'W':
- if (regflags & PMf_LOCALE) {
- if (!SIZE_ONLY)
+ if (!SIZE_ONLY) {
+ if (regflags & PMf_LOCALE)
*opnd |= ANYOF_NALNUML;
- }
- else {
- for (Class = 0; Class < 256; Class++)
- if (!isALNUM(Class))
- regset(opnd, Class);
+ else {
+ for (Class = 0; Class < 256; Class++)
+ if (!isALNUM(Class))
+ ANYOF_SET(opnd, Class);
+ }
}
lastclass = 1234;
continue;
case 's':
- if (regflags & PMf_LOCALE) {
- if (!SIZE_ONLY)
+ if (!SIZE_ONLY) {
+ if (regflags & PMf_LOCALE)
*opnd |= ANYOF_SPACEL;
- }
- else {
- for (Class = 0; Class < 256; Class++)
- if (isSPACE(Class))
- regset(opnd, Class);
+ else {
+ for (Class = 0; Class < 256; Class++)
+ if (isSPACE(Class))
+ ANYOF_SET(opnd, Class);
+ }
}
lastclass = 1234;
continue;
case 'S':
- if (regflags & PMf_LOCALE) {
- if (!SIZE_ONLY)
+ if (!SIZE_ONLY) {
+ if (regflags & PMf_LOCALE)
*opnd |= ANYOF_NSPACEL;
- }
- else {
- for (Class = 0; Class < 256; Class++)
- if (!isSPACE(Class))
- regset(opnd, Class);
+ else {
+ for (Class = 0; Class < 256; Class++)
+ if (!isSPACE(Class))
+ ANYOF_SET(opnd, Class);
+ }
}
lastclass = 1234;
continue;
case 'd':
- for (Class = '0'; Class <= '9'; Class++)
- regset(opnd, Class);
+ if (!SIZE_ONLY) {
+ for (Class = '0'; Class <= '9'; Class++)
+ ANYOF_SET(opnd, Class);
+ }
lastclass = 1234;
continue;
case 'D':
- for (Class = 0; Class < '0'; Class++)
- regset(opnd, Class);
- for (Class = '9' + 1; Class < 256; Class++)
- regset(opnd, Class);
+ if (!SIZE_ONLY) {
+ for (Class = 0; Class < '0'; Class++)
+ ANYOF_SET(opnd, Class);
+ for (Class = '9' + 1; Class < 256; Class++)
+ ANYOF_SET(opnd, Class);
+ }
lastclass = 1234;
continue;
case 'n':
Class = '\007';
break;
case 'x':
- Class = scan_hex(regparse, 2, &numlen);
- regparse += numlen;
+ Class = scan_hex(regcomp_parse, 2, &numlen);
+ regcomp_parse += numlen;
break;
case 'c':
- Class = UCHARAT(regparse++);
+ Class = UCHARAT(regcomp_parse++);
Class = toCTRL(Class);
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
- Class = scan_oct(--regparse, 3, &numlen);
- regparse += numlen;
+ Class = scan_oct(--regcomp_parse, 3, &numlen);
+ regcomp_parse += numlen;
break;
}
}
}
else {
lastclass = Class;
- if (*regparse == '-' && regparse+1 < regxend &&
- regparse[1] != ']') {
- regparse++;
+ if (*regcomp_parse == '-' && regcomp_parse+1 < regxend &&
+ regcomp_parse[1] != ']') {
+ regcomp_parse++;
range = 1;
continue; /* do it next time */
}
}
- for ( ; lastclass <= Class; lastclass++)
- regset(opnd, lastclass);
+ if (!SIZE_ONLY) {
+ for ( ; lastclass <= Class; lastclass++)
+ ANYOF_SET(opnd, lastclass);
+ }
lastclass = Class;
}
- if (*regparse != ']')
+ if (*regcomp_parse != ']')
FAIL("unmatched [] in regexp");
nextchar();
+ /* optimize case-insensitive simple patterns (e.g. /[a-z]/i) */
+ if (!SIZE_ONLY && (*opnd & (0xFF ^ ANYOF_INVERT)) == ANYOF_FOLD) {
+ for (Class = 0; Class < 256; ++Class) {
+ if (ANYOF_TEST(opnd, Class)) {
+ I32 cf = fold[Class];
+ ANYOF_SET(opnd, cf);
+ }
+ }
+ *opnd &= ~ANYOF_FOLD;
+ }
+ /* optimize inverted simple patterns (e.g. [^a-z]) */
+ if (!SIZE_ONLY && (*opnd & 0xFF) == ANYOF_INVERT) {
+ for (Class = 0; Class < 32; ++Class)
+ opnd[1 + Class] ^= 0xFF;
+ *opnd = 0;
+ }
return ret;
}
-static char*
+STATIC char*
nextchar(void)
{
- char* retval = regparse++;
+ char* retval = regcomp_parse++;
for (;;) {
- if (*regparse == '(' && regparse[1] == '?' &&
- regparse[2] == '#') {
- while (*regparse && *regparse != ')')
- regparse++;
- regparse++;
+ if (*regcomp_parse == '(' && regcomp_parse[1] == '?' &&
+ regcomp_parse[2] == '#') {
+ while (*regcomp_parse && *regcomp_parse != ')')
+ regcomp_parse++;
+ regcomp_parse++;
continue;
}
if (regflags & PMf_EXTENDED) {
- if (isSPACE(*regparse)) {
- regparse++;
+ if (isSPACE(*regcomp_parse)) {
+ regcomp_parse++;
continue;
}
- else if (*regparse == '#') {
- while (*regparse && *regparse != '\n')
- regparse++;
- regparse++;
+ else if (*regcomp_parse == '#') {
+ while (*regcomp_parse && *regcomp_parse != '\n')
+ regcomp_parse++;
+ regcomp_parse++;
continue;
}
}
/*
- reg_node - emit a node
*/
-static regnode * /* Location. */
-#ifdef CAN_PROTOTYPE
+STATIC regnode * /* Location. */
reg_node(U8 op)
-#else
-reg_node(op)
-U8 op;
-#endif
{
register regnode *ret;
register regnode *ptr;
/*
- reganode - emit a node with an argument
*/
-static regnode * /* Location. */
-#ifdef CAN_PROTOTYPE
+STATIC regnode * /* Location. */
reganode(U8 op, U32 arg)
-#else
-reganode(op, arg)
-U8 op;
-U32 arg;
-#endif
{
register regnode *ret;
register regnode *ptr;
/*
- regc - emit (if appropriate) a byte of code
*/
-#ifdef CAN_PROTOTYPE
-static void
+STATIC void
regc(U8 b, char* s)
-#else
-static void
-regc(b, s)
-U8 b;
-char *s;
-#endif
{
if (!SIZE_ONLY)
*s = b;
*
* Means relocating the operand.
*/
-#ifdef CAN_PROTOTYPE
-static void
+STATIC void
reginsert(U8 op, regnode *opnd)
-#else
-static void
-reginsert(op, opnd)
-U8 op;
-regnode *opnd;
-#endif
{
register regnode *src;
register regnode *dst;
/*
- regtail - set the next-pointer at the end of a node chain of p to val.
*/
-static void
+STATIC void
regtail(regnode *p, regnode *val)
{
register regnode *scan;
/*
- regoptail - regtail on operand of first argument; nop if operandless
*/
-static void
+STATIC void
regoptail(regnode *p, regnode *val)
{
/* "Operandless" and "op != BRANCH" are synonymous in practice. */
return TRUE;
}
-#ifdef DEBUGGING
-static regnode *
+STATIC regnode *
dumpuntil(regnode *start, regnode *node, regnode *last, SV* sv, I32 l)
{
+#ifdef DEBUGGING
register char op = EXACT; /* Arbitrary non-END op. */
register regnode *next, *onode;
else if (op == WHILEM)
l--;
}
+#endif /* DEBUGGING */
return node;
}
void
regdump(regexp *r)
{
+#ifdef DEBUGGING
SV *sv = sv_newmortal();
(void)dumpuntil(r->program, r->program + 1, NULL, sv, 0);
if (r->reganch & ROPT_IMPLICIT)
PerlIO_printf(Perl_debug_log, "implicit ");
PerlIO_printf(Perl_debug_log, "minlen %ld ", (long) r->minlen);
+ if (r->reganch & ROPT_EVAL_SEEN)
+ PerlIO_printf(Perl_debug_log, "with eval ");
PerlIO_printf(Perl_debug_log, "\n");
+#endif /* DEBUGGING */
}
/*
void
regprop(SV *sv, regnode *o)
{
+#ifdef DEBUGGING
register char *p = 0;
sv_setpv(sv, ":");
}
if (p)
sv_catpv(sv, p);
+#endif /* DEBUGGING */
}
-#endif /* DEBUGGING */
void
pregfree(struct regexp *r)
Safefree(r->precomp);
if (r->subbase)
Safefree(r->subbase);
- if (r->anchored_substr)
- SvREFCNT_dec(r->anchored_substr);
- if (r->float_substr)
- SvREFCNT_dec(r->float_substr);
+ if (r->substrs) {
+ if (r->anchored_substr)
+ SvREFCNT_dec(r->anchored_substr);
+ if (r->float_substr)
+ SvREFCNT_dec(r->float_substr);
+ Safefree(r->substrs);
+ }
if (r->data) {
int n = r->data->count;
while (--n >= 0) {
#endif
}
-#ifdef I_STDARG
-void
+STATIC void
re_croak2(const char* pat1,const char* pat2,...)
-#else
-/*VARARGS0*/
-void
-re_croak2(const char* pat1,const char* pat2, va_alist)
- const char* pat1;
- const char* pat2;
- va_dcl
-#endif
{
va_list args;
STRLEN l1 = strlen(pat1);
Copy(pat2, buf + l1, l2 , char);
buf[l1 + l2 + 1] = '\n';
buf[l1 + l2 + 2] = '\0';
-#ifdef I_STDARG
va_start(args, pat2);
-#else
- va_start(args);
-#endif
message = mess(buf, &args);
va_end(args);
l1 = strlen(message);
buf[l1] = '\0'; /* Overwrite \n */
croak("%s", buf);
}
-
-
-
projects / p5sagit/p5-mst-13.2.git / blobdiff