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, char *mbstr, int mblen,
25 wchar_t *wcstr, int wclen)
27 if (codepage == DEFAULT_CODEPAGE) {
29 mbstate_t state = { 0 };
31 setlocale(LC_CTYPE, "");
34 size_t i = mbrtowc(wcstr+n, mbstr, (size_t)mblen, &state);
35 if (i == (size_t)-1 || i == (size_t)-2)
42 setlocale(LC_CTYPE, "C");
45 } else if (codepage == CS_NONE) {
49 wcstr[n] = 0xD800 | (mbstr[0] & 0xFF);
57 return charset_to_unicode(&mbstr, &mblen, wcstr, wclen, codepage,
61 int wc_to_mb(int codepage, int flags, wchar_t *wcstr, int wclen,
62 char *mbstr, int mblen, char *defchr, int *defused,
63 struct unicode_data *ucsdata)
65 /* FIXME: we should remove the defused param completely... */
69 if (codepage == DEFAULT_CODEPAGE) {
70 char output[MB_LEN_MAX];
71 mbstate_t state = { 0 };
74 setlocale(LC_CTYPE, "");
77 int i = wcrtomb(output, wcstr[0], &state);
78 if (i == (size_t)-1 || i > n - mblen)
80 memcpy(mbstr+n, output, i);
86 setlocale(LC_CTYPE, "C");
89 } else if (codepage == CS_NONE) {
91 while (wclen > 0 && n < mblen) {
92 if (*wcstr >= 0xD800 && *wcstr < 0xD900)
93 mbstr[n++] = (*wcstr & 0xFF);
101 return charset_from_unicode(&wcstr, &wclen, mbstr, mblen, codepage,
102 NULL, defchr?defchr:NULL, defchr?1:0);
107 * Return value is TRUE if pterm is to run in direct-to-font mode.
109 int init_ucs(struct unicode_data *ucsdata, char *linecharset,
110 int utf8_override, int font_charset, int vtmode)
115 * In the platform-independent parts of the code, font_codepage
116 * is used only for system DBCS support - which we don't
117 * support at all. So we set this to something which will never
120 ucsdata->font_codepage = -1;
123 * If utf8_override is set and the POSIX locale settings
124 * dictate a UTF-8 character set, then just go straight for
127 ucsdata->line_codepage = CS_NONE;
130 if (((s = getenv("LC_ALL")) && *s) ||
131 ((s = getenv("LC_CTYPE")) && *s) ||
132 ((s = getenv("LANG")) && *s)) {
133 if (strstr(s, "UTF-8"))
134 ucsdata->line_codepage = CS_UTF8;
139 * Failing that, line_codepage should be decoded from the
140 * specification in cfg.
142 if (ucsdata->line_codepage == CS_NONE)
143 ucsdata->line_codepage = decode_codepage(linecharset);
146 * If line_codepage is _still_ CS_NONE, we assume we're using
147 * the font's own encoding. This has been passed in to us, so
148 * we use that. If it's still CS_NONE after _that_ - i.e. the
149 * font we were given had an incomprehensible charset - then we
150 * fall back to using the D800 page.
152 if (ucsdata->line_codepage == CS_NONE)
153 ucsdata->line_codepage = font_charset;
155 if (ucsdata->line_codepage == CS_NONE)
159 * Set up unitab_line, by translating each individual character
160 * in the line codepage into Unicode.
162 for (i = 0; i < 256; i++) {
169 if (ucsdata->line_codepage == CS_NONE)
170 ucsdata->unitab_line[i] = 0xD800 | i;
171 else if (1 == charset_to_unicode(&p, &len, wc, 1,
172 ucsdata->line_codepage,
174 ucsdata->unitab_line[i] = wc[0];
176 ucsdata->unitab_line[i] = 0xFFFD;
180 * Set up unitab_xterm. This is the same as unitab_line except
181 * in the line-drawing regions, where it follows the Unicode
184 * (Note that the strange X encoding of line-drawing characters
185 * in the bottom 32 glyphs of ISO8859-1 fonts is taken care of
186 * by the font encoding, which will spot such a font and act as
187 * if it were in a variant encoding of ISO8859-1.)
189 for (i = 0; i < 256; i++) {
190 static const wchar_t unitab_xterm_std[32] = {
191 0x2666, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
192 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
193 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
194 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x0020
196 static const wchar_t unitab_xterm_poorman[32] =
197 L"*#****o~**+++++-----++++|****L. ";
201 if (vtmode == VT_POORMAN)
202 ptr = unitab_xterm_poorman;
204 ptr = unitab_xterm_std;
206 if (i >= 0x5F && i < 0x7F)
207 ucsdata->unitab_xterm[i] = ptr[i & 0x1F];
209 ucsdata->unitab_xterm[i] = ucsdata->unitab_line[i];
213 * Set up unitab_scoacs. The SCO Alternate Character Set is
216 for (i = 0; i < 256; i++) {
223 if (1 == charset_to_unicode(&p, &len, wc, 1, CS_CP437, NULL, L"", 0))
224 ucsdata->unitab_scoacs[i] = wc[0];
226 ucsdata->unitab_scoacs[i] = 0xFFFD;
230 * Find the control characters in the line codepage. For
231 * direct-to-font mode using the D800 hack, we assume 00-1F and
232 * 7F are controls, but allow 80-9F through. (It's as good a
233 * guess as anything; and my bet is that half the weird fonts
234 * used in this way will be IBM or MS code pages anyway.)
236 for (i = 0; i < 256; i++) {
237 int lineval = ucsdata->unitab_line[i];
238 if (lineval < ' ' || (lineval >= 0x7F && lineval < 0xA0) ||
239 (lineval >= 0xD800 && lineval < 0xD820) || (lineval == 0xD87F))
240 ucsdata->unitab_ctrl[i] = i;
242 ucsdata->unitab_ctrl[i] = 0xFF;
248 const char *cp_name(int codepage)
250 if (codepage == CS_NONE)
251 return "Use font encoding";
252 return charset_to_localenc(codepage);
255 const char *cp_enumerate(int index)
259 return "Use font encoding";
260 charset = charset_localenc_nth(index-1);
261 if (charset == CS_NONE)
263 return charset_to_localenc(charset);
266 int decode_codepage(char *cp_name)
269 return CS_NONE; /* use font encoding */
270 return charset_from_localenc(cp_name);