static I32 regrepeat _((regnode *p, I32 max));
static I32 regrepeat_hard _((regnode *p, I32 max, I32 *lp));
static I32 regtry _((regexp *prog, char *startpos));
+
static bool reginclass _((char *p, I32 c));
static CHECKPOINT regcppush _((I32 parenfloor));
static char * regcppop _((void));
+#define REGINCLASS(p,c) (*(p) ? reginclass(p,c) : ANYOF_TEST(p,c))
static CHECKPOINT
regcppush(I32 parenfloor)
for (p = regsize; p > parenfloor; p--) {
SSPUSHPTR(regendp[p]);
SSPUSHPTR(regstartp[p]);
- SSPUSHINT(reg_start_tmp[p]);
+ SSPUSHPTR(reg_start_tmp[p]);
SSPUSHINT(p);
}
SSPUSHINT(regsize);
goto phooey;
} else if (c = prog->regstclass) {
I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
- char *class;
+ char *Class;
if (minlen)
dontbother = minlen - 1;
/* We know what class it must start with. */
switch (OP(c)) {
case ANYOF:
- class = OPERAND(c);
+ Class = (char *) OPERAND(c);
while (s < strend) {
- if (reginclass(class, *s)) {
+ if (REGINCLASS(Class, *s)) {
if (tmp && regtry(prog, s))
goto got_it;
else
nextchar = UCHARAT(++locinput);
break;
case EXACT:
- s = OPERAND(scan);
+ s = (char *) OPERAND(scan);
ln = UCHARAT(s++);
/* Inline the first character, for speed. */
if (UCHARAT(s) != nextchar)
reg_flags |= RF_tainted;
/* FALL THROUGH */
case EXACTF:
- s = OPERAND(scan);
+ s = (char *) OPERAND(scan);
ln = UCHARAT(s++);
/* Inline the first character, for speed. */
if (UCHARAT(s) != nextchar &&
nextchar = UCHARAT(locinput);
break;
case ANYOF:
- s = OPERAND(scan);
+ s = (char *) OPERAND(scan);
if (nextchar < 0)
nextchar = UCHARAT(locinput);
- if (!reginclass(s, nextchar))
+ if (!REGINCLASS(s, nextchar))
sayNO;
if (!nextchar && locinput >= regeol)
sayNO;
n = ARG(scan); /* which paren pair */
s = regstartp[n];
if (*reglastparen < n || !s)
- break; /* Zero length always matches */
+ sayNO; /* Do not match unless seen CLOSEn. */
if (s == regendp[n])
break;
/* Inline the first character, for speed. */
*reglastparen = paren;
}
#endif
- scan = NEXTOPER(scan) + 4/sizeof(regnode);
+ scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
if (paren)
scan += NEXT_OFF(scan); /* Skip former OPEN. */
reginput = locinput;
*reglastparen = paren;
ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
- scan = regnext(NEXTOPER(scan) + 4/sizeof(regnode));
+ scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
goto repeat;
case CURLY:
paren = 0;
ln = ARG1(scan); /* min to match */
n = ARG2(scan); /* max to match */
- scan = NEXTOPER(scan) + 4/sizeof(regnode);
+ scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
goto repeat;
case STAR:
ln = 0;
logical = 0;
sw = 1;
}
- if (OP(scan) == SUSPEND)
+ if (OP(scan) == SUSPEND) {
locinput = reginput;
+ nextchar = UCHARAT(locinput);
+ }
/* FALL THROUGH. */
case LONGJMP:
do_longjump:
scan = reginput;
if (max != REG_INFTY && max < loceol - scan)
loceol = scan + max;
- opnd = OPERAND(p);
+ opnd = (char *) OPERAND(p);
switch (OP(p)) {
case ANY:
while (scan < loceol && *scan != '\n')
scan++;
break;
case ANYOF:
- while (scan < loceol && reginclass(opnd, *scan))
+ while (scan < loceol && REGINCLASS(opnd, *scan))
scan++;
break;
case ALNUM:
bool match = FALSE;
c &= 0xFF;
- if (p[1 + (c >> 3)] & (1 << (c & 7)))
+ if (ANYOF_TEST(p, c))
match = TRUE;
else if (flags & ANYOF_FOLD) {
I32 cf;
}
else
cf = fold[c];
- if (p[1 + (cf >> 3)] & (1 << (cf & 7)))
+ if (ANYOF_TEST(p, cf))
match = TRUE;
}
}
}
- return match ^ ((flags & ANYOF_INVERT) != 0);
+ return (flags & ANYOF_INVERT) ? !match : match;
}
+
+