Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/diffutils/patches/diffutils-2.8.7-i18n.patch

    Contents of /trunk/diffutils/patches/diffutils-2.8.7-i18n.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 144 - (show annotations) (download)
    Tue May 8 20:06:05 2007 UTC (16 years, 11 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. */