mirror of https://github.com/postgres/postgres
Back-patch of commitsREL8_4_STABLE628cbb50baandc6aae3042b. This has been broken since 7.3, so back-patch to all supported branches.
Tom Lane
14 years ago
parent
b84da909d9
commit
b9edaa784e
@ -0,0 +1,256 @@ |
|||||||
|
/*-------------------------------------------------------------------------
|
||||||
|
* |
||||||
|
* regprefix.c |
||||||
|
* Extract a common prefix, if any, from a compiled regex. |
||||||
|
* |
||||||
|
* |
||||||
|
* Portions Copyright (c) 2012, PostgreSQL Global Development Group |
||||||
|
* Portions Copyright (c) 1998, 1999 Henry Spencer |
||||||
|
* |
||||||
|
* IDENTIFICATION |
||||||
|
* src/backend/regex/regprefix.c |
||||||
|
* |
||||||
|
*------------------------------------------------------------------------- |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "regex/regguts.h" |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* forward declarations |
||||||
|
*/ |
||||||
|
static int findprefix(struct cnfa * cnfa, struct colormap * cm, |
||||||
|
chr *string, size_t *slength); |
||||||
|
|
||||||
|
|
||||||
|
/*
|
||||||
|
* pg_regprefix - get common prefix for regular expression |
||||||
|
* |
||||||
|
* Returns one of: |
||||||
|
* REG_NOMATCH: there is no common prefix of strings matching the regex |
||||||
|
* REG_PREFIX: there is a common prefix of strings matching the regex |
||||||
|
* REG_EXACT: all strings satisfying the regex must match the same string |
||||||
|
* or a REG_XXX error code |
||||||
|
* |
||||||
|
* In the non-failure cases, *string is set to a malloc'd string containing |
||||||
|
* the common prefix or exact value, of length *slength (measured in chrs |
||||||
|
* not bytes!). |
||||||
|
* |
||||||
|
* This function does not analyze all complex cases (such as lookahead |
||||||
|
* constraints) exactly. Therefore it is possible that some strings matching |
||||||
|
* the reported prefix or exact-match string do not satisfy the regex. But |
||||||
|
* it should never be the case that a string satisfying the regex does not |
||||||
|
* match the reported prefix or exact-match string. |
||||||
|
*/ |
||||||
|
int |
||||||
|
pg_regprefix(regex_t *re, |
||||||
|
chr **string, |
||||||
|
size_t *slength) |
||||||
|
{ |
||||||
|
struct guts *g; |
||||||
|
struct cnfa *cnfa; |
||||||
|
int st; |
||||||
|
|
||||||
|
/* sanity checks */ |
||||||
|
if (string == NULL || slength == NULL) |
||||||
|
return REG_INVARG; |
||||||
|
*string = NULL; /* initialize for failure cases */ |
||||||
|
*slength = 0; |
||||||
|
if (re == NULL || re->re_magic != REMAGIC) |
||||||
|
return REG_INVARG; |
||||||
|
if (re->re_csize != sizeof(chr)) |
||||||
|
return REG_MIXED; |
||||||
|
|
||||||
|
/* setup */ |
||||||
|
g = (struct guts *) re->re_guts; |
||||||
|
if (g->info & REG_UIMPOSSIBLE) |
||||||
|
return REG_NOMATCH; |
||||||
|
|
||||||
|
/*
|
||||||
|
* This implementation considers only the search NFA for the topmost regex |
||||||
|
* tree node. Therefore, constraints such as backrefs are not fully |
||||||
|
* applied, which is allowed per the function's API spec. |
||||||
|
*/ |
||||||
|
assert(g->tree != NULL); |
||||||
|
cnfa = &g->tree->cnfa; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Since a correct NFA should never contain any exit-free loops, it should |
||||||
|
* not be possible for our traversal to return to a previously visited |
||||||
|
* NFA state. Hence we need at most nstates chrs in the output string. |
||||||
|
*/ |
||||||
|
*string = (chr *) MALLOC(cnfa->nstates * sizeof(chr)); |
||||||
|
if (*string == NULL) |
||||||
|
return REG_ESPACE; |
||||||
|
|
||||||
|
/* do it */ |
||||||
|
st = findprefix(cnfa, &g->cmap, *string, slength); |
||||||
|
|
||||||
|
assert(*slength <= cnfa->nstates); |
||||||
|
|
||||||
|
/* clean up */ |
||||||
|
if (st != REG_PREFIX && st != REG_EXACT) |
||||||
|
{ |
||||||
|
FREE(*string); |
||||||
|
*string = NULL; |
||||||
|
*slength = 0; |
||||||
|
} |
||||||
|
|
||||||
|
return st; |
||||||
|
} |
||||||
|
|
||||||
|
/*
|
||||||
|
* findprefix - extract common prefix from cNFA |
||||||
|
* |
||||||
|
* Results are returned into the preallocated chr array string[], with |
||||||
|
* *slength (which must be preset to zero) incremented for each chr. |
||||||
|
*/ |
||||||
|
static int /* regprefix return code */ |
||||||
|
findprefix(struct cnfa * cnfa, |
||||||
|
struct colormap * cm, |
||||||
|
chr *string, |
||||||
|
size_t *slength) |
||||||
|
{ |
||||||
|
int st; |
||||||
|
int nextst; |
||||||
|
color thiscolor; |
||||||
|
chr c; |
||||||
|
struct carc *ca; |
||||||
|
|
||||||
|
/*
|
||||||
|
* The "pre" state must have only BOS/BOL outarcs, else pattern isn't |
||||||
|
* anchored left. If we have both BOS and BOL, they must go to the |
||||||
|
* same next state. |
||||||
|
*/ |
||||||
|
st = cnfa->pre; |
||||||
|
nextst = -1; |
||||||
|
for (ca = cnfa->states[st]; ca->co != COLORLESS; ca++) |
||||||
|
{ |
||||||
|
if (ca->co == cnfa->bos[0] || ca->co == cnfa->bos[1]) |
||||||
|
{ |
||||||
|
if (nextst == -1) |
||||||
|
nextst = ca->to; |
||||||
|
else if (nextst != ca->to) |
||||||
|
return REG_NOMATCH; |
||||||
|
} |
||||||
|
else |
||||||
|
return REG_NOMATCH; |
||||||
|
} |
||||||
|
if (nextst == -1) |
||||||
|
return REG_NOMATCH; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Scan through successive states, stopping as soon as we find one with |
||||||
|
* more than one acceptable transition character (either multiple colors |
||||||
|
* on out-arcs, or a color with more than one member chr). |
||||||
|
* |
||||||
|
* We could find a state with multiple out-arcs that are all labeled with |
||||||
|
* the same singleton color; this comes from patterns like "^ab(cde|cxy)". |
||||||
|
* In that case we add the chr "c" to the output string but then exit the |
||||||
|
* loop with nextst == -1. This leaves a little bit on the table: if the |
||||||
|
* pattern is like "^ab(cde|cdy)", we won't notice that "d" could be added |
||||||
|
* to the prefix. But chasing multiple parallel state chains doesn't seem |
||||||
|
* worth the trouble. |
||||||
|
*/ |
||||||
|
do |
||||||
|
{ |
||||||
|
st = nextst; |
||||||
|
nextst = -1; |
||||||
|
thiscolor = COLORLESS; |
||||||
|
for (ca = cnfa->states[st]; ca->co != COLORLESS; ca++) |
||||||
|
{ |
||||||
|
/* We ignore lookahead constraints */ |
||||||
|
if (ca->co >= cnfa->ncolors) |
||||||
|
continue; |
||||||
|
/* We can also ignore BOS/BOL arcs */ |
||||||
|
if (ca->co == cnfa->bos[0] || ca->co == cnfa->bos[1]) |
||||||
|
continue; |
||||||
|
/* ... but EOS/EOL arcs terminate the search */ |
||||||
|
if (ca->co == cnfa->eos[0] || ca->co == cnfa->eos[1]) |
||||||
|
{ |
||||||
|
thiscolor = COLORLESS; |
||||||
|
break; |
||||||
|
} |
||||||
|
if (thiscolor == COLORLESS) |
||||||
|
{ |
||||||
|
/* First plain outarc */ |
||||||
|
thiscolor = ca->co; |
||||||
|
nextst = ca->to; |
||||||
|
} |
||||||
|
else if (thiscolor == ca->co) |
||||||
|
{ |
||||||
|
/* Another plain outarc for same color */ |
||||||
|
nextst = -1; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
/* More than one plain outarc color terminates the search */ |
||||||
|
thiscolor = COLORLESS; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
/* Done if we didn't find exactly one color on plain outarcs */ |
||||||
|
if (thiscolor == COLORLESS) |
||||||
|
break; |
||||||
|
/* The color must be a singleton */ |
||||||
|
if (cm->cd[thiscolor].nchrs != 1) |
||||||
|
break; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Identify the color's sole member chr and add it to the prefix |
||||||
|
* string. In general the colormap data structure doesn't provide a |
||||||
|
* way to find color member chrs, except by trying GETCOLOR() on each |
||||||
|
* possible chr value, which won't do at all. However, for the cases |
||||||
|
* we care about it should be sufficient to test the "firstchr" value, |
||||||
|
* that is the first chr ever added to the color. There are cases |
||||||
|
* where this might no longer be a member of the color (so we do need |
||||||
|
* to test), but none of them are likely to arise for a character that |
||||||
|
* is a member of a common prefix. If we do hit such a corner case, |
||||||
|
* we just fall out without adding anything to the prefix string. |
||||||
|
*/ |
||||||
|
c = cm->cd[thiscolor].firstchr; |
||||||
|
if (GETCOLOR(cm, c) != thiscolor) |
||||||
|
break; |
||||||
|
|
||||||
|
string[(*slength)++] = c; |
||||||
|
|
||||||
|
/* Advance to next state, but only if we have a unique next state */ |
||||||
|
} while (nextst != -1); |
||||||
|
|
||||||
|
/*
|
||||||
|
* If we ended at a state that only has EOS/EOL outarcs leading to the |
||||||
|
* "post" state, then we have an exact-match string. Note this is true |
||||||
|
* even if the string is of zero length. |
||||||
|
*/ |
||||||
|
nextst = -1; |
||||||
|
for (ca = cnfa->states[st]; ca->co != COLORLESS; ca++) |
||||||
|
{ |
||||||
|
if (ca->co == cnfa->eos[0] || ca->co == cnfa->eos[1]) |
||||||
|
{ |
||||||
|
if (nextst == -1) |
||||||
|
nextst = ca->to; |
||||||
|
else if (nextst != ca->to) |
||||||
|
{ |
||||||
|
nextst = -1; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
nextst = -1; |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
if (nextst == cnfa->post) |
||||||
|
return REG_EXACT; |
||||||
|
|
||||||
|
/*
|
||||||
|
* Otherwise, if we were unable to identify any prefix characters, say |
||||||
|
* NOMATCH --- the pattern is anchored left, but doesn't specify any |
||||||
|
* particular first character. |
||||||
|
*/ |
||||||
|
if (*slength > 0) |
||||||
|
return REG_PREFIX; |
||||||
|
|
||||||
|
return REG_NOMATCH; |
||||||
|
} |
||||||
Loading…
Reference in new issue