16 * Unix Unicode-handling routines.
19 int is_dbcs_leadbyte(int codepage, char byte)
21 return 0; /* we don't do DBCS */
24 int mb_to_wc(int codepage, int flags, const char *mbstr, int mblen,
25 wchar_t *wcstr, int wclen)
27 if (codepage == DEFAULT_CODEPAGE) {
31 memset(&state, 0, sizeof state);
32 setlocale(LC_CTYPE, "");
35 size_t i = mbrtowc(wcstr+n, mbstr, (size_t)mblen, &state);
36 if (i == (size_t)-1 || i == (size_t)-2)
43 setlocale(LC_CTYPE, "C");
46 } else if (codepage == CS_NONE) {
50 wcstr[n] = 0xD800 | (mbstr[0] & 0xFF);
58 return charset_to_unicode(&mbstr, &mblen, wcstr, wclen, codepage,
62 int wc_to_mb(int codepage, int flags, const wchar_t *wcstr, int wclen,
63 char *mbstr, int mblen, char *defchr, int *defused,
64 struct unicode_data *ucsdata)
66 /* FIXME: we should remove the defused param completely... */
70 if (codepage == DEFAULT_CODEPAGE) {
71 char output[MB_LEN_MAX];
75 memset(&state, 0, sizeof state);
76 setlocale(LC_CTYPE, "");
79 int i = wcrtomb(output, wcstr[0], &state);
80 if (i == (size_t)-1 || i > n - mblen)
82 memcpy(mbstr+n, output, i);
88 setlocale(LC_CTYPE, "C");
91 } else if (codepage == CS_NONE) {
93 while (wclen > 0 && n < mblen) {
94 if (*wcstr >= 0xD800 && *wcstr < 0xD900)
95 mbstr[n++] = (*wcstr & 0xFF);
103 return charset_from_unicode(&wcstr, &wclen, mbstr, mblen, codepage,
104 NULL, defchr?defchr:NULL, defchr?1:0);
109 * Return value is TRUE if pterm is to run in direct-to-font mode.
111 int init_ucs(struct unicode_data *ucsdata, char *linecharset,
112 int utf8_override, int font_charset, int vtmode)
117 * In the platform-independent parts of the code, font_codepage
118 * is used only for system DBCS support - which we don't
119 * support at all. So we set this to something which will never
122 ucsdata->font_codepage = -1;
125 * If utf8_override is set and the POSIX locale settings
126 * dictate a UTF-8 character set, then just go straight for
129 ucsdata->line_codepage = CS_NONE;
132 if (((s = getenv("LC_ALL")) && *s) ||
133 ((s = getenv("LC_CTYPE")) && *s) ||
134 ((s = getenv("LANG")) && *s)) {
135 if (strstr(s, "UTF-8"))
136 ucsdata->line_codepage = CS_UTF8;
141 * Failing that, line_codepage should be decoded from the
142 * specification in conf.
144 if (ucsdata->line_codepage == CS_NONE)
145 ucsdata->line_codepage = decode_codepage(linecharset);
148 * If line_codepage is _still_ CS_NONE, we assume we're using
149 * the font's own encoding. This has been passed in to us, so
150 * we use that. If it's still CS_NONE after _that_ - i.e. the
151 * font we were given had an incomprehensible charset - then we
152 * fall back to using the D800 page.
154 if (ucsdata->line_codepage == CS_NONE)
155 ucsdata->line_codepage = font_charset;
157 if (ucsdata->line_codepage == CS_NONE)
161 * Set up unitab_line, by translating each individual character
162 * in the line codepage into Unicode.
164 for (i = 0; i < 256; i++) {
172 if (ucsdata->line_codepage == CS_NONE)
173 ucsdata->unitab_line[i] = 0xD800 | i;
174 else if (1 == charset_to_unicode(&p, &len, wc, 1,
175 ucsdata->line_codepage,
177 ucsdata->unitab_line[i] = wc[0];
179 ucsdata->unitab_line[i] = 0xFFFD;
183 * Set up unitab_xterm. This is the same as unitab_line except
184 * in the line-drawing regions, where it follows the Unicode
187 * (Note that the strange X encoding of line-drawing characters
188 * in the bottom 32 glyphs of ISO8859-1 fonts is taken care of
189 * by the font encoding, which will spot such a font and act as
190 * if it were in a variant encoding of ISO8859-1.)
192 for (i = 0; i < 256; i++) {
193 static const wchar_t unitab_xterm_std[32] = {
194 0x2666, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
195 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
196 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
197 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x0020
199 static const wchar_t unitab_xterm_poorman[32] =
200 L"*#****o~**+++++-----++++|****L. ";
204 if (vtmode == VT_POORMAN)
205 ptr = unitab_xterm_poorman;
207 ptr = unitab_xterm_std;
209 if (i >= 0x5F && i < 0x7F)
210 ucsdata->unitab_xterm[i] = ptr[i & 0x1F];
212 ucsdata->unitab_xterm[i] = ucsdata->unitab_line[i];
216 * Set up unitab_scoacs. The SCO Alternate Character Set is
219 for (i = 0; i < 256; i++) {
227 if (1 == charset_to_unicode(&p, &len, wc, 1, CS_CP437, NULL, L"", 0))
228 ucsdata->unitab_scoacs[i] = wc[0];
230 ucsdata->unitab_scoacs[i] = 0xFFFD;
234 * Find the control characters in the line codepage. For
235 * direct-to-font mode using the D800 hack, we assume 00-1F and
236 * 7F are controls, but allow 80-9F through. (It's as good a
237 * guess as anything; and my bet is that half the weird fonts
238 * used in this way will be IBM or MS code pages anyway.)
240 for (i = 0; i < 256; i++) {
241 int lineval = ucsdata->unitab_line[i];
242 if (lineval < ' ' || (lineval >= 0x7F && lineval < 0xA0) ||
243 (lineval >= 0xD800 && lineval < 0xD820) || (lineval == 0xD87F))
244 ucsdata->unitab_ctrl[i] = i;
246 ucsdata->unitab_ctrl[i] = 0xFF;
252 const char *cp_name(int codepage)
254 if (codepage == CS_NONE)
255 return "Use font encoding";
256 return charset_to_localenc(codepage);
259 const char *cp_enumerate(int index)
263 return "Use font encoding";
264 charset = charset_localenc_nth(index-1);
265 if (charset == CS_NONE)
267 return charset_to_localenc(charset);
270 int decode_codepage(char *cp_name)
273 return CS_NONE; /* use font encoding */
274 return charset_from_localenc(cp_name);