From: Bruno Haible Date: Mon, 24 May 2010 08:36:51 +0000 (+0200) Subject: Reduce scope of local variables. X-Git-Tag: v0.18.1~30 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=95551a9f64e25a9c469df8e7dfbf03b645c88f8f;p=thirdparty%2Fgettext.git Reduce scope of local variables. --- diff --git a/gettext-tools/libgrep/ChangeLog b/gettext-tools/libgrep/ChangeLog index ebcfd5d7d..dd951dbc6 100644 --- a/gettext-tools/libgrep/ChangeLog +++ b/gettext-tools/libgrep/ChangeLog @@ -1,3 +1,10 @@ +2010-05-24 Bruno Haible + + * m-fgrep.c (Fcompile, Fexecute): Reduce scope of local variables. + * m-regex.c (compile, EGexecute): Likewise. + * kwset.c (kwsincr, treefails, kwsprep, bmexec, cwexec): Likewise. + (kwsexec): Remove useless cast. + 2010-05-23 Bruno Haible * kwset.c: Use GNU coding style. diff --git a/gettext-tools/libgrep/kwset.c b/gettext-tools/libgrep/kwset.c index 50fe75837..2eb4a5c90 100644 --- a/gettext-tools/libgrep/kwset.c +++ b/gettext-tools/libgrep/kwset.c @@ -127,12 +127,6 @@ kwsincr (kwset_t kws, char const *text, size_t len) { 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; @@ -142,6 +136,12 @@ kwsincr (kwset_t kws, char const *text, size_t len) 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, @@ -206,8 +206,11 @@ kwsincr (kwset_t kws, char const *text, size_t len) 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]) { @@ -296,8 +299,6 @@ static void treefails (register struct tree const *tree, struct trie const *fail, struct trie *recourse) { - register struct tree *link; - if (!tree) return; @@ -308,6 +309,8 @@ treefails (register struct tree const *tree, struct trie const *fail, 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) @@ -373,31 +376,31 @@ treenext (struct tree const *tree, struct trie *next[]) /* 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) @@ -417,10 +420,15 @@ kwsprep (kwset_t kws) } 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); @@ -464,25 +472,39 @@ kwsprep (kwset_t kws) /* 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; } @@ -494,9 +516,7 @@ static size_t 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; @@ -507,70 +527,92 @@ bmexec (kwset_t kws, char const *text, size_t size) 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; } @@ -580,155 +622,181 @@ static size_t 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 @@ -760,11 +828,8 @@ kwsexec (kwset_t kws, char const *text, size_t size, /* 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); } diff --git a/gettext-tools/libgrep/m-fgrep.c b/gettext-tools/libgrep/m-fgrep.c index 1711cec67..5c92365b3 100644 --- a/gettext-tools/libgrep/m-fgrep.c +++ b/gettext-tools/libgrep/m-fgrep.c @@ -92,7 +92,8 @@ Fcompile (const char *pattern, size_t pattern_size, 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); @@ -100,6 +101,8 @@ Fcompile (const char *pattern, size_t pattern_size, 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) @@ -153,10 +156,9 @@ Fexecute (const void *compiled_pattern, const char *buf, size_t buf_size, 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) @@ -165,6 +167,7 @@ Fexecute (const void *compiled_pattern, const char *buf, size_t buf_size, 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) @@ -199,28 +202,31 @@ Fexecute (const void *compiled_pattern, const char *buf, size_t buf_size, 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; } @@ -232,19 +238,23 @@ Fexecute (const void *compiled_pattern, const char *buf, size_t buf_size, 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 diff --git a/gettext-tools/libgrep/m-regex.c b/gettext-tools/libgrep/m-regex.c index 0c5b5840b..4b93a823b 100644 --- a/gettext-tools/libgrep/m-regex.c +++ b/gettext-tools/libgrep/m-regex.c @@ -63,10 +63,6 @@ compile (const char *pattern, size_t pattern_size, 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)); @@ -82,32 +78,41 @@ compile (const char *pattern, size_t pattern_size, 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; } @@ -145,15 +150,15 @@ EGexecute (const void *compiled_pattern, 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; @@ -161,6 +166,8 @@ EGexecute (const void *compiled_pattern, 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,