mirror of
https://github.com/postgres/postgres.git
synced 2025-07-02 09:02:37 +03:00
Renaming cleanup, no pgindent yet.
This commit is contained in:
Bruce Momjian
@ -94,7 +94,7 @@ extern "C"
|
||||
/* === engine.c === */
|
||||
static int
|
||||
matcher(struct re_guts * g, pg_wchar *string, size_t nmatch,
|
||||
regmatch_t pmatch[], int eflags);
|
||||
regmatch_t *pmatch, int eflags);
|
||||
static pg_wchar *
|
||||
dissect(struct match * m, pg_wchar *start, pg_wchar *stop,
|
||||
sopno startst, sopno stopst);
|
||||
@ -158,14 +158,14 @@ extern "C"
|
||||
/*
|
||||
- matcher - the actual matching engine
|
||||
== static int matcher(struct re_guts *g, pg_wchar *string, \
|
||||
== size_t nmatch, regmatch_t pmatch[], int eflags);
|
||||
== size_t nmatch, regmatch_t *pmatch, int eflags);
|
||||
*/
|
||||
static int /* 0 success, REG_NOMATCH failure */
|
||||
matcher(g, string, nmatch, pmatch, eflags)
|
||||
struct re_guts *g;
|
||||
pg_wchar *string;
|
||||
size_t nmatch;
|
||||
regmatch_t pmatch[];
|
||||
regmatch_t *pmatch;
|
||||
int eflags;
|
||||
{
|
||||
pg_wchar *endp;
|
||||
@ -196,7 +196,7 @@ int eflags;
|
||||
#endif
|
||||
}
|
||||
if (stop < start)
|
||||
return (REG_INVARG);
|
||||
return REG_INVARG;
|
||||
|
||||
/* prescreening; this does wonders for this rather slow code */
|
||||
if (g->must != NULL)
|
||||
@ -210,7 +210,7 @@ int eflags;
|
||||
#endif
|
||||
break;
|
||||
if (dp == stop) /* we didn't find g->must */
|
||||
return (REG_NOMATCH);
|
||||
return REG_NOMATCH;
|
||||
}
|
||||
|
||||
/* match struct setup */
|
||||
@ -235,7 +235,7 @@ int eflags;
|
||||
if (endp == NULL)
|
||||
{ /* a miss */
|
||||
STATETEARDOWN(m);
|
||||
return (REG_NOMATCH);
|
||||
return REG_NOMATCH;
|
||||
}
|
||||
if (nmatch == 0 && !g->backrefs)
|
||||
break; /* no further info needed */
|
||||
@ -261,7 +261,7 @@ int eflags;
|
||||
if (m->pmatch == NULL)
|
||||
{
|
||||
STATETEARDOWN(m);
|
||||
return (REG_ESPACE);
|
||||
return REG_ESPACE;
|
||||
}
|
||||
for (i = 1; i <= m->g->nsub; i++)
|
||||
m->pmatch[i].rm_so = m->pmatch[i].rm_eo = -1;
|
||||
@ -279,7 +279,7 @@ int eflags;
|
||||
{
|
||||
free(m->pmatch);
|
||||
STATETEARDOWN(m);
|
||||
return (REG_ESPACE);
|
||||
return REG_ESPACE;
|
||||
}
|
||||
NOTE("backref dissect");
|
||||
dp = backref(m, m->coldp, endp, gf, gl, (sopno) 0);
|
||||
@ -343,7 +343,7 @@ int eflags;
|
||||
if (m->lastpos != NULL)
|
||||
free((pg_wchar *) m->lastpos);
|
||||
STATETEARDOWN(m);
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -543,7 +543,7 @@ sopno stopst;
|
||||
}
|
||||
|
||||
assert(sp == stop);
|
||||
return (sp);
|
||||
return sp;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -583,17 +583,17 @@ sopno lev; /* PLUS nesting level */
|
||||
{
|
||||
case OCHAR:
|
||||
if (sp == stop || *sp++ != (pg_wchar) OPND(s))
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case OANY:
|
||||
if (sp == stop)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
sp++;
|
||||
break;
|
||||
case OANYOF:
|
||||
cs = &m->g->sets[OPND(s)];
|
||||
if (sp == stop || !CHIN(cs, *sp++))
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case OBOL:
|
||||
if ((sp == m->beginp && !(m->eflags & REG_NOTBOL)) ||
|
||||
@ -602,7 +602,7 @@ sopno lev; /* PLUS nesting level */
|
||||
{ /* yes */
|
||||
}
|
||||
else
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case OEOL:
|
||||
if ((sp == m->endp && !(m->eflags & REG_NOTEOL)) ||
|
||||
@ -611,7 +611,7 @@ sopno lev; /* PLUS nesting level */
|
||||
{ /* yes */
|
||||
}
|
||||
else
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case OBOW:
|
||||
if (((sp == m->beginp && !(m->eflags & REG_NOTBOL)) ||
|
||||
@ -623,7 +623,7 @@ sopno lev; /* PLUS nesting level */
|
||||
{ /* yes */
|
||||
}
|
||||
else
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case OEOW:
|
||||
if (((sp == m->endp && !(m->eflags & REG_NOTEOL)) ||
|
||||
@ -634,7 +634,7 @@ sopno lev; /* PLUS nesting level */
|
||||
{ /* yes */
|
||||
}
|
||||
else
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case O_QUEST:
|
||||
break;
|
||||
@ -655,8 +655,8 @@ sopno lev; /* PLUS nesting level */
|
||||
if (!hard)
|
||||
{ /* that was it! */
|
||||
if (sp != stop)
|
||||
return (NULL);
|
||||
return (sp);
|
||||
return NULL;
|
||||
return sp;
|
||||
}
|
||||
ss--; /* adjust for the for's final increment */
|
||||
|
||||
@ -669,41 +669,41 @@ sopno lev; /* PLUS nesting level */
|
||||
i = OPND(s);
|
||||
assert(0 < i && i <= m->g->nsub);
|
||||
if (m->pmatch[i].rm_eo == -1)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
assert(m->pmatch[i].rm_so != -1);
|
||||
len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
|
||||
assert(stop - m->beginp >= len);
|
||||
if (sp > stop - len)
|
||||
return (NULL); /* not enough left to match */
|
||||
return NULL; /* not enough left to match */
|
||||
ssp = m->offp + m->pmatch[i].rm_so;
|
||||
if (memcmp(sp, ssp, len) != 0)
|
||||
return (NULL);
|
||||
return NULL;
|
||||
while (m->g->strip[ss] != SOP(O_BACK, i))
|
||||
ss++;
|
||||
return (backref(m, sp + len, stop, ss + 1, stopst, lev));
|
||||
return backref(m, sp + len, stop, ss + 1, stopst, lev);
|
||||
break;
|
||||
case OQUEST_: /* to null or not */
|
||||
dp = backref(m, sp, stop, ss + 1, stopst, lev);
|
||||
if (dp != NULL)
|
||||
return (dp); /* not */
|
||||
return (backref(m, sp, stop, ss + OPND(s) + 1, stopst, lev));
|
||||
return dp; /* not */
|
||||
return backref(m, sp, stop, ss + OPND(s) + 1, stopst, lev);
|
||||
break;
|
||||
case OPLUS_:
|
||||
assert(m->lastpos != NULL);
|
||||
assert(lev + 1 <= m->g->nplus);
|
||||
m->lastpos[lev + 1] = sp;
|
||||
return (backref(m, sp, stop, ss + 1, stopst, lev + 1));
|
||||
return backref(m, sp, stop, ss + 1, stopst, lev + 1);
|
||||
break;
|
||||
case O_PLUS:
|
||||
if (sp == m->lastpos[lev]) /* last pass matched null */
|
||||
return (backref(m, sp, stop, ss + 1, stopst, lev - 1));
|
||||
return backref(m, sp, stop, ss + 1, stopst, lev - 1);
|
||||
/* try another pass */
|
||||
m->lastpos[lev] = sp;
|
||||
dp = backref(m, sp, stop, ss - OPND(s) + 1, stopst, lev);
|
||||
if (dp == NULL)
|
||||
return (backref(m, sp, stop, ss + 1, stopst, lev - 1));
|
||||
return backref(m, sp, stop, ss + 1, stopst, lev - 1);
|
||||
else
|
||||
return (dp);
|
||||
return dp;
|
||||
break;
|
||||
case OCH_: /* find the right one, if any */
|
||||
ssub = ss + 1;
|
||||
@ -713,10 +713,10 @@ sopno lev; /* PLUS nesting level */
|
||||
{ /* find first matching branch */
|
||||
dp = backref(m, sp, stop, ssub, esub, lev);
|
||||
if (dp != NULL)
|
||||
return (dp);
|
||||
return dp;
|
||||
/* that one missed, try next one */
|
||||
if (OP(m->g->strip[esub]) == O_CH)
|
||||
return (NULL); /* there is none */
|
||||
return NULL; /* there is none */
|
||||
esub++;
|
||||
assert(OP(m->g->strip[esub]) == OOR2);
|
||||
ssub = esub + 1;
|
||||
@ -734,9 +734,9 @@ sopno lev; /* PLUS nesting level */
|
||||
m->pmatch[i].rm_so = sp - m->offp;
|
||||
dp = backref(m, sp, stop, ss + 1, stopst, lev);
|
||||
if (dp != NULL)
|
||||
return (dp);
|
||||
return dp;
|
||||
m->pmatch[i].rm_so = offsave;
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
case ORPAREN: /* must undo assignment if rest fails */
|
||||
i = OPND(s);
|
||||
@ -745,9 +745,9 @@ sopno lev; /* PLUS nesting level */
|
||||
m->pmatch[i].rm_eo = sp - m->offp;
|
||||
dp = backref(m, sp, stop, ss + 1, stopst, lev);
|
||||
if (dp != NULL)
|
||||
return (dp);
|
||||
return dp;
|
||||
m->pmatch[i].rm_eo = offsave;
|
||||
return (NULL);
|
||||
return NULL;
|
||||
break;
|
||||
default: /* uh oh */
|
||||
assert(nope);
|
||||
@ -850,9 +850,9 @@ sopno stopst;
|
||||
assert(coldp != NULL);
|
||||
m->coldp = coldp;
|
||||
if (ISSET(st, stopst))
|
||||
return (p + 1);
|
||||
return p + 1;
|
||||
else
|
||||
return (NULL);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -941,7 +941,7 @@ sopno stopst;
|
||||
p++;
|
||||
}
|
||||
|
||||
return (matchp);
|
||||
return matchp;
|
||||
}
|
||||
|
||||
|
||||
@ -1075,7 +1075,7 @@ states aft; /* states already known reachable after */
|
||||
}
|
||||
}
|
||||
|
||||
return (aft);
|
||||
return aft;
|
||||
}
|
||||
|
||||
#ifdef REDEBUG
|
||||
@ -1171,7 +1171,7 @@ int ch;
|
||||
sprintf(pbuf, "%c", ch);
|
||||
else
|
||||
sprintf(pbuf, "\\%o", ch);
|
||||
return (pbuf);
|
||||
return pbuf;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -206,18 +206,18 @@ int cflags;
|
||||
|
||||
cflags = GOODFLAGS(cflags);
|
||||
if ((cflags & REG_EXTENDED) && (cflags & REG_NOSPEC))
|
||||
return (REG_INVARG);
|
||||
return REG_INVARG;
|
||||
|
||||
if (cflags & REG_PEND)
|
||||
{
|
||||
#ifdef MULTIBYTE
|
||||
wcp = preg->patsave;
|
||||
if (preg->re_endp < wcp)
|
||||
return (REG_INVARG);
|
||||
return REG_INVARG;
|
||||
len = preg->re_endp - wcp;
|
||||
#else
|
||||
if (preg->re_endp < pattern)
|
||||
return (REG_INVARG);
|
||||
return REG_INVARG;
|
||||
len = preg->re_endp - pattern;
|
||||
#endif
|
||||
}
|
||||
@ -225,7 +225,7 @@ int cflags;
|
||||
#ifdef MULTIBYTE
|
||||
wcp = (pg_wchar *)malloc((strlen(pattern)+1) * sizeof(pg_wchar));
|
||||
if (wcp == NULL) {
|
||||
return (REG_ESPACE);
|
||||
return REG_ESPACE;
|
||||
}
|
||||
preg->patsave = wcp;
|
||||
(void)pg_mb2wchar((unsigned char *)pattern,wcp);
|
||||
@ -240,7 +240,7 @@ int cflags;
|
||||
g = (struct re_guts *) malloc(sizeof(struct re_guts) +
|
||||
(NC - 1) * sizeof(cat_t));
|
||||
if (g == NULL)
|
||||
return (REG_ESPACE);
|
||||
return REG_ESPACE;
|
||||
p->ssize = len / (size_t) 2 *(size_t) 3 + (size_t) 1; /* ugh */
|
||||
|
||||
p->strip = (sop *) malloc(p->ssize * sizeof(sop));
|
||||
@ -248,7 +248,7 @@ int cflags;
|
||||
if (p->strip == NULL)
|
||||
{
|
||||
free((char *) g);
|
||||
return (REG_ESPACE);
|
||||
return REG_ESPACE;
|
||||
}
|
||||
|
||||
/* set things up */
|
||||
@ -312,7 +312,7 @@ int cflags;
|
||||
/* win or lose, we're done */
|
||||
if (p->error != 0) /* lose */
|
||||
pg95_regfree(preg);
|
||||
return (p->error);
|
||||
return p->error;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -716,9 +716,9 @@ int starordinary; /* is a leading * an ordinary character? */
|
||||
}
|
||||
}
|
||||
else if (c == (unsigned char) '$') /* $ (but not \$) ends it */
|
||||
return (1);
|
||||
return 1;
|
||||
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -739,7 +739,7 @@ struct parse *p;
|
||||
}
|
||||
|
||||
REQUIRE(ndigits > 0 && count <= DUPMAX, REG_BADBR);
|
||||
return (count);
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -982,12 +982,12 @@ struct parse *p;
|
||||
|
||||
REQUIRE(MORE(), REG_EBRACK);
|
||||
if (!EATTWO('[', '.'))
|
||||
return (GETNEXT());
|
||||
return GETNEXT();
|
||||
|
||||
/* collating symbol */
|
||||
value = p_b_coll_elem(p, '.');
|
||||
REQUIRE(EATTWO('.', ']'), REG_ECOLLATE);
|
||||
return (value);
|
||||
return value;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1008,7 +1008,7 @@ int endc; /* name ended by endc,']' */
|
||||
if (!MORE())
|
||||
{
|
||||
SETERROR(REG_EBRACK);
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
len = p->next - sp;
|
||||
for (cp = cnames; cp->name != NULL; cp++)
|
||||
@ -1017,11 +1017,11 @@ int endc; /* name ended by endc,']' */
|
||||
#else
|
||||
if (strncmp(cp->name, sp, len) == 0 && cp->name[len] == '\0')
|
||||
#endif
|
||||
return (cp->code); /* known name */
|
||||
return cp->code; /* known name */
|
||||
if (len == 1)
|
||||
return (*sp); /* single character */
|
||||
return *sp; /* single character */
|
||||
SETERROR(REG_ECOLLATE); /* neither */
|
||||
return (0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1034,12 +1034,12 @@ int ch;
|
||||
{
|
||||
assert(pg_isalpha(ch));
|
||||
if (pg_isupper(ch))
|
||||
return (tolower(ch));
|
||||
return tolower(ch);
|
||||
else if (pg_islower(ch))
|
||||
return (toupper(ch));
|
||||
return toupper(ch);
|
||||
else
|
||||
/* peculiar, but could happen */
|
||||
return (ch);
|
||||
return ch;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1208,7 +1208,7 @@ int e;
|
||||
p->error = e;
|
||||
p->next = nuls; /* try to bring things to a halt */
|
||||
p->end = nuls;
|
||||
return (0); /* make the return value well-defined */
|
||||
return 0; /* make the return value well-defined */
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1266,7 +1266,7 @@ struct parse *p;
|
||||
cs->smultis = 0;
|
||||
cs->multis = NULL;
|
||||
|
||||
return (cs);
|
||||
return cs;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1327,7 +1327,7 @@ cset *cs;
|
||||
cs = cs2;
|
||||
}
|
||||
|
||||
return ((int) (cs - p->g->sets));
|
||||
return (int) (cs - p->g->sets);
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1344,9 +1344,9 @@ cset *cs;
|
||||
|
||||
for (i = 0; i < css; i++)
|
||||
if (CHIN(cs, i))
|
||||
return (i);
|
||||
return i;
|
||||
assert(never);
|
||||
return (0); /* arbitrary */
|
||||
return 0; /* arbitrary */
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1365,7 +1365,7 @@ cset *cs;
|
||||
for (i = 0; i < css; i++)
|
||||
if (CHIN(cs, i))
|
||||
n++;
|
||||
return (n);
|
||||
return n;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1505,8 +1505,8 @@ int c;
|
||||
|
||||
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
|
||||
if (col[uc] != 0)
|
||||
return (1);
|
||||
return (0);
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1527,8 +1527,8 @@ int c2;
|
||||
|
||||
for (i = 0, col = g->setbits; i < ncols; i++, col += g->csetsize)
|
||||
if (col[uc1] != col[uc2])
|
||||
return (0);
|
||||
return (1);
|
||||
return 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1575,13 +1575,13 @@ sopno finish; /* to this less one */
|
||||
|
||||
assert(finish >= start);
|
||||
if (len == 0)
|
||||
return (ret);
|
||||
return ret;
|
||||
enlarge(p, p->ssize + len); /* this many unexpected additions */
|
||||
assert(p->ssize >= p->slen + len);
|
||||
memcpy((char *) (p->strip + p->slen),
|
||||
(char *) (p->strip + start), (size_t) len * sizeof(sop));
|
||||
p->slen += len;
|
||||
return (ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1826,7 +1826,7 @@ struct re_guts *g;
|
||||
sopno maxnest = 0;
|
||||
|
||||
if (p->error != 0)
|
||||
return (0); /* there may not be an OEND */
|
||||
return 0; /* there may not be an OEND */
|
||||
|
||||
scan = g->strip + 1;
|
||||
do
|
||||
@ -1846,7 +1846,7 @@ struct re_guts *g;
|
||||
} while (OP(s) != OEND);
|
||||
if (plusnest != 0)
|
||||
g->iflags |= BAD;
|
||||
return (maxnest);
|
||||
return maxnest;
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -200,7 +200,7 @@ size_t errbuf_size;
|
||||
}
|
||||
}
|
||||
|
||||
return (len);
|
||||
return len;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -222,8 +222,8 @@ char *localbuf;
|
||||
#endif
|
||||
break;
|
||||
if (r->code == 0)
|
||||
return ("0");
|
||||
return "0";
|
||||
|
||||
sprintf(localbuf, "%d", r->code);
|
||||
return (localbuf);
|
||||
return localbuf;
|
||||
}
|
||||
|
||||
@ -159,7 +159,7 @@ pg95_regexec(preg, string, nmatch, pmatch, eflags)
|
||||
const regex_t *preg;
|
||||
const char *string;
|
||||
size_t nmatch;
|
||||
regmatch_t pmatch[];
|
||||
regmatch_t *pmatch;
|
||||
int eflags;
|
||||
{
|
||||
struct re_guts *g = preg->re_g;
|
||||
@ -176,10 +176,10 @@ int eflags;
|
||||
#endif
|
||||
|
||||
if (preg->re_magic != MAGIC1 || g->magic != MAGIC2)
|
||||
return (REG_BADPAT);
|
||||
return REG_BADPAT;
|
||||
assert(!(g->iflags & BAD));
|
||||
if (g->iflags & BAD) /* backstop for no-debug case */
|
||||
return (REG_BADPAT);
|
||||
return REG_BADPAT;
|
||||
eflags = GOODFLAGS(eflags);
|
||||
|
||||
#ifdef MULTIBYTE
|
||||
@ -198,8 +198,8 @@ int eflags;
|
||||
# else
|
||||
|
||||
if (g->nstates <= CHAR_BIT * sizeof(states1) && !(eflags & REG_LARGE))
|
||||
return (smatcher(g, (pg_wchar *) string, nmatch, pmatch, eflags));
|
||||
return smatcher(g, (pg_wchar *) string, nmatch, pmatch, eflags);
|
||||
else
|
||||
return (lmatcher(g, (pg_wchar *) string, nmatch, pmatch, eflags));
|
||||
return lmatcher(g, (pg_wchar *) string, nmatch, pmatch, eflags);
|
||||
#endif
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user