592 lines
18 KiB
Plaintext
592 lines
18 KiB
Plaintext
From caa9ffa4f1340056db4dc3ce7d63b29393d676d7 Mon Sep 17 00:00:00 2001
|
|
From: Jerome Duval <jerome.duval@gmail.com>
|
|
Date: Wed, 4 Jun 2014 19:20:57 +0000
|
|
Subject: gcc2 patch
|
|
|
|
[cdesai: update for v2.22]
|
|
|
|
diff --git a/src/dfa.c b/src/dfa.c
|
|
index adc5de3..f397ff2 100644
|
|
--- a/src/dfa.c
|
|
+++ b/src/dfa.c
|
|
@@ -3481,7 +3481,8 @@ dfainit (struct dfa *d)
|
|
static bool _GL_ATTRIBUTE_PURE
|
|
dfa_supported (struct dfa const *d)
|
|
{
|
|
- for (size_t i = 0; i < d->tindex; i++)
|
|
+ size_t i;
|
|
+ for (i = 0; i < d->tindex; i++)
|
|
{
|
|
switch (d->tokens[i])
|
|
{
|
|
@@ -3934,6 +3935,7 @@ freemust (must *mp)
|
|
struct dfamust *
|
|
dfamust (struct dfa const *d)
|
|
{
|
|
+ struct dfamust *dm = NULL;
|
|
must *mp = NULL;
|
|
char const *result = "";
|
|
size_t i;
|
|
@@ -3943,8 +3945,10 @@ dfamust (struct dfa const *d)
|
|
bool need_begline = false;
|
|
bool need_endline = false;
|
|
bool case_fold_unibyte = case_fold && MB_CUR_MAX == 1;
|
|
+ size_t ri;
|
|
+ size_t rj;
|
|
|
|
- for (size_t ri = 0; ri < d->tindex; ++ri)
|
|
+ for (ri = 0; ri < d->tindex; ++ri)
|
|
{
|
|
token t = d->tokens[ri];
|
|
switch (t)
|
|
@@ -4119,7 +4123,7 @@ dfamust (struct dfa const *d)
|
|
}
|
|
}
|
|
|
|
- size_t rj = ri + 2;
|
|
+ rj = ri + 2;
|
|
if (d->tokens[ri + 1] == CAT)
|
|
{
|
|
for (; rj < d->tindex - 1; rj += 2)
|
|
@@ -4148,7 +4152,6 @@ dfamust (struct dfa const *d)
|
|
}
|
|
done:;
|
|
|
|
- struct dfamust *dm = NULL;
|
|
if (*result)
|
|
{
|
|
dm = xmalloc (sizeof *dm);
|
|
diff --git a/src/dfasearch.c b/src/dfasearch.c
|
|
index d348d44..cd33148 100644
|
|
--- a/src/dfasearch.c
|
|
+++ b/src/dfasearch.c
|
|
@@ -95,11 +95,11 @@ kwsmusts (void)
|
|
/* Prepare a substring whose presence implies a match.
|
|
The kwset matcher will return the index of the matching
|
|
string that it chooses. */
|
|
- ++kwset_exact_matches;
|
|
size_t old_len = strlen (dm->must);
|
|
size_t new_len = old_len + dm->begline + dm->endline;
|
|
char *must = xmalloc (new_len);
|
|
char *mp = must;
|
|
+ ++kwset_exact_matches;
|
|
*mp = eolbyte;
|
|
mp += dm->begline;
|
|
begline |= dm->begline;
|
|
@@ -122,6 +122,7 @@ kwsmusts (void)
|
|
void
|
|
GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
|
|
{
|
|
+ char const *p;
|
|
size_t total = size;
|
|
char *motif;
|
|
|
|
@@ -134,9 +135,10 @@ GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
|
|
"[\nallo\n]\n", where the patterns are "[", "allo" and "]", and
|
|
this should be a syntax error. The same for backref, where the
|
|
backref should be local to each pattern. */
|
|
- char const *p = pattern;
|
|
+ p = pattern;
|
|
do
|
|
{
|
|
+ char const *err;
|
|
size_t len;
|
|
char const *sep = memchr (p, '\n', total);
|
|
if (sep)
|
|
@@ -154,7 +156,7 @@ GEAcompile (char const *pattern, size_t size, reg_syntax_t syntax_bits)
|
|
patterns = xnrealloc (patterns, pcount + 1, sizeof *patterns);
|
|
patterns[pcount] = patterns0;
|
|
|
|
- char const *err = re_compile_pattern (p, len,
|
|
+ err = re_compile_pattern (p, len,
|
|
&(patterns[pcount].regexbuf));
|
|
if (err)
|
|
error (EXIT_TROUBLE, 0, "%s", err);
|
|
@@ -213,6 +215,7 @@ EGexecute (char *buf, size_t size, size_t *match_size,
|
|
size_t i;
|
|
struct dfa *superset = dfasuperset (dfa);
|
|
bool dfafast = dfaisfast (dfa);
|
|
+ size_t off;
|
|
|
|
mb_start = buf;
|
|
buflim = buf + size;
|
|
@@ -445,7 +448,7 @@ EGexecute (char *buf, size_t size, size_t *match_size,
|
|
success:
|
|
len = end - beg;
|
|
success_in_len:;
|
|
- size_t off = beg - buf;
|
|
+ off = beg - buf;
|
|
*match_size = len;
|
|
return off;
|
|
}
|
|
diff --git a/src/dosbuf.c b/src/dosbuf.c
|
|
index 839cc3a..405662a 100644
|
|
--- a/src/dosbuf.c
|
|
+++ b/src/dosbuf.c
|
|
@@ -95,11 +95,11 @@ guess_type (char *buf, size_t buflen)
|
|
static size_t
|
|
undossify_input (char *buf, size_t buflen)
|
|
{
|
|
+ size_t bytes_left = 0;
|
|
+
|
|
if (! O_BINARY)
|
|
return buflen;
|
|
|
|
- size_t bytes_left = 0;
|
|
-
|
|
if (totalcc == 0)
|
|
{
|
|
/* New file: forget everything we knew about character
|
|
@@ -186,12 +186,12 @@ undossify_input (char *buf, size_t buflen)
|
|
static off_t
|
|
dossified_pos (off_t byteno)
|
|
{
|
|
- if (! O_BINARY)
|
|
- return byteno;
|
|
-
|
|
off_t pos_lo;
|
|
off_t pos_hi;
|
|
|
|
+ if (! O_BINARY)
|
|
+ return byteno;
|
|
+
|
|
if (dos_file_type != DOS_TEXT || dos_report_unix_offset)
|
|
return byteno;
|
|
|
|
diff --git a/src/grep.c b/src/grep.c
|
|
index 73c3651..5455634 100644
|
|
--- a/src/grep.c
|
|
+++ b/src/grep.c
|
|
@@ -521,7 +521,9 @@ initialize_unibyte_mask (void)
|
|
bits work better. */
|
|
unsigned char mask = 0;
|
|
int ms1b = 1;
|
|
- for (int i = 1; i <= UCHAR_MAX; i++)
|
|
+ int i;
|
|
+ uword uword_max;
|
|
+ for (i = 1; i <= UCHAR_MAX; i++)
|
|
if (mbclen_cache[i] != 1 && ! (mask & i))
|
|
{
|
|
while (ms1b * 2 <= i)
|
|
@@ -532,7 +534,7 @@ initialize_unibyte_mask (void)
|
|
/* Now MASK will detect any encoding-error byte, although it may
|
|
cry wolf and it may not be optimal. Build a uword-length mask by
|
|
repeating MASK. */
|
|
- uword uword_max = -1;
|
|
+ uword_max = -1;
|
|
unibyte_mask = uword_max / UCHAR_MAX * mask;
|
|
}
|
|
|
|
@@ -564,14 +566,15 @@ skip_easy_bytes (char const *buf)
|
|
bool
|
|
buf_has_encoding_errors (char *buf, size_t size)
|
|
{
|
|
- if (! unibyte_mask)
|
|
- return false;
|
|
-
|
|
mbstate_t mbs = { 0 };
|
|
size_t clen;
|
|
+ char const *p;
|
|
+ if (! unibyte_mask)
|
|
+ return false;
|
|
|
|
+
|
|
buf[size] = -1;
|
|
- for (char const *p = buf; (p = skip_easy_bytes (p)) < buf + size; p += clen)
|
|
+ for (p = buf; (p = skip_easy_bytes (p)) < buf + size; p += clen)
|
|
{
|
|
clen = mbrlen (p, buf + size - p, &mbs);
|
|
if ((size_t) -2 <= clen)
|
|
@@ -606,6 +609,7 @@ file_must_have_nulls (size_t size, int fd, struct stat const *st)
|
|
/* If the file has holes, it must contain a null byte somewhere. */
|
|
if (SEEK_HOLE != SEEK_SET)
|
|
{
|
|
+ off_t hole_start;
|
|
off_t cur = size;
|
|
if (O_BINARY || fd == STDIN_FILENO)
|
|
{
|
|
@@ -615,7 +619,7 @@ file_must_have_nulls (size_t size, int fd, struct stat const *st)
|
|
}
|
|
|
|
/* Look for a hole after the current location. */
|
|
- off_t hole_start = lseek (fd, cur, SEEK_HOLE);
|
|
+ hole_start = lseek (fd, cur, SEEK_HOLE);
|
|
if (0 <= hole_start)
|
|
{
|
|
if (lseek (fd, cur, SEEK_SET) < 0)
|
|
@@ -717,7 +721,8 @@ add_count (uintmax_t a, uintmax_t b)
|
|
static bool
|
|
all_zeros (char const *buf, size_t size)
|
|
{
|
|
- for (char const *p = buf; p < buf + size; p++)
|
|
+ char const *p;
|
|
+ for (p = buf; p < buf + size; p++)
|
|
if (*p)
|
|
return false;
|
|
return true;
|
|
@@ -993,6 +998,7 @@ static bool
|
|
print_line_head (char *beg, size_t len, char const *lim, char sep)
|
|
{
|
|
bool encoding_errors = false;
|
|
+ bool pending_sep = false;
|
|
if (binary_files != TEXT_BINARY_FILES)
|
|
{
|
|
char ch = beg[len];
|
|
@@ -1005,7 +1011,6 @@ print_line_head (char *beg, size_t len, char const *lim, char sep)
|
|
return false;
|
|
}
|
|
|
|
- bool pending_sep = false;
|
|
|
|
if (out_file)
|
|
{
|
|
@@ -1230,11 +1235,13 @@ prtext (char *beg, char *lim)
|
|
{
|
|
static bool used; /* Avoid printing SEP_STR_GROUP before any output. */
|
|
char eol = eolbyte;
|
|
+ char *p;
|
|
+ intmax_t n;
|
|
|
|
if (!out_quiet && pending > 0)
|
|
prpending (beg);
|
|
|
|
- char *p = beg;
|
|
+ p = beg;
|
|
|
|
if (!out_quiet)
|
|
{
|
|
@@ -1267,7 +1274,6 @@ prtext (char *beg, char *lim)
|
|
}
|
|
}
|
|
|
|
- intmax_t n;
|
|
if (out_invert)
|
|
{
|
|
/* One or more lines are output. */
|
|
@@ -1324,9 +1330,11 @@ grepbuf (char *beg, char const *lim)
|
|
{
|
|
intmax_t outleft0 = outleft;
|
|
char *endp;
|
|
+ char *p;
|
|
|
|
- for (char *p = beg; p < lim; p = endp)
|
|
+ for (p = beg; p < lim; p = endp)
|
|
{
|
|
+ char *b;
|
|
size_t match_size;
|
|
size_t match_offset = execute (p, lim - p, &match_size, NULL);
|
|
if (match_offset == (size_t) -1)
|
|
@@ -1336,7 +1344,7 @@ grepbuf (char *beg, char const *lim)
|
|
match_offset = lim - p;
|
|
match_size = 0;
|
|
}
|
|
- char *b = p + match_offset;
|
|
+ b = p + match_offset;
|
|
endp = b + match_size;
|
|
/* Avoid matching the empty line at the end of the buffer. */
|
|
if (!out_invert && b == lim)
|
|
@@ -1373,6 +1381,7 @@ grep (int fd, struct stat const *st)
|
|
char nul_zapper = '\0';
|
|
bool done_on_match_0 = done_on_match;
|
|
bool out_quiet_0 = out_quiet;
|
|
+ bool firsttime;
|
|
|
|
/* The value of NLINES when nulls were first deduced in the input;
|
|
this is not necessarily the same as the number of matching lines
|
|
@@ -1402,7 +1411,7 @@ grep (int fd, struct stat const *st)
|
|
return 0;
|
|
}
|
|
|
|
- for (bool firsttime = true; ; firsttime = false)
|
|
+ for (firsttime = true; ; firsttime = false)
|
|
{
|
|
if (nlines_first_null < 0 && eol && binary_files != TEXT_BINARY_FILES
|
|
&& (buf_has_nulls (bufbeg, buflim - bufbeg)
|
|
@@ -2204,6 +2213,8 @@ fgrep_to_grep_pattern (size_t len, char const *keys,
|
|
int
|
|
main (int argc, char **argv)
|
|
{
|
|
+ bool status = true;
|
|
+ char *const *files;
|
|
char *keys;
|
|
size_t keycc, oldcc, keyalloc;
|
|
bool with_filenames;
|
|
@@ -2213,6 +2224,10 @@ main (int argc, char **argv)
|
|
int fread_errno;
|
|
intmax_t default_context;
|
|
FILE *fp;
|
|
+ struct stat tmp_stat;
|
|
+ char eolbytes[3];
|
|
+ size_t match_size;
|
|
+ int cmd;
|
|
exit_failure = EXIT_TROUBLE;
|
|
initialize_main (&argc, &argv);
|
|
set_program_name (argv[0]);
|
|
@@ -2487,7 +2502,7 @@ main (int argc, char **argv)
|
|
|
|
case EXCLUDE_OPTION:
|
|
case INCLUDE_OPTION:
|
|
- for (int cmd = 0; cmd < 2; cmd++)
|
|
+ for (cmd = 0; cmd < 2; cmd++)
|
|
{
|
|
if (!excluded_patterns[cmd])
|
|
excluded_patterns[cmd] = new_exclude ();
|
|
@@ -2497,7 +2512,7 @@ main (int argc, char **argv)
|
|
}
|
|
break;
|
|
case EXCLUDE_FROM_OPTION:
|
|
- for (int cmd = 0; cmd < 2; cmd++)
|
|
+ for (cmd = 0; cmd < 2; cmd++)
|
|
{
|
|
if (!excluded_patterns[cmd])
|
|
excluded_patterns[cmd] = new_exclude ();
|
|
@@ -2510,7 +2525,7 @@ main (int argc, char **argv)
|
|
|
|
case EXCLUDE_DIRECTORY_OPTION:
|
|
strip_trailing_slashes (optarg);
|
|
- for (int cmd = 0; cmd < 2; cmd++)
|
|
+ for (cmd = 0; cmd < 2; cmd++)
|
|
{
|
|
if (!excluded_directory_patterns[cmd])
|
|
excluded_directory_patterns[cmd] = new_exclude ();
|
|
@@ -2582,7 +2597,6 @@ main (int argc, char **argv)
|
|
if (show_help)
|
|
usage (EXIT_SUCCESS);
|
|
|
|
- struct stat tmp_stat;
|
|
if (fstat (STDOUT_FILENO, &tmp_stat) == 0 && S_ISREG (tmp_stat.st_mode))
|
|
out_stat = tmp_stat;
|
|
|
|
@@ -2634,8 +2648,9 @@ main (int argc, char **argv)
|
|
compile (keys, keycc);
|
|
free (keys);
|
|
/* We need one byte prior and one after. */
|
|
- char eolbytes[3] = { 0, eolbyte, 0 };
|
|
- size_t match_size;
|
|
+ eolbytes[0] = 0;
|
|
+ eolbytes[1] = eolbyte;
|
|
+ eolbytes[2] = 0;
|
|
skip_empty_lines = ((execute (eolbytes + 1, 1, &match_size, NULL) == 0)
|
|
== out_invert);
|
|
|
|
@@ -2655,7 +2670,6 @@ main (int argc, char **argv)
|
|
if (fts_options & FTS_LOGICAL && devices == READ_COMMAND_LINE_DEVICES)
|
|
devices = READ_DEVICES;
|
|
|
|
- char *const *files;
|
|
if (optind < argc)
|
|
{
|
|
files = argv + optind;
|
|
@@ -2672,7 +2686,6 @@ main (int argc, char **argv)
|
|
files = stdin_only;
|
|
}
|
|
|
|
- bool status = true;
|
|
do
|
|
status &= grep_command_line_arg (*files++);
|
|
while (*files != NULL);
|
|
diff --git a/src/kwsearch.c b/src/kwsearch.c
|
|
index e9966d4..a8f716d 100644
|
|
--- a/src/kwsearch.c
|
|
+++ b/src/kwsearch.c
|
|
@@ -37,13 +37,14 @@ void
|
|
Fcompile (char const *pattern, size_t size)
|
|
{
|
|
size_t total = size;
|
|
+ char const *p = pattern;
|
|
|
|
kwsinit (&kwset);
|
|
|
|
- char const *p = pattern;
|
|
do
|
|
{
|
|
size_t len;
|
|
+ char *buf = NULL;
|
|
char const *sep = memchr (p, '\n', total);
|
|
if (sep)
|
|
{
|
|
@@ -57,7 +58,6 @@ Fcompile (char const *pattern, size_t size)
|
|
total = 0;
|
|
}
|
|
|
|
- char *buf = NULL;
|
|
if (match_lines)
|
|
{
|
|
buf = xmalloc (len + 2);
|
|
@@ -86,6 +86,7 @@ Fexecute (char *buf, size_t size, size_t *match_size,
|
|
char eol = eolbyte;
|
|
struct kwsmatch kwsmatch;
|
|
size_t ret_val;
|
|
+ size_t off;
|
|
|
|
for (mb_start = beg = start_ptr ? start_ptr : buf; beg <= buf + size; beg++)
|
|
{
|
|
@@ -157,7 +158,7 @@ Fexecute (char *buf, size_t size, size_t *match_size,
|
|
beg = beg ? beg + 1 : buf;
|
|
len = end - beg;
|
|
success_in_beg_and_len:;
|
|
- size_t off = beg - buf;
|
|
+ off = beg - buf;
|
|
|
|
*match_size = len;
|
|
ret_val = off;
|
|
diff --git a/src/kwset.c b/src/kwset.c
|
|
index 03520b6..b0c7446 100644
|
|
--- a/src/kwset.c
|
|
+++ b/src/kwset.c
|
|
@@ -162,6 +162,7 @@ kwsincr (kwset_t kwset, char const *text, size_t len)
|
|
installing new nodes when necessary. */
|
|
while (len--)
|
|
{
|
|
+ int depth = 1;
|
|
unsigned char uc = *--text;
|
|
unsigned char label = trans ? trans[uc] : uc;
|
|
|
|
@@ -173,7 +174,6 @@ kwsincr (kwset_t kwset, char const *text, size_t len)
|
|
enum { L, R } dirs[DEPTH_SIZE];
|
|
links[0] = (struct tree *) &trie->links;
|
|
dirs[0] = L;
|
|
- int depth = 1;
|
|
|
|
while (link && label != link->label)
|
|
{
|
|
@@ -392,10 +392,13 @@ treenext (struct tree const *tree, struct trie *next[])
|
|
void
|
|
kwsprep (kwset_t kwset)
|
|
{
|
|
+ struct trie *curr, *last;
|
|
char const *trans = kwset->trans;
|
|
int i;
|
|
unsigned char deltabuf[NCHAR];
|
|
unsigned char *delta = trans ? deltabuf : kwset->delta;
|
|
+ struct trie *nextbuf[NCHAR];
|
|
+ struct trie **next;
|
|
|
|
/* Initial values for the delta table; will be changed later. The
|
|
delta entry for a given character is the smallest depth of any
|
|
@@ -404,9 +407,10 @@ kwsprep (kwset_t kwset)
|
|
|
|
/* Traverse the nodes of the trie in level order, simultaneously
|
|
computing the delta table, failure function, and shift function. */
|
|
- struct trie *curr, *last;
|
|
for (curr = last = kwset->trie; curr; curr = curr->next)
|
|
{
|
|
+ struct trie *fail;
|
|
+
|
|
/* Enqueue the immediate descendants in the level order queue. */
|
|
enqueue (curr->links, &last);
|
|
|
|
@@ -421,7 +425,6 @@ kwsprep (kwset_t kwset)
|
|
|
|
/* Update the shifts at each node in the current node's chain
|
|
of fails back to the root. */
|
|
- struct trie *fail;
|
|
for (fail = curr->fail; fail; fail = fail->fail)
|
|
{
|
|
/* If the current node has some outgoing edge that the fail
|
|
@@ -451,8 +454,7 @@ kwsprep (kwset_t kwset)
|
|
|
|
/* Create a vector, indexed by character code, of the outgoing links
|
|
from the root node. */
|
|
- struct trie *nextbuf[NCHAR];
|
|
- struct trie **next = trans ? nextbuf : kwset->next;
|
|
+ next = trans ? nextbuf : kwset->next;
|
|
memset (next, 0, sizeof nextbuf);
|
|
treenext (kwset->trie->links, next);
|
|
if (trans)
|
|
@@ -463,6 +465,8 @@ kwsprep (kwset_t kwset)
|
|
of the hairy commentz-walter algorithm. */
|
|
if (kwset->words == 1)
|
|
{
|
|
+ char gc1;
|
|
+ int gc1help = -1;
|
|
/* Looking for just one string. Extract it from the trie. */
|
|
kwset->target = obstack_alloc (&kwset->obstack, kwset->mind);
|
|
for (i = kwset->mind - 1, curr = kwset->trie; i >= 0; --i)
|
|
@@ -484,11 +488,10 @@ kwsprep (kwset_t kwset)
|
|
}
|
|
}
|
|
|
|
- char gc1 = tr (trans, kwset->target[kwset->mind - 1]);
|
|
+ gc1 = tr (trans, kwset->target[kwset->mind - 1]);
|
|
|
|
/* Set GC1HELP according to whether exactly one, exactly two, or
|
|
three-or-more characters match GC1. */
|
|
- int gc1help = -1;
|
|
if (trans)
|
|
{
|
|
char const *equiv1 = memchr (trans, gc1, NCHAR);
|
|
@@ -570,13 +573,16 @@ bm_delta2_search (char const **tpp, char const *ep, char const *sp, int len,
|
|
static char const *
|
|
memchr_kwset (char const *s, size_t n, kwset_t kwset)
|
|
{
|
|
+ int small_heuristic = 2;
|
|
+ int small;
|
|
+ size_t ntrans;
|
|
+ char const *slim;
|
|
if (kwset->gc1help < 0)
|
|
return memchr (s, kwset->gc1, n);
|
|
- int small_heuristic = 2;
|
|
- int small = (- (uintptr_t) s % sizeof (long)
|
|
+ small = (- (uintptr_t) s % sizeof (long)
|
|
+ small_heuristic * sizeof (long));
|
|
- size_t ntrans = kwset->gc1help < NCHAR && small < n ? small : n;
|
|
- char const *slim = s + ntrans;
|
|
+ ntrans = kwset->gc1help < NCHAR && small < n ? small : n;
|
|
+ slim = s + ntrans;
|
|
for (; s < slim; s++)
|
|
if (kwset->trans[U(*s)] == kwset->gc1)
|
|
return s;
|
|
@@ -593,6 +599,7 @@ bmexec_trans (kwset_t kwset, char const *text, size_t size)
|
|
int d;
|
|
int len = kwset->mind;
|
|
char const *trans = kwset->trans;
|
|
+ char gc1, gc2;
|
|
|
|
if (len == 0)
|
|
return 0;
|
|
@@ -607,8 +614,8 @@ bmexec_trans (kwset_t kwset, char const *text, size_t size)
|
|
d1 = kwset->delta;
|
|
sp = kwset->target + len;
|
|
tp = text + len;
|
|
- char gc1 = kwset->gc1;
|
|
- char gc2 = kwset->gc2;
|
|
+ gc1 = kwset->gc1;
|
|
+ gc2 = kwset->gc2;
|
|
|
|
/* Significance of 12: 1 (initial offset) + 10 (skip loop) + 1 (md2). */
|
|
if (size > 12 * len)
|
|
@@ -630,12 +637,12 @@ bmexec_trans (kwset_t kwset, char const *text, size_t size)
|
|
d = d1[U(tp[-1])], tp += d;
|
|
if (d != 0)
|
|
{
|
|
+ int advance_heuristic = 16 * sizeof (long);
|
|
d = d1[U(tp[-1])], tp += d;
|
|
d = d1[U(tp[-1])], tp += d;
|
|
|
|
/* As a heuristic, prefer memchr to seeking by
|
|
delta1 when the latter doesn't advance much. */
|
|
- int advance_heuristic = 16 * sizeof (long);
|
|
if (advance_heuristic <= tp - tp0)
|
|
continue;
|
|
tp--;
|
|
diff --git a/src/searchutils.c b/src/searchutils.c
|
|
index 2eab3dc..15710cb 100644
|
|
--- a/src/searchutils.c
|
|
+++ b/src/searchutils.c
|
|
@@ -272,9 +272,10 @@ mb_goback (char const **mb_start, char const *cur, char const *end)
|
|
wint_t
|
|
mb_prev_wc (char const *buf, char const *cur, char const *end)
|
|
{
|
|
+ char const *p;
|
|
if (cur == buf)
|
|
return WEOF;
|
|
- char const *p = buf;
|
|
+ p = buf;
|
|
cur--;
|
|
cur -= mb_goback (&p, cur, end);
|
|
return mb_next_wc (cur, end);
|
|
--
|
|
2.7.0
|
|
|