moriyoshi Mon Sep 29 20:41:01 2003 EDT
Modified files: (Branch: PHP_4_3)
/php-src/regex cclass.h debug.c engine.c engine.ih regcomp.c
regcomp.ih regex2.h regexec.c
Log:
MFH: Fixed bug #25669 (eregi() with non-ascii characters)
Index: php-src/regex/cclass.h
diff -u php-src/regex/cclass.h:1.3 php-src/regex/cclass.h:1.3.16.1
--- php-src/regex/cclass.h:1.3 Tue Dec 28 15:50:33 1999
+++ php-src/regex/cclass.h Mon Sep 29 20:41:00 2003
@@ -1,8 +1,8 @@
/* character-class table */
static struct cclass {
- char *name;
- char *chars;
- char *multis;
+ unsigned char *name;
+ unsigned char *chars;
+ unsigned char *multis;
} cclasses[] = {
{"alnum",
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
""},
{"alpha", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
Index: php-src/regex/debug.c
diff -u php-src/regex/debug.c:1.1.1.1 php-src/regex/debug.c:1.1.1.1.18.1
--- php-src/regex/debug.c:1.1.1.1 Wed Apr 7 17:04:56 1999
+++ php-src/regex/debug.c Mon Sep 29 20:41:00 2003
@@ -124,9 +124,9 @@
break;
case OCHAR:
if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
- fprintf(d, "\\%c", (char)opnd);
+ fprintf(d, "\\%c", (unsigned char)opnd);
else
- fprintf(d, "%s", regchar((char)opnd));
+ fprintf(d, "%s", regchar((unsigned char)opnd));
break;
case OBOL:
fprintf(d, "^");
@@ -228,11 +228,11 @@
- regchar - make a character printable
== static char *regchar(int ch);
*/
-static char * /* -> representation */
+static unsigned char * /* -> representation */
regchar(ch)
int ch;
{
- static char buf[10];
+ static unsigned char buf[10];
if (isprint(ch) || ch == ' ')
sprintf(buf, "%c", ch);
Index: php-src/regex/engine.c
diff -u php-src/regex/engine.c:1.3 php-src/regex/engine.c:1.3.16.1
--- php-src/regex/engine.c:1.3 Sun Nov 14 15:13:53 1999
+++ php-src/regex/engine.c Mon Sep 29 20:41:00 2003
@@ -33,11 +33,11 @@
struct re_guts *g;
int eflags;
regmatch_t *pmatch; /* [nsub+1] (0 element unused) */
- char *offp; /* offsets work from here */
- char *beginp; /* start of string -- virtual NUL precedes */
- char *endp; /* end of string -- virtual NUL here */
- char *coldp; /* can be no match starting before here */
- char **lastpos; /* [nplus+1] */
+ unsigned char *offp; /* offsets work from here */
+ unsigned char *beginp; /* start of string -- virtual NUL precedes */
+ unsigned char *endp; /* end of string -- virtual NUL here */
+ unsigned char *coldp; /* can be no match starting before here */
+ unsigned char **lastpos; /* [nplus+1] */
STATEVARS;
states st; /* current states */
states fresh; /* states for a fresh start */
@@ -65,20 +65,20 @@
static int /* 0 success, REG_NOMATCH failure */
matcher(g, string, nmatch, pmatch, eflags)
register struct re_guts *g;
-char *string;
+unsigned char *string;
size_t nmatch;
regmatch_t pmatch[];
int eflags;
{
- register char *endp;
+ register unsigned char *endp;
register size_t i;
struct match mv;
register struct match *m = &mv;
- register char *dp;
+ register unsigned char *dp;
const register sopno gf = g->firststate+1; /* +1 for OEND */
const register sopno gl = g->laststate;
- char *start;
- char *stop;
+ unsigned char *start;
+ unsigned char *stop;
/* simplify the situation where possible */
if (g->cflags®_NOSUB)
@@ -156,10 +156,10 @@
dp = dissect(m, m->coldp, endp, gf, gl);
} else {
if (g->nplus > 0 && m->lastpos == NULL)
- m->lastpos = (char **)malloc((g->nplus+1) *
- sizeof(char *));
+ m->lastpos = (unsigned char **)malloc((g->nplus+1) *
+ sizeof(unsigned char *));
if (g->nplus > 0 && m->lastpos == NULL) {
- free(m->pmatch);
+ free((char *)m->pmatch);
STATETEARDOWN(m);
return(REG_ESPACE);
}
@@ -225,30 +225,30 @@
/*
- dissect - figure out what matched what, no back references
- == static char *dissect(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst);
+ == static unsigned char *dissect(register struct match *m, unsigned char *start, \
+ == unsigned char *stop, sopno startst, sopno stopst);
*/
-static char * /* == stop (success) always */
+static unsigned char * /* == stop (success) always */
dissect(m, start, stop, startst, stopst)
register struct match *m;
-char *start;
-char *stop;
+unsigned char *start;
+unsigned char *stop;
sopno startst;
sopno stopst;
{
register int i;
register sopno ss; /* start sop of current subRE */
register sopno es; /* end sop of current subRE */
- register char *sp; /* start of string matched by it */
- register char *stp; /* string matched by it cannot pass here */
- register char *rest; /* start of rest of string */
- register char *tail; /* string unmatched by rest of RE */
+ register unsigned char *sp; /* start of string matched by it */
+ register unsigned char *stp; /* string matched by it cannot pass here */
+ register unsigned char *rest; /* start of rest of string */
+ register unsigned char *tail; /* string unmatched by rest of RE */
register sopno ssub; /* start sop of subsubRE */
register sopno esub; /* end sop of subsubRE */
- register char *ssp; /* start of string matched by subsubRE */
- register char *sep; /* end of string matched by subsubRE */
- register char *oldssp; /* previous ssp */
- register char *dp;
+ register unsigned char *ssp; /* start of string matched by subsubRE */
+ register unsigned char *sep; /* end of string matched by subsubRE */
+ register unsigned char *oldssp; /* previous ssp */
+ register unsigned char *dp;
AT("diss", start, stop, startst, stopst);
sp = start;
@@ -413,25 +413,25 @@
/*
- backref - figure out what matched what, figuring in back references
- == static char *backref(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst, sopno lev);
+ == static unsigned char *backref(register struct match *m, unsigned char *start, \
+ == unsigned char *stop, sopno startst, sopno stopst, sopno lev);
*/
-static char * /* == stop (success) or NULL (failure) */
+static unsigned char * /* == stop (success) or NULL (failure) */
backref(m, start, stop, startst, stopst, lev)
register struct match *m;
-char *start;
-char *stop;
+unsigned char *start;
+unsigned char *stop;
sopno startst;
sopno stopst;
sopno lev; /* PLUS nesting level */
{
register int i;
register sopno ss; /* start sop of current subRE */
- register char *sp; /* start of string matched by it */
+ register unsigned char *sp; /* start of string matched by it */
register sopno ssub; /* start sop of subsubRE */
register sopno esub; /* end sop of subsubRE */
- register char *ssp; /* start of string matched by subsubRE */
- register char *dp;
+ register unsigned char *ssp; /* start of string matched by subsubRE */
+ register unsigned char *dp;
register size_t len;
register int hard;
register sop s;
@@ -446,7 +446,7 @@
for (ss = startst; !hard && ss < stopst; ss++)
switch (OP(s = m->g->strip[ss])) {
case OCHAR:
- if (sp == stop || *sp++ != (char)OPND(s))
+ if (sp == stop || *sp++ != (unsigned char)OPND(s))
return(NULL);
break;
case OANY:
@@ -613,31 +613,31 @@
/* "can't happen" */
assert(nope);
/* NOTREACHED */
- return((char *)NULL); /* dummy */
+ return((unsigned char *)NULL); /* dummy */
}
/*
- fast - step through the string at top speed
- == static char *fast(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst);
+ == static unsigned char *fast(register struct match *m, unsigned char *start, \
+ == unsigned char *stop, sopno startst, sopno stopst);
*/
-static char * /* where tentative match ended, or NULL */
+static unsigned char * /* where tentative match ended, or NULL */
fast(m, start, stop, startst, stopst)
register struct match *m;
-char *start;
-char *stop;
+unsigned char *start;
+unsigned char *stop;
sopno startst;
sopno stopst;
{
register states st = m->st;
register states fresh = m->fresh;
register states tmp = m->tmp;
- register char *p = start;
+ register unsigned char *p = start;
register int c = (start == m->beginp) ? OUT : *(start-1);
register int lastc; /* previous c */
register int flagch;
register int i;
- register char *coldp; /* last p after which no match was underway */
+ register unsigned char *coldp; /* last p after which no match was underway */
CLEAR(st);
SET1(st, startst);
@@ -709,26 +709,26 @@
/*
- slow - step through the string more deliberately
- == static char *slow(register struct match *m, char *start, \
- == char *stop, sopno startst, sopno stopst);
+ == static unsigned char *slow(register struct match *m, unsigned char *start, \
+ == unsigned char *stop, sopno startst, sopno stopst);
*/
-static char * /* where it ended */
+static unsigned char * /* where it ended */
slow(m, start, stop, startst, stopst)
register struct match *m;
-char *start;
-char *stop;
+unsigned char *start;
+unsigned char *stop;
sopno startst;
sopno stopst;
{
register states st = m->st;
register states empty = m->empty;
register states tmp = m->tmp;
- register char *p = start;
+ register unsigned char *p = start;
register int c = (start == m->beginp) ? OUT : *(start-1);
register int lastc; /* previous c */
register int flagch;
register int i;
- register char *matchp; /* last p at which a match ended */
+ register unsigned char *matchp; /* last p at which a match ended */
AT("slow", start, stop, startst, stopst);
CLEAR(st);
@@ -805,8 +805,8 @@
== #define BOW (BOL+4)
== #define EOW (BOL+5)
== #define CODEMAX (BOL+5) // highest code used
- == #define NONCHAR(c) ((c) > CHAR_MAX)
- == #define NNONCHAR (CODEMAX-CHAR_MAX)
+ == #define NONCHAR(c) ((c) > UCHAR_MAX)
+ == #define NNONCHAR (CODEMAX-UCHAR_MAX)
*/
static states
step(g, start, stop, bef, ch, aft)
@@ -832,8 +832,8 @@
break;
case OCHAR:
/* only characters can match */
- assert(!NONCHAR(ch) || ch != (char)OPND(s));
- if (ch == (char)OPND(s))
+ assert(!NONCHAR(ch) || ch != (unsigned char)OPND(s));
+ if (ch == (unsigned char)OPND(s))
FWD(aft, bef, 1);
break;
case OBOL:
@@ -926,14 +926,14 @@
/*
- print - print a set of states
== #ifdef REDEBUG
- == static void print(struct match *m, char *caption, states st, \
+ == static void print(struct match *m, unsigned char *caption, states st, \
== int ch, FILE *d);
== #endif
*/
static void
print(m, caption, st, ch, d)
struct match *m;
-char *caption;
+unsigned char *caption;
states st;
int ch;
FILE *d;
@@ -959,16 +959,16 @@
/*
- at - print current situation
== #ifdef REDEBUG
- == static void at(struct match *m, char *title, char *start, char *stop, \
+ == static void at(struct match *m, unsigned char *title, unsigned char *start,
unsigned char *stop, \
== sopno startst, sopno stopst);
== #endif
*/
static void
at(m, title, start, stop, startst, stopst)
struct match *m;
-char *title;
-char *start;
-char *stop;
+unsigned char *title;
+unsigned char *start;
+unsigned char *stop;
sopno startst;
sopno stopst;
{
@@ -985,7 +985,7 @@
/*
- pchar - make a character printable
== #ifdef REDEBUG
- == static char *pchar(int ch);
+ == static unsigned char *pchar(int ch);
== #endif
*
* Is this identical to regchar() over in debug.c? Well, yes. But a
@@ -993,11 +993,11 @@
* a matching debug.o, and this is convenient. It all disappears in
* the non-debug compilation anyway, so it doesn't matter much.
*/
-static char * /* -> representation */
+static unsigned char * /* -> representation */
pchar(ch)
int ch;
{
- static char pbuf[10];
+ static unsigned char pbuf[10];
if (isprint(ch) || ch == ' ')
sprintf(pbuf, "%c", ch);
Index: php-src/regex/engine.ih
diff -u php-src/regex/engine.ih:1.2 php-src/regex/engine.ih:1.2.18.1
--- php-src/regex/engine.ih:1.2 Wed Jun 23 11:04:21 1999
+++ php-src/regex/engine.ih Mon Sep 29 20:41:00 2003
@@ -4,11 +4,11 @@
#endif
/* === engine.c === */
-static int matcher(register struct re_guts *g, char *string, size_t nmatch,
regmatch_t pmatch[], int eflags);
-static char *dissect(register struct match *m, char *start, char *stop, sopno
startst, sopno stopst);
-static char *backref(register struct match *m, char *start, char *stop, sopno
startst, sopno stopst, sopno lev);
-static char *fast(register struct match *m, char *start, char *stop, sopno startst,
sopno stopst);
-static char *slow(register struct match *m, char *start, char *stop, sopno startst,
sopno stopst);
+static int matcher(register struct re_guts *g, unsigned char *string, size_t nmatch,
regmatch_t pmatch[], int eflags);
+static unsigned char *dissect(register struct match *m, unsigned char *start,
unsigned char *stop, sopno startst, sopno stopst);
+static unsigned char *backref(register struct match *m, unsigned char *start,
unsigned char *stop, sopno startst, sopno stopst, sopno lev);
+static unsigned char *fast(register struct match *m, unsigned char *start, unsigned
char *stop, sopno startst, sopno stopst);
+static unsigned char *slow(register struct match *m, unsigned char *start, unsigned
char *stop, sopno startst, sopno stopst);
static states step(register struct re_guts *g, sopno start, sopno stop, register
states bef, int ch, register states aft);
#define BOL (OUT+1)
#define EOL (BOL+1)
@@ -17,16 +17,16 @@
#define BOW (BOL+4)
#define EOW (BOL+5)
#define CODEMAX (BOL+5) /* highest code used */
-#define NONCHAR(c) ((c) > CHAR_MAX)
-#define NNONCHAR (CODEMAX-CHAR_MAX)
+#define NONCHAR(c) ((c) > UCHAR_MAX)
+#define NNONCHAR (CODEMAX-UCHAR_MAX)
#ifdef REDEBUG
-static void print(struct match *m, char *caption, states st, int ch, FILE *d);
+static void print(struct match *m, unsigned char *caption, states st, int ch, FILE
*d);
#endif
#ifdef REDEBUG
-static void at(struct match *m, char *title, char *start, char *stop, sopno startst,
sopno stopst);
+static void at(struct match *m, unsigned char *title, unsigned char *start, unsigned
char *stop, sopno startst, sopno stopst);
#endif
#ifdef REDEBUG
-static char *pchar(int ch);
+static unsigned char *pchar(int ch);
#endif
#ifdef __cplusplus
Index: php-src/regex/regcomp.c
diff -u php-src/regex/regcomp.c:1.5 php-src/regex/regcomp.c:1.5.16.1
--- php-src/regex/regcomp.c:1.5 Tue Dec 28 15:50:34 1999
+++ php-src/regex/regcomp.c Mon Sep 29 20:41:00 2003
@@ -19,8 +19,8 @@
* other clumsinesses
*/
struct parse {
- char *next; /* next character in RE */
- char *end; /* end of string (-> NUL normally) */
+ unsigned char *next; /* next character in RE */
+ unsigned char *end; /* end of string (-> NUL normally) */
int error; /* has an error been seen? */
sop *strip; /* malloced strip */
sopno ssize; /* malloced strip size (allocated) */
@@ -34,7 +34,7 @@
#include "regcomp.ih"
-static char nuls[10]; /* place to point scanner in event of error */
+static unsigned char nuls[10]; /* place to point scanner in event of error */
/*
* macros for use with parse structure
@@ -127,7 +127,7 @@
/* set things up */
p->g = g;
- p->next = (char *)pattern; /* convenience; we do not modify it */
+ p->next = (unsigned char *)pattern; /* convenience; we do not modify it */
p->end = p->next + len;
p->error = 0;
p->ncsalloc = 0;
@@ -147,7 +147,7 @@
g->mlen = 0;
g->nsub = 0;
g->ncategories = 1; /* category 0 is "everything else" */
- g->categories = &g->catspace[-(CHAR_MIN)];
+ g->categories = &g->catspace[0];
(void) memset((char *)g->catspace, 0, NC*sizeof(cat_t));
g->backrefs = 0;
@@ -193,7 +193,7 @@
register struct parse *p;
int stop; /* character this ERE should end at */
{
- register char c;
+ register unsigned char c;
register sopno prevback = 0;
register sopno prevfwd = 0;
register sopno conc;
@@ -238,7 +238,7 @@
p_ere_exp(p)
register struct parse *p;
{
- register char c;
+ register unsigned char c;
register sopno pos;
register int count;
register int count2;
@@ -518,7 +518,7 @@
REQUIRE(starordinary, REG_BADRPT);
/* FALLTHROUGH */
default:
- ordinary(p, (char)c); /* takes off BACKSL, if any */
+ ordinary(p, (unsigned char)c); /* takes off BACKSL, if any */
break;
}
@@ -657,8 +657,8 @@
register struct parse *p;
register cset *cs;
{
- register char c;
- register char start, finish;
+ register unsigned char c;
+ register unsigned char start, finish;
register int i;
/* classify what we've got */
@@ -723,11 +723,11 @@
register struct parse *p;
register cset *cs;
{
- register char *sp = p->next;
+ register unsigned char *sp = p->next;
register struct cclass *cp;
register size_t len;
- register char *u;
- register char c;
+ register unsigned char *u;
+ register unsigned char c;
while (MORE() && isalpha(PEEK()))
NEXT();
@@ -759,7 +759,7 @@
register struct parse *p;
register cset *cs;
{
- register char c;
+ register unsigned char c;
c = p_b_coll_elem(p, '=');
CHadd(cs, c);
@@ -769,11 +769,11 @@
- p_b_symbol - parse a character or [..]ed multicharacter collating symbol
== static char p_b_symbol(register struct parse *p);
*/
-static char /* value of symbol */
+static unsigned char /* value of symbol */
p_b_symbol(p)
register struct parse *p;
{
- register char value;
+ register unsigned char value;
REQUIRE(MORE(), REG_EBRACK);
if (!EATTWO('[', '.'))
@@ -789,12 +789,12 @@
- p_b_coll_elem - parse a collating-element name and look it up
== static char p_b_coll_elem(register struct parse *p, int endc);
*/
-static char /* value of collating element */
+static unsigned char /* value of collating element */
p_b_coll_elem(p, endc)
register struct parse *p;
int endc; /* name ended by endc,']' */
{
- register char *sp = p->next;
+ register unsigned char *sp = p->next;
register struct cname *cp;
register int len;
@@ -818,7 +818,7 @@
- othercase - return the case counterpart of an alphabetic
== static char othercase(int ch);
*/
-static char /* if no counterpart, return ch */
+static unsigned char /* if no counterpart, return ch */
othercase(ch)
int ch;
{
@@ -842,9 +842,9 @@
register struct parse *p;
int ch;
{
- register char *oldnext = p->next;
- register char *oldend = p->end;
- char bracket[3];
+ register unsigned char *oldnext = p->next;
+ register unsigned char *oldend = p->end;
+ unsigned char bracket[3];
assert(othercase(ch) != ch); /* p_bracket() would recurse */
p->next = bracket;
@@ -888,9 +888,9 @@
nonnewline(p)
register struct parse *p;
{
- register char *oldnext = p->next;
- register char *oldend = p->end;
- char bracket[4];
+ register unsigned char *oldnext = p->next;
+ register unsigned char *oldend = p->end;
+ unsigned char bracket[4];
p->next = bracket;
p->end = bracket+3;
@@ -1015,19 +1015,19 @@
if (p->g->sets == NULL)
p->g->sets = (cset *)malloc(nc * sizeof(cset));
else
- p->g->sets = (cset *)realloc((char *)p->g->sets,
+ p->g->sets = (cset *)realloc((unsigned char *)p->g->sets,
nc * sizeof(cset));
if (p->g->setbits == NULL)
p->g->setbits = (uch *)malloc(nbytes);
else {
- p->g->setbits = (uch *)realloc((char *)p->g->setbits,
+ p->g->setbits = (uch *)realloc((unsigned char *)p->g->setbits,
nbytes);
/* xxx this isn't right if setbits is now NULL */
for (i = 0; i < no; i++)
p->g->sets[i].ptr = p->g->setbits + css*(i/CHAR_BIT);
}
if (p->g->sets != NULL && p->g->setbits != NULL)
- (void) memset((char *)p->g->setbits + (nbytes - css),
+ (void) memset((unsigned char *)p->g->setbits + (nbytes - css),
0, css);
else {
no = 0;
@@ -1120,7 +1120,7 @@
for (i = 0; i < css; i++)
if (CHIN(cs, i))
- return((char)i);
+ return((unsigned char)i);
assert(never);
return(0); /* arbitrary */
}
@@ -1153,7 +1153,7 @@
mcadd(p, cs, cp)
register struct parse *p;
register cset *cs;
-register char *cp;
+register unsigned char *cp;
{
register size_t oldend = cs->smultis;
@@ -1174,14 +1174,14 @@
#if 0
/*
- mcsub - subtract a collating element from a cset
- == static void mcsub(register cset *cs, register char *cp);
+ == static void mcsub(register cset *cs, register unsigned char *cp);
*/
static void
mcsub(cs, cp)
-register cset *cs;
-register char *cp;
+register unsigned cset *cs;
+register unsigned char *cp;
{
- register char *fp = mcfind(cs, cp);
+ register unsigned char *fp = mcfind(cs, cp);
register size_t len = strlen(fp);
assert(fp != NULL);
@@ -1201,12 +1201,12 @@
/*
- mcin - is a collating element in a cset?
- == static int mcin(register cset *cs, register char *cp);
+ == static int mcin(register cset *cs, register unsigned char *cp);
*/
static int
mcin(cs, cp)
register cset *cs;
-register char *cp;
+register unsigned char *cp;
{
return(mcfind(cs, cp) != NULL);
}
@@ -1214,14 +1214,14 @@
/*
- mcfind - find a collating element in a cset
- == static char *mcfind(register cset *cs, register char *cp);
+ == static unsigned char *mcfind(register cset *cs, register unsigned char *cp);
*/
-static char *
+static unsigned char *
mcfind(cs, cp)
register cset *cs;
-register char *cp;
+register unsigned char *cp;
{
- register char *p;
+ register unsigned char *p;
if (cs->multis == NULL)
return(NULL);
@@ -1322,11 +1322,11 @@
if (p->error != 0)
return;
- for (c = CHAR_MIN; c <= CHAR_MAX; c++)
+ for (c = 0; c <= UCHAR_MAX; c++)
if (cats[c] == 0 && isinsets(g, c)) {
cat = g->ncategories++;
cats[c] = cat;
- for (c2 = c+1; c2 <= CHAR_MAX; c2++)
+ for (c2 = c+1; c2 <= UCHAR_MAX; c2++)
if (cats[c2] == 0 && samesets(g, c, c2))
cats[c2] = cat;
}
@@ -1477,7 +1477,7 @@
register struct re_guts *g;
{
g->nstates = p->slen;
- g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
+ g->strip = (sop *)realloc((unsigned char *)p->strip, p->slen * sizeof(sop));
if (g->strip == NULL) {
SETERROR(REG_ESPACE);
g->strip = p->strip;
@@ -1504,7 +1504,7 @@
register sop *newstart = NULL;
register sopno newlen;
register sop s;
- register char *cp;
+ register unsigned char *cp;
register sopno i;
/* avoid making error situations worse */
@@ -1565,7 +1565,7 @@
while (OP(s = *scan++) != OCHAR)
continue;
assert(cp < g->must + g->mlen);
- *cp++ = (char)OPND(s);
+ *cp++ = (unsigned char)OPND(s);
}
assert(cp == g->must + g->mlen);
*cp++ = '\0'; /* just on general principles */
Index: php-src/regex/regcomp.ih
diff -u php-src/regex/regcomp.ih:1.4 php-src/regex/regcomp.ih:1.4.16.1
--- php-src/regex/regcomp.ih:1.4 Tue Dec 28 15:50:34 1999
+++ php-src/regex/regcomp.ih Mon Sep 29 20:41:00 2003
@@ -14,9 +14,9 @@
static void p_b_term(register struct parse *p, register cset *cs);
static void p_b_cclass(register struct parse *p, register cset *cs);
static void p_b_eclass(register struct parse *p, register cset *cs);
-static char p_b_symbol(register struct parse *p);
-static char p_b_coll_elem(register struct parse *p, int endc);
-static char othercase(int ch);
+static unsigned char p_b_symbol(register struct parse *p);
+static unsigned char p_b_coll_elem(register struct parse *p, int endc);
+static unsigned char othercase(int ch);
static void bothcases(register struct parse *p, int ch);
static void ordinary(register struct parse *p, register int ch);
static void nonnewline(register struct parse *p);
@@ -27,11 +27,11 @@
static int freezeset(register struct parse *p, register cset *cs);
static int firstch(register struct parse *p, register cset *cs);
static int nch(register struct parse *p, register cset *cs);
-static void mcadd(register struct parse *p, register cset *cs, register char *cp);
+static void mcadd(register struct parse *p, register cset *cs, register unsigned char
*cp);
#if 0
-static void mcsub(register cset *cs, register char *cp);
-static int mcin(register cset *cs, register char *cp);
-static char *mcfind(register cset *cs, register char *cp);
+static void mcsub(register cset *cs, register unsigned char *cp);
+static int mcin(register cset *cs, register unsigned char *cp);
+static unsigned char *mcfind(register cset *cs, register unsigned char *cp);
#endif
static void mcinvert(register struct parse *p, register cset *cs);
static void mccase(register struct parse *p, register cset *cs);
Index: php-src/regex/regex2.h
diff -u php-src/regex/regex2.h:1.2 php-src/regex/regex2.h:1.2.16.1
--- php-src/regex/regex2.h:1.2 Fri Nov 12 15:27:52 1999
+++ php-src/regex/regex2.h Mon Sep 29 20:41:00 2003
@@ -10,7 +10,7 @@
= typedef struct {
= int re_magic;
= size_t re_nsub; // number of parenthesized subexpressions
- = const char *re_endp; // end pointer for REG_PEND
+ = const unsigned char *re_endp; // end pointer for REG_PEND
= struct re_guts *re_g; // none of your business :-)
= } regex_t;
= typedef struct {
@@ -90,7 +90,7 @@
uch mask; /* bit within array */
uch hash; /* hash code */
size_t smultis;
- char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
+ unsigned char *multis; /* -> char[smulti] ab\0cd\0ef\0\0 */
} cset;
/* note that CHadd and CHsub are unsafe, and CHIN doesn't yield 0/1 */
#define CHadd(cs, c) ((cs)->ptr[(uch)(c)] |= (cs)->mask, (cs)->hash += (c))
@@ -125,8 +125,8 @@
int nbol; /* number of ^ used */
int neol; /* number of $ used */
int ncategories; /* how many character categories */
- cat_t *categories; /* ->catspace[-CHAR_MIN] */
- char *must; /* match must contain this string */
+ cat_t *categories; /* ->catspace[-UCHAR_MIN] */
+ unsigned char *must; /* match must contain this string */
int mlen; /* length of must */
size_t nsub; /* copy of re_nsub */
int backrefs; /* does it use back references? */
@@ -136,5 +136,5 @@
};
/* misc utilities */
-#define OUT (CHAR_MAX+1) /* a non-character value */
+#define OUT (UCHAR_MAX+1) /* a non-character value */
#define ISWORD(c) (isalnum(c) || (c) == '_')
Index: php-src/regex/regexec.c
diff -u php-src/regex/regexec.c:1.2 php-src/regex/regexec.c:1.2.16.1
--- php-src/regex/regexec.c:1.2 Fri Nov 12 15:27:52 1999
+++ php-src/regex/regexec.c Mon Sep 29 20:41:00 2003
@@ -67,14 +67,14 @@
#undef SNAMES
/* macros for manipulating states, large version */
-#define states char *
+#define states unsigned char *
#define CLEAR(v) memset(v, 0, m->g->nstates)
#define SET0(v, n) ((v)[n] = 0)
#define SET1(v, n) ((v)[n] = 1)
#define ISSET(v, n) ((v)[n])
#define ASSIGN(d, s) memcpy(d, s, m->g->nstates)
#define EQ(a, b) (memcmp(a, b, m->g->nstates) == 0)
-#define STATEVARS int vn; char *space
+#define STATEVARS int vn; unsigned char *space
#define STATESETUP(m, nv) { (m)->space = malloc((nv)*(m)->g->nstates); \
if ((m)->space == NULL) return(REG_ESPACE); \
(m)->vn = 0; }
@@ -132,7 +132,7 @@
eflags = GOODFLAGS(eflags);
if (g->nstates <= CHAR_BIT*sizeof(states1) && !(eflags®_LARGE))
- return(smatcher(g, (char *)string, nmatch, pmatch, eflags));
+ return(smatcher(g, (unsigned char *)string, nmatch, pmatch, eflags));
else
- return(lmatcher(g, (char *)string, nmatch, pmatch, eflags));
+ return(lmatcher(g, (unsigned char *)string, nmatch, pmatch, eflags));
}
--
PHP CVS Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php
