From 9778ec992d9a4a25a8b71d83034ad0ef796f0018 Mon Sep 17 00:00:00 2001 From: Tim Waugh Date: Mar 26 2013 11:27:03 +0000 Subject: 3.3 (bug #927560). Resolves: rhbz#927560 --- diff --git a/.gitignore b/.gitignore index e3f3c54..c8f81e9 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ diffutils-2.8.1.tar.gz /diffutils-3.0.tar.xz /diffutils-3.1.tar.xz /diffutils-3.2.tar.xz +/diffutils-3.3.tar.xz diff --git a/diffutils-3.2-i18n.patch b/diffutils-3.2-i18n.patch deleted file mode 100644 index 2d1eeb2..0000000 --- a/diffutils-3.2-i18n.patch +++ /dev/null @@ -1,780 +0,0 @@ -diff -up diffutils-3.2/src/diff.c.i18n diffutils-3.2/src/diff.c ---- diffutils-3.2/src/diff.c.i18n 2011-08-15 06:24:38.000000000 +0100 -+++ diffutils-3.2/src/diff.c 2012-10-26 18:23:47.495735160 +0100 -@@ -73,6 +73,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; -@@ -286,6 +288,13 @@ main (int argc, char **argv) - re_set_syntax (RE_SYNTAX_GREP | RE_NO_POSIX_BACKTRACKING); - excluded = new_exclude (); - -+#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.2/src/diff.h.i18n diffutils-3.2/src/diff.h ---- diffutils-3.2/src/diff.h.i18n 2011-08-15 06:25:26.000000000 +0100 -+++ diffutils-3.2/src/diff.h 2012-10-26 18:23:47.495735160 +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 - { -@@ -361,7 +372,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 *); -+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); -+#ifdef HANDLE_MULTIBYTE -+extern bool lines_differ_multibyte (char const *, size_t, char const *, size_t); -+#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.2/src/io.c.i18n diffutils-3.2/src/io.c ---- diffutils-3.2/src/io.c.i18n 2011-08-15 06:24:38.000000000 +0100 -+++ diffutils-3.2/src/io.c 2013-02-22 14:05:48.700990339 +0000 -@@ -22,6 +22,7 @@ - #include - #include - #include -+#include - - /* Rotate an unsigned value to the left. */ - #define ROL(v, n) ((v) << (n) | (v) >> (sizeof (v) * CHAR_BIT - (n))) -@@ -194,6 +195,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) -@@ -220,12 +243,302 @@ 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; -+ goto hashing_done; -+ } -+ -+ p1 += mblength; -+ MBC2WC (p1, suffix_begin, mblength, wc, state, convfail); -+ if (convfail || !iswspace (wc)) -+ break; -+ } -+ } -+ -+ size_t repetitions = 1; -+ -+ if (ig_white_space & IGNORE_TAB_EXPANSION) -+ { -+ bool flag = 0; -+ if (convfail) -+ column++; -+ else -+ switch (wc) -+ { -+ case L'\b': -+ column -= 0 < column; -+ break; -+ -+ case L'\t': -+ mbc[0] = ' '; -+ mblength = 1; -+ flag = 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) -+ { -+ 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++; -+ } -+ } -+ -+ 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) - { -@@ -376,7 +689,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.2/src/util.c.i18n diffutils-3.2/src/util.c ---- diffutils-3.2/src/util.c.i18n 2011-08-15 06:24:38.000000000 +0100 -+++ diffutils-3.2/src/util.c 2012-10-26 18:23:47.496735164 +0100 -@@ -317,7 +317,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; -@@ -473,6 +474,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/diffutils-3.2.tar.xz.sig b/diffutils-3.2.tar.xz.sig deleted file mode 100644 index d93f840..0000000 --- a/diffutils-3.2.tar.xz.sig +++ /dev/null @@ -1,17 +0,0 @@ ------BEGIN PGP SIGNATURE----- -Version: GnuPG v1.4.11 (GNU/Linux) - -iQIcBAABCAAGBQJOYPXJAAoJEH/Z/MsAC+7uxAwP/3GXgtb768UHYBBUBk+8e9ZC -vsoE3kxUwHPu1vPXHwoFPtsAqVtwKs8UEdpOBN4yrO0z7Nm1ELn58AfrfPuweflv -dJqsSVAt1lGxe596oS1+WXXKjjV6t27KVfJOypsYgqpJ5CAbjEjmeciYCa7N3MH4 -KMaIX1zxOOmBiqm2SI/Uv+1ub1Bjcr7s2E2+8Y/ufmPRYsd0ushK+mHNDE/OoySn -qByLTqbU93vJzBDvdfqG9z0e8JZmVAcdHU1Z4EDISV4L6eBORUDlroBCOVwIA+qm -c9yGA9OfWy2ThAZpeBcrd/eOus/Rx3U6znPpCwPmcaAUCLJKT3O4VU5NDPSm5/xX -1vO0lcIj3iJS0AcsHI+jWjKmuufxnWT9X9vPrpwPP47V8EfNk/zJkX8yfAT8GBqv -+LF1NOfaguvZhaIz7yIwJKB1WU5G2IImuYDNU1l/NxPKad498sGuL3UxqWVznHL/ -fB1mn1PQOimL48GvfuOqfw4GXGpN9YLF6fXlfjOAMDExzuuOr/nZbePvNNEjzHgK -iAlc/nHUlguBqfpEGqTjrSnT6akBHelnWjGx+/s7H7zsjAuE38IAyacxPQAEq0D9 -sbaGnutDARrTVo70eIp6rdrZzcuWCtWs46Au35qPtW8m6dFJLkQDpCzIXBvj3Kff -I5UeFwrX6rRqqSD+IFpn -=ngbK ------END PGP SIGNATURE----- diff --git a/diffutils-i18n.patch b/diffutils-i18n.patch new file mode 100644 index 0000000..8fcb66e --- /dev/null +++ b/diffutils-i18n.patch @@ -0,0 +1,780 @@ +diff -up diffutils-3.3/src/diff.c.i18n diffutils-3.3/src/diff.c +--- diffutils-3.3/src/diff.c.i18n 2013-02-02 04:39:05.000000000 +0000 ++++ diffutils-3.3/src/diff.c 2013-03-26 09:40:26.213878482 +0000 +@@ -74,6 +74,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; +@@ -285,6 +287,13 @@ main (int argc, char **argv) + re_set_syntax (RE_SYNTAX_GREP | RE_NO_POSIX_BACKTRACKING); + excluded = new_exclude (); + ++#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.3/src/diff.h.i18n diffutils-3.3/src/diff.h +--- diffutils-3.3/src/diff.h.i18n 2013-02-02 04:39:05.000000000 +0000 ++++ diffutils-3.3/src/diff.h 2013-03-26 09:42:32.941357743 +0000 +@@ -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 + { +@@ -365,7 +376,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.3/src/io.c.i18n diffutils-3.3/src/io.c +--- diffutils-3.3/src/io.c.i18n 2013-02-02 04:39:05.000000000 +0000 ++++ diffutils-3.3/src/io.c 2013-03-26 09:40:26.215878488 +0000 +@@ -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))) +@@ -208,6 +209,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) +@@ -234,12 +257,302 @@ 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; ++ goto hashing_done; ++ } ++ ++ p1 += mblength; ++ MBC2WC (p1, suffix_begin, mblength, wc, state, convfail); ++ if (convfail || !iswspace (wc)) ++ break; ++ } ++ } ++ ++ size_t repetitions = 1; ++ ++ if (ig_white_space & IGNORE_TAB_EXPANSION) ++ { ++ bool flag = 0; ++ if (convfail) ++ column++; ++ else ++ switch (wc) ++ { ++ case L'\b': ++ column -= 0 < column; ++ break; ++ ++ case L'\t': ++ mbc[0] = ' '; ++ mblength = 1; ++ flag = 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) ++ { ++ 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++; ++ } ++ } ++ ++ 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) + { +@@ -390,7 +703,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.3/src/util.c.i18n diffutils-3.3/src/util.c +--- diffutils-3.3/src/util.c.i18n 2013-02-02 04:39:05.000000000 +0000 ++++ diffutils-3.3/src/util.c 2013-03-26 09:40:26.215878488 +0000 +@@ -408,7 +408,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; +@@ -564,6 +565,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/diffutils-mkdir_p.patch b/diffutils-mkdir_p.patch new file mode 100644 index 0000000..78d29eb --- /dev/null +++ b/diffutils-mkdir_p.patch @@ -0,0 +1,12 @@ +diff -up diffutils-3.3/po/Makefile.in.in.mkdir_p diffutils-3.3/po/Makefile.in.in +--- diffutils-3.3/po/Makefile.in.in.mkdir_p 2013-03-26 11:25:58.869375066 +0000 ++++ diffutils-3.3/po/Makefile.in.in 2013-03-26 11:26:00.114379442 +0000 +@@ -42,7 +42,7 @@ INSTALL_DATA = @INSTALL_DATA@ + mkinstalldirs = $(SHELL) @install_sh@ -d + install_sh = $(SHELL) @install_sh@ + MKDIR_P = @MKDIR_P@ +-mkdir_p = @mkdir_p@ ++mkdir_p = @MKDIR_P@ + + GMSGFMT_ = @GMSGFMT@ + GMSGFMT_no = @GMSGFMT@ diff --git a/diffutils-ppc-float.patch b/diffutils-ppc-float.patch deleted file mode 100644 index 2a1256b..0000000 --- a/diffutils-ppc-float.patch +++ /dev/null @@ -1,49 +0,0 @@ -diff -up diffutils-3.2/gnulib-tests/float.c.ppc-float diffutils-3.2/gnulib-tests/float.c ---- diffutils-3.2/gnulib-tests/float.c.ppc-float 2011-08-28 12:57:24.000000000 +0100 -+++ diffutils-3.2/gnulib-tests/float.c 2011-11-25 14:13:58.090442846 +0000 -@@ -22,7 +22,7 @@ - /* Specification. */ - #include - --#if (defined _ARCH_PPC || defined _POWER) && defined _AIX && (LDBL_MANT_DIG == 106) && defined __GNUC__ -+#if (defined _ARCH_PPC || defined _POWER) && (defined _AIX || defined __linux__) && (LDBL_MANT_DIG == 106) && defined __GNUC__ - const union gl_long_double_union gl_LDBL_MAX = - { { DBL_MAX, DBL_MAX / (double)134217728UL / (double)134217728UL } }; - #elif defined __i386__ -diff -up diffutils-3.2/gnulib-tests/float.in.h.ppc-float diffutils-3.2/gnulib-tests/float.in.h ---- diffutils-3.2/gnulib-tests/float.in.h.ppc-float 2011-08-28 12:57:25.000000000 +0100 -+++ diffutils-3.2/gnulib-tests/float.in.h 2011-11-25 14:13:58.091442827 +0000 -@@ -111,7 +111,8 @@ extern const union gl_long_double_union - #endif - - /* On AIX 7.1 with gcc 4.2, the values of LDBL_MIN_EXP, LDBL_MIN, LDBL_MAX are -- wrong. */ -+ wrong. -+ On Linux/PowerPC with gcc 4.4, the value of LDBL_MAX is wrong. */ - #if (defined _ARCH_PPC || defined _POWER) && defined _AIX && (LDBL_MANT_DIG == 106) && defined __GNUC__ - # undef LDBL_MIN_EXP - # define LDBL_MIN_EXP DBL_MIN_EXP -@@ -119,6 +120,8 @@ extern const union gl_long_double_union - # define LDBL_MIN_10_EXP DBL_MIN_10_EXP - # undef LDBL_MIN - # define LDBL_MIN 2.22507385850720138309023271733240406422e-308L /* DBL_MIN = 2^-1022 */ -+#endif -+#if (defined _ARCH_PPC || defined _POWER) && (defined _AIX || defined __linux__) && (LDBL_MANT_DIG == 106) && defined __GNUC__ - # undef LDBL_MAX - /* LDBL_MAX is represented as { 0x7FEFFFFF, 0xFFFFFFFF, 0x7C8FFFFF, 0xFFFFFFFF }. - It is not easy to define: -diff -up diffutils-3.2/gnulib-tests/test-float.c.ppc-float diffutils-3.2/gnulib-tests/test-float.c ---- diffutils-3.2/gnulib-tests/test-float.c.ppc-float 2011-09-01 23:38:42.000000000 +0100 -+++ diffutils-3.2/gnulib-tests/test-float.c 2011-11-25 14:14:04.623319695 +0000 -@@ -325,7 +325,11 @@ test_long_double (void) - int n; - - ASSERT (m + m > m); -+#if (defined _ARCH_PPC || defined _POWER) -+ for (n = 0; n <= 2 * DBL_MANT_DIG; n++) -+#else - for (n = 0; n <= 2 * LDBL_MANT_DIG; n++) -+#endif - { - volatile long double pow2_n = pow2l (n); /* 2^n */ - volatile long double x = m + (m / pow2_n); diff --git a/diffutils-stdio-gets.patch b/diffutils-stdio-gets.patch deleted file mode 100644 index 8d7d5a3..0000000 --- a/diffutils-stdio-gets.patch +++ /dev/null @@ -1,30 +0,0 @@ -diff -up diffutils-3.2/lib/stdio.in.h.stdio-gets diffutils-3.2/lib/stdio.in.h ---- diffutils-3.2/lib/stdio.in.h.stdio-gets 2012-07-23 17:29:22.311787651 +0100 -+++ diffutils-3.2/lib/stdio.in.h 2012-07-23 17:29:58.316908463 +0100 -@@ -681,26 +681,6 @@ _GL_WARN_ON_USE (getline, "getline is un - # endif - #endif - --#if @GNULIB_GETS@ --# if @REPLACE_STDIO_READ_FUNCS@ && @GNULIB_STDIO_H_NONBLOCKING@ --# if !(defined __cplusplus && defined GNULIB_NAMESPACE) --# undef gets --# define gets rpl_gets --# endif --_GL_FUNCDECL_RPL (gets, char *, (char *s) _GL_ARG_NONNULL ((1))); --_GL_CXXALIAS_RPL (gets, char *, (char *s)); --# else --_GL_CXXALIAS_SYS (gets, char *, (char *s)); --# undef gets --# endif --_GL_CXXALIASWARN (gets); --/* It is very rare that the developer ever has full control of stdin, -- so any use of gets warrants an unconditional warning. Assume it is -- always declared, since it is required by C89. */ --_GL_WARN_ON_USE (gets, "gets is a security hole - use fgets instead"); --#endif -- -- - #if @GNULIB_OBSTACK_PRINTF@ || @GNULIB_OBSTACK_PRINTF_POSIX@ - struct obstack; - /* Grow an obstack with formatted output. Return the number of diff --git a/diffutils.spec b/diffutils.spec index 998d3c0..3f6c22b 100644 --- a/diffutils.spec +++ b/diffutils.spec @@ -1,14 +1,13 @@ Summary: A GNU collection of diff utilities Name: diffutils -Version: 3.2 -Release: 12%{?dist} +Version: 3.3 +Release: 1%{?dist} Group: Applications/Text URL: http://www.gnu.org/software/diffutils/diffutils.html Source: ftp://ftp.gnu.org/gnu/diffutils/diffutils-%{version}.tar.xz Patch1: diffutils-cmp-s-empty.patch -Patch2: diffutils-ppc-float.patch -Patch3: diffutils-stdio-gets.patch -Patch4: diffutils-3.2-i18n.patch +Patch2: diffutils-mkdir_p.patch +Patch4: diffutils-i18n.patch License: GPLv3+ Requires(post): info Requires(preun): info @@ -34,11 +33,8 @@ Install diffutils if you need to compare text files. # For 'cmp -s', compare file sizes only if both non-zero (bug #563618). %patch1 -p1 -b .cmp-s-empty -# Applied upstream gnulib fix for float test on ppc (bug #733536). -%patch2 -p1 -b .ppc-float - -# Fixed build failure. -%patch3 -p1 -b .stdio-gets +# Work around @mkdir_p@ build issue. +%patch2 -p1 -b .mkdir_p %patch4 -p1 -b .i18n @@ -75,6 +71,9 @@ rm -rf $RPM_BUILD_ROOT %{_infodir}/diffutils.info*gz %changelog +* Tue Mar 26 2013 Tim Waugh 3.3-1 +- 3.3 (bug #927560). + * Fri Feb 22 2013 Tim Waugh 3.2-12 - Fixed i18n handling of 'diff -E' (bug #914666). diff --git a/sources b/sources index 0de2652..180c1e0 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -26ff64c332429c830c154be46b393382 diffutils-3.2.tar.xz +99180208ec2a82ce71f55b0d7389f1b3 diffutils-3.3.tar.xz