diffutils/patches/diffutils-2.8.7-i18n.patch

diff -ur diffutils-2.8.7.orig/src/diff.c diffutils-2.8.7/src/diff.c
--- diffutils-2.8.7.orig/src/diff.c	2004-04-12 10:44:35.000000000 +0300
+++ diffutils-2.8.7/src/diff.c	2004-12-18 00:13:27.952635000 +0200
@@ -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)
diff -ur diffutils-2.8.7.orig/src/diff.h diffutils-2.8.7/src/diff.h
--- diffutils-2.8.7.orig/src/diff.h	2004-04-12 10:44:35.000000000 +0300
+++ diffutils-2.8.7/src/diff.h	2004-12-18 00:14:26.953665480 +0200
@@ -25,6 +25,19 @@
 #include <stdio.h>
 #include <unlocked-io.h>
 
+/* 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: <wchar.h> must be included before <wctype.h>.  */
+# include <wchar.h>
+# include <wctype.h>
+# 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,11 @@
 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 *);
diff -ur diffutils-2.8.7.orig/src/io.c diffutils-2.8.7/src/io.c
--- diffutils-2.8.7.orig/src/io.c	2004-04-12 10:44:35.000000000 +0300
+++ diffutils-2.8.7/src/io.c	2004-12-18 00:20:12.502134128 +0200
@@ -25,6 +25,7 @@
 #include <file-type.h>
 #include <setmode.h>
 #include <xalloc.h>
+#include <assert.h>
 
 /* Rotate an unsigned value to the left.  */
 #define ROL(v, n) ((v) << (n) | (v) >> (sizeof (v) * CHAR_BIT - (n)))
@@ -213,6 +214,29 @@
 /* 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 +262,282 @@
   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)
diff -ur diffutils-2.8.7.orig/src/side.c diffutils-2.8.7/src/side.c
--- diffutils-2.8.7.orig/src/side.c	2004-04-12 10:44:35.000000000 +0300
+++ diffutils-2.8.7/src/side.c	2004-12-18 00:22:09.875290696 +0200
@@ -74,10 +74,74 @@
   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,9 +199,40 @@
 	  break;
 
 	default:
-	  if (! isprint (c))
-	    goto control_char;
-	  /* falls through */
+#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)
 	    {
diff -ur diffutils-2.8.7.orig/src/util.c diffutils-2.8.7/src/util.c
--- diffutils-2.8.7.orig/src/util.c	2004-04-12 10:44:35.000000000 +0300
+++ diffutils-2.8.7/src/util.c	2004-12-18 00:24:29.209108736 +0200
@@ -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,294 @@
 
   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.  */
1	niro	144	diff -ur diffutils-2.8.7.orig/src/diff.c diffutils-2.8.7/src/diff.c
2			--- diffutils-2.8.7.orig/src/diff.c 2004-04-12 10:44:35.000000000 +0300
3			+++ diffutils-2.8.7/src/diff.c 2004-12-18 00:13:27.952635000 +0200
4			@@ -273,6 +273,13 @@
5			re_set_syntax (RE_SYNTAX_GREP \| RE_NO_POSIX_BACKTRACKING);
6			excluded = new_exclude ();
7
8			+#ifdef HANDLE_MULTIBYTE
9			+ if (MB_CUR_MAX > 1)
10			+ lines_differ = lines_differ_multibyte;
11			+ else
12			+#endif
13			+ lines_differ = lines_differ_singlebyte;
14			+
15			/* Decode the options. */
16
17			while ((c = getopt_long (argc, argv, shortopts, longopts, 0)) != -1)
18			diff -ur diffutils-2.8.7.orig/src/diff.h diffutils-2.8.7/src/diff.h
19			--- diffutils-2.8.7.orig/src/diff.h 2004-04-12 10:44:35.000000000 +0300
20			+++ diffutils-2.8.7/src/diff.h 2004-12-18 00:14:26.953665480 +0200
21			@@ -25,6 +25,19 @@
22			#include <stdio.h>
23			#include <unlocked-io.h>
24
25			+/* For platform which support the ISO C amendement 1 functionality we
26			+ support user defined character classes. */
27			+#if defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H
28			+/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */
29			+# include <wchar.h>
30			+# include <wctype.h>
31			+# if defined (HAVE_MBRTOWC)
32			+# define HANDLE_MULTIBYTE 1
33			+# endif
34			+#endif
35			+
36			+#define TAB_WIDTH 8
37			+
38			/* What kind of changes a hunk contains. */
39			enum changes
40			{
41			@@ -352,7 +365,11 @@
42			extern char const pr_program[];
43			char concat (char const , char const , char const );
44			char dir_file_pathname (char const , char const *);
45			-bool lines_differ (char const , char const );
46			+bool (lines_differ) (char const , char const *);
47			+bool lines_differ_singlebyte (char const , char const );
48			+#ifdef HANDLE_MULTIBYTE
49			+bool lines_differ_multibyte (char const , char const );
50			+#endif
51			lin translate_line_number (struct file_data const *, lin);
52			struct change find_change (struct change );
53			struct change find_reverse_change (struct change );
54			diff -ur diffutils-2.8.7.orig/src/io.c diffutils-2.8.7/src/io.c
55			--- diffutils-2.8.7.orig/src/io.c 2004-04-12 10:44:35.000000000 +0300
56			+++ diffutils-2.8.7/src/io.c 2004-12-18 00:20:12.502134128 +0200
57			@@ -25,6 +25,7 @@
58			#include <file-type.h>
59			#include <setmode.h>
60			#include <xalloc.h>
61			+#include <assert.h>
62
63			/* Rotate an unsigned value to the left. */
64			#define ROL(v, n) ((v) << (n) \| (v) >> (sizeof (v) * CHAR_BIT - (n)))
65			@@ -213,6 +214,29 @@
66			/* Split the file into lines, simultaneously computing the equivalence
67			class for each line. */
68
69			+#ifdef HANDLE_MULTIBYTE
70			+# define MBC2WC(P, END, MBLENGTH, WC, STATE, CONVFAIL) \
71			+do \
72			+{ \
73			+ mbstate_t state_bak = STATE; \
74			+ \
75			+ CONVFAIL = 0; \
76			+ MBLENGTH = mbrtowc (&WC, P, END - (char const *)P, &STATE); \
77			+ \
78			+ switch (MBLENGTH) \
79			+ { \
80			+ case (size_t)-2: \
81			+ case (size_t)-1: \
82			+ STATE = state_bak; \
83			+ ++CONVFAIL; \
84			+ /* Fall through. */ \
85			+ case 0: \
86			+ MBLENGTH = 1; \
87			+ } \
88			+} \
89			+while (0)
90			+#endif
91			+
92			static void
93			find_and_hash_each_line (struct file_data *current)
94			{
95			@@ -238,12 +262,282 @@
96			bool same_length_diff_contents_compare_anyway =
97			diff_length_compare_anyway \| ignore_case;
98
99			+#ifdef HANDLE_MULTIBYTE
100			+ wchar_t wc;
101			+ size_t mblength;
102			+ mbstate_t state;
103			+ int convfail;
104			+
105			+ memset (&state, '\0', sizeof (mbstate_t));
106			+#endif
107			+
108			while (p < suffix_begin)
109			{
110			char const *ip = p;
111
112			h = 0;
113
114			+#ifdef HANDLE_MULTIBYTE
115			+ if (MB_CUR_MAX > 1)
116			+ {
117			+ wchar_t lo_wc;
118			+ char mbc[MB_LEN_MAX];
119			+ mbstate_t state_wc;
120			+
121			+ /* Hash this line until we find a newline. */
122			+ switch (ignore_white_space)
123			+ {
124			+ case IGNORE_ALL_SPACE:
125			+ while (1)
126			+ {
127			+ if (*p == '\n')
128			+ {
129			+ ++p;
130			+ break;
131			+ }
132			+
133			+ MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
134			+
135			+ if (convfail)
136			+ mbc[0] = *p++;
137			+ else if (!iswspace (wc))
138			+ {
139			+ bool flag = 0;
140			+
141			+ if (ignore_case)
142			+ {
143			+ lo_wc = towlower (wc);
144			+ if (lo_wc != wc)
145			+ {
146			+ flag = 1;
147			+
148			+ p += mblength;
149			+ memset (&state_wc, '\0', sizeof(mbstate_t));
150			+ mblength = wcrtomb (mbc, lo_wc, &state_wc);
151			+
152			+ assert (mblength != (size_t)-1 &&
153			+ mblength != (size_t)-2);
154			+
155			+ mblength = (mblength < 1) ? 1 : mblength;
156			+ }
157			+ }
158			+
159			+ if (!flag)
160			+ {
161			+ for (i = 0; i < mblength; i++)
162			+ mbc[i] = *p++;
163			+ }
164			+ }
165			+ else
166			+ {
167			+ p += mblength;
168			+ continue;
169			+ }
170			+
171			+ for (i = 0; i < mblength; i++)
172			+ h = HASH (h, mbc[i]);
173			+ }
174			+ break;
175			+
176			+ case IGNORE_SPACE_CHANGE:
177			+ while (1)
178			+ {
179			+ if (*p == '\n')
180			+ {
181			+ ++p;
182			+ break;
183			+ }
184			+
185			+ MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
186			+
187			+ if (!convfail && iswspace (wc))
188			+ {
189			+ while (1)
190			+ {
191			+ if (*p == '\n')
192			+ {
193			+ ++p;
194			+ goto hashing_done;
195			+ }
196			+
197			+ p += mblength;
198			+ MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
199			+ if (convfail \|\| (!convfail && !iswspace (wc)))
200			+ break;
201			+ }
202			+ h = HASH (h, ' ');
203			+ }
204			+
205			+ /* WC is now the first non-space. */
206			+ if (convfail)
207			+ mbc[0] = *p++;
208			+ else
209			+ {
210			+ bool flag = 0;
211			+
212			+ if (ignore_case)
213			+ {
214			+ lo_wc = towlower (wc);
215			+ if (lo_wc != wc)
216			+ {
217			+ flag = 1;
218			+
219			+ p += mblength;
220			+ memset (&state_wc, '\0', sizeof(mbstate_t));
221			+ mblength = wcrtomb (mbc, lo_wc, &state_wc);
222			+
223			+ assert (mblength != (size_t)-1 &&
224			+ mblength != (size_t)-2);
225			+
226			+ mblength = (mblength < 1) ? 1 : mblength;
227			+ }
228			+ }
229			+
230			+ if (!flag)
231			+ {
232			+ for (i = 0; i < mblength; i++)
233			+ mbc[i] = *p++;
234			+ }
235			+ }
236			+
237			+ for (i = 0; i < mblength; i++)
238			+ h = HASH (h, mbc[i]);
239			+ }
240			+ break;
241			+
242			+ case IGNORE_TAB_EXPANSION:
243			+ {
244			+ size_t column = 0;
245			+
246			+ while (1)
247			+ {
248			+ if (*p == '\n')
249			+ {
250			+ ++p;
251			+ break;
252			+ }
253			+
254			+ MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
255			+
256			+ if (convfail)
257			+ {
258			+ h = HASH (h, *p++);
259			+ ++column;
260			+ }
261			+ else
262			+ {
263			+ bool flag;
264			+
265			+ switch (wc)
266			+ {
267			+ case L'\b':
268			+ column -= 0 < column;
269			+ h = HASH (h, '\b');
270			+ ++p;
271			+ break;
272			+
273			+ case L'\t':
274			+ {
275			+ int repetitions;
276			+
277			+ repetitions = TAB_WIDTH - column % TAB_WIDTH;
278			+ column += repetitions;
279			+ do
280			+ h = HASH (h, ' ');
281			+ while (--repetitions != 0);
282			+ ++p;
283			+ }
284			+ break;
285			+
286			+ case L'\r':
287			+ column = 0;
288			+ h = HASH (h, '\r');
289			+ ++p;
290			+ break;
291			+
292			+ default:
293			+ flag = 0;
294			+ column += wcwidth (wc);
295			+ if (ignore_case)
296			+ {
297			+ lo_wc = towlower (wc);
298			+ if (lo_wc != wc)
299			+ {
300			+ flag = 1;
301			+ p += mblength;
302			+ memset (&state_wc, '\0', sizeof(mbstate_t));
303			+ mblength = wcrtomb (mbc, lo_wc, &state_wc);
304			+
305			+ assert (mblength != (size_t)-1 &&
306			+ mblength != (size_t)-2);
307			+
308			+ mblength = (mblength < 1) ? 1 : mblength;
309			+ }
310			+ }
311			+
312			+ if (!flag)
313			+ {
314			+ for (i = 0; i < mblength; i++)
315			+ mbc[i] = *p++;
316			+ }
317			+
318			+ for (i = 0; i < mblength; i++)
319			+ h = HASH (h, mbc[i]);
320			+ }
321			+ }
322			+ }
323			+ }
324			+ break;
325			+
326			+ default:
327			+ while (1)
328			+ {
329			+ if (*p == '\n')
330			+ {
331			+ ++p;
332			+ break;
333			+ }
334			+
335			+ MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
336			+
337			+ if (convfail)
338			+ mbc[0] = *p++;
339			+ else
340			+ {
341			+ int flag = 0;
342			+
343			+ if (ignore_case)
344			+ {
345			+ lo_wc = towlower (wc);
346			+ if (lo_wc != wc)
347			+ {
348			+ flag = 1;
349			+ p += mblength;
350			+ memset (&state_wc, '\0', sizeof(mbstate_t));
351			+ mblength = wcrtomb (mbc, lo_wc, &state_wc);
352			+
353			+ assert (mblength != (size_t)-1 &&
354			+ mblength != (size_t)-2);
355			+
356			+ mblength = (mblength < 1) ? 1 : mblength;
357			+ }
358			+ }
359			+
360			+ if (!flag)
361			+ {
362			+ for (i = 0; i < mblength; i++)
363			+ mbc[i] = *p++;
364			+ }
365			+ }
366			+
367			+ for (i = 0; i < mblength; i++)
368			+ h = HASH (h, mbc[i]);
369			+ }
370			+ }
371			+ }
372			+ else
373			+#endif
374			+
375			/* Hash this line until we find a newline. */
376			if (ignore_case)
377			switch (ignore_white_space)
378			diff -ur diffutils-2.8.7.orig/src/side.c diffutils-2.8.7/src/side.c
379			--- diffutils-2.8.7.orig/src/side.c 2004-04-12 10:44:35.000000000 +0300
380			+++ diffutils-2.8.7/src/side.c 2004-12-18 00:22:09.875290696 +0200
381			@@ -74,10 +74,74 @@
382			register char const *text_pointer = line[0];
383			register char const *text_limit = line[1];
384
385			+#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H
386			+ unsigned char mbc[MB_LEN_MAX];
387			+ wchar_t wc;
388			+ mbstate_t state, state_bak;
389			+ size_t mbc_pos, mblength;
390			+ int mbc_loading_flag = 0;
391			+ int wc_width;
392			+
393			+ memset (&state, '\0', sizeof (mbstate_t));
394			+#endif
395			+
396			while (text_pointer < text_limit)
397			{
398			register unsigned char c = *text_pointer++;
399
400			+#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H
401			+ if (MB_CUR_MAX > 1 && mbc_loading_flag)
402			+ {
403			+ mbc_loading_flag = 0;
404			+ state_bak = state;
405			+ mbc[mbc_pos++] = c;
406			+
407			+process_mbc:
408			+ mblength = mbrtowc (&wc, mbc, mbc_pos, &state);
409			+
410			+ switch (mblength)
411			+ {
412			+ case (size_t)-2: /* Incomplete multibyte character. */
413			+ mbc_loading_flag = 1;
414			+ state = state_bak;
415			+ break;
416			+
417			+ case (size_t)-1: /* Invalid as a multibyte character. */
418			+ if (in_position++ < out_bound)
419			+ {
420			+ out_position = in_position;
421			+ putc (mbc[0], out);
422			+ }
423			+ memmove (mbc, mbc + 1, --mbc_pos);
424			+ if (mbc_pos > 0)
425			+ {
426			+ mbc[mbc_pos] = '\0';
427			+ goto process_mbc;
428			+ }
429			+ break;
430			+
431			+ default:
432			+ wc_width = wcwidth (wc);
433			+ if (wc_width < 1) /* Unprintable multibyte character. */
434			+ {
435			+ if (in_position <= out_bound)
436			+ fprintf (out, "%lc", (wint_t)wc);
437			+ }
438			+ else /* Printable multibyte character. */
439			+ {
440			+ in_position += wc_width;
441			+ if (in_position <= out_bound)
442			+ {
443			+ out_position = in_position;
444			+ fprintf (out, "%lc", (wint_t)wc);
445			+ }
446			+ }
447			+ }
448			+ continue;
449			+ }
450			+#endif
451			+
452			+
453			switch (c)
454			{
455			case '\t':
456			@@ -135,9 +199,40 @@
457			break;
458
459			default:
460			- if (! isprint (c))
461			- goto control_char;
462			- /* falls through */
463			+#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H
464			+ if (MB_CUR_MAX > 1)
465			+ {
466			+ memset (mbc, '\0', MB_LEN_MAX);
467			+ mbc_pos = 0;
468			+ mbc[mbc_pos++] = c;
469			+ state_bak = state;
470			+
471			+ mblength = mbrtowc (&wc, mbc, mbc_pos, &state);
472			+
473			+ /* The value of mblength is always less than 2 here. */
474			+ switch (mblength)
475			+ {
476			+ case (size_t)-2: /* Incomplete multibyte character. */
477			+ state = state_bak;
478			+ mbc_loading_flag = 1;
479			+ continue;
480			+
481			+ case (size_t)-1: /* Invalid as a multibyte character. */
482			+ state = state_bak;
483			+ break;
484			+
485			+ default:
486			+ if (! iswprint (wc))
487			+ goto control_char;
488			+ }
489			+ }
490			+ else
491			+#endif
492			+ {
493			+ if (! isprint (c))
494			+ goto control_char;
495			+ }
496			+ /* falls through */
497			case ' ':
498			if (in_position++ < out_bound)
499			{
500			diff -ur diffutils-2.8.7.orig/src/util.c diffutils-2.8.7/src/util.c
501			--- diffutils-2.8.7.orig/src/util.c 2004-04-12 10:44:35.000000000 +0300
502			+++ diffutils-2.8.7/src/util.c 2004-12-18 00:24:29.209108736 +0200
503			@@ -319,7 +319,7 @@
504			Return nonzero if the lines differ. */
505
506			bool
507			-lines_differ (char const s1, char const s2)
508			+lines_differ_singlebyte (char const s1, char const s2)
509			{
510			register char const *t1 = s1;
511			register char const *t2 = s2;
512			@@ -448,6 +448,294 @@
513
514			return true;
515			}
516			+
517			+
518			+#ifdef HANDLE_MULTIBYTE
519			+# define MBC2WC(T, END, MBLENGTH, WC, STATE, CONVFAIL) \
520			+do \
521			+{ \
522			+ mbstate_t bak = STATE; \
523			+ \
524			+ CONVFAIL = 0; \
525			+ MBLENGTH = mbrtowc (&WC, T, END - T, &STATE); \
526			+ \
527			+ switch (MBLENGTH) \
528			+ { \
529			+ case (size_t)-2: \
530			+ case (size_t)-1: \
531			+ STATE = bak; \
532			+ ++CONVFAIL; \
533			+ /* Fall through. */ \
534			+ case 0: \
535			+ MBLENGTH = 1; \
536			+ } \
537			+} \
538			+while (0)
539			+
540			+bool
541			+lines_differ_multibyte (char const s1, char const s2)
542			+{
543			+ unsigned char const end1, end2;
544			+ unsigned char c1, c2;
545			+ wchar_t wc1, wc2, wc1_bak, wc2_bak;
546			+ size_t mblen1, mblen2;
547			+ mbstate_t state1, state2, state1_bak, state2_bak;
548			+ int convfail1, convfail2, convfail1_bak, convfail2_bak;
549			+
550			+ unsigned char const t1 = (unsigned char const ) s1;
551			+ unsigned char const t2 = (unsigned char const ) s2;
552			+ unsigned char const t1_bak, t2_bak;
553			+ size_t column = 0;
554			+
555			+ if (ignore_white_space == IGNORE_NO_WHITE_SPACE && !ignore_case)
556			+ {
557			+ while (*t1 != '\n')
558			+ if (t1++ != t2++)
559			+ return 1;
560			+ return 0;
561			+ }
562			+
563			+ memset (&state1, '\0', sizeof (mbstate_t));
564			+ memset (&state2, '\0', sizeof (mbstate_t));
565			+
566			+ end1 = s1 + strlen (s1);
567			+ end2 = s2 + strlen (s2);
568			+
569			+ while (1)
570			+ {
571			+ c1 = *t1;
572			+ c2 = *t2;
573			+ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1);
574			+ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2);
575			+
576			+ /* Test for exact char equality first, since it's a common case. */
577			+ if (convfail1 ^ convfail2)
578			+ break;
579			+ else if (convfail1 && convfail2 && c1 != c2)
580			+ break;
581			+ else if (!convfail1 && !convfail2 && wc1 != wc2)
582			+ {
583			+ switch (ignore_white_space)
584			+ {
585			+ case IGNORE_ALL_SPACE:
586			+ /* For -w, just skip past any white space. */
587			+ while (1)
588			+ {
589			+ if (convfail1)
590			+ break;
591			+ else if (wc1 == L'\n' \|\| !iswspace (wc1))
592			+ break;
593			+
594			+ t1 += mblen1;
595			+ c1 = *t1;
596			+ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1);
597			+ }
598			+
599			+ while (1)
600			+ {
601			+ if (convfail2)
602			+ break;
603			+ else if (wc2 == L'\n' \|\| !iswspace (wc2))
604			+ break;
605			+
606			+ t2 += mblen2;
607			+ c2 = *t2;
608			+ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2);
609			+ }
610			+ t1 += mblen1;
611			+ t2 += mblen2;
612			+ break;
613			+
614			+ case IGNORE_SPACE_CHANGE:
615			+ /* For -b, advance past any sequence of white space in
616			+ line 1 and consider it just one space, or nothing at
617			+ all if it is at the end of the line. */
618			+ if (wc1 != L'\n' && iswspace (wc1))
619			+ {
620			+ size_t mblen_bak;
621			+ mbstate_t state_bak;
622			+
623			+ do
624			+ {
625			+ t1 += mblen1;
626			+ mblen_bak = mblen1;
627			+ state_bak = state1;
628			+ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1);
629			+ }
630			+ while (!convfail1 && (wc1 != L'\n' && iswspace (wc1)));
631			+
632			+ state1 = state_bak;
633			+ mblen1 = mblen_bak;
634			+ t1 -= mblen1;
635			+ convfail1 = 0;
636			+ wc1 = L' ';
637			+ }
638			+
639			+ /* Likewise for line 2. */
640			+ if (wc2 != L'\n' && iswspace (wc2))
641			+ {
642			+ size_t mblen_bak;
643			+ mbstate_t state_bak;
644			+
645			+ do
646			+ {
647			+ t2 += mblen2;
648			+ mblen_bak = mblen2;
649			+ state_bak = state2;
650			+ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2);
651			+ }
652			+ while (!convfail2 && (wc2 != L'\n' && iswspace (wc2)));
653			+
654			+ state2 = state_bak;
655			+ mblen2 = mblen_bak;
656			+ t2 -= mblen2;
657			+ convfail2 = 0;
658			+ wc2 = L' ';
659			+ }
660			+
661			+ if (wc1 != wc2)
662			+ {
663			+ if (wc2 == L' ' && wc1 != L'\n' &&
664			+ t1 > (unsigned char const *)s1 &&
665			+ !convfail1_bak && iswspace (wc1_bak))
666			+ {
667			+ t1 = t1_bak;
668			+ wc1 = wc1_bak;
669			+ state1 = state1_bak;
670			+ convfail1 = convfail1_bak;
671			+ continue;
672			+ }
673			+ if (wc1 == L' ' && wc2 != L'\n'
674			+ && t2 > (unsigned char const *)s2
675			+ && !convfail2_bak && iswspace (wc2_bak))
676			+ {
677			+ t2 = t2_bak;
678			+ wc2 = wc2_bak;
679			+ state2 = state2_bak;
680			+ convfail2 = convfail2_bak;
681			+ continue;
682			+ }
683			+ }
684			+
685			+ t1_bak = t1; t2_bak = t2;
686			+ wc1_bak = wc1; wc2_bak = wc2;
687			+ state1_bak = state1; state2_bak = state2;
688			+ convfail1_bak = convfail1; convfail2_bak = convfail2;
689			+
690			+ if (wc1 == L'\n')
691			+ wc1 = L' ';
692			+ else
693			+ t1 += mblen1;
694			+
695			+ if (wc2 == L'\n')
696			+ wc2 = L' ';
697			+ else
698			+ t2 += mblen2;
699			+
700			+ break;
701			+
702			+ case IGNORE_TAB_EXPANSION:
703			+ if ((wc1 == L' ' && wc2 == L'\t')
704			+ \|\| (wc1 == L'\t' && wc2 == L' '))
705			+ {
706			+ size_t column2 = column;
707			+
708			+ while (1)
709			+ {
710			+ if (convfail1)
711			+ {
712			+ ++t1;
713			+ break;
714			+ }
715			+ else if (wc1 == L' ')
716			+ column++;
717			+ else if (wc1 == L'\t')
718			+ column += TAB_WIDTH - column % TAB_WIDTH;
719			+ else
720			+ {
721			+ t1 += mblen1;
722			+ break;
723			+ }
724			+
725			+ t1 += mblen1;
726			+ c1 = *t1;
727			+ MBC2WC (t1, end1, mblen1, wc1, state1, convfail1);
728			+ }
729			+
730			+ while (1)
731			+ {
732			+ if (convfail2)
733			+ {
734			+ ++t2;
735			+ break;
736			+ }
737			+ else if (wc2 == L' ')
738			+ column2++;
739			+ else if (wc2 == L'\t')
740			+ column2 += TAB_WIDTH - column2 % TAB_WIDTH;
741			+ else
742			+ {
743			+ t2 += mblen2;
744			+ break;
745			+ }
746			+
747			+ t2 += mblen2;
748			+ c2 = *t2;
749			+ MBC2WC (t2, end2, mblen2, wc2, state2, convfail2);
750			+ }
751			+
752			+ if (column != column2)
753			+ return 1;
754			+ }
755			+ else
756			+ {
757			+ t1 += mblen1;
758			+ t2 += mblen2;
759			+ }
760			+ break;
761			+
762			+ case IGNORE_NO_WHITE_SPACE:
763			+ t1 += mblen1;
764			+ t2 += mblen2;
765			+ break;
766			+ }
767			+
768			+ /* Lowercase all letters if -i is specified. */
769			+ if (ignore_case)
770			+ {
771			+ if (!convfail1)
772			+ wc1 = towlower (wc1);
773			+ if (!convfail2)
774			+ wc2 = towlower (wc2);
775			+ }
776			+
777			+ if (convfail1 ^ convfail2)
778			+ break;
779			+ else if (convfail1 && convfail2 && c1 != c2)
780			+ break;
781			+ else if (!convfail1 && !convfail2 && wc1 != wc2)
782			+ break;
783			+ }
784			+ else
785			+ {
786			+ t1_bak = t1; t2_bak = t2;
787			+ wc1_bak = wc1; wc2_bak = wc2;
788			+ state1_bak = state1; state2_bak = state2;
789			+ convfail1_bak = convfail1; convfail2_bak = convfail2;
790			+
791			+ t1 += mblen1; t2 += mblen2;
792			+ }
793			+
794			+ if (!convfail1 && wc1 == L'\n')
795			+ return 0;
796			+
797			+ column += convfail1 ? 1 :
798			+ (wc1 == L'\t') ? TAB_WIDTH - column % TAB_WIDTH : wcwidth (wc1);
799			+ }
800			+
801			+ return 1;
802			+}
803			+#endif
804
805			/* Find the consecutive changes at the start of the script START.
806			Return the last link before the first gap. */