{
struct kwset *kwset;
register struct trie *trie;
- register unsigned char label;
- register struct tree *link;
- register int depth;
- struct tree *links[12];
- enum { L, R } dirs[12];
- struct tree *t, *r, *l, *rl, *lr;
kwset = (struct kwset *) kws;
trie = kwset->trie;
installing new nodes when necessary. */
while (len--)
{
+ register unsigned char label;
+ register struct tree *link;
+ register int depth;
+ struct tree *links[12];
+ enum { L, R } dirs[12];
+
label = kwset->trans ? kwset->trans[(unsigned char) *--text] : *--text;
/* Descend the tree of outgoing links for this trie node,
if (depth && ((dirs[depth] == L && --links[depth]->balance)
|| (dirs[depth] == R && ++links[depth]->balance)))
{
+ struct tree *t;
+
switch (links[depth]->balance)
{
+ struct tree *r, *l, *rl, *lr;
case (char) -2:
switch (dirs[depth + 1])
{
treefails (register struct tree const *tree, struct trie const *fail,
struct trie *recourse)
{
- register struct tree *link;
-
if (!tree)
return;
node that has a descendent on the current label. */
while (fail)
{
+ register struct tree *link;
+
link = fail->links;
while (link && tree->label != link->label)
if (tree->label < link->label)
/* Compute the shift for each trie node, as well as the delta
table and next cache for the given keyword set. */
const char *
-kwsprep (kwset_t kws)
+kwsprep (kwset_t kwset)
{
- register struct kwset *kwset;
- register int i;
- register struct trie *curr, *fail;
- register char const *trans;
unsigned char delta[NCHAR];
- struct trie *last, *next[NCHAR];
-
- kwset = (struct kwset *) kws;
/* Initial values for the delta table; will be changed later. The
delta entry for a given character is the smallest depth of any
node at which an outgoing edge is labeled by that character. */
- if (kwset->mind < 256)
- for (i = 0; i < NCHAR; ++i)
- delta[i] = kwset->mind;
- else
- for (i = 0; i < NCHAR; ++i)
- delta[i] = 255;
+ {
+ register int i;
+
+ if (kwset->mind < 256)
+ for (i = 0; i < NCHAR; ++i)
+ delta[i] = kwset->mind;
+ else
+ for (i = 0; i < NCHAR; ++i)
+ delta[i] = 255;
+ }
/* Check if we can use the simple boyer-moore algorithm, instead
of the hairy commentz-walter algorithm. */
if (kwset->words == 1 && kwset->trans == 0)
{
+ register int i;
+ register struct trie *curr;
+
/* Looking for just one string. Extract it from the trie. */
kwset->target = (char *) obstack_alloc (&kwset->obstack, kwset->mind);
for (i = kwset->mind - 1, curr = kwset->trie; i >= 0; --i)
}
else
{
+ register struct trie *curr;
+ struct trie *last;
+
/* Traverse the nodes of the trie in level order, simultaneously
computing the delta table, failure function, and shift function. */
for (curr = last = kwset->trie; curr; curr = curr->next)
{
+ register struct trie *fail;
+
/* Enqueue the immediate descendents in the level order queue. */
enqueue (curr->links, &last);
/* Create a vector, indexed by character code, of the outgoing links
from the root node. */
- for (i = 0; i < NCHAR; ++i)
- next[i] = 0;
- treenext (kwset->trie->links, next);
+ {
+ struct trie *next[NCHAR];
+ register int i;
- if ((trans = kwset->trans) != 0)
for (i = 0; i < NCHAR; ++i)
- kwset->next[i] = next[(unsigned char) trans[i]];
- else
- for (i = 0; i < NCHAR; ++i)
- kwset->next[i] = next[i];
+ next[i] = 0;
+ treenext (kwset->trie->links, next);
+
+ {
+ register char const *trans;
+
+ if ((trans = kwset->trans) != 0)
+ for (i = 0; i < NCHAR; ++i)
+ kwset->next[i] = next[(unsigned char) trans[i]];
+ else
+ for (i = 0; i < NCHAR; ++i)
+ kwset->next[i] = next[i];
+ }
+ }
}
/* Fix things up for any translation table. */
- if ((trans = kwset->trans) != 0)
- for (i = 0; i < NCHAR; ++i)
- kwset->delta[i] = delta[(unsigned char) trans[i]];
- else
- for (i = 0; i < NCHAR; ++i)
- kwset->delta[i] = delta[i];
+ {
+ register char const *trans;
+ register int i;
+
+ if ((trans = kwset->trans) != 0)
+ for (i = 0; i < NCHAR; ++i)
+ kwset->delta[i] = delta[(unsigned char) trans[i]];
+ else
+ for (i = 0; i < NCHAR; ++i)
+ kwset->delta[i] = delta[i];
+ }
return 0;
}
bmexec (kwset_t kws, char const *text, size_t size)
{
struct kwset const *kwset;
- register unsigned char const *d1;
- register char const *ep, *sp, *tp;
- register int d, gc, i, len, md2;
+ register int len;
kwset = (struct kwset const *) kws;
len = kwset->mind;
return -1;
if (len == 1)
{
+ register char const *tp;
+
tp = (const char *) memchr (text, kwset->target[0], size);
return tp ? tp - text : -1;
}
- d1 = kwset->delta;
- sp = kwset->target + len;
- gc = U(sp[-2]);
- md2 = kwset->mind2;
- tp = text + len;
-
- /* Significance of 12: 1 (initial offset) + 10 (skip loop) + 1 (md2). */
- if (size > 12 * len)
- /* 11 is not a bug, the initial offset happens only once. */
- for (ep = text + size - 11 * len;;)
+ {
+ register unsigned char const *d1;
+ register char const *sp;
+ register int gc;
+ register int md2;
+ register char const *tp;
+
+ d1 = kwset->delta;
+ sp = kwset->target + len;
+ gc = U(sp[-2]);
+ md2 = kwset->mind2;
+ tp = text + len;
+
+ /* Significance of 12: 1 (initial offset) + 10 (skip loop) + 1 (md2). */
+ if (size > 12 * len)
{
- while (tp <= ep)
- {
- d = d1[U(tp[-1])], tp += d;
- d = d1[U(tp[-1])], tp += d;
- if (d == 0)
- goto found;
- d = d1[U(tp[-1])], tp += d;
- d = d1[U(tp[-1])], tp += d;
- d = d1[U(tp[-1])], tp += d;
- if (d == 0)
- goto found;
- d = d1[U(tp[-1])], tp += d;
- d = d1[U(tp[-1])], tp += d;
- d = d1[U(tp[-1])], tp += d;
- if (d == 0)
- goto found;
- d = d1[U(tp[-1])], tp += d;
- d = d1[U(tp[-1])], tp += d;
- }
- break;
- found:
- if (U(tp[-2]) == gc)
+ register char const *ep;
+ register int d;
+
+ /* 11 is not a bug, the initial offset happens only once. */
+ for (ep = text + size - 11 * len;;)
{
- for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)
- ;
- if (i > len)
- return tp - len - text;
+ while (tp <= ep)
+ {
+ d = d1[U(tp[-1])], tp += d;
+ d = d1[U(tp[-1])], tp += d;
+ if (d == 0)
+ goto found;
+ d = d1[U(tp[-1])], tp += d;
+ d = d1[U(tp[-1])], tp += d;
+ d = d1[U(tp[-1])], tp += d;
+ if (d == 0)
+ goto found;
+ d = d1[U(tp[-1])], tp += d;
+ d = d1[U(tp[-1])], tp += d;
+ d = d1[U(tp[-1])], tp += d;
+ if (d == 0)
+ goto found;
+ d = d1[U(tp[-1])], tp += d;
+ d = d1[U(tp[-1])], tp += d;
+ }
+ break;
+ found:
+ if (U(tp[-2]) == gc)
+ {
+ register int i;
+ for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)
+ ;
+ if (i > len)
+ return tp - len - text;
+ }
+ tp += md2;
}
- tp += md2;
}
- /* Now we have only a few characters left to search. We
- carefully avoid ever producing an out-of-bounds pointer. */
- ep = text + size;
- d = d1[U(tp[-1])];
- while (d <= ep - tp)
{
- d = d1[U((tp += d)[-1])];
- if (d != 0)
- continue;
- if (U(tp[-2]) == gc)
+ /* Now we have only a few characters left to search. We
+ carefully avoid ever producing an out-of-bounds pointer. */
+ register char const *ep;
+ register int d;
+
+ ep = text + size;
+ d = d1[U(tp[-1])];
+ while (d <= ep - tp)
{
- for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)
- ;
- if (i > len)
- return tp - len - text;
+ d = d1[U((tp += d)[-1])];
+ if (d != 0)
+ continue;
+ if (U(tp[-2]) == gc)
+ {
+ register int i;
+ for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)
+ ;
+ if (i > len)
+ return tp - len - text;
+ }
+ d = md2;
}
- d = md2;
}
+ }
return -1;
}
cwexec (kwset_t kws, char const *text, size_t len, struct kwsmatch *kwsmatch)
{
struct kwset const *kwset;
- struct trie * const *next;
- struct trie const *trie;
- struct trie const *accept;
- char const *beg, *lim, *mch, *lmch;
- register unsigned char c;
- register unsigned char const *delta;
- register int d;
- register char const *end, *qlim;
- register struct tree const *tree;
- register char const *trans;
-
- accept = NULL;
/* Initialize register copies and look for easy ways out. */
kwset = (struct kwset *) kws;
if (len < kwset->mind)
return -1;
- next = kwset->next;
- delta = kwset->delta;
- trans = kwset->trans;
- lim = text + len;
- end = text;
- if ((d = kwset->mind) != 0)
- mch = 0;
- else
- {
- mch = text, accept = kwset->trie;
- goto match;
- }
+ {
+ struct trie const *accept;
+ struct trie * const *next;
+ register unsigned char const *delta;
+ register char const *trans;
+ char const *lim;
+ register char const *end;
+ register int d;
+ char const *mch;
+ register char const *qlim;
+
+ accept = NULL;
+
+ next = kwset->next;
+ delta = kwset->delta;
+ trans = kwset->trans;
+ lim = text + len;
+ end = text;
+ if ((d = kwset->mind) != 0)
+ mch = 0;
+ else
+ {
+ mch = text, accept = kwset->trie;
+ goto match;
+ }
- if (len >= 4 * kwset->mind)
- qlim = lim - 4 * kwset->mind;
- else
- qlim = 0;
+ if (len >= 4 * kwset->mind)
+ qlim = lim - 4 * kwset->mind;
+ else
+ qlim = 0;
+
+ while (lim - end >= d)
+ {
+ char const *beg;
+ struct trie const *trie;
- while (lim - end >= d)
- {
- if (qlim && end <= qlim)
- {
- end += d - 1;
- while ((d = delta[c = *end]) && end < qlim)
- {
- end += d;
- end += delta[(unsigned char) *end];
- end += delta[(unsigned char) *end];
- }
- ++end;
- }
- else
- d = delta[c = (end += d)[-1]];
- if (d)
- continue;
- beg = end - 1;
- trie = next[c];
- if (trie->accepting)
- {
- mch = beg;
- accept = trie;
- }
- d = trie->shift;
- while (beg > text)
{
- c = trans ? trans[(unsigned char) *--beg] : *--beg;
- tree = trie->links;
- while (tree && c != tree->label)
- if (c < tree->label)
- tree = tree->llink;
- else
- tree = tree->rlink;
- if (tree)
+ register unsigned char c;
+
+ if (qlim && end <= qlim)
{
- trie = tree->trie;
- if (trie->accepting)
+ end += d - 1;
+ while ((d = delta[c = *end]) && end < qlim)
{
- mch = beg;
- accept = trie;
+ end += d;
+ end += delta[(unsigned char) *end];
+ end += delta[(unsigned char) *end];
}
+ ++end;
}
else
- break;
- d = trie->shift;
+ d = delta[c = (end += d)[-1]];
+ if (d)
+ continue;
+ beg = end - 1;
+ trie = next[c];
}
- if (mch)
- goto match;
- }
- return -1;
+ if (trie->accepting)
+ {
+ mch = beg;
+ accept = trie;
+ }
+ d = trie->shift;
+ while (beg > text)
+ {
+ register unsigned char c;
+ register struct tree const *tree;
+
+ c = trans ? trans[(unsigned char) *--beg] : *--beg;
+ tree = trie->links;
+ while (tree && c != tree->label)
+ if (c < tree->label)
+ tree = tree->llink;
+ else
+ tree = tree->rlink;
+ if (tree)
+ {
+ trie = tree->trie;
+ if (trie->accepting)
+ {
+ mch = beg;
+ accept = trie;
+ }
+ }
+ else
+ break;
+ d = trie->shift;
+ }
+ if (mch)
+ goto match;
+ }
+ return -1;
- match:
- /* Given a known match, find the longest possible match anchored
- at or before its starting point. This is nearly a verbatim
- copy of the preceding main search loops. */
- if (lim - mch > kwset->maxd)
- lim = mch + kwset->maxd;
- lmch = 0;
- d = 1;
- while (lim - end >= d)
+ match:
+ /* Given a known match, find the longest possible match anchored
+ at or before its starting point. This is nearly a verbatim
+ copy of the preceding main search loops. */
{
- if ((d = delta[c = (end += d)[-1]]) != 0)
- continue;
- beg = end - 1;
- if (!(trie = next[c]))
- {
- d = 1;
- continue;
- }
- if (trie->accepting && beg <= mch)
- {
- lmch = beg;
- accept = trie;
- }
- d = trie->shift;
- while (beg > text)
+ char const *lmch;
+
+ if (lim - mch > kwset->maxd)
+ lim = mch + kwset->maxd;
+ lmch = 0;
+ d = 1;
+ while (lim - end >= d)
{
- c = trans ? trans[(unsigned char) *--beg] : *--beg;
- tree = trie->links;
- while (tree && c != tree->label)
- if (c < tree->label)
- tree = tree->llink;
- else
- tree = tree->rlink;
- if (tree)
+ char const *beg;
+ struct trie const *trie;
+
+ {
+ register unsigned char c;
+
+ if ((d = delta[c = (end += d)[-1]]) != 0)
+ continue;
+ beg = end - 1;
+ if (!(trie = next[c]))
+ {
+ d = 1;
+ continue;
+ }
+ }
+ if (trie->accepting && beg <= mch)
+ {
+ lmch = beg;
+ accept = trie;
+ }
+ d = trie->shift;
+ while (beg > text)
{
- trie = tree->trie;
- if (trie->accepting && beg <= mch)
+ register unsigned char c;
+ register struct tree const *tree;
+
+ c = trans ? trans[(unsigned char) *--beg] : *--beg;
+ tree = trie->links;
+ while (tree && c != tree->label)
+ if (c < tree->label)
+ tree = tree->llink;
+ else
+ tree = tree->rlink;
+ if (tree)
{
- lmch = beg;
- accept = trie;
+ trie = tree->trie;
+ if (trie->accepting && beg <= mch)
+ {
+ lmch = beg;
+ accept = trie;
+ }
}
+ else
+ break;
+ d = trie->shift;
}
- else
- break;
- d = trie->shift;
- }
- if (lmch)
- {
- mch = lmch;
- goto match;
+ if (lmch)
+ {
+ mch = lmch;
+ goto match;
+ }
+ if (!d)
+ d = 1;
}
- if (!d)
- d = 1;
}
- if (kwsmatch)
- {
- kwsmatch->index = accept->accepting / 2;
- kwsmatch->offset[0] = mch - text;
- kwsmatch->size[0] = accept->depth;
- }
- return mch - text;
+ if (kwsmatch)
+ {
+ kwsmatch->index = accept->accepting / 2;
+ kwsmatch->offset[0] = mch - text;
+ kwsmatch->size[0] = accept->depth;
+ }
+ return mch - text;
+ }
}
/* Search through the given text for a match of any member of the
/* Free the components of the given keyword set. */
void
-kwsfree (kwset_t kws)
+kwsfree (kwset_t kwset)
{
- struct kwset *kwset;
-
- kwset = (struct kwset *) kws;
obstack_free (&kwset->obstack, 0);
- free (kws);
+ free (kwset);
}
char eolbyte)
{
struct compiled_kwset *ckwset;
- const char *beg, *lim, *err;
+ const char *beg;
+ const char *err;
ckwset = XMALLOC (struct compiled_kwset);
kwsinit (ckwset, match_icase, match_words, match_lines, eolbyte);
beg = pattern;
do
{
+ const char *lim;
+
for (lim = beg; lim < pattern + pattern_size && *lim != '\n'; ++lim)
;
if ((err = kwsincr (ckwset->kwset, beg, lim - beg)) != NULL)
size_t *match_size, bool exact)
{
struct compiled_kwset *ckwset = (struct compiled_kwset *) compiled_pattern;
- register const char *beg, *curr, *end;
- register size_t len;
char eol = ckwset->eolbyte;
- struct kwsmatch kwsmatch;
+ register const char *beg;
+ register size_t len;
#ifdef MBS_SUPPORT
char *mb_properties;
if (MB_CUR_MAX > 1)
for (beg = buf; beg <= buf + buf_size; ++beg)
{
+ struct kwsmatch kwsmatch;
size_t offset =
kwsexec (ckwset->kwset, beg, buf + buf_size - beg, &kwsmatch);
if (offset == (size_t) -1)
goto success;
}
else if (ckwset->match_words)
- for (curr = beg; len; )
- {
- if (curr > buf && IS_WORD_CONSTITUENT ((unsigned char) curr[-1]))
- break;
- if (curr + len < buf + buf_size
- && IS_WORD_CONSTITUENT ((unsigned char) curr[len]))
- {
- offset = kwsexec (ckwset->kwset, beg, --len, &kwsmatch);
- if (offset == (size_t) -1)
- {
+ {
+ register const char *curr;
+ for (curr = beg; len; )
+ {
+ if (curr > buf && IS_WORD_CONSTITUENT ((unsigned char) curr[-1]))
+ break;
+ if (curr + len < buf + buf_size
+ && IS_WORD_CONSTITUENT ((unsigned char) curr[len]))
+ {
+ offset = kwsexec (ckwset->kwset, beg, --len, &kwsmatch);
+ if (offset == (size_t) -1)
+ {
#ifdef MBS_SUPPORT
- if (MB_CUR_MAX > 1)
- free (mb_properties);
+ if (MB_CUR_MAX > 1)
+ free (mb_properties);
#endif /* MBS_SUPPORT */
- return offset;
- }
- curr = beg + offset;
- len = kwsmatch.size[0];
- }
- else
- goto success;
- }
+ return offset;
+ }
+ curr = beg + offset;
+ len = kwsmatch.size[0];
+ }
+ else
+ goto success;
+ }
+ }
else
goto success;
}
return -1;
success:
- end = (const char *) memchr (beg + len, eol, (buf + buf_size) - (beg + len));
- if (end != NULL)
- end++;
- else
- end = buf + buf_size;
- while (buf < beg && beg[-1] != eol)
- --beg;
- *match_size = end - beg;
+ {
+ register const char *end;
+
+ end = (const char *) memchr (beg + len, eol, (buf + buf_size) - (beg + len));
+ if (end != NULL)
+ end++;
+ else
+ end = buf + buf_size;
+ while (buf < beg && beg[-1] != eol)
+ --beg;
+ *match_size = end - beg;
#ifdef MBS_SUPPORT
- if (MB_CUR_MAX > 1)
- free (mb_properties);
+ if (MB_CUR_MAX > 1)
+ free (mb_properties);
#endif /* MBS_SUPPORT */
- return beg - buf;
+ return beg - buf;
+ }
}
static void
reg_syntax_t syntax)
{
struct compiled_regex *cregex;
- const char *err;
- const char *sep;
- size_t total = pattern_size;
- const char *motif = pattern;
cregex = XMALLOC (struct compiled_regex);
memset (cregex, '\0', sizeof (struct compiled_regex));
errors like "[\nallo\n]\n". The patterns here are "[", "allo" and "]"
GNU regex should have raised a syntax error. The same for backref, where
the backref should have been local to each pattern. */
- do
- {
- size_t len;
- sep = (const char *) memchr (motif, '\n', total);
- if (sep)
- {
- len = sep - motif;
- sep++;
- total -= (len + 1);
- }
- else
- {
- len = total;
- total = 0;
- }
-
- cregex->patterns = xrealloc (cregex->patterns, (cregex->pcount + 1) * sizeof (struct patterns));
- memset (&cregex->patterns[cregex->pcount], '\0', sizeof (struct patterns));
-
- if ((err = re_compile_pattern (motif, len,
- &(cregex->patterns[cregex->pcount].regexbuf))) != NULL)
- error (exit_failure, 0, err);
- cregex->pcount++;
-
- motif = sep;
- } while (sep && total != 0);
+ {
+ const char *sep;
+ size_t total = pattern_size;
+ const char *motif = pattern;
+
+ do
+ {
+ size_t len;
+ const char *err;
+
+ sep = (const char *) memchr (motif, '\n', total);
+ if (sep)
+ {
+ len = sep - motif;
+ sep++;
+ total -= (len + 1);
+ }
+ else
+ {
+ len = total;
+ total = 0;
+ }
+
+ cregex->patterns = xrealloc (cregex->patterns, (cregex->pcount + 1) * sizeof (struct patterns));
+ memset (&cregex->patterns[cregex->pcount], '\0', sizeof (struct patterns));
+
+ if ((err = re_compile_pattern (motif, len,
+ &(cregex->patterns[cregex->pcount].regexbuf))) != NULL)
+ error (exit_failure, 0, err);
+ cregex->pcount++;
+
+ motif = sep;
+ }
+ while (sep && total != 0);
+ }
return cregex;
}
size_t *match_size, bool exact)
{
struct compiled_regex *cregex = (struct compiled_regex *) compiled_pattern;
- register const char *buflim, *beg, *end;
char eol = cregex->eolbyte;
- int start, len;
- size_t i;
-
- buflim = buf + buf_size;
+ register const char *buflim = buf + buf_size;
+ register const char *beg;
+ register const char *end;
for (beg = buf; beg < buflim; beg = end)
{
+ size_t i;
+
end = (const char *) memchr (beg, eol, buflim - beg);
if (end == NULL)
end = buflim;
for (i = 0; i < cregex->pcount; i++)
{
+ int start, len;
+
cregex->patterns[i].regexbuf.not_eol = 0;
if (0 <= (start = re_search (&(cregex->patterns[i].regexbuf), beg,
end - beg, 0,
projects / thirdparty / gettext.git / commitdiff
