Contents of /trunk/diffutils/patches/diffutils-2.8.7-i18n.patch
Parent Directory | Revision Log
Revision 144 -
(show annotations)
(download)
Tue May 8 20:06:05 2007 UTC (17 years, 4 months ago) by niro
File size: 26761 byte(s)
Tue May 8 20:06:05 2007 UTC (17 years, 4 months ago) by niro
File size: 26761 byte(s)
-import
1 | 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. */ |