2 * Copyright (C) 2000 Edmund Grimley Evans <edmundo@rano.org>
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
20 * Japanese support by TAKIZAWA Takashi <taki@luna.email.ne.jp>.
39 int Charset_is_utf8 = 0;
41 static int charset_is_ja = 0;
42 static iconv_t charset_to_utf8 = (iconv_t)(-1);
43 static iconv_t charset_from_utf8 = (iconv_t)(-1);
46 void mutt_set_charset (char *charset)
50 mutt_canonical_charset (buffer, sizeof (buffer), charset);
55 if (charset_to_utf8 != (iconv_t)(-1))
57 iconv_close (charset_to_utf8);
58 charset_to_utf8 = (iconv_t)(-1);
60 if (charset_from_utf8 != (iconv_t)(-1))
62 iconv_close (charset_from_utf8);
63 charset_from_utf8 = (iconv_t)(-1);
67 if (!strcmp(buffer, "utf-8"))
70 else if (!ascii_strcasecmp(buffer, "euc-jp") || !ascii_strcasecmp(buffer, "shift_jis")
71 || !ascii_strcasecmp(buffer, "cp932") || !ascii_strcasecmp(buffer, "eucJP-ms"))
74 charset_to_utf8 = iconv_open ("UTF-8", charset);
75 charset_from_utf8 = iconv_open (charset, "UTF-8");
79 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
80 bind_textdomain_codeset(PACKAGE, buffer);
87 * For systems that don't have them, we provide here our own
88 * implementations of wcrtomb(), mbrtowc(), iswprint() and wcwidth().
89 * Instead of using the locale, as these functions normally would,
90 * we use Mutt's Charset variable. We support 3 types of charset:
91 * (1) For 8-bit charsets, wchar_t uses the same encoding as char.
92 * (2) For UTF-8, wchar_t uses UCS.
93 * (3) For stateless Japanese encodings, we use UCS and convert
94 * via UTF-8 using iconv.
95 * Unfortunately, we can't handle non-stateless encodings.
98 static size_t wcrtomb_iconv (char *s, wchar_t wc, iconv_t cd)
100 char buf[MB_LEN_MAX];
101 ICONV_CONST char *ib;
107 ibl = mutt_wctoutf8 (buf, wc);
108 if (ibl == (size_t)(-1))
113 r = iconv (cd, &ib, &ibl, &ob, &obl);
121 r = iconv (cd, &ib, &ibl, &ob, &obl);
126 size_t wcrtomb (char *s, wchar_t wc, mbstate_t *ps)
128 /* We only handle stateless encodings, so we can ignore ps. */
131 return mutt_wctoutf8 (s, wc);
132 else if (charset_from_utf8 != (iconv_t)(-1))
133 return wcrtomb_iconv (s, wc, charset_from_utf8);
148 size_t mbrtowc_iconv (wchar_t *pwc, const char *s, size_t n,
149 mbstate_t *ps, iconv_t cd)
151 static mbstate_t mbstate;
152 ICONV_CONST char *ib, *ibmax;
154 size_t ibl, obl, k, r;
155 char bufi[8], bufo[6];
160 t = memchr (ps, 0, sizeof (*ps));
161 k = t ? (t - (char *)ps) : sizeof (*ps);
162 if (k > sizeof (bufi))
166 /* use the buffer for input */
167 memcpy (bufi, ps, k);
169 ibmax = bufi + (k + n < sizeof (bufi) ? k + n : sizeof (bufi));
170 memcpy (bufi + k, s, ibmax - bufi - k);
174 /* use the real input */
185 r = iconv (cd, &ib, &ibl, &ob, &obl);
186 if (ob > bufo && (!k || ib > bufi + k))
188 /* we have a character */
189 memset (ps, 0, sizeof (*ps));
190 utf8rtowc (pwc, bufo, ob - bufo, &mbstate);
191 return (pwc && *pwc) ? (ib - (k ? bufi + k : s)) : 0;
193 else if (!r || (r == (size_t)(-1) && errno == EINVAL))
195 if (ib + ibl < ibmax)
196 /* try using more input */
198 else if (k && ib > bufi + k && bufi + k + n > ibmax)
200 /* switch to using real input */
201 ib = s + (ib - bufi - k);
208 /* save the state and give up */
209 memset (ps, 0, sizeof (*ps));
210 if (ibl <= sizeof (mbstate_t)) /* need extra condition here! */
211 memcpy (ps, ib, ibl);
224 size_t mbrtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)
226 static mbstate_t mbstate;
232 return utf8rtowc (pwc, s, n, ps);
233 else if (charset_to_utf8 != (iconv_t)(-1))
234 return mbrtowc_iconv (pwc, s, n, ps, charset_to_utf8);
239 memset(ps, 0, sizeof(*ps));
245 *pwc = (wchar_t)(unsigned char)*s;
250 int iswprint (wint_t wc)
252 if (Charset_is_utf8 || charset_is_ja)
253 return ((0x20 <= wc && wc < 0x7f) || 0xa0 <= wc);
255 return (0 <= wc && wc < 256) ? IsPrint (wc) : 0;
258 int iswspace (wint_t wc)
260 if (Charset_is_utf8 || charset_is_ja)
261 return (9 <= wc && wc <= 13) || wc == 32;
263 return (0 <= wc && wc < 256) ? isspace (wc) : 0;
266 static wint_t towupper_ucs (wint_t x)
268 /* Only works for x < 0x130 */
269 if ((0x60 < x && x < 0x7b) || (0xe0 <= x && x < 0xff && x != 0xf7))
271 else if (0x100 <= x && x < 0x130)
281 static wint_t towlower_ucs (wint_t x)
283 /* Only works for x < 0x130 */
284 if ((0x40 < x && x < 0x5b) || (0xc0 <= x && x < 0xdf && x != 0xd7))
286 else if (0x100 <= x && x < 0x130)
292 static int iswalnum_ucs (wint_t wc)
294 /* Only works for x < 0x220 */
302 return (0x40 < (wc & ~0x20) && (wc & ~0x20) < 0x5b);
304 return (wc == 0xaa || wc == 0xb5 || wc == 0xba);
306 return !(wc == 0xd7 || wc == 0xf7);
309 wint_t towupper (wint_t wc)
311 if (Charset_is_utf8 || charset_is_ja)
312 return towupper_ucs (wc);
314 return (0 <= wc && wc < 256) ? toupper (wc) : wc;
317 wint_t towlower (wint_t wc)
319 if (Charset_is_utf8 || charset_is_ja)
320 return towlower_ucs (wc);
322 return (0 <= wc && wc < 256) ? tolower (wc) : wc;
325 int iswalnum (wint_t wc)
327 if (Charset_is_utf8 || charset_is_ja)
328 return iswalnum_ucs (wc);
330 return (0 <= wc && wc < 256) ? isalnum (wc) : 0;
335 * Symbols, Greek and Cyrillic in JIS X 0208, Japanese Kanji
336 * Character Set, have a column width of 2.
338 int wcwidth_ja (wchar_t ucs)
341 return -1; /* continue with the normal check */
342 /* a rough range for quick check */
343 if ((ucs >= 0x00a1 && ucs <= 0x00fe) || /* Latin-1 Supplement */
344 (ucs >= 0x0391 && ucs <= 0x0451) || /* Greek and Cyrillic */
345 (ucs >= 0x2010 && ucs <= 0x266f) || /* Symbols */
346 (ucs >= 0x3000 && ucs <= 0x3020)) /* CJK Symbols and Punctuation */
352 int wcwidth_ucs(wchar_t ucs);
354 int wcwidth (wchar_t wc)
356 if (!Charset_is_utf8)
363 else if ((0 <= wc && wc < 256) && IsPrint (wc))
371 int k = wcwidth_ja (wc);
376 return wcwidth_ucs (wc);
379 size_t utf8rtowc (wchar_t *pwc, const char *s, size_t n, mbstate_t *_ps)
381 static wchar_t mbstate;
382 wchar_t *ps = (wchar_t *)_ps;
401 c = (unsigned char)*s;
414 wc = ((c & 0x1f) << 6) + (count = 0);
416 wc = ((c & 0x0f) << 12) + (count = 1);
418 wc = ((c & 0x07) << 18) + (count = 2);
420 wc = ((c & 0x03) << 24) + (count = 3);
422 wc = ((c & 0x01) << 30) + (count = 4);
432 wc = *ps & 0x7fffffff;
433 count = wc & 7; /* if count > 4 it will be caught below */
436 for (; n; ++s, --n, ++k)
438 c = (unsigned char)*s;
439 if (0x80 <= c && c < 0xc0)
441 wc |= (c & 0x3f) << (6 * count);
450 if (!(wc >> (11+count*5)))
452 errno = count < 4 ? EILSEQ : EINVAL;
466 #endif /* !HAVE_WC_FUNCS */
468 wchar_t replacement_char ()
470 return Charset_is_utf8 ? 0xfffd : '?';