From 1a6e0105445acef349524b6d049dc0fe77ad1aa5 Mon Sep 17 00:00:00 2001 From: Chirayu Desai Date: Wed, 3 Dec 2014 12:47:58 +0000 Subject: [PATCH] Update GNU grep to 2.21 --- sys-apps/grep/grep-2.21.recipe | 71 ++++ sys-apps/grep/patches/grep-2.21.patchset | 471 +++++++++++++++++++++++ 2 files changed, 542 insertions(+) create mode 100644 sys-apps/grep/grep-2.21.recipe create mode 100644 sys-apps/grep/patches/grep-2.21.patchset diff --git a/sys-apps/grep/grep-2.21.recipe b/sys-apps/grep/grep-2.21.recipe new file mode 100644 index 000000000..170d6b942 --- /dev/null +++ b/sys-apps/grep/grep-2.21.recipe @@ -0,0 +1,71 @@ +SUMMARY="GNU regular expression matcher" +DESCRIPTION=" +The grep command searches one or more input files for lines containing a match \ +to a specified pattern. By default, grep prints the matching lines. +" +HOMEPAGE="http://www.gnu.org/software/grep/" +LICENSE="GNU GPL v3" +COPYRIGHT="1992-2014 Free Software Foundation, Inc." +SRC_URI="http://ftp.gnu.org/gnu/grep/grep-2.21.tar.xz" +CHECKSUM_SHA256="5244a11c00dee8e7e5e714b9aaa053ac6cbfa27e104abee20d3c778e4bb0e5de" +REVISION="1" +ARCHITECTURES="x86_gcc2 x86 x86_64 arm" + +PATCHES="grep-2.21.patchset" + +PROVIDES=" + grep = $portVersion compat >= 2 + cmd:egrep = $portVersion compat >= 2 + cmd:fgrep = $portVersion compat >= 2 + cmd:grep = $portVersion compat >= 2 + " +REQUIRES=" + haiku >= $haikuVersion + lib:libiconv + lib:libintl + " +BUILD_REQUIRES=" + devel:libiconv + devel:libintl + " +BUILD_PREREQUIRES=" + haiku_devel >= $haikuVersion + cmd:aclocal + cmd:autoconf + cmd:automake + cmd:gcc + cmd:gettext + cmd:grep + cmd:ld + cmd:libtoolize + cmd:make + cmd:makeinfo + cmd:sed + " + +defineDebugInfoPackage grep \ + $binDir/grep + + +BUILD() +{ + libtoolize --force --copy --install + aclocal -I m4 + autoconf + runConfigure ./configure \ + --disable-perl-regexp --disable-gcc-warnings + make $jobArgs +} + +INSTALL() +{ + make install + + rm $libDir/charset.alias + rmdir $libDir +} + +TEST() +{ + make check +} diff --git a/sys-apps/grep/patches/grep-2.21.patchset b/sys-apps/grep/patches/grep-2.21.patchset new file mode 100644 index 000000000..db0115694 --- /dev/null +++ b/sys-apps/grep/patches/grep-2.21.patchset @@ -0,0 +1,471 @@ +From d2e48169bd6f0f4ff6f1bceb951061dfd98b2e62 Mon Sep 17 00:00:00 2001 +From: Jerome Duval +Date: Wed, 4 Jun 2014 19:20:57 +0000 +Subject: [PATCH] gcc2 patch + +[cdesai: update for v2.21] +--- + src/dfasearch.c | 21 ++++++++++++++------- + src/dosbuf.c | 10 +++++----- + src/grep.c | 37 ++++++++++++++++++++++++------------- + src/kwsearch.c | 8 +++++--- + src/kwset.c | 37 ++++++++++++++++++++++--------------- + src/searchutils.c | 3 ++- + 6 files changed, 72 insertions(+), 44 deletions(-) + +diff --git a/src/dfasearch.c b/src/dfasearch.c +index 77b4e3ecaf..076f49ca18 100644 +--- a/src/dfasearch.c ++++ b/src/dfasearch.c +@@ -95,13 +95,17 @@ kwsmusts (void) + of the matching string that it chooses. */ + for (; dm; dm = dm->next) + { ++ char *must; ++ char *mp; ++ size_t old_len; ++ size_t new_len; + if (!dm->exact) + continue; + ++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; ++ old_len = strlen (dm->must); ++ new_len = old_len + dm->begline + dm->endline; ++ must = xmalloc (new_len); ++ mp = must; + *mp = eolbyte; + mp += dm->begline; + begline |= dm->begline; +@@ -126,6 +130,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; + +@@ -138,9 +143,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) +@@ -158,7 +164,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); +@@ -218,6 +224,7 @@ EGexecute (char const *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; +@@ -448,7 +455,7 @@ EGexecute (char const *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 3b4052ac4a..f9f26a7685 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 8dbf86ec94..52dbcf8f54 100644 +--- a/src/grep.c ++++ b/src/grep.c +@@ -463,8 +463,9 @@ static bool easy_encoding; + static void + init_easy_encoding (void) + { ++ int i; + easy_encoding = true; +- for (int i = 0; i < HIBYTE; i++) ++ for (i = 0; i < HIBYTE; i++) + easy_encoding &= mbclen_cache[i] == 1; + } + +@@ -493,20 +494,23 @@ typedef uintmax_t uword; + static char const * _GL_ATTRIBUTE_PURE + skip_easy_bytes (char const *buf) + { ++ uword uword_max; ++ uword hibyte_mask; ++ char const *p; ++ uword const *s; ++ + if (!easy_encoding) + return buf; + +- uword uword_max = -1; ++ uword_max = -1; + + /* 0x8080..., extended to be wide enough for uword. */ +- uword hibyte_mask = uword_max / UCHAR_MAX * HIBYTE; ++ hibyte_mask = uword_max / UCHAR_MAX * HIBYTE; + + /* Search a byte at a time until the pointer is aligned, then a + uword at a time until a match is found, then a byte at a time to + identify the exact byte. The uword search may go slightly past + the buffer end, but that's benign. */ +- char const *p; +- uword const *s; + for (p = buf; (uintptr_t) p % sizeof (uword) != 0; p++) + if (*p & HIBYTE) + return p; +@@ -563,6 +567,7 @@ file_textbin (char *buf, 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 && eolbyte) + { ++ off_t hole_start; + off_t cur = size; + if (O_BINARY || fd == STDIN_FILENO) + { +@@ -572,7 +577,7 @@ file_textbin (char *buf, 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) +@@ -663,7 +668,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; +@@ -1130,11 +1136,13 @@ prtext (char const *beg, char const *lim) + { + static bool used; /* Avoid printing SEP_STR_GROUP before any output. */ + char eol = eolbyte; ++ char const *p; ++ intmax_t n; + + if (!out_quiet && pending > 0) + prpending (beg); + +- char const *p = beg; ++ p = beg; + + if (!out_quiet) + { +@@ -1167,7 +1175,6 @@ prtext (char const *beg, char const *lim) + } + } + +- intmax_t n; + if (out_invert) + { + /* One or more lines are output. */ +@@ -1228,6 +1235,7 @@ grepbuf (char const *beg, char const *lim) + + for (p = beg; p < lim; p = endp) + { ++ char const *b; + size_t match_size; + size_t match_offset = execute (p, lim - p, &match_size, NULL); + if (match_offset == (size_t) -1) +@@ -1237,7 +1245,7 @@ grepbuf (char const *beg, char const *lim) + match_offset = lim - p; + match_size = 0; + } +- char const *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) +@@ -2118,6 +2126,9 @@ 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; + exit_failure = EXIT_TROUBLE; + initialize_main (&argc, &argv); + set_program_name (argv[0]); +@@ -2478,7 +2489,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; + +@@ -2526,8 +2536,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); + +diff --git a/src/kwsearch.c b/src/kwsearch.c +index 1335a269cc..eddb01b520 100644 +--- a/src/kwsearch.c ++++ b/src/kwsearch.c +@@ -38,16 +38,18 @@ Fcompile (char const *pattern, size_t size) + { + size_t total = size; + mb_len_map_t *map = NULL; ++ char const *p; + char const *pat = (match_icase && MB_CUR_MAX > 1 + ? mbtoupper (pattern, &total, &map) + : pattern); + + kwsinit (&kwset); + +- char const *p = pat; ++ p = pat; + do + { + size_t len; ++ char *buf = NULL; + char const *sep = memchr (p, '\n', total); + if (sep) + { +@@ -61,7 +63,6 @@ Fcompile (char const *pattern, size_t size) + total = 0; + } + +- char *buf = NULL; + if (match_lines) + { + buf = xmalloc (len + 2); +@@ -110,6 +111,7 @@ Fexecute (char const *buf, size_t size, size_t *match_size, + char eol = eolbyte; + struct kwsmatch kwsmatch; + size_t ret_val; ++ size_t off; + mb_len_map_t *map = NULL; + + if (MB_CUR_MAX > 1) +@@ -193,7 +195,7 @@ Fexecute (char const *buf, size_t size, size_t *match_size, + --beg; + len = end - beg; + success_in_beg_and_len:; +- size_t off = beg - buf; ++ off = beg - buf; + mb_case_map_apply (map, &off, &len); + + *match_size = len; +diff --git a/src/kwset.c b/src/kwset.c +index 6d218938e7..8df7cd4fe2 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,8 +174,7 @@ 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) + { + links[depth] = link; +@@ -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) + goto big_advance; + tp--; +diff --git a/src/searchutils.c b/src/searchutils.c +index 9edc7855cd..bdb006386c 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); +-- +1.8.3.4 +