database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-06-30 21:42:05 +03:00
Code Activity

pgindent run.

Browse Source
This commit is contained in:
Bruce Momjian
2003-08-04 00:43:34 +00:00
parent 63354a0228
commit 089003fb46
554 changed files with 24888 additions and 21245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

412
src/backend/regex/regc_color.c
View File

@ -2,21 +2,21 @@
* colorings of characters
* This file is #included by regcomp.c.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Development of this software was funded, in part, by Cray Research Inc.,
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
* Corporation, none of whom are responsible for the results. The author
* thanks all of them.
*
* thanks all of them.
*
* Redistribution and use in source and binary forms -- with or without
* modification -- are permitted for any purpose, provided that
* redistributions in source form retain this entire copyright notice and
* indicate the origin and nature of any modifications.
*
*
* I'd appreciate being given credit for this package in the documentation
* of software which uses it, but that is not a requirement.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.1 2003/02/05 17:41:32 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regc_color.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
*
*
* Note that there are some incestuous relationships between this code and
@ -37,8 +37,8 @@
#define CISERR() VISERR(cm->v)
#define CERR(e) VERR(cm->v, (e))
#define CISERR() VISERR(cm->v)
#define CERR(e) VERR(cm->v, (e))
@ -46,11 +46,11 @@
* initcm - set up new colormap
*/
static void
initcm(struct vars *v,
struct colormap *cm)
initcm(struct vars * v,
struct colormap * cm)
{
int i;
int j;
int i;
int j;
union tree *t;
union tree *nextt;
struct colordesc *cd;
@ -63,21 +63,22 @@ initcm(struct vars *v,
cm->max = 0;
cm->free = 0;
cd = cm->cd; /* cm->cd[WHITE] */
cd = cm->cd; /* cm->cd[WHITE] */
cd->sub = NOSUB;
cd->arcs = NULL;
cd->flags = 0;
cd->nchrs = CHR_MAX - CHR_MIN + 1;
/* upper levels of tree */
for (t = &cm->tree[0], j = NBYTS-1; j > 0; t = nextt, j--) {
for (t = &cm->tree[0], j = NBYTS - 1; j > 0; t = nextt, j--)
{
nextt = t + 1;
for (i = BYTTAB-1; i >= 0; i--)
for (i = BYTTAB - 1; i >= 0; i--)
t->tptr[i] = nextt;
}
/* bottom level is solid white */
t = &cm->tree[NBYTS-1];
for (i = BYTTAB-1; i >= 0; i--)
t = &cm->tree[NBYTS - 1];
for (i = BYTTAB - 1; i >= 0; i--)
t->tcolor[i] = WHITE;
cd->block = t;
}
@ -86,16 +87,17 @@ initcm(struct vars *v,
* freecm - free dynamically-allocated things in a colormap
*/
static void
freecm(struct colormap *cm)
freecm(struct colormap * cm)
{
size_t i;
size_t i;
union tree *cb;
cm->magic = 0;
if (NBYTS > 1)
cmtreefree(cm, cm->tree, 0);
for (i = 1; i <= cm->max; i++) /* skip WHITE */
if (!UNUSEDCOLOR(&cm->cd[i])) {
if (!UNUSEDCOLOR(&cm->cd[i]))
{
cb = cm->cd[i].block;
if (cb != NULL)
FREE(cb);
@ -108,24 +110,29 @@ freecm(struct colormap *cm)
* cmtreefree - free a non-terminal part of a colormap tree
*/
static void
cmtreefree(struct colormap *cm,
union tree *tree,
cmtreefree(struct colormap * cm,
union tree * tree,
int level) /* level number (top == 0) of this block */
{
int i;
int i;
union tree *t;
union tree *fillt = &cm->tree[level+1];
union tree *fillt = &cm->tree[level + 1];
union tree *cb;
assert(level < NBYTS-1); /* this level has pointers */
for (i = BYTTAB-1; i >= 0; i--) {
assert(level < NBYTS - 1); /* this level has pointers */
for (i = BYTTAB - 1; i >= 0; i--)
{
t = tree->tptr[i];
assert(t != NULL);
if (t != fillt) {
if (level < NBYTS-2) { /* more pointer blocks below */
cmtreefree(cm, t, level+1);
if (t != fillt)
{
if (level < NBYTS - 2)
{ /* more pointer blocks below */
cmtreefree(cm, t, level + 1);
FREE(t);
} else { /* color block below */
}
else
{ /* color block below */
cb = cm->cd[t->tcolor[0]].block;
if (t != cb) /* not a solid block */
FREE(t);
@ -137,22 +144,22 @@ cmtreefree(struct colormap *cm,
/*
* setcolor - set the color of a character in a colormap
*/
static color /* previous color */
setcolor(struct colormap *cm,
static color /* previous color */
setcolor(struct colormap * cm,
chr c,
pcolor co)
{
uchr uc = c;
int shift;
int level;
int b;
int bottom;
uchr uc = c;
int shift;
int level;
int b;
int bottom;
union tree *t;
union tree *newt;
union tree *fillt;
union tree *lastt;
union tree *cb;
color prev;
color prev;
assert(cm->magic == CMMAGIC);
if (CISERR() || co == COLORLESS)
@ -160,27 +167,30 @@ setcolor(struct colormap *cm,
t = cm->tree;
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
level++, shift -= BYTBITS) {
level++, shift -= BYTBITS)
{
b = (uc >> shift) & BYTMASK;
lastt = t;
t = lastt->tptr[b];
assert(t != NULL);
fillt = &cm->tree[level+1];
fillt = &cm->tree[level + 1];
bottom = (shift <= BYTBITS) ? 1 : 0;
cb = (bottom) ? cm->cd[t->tcolor[0]].block : fillt;
if (t == fillt || t == cb) { /* must allocate a new block */
newt = (union tree *)MALLOC((bottom) ?
sizeof(struct colors) : sizeof(struct ptrs));
if (newt == NULL) {
if (t == fillt || t == cb)
{ /* must allocate a new block */
newt = (union tree *) MALLOC((bottom) ?
sizeof(struct colors) : sizeof(struct ptrs));
if (newt == NULL)
{
CERR(REG_ESPACE);
return COLORLESS;
}
if (bottom)
memcpy(VS(newt->tcolor), VS(t->tcolor),
BYTTAB*sizeof(color));
BYTTAB * sizeof(color));
else
memcpy(VS(newt->tptr), VS(t->tptr),
BYTTAB*sizeof(union tree *));
BYTTAB * sizeof(union tree *));
t = newt;
lastt->tptr[b] = t;
}
@ -188,7 +198,7 @@ setcolor(struct colormap *cm,
b = uc & BYTMASK;
prev = t->tcolor[b];
t->tcolor[b] = (color)co;
t->tcolor[b] = (color) co;
return prev;
}
@ -196,51 +206,59 @@ setcolor(struct colormap *cm,
* maxcolor - report largest color number in use
*/
static color
maxcolor(struct colormap *cm)
maxcolor(struct colormap * cm)
{
if (CISERR())
return COLORLESS;
return (color)cm->max;
return (color) cm->max;
}
/*
* newcolor - find a new color (must be subject of setcolor at once)
* Beware: may relocate the colordescs.
* Beware: may relocate the colordescs.
*/
static color /* COLORLESS for error */
newcolor(struct colormap *cm)
static color /* COLORLESS for error */
newcolor(struct colormap * cm)
{
struct colordesc *cd;
struct colordesc *new;
size_t n;
size_t n;
if (CISERR())
return COLORLESS;
if (cm->free != 0) {
if (cm->free != 0)
{
assert(cm->free > 0);
assert((size_t)cm->free < cm->ncds);
assert((size_t) cm->free < cm->ncds);
cd = &cm->cd[cm->free];
assert(UNUSEDCOLOR(cd));
assert(cd->arcs == NULL);
cm->free = cd->sub;
} else if (cm->max < cm->ncds - 1) {
}
else if (cm->max < cm->ncds - 1)
{
cm->max++;
cd = &cm->cd[cm->max];
} else {
}
else
{
/* oops, must allocate more */
n = cm->ncds * 2;
if (cm->cd == cm->cdspace) {
new = (struct colordesc *)MALLOC(n *
sizeof(struct colordesc));
if (cm->cd == cm->cdspace)
{
new = (struct colordesc *) MALLOC(n *
sizeof(struct colordesc));
if (new != NULL)
memcpy(VS(new), VS(cm->cdspace), cm->ncds *
sizeof(struct colordesc));
} else
new = (struct colordesc *)REALLOC(cm->cd,
n * sizeof(struct colordesc));
if (new == NULL) {
sizeof(struct colordesc));
}
else
new = (struct colordesc *) REALLOC(cm->cd,
n * sizeof(struct colordesc));
if (new == NULL)
{
CERR(REG_ESPACE);
return COLORLESS;
}
@ -257,18 +275,19 @@ newcolor(struct colormap *cm)
cd->flags = 0;
cd->block = NULL;
return (color)(cd - cm->cd);
return (color) (cd - cm->cd);
}
/*
* freecolor - free a color (must have no arcs or subcolor)
*/
static void
freecolor(struct colormap *cm,
freecolor(struct colormap * cm,
pcolor co)
{
struct colordesc *cd = &cm->cd[co];
color pco, nco; /* for freelist scan */
color pco,
nco; /* for freelist scan */
assert(co >= 0);
if (co == WHITE)
@ -278,35 +297,43 @@ freecolor(struct colormap *cm,
assert(cd->sub == NOSUB);
assert(cd->nchrs == 0);
cd->flags = FREECOL;
if (cd->block != NULL) {
if (cd->block != NULL)
{
FREE(cd->block);
cd->block = NULL; /* just paranoia */
cd->block = NULL; /* just paranoia */
}
if ((size_t)co == cm->max) {
if ((size_t) co == cm->max)
{
while (cm->max > WHITE && UNUSEDCOLOR(&cm->cd[cm->max]))
cm->max--;
assert(cm->free >= 0);
while ((size_t)cm->free > cm->max)
while ((size_t) cm->free > cm->max)
cm->free = cm->cd[cm->free].sub;
if (cm->free > 0) {
if (cm->free > 0)
{
assert(cm->free < cm->max);
pco = cm->free;
nco = cm->cd[pco].sub;
while (nco > 0)
if ((size_t)nco > cm->max) {
if ((size_t) nco > cm->max)
{
/* take this one out of freelist */
nco = cm->cd[nco].sub;
cm->cd[pco].sub = nco;
} else {
}
else
{
assert(nco < cm->max);
pco = nco;
nco = cm->cd[pco].sub;
}
}
} else {
}
else
{
cd->sub = cm->free;
cm->free = (color)(cd - cm->cd);
cm->free = (color) (cd - cm->cd);
}
}
@ -314,9 +341,9 @@ freecolor(struct colormap *cm,
* pseudocolor - allocate a false color, to be managed by other means
*/
static color
pseudocolor(struct colormap *cm)
pseudocolor(struct colormap * cm)
{
color co;
color co;
co = newcolor(cm);
if (CISERR())
@ -330,10 +357,10 @@ pseudocolor(struct colormap *cm)
* subcolor - allocate a new subcolor (if necessary) to this chr
*/
static color
subcolor(struct colormap *cm, chr c)
subcolor(struct colormap * cm, chr c)
{
color co; /* current color of c */
color sco; /* new subcolor */
color co; /* current color of c */
color sco; /* new subcolor */
co = GETCOLOR(cm, c);
sco = newsub(cm, co);
@ -341,8 +368,8 @@ subcolor(struct colormap *cm, chr c)
return COLORLESS;
assert(sco != COLORLESS);
if (co == sco) /* already in an open subcolor */
return co; /* rest is redundant */
if (co == sco) /* already in an open subcolor */
return co; /* rest is redundant */
cm->cd[co].nchrs--;
cm->cd[sco].nchrs++;
setcolor(cm, c, sco);
@ -353,17 +380,19 @@ subcolor(struct colormap *cm, chr c)
* newsub - allocate a new subcolor (if necessary) for a color
*/
static color
newsub(struct colormap *cm,
newsub(struct colormap * cm,
pcolor co)
{
color sco; /* new subcolor */
color sco; /* new subcolor */
sco = cm->cd[co].sub;
if (sco == NOSUB) { /* color has no open subcolor */
if (cm->cd[co].nchrs == 1) /* optimization */
if (sco == NOSUB)
{ /* color has no open subcolor */
if (cm->cd[co].nchrs == 1) /* optimization */
return co;
sco = newcolor(cm); /* must create subcolor */
if (sco == COLORLESS) {
sco = newcolor(cm); /* must create subcolor */
if (sco == COLORLESS)
{
assert(CISERR());
return COLORLESS;
}
@ -379,23 +408,23 @@ newsub(struct colormap *cm,
* subrange - allocate new subcolors to this range of chrs, fill in arcs
*/
static void
subrange(struct vars *v,
subrange(struct vars * v,
chr from,
chr to,
struct state *lp,
struct state *rp)
struct state * lp,
struct state * rp)
{
uchr uf;
int i;
uchr uf;
int i;
assert(from <= to);
/* first, align "from" on a tree-block boundary */
uf = (uchr)from;
i = (int)( ((uf + BYTTAB-1) & (uchr)~BYTMASK) - uf );
uf = (uchr) from;
i = (int) (((uf + BYTTAB - 1) & (uchr) ~ BYTMASK) - uf);
for (; from <= to && i > 0; i--, from++)
newarc(v->nfa, PLAIN, subcolor(v->cm, from), lp, rp);
if (from > to) /* didn't reach a boundary */
if (from > to) /* didn't reach a boundary */
return;
/* deal with whole blocks */
@ -411,25 +440,25 @@ subrange(struct vars *v,
* subblock - allocate new subcolors for one tree block of chrs, fill in arcs
*/
static void
subblock(struct vars *v,
subblock(struct vars * v,
chr start, /* first of BYTTAB chrs */
struct state *lp,
struct state *rp)
struct state * lp,
struct state * rp)
{
uchr uc = start;
uchr uc = start;
struct colormap *cm = v->cm;
int shift;
int level;
int i;
int b;
int shift;
int level;
int i;
int b;
union tree *t;
union tree *cb;
union tree *fillt;
union tree *lastt;
int previ;
int ndone;
color co;
color sco;
int previ;
int ndone;
color co;
color sco;
assert((uc % BYTTAB) == 0);
@ -437,20 +466,23 @@ subblock(struct vars *v,
t = cm->tree;
fillt = NULL;
for (level = 0, shift = BYTBITS * (NBYTS - 1); shift > 0;
level++, shift -= BYTBITS) {
level++, shift -= BYTBITS)
{
b = (uc >> shift) & BYTMASK;
lastt = t;
t = lastt->tptr[b];
assert(t != NULL);
fillt = &cm->tree[level+1];
if (t == fillt && shift > BYTBITS) { /* need new ptr block */
t = (union tree *)MALLOC(sizeof(struct ptrs));
if (t == NULL) {
fillt = &cm->tree[level + 1];
if (t == fillt && shift > BYTBITS)
{ /* need new ptr block */
t = (union tree *) MALLOC(sizeof(struct ptrs));
if (t == NULL)
{
CERR(REG_ESPACE);
return;
}
memcpy(VS(t->tptr), VS(fillt->tptr),
BYTTAB*sizeof(union tree *));
BYTTAB * sizeof(union tree *));
lastt->tptr[b] = t;
}
}
@ -458,13 +490,16 @@ subblock(struct vars *v,
/* special cases: fill block or solid block */
co = t->tcolor[0];
cb = cm->cd[co].block;
if (t == fillt || t == cb) {
if (t == fillt || t == cb)
{
/* either way, we want a subcolor solid block */
sco = newsub(cm, co);
t = cm->cd[sco].block;
if (t == NULL) { /* must set it up */
t = (union tree *)MALLOC(sizeof(struct colors));
if (t == NULL) {
if (t == NULL)
{ /* must set it up */
t = (union tree *) MALLOC(sizeof(struct colors));
if (t == NULL)
{
CERR(REG_ESPACE);
return;
}
@ -482,12 +517,14 @@ subblock(struct vars *v,
/* general case, a mixed block to be altered */
i = 0;
while (i < BYTTAB) {
while (i < BYTTAB)
{
co = t->tcolor[i];
sco = newsub(cm, co);
newarc(v->nfa, PLAIN, sco, lp, rp);
previ = i;
do {
do
{
t->tcolor[i++] = sco;
} while (i < BYTTAB && t->tcolor[i] == co);
ndone = i - previ;
@ -500,30 +537,37 @@ subblock(struct vars *v,
* okcolors - promote subcolors to full colors
*/
static void
okcolors(struct nfa *nfa,
struct colormap *cm)
okcolors(struct nfa * nfa,
struct colormap * cm)
{
struct colordesc *cd;
struct colordesc *end = CDEND(cm);
struct colordesc *scd;
struct arc *a;
color co;
color sco;
color co;
color sco;
for (cd = cm->cd, co = 0; cd < end; cd++, co++) {
for (cd = cm->cd, co = 0; cd < end; cd++, co++)
{
sco = cd->sub;
if (UNUSEDCOLOR(cd) || sco == NOSUB) {
if (UNUSEDCOLOR(cd) || sco == NOSUB)
{
/* has no subcolor, no further action */
} else if (sco == co) {
}
else if (sco == co)
{
/* is subcolor, let parent deal with it */
} else if (cd->nchrs == 0) {
}
else if (cd->nchrs == 0)
{
/* parent empty, its arcs change color to subcolor */
cd->sub = NOSUB;
scd = &cm->cd[sco];
assert(scd->nchrs > 0);
assert(scd->sub == sco);
scd->sub = NOSUB;
while ((a = cd->arcs) != NULL) {
while ((a = cd->arcs) != NULL)
{
assert(a->co == co);
/* uncolorchain(cm, a); */
cd->arcs = a->colorchain;
@ -533,14 +577,17 @@ okcolors(struct nfa *nfa,
scd->arcs = a;
}
freecolor(cm, co);
} else {
}
else
{
/* parent's arcs must gain parallel subcolor arcs */
cd->sub = NOSUB;
scd = &cm->cd[sco];
assert(scd->nchrs > 0);
assert(scd->sub == sco);
scd->sub = NOSUB;
for (a = cd->arcs; a != NULL; a = a->colorchain) {
for (a = cd->arcs; a != NULL; a = a->colorchain)
{
assert(a->co == co);
newarc(nfa, a->type, sco, a->from, a->to);
}
@ -552,8 +599,8 @@ okcolors(struct nfa *nfa,
* colorchain - add this arc to the color chain of its color
*/
static void
colorchain(struct colormap *cm,
struct arc *a)
colorchain(struct colormap * cm,
struct arc * a)
{
struct colordesc *cd = &cm->cd[a->co];
@ -565,32 +612,33 @@ colorchain(struct colormap *cm,
* uncolorchain - delete this arc from the color chain of its color
*/
static void
uncolorchain(struct colormap *cm,
struct arc *a)
uncolorchain(struct colormap * cm,
struct arc * a)
{
struct colordesc *cd = &cm->cd[a->co];
struct arc *aa;
aa = cd->arcs;
if (aa == a) /* easy case */
if (aa == a) /* easy case */
cd->arcs = a->colorchain;
else {
else
{
for (; aa != NULL && aa->colorchain != a; aa = aa->colorchain)
continue;
assert(aa != NULL);
aa->colorchain = a->colorchain;
}
a->colorchain = NULL; /* paranoia */
a->colorchain = NULL; /* paranoia */
}
/*
* singleton - is this character in its own color?
*/
static int /* predicate */
singleton(struct colormap *cm,
static int /* predicate */
singleton(struct colormap * cm,
chr c)
{
color co; /* color of c */
color co; /* color of c */
co = GETCOLOR(cm, c);
if (cm->cd[co].nchrs == 1 && cm->cd[co].sub == NOSUB)
@ -602,20 +650,20 @@ singleton(struct colormap *cm,
* rainbow - add arcs of all full colors (but one) between specified states
*/
static void
rainbow(struct nfa *nfa,
struct colormap *cm,
rainbow(struct nfa * nfa,
struct colormap * cm,
int type,
pcolor but, /* COLORLESS if no exceptions */
struct state *from,
struct state *to)
struct state * from,
struct state * to)
{
struct colordesc *cd;
struct colordesc *end = CDEND(cm);
color co;
color co;
for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
if (!UNUSEDCOLOR(cd) && cd->sub != co && co != but &&
!(cd->flags&PSEUDO))
!(cd->flags & PSEUDO))
newarc(nfa, type, co, from, to);
}
@ -625,20 +673,21 @@ rainbow(struct nfa *nfa,
* The calling sequence ought to be reconciled with cloneouts().
*/
static void
colorcomplement(struct nfa *nfa,
struct colormap *cm,
colorcomplement(struct nfa * nfa,
struct colormap * cm,
int type,
struct state *of, /* complements of this guy's PLAIN outarcs */
struct state *from,
struct state *to)
struct state * of, /* complements of this guy's PLAIN
* outarcs */
struct state * from,
struct state * to)
{
struct colordesc *cd;
struct colordesc *end = CDEND(cm);
color co;
color co;
assert(of != from);
for (cd = cm->cd, co = 0; cd < end && !CISERR(); cd++, co++)
if (!UNUSEDCOLOR(cd) && !(cd->flags&PSEUDO))
if (!UNUSEDCOLOR(cd) && !(cd->flags & PSEUDO))
if (findarc(of, PLAIN, co) == NULL)
newarc(nfa, type, co, from, to);
}
@ -650,28 +699,29 @@ colorcomplement(struct nfa *nfa,
* dumpcolors - debugging output
*/
static void
dumpcolors(struct colormap *cm,
dumpcolors(struct colormap * cm,
FILE *f)
{
struct colordesc *cd;
struct colordesc *end;
color co;
chr c;
char *has;
color co;
chr c;
char *has;
fprintf(f, "max %ld\n", (long)cm->max);
fprintf(f, "max %ld\n", (long) cm->max);
if (NBYTS > 1)
fillcheck(cm, cm->tree, 0, f);
end = CDEND(cm);
for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */
if (!UNUSEDCOLOR(cd)) {
for (cd = cm->cd + 1, co = 1; cd < end; cd++, co++) /* skip 0 */
if (!UNUSEDCOLOR(cd))
{
assert(cd->nchrs > 0);
has = (cd->block != NULL) ? "#" : "";
if (cd->flags&PSEUDO)
fprintf(f, "#%2ld%s(ps): ", (long)co, has);
if (cd->flags & PSEUDO)
fprintf(f, "#%2ld%s(ps): ", (long) co, has);
else
fprintf(f, "#%2ld%s(%2d): ", (long)co,
has, cd->nchrs);
fprintf(f, "#%2ld%s(%2d): ", (long) co,
has, cd->nchrs);
/* it's hard to do this more efficiently */
for (c = CHR_MIN; c < CHR_MAX; c++)
if (GETCOLOR(cm, c) == co)
@ -687,24 +737,26 @@ dumpcolors(struct colormap *cm,
* fillcheck - check proper filling of a tree
*/
static void
fillcheck(struct colormap *cm,
union tree *tree,
fillcheck(struct colormap * cm,
union tree * tree,
int level, /* level number (top == 0) of this block */
FILE *f)
{
int i;
int i;
union tree *t;
union tree *fillt = &cm->tree[level+1];
union tree *fillt = &cm->tree[level + 1];
assert(level < NBYTS-1); /* this level has pointers */
for (i = BYTTAB-1; i >= 0; i--) {
assert(level < NBYTS - 1); /* this level has pointers */
for (i = BYTTAB - 1; i >= 0; i--)
{
t = tree->tptr[i];
if (t == NULL)
fprintf(f, "NULL found in filled tree!\n");
else if (t == fillt)
{}
else if (level < NBYTS-2) /* more pointer blocks below */
fillcheck(cm, t, level+1, f);
{
}
else if (level < NBYTS - 2) /* more pointer blocks below */
fillcheck(cm, t, level + 1, f);
}
}
@ -720,9 +772,9 @@ dumpchr(chr c,
if (c == '\\')
fprintf(f, "\\\\");
else if (c > ' ' && c <= '~')
putc((char)c, f);
putc((char) c, f);
else
fprintf(f, "\\u%04lx", (long)c);
fprintf(f, "\\u%04lx", (long) c);
}
#endif /* REG_DEBUG */
#endif /* REG_DEBUG */

185
src/backend/regex/regc_cvec.c
View File

@ -2,21 +2,21 @@
* Utility functions for handling cvecs
* This file is #included by regcomp.c.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Development of this software was funded, in part, by Cray Research Inc.,
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
* Corporation, none of whom are responsible for the results. The author
* thanks all of them.
*
* thanks all of them.
*
* Redistribution and use in source and binary forms -- with or without
* modification -- are permitted for any purpose, provided that
* redistributions in source form retain this entire copyright notice and
* indicate the origin and nature of any modifications.
*
*
* I'd appreciate being given credit for this package in the documentation
* of software which uses it, but that is not a requirement.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -28,7 +28,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.1 2003/02/05 17:41:32 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regc_cvec.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
*
*/
@ -40,23 +40,24 @@ newcvec(int nchrs, /* to hold this many chrs... */
int nranges, /* ... and this many ranges... */
int nmcces) /* ... and this many MCCEs */
{
size_t n;
size_t nc;
struct cvec *cv;
size_t n;
size_t nc;
struct cvec *cv;
nc = (size_t)nchrs + (size_t)nmcces*(MAXMCCE+1) + (size_t)nranges*2;
n = sizeof(struct cvec) + (size_t)(nmcces-1)*sizeof(chr *)
+ nc*sizeof(chr);
cv = (struct cvec *)MALLOC(n);
if (cv == NULL) {
return NULL;
}
cv->chrspace = nchrs;
cv->chrs = (chr *)&cv->mcces[nmcces]; /* chrs just after MCCE ptrs */
cv->mccespace = nmcces;
cv->ranges = cv->chrs + nchrs + nmcces*(MAXMCCE+1);
cv->rangespace = nranges;
return clearcvec(cv);
nc = (size_t) nchrs + (size_t) nmcces *(MAXMCCE + 1) + (size_t) nranges *2;
n = sizeof(struct cvec) + (size_t) (nmcces - 1) * sizeof(chr *)
+ nc * sizeof(chr);
cv = (struct cvec *) MALLOC(n);
if (cv == NULL)
return NULL;
cv->chrspace = nchrs;
cv->chrs = (chr *) & cv->mcces[nmcces]; /* chrs just after MCCE
* ptrs */
cv->mccespace = nmcces;
cv->ranges = cv->chrs + nchrs + nmcces * (MAXMCCE + 1);
cv->rangespace = nranges;
return clearcvec(cv);
}
/*
@ -64,131 +65,125 @@ newcvec(int nchrs, /* to hold this many chrs... */
* Returns pointer as convenience.
*/
static struct cvec *
clearcvec(struct cvec *cv)
clearcvec(struct cvec * cv)
{
int i;
int i;
assert(cv != NULL);
cv->nchrs = 0;
assert(cv->chrs == (chr *)&cv->mcces[cv->mccespace]);
cv->nmcces = 0;
cv->nmccechrs = 0;
cv->nranges = 0;
for (i = 0; i < cv->mccespace; i++) {
cv->mcces[i] = NULL;
}
assert(cv != NULL);
cv->nchrs = 0;
assert(cv->chrs == (chr *) & cv->mcces[cv->mccespace]);
cv->nmcces = 0;
cv->nmccechrs = 0;
cv->nranges = 0;
for (i = 0; i < cv->mccespace; i++)
cv->mcces[i] = NULL;
return cv;
return cv;
}
/*
* addchr - add a chr to a cvec
*/
static void
addchr(struct cvec *cv, /* character vector */
chr c) /* character to add */
addchr(struct cvec * cv, /* character vector */
chr c) /* character to add */
{
assert(cv->nchrs < cv->chrspace - cv->nmccechrs);
cv->chrs[cv->nchrs++] = (chr)c;
assert(cv->nchrs < cv->chrspace - cv->nmccechrs);
cv->chrs[cv->nchrs++] = (chr) c;
}
/*
* addrange - add a range to a cvec
*/
static void
addrange(struct cvec *cv, /* character vector */
addrange(struct cvec * cv, /* character vector */
chr from, /* first character of range */
chr to) /* last character of range */
{
assert(cv->nranges < cv->rangespace);
cv->ranges[cv->nranges*2] = (chr)from;
cv->ranges[cv->nranges*2 + 1] = (chr)to;
cv->nranges++;
assert(cv->nranges < cv->rangespace);
cv->ranges[cv->nranges * 2] = (chr) from;
cv->ranges[cv->nranges * 2 + 1] = (chr) to;
cv->nranges++;
}
/*
* addmcce - add an MCCE to a cvec
*/
static void
addmcce(struct cvec *cv, /* character vector */
chr *startp, /* beginning of text */
chr *endp) /* just past end of text */
addmcce(struct cvec * cv, /* character vector */
chr * startp, /* beginning of text */
chr * endp) /* just past end of text */
{
int len;
int i;
chr *s;
chr *d;
int len;
int i;
chr *s;
chr *d;
if (startp == NULL && endp == NULL) {
return;
}
len = endp - startp;
assert(len > 0);
assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);
assert(cv->nmcces < cv->mccespace);
d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];
cv->mcces[cv->nmcces++] = d;
for (s = startp, i = len; i > 0; s++, i--) {
*d++ = *s;
}
*d++ = 0; /* endmarker */
assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);
cv->nmccechrs += len + 1;
if (startp == NULL && endp == NULL)
return;
len = endp - startp;
assert(len > 0);
assert(cv->nchrs + len < cv->chrspace - cv->nmccechrs);
assert(cv->nmcces < cv->mccespace);
d = &cv->chrs[cv->chrspace - cv->nmccechrs - len - 1];
cv->mcces[cv->nmcces++] = d;
for (s = startp, i = len; i > 0; s++, i--)
*d++ = *s;
*d++ = 0; /* endmarker */
assert(d == &cv->chrs[cv->chrspace - cv->nmccechrs]);
cv->nmccechrs += len + 1;
}
/*
* haschr - does a cvec contain this chr?
*/
static int /* predicate */
haschr(struct cvec *cv, /* character vector */
chr c) /* character to test for */
static int /* predicate */
haschr(struct cvec * cv, /* character vector */
chr c) /* character to test for */
{
int i;
chr *p;
int i;
chr *p;
for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--) {
if (*p == c) {
return 1;
for (p = cv->chrs, i = cv->nchrs; i > 0; p++, i--)
{
if (*p == c)
return 1;
}
}
for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--) {
if ((*p <= c) && (c <= *(p+1))) {
return 1;
for (p = cv->ranges, i = cv->nranges; i > 0; p += 2, i--)
{
if ((*p <= c) && (c <= *(p + 1)))
return 1;
}
}
return 0;
return 0;
}
/*
* getcvec - get a cvec, remembering it as v->cv
*/
static struct cvec *
getcvec(struct vars *v, /* context */
getcvec(struct vars * v, /* context */
int nchrs, /* to hold this many chrs... */
int nranges, /* ... and this many ranges... */
int nmcces) /* ... and this many MCCEs */
{
if (v->cv != NULL && nchrs <= v->cv->chrspace &&
nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace) {
return clearcvec(v->cv);
}
if (v->cv != NULL && nchrs <= v->cv->chrspace &&
nranges <= v->cv->rangespace && nmcces <= v->cv->mccespace)
return clearcvec(v->cv);
if (v->cv != NULL) {
freecvec(v->cv);
}
v->cv = newcvec(nchrs, nranges, nmcces);
if (v->cv == NULL) {
ERR(REG_ESPACE);
}
if (v->cv != NULL)
freecvec(v->cv);
v->cv = newcvec(nchrs, nranges, nmcces);
if (v->cv == NULL)
ERR(REG_ESPACE);
return v->cv;
return v->cv;
}
/*
* freecvec - free a cvec
*/
static void
freecvec(struct cvec *cv)
freecvec(struct cvec * cv)
{
FREE(cv);
FREE(cv);
}

1506
src/backend/regex/regc_lex.c
View File

File diff suppressed because it is too large Load Diff

968
src/backend/regex/regc_locale.c
View File

File diff suppressed because it is too large Load Diff

856
src/backend/regex/regc_nfa.c
View File

File diff suppressed because it is too large Load Diff

1838
src/backend/regex/regcomp.c
View File

File diff suppressed because it is too large Load Diff

416
src/backend/regex/rege_dfa.c
View File

@ -2,21 +2,21 @@
* DFA routines
* This file is #included by regexec.c.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Development of this software was funded, in part, by Cray Research Inc.,
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
* Corporation, none of whom are responsible for the results. The author
* thanks all of them.
*
* thanks all of them.
*
* Redistribution and use in source and binary forms -- with or without
* modification -- are permitted for any purpose, provided that
* redistributions in source form retain this entire copyright notice and
* indicate the origin and nature of any modifications.
*
*
* I'd appreciate being given credit for this package in the documentation
* of software which uses it, but that is not a requirement.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -28,27 +28,27 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.1 2003/02/05 17:41:33 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/rege_dfa.c,v 1.2 2003/08/04 00:43:21 momjian Exp $
*
*/
/*
* longest - longest-preferred matching engine
*/
static chr * /* endpoint, or NULL */
longest(struct vars *v, /* used only for debug and exec flags */
struct dfa *d,
chr *start, /* where the match should start */
chr *stop, /* match must end at or before here */
static chr * /* endpoint, or NULL */
longest(struct vars * v, /* used only for debug and exec flags */
struct dfa * d,
chr * start, /* where the match should start */
chr * stop, /* match must end at or before here */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
{
chr *cp;
chr *realstop = (stop == v->stop) ? stop : stop + 1;
color co;
chr *cp;
chr *realstop = (stop == v->stop) ? stop : stop + 1;
color co;
struct sset *css;
struct sset *ss;
chr *post;
int i;
chr *post;
int i;
struct colormap *cm = d->cm;
/* initialize */
@ -59,12 +59,15 @@ longest(struct vars *v, /* used only for debug and exec flags */
/* startup */
FDEBUG(("+++ startup +++\n"));
if (cp == v->start) {
co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co));
} else {
if (cp == v->start)
{
co = d->cnfa->bos[(v->eflags & REG_NOTBOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long) co));
}
else
{
co = GETCOLOR(cm, *(cp - 1));
FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co));
FDEBUG(("char %c, color %ld\n", (char) *(cp - 1), (long) co));
}
css = miss(v, d, css, co, cp, start);
if (css == NULL)
@ -72,29 +75,33 @@ longest(struct vars *v, /* used only for debug and exec flags */
css->lastseen = cp;
/* main loop */
if (v->eflags&REG_FTRACE)
while (cp < realstop) {
if (v->eflags & REG_FTRACE)
while (cp < realstop)
{
FDEBUG(("+++ at c%d +++\n", css - d->ssets));
co = GETCOLOR(cm, *cp);
FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co));
FDEBUG(("char %c, color %ld\n", (char) *cp, (long) co));
ss = css->outs[co];
if (ss == NULL) {
ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL)
{
ss = miss(v, d, css, co, cp + 1, start);
if (ss == NULL)
break; /* NOTE BREAK OUT */
break; /* NOTE BREAK OUT */
}
cp++;
ss->lastseen = cp;
css = ss;
}
else
while (cp < realstop) {
while (cp < realstop)
{
co = GETCOLOR(cm, *cp);
ss = css->outs[co];
if (ss == NULL) {
ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL)
{
ss = miss(v, d, css, co, cp + 1, start);
if (ss == NULL)
break; /* NOTE BREAK OUT */
break; /* NOTE BREAK OUT */
}
cp++;
ss->lastseen = cp;
@ -103,14 +110,15 @@ longest(struct vars *v, /* used only for debug and exec flags */
/* shutdown */
FDEBUG(("+++ shutdown at c%d +++\n", css - d->ssets));
if (cp == v->stop && stop == v->stop) {
if (cp == v->stop && stop == v->stop)
{
if (hitstopp != NULL)
*hitstopp = 1;
co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co));
co = d->cnfa->eos[(v->eflags & REG_NOTEOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long) co));
ss = miss(v, d, css, co, cp, start);
/* special case: match ended at eol? */
if (ss != NULL && (ss->flags&POSTSTATE))
if (ss != NULL && (ss->flags & POSTSTATE))
return cp;
else if (ss != NULL)
ss->lastseen = cp; /* to be tidy */
@ -119,10 +127,10 @@ longest(struct vars *v, /* used only for debug and exec flags */
/* find last match, if any */
post = d->lastpost;
for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
if ((ss->flags&POSTSTATE) && post != ss->lastseen &&
(post == NULL || post < ss->lastseen))
if ((ss->flags & POSTSTATE) && post != ss->lastseen &&
(post == NULL || post < ss->lastseen))
post = ss->lastseen;
if (post != NULL) /* found one */
if (post != NULL) /* found one */
return post - 1;
return NULL;
@ -131,19 +139,20 @@ longest(struct vars *v, /* used only for debug and exec flags */
/*
* shortest - shortest-preferred matching engine
*/
static chr * /* endpoint, or NULL */
shortest(struct vars *v,
struct dfa *d,
chr *start, /* where the match should start */
chr *min, /* match must end at or after here */
chr *max, /* match must end at or before here */
chr **coldp, /* store coldstart pointer here, if nonNULL */
static chr * /* endpoint, or NULL */
shortest(struct vars * v,
struct dfa * d,
chr * start, /* where the match should start */
chr * min, /* match must end at or after here */
chr * max, /* match must end at or before here */
chr ** coldp, /* store coldstart pointer here, if
* nonNULL */
int *hitstopp) /* record whether hit v->stop, if non-NULL */
{
chr *cp;
chr *realmin = (min == v->stop) ? min : min + 1;
chr *realmax = (max == v->stop) ? max : max + 1;
color co;
chr *cp;
chr *realmin = (min == v->stop) ? min : min + 1;
chr *realmax = (max == v->stop) ? max : max + 1;
color co;
struct sset *css;
struct sset *ss;
struct colormap *cm = d->cm;
@ -156,12 +165,15 @@ shortest(struct vars *v,
/* startup */
FDEBUG(("--- startup ---\n"));
if (cp == v->start) {
co = d->cnfa->bos[(v->eflags&REG_NOTBOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co));
} else {
if (cp == v->start)
{
co = d->cnfa->bos[(v->eflags & REG_NOTBOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long) co));
}
else
{
co = GETCOLOR(cm, *(cp - 1));
FDEBUG(("char %c, color %ld\n", (char)*(cp-1), (long)co));
FDEBUG(("char %c, color %ld\n", (char) *(cp - 1), (long) co));
}
css = miss(v, d, css, co, cp, start);
if (css == NULL)
@ -170,58 +182,66 @@ shortest(struct vars *v,
ss = css;
/* main loop */
if (v->eflags&REG_FTRACE)
while (cp < realmax) {
if (v->eflags & REG_FTRACE)
while (cp < realmax)
{
FDEBUG(("--- at c%d ---\n", css - d->ssets));
co = GETCOLOR(cm, *cp);
FDEBUG(("char %c, color %ld\n", (char)*cp, (long)co));
FDEBUG(("char %c, color %ld\n", (char) *cp, (long) co));
ss = css->outs[co];
if (ss == NULL) {
ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL)
{
ss = miss(v, d, css, co, cp + 1, start);
if (ss == NULL)
break; /* NOTE BREAK OUT */
break; /* NOTE BREAK OUT */
}
cp++;
ss->lastseen = cp;
css = ss;
if ((ss->flags&POSTSTATE) && cp >= realmin)
break; /* NOTE BREAK OUT */
if ((ss->flags & POSTSTATE) && cp >= realmin)
break; /* NOTE BREAK OUT */
}
else
while (cp < realmax) {
while (cp < realmax)
{
co = GETCOLOR(cm, *cp);
ss = css->outs[co];
if (ss == NULL) {
ss = miss(v, d, css, co, cp+1, start);
if (ss == NULL)
{
ss = miss(v, d, css, co, cp + 1, start);
if (ss == NULL)
break; /* NOTE BREAK OUT */
break; /* NOTE BREAK OUT */
}
cp++;
ss->lastseen = cp;
css = ss;
if ((ss->flags&POSTSTATE) && cp >= realmin)
break; /* NOTE BREAK OUT */
if ((ss->flags & POSTSTATE) && cp >= realmin)
break; /* NOTE BREAK OUT */
}
if (ss == NULL)
return NULL;
if (coldp != NULL) /* report last no-progress state set, if any */
if (coldp != NULL) /* report last no-progress state set, if
* any */
*coldp = lastcold(v, d);
if ((ss->flags&POSTSTATE) && cp > min) {
if ((ss->flags & POSTSTATE) && cp > min)
{
assert(cp >= realmin);
cp--;
} else if (cp == v->stop && max == v->stop) {
co = d->cnfa->eos[(v->eflags&REG_NOTEOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long)co));
}
else if (cp == v->stop && max == v->stop)
{
co = d->cnfa->eos[(v->eflags & REG_NOTEOL) ? 0 : 1];
FDEBUG(("color %ld\n", (long) co));
ss = miss(v, d, css, co, cp, start);
/* match might have ended at eol */
if ((ss == NULL || !(ss->flags&POSTSTATE)) && hitstopp != NULL)
if ((ss == NULL || !(ss->flags & POSTSTATE)) && hitstopp != NULL)
*hitstopp = 1;
}
if (ss == NULL || !(ss->flags&POSTSTATE))
if (ss == NULL || !(ss->flags & POSTSTATE))
return NULL;
return cp;
@ -230,19 +250,19 @@ shortest(struct vars *v,
/*
* lastcold - determine last point at which no progress had been made
*/
static chr * /* endpoint, or NULL */
lastcold(struct vars *v,
struct dfa *d)
static chr * /* endpoint, or NULL */
lastcold(struct vars * v,
struct dfa * d)
{
struct sset *ss;
chr *nopr;
int i;
chr *nopr;
int i;
nopr = d->lastnopr;
if (nopr == NULL)
nopr = v->start;
for (ss = d->ssets, i = d->nssused; i > 0; ss++, i--)
if ((ss->flags&NOPROGRESS) && nopr < ss->lastseen)
if ((ss->flags & NOPROGRESS) && nopr < ss->lastseen)
nopr = ss->lastseen;
return nopr;
}
@ -251,24 +271,27 @@ lastcold(struct vars *v,
* newdfa - set up a fresh DFA
*/
static struct dfa *
newdfa(struct vars *v,
struct cnfa *cnfa,
struct colormap *cm,
struct smalldfa *small) /* preallocated space, may be NULL */
newdfa(struct vars * v,
struct cnfa * cnfa,
struct colormap * cm,
struct smalldfa * small) /* preallocated space, may be NULL */
{
struct dfa *d;
size_t nss = cnfa->nstates * 2;
int wordsper = (cnfa->nstates + UBITS - 1) / UBITS;
size_t nss = cnfa->nstates * 2;
int wordsper = (cnfa->nstates + UBITS - 1) / UBITS;
struct smalldfa *smallwas = small;
assert(cnfa != NULL && cnfa->nstates != 0);
if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS) {
if (nss <= FEWSTATES && cnfa->ncolors <= FEWCOLORS)
{
assert(wordsper == 1);
if (small == NULL) {
small = (struct smalldfa *)MALLOC(
sizeof(struct smalldfa));
if (small == NULL) {
if (small == NULL)
{
small = (struct smalldfa *) MALLOC(
sizeof(struct smalldfa));
if (small == NULL)
{
ERR(REG_ESPACE);
return NULL;
}
@ -280,32 +303,36 @@ newdfa(struct vars *v,
d->outsarea = small->outsarea;
d->incarea = small->incarea;
d->cptsmalloced = 0;
d->mallocarea = (smallwas == NULL) ? (char *)small : NULL;
} else {
d = (struct dfa *)MALLOC(sizeof(struct dfa));
if (d == NULL) {
d->mallocarea = (smallwas == NULL) ? (char *) small : NULL;
}
else
{
d = (struct dfa *) MALLOC(sizeof(struct dfa));
if (d == NULL)
{
ERR(REG_ESPACE);
return NULL;
}
d->ssets = (struct sset *)MALLOC(nss * sizeof(struct sset));
d->statesarea = (unsigned *)MALLOC((nss+WORK) * wordsper *
sizeof(unsigned));
d->ssets = (struct sset *) MALLOC(nss * sizeof(struct sset));
d->statesarea = (unsigned *) MALLOC((nss + WORK) * wordsper *
sizeof(unsigned));
d->work = &d->statesarea[nss * wordsper];
d->outsarea = (struct sset **)MALLOC(nss * cnfa->ncolors *
sizeof(struct sset *));
d->incarea = (struct arcp *)MALLOC(nss * cnfa->ncolors *
sizeof(struct arcp));
d->outsarea = (struct sset **) MALLOC(nss * cnfa->ncolors *
sizeof(struct sset *));
d->incarea = (struct arcp *) MALLOC(nss * cnfa->ncolors *
sizeof(struct arcp));
d->cptsmalloced = 1;
d->mallocarea = (char *)d;
d->mallocarea = (char *) d;
if (d->ssets == NULL || d->statesarea == NULL ||
d->outsarea == NULL || d->incarea == NULL) {
d->outsarea == NULL || d->incarea == NULL)
{
freedfa(d);
ERR(REG_ESPACE);
return NULL;
}
}
d->nssets = (v->eflags&REG_SMALL) ? 7 : nss;
d->nssets = (v->eflags & REG_SMALL) ? 7 : nss;
d->nssused = 0;
d->nstates = cnfa->nstates;
d->ncolors = cnfa->ncolors;
@ -325,9 +352,10 @@ newdfa(struct vars *v,
* freedfa - free a DFA
*/
static void
freedfa(struct dfa *d)
freedfa(struct dfa * d)
{
if (d->cptsmalloced) {
if (d->cptsmalloced)
{
if (d->ssets != NULL)
FREE(d->ssets);
if (d->statesarea != NULL)
@ -351,8 +379,8 @@ static unsigned
hash(unsigned *uv,
int n)
{
int i;
unsigned h;
int i;
unsigned h;
h = 0;
for (i = 0; i < n; i++)
@ -364,24 +392,25 @@ hash(unsigned *uv,
* initialize - hand-craft a cache entry for startup, otherwise get ready
*/
static struct sset *
initialize(struct vars *v, /* used only for debug flags */
struct dfa *d,
chr *start)
initialize(struct vars * v, /* used only for debug flags */
struct dfa * d,
chr * start)
{
struct sset *ss;
int i;
int i;
/* is previous one still there? */
if (d->nssused > 0 && (d->ssets[0].flags&STARTER))
if (d->nssused > 0 && (d->ssets[0].flags & STARTER))
ss = &d->ssets[0];
else { /* no, must (re)build it */
else
{ /* no, must (re)build it */
ss = getvacant(v, d, start, start);
for (i = 0; i < d->wordsper; i++)
ss->states[i] = 0;
BSET(ss->states, d->cnfa->pre);
ss->hash = HASH(ss->states, d->wordsper);
assert(d->cnfa->pre != d->cnfa->post);
ss->flags = STARTER|LOCKED|NOPROGRESS;
ss->flags = STARTER | LOCKED | NOPROGRESS;
/* lastseen dealt with below */
}
@ -396,27 +425,28 @@ initialize(struct vars *v, /* used only for debug flags */
/*
* miss - handle a cache miss
*/
static struct sset * /* NULL if goes to empty set */
miss(struct vars *v, /* used only for debug flags */
struct dfa *d,
struct sset *css,
static struct sset * /* NULL if goes to empty set */
miss(struct vars * v, /* used only for debug flags */
struct dfa * d,
struct sset * css,
pcolor co,
chr *cp, /* next chr */
chr *start) /* where the attempt got started */
chr * cp, /* next chr */
chr * start) /* where the attempt got started */
{
struct cnfa *cnfa = d->cnfa;
int i;
unsigned h;
int i;
unsigned h;
struct carc *ca;
struct sset *p;
int ispost;
int noprogress;
int gotstate;
int dolacons;
int sawlacons;
int ispost;
int noprogress;
int gotstate;
int dolacons;
int sawlacons;
/* for convenience, we can be called even if it might not be a miss */
if (css->outs[co] != NULL) {
if (css->outs[co] != NULL)
{
FDEBUG(("hit\n"));
return css->outs[co];
}
@ -430,8 +460,9 @@ miss(struct vars *v, /* used only for debug flags */
gotstate = 0;
for (i = 0; i < d->nstates; i++)
if (ISBSET(css->states, i))
for (ca = cnfa->states[i]+1; ca->co != COLORLESS; ca++)
if (ca->co == co) {
for (ca = cnfa->states[i] + 1; ca->co != COLORLESS; ca++)
if (ca->co == co)
{
BSET(d->work, ca->to);
gotstate = 1;
if (ca->to == cnfa->post)
@ -440,21 +471,23 @@ miss(struct vars *v, /* used only for debug flags */
noprogress = 0;
FDEBUG(("%d -> %d\n", i, ca->to));
}
dolacons = (gotstate) ? (cnfa->flags&HASLACONS) : 0;
dolacons = (gotstate) ? (cnfa->flags & HASLACONS) : 0;
sawlacons = 0;
while (dolacons) { /* transitive closure */
while (dolacons)
{ /* transitive closure */
dolacons = 0;
for (i = 0; i < d->nstates; i++)
if (ISBSET(d->work, i))
for (ca = cnfa->states[i]+1; ca->co != COLORLESS;
ca++) {
for (ca = cnfa->states[i] + 1; ca->co != COLORLESS;
ca++)
{
if (ca->co <= cnfa->ncolors)
continue; /* NOTE CONTINUE */
continue; /* NOTE CONTINUE */
sawlacons = 1;
if (ISBSET(d->work, ca->to))
continue; /* NOTE CONTINUE */
continue; /* NOTE CONTINUE */
if (!lacon(v, cnfa, cp, ca->co))
continue; /* NOTE CONTINUE */
continue; /* NOTE CONTINUE */
BSET(d->work, ca->to);
dolacons = 1;
if (ca->to == cnfa->post)
@ -470,11 +503,13 @@ miss(struct vars *v, /* used only for debug flags */
/* next, is that in the cache? */
for (p = d->ssets, i = d->nssused; i > 0; p++, i--)
if (HIT(h, d->work, p, d->wordsper)) {
if (HIT(h, d->work, p, d->wordsper))
{
FDEBUG(("cached c%d\n", p - d->ssets));
break; /* NOTE BREAK OUT */
break; /* NOTE BREAK OUT */
}
if (i == 0) { /* nope, need a new cache entry */
if (i == 0)
{ /* nope, need a new cache entry */
p = getvacant(v, d, cp, start);
assert(p != css);
for (i = 0; i < d->wordsper; i++)
@ -486,12 +521,13 @@ miss(struct vars *v, /* used only for debug flags */
/* lastseen to be dealt with by caller */
}
if (!sawlacons) { /* lookahead conds. always cache miss */
if (!sawlacons)
{ /* lookahead conds. always cache miss */
FDEBUG(("c%d[%d]->c%d\n", css - d->ssets, co, p - d->ssets));
css->outs[co] = p;
css->inchain[co] = p->ins;
p->ins.ss = css;
p->ins.co = (color)co;
p->ins.co = (color) co;
}
return p;
}
@ -499,28 +535,29 @@ miss(struct vars *v, /* used only for debug flags */
/*
* lacon - lookahead-constraint checker for miss()
*/
static int /* predicate: constraint satisfied? */
lacon(struct vars *v,
struct cnfa *pcnfa, /* parent cnfa */
chr *cp,
pcolor co) /* "color" of the lookahead constraint */
static int /* predicate: constraint satisfied? */
lacon(struct vars * v,
struct cnfa * pcnfa, /* parent cnfa */
chr * cp,
pcolor co) /* "color" of the lookahead constraint */
{
int n;
int n;
struct subre *sub;
struct dfa *d;
struct smalldfa sd;
chr *end;
chr *end;
n = co - pcnfa->ncolors;
assert(n < v->g->nlacons && v->g->lacons != NULL);
FDEBUG(("=== testing lacon %d\n", n));
sub = &v->g->lacons[n];
d = newdfa(v, &sub->cnfa, &v->g->cmap, &sd);
if (d == NULL) {
if (d == NULL)
{
ERR(REG_ESPACE);
return 0;
}
end = longest(v, d, cp, v->stop, (int *)NULL);
end = longest(v, d, cp, v->stop, (int *) NULL);
freedfa(d);
FDEBUG(("=== lacon %d match %d\n", n, (end != NULL)));
return (sub->subno) ? (end != NULL) : (end == NULL);
@ -532,46 +569,49 @@ lacon(struct vars *v,
* clear the innards of the state set -- that's up to the caller.
*/
static struct sset *
getvacant(struct vars *v, /* used only for debug flags */
struct dfa *d,
chr *cp,
chr *start)
getvacant(struct vars * v, /* used only for debug flags */
struct dfa * d,
chr * cp,
chr * start)
{
int i;
int i;
struct sset *ss;
struct sset *p;
struct arcp ap;
struct arcp lastap;
color co;
color co;
ss = pickss(v, d, cp, start);
assert(!(ss->flags&LOCKED));
assert(!(ss->flags & LOCKED));
/* clear out its inarcs, including self-referential ones */
ap = ss->ins;
while ((p = ap.ss) != NULL) {
while ((p = ap.ss) != NULL)
{
co = ap.co;
FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long)co));
FDEBUG(("zapping c%d's %ld outarc\n", p - d->ssets, (long) co));
p->outs[co] = NULL;
ap = p->inchain[co];
p->inchain[co].ss = NULL; /* paranoia */
p->inchain[co].ss = NULL; /* paranoia */
}
ss->ins.ss = NULL;
/* take it off the inarc chains of the ssets reached by its outarcs */
for (i = 0; i < d->ncolors; i++) {
for (i = 0; i < d->ncolors; i++)
{
p = ss->outs[i];
assert(p != ss); /* not self-referential */
if (p == NULL)
continue; /* NOTE CONTINUE */
continue; /* NOTE CONTINUE */
FDEBUG(("del outarc %d from c%d's in chn\n", i, p - d->ssets));
if (p->ins.ss == ss && p->ins.co == i)
p->ins = ss->inchain[i];
else {
else
{
assert(p->ins.ss != NULL);
for (ap = p->ins; ap.ss != NULL &&
!(ap.ss == ss && ap.co == i);
ap = ap.ss->inchain[ap.co])
!(ap.ss == ss && ap.co == i);
ap = ap.ss->inchain[ap.co])
lastap = ap;
assert(ap.ss != NULL);
lastap.ss->inchain[lastap.co] = ss->inchain[i];
@ -581,13 +621,13 @@ getvacant(struct vars *v, /* used only for debug flags */
}
/* if ss was a success state, may need to remember location */
if ((ss->flags&POSTSTATE) && ss->lastseen != d->lastpost &&
(d->lastpost == NULL || d->lastpost < ss->lastseen))
if ((ss->flags & POSTSTATE) && ss->lastseen != d->lastpost &&
(d->lastpost == NULL || d->lastpost < ss->lastseen))
d->lastpost = ss->lastseen;
/* likewise for a no-progress state */
if ((ss->flags&NOPROGRESS) && ss->lastseen != d->lastnopr &&
(d->lastnopr == NULL || d->lastnopr < ss->lastseen))
if ((ss->flags & NOPROGRESS) && ss->lastseen != d->lastnopr &&
(d->lastnopr == NULL || d->lastnopr < ss->lastseen))
d->lastnopr = ss->lastseen;
return ss;
@ -597,18 +637,19 @@ getvacant(struct vars *v, /* used only for debug flags */
* pickss - pick the next stateset to be used
*/
static struct sset *
pickss(struct vars *v, /* used only for debug flags */
struct dfa *d,
chr *cp,
chr *start)
pickss(struct vars * v, /* used only for debug flags */
struct dfa * d,
chr * cp,
chr * start)
{
int i;
int i;
struct sset *ss;
struct sset *end;
chr *ancient;
chr *ancient;
/* shortcut for cases where cache isn't full */
if (d->nssused < d->nssets) {
if (d->nssused < d->nssets)
{
i = d->nssused;
d->nssused++;
ss = &d->ssets[i];
@ -620,7 +661,8 @@ pickss(struct vars *v, /* used only for debug flags */
ss->ins.co = WHITE; /* give it some value */
ss->outs = &d->outsarea[i * d->ncolors];
ss->inchain = &d->incarea[i * d->ncolors];
for (i = 0; i < d->ncolors; i++) {
for (i = 0; i < d->ncolors; i++)
{
ss->outs[i] = NULL;
ss->inchain[i].ss = NULL;
}
@ -628,20 +670,22 @@ pickss(struct vars *v, /* used only for debug flags */
}
/* look for oldest, or old enough anyway */
if (cp - start > d->nssets*2/3) /* oldest 33% are expendable */
ancient = cp - d->nssets*2/3;
if (cp - start > d->nssets * 2 / 3) /* oldest 33% are expendable */
ancient = cp - d->nssets * 2 / 3;
else
ancient = start;
for (ss = d->search, end = &d->ssets[d->nssets]; ss < end; ss++)
if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
!(ss->flags&LOCKED)) {
!(ss->flags & LOCKED))
{
d->search = ss + 1;
FDEBUG(("replacing c%d\n", ss - d->ssets));
return ss;
}
for (ss = d->ssets, end = d->search; ss < end; ss++)
if ((ss->lastseen == NULL || ss->lastseen < ancient) &&
!(ss->flags&LOCKED)) {
!(ss->flags & LOCKED))
{
d->search = ss + 1;
FDEBUG(("replacing c%d\n", ss - d->ssets));
return ss;

118
src/backend/regex/regerror.c
View File

@ -1,21 +1,21 @@
/*
* regerror - error-code expansion
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Development of this software was funded, in part, by Cray Research Inc.,
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
* Corporation, none of whom are responsible for the results. The author
* thanks all of them.
*
* thanks all of them.
*
* Redistribution and use in source and binary forms -- with or without
* modification -- are permitted for any purpose, provided that
* redistributions in source form retain this entire copyright notice and
* indicate the origin and nature of any modifications.
*
*
* I'd appreciate being given credit for this package in the documentation
* of software which uses it, but that is not a requirement.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -27,7 +27,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regerror.c,v 1.25 2003/02/05 17:41:33 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regerror.c,v 1.26 2003/08/04 00:43:21 momjian Exp $
*
*/
@ -37,72 +37,82 @@
static char unk[] = "*** unknown regex error code 0x%x ***";
/* struct to map among codes, code names, and explanations */
static struct rerr {
int code;
char *name;
char *explain;
} rerrs[] = {
static struct rerr
{
int code;
char *name;
char *explain;
} rerrs[] =
{
/* the actual table is built from regex.h */
#include "regex/regerrs.h"
{ -1, "", "oops" }, /* explanation special-cased in code */
{
-1, "", "oops"
}, /* explanation special-cased in code */
};
/*
* pg_regerror - the interface to error numbers
*/
/* ARGSUSED */
size_t /* actual space needed (including NUL) */
size_t /* actual space needed (including NUL) */
pg_regerror(int errcode, /* error code, or REG_ATOI or REG_ITOA */
const regex_t *preg, /* associated regex_t (unused at present) */
const regex_t *preg, /* associated regex_t (unused at present) */
char *errbuf, /* result buffer (unless errbuf_size==0) */
size_t errbuf_size) /* available space in errbuf, can be 0 */
size_t errbuf_size) /* available space in errbuf, can be 0 */
{
struct rerr *r;
char *msg;
char convbuf[sizeof(unk)+50]; /* 50 = plenty for int */
size_t len;
int icode;
char *msg;
char convbuf[sizeof(unk) + 50]; /* 50 = plenty for int */
size_t len;
int icode;
switch (errcode) {
case REG_ATOI: /* convert name to number */
for (r = rerrs; r->code >= 0; r++)
if (strcmp(r->name, errbuf) == 0)
break;
sprintf(convbuf, "%d", r->code); /* -1 for unknown */
msg = convbuf;
break;
case REG_ITOA: /* convert number to name */
icode = atoi(errbuf); /* not our problem if this fails */
for (r = rerrs; r->code >= 0; r++)
if (r->code == icode)
break;
if (r->code >= 0)
msg = r->name;
else { /* unknown; tell him the number */
sprintf(convbuf, "REG_%u", (unsigned)icode);
switch (errcode)
{
case REG_ATOI: /* convert name to number */
for (r = rerrs; r->code >= 0; r++)
if (strcmp(r->name, errbuf) == 0)
break;
sprintf(convbuf, "%d", r->code); /* -1 for unknown */
msg = convbuf;
}
break;
default: /* a real, normal error code */
for (r = rerrs; r->code >= 0; r++)
if (r->code == errcode)
break;
if (r->code >= 0)
msg = r->explain;
else { /* unknown; say so */
sprintf(convbuf, unk, errcode);
msg = convbuf;
}
break;
break;
case REG_ITOA: /* convert number to name */
icode = atoi(errbuf); /* not our problem if this fails */
for (r = rerrs; r->code >= 0; r++)
if (r->code == icode)
break;
if (r->code >= 0)
msg = r->name;
else
{ /* unknown; tell him the number */
sprintf(convbuf, "REG_%u", (unsigned) icode);
msg = convbuf;
}
break;
default: /* a real, normal error code */
for (r = rerrs; r->code >= 0; r++)
if (r->code == errcode)
break;
if (r->code >= 0)
msg = r->explain;
else
{ /* unknown; say so */
sprintf(convbuf, unk, errcode);
msg = convbuf;
}
break;
}
len = strlen(msg) + 1; /* space needed, including NUL */
if (errbuf_size > 0) {
if (errbuf_size > 0)
{
if (errbuf_size > len)
strcpy(errbuf, msg);
else { /* truncate to fit */
strncpy(errbuf, msg, errbuf_size-1);
errbuf[errbuf_size-1] = '\0';
else
{ /* truncate to fit */
strncpy(errbuf, msg, errbuf_size - 1);
errbuf[errbuf_size - 1] = '\0';
}
}

776
src/backend/regex/regexec.c
View File

File diff suppressed because it is too large Load Diff

16
src/backend/regex/regfree.c
View File

@ -1,21 +1,21 @@
/*
* regfree - free an RE
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Copyright (c) 1998, 1999 Henry Spencer. All rights reserved.
*
* Development of this software was funded, in part, by Cray Research Inc.,
* UUNET Communications Services Inc., Sun Microsystems Inc., and Scriptics
* Corporation, none of whom are responsible for the results. The author
* thanks all of them.
*
* thanks all of them.
*
* Redistribution and use in source and binary forms -- with or without
* modification -- are permitted for any purpose, provided that
* redistributions in source form retain this entire copyright notice and
* indicate the origin and nature of any modifications.
*
*
* I'd appreciate being given credit for this package in the documentation
* of software which uses it, but that is not a requirement.
*
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
@ -27,7 +27,7 @@
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* $Header: /cvsroot/pgsql/src/backend/regex/regfree.c,v 1.16 2003/02/05 17:41:33 tgl Exp $
* $Header: /cvsroot/pgsql/src/backend/regex/regfree.c,v 1.17 2003/08/04 00:43:21 momjian Exp $
*
*
* You might think that this could be incorporated into regcomp.c, and
@ -50,5 +50,5 @@ pg_regfree(regex_t *re)
{
if (re == NULL)
return;
(*((struct fns *)re->re_fns)->free)(re);
(*((struct fns *) re->re_fns)->free) (re);
}