commit d1fae69c4e5e9d2d3526ce460ff1ae5e3fca350f Author: Toshaan Bharvani Date: Wed Oct 5 04:08:24 2022 +0200 initial package creation Signed-off-by: Toshaan Bharvani diff --git a/SOURCES/diffutils-3.7-coverity.patch b/SOURCES/diffutils-3.7-coverity.patch new file mode 100644 index 0000000..41d7756 --- /dev/null +++ b/SOURCES/diffutils-3.7-coverity.patch @@ -0,0 +1,315 @@ +diff -up diffutils-3.7/lib/careadlinkat.c.me diffutils-3.7/lib/careadlinkat.c +--- diffutils-3.7/lib/careadlinkat.c.me 2021-03-23 23:19:06.957542021 +0100 ++++ diffutils-3.7/lib/careadlinkat.c 2021-03-23 23:22:29.309145314 +0100 +@@ -1,6 +1,6 @@ + /* Read symbolic links into a buffer without size limitation, relative to fd. + +- Copyright (C) 2001, 2003-2004, 2007, 2009-2018 Free Software Foundation, ++ Copyright (C) 2001, 2003-2004, 2007, 2009-2021 Free Software Foundation, + Inc. + + This program is free software: you can redistribute it and/or modify +@@ -38,75 +38,64 @@ + + #include "allocator.h" + +-/* Assuming the current directory is FD, get the symbolic link value +- of FILENAME as a null-terminated string and put it into a buffer. +- If FD is AT_FDCWD, FILENAME is interpreted relative to the current +- working directory, as in openat. +- +- If the link is small enough to fit into BUFFER put it there. +- BUFFER's size is BUFFER_SIZE, and BUFFER can be null +- if BUFFER_SIZE is zero. +- +- If the link is not small, put it into a dynamically allocated +- buffer managed by ALLOC. It is the caller's responsibility to free +- the returned value if it is nonnull and is not BUFFER. A null +- ALLOC stands for the standard allocator. +- +- The PREADLINKAT function specifies how to read links. It operates +- like POSIX readlinkat() +- +- but can assume that its first argument is the same as FD. ++enum { STACK_BUF_SIZE = 1024 }; + +- If successful, return the buffer address; otherwise return NULL and +- set errno. */ ++/* Act like careadlinkat (see below), with an additional argument ++ STACK_BUF that can be used as temporary storage. + +-char * +-careadlinkat (int fd, char const *filename, ++ If GCC_LINT is defined, do not inline this function with GCC 10.1 ++ and later, to avoid creating a pointer to the stack that GCC ++ -Wreturn-local-addr incorrectly complains about. See: ++ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=93644 ++ Although the noinline attribute can hurt performance a bit, no better way ++ to pacify GCC is known; even an explicit #pragma does not pacify GCC. ++ When the GCC bug is fixed this workaround should be limited to the ++ broken GCC versions. */ ++#if __GNUC_PREREQ (10, 1) ++# if defined GCC_LINT || defined lint ++__attribute__ ((__noinline__)) ++# elif __OPTIMIZE__ && !__NO_INLINE__ ++# define GCC_BOGUS_WRETURN_LOCAL_ADDR ++# endif ++#endif ++static char * ++readlink_stk (int fd, char const *filename, + char *buffer, size_t buffer_size, + struct allocator const *alloc, +- ssize_t (*preadlinkat) (int, char const *, char *, size_t)) ++ ssize_t (*preadlinkat) (int, char const *, char *, size_t), ++ char stack_buf[STACK_BUF_SIZE]) + { + char *buf; + size_t buf_size; + size_t buf_size_max = + SSIZE_MAX < SIZE_MAX ? (size_t) SSIZE_MAX + 1 : SIZE_MAX; +- char stack_buf[1024]; + + if (! alloc) + alloc = &stdlib_allocator; + +- if (! buffer_size) ++ if (!buffer) + { +- /* Allocate the initial buffer on the stack. This way, in the +- common case of a symlink of small size, we get away with a +- single small malloc() instead of a big malloc() followed by a +- shrinking realloc(). */ + buffer = stack_buf; +- buffer_size = sizeof stack_buf; ++ buffer_size = STACK_BUF_SIZE; + } + + buf = buffer; + buf_size = buffer_size; + +- do ++ while (buf) + { + /* Attempt to read the link into the current buffer. */ + ssize_t link_length = preadlinkat (fd, filename, buf, buf_size); + size_t link_size; + if (link_length < 0) + { +- /* On AIX 5L v5.3 and HP-UX 11i v2 04/09, readlink returns -1 +- with errno == ERANGE if the buffer is too small. */ +- int readlinkat_errno = errno; +- if (readlinkat_errno != ERANGE) ++ if (buf != buffer) + { +- if (buf != buffer) +- { +- alloc->free (buf); +- errno = readlinkat_errno; +- } +- return NULL; ++ int readlinkat_errno = errno; ++ alloc->free (buf); ++ errno = readlinkat_errno; + } ++ return NULL; + } + + link_size = link_length; +@@ -117,19 +106,19 @@ careadlinkat (int fd, char const *filena + + if (buf == stack_buf) + { +- char *b = (char *) alloc->allocate (link_size); ++ char *b = alloc->allocate (link_size); + buf_size = link_size; + if (! b) + break; +- memcpy (b, buf, link_size); +- buf = b; ++ return memcpy (b, buf, link_size); + } +- else if (link_size < buf_size && buf != buffer && alloc->reallocate) ++ ++ if (link_size < buf_size && buf != buffer && alloc->reallocate) + { + /* Shrink BUF before returning it. */ +- char *b = (char *) alloc->reallocate (buf, link_size); ++ char *b = alloc->reallocate (buf, link_size); + if (b) +- buf = b; ++ return b; + } + + return buf; +@@ -138,8 +127,8 @@ careadlinkat (int fd, char const *filena + if (buf != buffer) + alloc->free (buf); + +- if (buf_size <= buf_size_max / 2) +- buf_size *= 2; ++ if (buf_size < buf_size_max / 2) ++ buf_size = 2 * buf_size + 1; + else if (buf_size < buf_size_max) + buf_size = buf_size_max; + else if (buf_size_max < SIZE_MAX) +@@ -149,12 +138,53 @@ careadlinkat (int fd, char const *filena + } + else + break; +- buf = (char *) alloc->allocate (buf_size); ++ buf = alloc->allocate (buf_size); + } +- while (buf); + + if (alloc->die) + alloc->die (buf_size); + errno = ENOMEM; + return NULL; + } ++ ++ ++/* Assuming the current directory is FD, get the symbolic link value ++ of FILENAME as a null-terminated string and put it into a buffer. ++ If FD is AT_FDCWD, FILENAME is interpreted relative to the current ++ working directory, as in openat. ++ ++ If the link is small enough to fit into BUFFER put it there. ++ BUFFER's size is BUFFER_SIZE, and BUFFER can be null ++ if BUFFER_SIZE is zero. ++ ++ If the link is not small, put it into a dynamically allocated ++ buffer managed by ALLOC. It is the caller's responsibility to free ++ the returned value if it is nonnull and is not BUFFER. A null ++ ALLOC stands for the standard allocator. ++ ++ The PREADLINKAT function specifies how to read links. It operates ++ like POSIX readlinkat() ++ ++ but can assume that its first argument is the same as FD. ++ ++ If successful, return the buffer address; otherwise return NULL and ++ set errno. */ ++ ++char * ++careadlinkat (int fd, char const *filename, ++ char *buffer, size_t buffer_size, ++ struct allocator const *alloc, ++ ssize_t (*preadlinkat) (int, char const *, char *, size_t)) ++{ ++ /* Allocate the initial buffer on the stack. This way, in the ++ common case of a symlink of small size, we get away with a ++ single small malloc instead of a big malloc followed by a ++ shrinking realloc. */ ++ #ifdef GCC_BOGUS_WRETURN_LOCAL_ADDR ++ #warning "GCC might issue a bogus -Wreturn-local-addr warning here." ++ #warning "See ." ++ #endif ++ char stack_buf[STACK_BUF_SIZE]; ++ return readlink_stk (fd, filename, buffer, buffer_size, alloc, ++ preadlinkat, stack_buf); ++} +diff -up diffutils-3.7/src/diff.c.me diffutils-3.7/src/diff.c +diff -up diffutils-3.7/src/diff.h.me diffutils-3.7/src/diff.h +--- diffutils-3.7/src/diff.h.me 2021-03-23 22:47:04.509390138 +0100 ++++ diffutils-3.7/src/diff.h 2021-03-23 22:58:35.022552755 +0100 +@@ -392,7 +392,7 @@ extern void print_sdiff_script (struct c + extern char const change_letter[4]; + extern char const pr_program[]; + extern char *concat (char const *, char const *, char const *); +-extern bool (*lines_differ) (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE; ++extern bool (*lines_differ) (char const *, size_t, char const *, size_t); + extern bool lines_differ_singlebyte (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE; + #ifdef HANDLE_MULTIBYTE + extern bool lines_differ_multibyte (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE; +diff -up diffutils-3.7/src/util.c.me diffutils-3.7/src/util.c +--- diffutils-3.7/src/util.c.me 2021-03-23 23:01:58.105168496 +0100 ++++ diffutils-3.7/src/util.c 2021-03-23 23:18:18.833918967 +0100 +@@ -1144,6 +1144,7 @@ lines_differ_singlebyte (char const *s1, + } + + #ifdef HANDLE_MULTIBYTE ++#pragma GCC diagnostic ignored "-Wmaybe-uninitialized" + # define MBC2WC(T, END, MBLENGTH, WC, STATE, CONVFAIL) \ + do \ + { \ +diff -up diffutils-3.7/lib/regcomp.c.me diffutils-3.7/lib/regcomp.c +--- diffutils-3.7/lib/regcomp.c.me 2021-03-24 09:01:20.582271604 +0100 ++++ diffutils-3.7/lib/regcomp.c 2021-03-24 09:03:54.125287605 +0100 +@@ -3674,7 +3674,6 @@ build_charclass_op (re_dfa_t *dfa, RE_TR + Idx alloc = 0; + #endif /* not RE_ENABLE_I18N */ + reg_errcode_t ret; +- re_token_t br_token; + bin_tree_t *tree; + + sbcset = (re_bitset_ptr_t) calloc (sizeof (bitset_t), 1); +@@ -3725,11 +3724,7 @@ build_charclass_op (re_dfa_t *dfa, RE_TR + #endif + + /* Build a tree for simple bracket. */ +-#if defined GCC_LINT || defined lint +- memset (&br_token, 0, sizeof br_token); +-#endif +- br_token.type = SIMPLE_BRACKET; +- br_token.opr.sbcset = sbcset; ++ re_token_t br_token = { .type = SIMPLE_BRACKET, .opr.sbcset = sbcset }; + tree = create_token_tree (dfa, NULL, NULL, &br_token); + if (__glibc_unlikely (tree == NULL)) + goto build_word_op_espace; +@@ -3820,11 +3815,7 @@ static bin_tree_t * + create_tree (re_dfa_t *dfa, bin_tree_t *left, bin_tree_t *right, + re_token_type_t type) + { +- re_token_t t; +-#if defined GCC_LINT || defined lint +- memset (&t, 0, sizeof t); +-#endif +- t.type = type; ++ re_token_t t = { .type = type }; + return create_token_tree (dfa, left, right, &t); + } + +diff -up diffutils-3.7/lib/regexec.c.me diffutils-3.7/lib/regexec.c +--- diffutils-3.7/lib/regexec.c.me 2021-03-24 08:50:16.101143023 +0100 ++++ diffutils-3.7/lib/regexec.c 2021-03-24 08:55:03.347246385 +0100 +@@ -828,7 +828,9 @@ re_search_internal (const regex_t *preg, + break; + if (__glibc_unlikely (err != REG_NOMATCH)) + goto free_return; ++#ifdef DEBUG + match_last = -1; ++#endif + } + else + break; /* We found a match. */ +@@ -3693,6 +3695,7 @@ group_nodes_into_DFAstates (const re_dfa + bitset_empty (accepts); + } + } ++ assume (ndests <= SBC_MAX); + return ndests; + error_return: + for (j = 0; j < ndests; ++j) +diff -up diffutils-3.7/lib/regex_internal.h.me diffutils-3.7/lib/regex_internal.h +--- diffutils-3.7/lib/regex_internal.h.me 2021-03-24 08:54:03.464477733 +0100 ++++ diffutils-3.7/lib/regex_internal.h 2021-03-24 08:54:22.824728618 +0100 +@@ -34,6 +34,7 @@ + #include + + #include ++#include + + #ifdef _LIBC + # include +diff -up diffutils-3.7/src/ifdef.c.me diffutils-3.7/src/ifdef.c +--- diffutils-3.7/src/ifdef.c.me 2021-03-24 18:10:43.265671781 +0100 ++++ diffutils-3.7/src/ifdef.c 2021-03-24 18:08:39.843320920 +0100 +@@ -362,7 +362,7 @@ do_printf_spec (FILE *out, char const *s + printint print_value = value; + size_t spec_prefix_len = f - spec - 2; + size_t pI_len = sizeof pI - 1; +-#if 0 ++#if HAVE_C_VARARRAYS + char format[spec_prefix_len + pI_len + 2]; + #else + char *format = xmalloc (spec_prefix_len + pI_len + 2); diff --git a/SOURCES/diffutils-3.7-false-positive.patch b/SOURCES/diffutils-3.7-false-positive.patch new file mode 100644 index 0000000..ce789b1 --- /dev/null +++ b/SOURCES/diffutils-3.7-false-positive.patch @@ -0,0 +1,73 @@ +diff -up diffutils-3.7/lib/freopen-safer.c.me diffutils-3.7/lib/freopen-safer.c +--- diffutils-3.7/lib/freopen-safer.c.me 2021-03-24 15:38:27.785170510 +0100 ++++ diffutils-3.7/lib/freopen-safer.c 2021-03-24 15:39:56.389523872 +0100 +@@ -49,6 +49,7 @@ protect_fd (int fd) + } + return false; + } ++ /* coverity[leaked_handle : FALSE] */ + return true; + } + +diff -up diffutils-3.7/lib/regex_internal.c.me diffutils-3.7/lib/regex_internal.c +--- diffutils-3.7/lib/regex_internal.c.me 2021-03-24 15:45:12.934308141 +0100 ++++ diffutils-3.7/lib/regex_internal.c 2021-03-24 15:48:06.165592478 +0100 +@@ -1724,6 +1724,7 @@ create_cd_newstate (const re_dfa_t *dfa, + } + if (re_node_set_init_copy (newstate->entrance_nodes, nodes) + != REG_NOERROR) ++ /* coverity[leaked_storage : FALSE] */ + return NULL; + nctx_nodes = 0; + newstate->has_constraint = 1; +diff -up diffutils-3.7/src/analyze.c.me diffutils-3.7/src/analyze.c +--- diffutils-3.7/src/analyze.c.me 2021-03-24 17:16:35.560137760 +0100 ++++ diffutils-3.7/src/analyze.c 2021-03-24 17:18:02.298846273 +0100 +@@ -688,6 +688,7 @@ diff_2_files (struct comparison *cmp) + for (f = 0; f < 2; f++) + { + free (cmp->file[f].equivs); ++ /* coverity[offset_free : FALSE] */ + free (cmp->file[f].linbuf + cmp->file[f].linbuf_base); + } + +diff -up diffutils-3.7/src/diff3.c.me diffutils-3.7/src/diff3.c +--- diffutils-3.7/src/diff3.c.me 2021-03-24 17:18:21.317231331 +0100 ++++ diffutils-3.7/src/diff3.c 2021-03-24 17:22:54.217398657 +0100 +@@ -795,6 +795,7 @@ using_to_diff3_block (struct diff_block + D_LINEARRAY (result, FILEC) + result_offset, + D_LENARRAY (result, FILEC) + result_offset, + D_NUMLINES (ptr, FC))) ++ /* coverity[leaked_storage : FALSE] */ + return 0; + } + +@@ -824,6 +825,7 @@ using_to_diff3_block (struct diff_block + D_LINEARRAY (result, FILE0 + d) + result_offset, + D_LENARRAY (result, FILE0 + d) + result_offset, + D_NUMLINES (ptr, FO))) ++ /* coverity[leaked_storage : FALSE] */ + return 0; + + /* Catch the lines between here and the next diff */ +diff -up diffutils-3.7/src/sdiff.c.me diffutils-3.7/src/sdiff.c +--- diffutils-3.7/src/sdiff.c.me 2021-03-24 17:24:37.022988328 +0100 ++++ diffutils-3.7/src/sdiff.c 2021-03-24 17:25:39.145495628 +0100 +@@ -1169,5 +1169,6 @@ temporary_file (void) + fd = mkstemp (buf); + if (0 <= fd) + tmpname = buf; ++ /* coverity[leaked_storage : FALSE] */ + return fd; + } +diff -up diffutils-3.7/src/util.c.me diffutils-3.7/src/util.c +--- diffutils-3.7/src/util.c.me 2021-03-24 17:25:51.419067091 +0100 ++++ diffutils-3.7/src/util.c 2021-03-24 17:36:28.882404028 +0100 +@@ -699,6 +699,7 @@ parse_diff_color (void) + } + colors_enabled = false; + } ++/* coverity[leaked_storage : FALSE] */ + } + + static void diff --git a/SOURCES/diffutils-cmp-s-empty.patch b/SOURCES/diffutils-cmp-s-empty.patch new file mode 100644 index 0000000..7fc3a18 --- /dev/null +++ b/SOURCES/diffutils-cmp-s-empty.patch @@ -0,0 +1,20 @@ +diff -up diffutils-3.6/src/cmp.c.cmp-s-empty diffutils-3.6/src/cmp.c +--- diffutils-3.6/src/cmp.c.cmp-s-empty 2017-05-18 18:39:59.000000000 +0100 ++++ diffutils-3.6/src/cmp.c 2017-05-22 10:53:28.477147864 +0100 +@@ -330,12 +330,15 @@ main (int argc, char **argv) + + /* If only a return code is needed, + and if both input descriptors are associated with plain files, ++ and if both files are larger than 0 bytes (procfs files are always 0), + conclude that the files differ if they have different sizes + and if more bytes will be compared than are in the smaller file. */ + + if (comparison_type == type_status + && S_ISREG (stat_buf[0].st_mode) +- && S_ISREG (stat_buf[1].st_mode)) ++ && S_ISREG (stat_buf[1].st_mode) ++ && stat_buf[0].st_size > 0 ++ && stat_buf[1].st_size > 0) + { + off_t s0 = stat_buf[0].st_size - file_position (0); + off_t s1 = stat_buf[1].st_size - file_position (1); diff --git a/SOURCES/diffutils-fix-gnulib-tests.patch b/SOURCES/diffutils-fix-gnulib-tests.patch new file mode 100644 index 0000000..3f62b2b --- /dev/null +++ b/SOURCES/diffutils-fix-gnulib-tests.patch @@ -0,0 +1,26 @@ +diff -up diffutils-3.7/gnulib-tests/test-perror2.c.fix-gnulib-tests diffutils-3.7/gnulib-tests/test-perror2.c +--- diffutils-3.7/gnulib-tests/test-perror2.c.fix-gnulib-tests 2018-01-07 00:45:53.000000000 +0000 ++++ diffutils-3.7/gnulib-tests/test-perror2.c 2020-10-08 14:36:15.002040558 +0100 +@@ -79,9 +79,6 @@ main (void) + errno = -5; + perror (""); + ASSERT (!ferror (stderr)); +- ASSERT (msg1 == msg2 || msg1 == msg4 || STREQ (msg1, str1)); +- ASSERT (msg2 == msg4 || STREQ (msg2, str2)); +- ASSERT (msg3 == msg4 || STREQ (msg3, str3)); + ASSERT (STREQ (msg4, str4)); + + free (str1); +diff -up diffutils-3.7/gnulib-tests/test-strerror_r.c.fix-gnulib-tests diffutils-3.7/gnulib-tests/test-strerror_r.c +--- diffutils-3.7/gnulib-tests/test-strerror_r.c.fix-gnulib-tests 2018-01-07 00:45:53.000000000 +0000 ++++ diffutils-3.7/gnulib-tests/test-strerror_r.c 2020-10-08 14:36:15.003040568 +0100 +@@ -165,9 +165,6 @@ main (void) + + strerror_r (EACCES, buf, sizeof buf); + strerror_r (-5, buf, sizeof buf); +- ASSERT (msg1 == msg2 || msg1 == msg4 || STREQ (msg1, str1)); +- ASSERT (msg2 == msg4 || STREQ (msg2, str2)); +- ASSERT (msg3 == msg4 || STREQ (msg3, str3)); + ASSERT (STREQ (msg4, str4)); + + free (str1); diff --git a/SOURCES/diffutils-i18n.patch b/SOURCES/diffutils-i18n.patch new file mode 100644 index 0000000..6d2b341 --- /dev/null +++ b/SOURCES/diffutils-i18n.patch @@ -0,0 +1,778 @@ +diff -up diffutils-3.6/src/diff.c.i18n diffutils-3.6/src/diff.c +--- diffutils-3.6/src/diff.c.i18n 2017-05-06 20:02:54.000000000 +0100 ++++ diffutils-3.6/src/diff.c 2017-05-22 10:52:21.989254674 +0100 +@@ -76,6 +76,8 @@ static void try_help (char const *, char + static void check_stdout (void); + static void usage (void); + ++bool (*lines_differ) (char const *, size_t, char const *, size_t); ++ + /* If comparing directories, compare their common subdirectories + recursively. */ + static bool recursive; +@@ -298,6 +300,13 @@ main (int argc, char **argv) + excluded = new_exclude (); + presume_output_tty = false; + ++#ifdef HANDLE_MULTIBYTE ++ if (MB_CUR_MAX > 1) ++ lines_differ = lines_differ_multibyte; ++ else ++#endif ++ lines_differ = lines_differ_singlebyte; ++ + /* Decode the options. */ + + while ((c = getopt_long (argc, argv, shortopts, longopts, NULL)) != -1) +diff -up diffutils-3.6/src/diff.h.i18n diffutils-3.6/src/diff.h +--- diffutils-3.6/src/diff.h.i18n 2017-01-01 11:22:36.000000000 +0000 ++++ diffutils-3.6/src/diff.h 2017-05-22 10:51:09.050371844 +0100 +@@ -23,6 +23,17 @@ + #include + #include + ++/* For platforms which support the ISO C ammendment 1 functionality we ++ support user-defined character classes. */ ++#if defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H ++/* Solaris 2.5 has a bug: must be included before . */ ++# include ++# include ++# if defined (HAVE_MBRTOWC) ++# define HANDLE_MULTIBYTE 1 ++# endif ++#endif ++ + /* What kind of changes a hunk contains. */ + enum changes + { +@@ -381,7 +392,11 @@ extern void print_sdiff_script (struct c + extern char const change_letter[4]; + extern char const pr_program[]; + extern char *concat (char const *, char const *, char const *); +-extern bool lines_differ (char const *, char const *) _GL_ATTRIBUTE_PURE; ++extern bool (*lines_differ) (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE; ++extern bool lines_differ_singlebyte (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE; ++#ifdef HANDLE_MULTIBYTE ++extern bool lines_differ_multibyte (char const *, size_t, char const *, size_t) _GL_ATTRIBUTE_PURE; ++#endif + extern lin translate_line_number (struct file_data const *, lin); + extern struct change *find_change (struct change *); + extern struct change *find_reverse_change (struct change *); +diff -up diffutils-3.6/src/io.c.i18n diffutils-3.6/src/io.c +--- diffutils-3.6/src/io.c.i18n 2017-01-01 11:22:36.000000000 +0000 ++++ diffutils-3.6/src/io.c 2017-05-22 10:51:09.050371844 +0100 +@@ -23,6 +23,7 @@ + #include + #include + #include ++#include + + /* Rotate an unsigned value to the left. */ + #define ROL(v, n) ((v) << (n) | (v) >> (sizeof (v) * CHAR_BIT - (n))) +@@ -215,6 +216,28 @@ slurp (struct file_data *current) + + /* Split the file into lines, simultaneously computing the equivalence + class for each line. */ ++#ifdef HANDLE_MULTIBYTE ++# define MBC2WC(P, END, MBLENGTH, WC, STATE, CONVFAIL) \ ++do \ ++ { \ ++ mbstate_t state_bak = STATE; \ ++ \ ++ CONVFAIL = 0; \ ++ MBLENGTH = mbrtowc (&WC, P, END - (char const *)P, &STATE); \ ++ \ ++ switch (MBLENGTH) \ ++ { \ ++ case (size_t)-2: \ ++ case (size_t)-1: \ ++ STATE = state_bak; \ ++ ++CONVFAIL; \ ++ /* Fall through. */ \ ++ case 0: \ ++ MBLENGTH = 1; \ ++ } \ ++ } \ ++ while (0) ++#endif + + static void + find_and_hash_each_line (struct file_data *current) +@@ -241,12 +264,300 @@ find_and_hash_each_line (struct file_dat + bool same_length_diff_contents_compare_anyway = + diff_length_compare_anyway | ig_case; + ++#ifdef HANDLE_MULTIBYTE ++ wchar_t wc; ++ size_t mblength; ++ mbstate_t state; ++ int convfail; ++ ++ memset (&state, '\0', sizeof (mbstate_t)); ++#endif ++ + while (p < suffix_begin) + { + char const *ip = p; + hash_value h = 0; + unsigned char c; + ++#ifdef HANDLE_MULTIBYTE ++ if (MB_CUR_MAX > 1) ++ { ++ wchar_t lo_wc; ++ char mbc[MB_LEN_MAX]; ++ mbstate_t state_wc; ++ ++ /* Hash this line until we find a newline. */ ++ switch (ig_white_space) ++ { ++ case IGNORE_ALL_SPACE: ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ break; ++ } ++ ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ ++ if (convfail) ++ mbc[0] = *p++; ++ else if (!iswspace (wc)) ++ { ++ bool flag = 0; ++ ++ if (ig_case) ++ { ++ lo_wc = towlower (wc); ++ if (lo_wc != wc) ++ { ++ flag = 1; ++ ++ p += mblength; ++ memset (&state_wc, '\0', sizeof(mbstate_t)); ++ mblength = wcrtomb (mbc, lo_wc, &state_wc); ++ ++ assert (mblength != (size_t)-1 && ++ mblength != (size_t)-2); ++ ++ mblength = (mblength < 1) ? 1 : mblength; ++ } ++ } ++ ++ if (!flag) ++ { ++ for (i = 0; i < mblength; i++) ++ mbc[i] = *p++; ++ } ++ } ++ else ++ { ++ p += mblength; ++ continue; ++ } ++ ++ for (i = 0; i < mblength; i++) ++ h = HASH (h, mbc[i]); ++ } ++ break; ++ ++ case IGNORE_SPACE_CHANGE: ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ break; ++ } ++ ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ ++ if (!convfail && iswspace (wc)) ++ { ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ goto hashing_done; ++ } ++ ++ p += mblength; ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ if (convfail || !iswspace (wc)) ++ break; ++ } ++ h = HASH (h, ' '); ++ } ++ ++ /* WC is now the first non-space. */ ++ if (convfail) ++ mbc[0] = *p++; ++ else ++ { ++ bool flag = 0; ++ ++ if (ignore_case) ++ { ++ lo_wc = towlower (wc); ++ if (lo_wc != wc) ++ { ++ flag = 1; ++ ++ p += mblength; ++ memset (&state_wc, '\0', sizeof(mbstate_t)); ++ mblength = wcrtomb (mbc, lo_wc, &state_wc); ++ ++ assert (mblength != (size_t)-1 && ++ mblength != (size_t)-2); ++ ++ mblength = (mblength < 1) ? 1 : mblength; ++ } ++ } ++ ++ if (!flag) ++ { ++ for (i = 0; i < mblength; i++) ++ mbc[i] = *p++; ++ } ++ } ++ ++ for (i = 0; i < mblength; i++) ++ h = HASH (h, mbc[i]); ++ } ++ break; ++ ++ case IGNORE_TAB_EXPANSION: ++ case IGNORE_TAB_EXPANSION_AND_TRAILING_SPACE: ++ case IGNORE_TRAILING_SPACE: ++ { ++ size_t column = 0; ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ break; ++ } ++ ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ ++ if (!convfail ++ && ig_white_space & IGNORE_TRAILING_SPACE ++ && iswspace (wc)) ++ { ++ char const *p1 = p; ++ while (1) ++ { ++ if (*p1 == '\n') ++ { ++ p = p1 + 1; ++ goto hashing_done; ++ } ++ ++ p1 += mblength; ++ MBC2WC (p1, suffix_begin, mblength, wc, state, convfail); ++ if (convfail || !iswspace (wc)) ++ break; ++ } ++ } ++ ++ size_t repetitions = 1; ++ bool no_convert = 0; ++ ++ if (ig_white_space & IGNORE_TAB_EXPANSION) ++ { ++ if (convfail) ++ column++; ++ else ++ switch (wc) ++ { ++ case L'\b': ++ column -= 0 < column; ++ break; ++ ++ case L'\t': ++ mbc[0] = ' '; ++ mblength = 1; ++ no_convert = 1; ++ p++; ++ assert(mblength == 1); ++ repetitions = tabsize - column % tabsize; ++ column = (column + repetitions < column ++ ? 0 ++ : column + repetitions); ++ break; ++ ++ case L'\r': ++ column = 0; ++ break; ++ ++ default: ++ column += wcwidth (wc); ++ break; ++ } ++ } ++ ++ if (ig_case) ++ { ++ lo_wc = towlower (wc); ++ if (lo_wc != wc) ++ { ++ no_convert = 1; ++ p += mblength; ++ memset (&state_wc, '\0', sizeof(mbstate_t)); ++ mblength = wcrtomb (mbc, lo_wc, &state_wc); ++ ++ assert (mblength != (size_t)-1 && ++ mblength != (size_t)-2); ++ ++ mblength = (mblength < 1) ? 1 : mblength; ++ } ++ } ++ ++ if (!no_convert) ++ for (i = 0; i < mblength; i++) ++ mbc[i] = *p++; ++ ++ do ++ { ++ for (i = 0; i < mblength; i++) ++ h = HASH (h, mbc[i]); ++ } ++ while (--repetitions != 0); ++ } ++ } ++ break; ++ ++ default: ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ break; ++ } ++ ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ ++ if (convfail) ++ mbc[0] = *p++; ++ else ++ { ++ int flag = 0; ++ ++ if (ig_case) ++ { ++ lo_wc = towlower (wc); ++ if (lo_wc != wc) ++ { ++ flag = 1; ++ p += mblength; ++ memset (&state_wc, '\0', sizeof(mbstate_t)); ++ mblength = wcrtomb (mbc, lo_wc, &state_wc); ++ ++ assert (mblength != (size_t)-1 && ++ mblength != (size_t)-2); ++ ++ mblength = (mblength < 1) ? 1 : mblength; ++ } ++ } ++ ++ if (!flag) ++ { ++ for (i = 0; i < mblength; i++) ++ mbc[i] = *p++; ++ } ++ } ++ ++ for (i = 0; i < mblength; i++) ++ h = HASH (h, mbc[i]); ++ } ++ } ++ } ++ else ++#endif ++ + /* Hash this line until we find a newline. */ + switch (ig_white_space) + { +@@ -397,7 +708,7 @@ find_and_hash_each_line (struct file_dat + else if (!diff_length_compare_anyway) + continue; + +- if (! lines_differ (eqline, ip)) ++ if (! lines_differ (eqline, eqs[i].length + 1, ip, length + 1)) + break; + } + +diff -up diffutils-3.6/src/util.c.i18n diffutils-3.6/src/util.c +--- diffutils-3.6/src/util.c.i18n 2017-05-18 18:39:59.000000000 +0100 ++++ diffutils-3.6/src/util.c 2017-05-22 10:51:09.050371844 +0100 +@@ -985,7 +985,8 @@ finish_output (void) + Return nonzero if the lines differ. */ + + bool +-lines_differ (char const *s1, char const *s2) ++lines_differ_singlebyte (char const *s1, size_t s1len, ++ char const *s2, size_t s2len) + { + register char const *t1 = s1; + register char const *t2 = s2; +@@ -1141,6 +1142,354 @@ lines_differ (char const *s1, char const + + return true; + } ++ ++#ifdef HANDLE_MULTIBYTE ++# define MBC2WC(T, END, MBLENGTH, WC, STATE, CONVFAIL) \ ++do \ ++ { \ ++ mbstate_t bak = STATE; \ ++ \ ++ CONVFAIL = 0; \ ++ MBLENGTH = mbrtowc (&WC, T, END - T, &STATE); \ ++ \ ++ switch (MBLENGTH) \ ++ { \ ++ case (size_t)-2: \ ++ case (size_t)-1: \ ++ STATE = bak; \ ++ ++CONVFAIL; \ ++ /* Fall through. */ \ ++ case 0: \ ++ MBLENGTH = 1; \ ++ } \ ++ } \ ++ while (0) ++ ++bool ++lines_differ_multibyte (char const *s1, size_t s1len, ++ char const *s2, size_t s2len) ++{ ++ char const *end1, *end2; ++ char c1, c2; ++ wchar_t wc1, wc2, wc1_bak, wc2_bak; ++ size_t mblen1, mblen2; ++ mbstate_t state1, state2, state1_bak, state2_bak; ++ int convfail1, convfail2, convfail1_bak, convfail2_bak; ++ ++ char const *t1 = s1; ++ char const *t2 = s2; ++ char const *t1_bak, *t2_bak; ++ size_t column = 0; ++ ++ if (ignore_white_space == IGNORE_NO_WHITE_SPACE && !ignore_case) ++ { ++ while (*t1 != '\n') ++ if (*t1++ != *t2++) ++ return 1; ++ return 0; ++ } ++ ++ end1 = t1 + s1len; ++ end2 = t2 + s2len; ++ ++ memset (&state1, '\0', sizeof (mbstate_t)); ++ memset (&state2, '\0', sizeof (mbstate_t)); ++ ++ while (1) ++ { ++ c1 = *t1; ++ c2 = *t2; ++ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1); ++ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2); ++ ++ /* Test for exact char equality first, since it's a common case. */ ++ if (convfail1 ^ convfail2) ++ break; ++ else if (convfail1 && convfail2 && c1 != c2) ++ break; ++ else if (!convfail1 && !convfail2 && wc1 != wc2) ++ { ++ switch (ignore_white_space) ++ { ++ case IGNORE_ALL_SPACE: ++ /* For -w, just skip past any white space. */ ++ while (1) ++ { ++ if (convfail1) ++ break; ++ else if (wc1 == L'\n' || !iswspace (wc1)) ++ break; ++ ++ t1 += mblen1; ++ c1 = *t1; ++ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1); ++ } ++ ++ while (1) ++ { ++ if (convfail2) ++ break; ++ else if (wc2 == L'\n' || !iswspace (wc2)) ++ break; ++ ++ t2 += mblen2; ++ c2 = *t2; ++ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2); ++ } ++ t1 += mblen1; ++ t2 += mblen2; ++ break; ++ ++ case IGNORE_SPACE_CHANGE: ++ /* For -b, advance past any sequence of white space in ++ line 1 and consider it just one space, or nothing at ++ all if it is at the end of the line. */ ++ if (wc1 != L'\n' && iswspace (wc1)) ++ { ++ size_t mblen_bak; ++ mbstate_t state_bak; ++ ++ do ++ { ++ t1 += mblen1; ++ mblen_bak = mblen1; ++ state_bak = state1; ++ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1); ++ } ++ while (!convfail1 && (wc1 != L'\n' && iswspace (wc1))); ++ ++ state1 = state_bak; ++ mblen1 = mblen_bak; ++ t1 -= mblen1; ++ convfail1 = 0; ++ wc1 = L' '; ++ } ++ ++ /* Likewise for line 2. */ ++ if (wc2 != L'\n' && iswspace (wc2)) ++ { ++ size_t mblen_bak; ++ mbstate_t state_bak; ++ ++ do ++ { ++ t2 += mblen2; ++ mblen_bak = mblen2; ++ state_bak = state2; ++ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2); ++ } ++ while (!convfail2 && (wc2 != L'\n' && iswspace (wc2))); ++ ++ state2 = state_bak; ++ mblen2 = mblen_bak; ++ t2 -= mblen2; ++ convfail2 = 0; ++ wc2 = L' '; ++ } ++ ++ if (wc1 != wc2) ++ { ++ /* If we went too far when doing the simple test for ++ equality, go back to the first non-whitespace ++ character in both sides and try again. */ ++ if (wc2 == L' ' && wc1 != L'\n' && ++ t1 > s1 && ++ !convfail1_bak && iswspace (wc1_bak)) ++ { ++ t1 = t1_bak; ++ wc1 = wc1_bak; ++ state1 = state1_bak; ++ convfail1 = convfail1_bak; ++ continue; ++ } ++ if (wc1 == L' ' && wc2 != L'\n' ++ && t2 > s2 ++ && !convfail2_bak && iswspace (wc2_bak)) ++ { ++ t2 = t2_bak; ++ wc2 = wc2_bak; ++ state2 = state2_bak; ++ convfail2 = convfail2_bak; ++ continue; ++ } ++ } ++ ++ t1_bak = t1; t2_bak = t2; ++ wc1_bak = wc1; wc2_bak = wc2; ++ state1_bak = state1; state2_bak = state2; ++ convfail1_bak = convfail1; convfail2_bak = convfail2; ++ ++ if (wc1 == L'\n') ++ wc1 = L' '; ++ else ++ t1 += mblen1; ++ ++ if (wc2 == L'\n') ++ wc2 = L' '; ++ else ++ t2 += mblen2; ++ ++ break; ++ ++ case IGNORE_TRAILING_SPACE: ++ case IGNORE_TAB_EXPANSION_AND_TRAILING_SPACE: ++ if (iswspace (wc1) && iswspace (wc2)) ++ { ++ char const *p; ++ wchar_t wc; ++ size_t mblength; ++ int convfail; ++ mbstate_t state; ++ bool just_whitespace_left = 1; ++ if (wc1 != L'\n') ++ { ++ mblength = mblen1; ++ p = t1; ++ memset (&state, '\0', sizeof(mbstate_t)); ++ while (p < end1) ++ { ++ if (*p == '\n') ++ break; ++ ++ p += mblength; ++ MBC2WC (p, end1, mblength, wc, state, convfail); ++ if (convfail || !iswspace (wc)) ++ { ++ just_whitespace_left = 0; ++ break; ++ } ++ } ++ } ++ if (just_whitespace_left && wc2 != L'\n') ++ { ++ mblength = mblen2; ++ p = t2; ++ memset (&state, '\0', sizeof(mbstate_t)); ++ while (p < end2) ++ { ++ if (*p == '\n') ++ break; ++ ++ p += mblength; ++ MBC2WC (p, end2, mblength, wc, state, convfail); ++ if (convfail || !iswspace (wc)) ++ { ++ just_whitespace_left = 0; ++ break; ++ } ++ } ++ } ++ ++ if (just_whitespace_left) ++ /* Both lines have nothing but whitespace left. */ ++ return false; ++ } ++ ++ if (ignore_white_space == IGNORE_TRAILING_SPACE) ++ break; ++ /* Fall through. */ ++ case IGNORE_TAB_EXPANSION: ++ if ((wc1 == L' ' && wc2 == L'\t') ++ || (wc1 == L'\t' && wc2 == L' ')) ++ { ++ size_t column2 = column; ++ ++ while (1) ++ { ++ if (convfail1) ++ { ++ ++t1; ++ break; ++ } ++ else if (wc1 == L' ') ++ column++; ++ else if (wc1 == L'\t') ++ column += tabsize - column % tabsize; ++ else ++ { ++ t1 += mblen1; ++ break; ++ } ++ ++ t1 += mblen1; ++ c1 = *t1; ++ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1); ++ } ++ ++ while (1) ++ { ++ if (convfail2) ++ { ++ ++t2; ++ break; ++ } ++ else if (wc2 == L' ') ++ column2++; ++ else if (wc2 == L'\t') ++ column2 += tabsize - column2 % tabsize; ++ else ++ { ++ t2 += mblen2; ++ break; ++ } ++ ++ t2 += mblen2; ++ c2 = *t2; ++ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2); ++ } ++ ++ if (column != column2) ++ return 1; ++ } ++ else ++ { ++ t1 += mblen1; ++ t2 += mblen2; ++ } ++ break; ++ ++ case IGNORE_NO_WHITE_SPACE: ++ t1 += mblen1; ++ t2 += mblen2; ++ break; ++ } ++ ++ /* Lowercase all letters if -i is specified. */ ++ if (ignore_case) ++ { ++ if (!convfail1) ++ wc1 = towlower (wc1); ++ if (!convfail2) ++ wc2 = towlower (wc2); ++ } ++ ++ if (convfail1 ^ convfail2) ++ break; ++ else if (convfail1 && convfail2 && c1 != c2) ++ break; ++ else if (!convfail1 && !convfail2 && wc1 != wc2) ++ break; ++ } ++ else ++ { ++ t1_bak = t1; t2_bak = t2; ++ wc1_bak = wc1; wc2_bak = wc2; ++ state1_bak = state1; state2_bak = state2; ++ convfail1_bak = convfail1; convfail2_bak = convfail2; ++ ++ t1 += mblen1; t2 += mblen2; ++ } ++ ++ if (!convfail1 && wc1 == L'\n') ++ return 0; ++ ++ column += convfail1 ? 1 : ++ (wc1 == L'\t') ? tabsize - column % tabsize : wcwidth (wc1); ++ } ++ ++ return 1; ++} ++#endif + + /* Find the consecutive changes at the start of the script START. + Return the last link before the first gap. */ diff --git a/SOURCES/diffutils-sigstksz.patch b/SOURCES/diffutils-sigstksz.patch new file mode 100644 index 0000000..a632343 --- /dev/null +++ b/SOURCES/diffutils-sigstksz.patch @@ -0,0 +1,25 @@ +diff -up diffutils-3.7/lib/c-stack.c.sigstksz diffutils-3.7/lib/c-stack.c +--- diffutils-3.7/lib/c-stack.c.sigstksz 2021-04-12 10:58:48.892279388 +0100 ++++ diffutils-3.7/lib/c-stack.c 2021-04-12 11:04:59.488695551 +0100 +@@ -52,12 +52,18 @@ typedef struct sigaltstack stack_t; + #endif + #ifndef SIGSTKSZ + # define SIGSTKSZ 16384 +-#elif HAVE_LIBSIGSEGV && SIGSTKSZ < 16384 ++#elif HAVE_LIBSIGSEGV + /* libsigsegv 2.6 through 2.8 have a bug where some architectures use + more than the Linux default of an 8k alternate stack when deciding + if a fault was caused by stack overflow. */ +-# undef SIGSTKSZ +-# define SIGSTKSZ 16384 ++# if defined _SC_SIGSTKSZ && _SC_SIGSTKSZ < 16384 ++ /* glibc 2.34 defines SIGSTKSZ to sysconf (_SC_SIGSTKSZ) */ ++# undef SIGSTKSZ ++# define SIGSTKSZ 16384 ++# elif SIGSTKSZ < 16384 ++# undef SIGSTKSZ ++# define SIGSTKSZ 16384 ++# endif + #endif + + #include diff --git a/SPECS/diffutils.spec b/SPECS/diffutils.spec new file mode 100644 index 0000000..bba010a --- /dev/null +++ b/SPECS/diffutils.spec @@ -0,0 +1,394 @@ +Summary: GNU collection of diff utilities +Name: diffutils +Version: 3.7 +Release: 12%{?dist} +URL: https://www.gnu.org/software/diffutils/diffutils.html +Source: https://ftp.gnu.org/gnu/diffutils/diffutils-%{version}.tar.xz +Patch1: diffutils-cmp-s-empty.patch +Patch2: diffutils-i18n.patch +Patch3: diffutils-fix-gnulib-tests.patch +Patch4: diffutils-3.7-coverity.patch +Patch5: diffutils-3.7-false-positive.patch +Patch6: diffutils-sigstksz.patch +License: GPLv3+ +Provides: bundled(gnulib) +BuildRequires: gcc +BuildRequires: help2man +BuildRequires: autoconf, automake, texinfo +BuildRequires: make + +%description +Diffutils includes four utilities: diff, cmp, diff3 and sdiff. Diff +compares two files and shows the differences, line by line. The cmp +command shows the offset and line numbers where two files differ, or +cmp can show the characters that differ between the two files. The +diff3 command shows the differences between three files. Diff3 can be +used when two people have made independent changes to a common +original; diff3 can produce a merged file that contains both sets of +changes and warnings about conflicts. The sdiff command can be used +to merge two files interactively. + +Install diffutils if you need to compare text files. + +%prep +%autosetup -p1 + +# Run autoreconf for aarch64 support (bug #925256). +autoreconf + +%build +%global optflags %{optflags} -Dlint +%configure +make PR_PROGRAM=%{_bindir}/pr + +%install +%make_install + +rm -f $RPM_BUILD_ROOT%{_infodir}/dir +%find_lang %{name} + +%check +# Disable update-copyright gnulib test (bug #1239428). +>gnulib-tests/test-update-copyright.sh +make check + +%files -f %{name}.lang +%doc NEWS README +%license COPYING +%{_bindir}/* +%{_mandir}/*/* +%{_infodir}/diffutils.info* + +%changelog +* Mon Aug 09 2021 Mohan Boddu - 3.7-12 +- Rebuilt for IMA sigs, glibc 2.34, aarch64 flags + Related: rhbz#1991688 + +* Wed Jun 23 2021 Than Ngo - 3.7-11 +- Resolves: #1975121, Handle SIGSTKSZ no longer being a constant. + +* Thu Apr 15 2021 Mohan Boddu - 3.7-10 +- Rebuilt for RHEL 9 BETA on Apr 15th 2021. Related: rhbz#1947937 + +* Wed Mar 24 2021 Than Ngo - 3.7-9 +- Fix coverity issues + +* Tue Jan 26 2021 Fedora Release Engineering - 3.7-8 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_34_Mass_Rebuild + +* Thu Oct 8 2020 Tim Waugh - 3.7-7 +- Fix from gnulib upstream, commit 175e0bc (bug #1863423). + +* Sat Aug 01 2020 Fedora Release Engineering - 3.7-6 +- Second attempt - Rebuilt for + https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Mon Jul 27 2020 Fedora Release Engineering - 3.7-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_33_Mass_Rebuild + +* Tue Jan 28 2020 Fedora Release Engineering - 3.7-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_32_Mass_Rebuild + +* Wed Jul 24 2019 Fedora Release Engineering - 3.7-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_31_Mass_Rebuild + +* Thu Jan 31 2019 Fedora Release Engineering - 3.7-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_30_Mass_Rebuild + +* Mon Jan 07 2019 Than Ngo - 3.7-1 +- 3.7 + +* Thu Jul 12 2018 Fedora Release Engineering - 3.6-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_29_Mass_Rebuild + +* Wed Feb 07 2018 Fedora Release Engineering - 3.6-4 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_28_Mass_Rebuild + +* Wed Aug 02 2017 Fedora Release Engineering - 3.6-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Binutils_Mass_Rebuild + +* Wed Jul 26 2017 Fedora Release Engineering - 3.6-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_27_Mass_Rebuild + +* Mon May 22 2017 Tim Waugh - 3.6-1 +- 3.6 (bug #1453019). + +* Tue Feb 21 2017 Than Ngo - 3.5-3 +- backport to fix FTBFs with GCC 7 + +* Fri Feb 10 2017 Fedora Release Engineering - 3.5-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_26_Mass_Rebuild + +* Wed Sep 21 2016 Tim Waugh - 3.5-1 +- 3.5 (bug #1365325). + +* Wed Feb 03 2016 Fedora Release Engineering - 3.3-13 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_24_Mass_Rebuild + +* Mon Jul 6 2015 Tim Waugh - 3.3-12 +- Disable update-copyright gnulib test (bug #1239428). + +* Wed Jun 17 2015 Fedora Release Engineering - 3.3-11 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_23_Mass_Rebuild + +* Sat Feb 21 2015 Till Maas - 3.3-10 +- Rebuilt for Fedora 23 Change + https://fedoraproject.org/wiki/Changes/Harden_all_packages_with_position-independent_code + +* Sat Aug 16 2014 Fedora Release Engineering - 3.3-9 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_22_Mass_Rebuild + +* Fri Jul 11 2014 Tom Callaway - 3.3-8 +- fix license handling + +* Sat Jun 07 2014 Fedora Release Engineering - 3.3-7 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_21_Mass_Rebuild + +* Thu Mar 27 2014 Tim Waugh 3.3-6 +- Fix --help output and man page (bug #1079076). + +* Wed Dec 4 2013 Tim Waugh 3.3-5 +- Applied upstream gnulib patch to avoid -Wformat-security warning + (bug #1037038). + +* Wed Oct 23 2013 Tim Waugh 3.3-4 +- Fixed multibyte handling logic for diff -Z (bug #1012075). + +* Sat Aug 03 2013 Fedora Release Engineering - 3.3-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Mon Apr 29 2013 Tim Waugh 3.3-2 +- Run autoreconf for aarch64 support (bug #925256). + +* Tue Mar 26 2013 Tim Waugh 3.3-1 +- 3.3 (bug #927560). + +* Fri Feb 22 2013 Tim Waugh 3.2-13 +- Fixed i18n handling of 'diff -E' (bug #914666). + +* Wed Feb 13 2013 Fedora Release Engineering - 3.2-12 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Fri Oct 26 2012 Tim Waugh 3.2-11 +- Ported i18n patch and reinstated it (bug #870460). + +* Wed Sep 19 2012 Tim Waugh 3.2-10 +- Fixed license as current source says GPLv3+. + +* Mon Jul 23 2012 Tim Waugh 3.2-9 +- Fixed build failure. + +* Wed Jul 18 2012 Fedora Release Engineering - 3.2-8 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Mon May 21 2012 Tim Waugh 3.2-7 +- Provides bundled(gnulib) (bug #821751). + +* Fri Jan 13 2012 Fedora Release Engineering - 3.2-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild + +* Thu Dec 8 2011 Tim Waugh 3.2-5 +- Fix bug #747969 again. + +* Tue Nov 29 2011 Tim Waugh 3.2-4 +- Real fix for bug #747969: the diffutils info file changed name in + 3.1. Updated the scriptlets to install/remove the correct filename + from the info directory. + +* Fri Nov 25 2011 Tim Waugh 3.2-3 +- Fixed up reference to info page in man pages (bug #747969). + +* Fri Nov 25 2011 Tim Waugh 3.2-2 +- Applied upstream gnulib fix for float test on ppc, as well as + correction for LDBL_MANT_DIG definition (bug #733536). + +* Fri Sep 2 2011 Tim Waugh 3.2-1 +- 3.2. + +* Thu Aug 11 2011 Tim Waugh 3.1-1 +- 3.1. + +* Wed Apr 13 2011 Tim Waugh 3.0-1 +- 3.0 (bug #566482). +- The i18n patch is dropped for the time being. + +* Tue Feb 08 2011 Fedora Release Engineering - 2.8.1-30 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Fri Jun 25 2010 Tim Waugh 2.8.1-29 +- For 'cmp -s', compare file sizes only if both non-zero (bug #563618). + +* Wed Apr 21 2010 Tim Waugh - 2.8.1-28 +- Build requires help2man (bug #577325). Fixes empty diff man page. + +* Wed Mar 3 2010 Tim Waugh - 2.8.1-27 +- Added comments for all patches. + +* Wed Mar 3 2010 Tim Waugh - 2.8.1-26 +- Use upstream man pages. +- Ship COPYING file. + +* Tue Aug 11 2009 Tim Waugh 2.8.1-25 +- Only try to install the info file if it exists so that package + installation does not fail with --excludedocs (bug #515919). + +* Fri Jul 24 2009 Fedora Release Engineering - 2.8.1-24 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Tue Feb 24 2009 Fedora Release Engineering - 2.8.1-23 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Fri Feb 13 2009 Tim Waugh 2.8.1-22 +- Fixed 'sdiff -E' (bug #484892). + +* Wed Feb 13 2008 Tim Waugh 2.8.1-21 +- Rebuild for GCC 4.3. + +* Wed Jan 2 2008 Tim Waugh 2.8.1-20 +- Converted spec file to UTF-8 (bug #225696). +- Fixed summary (bug #225696). +- Fixed PreReq (bug #225696). +- Removed Prefix (bug #225696). +- Fixed build root (bug #225696). +- Avoid %%makeinstall (bug #225696). +- Fixed license tag (bug #225696). + +* Tue Nov 6 2007 Tim Waugh 2.8.1-19 +- Rebuilt. + +* Tue Nov 6 2007 Tim Waugh 2.8.1-18 +- Fixed multibyte speed improvement patch (bug #363831). + +* Tue Aug 14 2007 Tim Waugh 2.8.1-17 +- Multibyte speed improvement (bug #252117). + +* Mon Jan 22 2007 Tim Waugh 2.8.1-16 +- Make scriptlet unconditionally succeed (bug #223683). + +* Wed Jul 12 2006 Jesse Keating - 2.8.1-15.2.2 +- rebuild + +* Fri Feb 10 2006 Jesse Keating - 2.8.1-15.2.1 +- bump again for double-long bug on ppc(64) + +* Tue Feb 07 2006 Jesse Keating - 2.8.1-15.2 +- rebuilt for new gcc4.1 snapshot and glibc changes + +* Fri Dec 09 2005 Jesse Keating +- rebuilt + +* Wed Apr 6 2005 Tim Waugh 2.8.1-15 +- Fixed sdiff exit code handling (bug #152967). + +* Wed Mar 2 2005 Tim Waugh 2.8.1-14 +- Rebuild for new GCC. + +* Wed Feb 9 2005 Tim Waugh 2.8.1-13 +- Rebuilt. + +* Tue Jun 15 2004 Elliot Lee +- rebuilt + +* Fri Feb 13 2004 Elliot Lee +- rebuilt + +* Thu Jan 8 2004 Tim Waugh 2.8.1-10 +- Fix mistaken use of '|' instead of '||'. + +* Sat Oct 25 2003 Tim Waugh 2.8.1-9 +- Rebuilt. + +* Tue Jun 17 2003 Tim Waugh 2.8.1-8 +- Rebuilt. + +* Wed Jun 04 2003 Elliot Lee +- rebuilt + +* Wed Jan 22 2003 Tim Powers +- rebuilt + +* Tue Nov 19 2002 Tim Waugh 2.8.1-5 +- i18n patch. + +* Tue Oct 22 2002 Tim Waugh 2.8.1-4 +- Ship translations. + +* Fri Jun 21 2002 Tim Powers +- automated rebuild + +* Thu May 23 2002 Tim Powers +- automated rebuild + +* Mon Apr 22 2002 Tim Waugh 2.8.1-1 +- 2.8.1. +- No longer need immunix-owl-tmp patch. + +* Wed Feb 27 2002 Tim Waugh 2.7.2-5 +- Rebuild in new environment. + +* Wed Jan 09 2002 Tim Powers +- automated rebuild + +* Fri Nov 02 2001 Tim Waugh 2.7.2-3 +- Make sure %%post scriplet doesn't fail if --excludedocs is used. + +* Fri Jun 01 2001 Tim Waugh 2.7.2-2 +- Install diff.1, since it's no longer in man-pages. + +* Fri Mar 30 2001 Tim Waugh 2.7.2-1 +- 2.7.2. + +* Wed Jul 12 2000 Prospector +- automatic rebuild + +* Thu Jul 06 2000 Trond Eivind Glomsrød +- fix %%changelog entries (escape them) +- update source location +- remove manual stripping +- add URL + +* Tue Jun 06 2000 Than Ngo +- add %%defattr +- use rpm macros + +* Wed May 31 2000 Ngo Than +- put man pages and info files in correct place +- cleanup specfile + +* Thu Feb 03 2000 Preston Brown +- rebuild to gzip man pages. + +* Mon Apr 19 1999 Jeff Johnson +- man pages not in %%files. +- but avoid conflict for diff.1 + +* Sun Mar 21 1999 Cristian Gafton +- auto rebuild in the new build environment (release 14) + +* Sun Mar 14 1999 Jeff Johnson +- add man pages (#831). +- add %%configure and Prefix. + +* Thu Dec 17 1998 Cristian Gafton +- build for glibc 2.1 + +* Tue Jul 14 1998 Bill Kawakami +- included the four man pages stolen from Slackware + +* Tue May 05 1998 Prospector System +- translations modified for de, fr, tr + +* Sun May 03 1998 Cristian Gafton +- fixed spec file to reference/use the $RPM_BUILD_ROOT always + +* Wed Dec 31 1997 Otto Hammersmith +- fixed where it looks for 'pr' (/usr/bin, rather than /bin) + +* Fri Oct 17 1997 Donnie Barnes +- added BuildRoot + +* Sun Sep 14 1997 Erik Troan +- uses install-info + +* Mon Jun 02 1997 Erik Troan +- built against glibc