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,
110 char *linecharset, 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 * line_codepage should be decoded from the specification in
126 ucsdata->line_codepage = decode_codepage(linecharset);
129 * If line_codepage is _still_ CS_NONE, we assume we're using
130 * the font's own encoding. This has been passed in to us, so
131 * we use that. If it's still CS_NONE after _that_ - i.e. the
132 * font we were given had an incomprehensible charset - then we
133 * fall back to using the D800 page.
135 if (ucsdata->line_codepage == CS_NONE)
136 ucsdata->line_codepage = font_charset;
138 if (ucsdata->line_codepage == CS_NONE)
142 * Set up unitab_line, by translating each individual character
143 * in the line codepage into Unicode.
145 for (i = 0; i < 256; i++) {
152 if (ucsdata->line_codepage == CS_NONE)
153 ucsdata->unitab_line[i] = 0xD800 | i;
154 else if (1 == charset_to_unicode(&p, &len, wc, 1,
155 ucsdata->line_codepage,
157 ucsdata->unitab_line[i] = wc[0];
159 ucsdata->unitab_line[i] = 0xFFFD;
163 * Set up unitab_xterm. This is the same as unitab_line except
164 * in the line-drawing regions, where it follows the Unicode
167 * (Note that the strange X encoding of line-drawing characters
168 * in the bottom 32 glyphs of ISO8859-1 fonts is taken care of
169 * by the font encoding, which will spot such a font and act as
170 * if it were in a variant encoding of ISO8859-1.)
172 for (i = 0; i < 256; i++) {
173 static const wchar_t unitab_xterm_std[32] = {
174 0x2666, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
175 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
176 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
177 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x0020
179 static const wchar_t unitab_xterm_poorman[32] =
180 L"*#****o~**+++++-----++++|****L. ";
184 if (vtmode == VT_POORMAN)
185 ptr = unitab_xterm_poorman;
187 ptr = unitab_xterm_std;
189 if (i >= 0x5F && i < 0x7F)
190 ucsdata->unitab_xterm[i] = ptr[i & 0x1F];
192 ucsdata->unitab_xterm[i] = ucsdata->unitab_line[i];
196 * Set up unitab_scoacs. The SCO Alternate Character Set is
199 for (i = 0; i < 256; i++) {
206 if (1 == charset_to_unicode(&p, &len, wc, 1, CS_CP437, NULL, L"", 0))
207 ucsdata->unitab_scoacs[i] = wc[0];
209 ucsdata->unitab_scoacs[i] = 0xFFFD;
213 * Find the control characters in the line codepage. For
214 * direct-to-font mode using the D800 hack, we assume 00-1F and
215 * 7F are controls, but allow 80-9F through. (It's as good a
216 * guess as anything; and my bet is that half the weird fonts
217 * used in this way will be IBM or MS code pages anyway.)
219 for (i = 0; i < 256; i++) {
220 int lineval = ucsdata->unitab_line[i];
221 if (lineval < ' ' || (lineval >= 0x7F && lineval < 0xA0) ||
222 (lineval >= 0xD800 && lineval < 0xD820) || (lineval == 0xD87F))
223 ucsdata->unitab_ctrl[i] = i;
225 ucsdata->unitab_ctrl[i] = 0xFF;
231 const char *cp_name(int codepage)
233 if (codepage == CS_NONE)
234 return "Use font encoding";
235 return charset_to_localenc(codepage);
238 const char *cp_enumerate(int index)
242 return "Use font encoding";
243 charset = charset_localenc_nth(index-1);
244 if (charset == CS_NONE)
246 return charset_to_localenc(charset);
249 int decode_codepage(char *cp_name)
252 return CS_NONE; /* use font encoding */
253 return charset_from_localenc(cp_name);