This is the mail archive of the
newlib@sourceware.org
mailing list for the newlib project.
[PATCH] New wcwidth/wcswidth implementation (was Re: [Fwd: [1.7] wcwidth failing configure tests])
On May 12 15:47, Jeff Johnston wrote:
> Corinna Vinschen wrote:
>> On May 12 19:31, Corinna Vinschen wrote:
>>> On May 12 17:56, Andy Koppe wrote:
>>>> There's Markus Kuhn's wcwidth implementation, which says it's based on
>>>> Unicode 5.0:
>>>>
>>>> http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
>>>>
>>>[...]
>> Jeff, is that wcwidth something for newlib? I'd be willing to tweak
>> it for newlib and to add the surrogate pair handling to wcswidth.
>>
> Sure.
Patch below. It replaces wcwidth with the implementation from Markus Kuhn,
adds the _jp2uc conversion necessary for the japanese charsets, and adds
surrogate pair handling to wcwidth and wcswidth.
Tested on Cygwin. Ok to check in?
Btw., what about my question concerning upgrade of the iswXXX functions
(actually the utf8 character class tables) to Unicode 5?
Thanks,
Corinna
* libc/string/local.h: New file.
* libc/string/wcswidth.c (wcswidth): Convert japanese wide
characters to Unicode here. Handle surrogate pairs for UTF-16
systems. Call __wcwidth rather than wcwidth.
* libc/string/wcwidth.c: New implementation using Markus Kuhn's
wcwidth implementation for Unicode.
(bisearch): New static function.
(__wcwidth): New function. Take wint_t rather than wchar_t as
parameter to allow full Unicode handling on UTF-16 systems.
(wcwidth): Convert japanese wide characters to Unicode here.
Call __wcwidth rather than using iswprint/iswcntrl.
Index: libc/string/local.h
===================================================================
RCS file: libc/string/local.h
diff -N libc/string/local.h
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ libc/string/local.h 13 May 2009 08:58:13 -0000
@@ -0,0 +1,14 @@
+#include <_ansi.h>
+
+extern char *__locale_charset ();
+
+/* Japanese encoding types supported */
+#define JP_JIS 1
+#define JP_SJIS 2
+#define JP_EUCJP 3
+
+/* internal function to translate JP to Unicode */
+wint_t _EXFUN (__jp2uc, (wint_t, int));
+
+/* internal function to compute width of wide char. */
+int _EXFUN (__wcwidth, (wint_t));
Index: libc/string/wcswidth.c
===================================================================
RCS file: /cvs/src/src/newlib/libc/string/wcswidth.c,v
retrieving revision 1.2
diff -u -p -r1.2 wcswidth.c
--- libc/string/wcswidth.c 28 Oct 2005 21:21:07 -0000 1.2
+++ libc/string/wcswidth.c 13 May 2009 08:58:13 -0000
@@ -37,6 +37,7 @@ PORTABILITY
#include <_ansi.h>
#include <wchar.h>
+#include "local.h"
int
_DEFUN (wcswidth, (pwcs, n),
@@ -48,7 +49,27 @@ _DEFUN (wcswidth, (pwcs, n),
if (!pwcs || n == 0)
return 0;
do {
- if ((w = wcwidth (*pwcs)) < 0)
+ wint_t wi = *pwcs;
+
+ if (!strcmp (__locale_charset (), "JIS"))
+ wi = __jp2uc (wi, JP_JIS);
+ else if (!strcmp (__locale_charset (), "SJIS"))
+ wi = __jp2uc (wi, JP_SJIS);
+ else if (!strcmp (__locale_charset (), "EUCJP"))
+ wi = __jp2uc (wi, JP_EUCJP);
+
+ /* First half of a surrogate pair? */
+ if (sizeof (wchar_t) == 2 && wi >= 0xd800 && wi <= 0xdbff)
+ {
+ wint_t wi2;
+
+ /* Extract second half and check for validity. */
+ if (--n == 0 || (wi2 = *++pwcs) < 0xdc00 || wi2 > 0xdfff)
+ return -1;
+ /* Compute actual unicode value to use in call to __wcwidth. */
+ wi = (((wi & 0x3ff) << 10) | (wi2 & 0x3ff)) + 0x10000;
+ }
+ if ((w = __wcwidth (wi)) < 0)
return -1;
len += w;
} while (*pwcs++ && --n > 0);
Index: libc/string/wcwidth.c
===================================================================
RCS file: /cvs/src/src/newlib/libc/string/wcwidth.c,v
retrieving revision 1.2
diff -u -p -r1.2 wcwidth.c
--- libc/string/wcwidth.c 28 Oct 2005 21:21:07 -0000 1.2
+++ libc/string/wcwidth.c 13 May 2009 08:58:13 -0000
@@ -27,27 +27,238 @@ RETURNS
be occupied by the wide-character code <[wc]>, or return -1 (if <[wc]>
does not correspond to a printable wide-character code).
- The current implementation of <<wcwidth>> simply sets the width
- of all printable characters to 1 since newlib has no character
- tables around.
-
PORTABILITY
<<wcwidth>> has been introduced in the Single UNIX Specification Volume 2.
<<wcwidth>> has been marked as an extension in the Single UNIX Specification Volume 3.
*/
+/*
+ * This is an implementation of wcwidth() (defined in
+ * IEEE Std 1002.1-2001) for Unicode.
+ *
+ * http://www.opengroup.org/onlinepubs/007904975/functions/wcwidth.html
+ *
+ * In fixed-width output devices, Latin characters all occupy a single
+ * "cell" position of equal width, whereas ideographic CJK characters
+ * occupy two such cells. Interoperability between terminal-line
+ * applications and (teletype-style) character terminals using the
+ * UTF-8 encoding requires agreement on which character should advance
+ * the cursor by how many cell positions. No established formal
+ * standards exist at present on which Unicode character shall occupy
+ * how many cell positions on character terminals. These routines are
+ * a first attempt of defining such behavior based on simple rules
+ * applied to data provided by the Unicode Consortium.
+ *
+ * For some graphical characters, the Unicode standard explicitly
+ * defines a character-cell width via the definition of the East Asian
+ * FullWidth (F), Wide (W), Half-width (H), and Narrow (Na) classes.
+ * In all these cases, there is no ambiguity about which width a
+ * terminal shall use. For characters in the East Asian Ambiguous (A)
+ * class, the width choice depends purely on a preference of backward
+ * compatibility with either historic CJK or Western practice.
+ * Choosing single-width for these characters is easy to justify as
+ * the appropriate long-term solution, as the CJK practice of
+ * displaying these characters as double-width comes from historic
+ * implementation simplicity (8-bit encoded characters were displayed
+ * single-width and 16-bit ones double-width, even for Greek,
+ * Cyrillic, etc.) and not any typographic considerations.
+ *
+ * Much less clear is the choice of width for the Not East Asian
+ * (Neutral) class. Existing practice does not dictate a width for any
+ * of these characters. It would nevertheless make sense
+ * typographically to allocate two character cells to characters such
+ * as for instance EM SPACE or VOLUME INTEGRAL, which cannot be
+ * represented adequately with a single-width glyph. The following
+ * routines at present merely assign a single-cell width to all
+ * neutral characters, in the interest of simplicity. This is not
+ * entirely satisfactory and should be reconsidered before
+ * establishing a formal standard in this area. At the moment, the
+ * decision which Not East Asian (Neutral) characters should be
+ * represented by double-width glyphs cannot yet be answered by
+ * applying a simple rule from the Unicode database content. Setting
+ * up a proper standard for the behavior of UTF-8 character terminals
+ * will require a careful analysis not only of each Unicode character,
+ * but also of each presentation form, something the author of these
+ * routines has avoided to do so far.
+ *
+ * http://www.unicode.org/unicode/reports/tr11/
+ *
+ * Markus Kuhn -- 2007-05-26 (Unicode 5.0)
+ *
+ * Permission to use, copy, modify, and distribute this software
+ * for any purpose and without fee is hereby granted. The author
+ * disclaims all warranties with regard to this software.
+ *
+ * Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
+ */
+
#include <_ansi.h>
#include <wchar.h>
-#include <wctype.h>
+#include "local.h"
+
+struct interval
+{
+ int first;
+ int last;
+};
+
+/* auxiliary function for binary search in interval table */
+static int
+bisearch(wint_t ucs, const struct interval *table, int max)
+{
+ int min = 0;
+ int mid;
+
+ if (ucs < table[0].first || ucs > table[max].last)
+ return 0;
+ while (max >= min)
+ {
+ mid = (min + max) / 2;
+ if (ucs > table[mid].last)
+ min = mid + 1;
+ else if (ucs < table[mid].first)
+ max = mid - 1;
+ else
+ return 1;
+ }
+
+ return 0;
+}
+
+
+/* The following two functions define the column width of an ISO 10646
+ * character as follows:
+ *
+ * - The null character (U+0000) has a column width of 0.
+ *
+ * - Other C0/C1 control characters and DEL will lead to a return
+ * value of -1.
+ *
+ * - Non-spacing and enclosing combining characters (general
+ * category code Mn or Me in the Unicode database) have a
+ * column width of 0.
+ *
+ * - SOFT HYPHEN (U+00AD) has a column width of 1.
+ *
+ * - Other format characters (general category code Cf in the Unicode
+ * database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
+ *
+ * - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+ * have a column width of 0.
+ *
+ * - Spacing characters in the East Asian Wide (W) or East Asian
+ * Full-width (F) category as defined in Unicode Technical
+ * Report #11 have a column width of 2.
+ *
+ * - All remaining characters (including all printable
+ * ISO 8859-1 and WGL4 characters, Unicode control characters,
+ * etc.) have a column width of 1.
+ *
+ * This implementation assumes that wchar_t characters are encoded
+ * in ISO 10646.
+ */
int
+_DEFUN (__wcwidth, (ucs),
+ _CONST wint_t ucs)
+{
+ /* sorted list of non-overlapping intervals of non-spacing characters */
+ /* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
+ static const struct interval combining[] = {
+ { 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },
+ { 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
+ { 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },
+ { 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },
+ { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
+ { 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },
+ { 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },
+ { 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },
+ { 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },
+ { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },
+ { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },
+ { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
+ { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },
+ { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },
+ { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
+ { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
+ { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
+ { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
+ { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },
+ { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },
+ { 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
+ { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
+ { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
+ { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
+ { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
+ { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
+ { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
+ { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
+ { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
+ { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },
+ { 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },
+ { 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },
+ { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },
+ { 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },
+ { 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },
+ { 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },
+ { 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },
+ { 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },
+ { 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },
+ { 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },
+ { 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },
+ { 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },
+ { 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },
+ { 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },
+ { 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },
+ { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },
+ { 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },
+ { 0xE0100, 0xE01EF }
+ };
+
+ /* test for 8-bit control characters */
+ if (ucs == 0)
+ return 0;
+ if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
+ return -1;
+ /* Test for surrogate pair values. */
+ if (ucs >= 0xd800 && ucs <= 0xdfff)
+ return -1;
+
+ /* binary search in table of non-spacing characters */
+ if (bisearch(ucs, combining,
+ sizeof(combining) / sizeof(struct interval) - 1))
+ return 0;
+
+ /* if we arrive here, ucs is not a combining or C0/C1 control character */
+
+ return 1 +
+ (ucs >= 0x1100 &&
+ (ucs <= 0x115f || /* Hangul Jamo init. consonants */
+ ucs == 0x2329 || ucs == 0x232a ||
+ (ucs >= 0x2e80 && ucs <= 0xa4cf &&
+ ucs != 0x303f) || /* CJK ... Yi */
+ (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
+ (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
+ (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
+ (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
+ (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
+ (ucs >= 0xffe0 && ucs <= 0xffe6) ||
+ (ucs >= 0x20000 && ucs <= 0x2fffd) ||
+ (ucs >= 0x30000 && ucs <= 0x3fffd)));
+}
+
+int
_DEFUN (wcwidth, (wc),
_CONST wchar_t wc)
+{
+ wint_t wi = wc;
-{
- if (iswprint (wc))
- return 1;
- if (iswcntrl (wc) || wc == L'\0')
- return 0;
- return -1;
+ if (!strcmp (__locale_charset (), "JIS"))
+ wi = __jp2uc (wi, JP_JIS);
+ else if (!strcmp (__locale_charset (), "SJIS"))
+ wi = __jp2uc (wi, JP_SJIS);
+ else if (!strcmp (__locale_charset (), "EUCJP"))
+ wi = __jp2uc (wi, JP_EUCJP);
+
+ return __wcwidth (wi);
}
--
Corinna Vinschen
Cygwin Project Co-Leader
Red Hat