Annotation of /trunk/diffutils/patches/diffutils-2.8.7-i18n.patch
Parent Directory | Revision Log
Revision 144 -
(hide 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 | 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. */ |