projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
The WinSock library is now loaded at run-time, which means we can
[u/mdw/putty] / unicode.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <ctype.h>
4 #include <time.h>
5 #include <assert.h>
6
7 #include "putty.h"
8 #include "terminal.h"
9 #include "misc.h"
10
11 /* Character conversion arrays; they are usually taken from windows,
12 * the xterm one has the four scanlines that have no unicode 2.0
13 * equivalents mapped to their unicode 3.0 locations.
14 */
15 static const WCHAR unitab_xterm_std[32] = {
16 0x2666, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
17 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
18 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
19 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, 0x0020
20 };
21
22 /*
23 * If the codepage is non-zero it's a window codepage, zero means use a
24 * local codepage. The name is always converted to the first of any
25 * duplicate definitions.
26 */
27
28 /*
29 * Tables for ISO-8859-{1-10,13-16} derived from those downloaded
30 * 2001-10-02 from <http://www.unicode.org/Public/MAPPINGS/> -- jtn
31 * Table for ISO-8859-11 derived from same on 2002-11-18. -- bjh21
32 */
33
34 /* XXX: This could be done algorithmically, but I'm not sure it's
35 * worth the hassle -- jtn */
36 /* ISO/IEC 8859-1:1998 (Latin-1, "Western", "West European") */
37 static const wchar_t iso_8859_1[] = {
38 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
39 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
40 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
41 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
42 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
43 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
44 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
45 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
46 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
47 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
48 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
49 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
50 };
51
52 /* ISO/IEC 8859-2:1999 (Latin-2, "Central European", "East European") */
53 static const wchar_t iso_8859_2[] = {
54 0x00A0, 0x0104, 0x02D8, 0x0141, 0x00A4, 0x013D, 0x015A, 0x00A7,
55 0x00A8, 0x0160, 0x015E, 0x0164, 0x0179, 0x00AD, 0x017D, 0x017B,
56 0x00B0, 0x0105, 0x02DB, 0x0142, 0x00B4, 0x013E, 0x015B, 0x02C7,
57 0x00B8, 0x0161, 0x015F, 0x0165, 0x017A, 0x02DD, 0x017E, 0x017C,
58 0x0154, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0139, 0x0106, 0x00C7,
59 0x010C, 0x00C9, 0x0118, 0x00CB, 0x011A, 0x00CD, 0x00CE, 0x010E,
60 0x0110, 0x0143, 0x0147, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x00D7,
61 0x0158, 0x016E, 0x00DA, 0x0170, 0x00DC, 0x00DD, 0x0162, 0x00DF,
62 0x0155, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x013A, 0x0107, 0x00E7,
63 0x010D, 0x00E9, 0x0119, 0x00EB, 0x011B, 0x00ED, 0x00EE, 0x010F,
64 0x0111, 0x0144, 0x0148, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x00F7,
65 0x0159, 0x016F, 0x00FA, 0x0171, 0x00FC, 0x00FD, 0x0163, 0x02D9
66 };
67
68 /* ISO/IEC 8859-3:1999 (Latin-3, "South European", "Maltese & Esperanto") */
69 static const wchar_t iso_8859_3[] = {
70 0x00A0, 0x0126, 0x02D8, 0x00A3, 0x00A4, 0xFFFD, 0x0124, 0x00A7,
71 0x00A8, 0x0130, 0x015E, 0x011E, 0x0134, 0x00AD, 0xFFFD, 0x017B,
72 0x00B0, 0x0127, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x0125, 0x00B7,
73 0x00B8, 0x0131, 0x015F, 0x011F, 0x0135, 0x00BD, 0xFFFD, 0x017C,
74 0x00C0, 0x00C1, 0x00C2, 0xFFFD, 0x00C4, 0x010A, 0x0108, 0x00C7,
75 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
76 0xFFFD, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x0120, 0x00D6, 0x00D7,
77 0x011C, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x016C, 0x015C, 0x00DF,
78 0x00E0, 0x00E1, 0x00E2, 0xFFFD, 0x00E4, 0x010B, 0x0109, 0x00E7,
79 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
80 0xFFFD, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x0121, 0x00F6, 0x00F7,
81 0x011D, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x016D, 0x015D, 0x02D9
82 };
83
84 /* ISO/IEC 8859-4:1998 (Latin-4, "North European") */
85 static const wchar_t iso_8859_4[] = {
86 0x00A0, 0x0104, 0x0138, 0x0156, 0x00A4, 0x0128, 0x013B, 0x00A7,
87 0x00A8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00AD, 0x017D, 0x00AF,
88 0x00B0, 0x0105, 0x02DB, 0x0157, 0x00B4, 0x0129, 0x013C, 0x02C7,
89 0x00B8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014A, 0x017E, 0x014B,
90 0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
91 0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x012A,
92 0x0110, 0x0145, 0x014C, 0x0136, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
93 0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x0168, 0x016A, 0x00DF,
94 0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
95 0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x012B,
96 0x0111, 0x0146, 0x014D, 0x0137, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
97 0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x0169, 0x016B, 0x02D9
98 };
99
100 /* ISO/IEC 8859-5:1999 (Latin/Cyrillic) */
101 static const wchar_t iso_8859_5[] = {
102 0x00A0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
103 0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x00AD, 0x040E, 0x040F,
104 0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
105 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
106 0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
107 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
108 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
109 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
110 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
111 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
112 0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
113 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x00A7, 0x045E, 0x045F
114 };
115
116 /* ISO/IEC 8859-6:1999 (Latin/Arabic) */
117 static const wchar_t iso_8859_6[] = {
118 0x00A0, 0xFFFD, 0xFFFD, 0xFFFD, 0x00A4, 0xFFFD, 0xFFFD, 0xFFFD,
119 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x060C, 0x00AD, 0xFFFD, 0xFFFD,
120 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
121 0xFFFD, 0xFFFD, 0xFFFD, 0x061B, 0xFFFD, 0xFFFD, 0xFFFD, 0x061F,
122 0xFFFD, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
123 0x0628, 0x0629, 0x062A, 0x062B, 0x062C, 0x062D, 0x062E, 0x062F,
124 0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
125 0x0638, 0x0639, 0x063A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
126 0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
127 0x0648, 0x0649, 0x064A, 0x064B, 0x064C, 0x064D, 0x064E, 0x064F,
128 0x0650, 0x0651, 0x0652, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
129 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD
130 };
131
132 /* ISO 8859-7:1987 (Latin/Greek) */
133 static const wchar_t iso_8859_7[] = {
134 0x00A0, 0x2018, 0x2019, 0x00A3, 0xFFFD, 0xFFFD, 0x00A6, 0x00A7,
135 0x00A8, 0x00A9, 0xFFFD, 0x00AB, 0x00AC, 0x00AD, 0xFFFD, 0x2015,
136 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x0384, 0x0385, 0x0386, 0x00B7,
137 0x0388, 0x0389, 0x038A, 0x00BB, 0x038C, 0x00BD, 0x038E, 0x038F,
138 0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
139 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
140 0x03A0, 0x03A1, 0xFFFD, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7,
141 0x03A8, 0x03A9, 0x03AA, 0x03AB, 0x03AC, 0x03AD, 0x03AE, 0x03AF,
142 0x03B0, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7,
143 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
144 0x03C0, 0x03C1, 0x03C2, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7,
145 0x03C8, 0x03C9, 0x03CA, 0x03CB, 0x03CC, 0x03CD, 0x03CE, 0xFFFD
146 };
147
148 /* ISO/IEC 8859-8:1999 (Latin/Hebrew) */
149 static const wchar_t iso_8859_8[] = {
150 0x00A0, 0xFFFD, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
151 0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
152 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
153 0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0xFFFD,
154 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
155 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
156 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
157 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2017,
158 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
159 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
160 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
161 0x05E8, 0x05E9, 0x05EA, 0xFFFD, 0xFFFD, 0x200E, 0x200F, 0xFFFD
162 };
163
164 /* ISO/IEC 8859-9:1999 (Latin-5, "Turkish") */
165 static const wchar_t iso_8859_9[] = {
166 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
167 0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
168 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
169 0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
170 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
171 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
172 0x011E, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
173 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0130, 0x015E, 0x00DF,
174 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
175 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
176 0x011F, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
177 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0131, 0x015F, 0x00FF
178 };
179
180 /* ISO/IEC 8859-10:1998 (Latin-6, "Nordic" [Sami, Inuit, Icelandic]) */
181 static const wchar_t iso_8859_10[] = {
182 0x00A0, 0x0104, 0x0112, 0x0122, 0x012A, 0x0128, 0x0136, 0x00A7,
183 0x013B, 0x0110, 0x0160, 0x0166, 0x017D, 0x00AD, 0x016A, 0x014A,
184 0x00B0, 0x0105, 0x0113, 0x0123, 0x012B, 0x0129, 0x0137, 0x00B7,
185 0x013C, 0x0111, 0x0161, 0x0167, 0x017E, 0x2015, 0x016B, 0x014B,
186 0x0100, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x012E,
187 0x010C, 0x00C9, 0x0118, 0x00CB, 0x0116, 0x00CD, 0x00CE, 0x00CF,
188 0x00D0, 0x0145, 0x014C, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0168,
189 0x00D8, 0x0172, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
190 0x0101, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x012F,
191 0x010D, 0x00E9, 0x0119, 0x00EB, 0x0117, 0x00ED, 0x00EE, 0x00EF,
192 0x00F0, 0x0146, 0x014D, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0169,
193 0x00F8, 0x0173, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x0138
194 };
195
196 /* ISO/IEC 8859-11:2001 ("Thai", "TIS620") */
197 static const wchar_t iso_8859_11[] = {
198 0x00A0, 0x0E01, 0x0E02, 0x0E03, 0x0E04, 0x0E05, 0x0E06, 0x0E07,
199 0x0E08, 0x0E09, 0x0E0A, 0x0E0B, 0x0E0C, 0x0E0D, 0x0E0E, 0x0E0F,
200 0x0E10, 0x0E11, 0x0E12, 0x0E13, 0x0E14, 0x0E15, 0x0E16, 0x0E17,
201 0x0E18, 0x0E19, 0x0E1A, 0x0E1B, 0x0E1C, 0x0E1D, 0x0E1E, 0x0E1F,
202 0x0E20, 0x0E21, 0x0E22, 0x0E23, 0x0E24, 0x0E25, 0x0E26, 0x0E27,
203 0x0E28, 0x0E29, 0x0E2A, 0x0E2B, 0x0E2C, 0x0E2D, 0x0E2E, 0x0E2F,
204 0x0E30, 0x0E31, 0x0E32, 0x0E33, 0x0E34, 0x0E35, 0x0E36, 0x0E37,
205 0x0E38, 0x0E39, 0x0E3A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0E3F,
206 0x0E40, 0x0E41, 0x0E42, 0x0E43, 0x0E44, 0x0E45, 0x0E46, 0x0E47,
207 0x0E48, 0x0E49, 0x0E4A, 0x0E4B, 0x0E4C, 0x0E4D, 0x0E4E, 0x0E4F,
208 0x0E50, 0x0E51, 0x0E52, 0x0E53, 0x0E54, 0x0E55, 0x0E56, 0x0E57,
209 0x0E58, 0x0E59, 0x0E5A, 0x0E5B, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD
210 };
211
212 /* ISO/IEC 8859-13:1998 (Latin-7, "Baltic Rim") */
213 static const wchar_t iso_8859_13[] = {
214 0x00A0, 0x201D, 0x00A2, 0x00A3, 0x00A4, 0x201E, 0x00A6, 0x00A7,
215 0x00D8, 0x00A9, 0x0156, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00C6,
216 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x201C, 0x00B5, 0x00B6, 0x00B7,
217 0x00F8, 0x00B9, 0x0157, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00E6,
218 0x0104, 0x012E, 0x0100, 0x0106, 0x00C4, 0x00C5, 0x0118, 0x0112,
219 0x010C, 0x00C9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012A, 0x013B,
220 0x0160, 0x0143, 0x0145, 0x00D3, 0x014C, 0x00D5, 0x00D6, 0x00D7,
221 0x0172, 0x0141, 0x015A, 0x016A, 0x00DC, 0x017B, 0x017D, 0x00DF,
222 0x0105, 0x012F, 0x0101, 0x0107, 0x00E4, 0x00E5, 0x0119, 0x0113,
223 0x010D, 0x00E9, 0x017A, 0x0117, 0x0123, 0x0137, 0x012B, 0x013C,
224 0x0161, 0x0144, 0x0146, 0x00F3, 0x014D, 0x00F5, 0x00F6, 0x00F7,
225 0x0173, 0x0142, 0x015B, 0x016B, 0x00FC, 0x017C, 0x017E, 0x2019
226 };
227
228 /* ISO/IEC 8859-14:1998 (Latin-8, "Celtic", "Gaelic/Welsh") */
229 static const wchar_t iso_8859_14[] = {
230 0x00A0, 0x1E02, 0x1E03, 0x00A3, 0x010A, 0x010B, 0x1E0A, 0x00A7,
231 0x1E80, 0x00A9, 0x1E82, 0x1E0B, 0x1EF2, 0x00AD, 0x00AE, 0x0178,
232 0x1E1E, 0x1E1F, 0x0120, 0x0121, 0x1E40, 0x1E41, 0x00B6, 0x1E56,
233 0x1E81, 0x1E57, 0x1E83, 0x1E60, 0x1EF3, 0x1E84, 0x1E85, 0x1E61,
234 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
235 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
236 0x0174, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x1E6A,
237 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x0176, 0x00DF,
238 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
239 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
240 0x0175, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x1E6B,
241 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x0177, 0x00FF
242 };
243
244 /* ISO/IEC 8859-15:1999 (Latin-9 aka -0, "euro") */
245 static const wchar_t iso_8859_15[] = {
246 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AC, 0x00A5, 0x0160, 0x00A7,
247 0x0161, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
248 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x017D, 0x00B5, 0x00B6, 0x00B7,
249 0x017E, 0x00B9, 0x00BA, 0x00BB, 0x0152, 0x0153, 0x0178, 0x00BF,
250 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
251 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
252 0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
253 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
254 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
255 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
256 0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
257 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
258 };
259
260 /* ISO/IEC 8859-16:2001 (Latin-10, "Balkan") */
261 static const wchar_t iso_8859_16[] = {
262 0x00A0, 0x0104, 0x0105, 0x0141, 0x20AC, 0x201E, 0x0160, 0x00A7,
263 0x0161, 0x00A9, 0x0218, 0x00AB, 0x0179, 0x00AD, 0x017A, 0x017B,
264 0x00B0, 0x00B1, 0x010C, 0x0142, 0x017D, 0x201D, 0x00B6, 0x00B7,
265 0x017E, 0x010D, 0x0219, 0x00BB, 0x0152, 0x0153, 0x0178, 0x017C,
266 0x00C0, 0x00C1, 0x00C2, 0x0102, 0x00C4, 0x0106, 0x00C6, 0x00C7,
267 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
268 0x0110, 0x0143, 0x00D2, 0x00D3, 0x00D4, 0x0150, 0x00D6, 0x015A,
269 0x0170, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0118, 0x021A, 0x00DF,
270 0x00E0, 0x00E1, 0x00E2, 0x0103, 0x00E4, 0x0107, 0x00E6, 0x00E7,
271 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
272 0x0111, 0x0144, 0x00F2, 0x00F3, 0x00F4, 0x0151, 0x00F6, 0x015B,
273 0x0171, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x0119, 0x021B, 0x00FF
274 };
275
276 static const wchar_t roman8[] = {
277 0x00A0, 0x00C0, 0x00C2, 0x00C8, 0x00CA, 0x00CB, 0x00CE, 0x00CF,
278 0x00B4, 0x02CB, 0x02C6, 0x00A8, 0x02DC, 0x00D9, 0x00DB, 0x20A4,
279 0x00AF, 0x00DD, 0x00FD, 0x00B0, 0x00C7, 0x00E7, 0x00D1, 0x00F1,
280 0x00A1, 0x00BF, 0x00A4, 0x00A3, 0x00A5, 0x00A7, 0x0192, 0x00A2,
281 0x00E2, 0x00EA, 0x00F4, 0x00FB, 0x00E1, 0x00E9, 0x00F3, 0x00FA,
282 0x00E0, 0x00E8, 0x00F2, 0x00F9, 0x00E4, 0x00EB, 0x00F6, 0x00FC,
283 0x00C5, 0x00EE, 0x00D8, 0x00C6, 0x00E5, 0x00ED, 0x00F8, 0x00E6,
284 0x00C4, 0x00EC, 0x00D6, 0x00DC, 0x00C9, 0x00EF, 0x00DF, 0x00D4,
285 0x00C1, 0x00C3, 0x00E3, 0x00D0, 0x00F0, 0x00CD, 0x00CC, 0x00D3,
286 0x00D2, 0x00D5, 0x00F5, 0x0160, 0x0161, 0x00DA, 0x0178, 0x00FF,
287 0x00DE, 0x00FE, 0x00B7, 0x00B5, 0x00B6, 0x00BE, 0x2014, 0x00BC,
288 0x00BD, 0x00AA, 0x00BA, 0x00AB, 0x25A0, 0x00BB, 0x00B1, 0xFFFD
289 };
290
291 static const wchar_t koi8_u[] = {
292 0x2500, 0x2502, 0x250C, 0x2510, 0x2514, 0x2518, 0x251C, 0x2524,
293 0x252C, 0x2534, 0x253C, 0x2580, 0x2584, 0x2588, 0x258C, 0x2590,
294 0x2591, 0x2592, 0x2593, 0x2320, 0x25A0, 0x2022, 0x221A, 0x2248,
295 0x2264, 0x2265, 0x00A0, 0x2321, 0x00B0, 0x00B2, 0x00B7, 0x00F7,
296 0x2550, 0x2551, 0x2552, 0x0451, 0x0454, 0x2554, 0x0456, 0x0457,
297 0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x0491, 0x255D, 0x255E,
298 0x255F, 0x2560, 0x2561, 0x0401, 0x0404, 0x2563, 0x0406, 0x0407,
299 0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x0490, 0x256C, 0x00A9,
300 0x044E, 0x0430, 0x0431, 0x0446, 0x0434, 0x0435, 0x0444, 0x0433,
301 0x0445, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
302 0x043F, 0x044F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0436, 0x0432,
303 0x044C, 0x044B, 0x0437, 0x0448, 0x044D, 0x0449, 0x0447, 0x044A,
304 0x042E, 0x0410, 0x0411, 0x0426, 0x0414, 0x0415, 0x0424, 0x0413,
305 0x0425, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E,
306 0x041F, 0x042F, 0x0420, 0x0421, 0x0422, 0x0423, 0x0416, 0x0412,
307 0x042C, 0x042B, 0x0417, 0x0428, 0x042D, 0x0429, 0x0427, 0x042A
308 };
309
310 static const wchar_t vscii[] = {
311 0x0000, 0x0001, 0x1EB2, 0x0003, 0x0004, 0x1EB4, 0x1EAA, 0x0007,
312 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f,
313 0x0010, 0x0011, 0x0012, 0x0013, 0x1EF6, 0x0015, 0x0016, 0x0017,
314 0x0018, 0x1EF8, 0x001a, 0x001b, 0x001c, 0x001d, 0x1EF4, 0x001f,
315 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
316 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
317 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
318 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
319 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
320 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
321 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
322 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
323 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
324 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
325 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
326 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007f,
327 0x1EA0, 0x1EAE, 0x1EB0, 0x1EB6, 0x1EA4, 0x1EA6, 0x1EA8, 0x1EAC,
328 0x1EBC, 0x1EB8, 0x1EBE, 0x1EC0, 0x1EC2, 0x1EC4, 0x1EC6, 0x1ED0,
329 0x1ED2, 0x1ED4, 0x1ED6, 0x1ED8, 0x1EE2, 0x1EDA, 0x1EDC, 0x1EDE,
330 0x1ECA, 0x1ECE, 0x1ECC, 0x1EC8, 0x1EE6, 0x0168, 0x1EE4, 0x1EF2,
331 0x00D5, 0x1EAF, 0x1EB1, 0x1EB7, 0x1EA5, 0x1EA7, 0x1EA8, 0x1EAD,
332 0x1EBD, 0x1EB9, 0x1EBF, 0x1EC1, 0x1EC3, 0x1EC5, 0x1EC7, 0x1ED1,
333 0x1ED3, 0x1ED5, 0x1ED7, 0x1EE0, 0x01A0, 0x1ED9, 0x1EDD, 0x1EDF,
334 0x1ECB, 0x1EF0, 0x1EE8, 0x1EEA, 0x1EEC, 0x01A1, 0x1EDB, 0x01AF,
335 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x1EA2, 0x0102, 0x1EB3, 0x1EB5,
336 0x00C8, 0x00C9, 0x00CA, 0x1EBA, 0x00CC, 0x00CD, 0x0128, 0x1EF3,
337 0x0110, 0x1EE9, 0x00D2, 0x00D3, 0x00D4, 0x1EA1, 0x1EF7, 0x1EEB,
338 0x1EED, 0x00D9, 0x00DA, 0x1EF9, 0x1EF5, 0x00DD, 0x1EE1, 0x01B0,
339 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x1EA3, 0x0103, 0x1EEF, 0x1EAB,
340 0x00E8, 0x00E9, 0x00EA, 0x1EBB, 0x00EC, 0x00ED, 0x0129, 0x1EC9,
341 0x0111, 0x1EF1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x1ECF, 0x1ECD,
342 0x1EE5, 0x00F9, 0x00FA, 0x0169, 0x1EE7, 0x00FD, 0x1EE3, 0x1EEE
343 };
344
345 static const wchar_t dec_mcs[] = {
346 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0xFFFD, 0x00A5, 0xFFFD, 0x00A7,
347 0x00A4, 0x00A9, 0x00AA, 0x00AB, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
348 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0xFFFD, 0x00B5, 0x00B6, 0x00B7,
349 0xFFFD, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0xFFFD, 0x00BF,
350 0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
351 0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
352 0xFFFD, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x0152,
353 0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x0178, 0xFFFD, 0x00DF,
354 0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
355 0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
356 0xFFFD, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x0153,
357 0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FF, 0xFFFD, 0xFFFD
358 };
359
360 struct cp_list_item {
361 char *name;
362 int codepage;
363 int cp_size;
364 const wchar_t *cp_table;
365 };
366
367 static const struct cp_list_item cp_list[] = {
368 {"ISO-8859-1:1998 (Latin-1, West Europe)", 0, 96, iso_8859_1},
369 {"ISO-8859-2:1999 (Latin-2, East Europe)", 0, 96, iso_8859_2},
370 {"ISO-8859-3:1999 (Latin-3, South Europe)", 0, 96, iso_8859_3},
371 {"ISO-8859-4:1998 (Latin-4, North Europe)", 0, 96, iso_8859_4},
372 {"ISO-8859-5:1999 (Latin/Cyrillic)", 0, 96, iso_8859_5},
373 {"ISO-8859-6:1999 (Latin/Arabic)", 0, 96, iso_8859_6},
374 {"ISO-8859-7:1987 (Latin/Greek)", 0, 96, iso_8859_7},
375 {"ISO-8859-8:1999 (Latin/Hebrew)", 0, 96, iso_8859_8},
376 {"ISO-8859-9:1999 (Latin-5, Turkish)", 0, 96, iso_8859_9},
377 {"ISO-8859-10:1998 (Latin-6, Nordic)", 0, 96, iso_8859_10},
378 {"ISO-8859-11:2001 (Latin/Thai)", 0, 96, iso_8859_11},
379 {"ISO-8859-13:1998 (Latin-7, Baltic)", 0, 96, iso_8859_13},
380 {"ISO-8859-14:1998 (Latin-8, Celtic)", 0, 96, iso_8859_14},
381 {"ISO-8859-15:1999 (Latin-9, \"euro\")", 0, 96, iso_8859_15},
382 {"ISO-8859-16:2001 (Latin-10, Balkan)", 0, 96, iso_8859_16},
383
384 {"UTF-8", CP_UTF8},
385
386 {"KOI8-U", 0, 128, koi8_u},
387 {"KOI8-R", 20866},
388 {"HP-ROMAN8", 0, 96, roman8},
389 {"VSCII", 0, 256, vscii},
390 {"DEC-MCS", 0, 96, dec_mcs},
391
392 {"Win1250 (Central European)", 1250},
393 {"Win1251 (Cyrillic)", 1251},
394 {"Win1252 (Western)", 1252},
395 {"Win1253 (Greek)", 1253},
396 {"Win1254 (Turkish)", 1254},
397 {"Win1255 (Hebrew)", 1255},
398 {"Win1256 (Arabic)", 1256},
399 {"Win1257 (Baltic)", 1257},
400 {"Win1258 (Vietnamese)", 1258},
401
402 {"CP437", 437},
403 {"CP819", 28591},
404 {"CP878", 20866},
405
406 {"Use font encoding", -1},
407
408 {0, 0}
409 };
410
411 static void link_font(WCHAR * line_tbl, WCHAR * font_tbl, WCHAR attr);
412
413 void init_ucs(Config *cfg, struct unicode_data *ucsdata)
414 {
415 int i, j;
416 int used_dtf = 0;
417 char tbuf[256];
418
419 for (i = 0; i < 256; i++)
420 tbuf[i] = i;
421
422 /* Decide on the Line and Font codepages */
423 ucsdata->line_codepage = decode_codepage(cfg->line_codepage);
424
425 if (ucsdata->font_codepage <= 0) {
426 ucsdata->font_codepage=0;
427 ucsdata->dbcs_screenfont=0;
428 }
429
430 if (cfg->vtmode == VT_OEMONLY) {
431 ucsdata->font_codepage = 437;
432 ucsdata->dbcs_screenfont = 0;
433 if (ucsdata->line_codepage <= 0)
434 ucsdata->line_codepage = GetACP();
435 } else if (ucsdata->line_codepage <= 0)
436 ucsdata->line_codepage = ucsdata->font_codepage;
437
438 /* Collect screen font ucs table */
439 if (ucsdata->dbcs_screenfont || ucsdata->font_codepage == 0) {
440 get_unitab(ucsdata->font_codepage, ucsdata->unitab_font, 2);
441 for (i = 128; i < 256; i++)
442 ucsdata->unitab_font[i] = (WCHAR) (ATTR_ACP + i);
443 } else {
444 get_unitab(ucsdata->font_codepage, ucsdata->unitab_font, 1);
445
446 /* CP437 fonts are often broken ... */
447 if (ucsdata->font_codepage == 437)
448 ucsdata->unitab_font[0] = ucsdata->unitab_font[255] = 0xFFFF;
449 }
450 if (cfg->vtmode == VT_XWINDOWS)
451 memcpy(ucsdata->unitab_font + 1, unitab_xterm_std,
452 sizeof(unitab_xterm_std));
453
454 /* Collect OEMCP ucs table */
455 get_unitab(CP_OEMCP, ucsdata->unitab_oemcp, 1);
456
457 /* Collect CP437 ucs table for SCO acs */
458 if (cfg->vtmode == VT_OEMANSI || cfg->vtmode == VT_XWINDOWS)
459 memcpy(ucsdata->unitab_scoacs, ucsdata->unitab_oemcp,
460 sizeof(ucsdata->unitab_scoacs));
461 else
462 get_unitab(437, ucsdata->unitab_scoacs, 1);
463
464 /* Collect line set ucs table */
465 if (ucsdata->line_codepage == ucsdata->font_codepage &&
466 (ucsdata->dbcs_screenfont ||
467 cfg->vtmode == VT_POORMAN || ucsdata->font_codepage==0)) {
468
469 /* For DBCS and POOR fonts force direct to font */
470 used_dtf = 1;
471 for (i = 0; i < 32; i++)
472 ucsdata->unitab_line[i] = (WCHAR) i;
473 for (i = 32; i < 256; i++)
474 ucsdata->unitab_line[i] = (WCHAR) (ATTR_ACP + i);
475 ucsdata->unitab_line[127] = (WCHAR) 127;
476 } else {
477 get_unitab(ucsdata->line_codepage, ucsdata->unitab_line, 0);
478 }
479
480 #if 0
481 debug(
482 ("Line cp%d, Font cp%d%s\n", ucsdata->line_codepage,
483 ucsdata->font_codepage, ucsdata->dbcs_screenfont ? " DBCS" : ""));
484
485 for (i = 0; i < 256; i += 16) {
486 for (j = 0; j < 16; j++) {
487 debug(("%04x%s", ucsdata->unitab_line[i + j], j == 15 ? "" : ","));
488 }
489 debug(("\n"));
490 }
491 #endif
492
493 /* VT100 graphics - NB: Broken for non-ascii CP's */
494 memcpy(ucsdata->unitab_xterm, ucsdata->unitab_line,
495 sizeof(ucsdata->unitab_xterm));
496 memcpy(ucsdata->unitab_xterm + '`', unitab_xterm_std,
497 sizeof(unitab_xterm_std));
498 ucsdata->unitab_xterm['_'] = ' ';
499
500 /* Generate UCS ->line page table. */
501 if (ucsdata->uni_tbl) {
502 for (i = 0; i < 256; i++)
503 if (ucsdata->uni_tbl[i])
504 sfree(ucsdata->uni_tbl[i]);
505 sfree(ucsdata->uni_tbl);
506 ucsdata->uni_tbl = 0;
507 }
508 if (!used_dtf) {
509 for (i = 0; i < 256; i++) {
510 if (DIRECT_CHAR(ucsdata->unitab_line[i]))
511 continue;
512 if (DIRECT_FONT(ucsdata->unitab_line[i]))
513 continue;
514 if (!ucsdata->uni_tbl) {
515 ucsdata->uni_tbl = snewn(256, char *);
516 memset(ucsdata->uni_tbl, 0, 256 * sizeof(char *));
517 }
518 j = ((ucsdata->unitab_line[i] >> 8) & 0xFF);
519 if (!ucsdata->uni_tbl[j]) {
520 ucsdata->uni_tbl[j] = snewn(256, char);
521 memset(ucsdata->uni_tbl[j], 0, 256 * sizeof(char));
522 }
523 ucsdata->uni_tbl[j][ucsdata->unitab_line[i] & 0xFF] = i;
524 }
525 }
526
527 /* Find the line control characters. */
528 for (i = 0; i < 256; i++)
529 if (ucsdata->unitab_line[i] < ' '
530 || (ucsdata->unitab_line[i] >= 0x7F &&
531 ucsdata->unitab_line[i] < 0xA0))
532 ucsdata->unitab_ctrl[i] = i;
533 else
534 ucsdata->unitab_ctrl[i] = 0xFF;
535
536 /* Generate line->screen direct conversion links. */
537 if (cfg->vtmode == VT_OEMANSI || cfg->vtmode == VT_XWINDOWS)
538 link_font(ucsdata->unitab_scoacs, ucsdata->unitab_oemcp, ATTR_OEMCP);
539
540 link_font(ucsdata->unitab_line, ucsdata->unitab_font, ATTR_ACP);
541 link_font(ucsdata->unitab_scoacs, ucsdata->unitab_font, ATTR_ACP);
542 link_font(ucsdata->unitab_xterm, ucsdata->unitab_font, ATTR_ACP);
543
544 if (cfg->vtmode == VT_OEMANSI || cfg->vtmode == VT_XWINDOWS) {
545 link_font(ucsdata->unitab_line, ucsdata->unitab_oemcp, ATTR_OEMCP);
546 link_font(ucsdata->unitab_xterm, ucsdata->unitab_oemcp, ATTR_OEMCP);
547 }
548
549 if (ucsdata->dbcs_screenfont &&
550 ucsdata->font_codepage != ucsdata->line_codepage) {
551 /* F***ing Microsoft fonts, Japanese and Korean codepage fonts
552 * have a currency symbol at 0x5C but their unicode value is
553 * still given as U+005C not the correct U+00A5. */
554 ucsdata->unitab_line['\\'] = ATTR_OEMCP + '\\';
555 }
556
557 /* Last chance, if !unicode then try poorman links. */
558 if (cfg->vtmode != VT_UNICODE) {
559 static const char poorman_scoacs[] =
560 "CueaaaaceeeiiiAAE**ooouuyOUc$YPsaiounNao?++**!<>###||||++||++++++--|-+||++--|-+----++++++++##||#aBTPEsyt******EN=+><++-=... n2* ";
561 static const char poorman_latin1[] =
562 " !cL.Y|S\"Ca<--R~o+23'u|.,1o>///?AAAAAAACEEEEIIIIDNOOOOOxOUUUUYPBaaaaaaaceeeeiiiionooooo/ouuuuypy";
563 static const char poorman_vt100[] = "*#****o~**+++++-----++++|****L.";
564
565 for (i = 160; i < 256; i++)
566 if (!DIRECT_FONT(ucsdata->unitab_line[i]) &&
567 ucsdata->unitab_line[i] >= 160 &&
568 ucsdata->unitab_line[i] < 256) {
569 ucsdata->unitab_line[i] =
570 (WCHAR) (ATTR_ACP +
571 poorman_latin1[ucsdata->unitab_line[i] - 160]);
572 }
573 for (i = 96; i < 127; i++)
574 if (!DIRECT_FONT(ucsdata->unitab_xterm[i]))
575 ucsdata->unitab_xterm[i] =
576 (WCHAR) (ATTR_ACP + poorman_vt100[i - 96]);
577 for(i=128;i<256;i++)
578 if (!DIRECT_FONT(ucsdata->unitab_scoacs[i]))
579 ucsdata->unitab_scoacs[i] =
580 (WCHAR) (ATTR_ACP + poorman_scoacs[i - 128]);
581 }
582 }
583
584 static void link_font(WCHAR * line_tbl, WCHAR * font_tbl, WCHAR attr)
585 {
586 int font_index, line_index, i;
587 for (line_index = 0; line_index < 256; line_index++) {
588 if (DIRECT_FONT(line_tbl[line_index]))
589 continue;
590 for(i = 0; i < 256; i++) {
591 font_index = ((32 + i) & 0xFF);
592 if (line_tbl[line_index] == font_tbl[font_index]) {
593 line_tbl[line_index] = (WCHAR) (attr + font_index);
594 break;
595 }
596 }
597 }
598 }
599
600 wchar_t xlat_uskbd2cyrllic(int ch)
601 {
602 static const wchar_t cyrtab[] = {
603 0, 1, 2, 3, 4, 5, 6, 7,
604 8, 9, 10, 11, 12, 13, 14, 15,
605 16, 17, 18, 19, 20, 21, 22, 23,
606 24, 25, 26, 27, 28, 29, 30, 31,
607 32, 33, 0x042d, 35, 36, 37, 38, 0x044d,
608 40, 41, 42, 0x0406, 0x0431, 0x0454, 0x044e, 0x002e,
609 48, 49, 50, 51, 52, 53, 54, 55,
610 56, 57, 0x0416, 0x0436, 0x0411, 0x0456, 0x042e, 0x002c,
611 64, 0x0424, 0x0418, 0x0421, 0x0412, 0x0423, 0x0410, 0x041f,
612 0x0420, 0x0428, 0x041e, 0x041b, 0x0414, 0x042c, 0x0422, 0x0429,
613 0x0417, 0x0419, 0x041a, 0x042b, 0x0415, 0x0413, 0x041c, 0x0426,
614 0x0427, 0x041d, 0x042f, 0x0445, 0x0457, 0x044a, 94, 0x0404,
615 96, 0x0444, 0x0438, 0x0441, 0x0432, 0x0443, 0x0430, 0x043f,
616 0x0440, 0x0448, 0x043e, 0x043b, 0x0434, 0x044c, 0x0442, 0x0449,
617 0x0437, 0x0439, 0x043a, 0x044b, 0x0435, 0x0433, 0x043c, 0x0446,
618 0x0447, 0x043d, 0x044f, 0x0425, 0x0407, 0x042a, 126, 127
619 };
620 return cyrtab[ch&0x7F];
621 }
622
623 int check_compose_internal(int first, int second, int recurse)
624 {
625
626 static const struct {
627 char first, second;
628 wchar_t composed;
629 } composetbl[] = {
630 {
631 0x2b, 0x2b, 0x0023}, {
632 0x41, 0x41, 0x0040}, {
633 0x28, 0x28, 0x005b}, {
634 0x2f, 0x2f, 0x005c}, {
635 0x29, 0x29, 0x005d}, {
636 0x28, 0x2d, 0x007b}, {
637 0x2d, 0x29, 0x007d}, {
638 0x2f, 0x5e, 0x007c}, {
639 0x21, 0x21, 0x00a1}, {
640 0x43, 0x2f, 0x00a2}, {
641 0x43, 0x7c, 0x00a2}, {
642 0x4c, 0x2d, 0x00a3}, {
643 0x4c, 0x3d, 0x20a4}, {
644 0x58, 0x4f, 0x00a4}, {
645 0x58, 0x30, 0x00a4}, {
646 0x59, 0x2d, 0x00a5}, {
647 0x59, 0x3d, 0x00a5}, {
648 0x7c, 0x7c, 0x00a6}, {
649 0x53, 0x4f, 0x00a7}, {
650 0x53, 0x21, 0x00a7}, {
651 0x53, 0x30, 0x00a7}, {
652 0x22, 0x22, 0x00a8}, {
653 0x43, 0x4f, 0x00a9}, {
654 0x43, 0x30, 0x00a9}, {
655 0x41, 0x5f, 0x00aa}, {
656 0x3c, 0x3c, 0x00ab}, {
657 0x2c, 0x2d, 0x00ac}, {
658 0x2d, 0x2d, 0x00ad}, {
659 0x52, 0x4f, 0x00ae}, {
660 0x2d, 0x5e, 0x00af}, {
661 0x30, 0x5e, 0x00b0}, {
662 0x2b, 0x2d, 0x00b1}, {
663 0x32, 0x5e, 0x00b2}, {
664 0x33, 0x5e, 0x00b3}, {
665 0x27, 0x27, 0x00b4}, {
666 0x2f, 0x55, 0x00b5}, {
667 0x50, 0x21, 0x00b6}, {
668 0x2e, 0x5e, 0x00b7}, {
669 0x2c, 0x2c, 0x00b8}, {
670 0x31, 0x5e, 0x00b9}, {
671 0x4f, 0x5f, 0x00ba}, {
672 0x3e, 0x3e, 0x00bb}, {
673 0x31, 0x34, 0x00bc}, {
674 0x31, 0x32, 0x00bd}, {
675 0x33, 0x34, 0x00be}, {
676 0x3f, 0x3f, 0x00bf}, {
677 0x60, 0x41, 0x00c0}, {
678 0x27, 0x41, 0x00c1}, {
679 0x5e, 0x41, 0x00c2}, {
680 0x7e, 0x41, 0x00c3}, {
681 0x22, 0x41, 0x00c4}, {
682 0x2a, 0x41, 0x00c5}, {
683 0x41, 0x45, 0x00c6}, {
684 0x2c, 0x43, 0x00c7}, {
685 0x60, 0x45, 0x00c8}, {
686 0x27, 0x45, 0x00c9}, {
687 0x5e, 0x45, 0x00ca}, {
688 0x22, 0x45, 0x00cb}, {
689 0x60, 0x49, 0x00cc}, {
690 0x27, 0x49, 0x00cd}, {
691 0x5e, 0x49, 0x00ce}, {
692 0x22, 0x49, 0x00cf}, {
693 0x2d, 0x44, 0x00d0}, {
694 0x7e, 0x4e, 0x00d1}, {
695 0x60, 0x4f, 0x00d2}, {
696 0x27, 0x4f, 0x00d3}, {
697 0x5e, 0x4f, 0x00d4}, {
698 0x7e, 0x4f, 0x00d5}, {
699 0x22, 0x4f, 0x00d6}, {
700 0x58, 0x58, 0x00d7}, {
701 0x2f, 0x4f, 0x00d8}, {
702 0x60, 0x55, 0x00d9}, {
703 0x27, 0x55, 0x00da}, {
704 0x5e, 0x55, 0x00db}, {
705 0x22, 0x55, 0x00dc}, {
706 0x27, 0x59, 0x00dd}, {
707 0x48, 0x54, 0x00de}, {
708 0x73, 0x73, 0x00df}, {
709 0x60, 0x61, 0x00e0}, {
710 0x27, 0x61, 0x00e1}, {
711 0x5e, 0x61, 0x00e2}, {
712 0x7e, 0x61, 0x00e3}, {
713 0x22, 0x61, 0x00e4}, {
714 0x2a, 0x61, 0x00e5}, {
715 0x61, 0x65, 0x00e6}, {
716 0x2c, 0x63, 0x00e7}, {
717 0x60, 0x65, 0x00e8}, {
718 0x27, 0x65, 0x00e9}, {
719 0x5e, 0x65, 0x00ea}, {
720 0x22, 0x65, 0x00eb}, {
721 0x60, 0x69, 0x00ec}, {
722 0x27, 0x69, 0x00ed}, {
723 0x5e, 0x69, 0x00ee}, {
724 0x22, 0x69, 0x00ef}, {
725 0x2d, 0x64, 0x00f0}, {
726 0x7e, 0x6e, 0x00f1}, {
727 0x60, 0x6f, 0x00f2}, {
728 0x27, 0x6f, 0x00f3}, {
729 0x5e, 0x6f, 0x00f4}, {
730 0x7e, 0x6f, 0x00f5}, {
731 0x22, 0x6f, 0x00f6}, {
732 0x3a, 0x2d, 0x00f7}, {
733 0x6f, 0x2f, 0x00f8}, {
734 0x60, 0x75, 0x00f9}, {
735 0x27, 0x75, 0x00fa}, {
736 0x5e, 0x75, 0x00fb}, {
737 0x22, 0x75, 0x00fc}, {
738 0x27, 0x79, 0x00fd}, {
739 0x68, 0x74, 0x00fe}, {
740 0x22, 0x79, 0x00ff},
741 /* Unicode extras. */
742 {
743 0x6f, 0x65, 0x0153}, {
744 0x4f, 0x45, 0x0152},
745 /* Compose pairs from UCS */
746 {
747 0x41, 0x2D, 0x0100}, {
748 0x61, 0x2D, 0x0101}, {
749 0x43, 0x27, 0x0106}, {
750 0x63, 0x27, 0x0107}, {
751 0x43, 0x5E, 0x0108}, {
752 0x63, 0x5E, 0x0109}, {
753 0x45, 0x2D, 0x0112}, {
754 0x65, 0x2D, 0x0113}, {
755 0x47, 0x5E, 0x011C}, {
756 0x67, 0x5E, 0x011D}, {
757 0x47, 0x2C, 0x0122}, {
758 0x67, 0x2C, 0x0123}, {
759 0x48, 0x5E, 0x0124}, {
760 0x68, 0x5E, 0x0125}, {
761 0x49, 0x7E, 0x0128}, {
762 0x69, 0x7E, 0x0129}, {
763 0x49, 0x2D, 0x012A}, {
764 0x69, 0x2D, 0x012B}, {
765 0x4A, 0x5E, 0x0134}, {
766 0x6A, 0x5E, 0x0135}, {
767 0x4B, 0x2C, 0x0136}, {
768 0x6B, 0x2C, 0x0137}, {
769 0x4C, 0x27, 0x0139}, {
770 0x6C, 0x27, 0x013A}, {
771 0x4C, 0x2C, 0x013B}, {
772 0x6C, 0x2C, 0x013C}, {
773 0x4E, 0x27, 0x0143}, {
774 0x6E, 0x27, 0x0144}, {
775 0x4E, 0x2C, 0x0145}, {
776 0x6E, 0x2C, 0x0146}, {
777 0x4F, 0x2D, 0x014C}, {
778 0x6F, 0x2D, 0x014D}, {
779 0x52, 0x27, 0x0154}, {
780 0x72, 0x27, 0x0155}, {
781 0x52, 0x2C, 0x0156}, {
782 0x72, 0x2C, 0x0157}, {
783 0x53, 0x27, 0x015A}, {
784 0x73, 0x27, 0x015B}, {
785 0x53, 0x5E, 0x015C}, {
786 0x73, 0x5E, 0x015D}, {
787 0x53, 0x2C, 0x015E}, {
788 0x73, 0x2C, 0x015F}, {
789 0x54, 0x2C, 0x0162}, {
790 0x74, 0x2C, 0x0163}, {
791 0x55, 0x7E, 0x0168}, {
792 0x75, 0x7E, 0x0169}, {
793 0x55, 0x2D, 0x016A}, {
794 0x75, 0x2D, 0x016B}, {
795 0x55, 0x2A, 0x016E}, {
796 0x75, 0x2A, 0x016F}, {
797 0x57, 0x5E, 0x0174}, {
798 0x77, 0x5E, 0x0175}, {
799 0x59, 0x5E, 0x0176}, {
800 0x79, 0x5E, 0x0177}, {
801 0x59, 0x22, 0x0178}, {
802 0x5A, 0x27, 0x0179}, {
803 0x7A, 0x27, 0x017A}, {
804 0x47, 0x27, 0x01F4}, {
805 0x67, 0x27, 0x01F5}, {
806 0x4E, 0x60, 0x01F8}, {
807 0x6E, 0x60, 0x01F9}, {
808 0x45, 0x2C, 0x0228}, {
809 0x65, 0x2C, 0x0229}, {
810 0x59, 0x2D, 0x0232}, {
811 0x79, 0x2D, 0x0233}, {
812 0x44, 0x2C, 0x1E10}, {
813 0x64, 0x2C, 0x1E11}, {
814 0x47, 0x2D, 0x1E20}, {
815 0x67, 0x2D, 0x1E21}, {
816 0x48, 0x22, 0x1E26}, {
817 0x68, 0x22, 0x1E27}, {
818 0x48, 0x2C, 0x1E28}, {
819 0x68, 0x2C, 0x1E29}, {
820 0x4B, 0x27, 0x1E30}, {
821 0x6B, 0x27, 0x1E31}, {
822 0x4D, 0x27, 0x1E3E}, {
823 0x6D, 0x27, 0x1E3F}, {
824 0x50, 0x27, 0x1E54}, {
825 0x70, 0x27, 0x1E55}, {
826 0x56, 0x7E, 0x1E7C}, {
827 0x76, 0x7E, 0x1E7D}, {
828 0x57, 0x60, 0x1E80}, {
829 0x77, 0x60, 0x1E81}, {
830 0x57, 0x27, 0x1E82}, {
831 0x77, 0x27, 0x1E83}, {
832 0x57, 0x22, 0x1E84}, {
833 0x77, 0x22, 0x1E85}, {
834 0x58, 0x22, 0x1E8C}, {
835 0x78, 0x22, 0x1E8D}, {
836 0x5A, 0x5E, 0x1E90}, {
837 0x7A, 0x5E, 0x1E91}, {
838 0x74, 0x22, 0x1E97}, {
839 0x77, 0x2A, 0x1E98}, {
840 0x79, 0x2A, 0x1E99}, {
841 0x45, 0x7E, 0x1EBC}, {
842 0x65, 0x7E, 0x1EBD}, {
843 0x59, 0x60, 0x1EF2}, {
844 0x79, 0x60, 0x1EF3}, {
845 0x59, 0x7E, 0x1EF8}, {
846 0x79, 0x7E, 0x1EF9},
847 /* Compatible/possibles from UCS */
848 {
849 0x49, 0x4A, 0x0132}, {
850 0x69, 0x6A, 0x0133}, {
851 0x4C, 0x4A, 0x01C7}, {
852 0x4C, 0x6A, 0x01C8}, {
853 0x6C, 0x6A, 0x01C9}, {
854 0x4E, 0x4A, 0x01CA}, {
855 0x4E, 0x6A, 0x01CB}, {
856 0x6E, 0x6A, 0x01CC}, {
857 0x44, 0x5A, 0x01F1}, {
858 0x44, 0x7A, 0x01F2}, {
859 0x64, 0x7A, 0x01F3}, {
860 0x2E, 0x2E, 0x2025}, {
861 0x21, 0x21, 0x203C}, {
862 0x3F, 0x21, 0x2048}, {
863 0x21, 0x3F, 0x2049}, {
864 0x52, 0x73, 0x20A8}, {
865 0x4E, 0x6F, 0x2116}, {
866 0x53, 0x4D, 0x2120}, {
867 0x54, 0x4D, 0x2122}, {
868 0x49, 0x49, 0x2161}, {
869 0x49, 0x56, 0x2163}, {
870 0x56, 0x49, 0x2165}, {
871 0x49, 0x58, 0x2168}, {
872 0x58, 0x49, 0x216A}, {
873 0x69, 0x69, 0x2171}, {
874 0x69, 0x76, 0x2173}, {
875 0x76, 0x69, 0x2175}, {
876 0x69, 0x78, 0x2178}, {
877 0x78, 0x69, 0x217A}, {
878 0x31, 0x30, 0x2469}, {
879 0x31, 0x31, 0x246A}, {
880 0x31, 0x32, 0x246B}, {
881 0x31, 0x33, 0x246C}, {
882 0x31, 0x34, 0x246D}, {
883 0x31, 0x35, 0x246E}, {
884 0x31, 0x36, 0x246F}, {
885 0x31, 0x37, 0x2470}, {
886 0x31, 0x38, 0x2471}, {
887 0x31, 0x39, 0x2472}, {
888 0x32, 0x30, 0x2473}, {
889 0x31, 0x2E, 0x2488}, {
890 0x32, 0x2E, 0x2489}, {
891 0x33, 0x2E, 0x248A}, {
892 0x34, 0x2E, 0x248B}, {
893 0x35, 0x2E, 0x248C}, {
894 0x36, 0x2E, 0x248D}, {
895 0x37, 0x2E, 0x248E}, {
896 0x38, 0x2E, 0x248F}, {
897 0x39, 0x2E, 0x2490}, {
898 0x64, 0x61, 0x3372}, {
899 0x41, 0x55, 0x3373}, {
900 0x6F, 0x56, 0x3375}, {
901 0x70, 0x63, 0x3376}, {
902 0x70, 0x41, 0x3380}, {
903 0x6E, 0x41, 0x3381}, {
904 0x6D, 0x41, 0x3383}, {
905 0x6B, 0x41, 0x3384}, {
906 0x4B, 0x42, 0x3385}, {
907 0x4D, 0x42, 0x3386}, {
908 0x47, 0x42, 0x3387}, {
909 0x70, 0x46, 0x338A}, {
910 0x6E, 0x46, 0x338B}, {
911 0x6D, 0x67, 0x338E}, {
912 0x6B, 0x67, 0x338F}, {
913 0x48, 0x7A, 0x3390}, {
914 0x66, 0x6D, 0x3399}, {
915 0x6E, 0x6D, 0x339A}, {
916 0x6D, 0x6D, 0x339C}, {
917 0x63, 0x6D, 0x339D}, {
918 0x6B, 0x6D, 0x339E}, {
919 0x50, 0x61, 0x33A9}, {
920 0x70, 0x73, 0x33B0}, {
921 0x6E, 0x73, 0x33B1}, {
922 0x6D, 0x73, 0x33B3}, {
923 0x70, 0x56, 0x33B4}, {
924 0x6E, 0x56, 0x33B5}, {
925 0x6D, 0x56, 0x33B7}, {
926 0x6B, 0x56, 0x33B8}, {
927 0x4D, 0x56, 0x33B9}, {
928 0x70, 0x57, 0x33BA}, {
929 0x6E, 0x57, 0x33BB}, {
930 0x6D, 0x57, 0x33BD}, {
931 0x6B, 0x57, 0x33BE}, {
932 0x4D, 0x57, 0x33BF}, {
933 0x42, 0x71, 0x33C3}, {
934 0x63, 0x63, 0x33C4}, {
935 0x63, 0x64, 0x33C5}, {
936 0x64, 0x42, 0x33C8}, {
937 0x47, 0x79, 0x33C9}, {
938 0x68, 0x61, 0x33CA}, {
939 0x48, 0x50, 0x33CB}, {
940 0x69, 0x6E, 0x33CC}, {
941 0x4B, 0x4B, 0x33CD}, {
942 0x4B, 0x4D, 0x33CE}, {
943 0x6B, 0x74, 0x33CF}, {
944 0x6C, 0x6D, 0x33D0}, {
945 0x6C, 0x6E, 0x33D1}, {
946 0x6C, 0x78, 0x33D3}, {
947 0x6D, 0x62, 0x33D4}, {
948 0x50, 0x48, 0x33D7}, {
949 0x50, 0x52, 0x33DA}, {
950 0x73, 0x72, 0x33DB}, {
951 0x53, 0x76, 0x33DC}, {
952 0x57, 0x62, 0x33DD}, {
953 0x66, 0x66, 0xFB00}, {
954 0x66, 0x69, 0xFB01}, {
955 0x66, 0x6C, 0xFB02}, {
956 0x73, 0x74, 0xFB06}, {
957 0, 0, 0}
958 }, *c;
959
960 int nc = -1;
961
962 for (c = composetbl; c->first; c++) {
963 if (c->first == first && c->second == second)
964 return c->composed;
965 }
966
967 if (recurse == 0) {
968 nc = check_compose_internal(second, first, 1);
969 if (nc == -1)
970 nc = check_compose_internal(toupper(first), toupper(second), 1);
971 if (nc == -1)
972 nc = check_compose_internal(toupper(second), toupper(first), 1);
973 }
974 return nc;
975 }
976
977 int check_compose(int first, int second)
978 {
979 return check_compose_internal(first, second, 0);
980 }
981
982 int decode_codepage(char *cp_name)
983 {
984 char *s, *d;
985 const struct cp_list_item *cpi;
986 int codepage = -1;
987 CPINFO cpinfo;
988
989 if (!*cp_name) {
990 /*
991 * Here we select a plausible default code page based on
992 * the locale the user is in. We wish to select an ISO code
993 * page or appropriate local default _rather_ than go with
994 * the Win125* series, because it's more important to have
995 * CSI and friends enabled by default than the ghastly
996 * Windows extra quote characters, and because it's more
997 * likely the user is connecting to a remote server that
998 * does something Unixy or VMSy and hence standards-
999 * compliant than that they're connecting back to a Windows
1000 * box using horrible nonstandard charsets.
1001 *
1002 * Accordingly, Robert de Bath suggests a method for
1003 * picking a default character set that runs as follows:
1004 * first call GetACP to get the system's ANSI code page
1005 * identifier, and translate as follows:
1006 *
1007 * 1250 -> ISO 8859-2
1008 * 1251 -> KOI8-U
1009 * 1252 -> ISO 8859-1
1010 * 1253 -> ISO 8859-7
1011 * 1254 -> ISO 8859-9
1012 * 1255 -> ISO 8859-8
1013 * 1256 -> ISO 8859-6
1014 * 1257 -> ISO 8859-13 (changed from 8859-4 on advice of a Lithuanian)
1015 *
1016 * and for anything else, choose direct-to-font.
1017 */
1018 int cp = GetACP();
1019 switch (cp) {
1020 case 1250: cp_name = "ISO-8859-2"; break;
1021 case 1251: cp_name = "KOI8-U"; break;
1022 case 1252: cp_name = "ISO-8859-1"; break;
1023 case 1253: cp_name = "ISO-8859-7"; break;
1024 case 1254: cp_name = "ISO-8859-9"; break;
1025 case 1255: cp_name = "ISO-8859-8"; break;
1026 case 1256: cp_name = "ISO-8859-6"; break;
1027 case 1257: cp_name = "ISO-8859-13"; break;
1028 /* default: leave it blank, which will select -1, direct->font */
1029 }
1030 }
1031
1032 if (cp_name && *cp_name)
1033 for (cpi = cp_list; cpi->name; cpi++) {
1034 s = cp_name;
1035 d = cpi->name;
1036 for (;;) {
1037 while (*s && !isalnum(*s) && *s != ':')
1038 s++;
1039 while (*d && !isalnum(*d) && *d != ':')
1040 d++;
1041 if (*s == 0) {
1042 codepage = cpi->codepage;
1043 if (codepage == CP_UTF8)
1044 goto break_break;
1045 if (codepage == -1)
1046 return codepage;
1047 if (codepage == 0) {
1048 codepage = 65536 + (cpi - cp_list);
1049 goto break_break;
1050 }
1051
1052 if (GetCPInfo(codepage, &cpinfo) != 0)
1053 goto break_break;
1054 }
1055 if (tolower(*s++) != tolower(*d++))
1056 break;
1057 }
1058 }
1059
1060 if (cp_name && *cp_name) {
1061 d = cp_name;
1062 if (tolower(d[0]) == 'c' && tolower(d[1]) == 'p')
1063 d += 2;
1064 if (tolower(d[0]) == 'i' && tolower(d[1]) == 'b'
1065 && tolower(d[1]) == 'm')
1066 d += 3;
1067 for (s = d; *s >= '0' && *s <= '9'; s++);
1068 if (*s == 0 && s != d)
1069 codepage = atoi(d); /* CP999 or IBM999 */
1070
1071 if (codepage == CP_ACP)
1072 codepage = GetACP();
1073 if (codepage == CP_OEMCP)
1074 codepage = GetOEMCP();
1075 if (codepage > 65535)
1076 codepage = -2;
1077 }
1078
1079 break_break:;
1080 if (codepage != -1) {
1081 if (codepage != CP_UTF8 && codepage < 65536) {
1082 if (GetCPInfo(codepage, &cpinfo) == 0) {
1083 codepage = -2;
1084 } else if (cpinfo.MaxCharSize > 1)
1085 codepage = -3;
1086 }
1087 }
1088 if (codepage == -1 && *cp_name)
1089 codepage = -2;
1090 return codepage;
1091 }
1092
1093 const char *cp_name(int codepage)
1094 {
1095 const struct cp_list_item *cpi, *cpno;
1096 static char buf[32];
1097
1098 if (codepage == -1) {
1099 sprintf(buf, "Use font encoding");
1100 return buf;
1101 }
1102
1103 if (codepage > 0 && codepage < 65536)
1104 sprintf(buf, "CP%03d", codepage);
1105 else
1106 *buf = 0;
1107
1108 if (codepage >= 65536) {
1109 cpno = 0;
1110 for (cpi = cp_list; cpi->name; cpi++)
1111 if (cpi == cp_list + (codepage - 65536)) {
1112 cpno = cpi;
1113 break;
1114 }
1115 if (cpno)
1116 for (cpi = cp_list; cpi->name; cpi++) {
1117 if (cpno->cp_table == cpi->cp_table)
1118 return cpi->name;
1119 }
1120 } else {
1121 for (cpi = cp_list; cpi->name; cpi++) {
1122 if (codepage == cpi->codepage)
1123 return cpi->name;
1124 }
1125 }
1126 return buf;
1127 }
1128
1129 /*
1130 * Return the nth code page in the list, for use in the GUI
1131 * configurer.
1132 */
1133 const char *cp_enumerate(int index)
1134 {
1135 if (index < 0 || index >= lenof(cp_list))
1136 return NULL;
1137 return cp_list[index].name;
1138 }
1139
1140 void get_unitab(int codepage, wchar_t * unitab, int ftype)
1141 {
1142 char tbuf[4];
1143 int i, max = 256, flg = MB_ERR_INVALID_CHARS;
1144
1145 if (ftype)
1146 flg |= MB_USEGLYPHCHARS;
1147 if (ftype == 2)
1148 max = 128;
1149
1150 if (codepage == CP_UTF8) {
1151 for (i = 0; i < max; i++)
1152 unitab[i] = i;
1153 return;
1154 }
1155
1156 if (codepage == CP_ACP)
1157 codepage = GetACP();
1158 else if (codepage == CP_OEMCP)
1159 codepage = GetOEMCP();
1160
1161 if (codepage > 0 && codepage < 65536) {
1162 for (i = 0; i < max; i++) {
1163 tbuf[0] = i;
1164
1165 if (mb_to_wc(codepage, flg, tbuf, 1, unitab + i, 1)
1166 != 1)
1167 unitab[i] = 0xFFFD;
1168 }
1169 } else {
1170 int j = 256 - cp_list[codepage & 0xFFFF].cp_size;
1171 for (i = 0; i < max; i++)
1172 unitab[i] = i;
1173 for (i = j; i < max; i++)
1174 unitab[i] = cp_list[codepage & 0xFFFF].cp_table[i - j];
1175 }
1176 }
1177
1178 int wc_to_mb(int codepage, int flags, wchar_t *wcstr, int wclen,
1179 char *mbstr, int mblen, char *defchr, int *defused,
1180 struct unicode_data *ucsdata)
1181 {
1182 char *p;
1183 int i;
1184 if (ucsdata && codepage == ucsdata->line_codepage && ucsdata->uni_tbl) {
1185 /* Do this by array lookup if we can. */
1186 if (wclen < 0) {
1187 for (wclen = 0; wcstr[wclen++] ;); /* will include the NUL */
1188 }
1189 for (p = mbstr, i = 0; i < wclen; i++) {
1190 wchar_t ch = wcstr[i];
1191 int by;
1192 char *p1;
1193 if (ucsdata->uni_tbl && (p1 = ucsdata->uni_tbl[(ch >> 8) & 0xFF])
1194 && (by = p1[ch & 0xFF]))
1195 *p++ = by;
1196 else if (ch < 0x80)
1197 *p++ = (char) ch;
1198 else if (defchr) {
1199 int j;
1200 for (j = 0; defchr[j]; j++)
1201 *p++ = defchr[j];
1202 if (defused) *defused = 1;
1203 }
1204 #if 1
1205 else
1206 *p++ = '.';
1207 #endif
1208 assert(p - mbstr < mblen);
1209 }
1210 return p - mbstr;
1211 } else
1212 return WideCharToMultiByte(codepage, flags, wcstr, wclen,
1213 mbstr, mblen, defchr, defused);
1214 }
1215
1216 int mb_to_wc(int codepage, int flags, char *mbstr, int mblen,
1217 wchar_t *wcstr, int wclen)
1218 {
1219 return MultiByteToWideChar(codepage, flags, mbstr, mblen, wcstr, wclen);
1220 }
1221
1222 int is_dbcs_leadbyte(int codepage, char byte)
1223 {
1224 return IsDBCSLeadByteEx(codepage, byte);
1225 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator