source: patches/diffutils-2.8.7-i18n-1.patch @ 038f274

clfs-1.2clfs-2.1clfs-3.0.0-systemdclfs-3.0.0-sysvinitsystemdsysvinit
Last change on this file since 038f274 was 92584937, checked in by Jim Gifford <clfs@…>, 15 years ago

Added Internationalization Patch to Diffutils
  • Property mode set to 100644
File size: 17.9 KB
RevLine 
[92584937]1Submitted By: Jim Gifford <jim at cross-lfs dot org>
2Date: 2009-01-08
3Initial Package Version: 2.8.7
4Upstream Status: Unkown
5Origin: Mandriva
6Description: i18n Updates
7
8diff -Naur diffutils-2.8.7.orig/src/diff.c diffutils-2.8.7/src/diff.c
9--- diffutils-2.8.7.orig/src/diff.c     2004-04-12 00:44:35.000000000 -0700
10+++ diffutils-2.8.7/src/diff.c  2009-01-08 13:26:42.000000000 -0800
11@@ -273,6 +273,13 @@
12   re_set_syntax (RE_SYNTAX_GREP | RE_NO_POSIX_BACKTRACKING);
13   excluded = new_exclude ();
14 
15+#ifdef HANDLE_MULTIBYTE
16+  if (MB_CUR_MAX > 1)
17+    lines_differ = lines_differ_multibyte;
18+  else
19+#endif
20+    lines_differ = lines_differ_singlebyte;
21+
22   /* Decode the options.  */
23 
24   while ((c = getopt_long (argc, argv, shortopts, longopts, 0)) != -1)
25diff -Naur diffutils-2.8.7.orig/src/diff.h diffutils-2.8.7/src/diff.h
26--- diffutils-2.8.7.orig/src/diff.h     2004-04-12 00:44:35.000000000 -0700
27+++ diffutils-2.8.7/src/diff.h  2009-01-08 13:26:42.000000000 -0800
28@@ -25,6 +25,19 @@
29 #include <stdio.h>
30 #include <unlocked-io.h>
31 
32+/* For platform which support the ISO C amendement 1 functionality we
33+   support user defined character classes.  */
34+#if defined HAVE_WCTYPE_H && defined HAVE_WCHAR_H
35+/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
36+# include <wchar.h>
37+# include <wctype.h>
38+/* # if defined (HAVE_MBRTOWC) */
39+#  define HANDLE_MULTIBYTE      1
40+/* # endif */
41+#endif
42+
43+#define TAB_WIDTH 8
44+
45 /* What kind of changes a hunk contains.  */
46 enum changes
47 {
48@@ -352,7 +365,13 @@
49 extern char const pr_program[];
50 char *concat (char const *, char const *, char const *);
51 char *dir_file_pathname (char const *, char const *);
52-bool lines_differ (char const *, char const *);
53+
54+bool (*lines_differ) (char const *, char const *);
55+bool lines_differ_singlebyte (char const *, char const *);
56+#ifdef HANDLE_MULTIBYTE
57+bool lines_differ_multibyte (char const *, char const *);
58+#endif
59+
60 lin translate_line_number (struct file_data const *, lin);
61 struct change *find_change (struct change *);
62 struct change *find_reverse_change (struct change *);
63diff -Naur diffutils-2.8.7.orig/src/io.c diffutils-2.8.7/src/io.c
64--- diffutils-2.8.7.orig/src/io.c       2004-04-12 00:44:35.000000000 -0700
65+++ diffutils-2.8.7/src/io.c    2009-01-08 13:26:42.000000000 -0800
66@@ -25,6 +25,7 @@
67 #include <file-type.h>
68 #include <setmode.h>
69 #include <xalloc.h>
70+#include <assert.h>
71 
72 /* Rotate an unsigned value to the left.  */
73 #define ROL(v, n) ((v) << (n) | (v) >> (sizeof (v) * CHAR_BIT - (n)))
74@@ -212,6 +213,28 @@
75 
76 /* Split the file into lines, simultaneously computing the equivalence
77    class for each line.  */
78+#ifdef HANDLE_MULTIBYTE
79+# define MBC2WC(P, END, MBLENGTH, WC, STATE, CONVFAIL)                 \
80+do                                                                     \
81+{                                                                      \
82+    mbstate_t state_bak = STATE;                                       \
83+                                                                       \
84+    CONVFAIL = 0;                                                      \
85+    MBLENGTH = mbrtowc (&WC, P, END - (char const *)P, &STATE);                \
86+                                                                       \
87+    switch (MBLENGTH)                                                  \
88+      {                                                                        \
89+      case (size_t)-2:                                                 \
90+      case (size_t)-1:                                                 \
91+       STATE = state_bak;                                              \
92+       ++CONVFAIL;                                                     \
93+         /* Fall through. */                                           \
94+      case 0:                                                          \
95+       MBLENGTH = 1;                                                   \
96+      }                                                                        \
97+}                                                                      \
98+while (0)
99+#endif
100 
101 static void
102 find_and_hash_each_line (struct file_data *current)
103@@ -238,12 +261,280 @@
104   bool same_length_diff_contents_compare_anyway =
105     diff_length_compare_anyway | ignore_case;
106 
107+#ifdef HANDLE_MULTIBYTE
108+  wchar_t   wc;
109+  size_t    mblength;
110+  mbstate_t state;
111+  int       convfail;
112+ 
113+  memset (&state, '\0', sizeof (mbstate_t));
114+#endif
115+
116   while (p < suffix_begin)
117     {
118       char const *ip = p;
119 
120       h = 0;
121+#ifdef HANDLE_MULTIBYTE
122+      if (MB_CUR_MAX > 1)
123+       {
124+         wchar_t   lo_wc;
125+         char      mbc[MB_LEN_MAX];
126+         mbstate_t state_wc;
127+
128+         /* Hash this line until we find a newline.  */
129+         switch (ignore_white_space)
130+           {
131+           case IGNORE_ALL_SPACE:
132+             while (1)
133+               {
134+                 if (*p == '\n')
135+                   {
136+                     ++p;
137+                     break;
138+                   }
139+
140+                 MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
141+
142+                 if (convfail)
143+                   mbc[0] = *p++;
144+                 else if (!iswspace (wc))
145+                   {
146+                     bool flag = 0;
147+
148+                     if (ignore_case)
149+                       {
150+                         lo_wc = towlower (wc);
151+                         if (lo_wc != wc)
152+                           {
153+                             flag = 1;
154+
155+                             p += mblength;
156+                             memset (&state_wc, '\0', sizeof(mbstate_t));
157+                             mblength = wcrtomb (mbc, lo_wc, &state_wc);
158+
159+                             assert (mblength != (size_t)-1 &&
160+                                 mblength != (size_t)-2);
161+
162+                             mblength = (mblength < 1) ? 1 : mblength;
163+                           }
164+                       }
165+
166+                     if (!flag)
167+                       {
168+                         for (i = 0; i < mblength; i++)
169+                           mbc[i] =  *p++;
170+                       }
171+                   }
172+                 else
173+                   {
174+                     p += mblength;
175+                     continue;
176+                   }
177+
178+                 for (i = 0; i < mblength; i++)
179+                   h = HASH (h, mbc[i]);
180+               }
181+             break;
182+
183+           case IGNORE_SPACE_CHANGE:
184+             while (1)
185+               {
186+                 if (*p == '\n')
187+                   {
188+                     ++p;
189+                     break;
190+                   }
191 
192+                 MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
193+
194+                 if (!convfail && iswspace (wc))
195+                   {
196+                     while (1)
197+                       {
198+                         if (*p == '\n')
199+                           {
200+                             ++p;
201+                             goto hashing_done;
202+                           }
203+
204+                         p += mblength;
205+                         MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
206+                         if (convfail || (!convfail && !iswspace (wc)))
207+                           break;
208+                       }
209+                     h = HASH (h, ' ');
210+                   }
211+
212+                 /* WC is now the first non-space.  */
213+                 if (convfail)
214+                   mbc[0] = *p++;
215+                 else
216+                   {
217+                     bool flag = 0;
218+
219+                     if (ignore_case)
220+                       {
221+                         lo_wc = towlower (wc);
222+                         if (lo_wc != wc)
223+                           {
224+                             flag = 1;
225+
226+                             p += mblength;
227+                             memset (&state_wc, '\0', sizeof(mbstate_t));
228+                             mblength = wcrtomb (mbc, lo_wc, &state_wc);
229+
230+                             assert (mblength != (size_t)-1 &&
231+                                 mblength != (size_t)-2);
232+
233+                             mblength = (mblength < 1) ? 1 : mblength;
234+                           }
235+                       }
236+
237+                     if (!flag)
238+                       {
239+                         for (i = 0; i < mblength; i++)
240+                           mbc[i] = *p++;
241+                       }
242+                   }
243+
244+                 for (i = 0; i < mblength; i++)
245+                   h = HASH (h, mbc[i]);
246+               }
247+             break;
248+
249+           case IGNORE_TAB_EXPANSION:
250+               {
251+                 size_t column = 0;
252+
253+                 while (1)
254+                   {
255+                     if (*p == '\n')
256+                       {
257+                         ++p;
258+                         break;
259+                       }
260+
261+                     MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
262+
263+                     if (convfail)
264+                       {
265+                         h = HASH (h, *p++);
266+                         ++column;
267+                       }
268+                     else
269+                       {
270+                         bool flag;
271+
272+                         switch (wc)
273+                           {
274+                           case L'\b':
275+                             column -= 0 < column;
276+                             h = HASH (h, '\b');
277+                             ++p;
278+                             break;
279+
280+                           case L'\t':
281+                               {
282+                                 int repetitions;
283+
284+                                 repetitions = TAB_WIDTH - column % TAB_WIDTH;
285+                                 column += repetitions;
286+                                 do
287+                                   h = HASH (h, ' ');
288+                                 while (--repetitions != 0);
289+                                 ++p;
290+                               }
291+                             break;
292+
293+                           case L'\r':
294+                             column = 0;
295+                             h = HASH (h, '\r');
296+                             ++p;
297+                             break;
298+
299+                           default:
300+                             flag = 0;
301+                             column += wcwidth (wc);
302+                             if (ignore_case)
303+                               {
304+                                 lo_wc = towlower (wc);
305+                                 if (lo_wc != wc)
306+                                   {
307+                                     flag = 1;
308+                                     p += mblength;
309+                                     memset (&state_wc, '\0', sizeof(mbstate_t));
310+                                     mblength = wcrtomb (mbc, lo_wc, &state_wc);
311+
312+                                     assert (mblength != (size_t)-1 &&
313+                                         mblength != (size_t)-2);
314+
315+                                     mblength = (mblength < 1) ? 1 : mblength;
316+                                   }
317+                               }
318+
319+                             if (!flag)
320+                               {
321+                                 for (i = 0; i < mblength; i++)
322+                                   mbc[i] = *p++;
323+                               }
324+
325+                             for (i = 0; i < mblength; i++)
326+                               h = HASH (h, mbc[i]);
327+                           }
328+                       }
329+                   }
330+               }
331+             break;
332+
333+           default:
334+             while (1)
335+               {
336+                 if (*p == '\n')
337+                   {
338+                     ++p;
339+                     break;
340+                   }
341+
342+                 MBC2WC (p, suffix_begin, mblength, wc, state, convfail);
343+
344+                 if (convfail)
345+                   mbc[0] = *p++;
346+                 else
347+                   {
348+                     int flag = 0;
349+
350+                     if (ignore_case)
351+                       {
352+                         lo_wc = towlower (wc);
353+                         if (lo_wc != wc)
354+                           {
355+                             flag = 1;
356+                             p += mblength;
357+                             memset (&state_wc, '\0', sizeof(mbstate_t));
358+                             mblength = wcrtomb (mbc, lo_wc, &state_wc);
359+
360+                             assert (mblength != (size_t)-1 &&
361+                                 mblength != (size_t)-2);
362+
363+                             mblength = (mblength < 1) ? 1 : mblength;
364+                           }
365+                       }
366+
367+                     if (!flag)
368+                       {
369+                         for (i = 0; i < mblength; i++)
370+                           mbc[i] = *p++;
371+                       }
372+                   }
373+
374+                 for (i = 0; i < mblength; i++)
375+                   h = HASH (h, mbc[i]);
376+               }
377+           }
378+       }
379+      else
380+#endif
381       /* Hash this line until we find a newline.  */
382       if (ignore_case)
383        switch (ignore_white_space)
384diff -Naur diffutils-2.8.7.orig/src/side.c diffutils-2.8.7/src/side.c
385--- diffutils-2.8.7.orig/src/side.c     2004-04-12 00:44:35.000000000 -0700
386+++ diffutils-2.8.7/src/side.c  2009-01-08 13:26:42.000000000 -0800
387@@ -73,11 +73,72 @@
388   register size_t out_position = 0;
389   register char const *text_pointer = line[0];
390   register char const *text_limit = line[1];
391+#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H
392+  unsigned char mbc[MB_LEN_MAX];
393+  wchar_t wc;
394+  mbstate_t state, state_bak;
395+  size_t mbc_pos, mblength;
396+  int mbc_loading_flag = 0;
397+  int wc_width;
398+
399+  memset (&state, '\0', sizeof (mbstate_t));
400+#endif
401 
402   while (text_pointer < text_limit)
403     {
404       register unsigned char c = *text_pointer++;
405 
406+#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H
407+      if (MB_CUR_MAX > 1 && mbc_loading_flag)
408+       {
409+         mbc_loading_flag = 0;
410+         state_bak = state;
411+         mbc[mbc_pos++] = c;
412+
413+process_mbc:
414+         mblength = mbrtowc (&wc, mbc, mbc_pos, &state);
415+
416+         switch (mblength)
417+           {
418+           case (size_t)-2:    /* Incomplete multibyte character. */
419+             mbc_loading_flag = 1;
420+             state = state_bak;
421+             break;
422+
423+           case (size_t)-1:    /* Invalid as a multibyte character. */
424+             if (in_position++ < out_bound)
425+               {
426+                 out_position = in_position;
427+                 putc (mbc[0], out);
428+               }
429+             memmove (mbc, mbc + 1, --mbc_pos);
430+             if (mbc_pos > 0)
431+               {
432+                 mbc[mbc_pos] = '\0';
433+                 goto process_mbc;
434+               }
435+             break;
436+
437+           default:
438+             wc_width = wcwidth (wc);
439+             if (wc_width < 1) /* Unprintable multibyte character. */
440+               {
441+                 if (in_position <= out_bound)
442+                   fprintf (out, "%lc", (wint_t)wc);
443+               }
444+             else              /* Printable multibyte character. */
445+               {
446+                 in_position += wc_width;
447+                 if (in_position <= out_bound)
448+                   {
449+                     out_position = in_position;
450+                     fprintf (out, "%lc", (wint_t)wc);
451+                   }
452+               }
453+           }
454+         continue;
455+       }
456+#endif
457       switch (c)
458        {
459        case '\t':
460@@ -135,8 +196,39 @@
461          break;
462 
463        default:
464-         if (! isprint (c))
465-           goto control_char;
466+#if defined HAVE_WCHAR_H && defined HAVE_WCTYPE_H
467+         if (MB_CUR_MAX > 1)
468+           {
469+             memset (mbc, '\0', MB_LEN_MAX);
470+             mbc_pos = 0;
471+             mbc[mbc_pos++] = c;
472+             state_bak = state;
473+
474+             mblength = mbrtowc (&wc, mbc, mbc_pos, &state);
475+
476+             /* The value of mblength is always less than 2 here. */
477+             switch (mblength)
478+               {
479+               case (size_t)-2:        /* Incomplete multibyte character. */
480+                 state = state_bak;
481+                 mbc_loading_flag = 1;
482+                 continue;
483+
484+               case (size_t)-1:        /* Invalid as a multibyte character. */
485+                 state = state_bak;
486+                 break;
487+
488+               default:
489+                 if (! iswprint (wc))
490+                   goto control_char;
491+               }
492+           }
493+         else
494+#endif
495+           {
496+             if (! isprint (c))
497+               goto control_char;
498+           }
499          /* falls through */
500        case ' ':
501          if (in_position++ < out_bound)
502diff -Naur diffutils-2.8.7.orig/src/util.c diffutils-2.8.7/src/util.c
503--- diffutils-2.8.7.orig/src/util.c     2004-04-12 00:44:35.000000000 -0700
504+++ diffutils-2.8.7/src/util.c  2009-01-08 13:26:42.000000000 -0800
505@@ -319,7 +319,7 @@
506    Return nonzero if the lines differ.  */
507 
508 bool
509-lines_differ (char const *s1, char const *s2)
510+lines_differ_singlebyte (char const *s1, char const *s2)
511 {
512   register char const *t1 = s1;
513   register char const *t2 = s2;
514@@ -458,6 +458,293 @@
515   return start;
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 struct change *
806 find_reverse_change (struct change *start)
807 {
808
Note: See TracBrowser for help on using the repository browser.