diff --git a/cmp-eof-dev-null.diff b/cmp-eof-dev-null.diff deleted file mode 100644 index aa2e6ad..0000000 --- a/cmp-eof-dev-null.diff +++ /dev/null @@ -1,164 +0,0 @@ -2006-05-09 Paul Eggert - - * src/cmp.c (cmp): The previous fix wasn't quite right either, as - it mishandled 'cmp A B >/dev/null' when A is shorter than B and - differs before A's end-of-file, by outputting a bogus EOF message. - Also, it was inefficient if A and B were large. - -2006-05-07 Jim Meyering (tiny change) - - Fix bug introduced in 2006-03-09 change: - cmp always exits successfully, when stdout is redirected to /dev/null. - * src/cmp.c (cmp): When there's a difference, arrange to return nonzero - also when comparison_type is the new (from 2006-03-09) type_no_stdout. - -2006-03-09 Paul Eggert - - * src/cmp.c (type_no_stdout): New constant. - (main): Use it to avoid bug when the "EOF on foo" message is - generated and stdout is /dev/null. - Problem reported by Vincent Lefevre (Debian bug 356083). - -Index: cmp.c -=================================================================== -RCS file: /sources/diffutils/diffutils/src/cmp.c,v -retrieving revision 1.39 -retrieving revision 1.40 -diff -u -a -p -u -p -a -r1.39 -r1.40 ---- cmp.c 5 Jan 2006 07:23:55 -0000 1.39 -+++ cmp.c 9 Mar 2006 20:38:11 -0000 1.40 -@@ -78,6 +78,7 @@ static enum comparison_type - { - type_first_diff, /* Print the first difference. */ - type_all_diffs, /* Print all differences. */ -+ type_no_stdout, /* Do not output to stdout; only stderr. */ - type_status /* Exit status only. */ - } comparison_type; - -@@ -317,7 +318,12 @@ main (int argc, char **argv) - if (fstat (STDOUT_FILENO, &outstat) == 0 - && stat (NULL_DEVICE, &nullstat) == 0 - && 0 < same_file (&outstat, &nullstat)) -- comparison_type = type_status; -+ comparison_type = -+ ((fstat (STDERR_FILENO, &outstat) == 0 -+ ? 0 < same_file (&outstat, &nullstat) -+ : errno == EBADF) -+ ? type_status -+ : type_no_stdout); - } - - /* If only a return code is needed, -@@ -356,7 +362,7 @@ main (int argc, char **argv) - for (f = 0; f < 2; f++) - if (close (file_desc[f]) != 0) - error (EXIT_TROUBLE, errno, "%s", file[f]); -- if (exit_status != 0 && comparison_type != type_status) -+ if (exit_status != EXIT_SUCCESS && comparison_type < type_no_stdout) - check_stdout (); - exit (exit_status); - return exit_status; -@@ -536,6 +542,9 @@ cmp (void) - while (first_diff < smaller); - ret = EXIT_FAILURE; - break; -+ -+ case type_no_stdout: -+ break; - } - } - -Index: cmp.c -=================================================================== -RCS file: /sources/diffutils/diffutils/src/cmp.c,v -retrieving revision 1.40 -retrieving revision 1.41 -diff -u -a -p -u -p -a -r1.40 -r1.41 ---- cmp.c 9 Mar 2006 20:38:11 -0000 1.40 -+++ cmp.c 9 Mar 2006 20:54:39 -0000 1.41 -@@ -318,12 +318,7 @@ main (int argc, char **argv) - if (fstat (STDOUT_FILENO, &outstat) == 0 - && stat (NULL_DEVICE, &nullstat) == 0 - && 0 < same_file (&outstat, &nullstat)) -- comparison_type = -- ((fstat (STDERR_FILENO, &outstat) == 0 -- ? 0 < same_file (&outstat, &nullstat) -- : errno == EBADF) -- ? type_status -- : type_no_stdout); -+ comparison_type = type_no_stdout; - } - - /* If only a return code is needed, -Index: cmp.c -=================================================================== -RCS file: /sources/diffutils/diffutils/src/cmp.c,v -retrieving revision 1.43 -retrieving revision 1.44 -diff -u -a -p -u -p -a -r1.43 -r1.44 ---- cmp.c 13 Mar 2006 19:11:17 -0000 1.43 -+++ cmp.c 8 May 2006 01:41:04 -0000 1.44 -@@ -536,10 +536,10 @@ cmp (void) - first_diff++; - } - while (first_diff < smaller); -- ret = EXIT_FAILURE; -- break; - -+ /* Fall through. */ - case type_no_stdout: -+ ret = EXIT_FAILURE; - break; - } - } -Index: cmp.c -=================================================================== -RCS file: /sources/diffutils/diffutils/src/cmp.c,v -retrieving revision 1.44 -retrieving revision 1.45 -diff -u -a -p -u -p -a -r1.44 -r1.45 ---- cmp.c 8 May 2006 01:41:04 -0000 1.44 -+++ cmp.c 9 May 2006 22:57:20 -0000 1.45 -@@ -382,7 +382,7 @@ cmp (void) - word *buffer1 = buffer[1]; - char *buf0 = (char *) buffer0; - char *buf1 = (char *) buffer1; -- int ret = EXIT_SUCCESS; -+ int differing = 0; - int f; - int offset_width IF_LINT (= 0); - -@@ -536,17 +536,18 @@ cmp (void) - first_diff++; - } - while (first_diff < smaller); -+ differing = -1; -+ break; - -- /* Fall through. */ - case type_no_stdout: -- ret = EXIT_FAILURE; -+ differing = 1; - break; - } - } - - if (read0 != read1) - { -- if (comparison_type != type_status) -+ if (differing <= 0 && comparison_type != type_status) - { - /* See POSIX 1003.1-2001 for this format. */ - fprintf (stderr, _("cmp: EOF on %s\n"), file[read1 < read0]); -@@ -555,9 +556,9 @@ cmp (void) - return EXIT_FAILURE; - } - } -- while (read0 == buf_size); -+ while (differing <= 0 && read0 == buf_size); - -- return ret; -+ return differing == 0 ? EXIT_SUCCESS : EXIT_FAILURE; - } - - /* Compare two blocks of memory P0 and P1 until they differ, diff --git a/diffutils-2.8.1-i18n-0.2.patch b/diffutils-2.8.1-i18n-0.2.patch new file mode 100644 index 0000000..cc7b2e6 --- /dev/null +++ b/diffutils-2.8.1-i18n-0.2.patch @@ -0,0 +1,817 @@ +--- diffutils-2.8.7-cvs/configure.ac ++++ diffutils-2.8.7-cvs/configure.ac +@@ -57,6 +57,7 @@ if test $ac_cv_func_sigprocmask = no; th + fi + AC_FUNC_CLOSEDIR_VOID + AC_FUNC_FORK ++AC_FUNC_MBRTOWC + + AM_GNU_GETTEXT([external], [need-formatstring-macros]) + AM_GNU_GETTEXT_VERSION([0.15]) +--- diffutils-2.8.7-cvs/src/diff.c ++++ diffutils-2.8.7-cvs/src/diff.c +@@ -276,6 +276,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) +--- diffutils-2.8.7-cvs/src/diff.h ++++ diffutils-2.8.7-cvs/src/diff.h +@@ -23,6 +23,17 @@ + #include + #include + ++/* For platform which support the ISO C amendement 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 + { +@@ -353,7 +364,13 @@ extern char const change_letter[4]; + extern char const pr_program[]; + char *concat (char const *, char const *, char const *); + char *dir_file_pathname (char const *, char const *); +-bool lines_differ (char const *, char const *); ++ ++bool (*lines_differ) (char const *, char const *); ++bool lines_differ_singlebyte (char const *, char const *); ++#ifdef HANDLE_MULTIBYTE ++bool lines_differ_multibyte (char const *, char const *); ++#endif ++ + lin translate_line_number (struct file_data const *, lin); + struct change *find_change (struct change *); + struct change *find_reverse_change (struct change *); +--- diffutils-2.8.7-cvs/src/io.c ++++ diffutils-2.8.7-cvs/src/io.c +@@ -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,11 +243,294 @@ find_and_hash_each_line (struct file_dat + bool same_length_diff_contents_compare_anyway = + diff_length_compare_anyway | ignore_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; + + h = 0; ++#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 (ignore_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 (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++; ++ } ++ } ++ else ++ { ++ p += mblength; ++ continue; ++ } ++ ++ for (i = 0; i < mblength; i++) ++ { ++ c = mbc[i]; ++ h = HASH (h, c); ++ } ++ } ++ 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 || (!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++) ++ { ++ c = mbc[i]; ++ h = HASH (h, c); ++ } ++ } ++ break; ++ ++ case IGNORE_TAB_EXPANSION: ++ { ++ size_t column = 0; ++ ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ break; ++ } ++ ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ ++ if (convfail) ++ { ++ c = *p++; ++ h = HASH (h, c); ++ ++column; ++ } ++ else ++ { ++ bool flag; ++ ++ switch (wc) ++ { ++ case L'\b': ++ column -= 0 < column; ++ h = HASH (h, '\b'); ++ ++p; ++ break; ++ ++ case L'\t': ++ { ++ size_t repetitions; ++ repetitions = tabsize - column % tabsize; ++ column = (column + repetitions < column ++ ? 0 ++ : column + repetitions); ++ do ++ h = HASH (h, ' '); ++ while (--repetitions != 0); ++ ++p; ++ } ++ break; ++ ++ case L'\r': ++ column = 0; ++ h = HASH (h, '\r'); ++ ++p; ++ break; ++ ++ default: ++ flag = 0; ++ column += wcwidth (wc); ++ 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++) ++ { ++ c = mbc[i]; ++ h = HASH (h, c); ++ } ++ } ++ } ++ } ++ } ++ 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 (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++) ++ { ++ c = mbc[i]; ++ h = HASH (h, c); ++ } ++ } ++ } ++ goto hashing_done; ++ } ++#endif + + /* Hash this line until we find a newline. */ + if (ignore_case) +--- diffutils-2.8.7-cvs/src/side.c ++++ diffutils-2.8.7-cvs/src/side.c +@@ -73,11 +73,72 @@ print_half_line (char const *const *line + register size_t out_position = 0; + register char const *text_pointer = line[0]; + register char const *text_limit = line[1]; ++#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H ++ unsigned char mbc[MB_LEN_MAX]; ++ wchar_t wc; ++ mbstate_t state, state_bak; ++ size_t mbc_pos, mblength; ++ int mbc_loading_flag = 0; ++ int wc_width; ++ ++ memset (&state, '\0', sizeof (mbstate_t)); ++#endif + + while (text_pointer < text_limit) + { + register unsigned char c = *text_pointer++; + ++#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H ++ if (MB_CUR_MAX > 1 && mbc_loading_flag) ++ { ++ mbc_loading_flag = 0; ++ state_bak = state; ++ mbc[mbc_pos++] = c; ++ ++process_mbc: ++ mblength = mbrtowc (&wc, mbc, mbc_pos, &state); ++ ++ switch (mblength) ++ { ++ case (size_t)-2: /* Incomplete multibyte character. */ ++ mbc_loading_flag = 1; ++ state = state_bak; ++ break; ++ ++ case (size_t)-1: /* Invalid as a multibyte character. */ ++ if (in_position++ < out_bound) ++ { ++ out_position = in_position; ++ putc (mbc[0], out); ++ } ++ memmove (mbc, mbc + 1, --mbc_pos); ++ if (mbc_pos > 0) ++ { ++ mbc[mbc_pos] = '\0'; ++ goto process_mbc; ++ } ++ break; ++ ++ default: ++ wc_width = wcwidth (wc); ++ if (wc_width < 1) /* Unprintable multibyte character. */ ++ { ++ if (in_position <= out_bound) ++ fprintf (out, "%lc", (wint_t)wc); ++ } ++ else /* Printable multibyte character. */ ++ { ++ in_position += wc_width; ++ if (in_position <= out_bound) ++ { ++ out_position = in_position; ++ fprintf (out, "%lc", (wint_t)wc); ++ } ++ } ++ } ++ continue; ++ } ++#endif + switch (c) + { + case '\t': +@@ -135,8 +196,39 @@ print_half_line (char const *const *line + break; + + default: +- if (! isprint (c)) +- goto control_char; ++#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H ++ if (MB_CUR_MAX > 1) ++ { ++ memset (mbc, '\0', MB_LEN_MAX); ++ mbc_pos = 0; ++ mbc[mbc_pos++] = c; ++ state_bak = state; ++ ++ mblength = mbrtowc (&wc, mbc, mbc_pos, &state); ++ ++ /* The value of mblength is always less than 2 here. */ ++ switch (mblength) ++ { ++ case (size_t)-2: /* Incomplete multibyte character. */ ++ state = state_bak; ++ mbc_loading_flag = 1; ++ continue; ++ ++ case (size_t)-1: /* Invalid as a multibyte character. */ ++ state = state_bak; ++ break; ++ ++ default: ++ if (! iswprint (wc)) ++ goto control_char; ++ } ++ } ++ else ++#endif ++ { ++ if (! isprint (c)) ++ goto control_char; ++ } + /* falls through */ + case ' ': + if (in_position++ < out_bound) +--- diffutils-2.8.7-cvs/src/util.c ++++ diffutils-2.8.7-cvs/src/util.c +@@ -317,7 +317,7 @@ finish_output (void) + Return nonzero if the lines differ. */ + + bool +-lines_differ (char const *s1, char const *s2) ++lines_differ_singlebyte (char const *s1, char const *s2) + { + register char const *t1 = s1; + register char const *t2 = s2; +@@ -446,6 +446,293 @@ 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, char const *s2) ++{ ++ unsigned char const *end1, *end2; ++ unsigned 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; ++ ++ unsigned char const *t1 = (unsigned char const *) s1; ++ unsigned char const *t2 = (unsigned char const *) s2; ++ unsigned 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; ++ } ++ ++ memset (&state1, '\0', sizeof (mbstate_t)); ++ memset (&state2, '\0', sizeof (mbstate_t)); ++ ++ end1 = s1 + strlen (s1); ++ end2 = s2 + strlen (s2); ++ ++ 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 (wc2 == L' ' && wc1 != L'\n' && ++ t1 > (unsigned char const *)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 > (unsigned char const *)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_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-2.8.1-i18n-0.2.patch.gz b/diffutils-2.8.1-i18n-0.2.patch.gz deleted file mode 100644 index 744c38b..0000000 --- a/diffutils-2.8.1-i18n-0.2.patch.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:9289be62b118f41757d3ac267c6fbe4678717dfb26240edfdd85a5b5ddff4029 -size 4450 diff --git a/diffutils-2.8.7-cvs.tar.bz2 b/diffutils-2.8.7-cvs.tar.bz2 new file mode 100644 index 0000000..f1131cd --- /dev/null +++ b/diffutils-2.8.7-cvs.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a55f870c2dddde476f13cddfa013b4f429068b91ceaeeab45d383a92633e2ff1 +size 922261 diff --git a/diffutils-2.8.7.tar.gz b/diffutils-2.8.7.tar.gz deleted file mode 100644 index 8242c96..0000000 --- a/diffutils-2.8.7.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:53d9c10830ac322c00dfcccf60d961014e767da86d2c802ccc5cbad7e7aea07c -size 1057977 diff --git a/diffutils.changes b/diffutils.changes index 335a465..83a4f3c 100644 --- a/diffutils.changes +++ b/diffutils.changes @@ -1,3 +1,19 @@ +------------------------------------------------------------------- +Thu Jan 10 17:36:12 CET 2008 - schwab@suse.de + +- Update to head of trunk. + * New diff option --suppress-blank-empty. + * Bring back support for `diff -NUM', where NUM is a number, + even when conforming to POSIX 1003.1-2001. This change reverts to + the behavior of GNU diff 2.7 and earlier. This is a change only + when conforming to POSIX 1003.1-2001; there is no effect when + conforming to older POSIX versions. + This change is in response to decisions taken in the January 2005 + Austin Group standardization meeting. For more details, please see + "Utility Syntax Guidelines" in the Minutes of the January 2005 + Meeting . + * sdiff now understands '1' and '2' as synonyms for 'l' and 'r'. + ------------------------------------------------------------------- Mon Nov 27 17:15:34 CET 2006 - rguenther@suse.de diff --git a/diffutils.spec b/diffutils.spec index fddf31d..7a3c708 100644 --- a/diffutils.spec +++ b/diffutils.spec @@ -1,7 +1,7 @@ # # spec file for package diffutils (Version 2.8.7) # -# Copyright (c) 2006 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2008 SUSE LINUX Products GmbH, Nuernberg, Germany. # This file and all modifications and additions to the pristine # package are under the same license as the package itself. # @@ -11,19 +11,18 @@ # norootforbuild Name: diffutils -URL: http://www.gnu.org/software/diffutils/ -License: GNU General Public License (GPL) +Url: http://www.gnu.org/software/diffutils/ +License: GPL v2 or later Group: Productivity/Text/Utilities Provides: diff Obsoletes: diff -Autoreqprov: on +AutoReqProv: on PreReq: %{install_info_prereq} Version: 2.8.7 -Release: 38 +Release: 92 Summary: GNU diff Utilities -Source: diffutils-%{version}.tar.gz -Patch1: diffutils-2.8.1-i18n-0.2.patch.gz -Patch2: cmp-eof-dev-null.diff +Source: diffutils-%{version}-cvs.tar.bz2 +Patch1: diffutils-2.8.1-i18n-0.2.patch BuildRoot: %{_tmppath}/%{name}-%{version}-build %description @@ -40,13 +39,11 @@ Authors: Roland McGrath %prep -%setup +%setup -q -n %{name}-%{version}-cvs %patch1 -p1 -cd src -%patch2 %build -autoreconf -fi +AUTOPOINT=true autoreconf -fi touch man/*.1 ./configure CFLAGS="$RPM_OPT_FLAGS" \ --prefix=/usr --infodir=%{_infodir} --mandir=%{_mandir} @@ -75,7 +72,20 @@ rm -rf $RPM_BUILD_ROOT %doc %{_infodir}/diff.info*.gz %doc %{_mandir}/man1/*.gz -%changelog -n diffutils +%changelog +* Thu Jan 10 2008 - schwab@suse.de +- Update to head of trunk. + * New diff option --suppress-blank-empty. + * Bring back support for `diff -NUM', where NUM is a number, + even when conforming to POSIX 1003.1-2001. This change reverts to + the behavior of GNU diff 2.7 and earlier. This is a change only + when conforming to POSIX 1003.1-2001; there is no effect when + conforming to older POSIX versions. + This change is in response to decisions taken in the January 2005 + Austin Group standardization meeting. For more details, please see + "Utility Syntax Guidelines" in the Minutes of the January 2005 + Meeting . + * sdiff now understands '1' and '2' as synonyms for 'l' and 'r'. * Mon Nov 27 2006 - rguenther@suse.de - removed help2man BuildRequires again. Instead prevent patches from invalidating the shipped manpages.