From 073467edad21ec2211591110f2af536ca656eedf Mon Sep 17 00:00:00 2001 From: Automatic Build System Date: Fri, 5 Jan 2024 21:47:15 +0100 Subject: [PATCH] automatic version update by autodist [release 3.3-1mamba;Tue Mar 26 2013] --- README.md | 9 + diffutils-2.8.7-hardened_tmp-1.patch | 31 ++ diffutils-2.8.7-i18n.patch | 795 +++++++++++++++++++++++++++ diffutils.spec | 110 ++++ 4 files changed, 945 insertions(+) create mode 100644 diffutils-2.8.7-hardened_tmp-1.patch create mode 100644 diffutils-2.8.7-i18n.patch create mode 100644 diffutils.spec diff --git a/README.md b/README.md index 9021ab2..c2078ec 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,11 @@ # diffutils +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 persons' 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. + diff --git a/diffutils-2.8.7-hardened_tmp-1.patch b/diffutils-2.8.7-hardened_tmp-1.patch new file mode 100644 index 0000000..c335090 --- /dev/null +++ b/diffutils-2.8.7-hardened_tmp-1.patch @@ -0,0 +1,31 @@ +Submitted By: Robert Connolly (ashes) +Date: 2006-10-09 +Initial Package Version: 2.8.7 +Upstream Status: Submitted - Partially accepted +Thread starts here: + http://sources.redhat.com/ml/bug-gnu-utils/2000-12/msg00163.html +Origin: ALT Linux / Openwall Owl Linux - diffutils-2.8.7-alt-tmp.diff +Description: This patch removes the more portable and less safe use of +tmpname(3), in preference of mkstemp(3). + +--- diffutils-2.8.7/src/sdiff.c.orig 2004-04-12 07:44:35 +0000 ++++ diffutils-2.8.7/src/sdiff.c 2005-05-17 12:58:44 +0000 +@@ -990,13 +990,13 @@ edit (struct line_filter *left, char con + int fd; + + if (tmpname) +- tmp = fopen (tmpname, "w"); +- else + { +- if ((fd = temporary_file ()) < 0) +- perror_fatal ("mkstemp"); +- tmp = fdopen (fd, "w"); ++ unlink (tmpname); ++ free (tmpname); + } ++ if ((fd = temporary_file ()) < 0) ++ perror_fatal ("mkstemp"); ++ tmp = fdopen (fd, "w"); + + if (! tmp) + perror_fatal (tmpname); diff --git a/diffutils-2.8.7-i18n.patch b/diffutils-2.8.7-i18n.patch new file mode 100644 index 0000000..fe29b46 --- /dev/null +++ b/diffutils-2.8.7-i18n.patch @@ -0,0 +1,795 @@ +--- diffutils-2.8.7/src/diff.c.i18n 2004-04-12 03:44:35.000000000 -0400 ++++ diffutils-2.8.7/src/diff.c 2004-06-01 08:32:14.000000000 -0400 +@@ -273,6 +273,13 @@ + 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, 0)) != -1) +--- diffutils-2.8.7/src/diff.h.i18n 2004-04-12 03:44:35.000000000 -0400 ++++ diffutils-2.8.7/src/diff.h 2004-06-01 08:34:02.000000000 -0400 +@@ -25,6 +25,19 @@ + #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 ++ ++#define TAB_WIDTH 8 ++ + /* What kind of changes a hunk contains. */ + enum changes + { +@@ -352,7 +365,13 @@ + 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/src/io.c.i18n 2004-04-12 03:44:35.000000000 -0400 ++++ diffutils-2.8.7/src/io.c 2004-06-01 08:32:14.000000000 -0400 +@@ -25,6 +25,7 @@ + #include + #include + #include ++#include + + /* Rotate an unsigned value to the left. */ + #define ROL(v, n) ((v) << (n) | (v) >> (sizeof (v) * CHAR_BIT - (n))) +@@ -212,6 +213,28 @@ + + /* 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) +@@ -238,12 +261,280 @@ + 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++) ++ 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 || (!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: ++ { ++ size_t column = 0; ++ ++ while (1) ++ { ++ if (*p == '\n') ++ { ++ ++p; ++ break; ++ } ++ ++ MBC2WC (p, suffix_begin, mblength, wc, state, convfail); ++ ++ if (convfail) ++ { ++ h = HASH (h, *p++); ++ ++column; ++ } ++ else ++ { ++ bool flag; ++ ++ switch (wc) ++ { ++ case L'\b': ++ column -= 0 < column; ++ h = HASH (h, '\b'); ++ ++p; ++ break; ++ ++ case L'\t': ++ { ++ int repetitions; ++ ++ repetitions = TAB_WIDTH - column % TAB_WIDTH; ++ 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++) ++ h = HASH (h, mbc[i]); ++ } ++ } ++ } ++ } ++ 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++) ++ h = HASH (h, mbc[i]); ++ } ++ } ++ } ++ else ++#endif + /* Hash this line until we find a newline. */ + if (ignore_case) + switch (ignore_white_space) +--- diffutils-2.8.7/src/side.c.i18n 2004-04-12 03:44:35.000000000 -0400 ++++ diffutils-2.8.7/src/side.c 2004-06-01 08:32:14.000000000 -0400 +@@ -73,11 +73,72 @@ + 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 @@ + 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/src/util.c.i18n 2004-04-12 03:44:35.000000000 -0400 ++++ diffutils-2.8.7/src/util.c 2004-06-01 08:32:14.000000000 -0400 +@@ -319,7 +319,7 @@ + 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; +@@ -448,6 +448,293 @@ + + 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 += TAB_WIDTH - column % TAB_WIDTH; ++ 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 += TAB_WIDTH - column2 % TAB_WIDTH; ++ 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') ? TAB_WIDTH - column % TAB_WIDTH : 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.spec b/diffutils.spec new file mode 100644 index 0000000..cff596f --- /dev/null +++ b/diffutils.spec @@ -0,0 +1,110 @@ +Name: diffutils +Version: 3.3 +Release: 1mamba +Summary: A GNU collection of diff utilities +Group: Applications/Development +Vendor: openmamba +Distribution: openmamba +Packager: Silvan Calarco +URL: http://www.gnu.org/software/diffutils/ +Source: ftp://ftp.gnu.org/pub/gnu/diffutils/diffutils-%{version}.tar.xz +# http://www.openi18n.org/ +Patch0: %{name}-2.8.7-i18n.patch +# http://www.linuxfromscratch.org/patches/downloads/diffutils/ +Patch2: %{name}-2.8.7-hardened_tmp-1.patch +License: GPL +BuildRequires: gettext-devel >= 0.14.0 +#BuildRequires: help2man +Requires(post):%{__install_info} +BuildRoot: %{_tmppath}/%{name}-%{version}-root + +%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 persons' 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 +%setup -q +#%patch0 -p1 -b .i18n +%patch2 -p1 -b .hardened_tmp + +%build +%configure +# modify the default editor for sdiff interactive mode +sed -i 's/\(.*#define DEFAULT_EDITOR_PROGRAM \\"\)ed\\"/\1vi\\"/' configure +%make + +%install +[ "%{buildroot}" != / ] && rm -rf %{buildroot} +%makeinstall mkdir_p="mkdir -p" + +%find_lang %{name} + +%clean +[ "%{buildroot}" != / ] && rm -rf %{buildroot} + +%post +%install_info %{name}.info +exit 0 + +%preun +%uninstall_info %{name}.info +exit 0 + +%files -f %{name}.lang +%defattr(-,root,root) +%{_bindir}/cmp +%{_bindir}/diff +%{_bindir}/diff3 +%{_bindir}/sdiff +%{_mandir}/man1/cmp.* +%{_mandir}/man1/diff.* +%{_mandir}/man1/diff3.* +%{_mandir}/man1/sdiff.* +%{_infodir}/%{name}.info.* +%doc AUTHORS COPYING +#NEWS README THANKS + +%changelog +* Tue Mar 26 2013 Automatic Build System 3.3-1mamba +- automatic version update by autodist + +* Sat Sep 03 2011 Automatic Build System 3.2-1mamba +- automatic version update by autodist + +* Thu Aug 11 2011 Automatic Build System 3.1-1mamba +- automatic version update by autodist + +* Tue May 04 2010 Automatic Build System 3.0-1mamba +- automatic update to 3.0 by autodist + +* Thu Feb 18 2010 Davide Madrisan 2.9-1mamba +- update to 2.9 + +* Wed May 14 2008 Aleph0 2.8.7-2mamba +- specfile updated + +* Thu Oct 19 2006 Davide Madrisan 2.8.7-1qilnx +- update to version 2.8.7 by autospec +- added tmp hardened patch from LFS project + +* Mon Oct 24 2005 Davide Madrisan 2.8.1-4qilnx +- updated i18n patch to pass LSB test /tset/LI18NUX2K.L1/utils/diff/T.diff + +* Tue Apr 05 2005 Davide Madrisan 2.8.1-3qilnx +- added missing prereq (install-info) + +* Tue Apr 05 2005 Davide Madrisan 2.8.1-2qilnx +- made diffutils LSB 2.0 compliant +- specfils updates +- fixed package group +- added missing scripts for info files + +* Mon Apr 7 2003 Luca Tinelli 2.8.1-1qilnx +- First build +