1 | /* vi: set sw=4 ts=4: */
|
---|
2 | /*
|
---|
3 | * loadfont.c - Eugene Crosser & Andries Brouwer
|
---|
4 | *
|
---|
5 | * Version 0.96bb
|
---|
6 | *
|
---|
7 | * Loads the console font, and possibly the corresponding screen map(s).
|
---|
8 | * (Adapted for busybox by Matej Vela.)
|
---|
9 | *
|
---|
10 | * Licensed under GPLv2, see file LICENSE in this source tree.
|
---|
11 | */
|
---|
12 |
|
---|
13 | //usage:#define loadfont_trivial_usage
|
---|
14 | //usage: "< font"
|
---|
15 | //usage:#define loadfont_full_usage "\n\n"
|
---|
16 | //usage: "Load a console font from stdin"
|
---|
17 | /* //usage: "\n -C TTY Affect TTY instead of /dev/tty" */
|
---|
18 | //usage:
|
---|
19 | //usage:#define loadfont_example_usage
|
---|
20 | //usage: "$ loadfont < /etc/i18n/fontname\n"
|
---|
21 | //usage:
|
---|
22 | //usage:#define setfont_trivial_usage
|
---|
23 | //usage: "FONT [-m MAPFILE] [-C TTY]"
|
---|
24 | //usage:#define setfont_full_usage "\n\n"
|
---|
25 | //usage: "Load a console font\n"
|
---|
26 | //usage: "\n -m MAPFILE Load console screen map"
|
---|
27 | //usage: "\n -C TTY Affect TTY instead of /dev/tty"
|
---|
28 | //usage:
|
---|
29 | //usage:#define setfont_example_usage
|
---|
30 | //usage: "$ setfont -m koi8-r /etc/i18n/fontname\n"
|
---|
31 |
|
---|
32 | #include "libbb.h"
|
---|
33 | #include <sys/kd.h>
|
---|
34 |
|
---|
35 | #ifndef KDFONTOP
|
---|
36 | # define KDFONTOP 0x4B72
|
---|
37 | struct console_font_op {
|
---|
38 | unsigned op; /* KD_FONT_OP_* */
|
---|
39 | unsigned flags; /* KD_FONT_FLAG_* */
|
---|
40 | unsigned width, height;
|
---|
41 | unsigned charcount;
|
---|
42 | unsigned char *data; /* font data with height fixed to 32 */
|
---|
43 | };
|
---|
44 | # define KD_FONT_OP_SET 0 /* Set font */
|
---|
45 | # define KD_FONT_OP_GET 1 /* Get font */
|
---|
46 | # define KD_FONT_OP_SET_DEFAULT 2 /* Set font to default, data points to name / NULL */
|
---|
47 | # define KD_FONT_OP_COPY 3 /* Copy from another console */
|
---|
48 | # define KD_FONT_FLAG_OLD 0x80000000 /* Invoked via old interface */
|
---|
49 | # define KD_FONT_FLAG_DONT_RECALC 1 /* Don't call adjust_height() */
|
---|
50 | /* (Used internally for PIO_FONT support) */
|
---|
51 | #endif /* KDFONTOP */
|
---|
52 |
|
---|
53 |
|
---|
54 | enum {
|
---|
55 | PSF1_MAGIC0 = 0x36,
|
---|
56 | PSF1_MAGIC1 = 0x04,
|
---|
57 | PSF1_MODE512 = 0x01,
|
---|
58 | PSF1_MODEHASTAB = 0x02,
|
---|
59 | PSF1_MODEHASSEQ = 0x04,
|
---|
60 | PSF1_MAXMODE = 0x05,
|
---|
61 | PSF1_STARTSEQ = 0xfffe,
|
---|
62 | PSF1_SEPARATOR = 0xffff,
|
---|
63 | };
|
---|
64 |
|
---|
65 | struct psf1_header {
|
---|
66 | unsigned char magic[2]; /* Magic number */
|
---|
67 | unsigned char mode; /* PSF font mode */
|
---|
68 | unsigned char charsize; /* Character size */
|
---|
69 | };
|
---|
70 |
|
---|
71 | #define psf1h(x) ((struct psf1_header*)(x))
|
---|
72 |
|
---|
73 | #define PSF1_MAGIC_OK(x) ( \
|
---|
74 | (x)->magic[0] == PSF1_MAGIC0 \
|
---|
75 | && (x)->magic[1] == PSF1_MAGIC1 \
|
---|
76 | )
|
---|
77 |
|
---|
78 | #if ENABLE_FEATURE_LOADFONT_PSF2
|
---|
79 | enum {
|
---|
80 | PSF2_MAGIC0 = 0x72,
|
---|
81 | PSF2_MAGIC1 = 0xb5,
|
---|
82 | PSF2_MAGIC2 = 0x4a,
|
---|
83 | PSF2_MAGIC3 = 0x86,
|
---|
84 | PSF2_HAS_UNICODE_TABLE = 0x01,
|
---|
85 | PSF2_MAXVERSION = 0,
|
---|
86 | PSF2_STARTSEQ = 0xfe,
|
---|
87 | PSF2_SEPARATOR = 0xff
|
---|
88 | };
|
---|
89 |
|
---|
90 | struct psf2_header {
|
---|
91 | unsigned char magic[4];
|
---|
92 | unsigned int version;
|
---|
93 | unsigned int headersize; /* offset of bitmaps in file */
|
---|
94 | unsigned int flags;
|
---|
95 | unsigned int length; /* number of glyphs */
|
---|
96 | unsigned int charsize; /* number of bytes for each character */
|
---|
97 | unsigned int height; /* max dimensions of glyphs */
|
---|
98 | unsigned int width; /* charsize = height * ((width + 7) / 8) */
|
---|
99 | };
|
---|
100 |
|
---|
101 | #define psf2h(x) ((struct psf2_header*)(x))
|
---|
102 |
|
---|
103 | #define PSF2_MAGIC_OK(x) ( \
|
---|
104 | (x)->magic[0] == PSF2_MAGIC0 \
|
---|
105 | && (x)->magic[1] == PSF2_MAGIC1 \
|
---|
106 | && (x)->magic[2] == PSF2_MAGIC2 \
|
---|
107 | && (x)->magic[3] == PSF2_MAGIC3 \
|
---|
108 | )
|
---|
109 | #endif /* ENABLE_FEATURE_LOADFONT_PSF2 */
|
---|
110 |
|
---|
111 |
|
---|
112 | static void do_loadfont(int fd, unsigned char *inbuf, int height, int width, int charsize, int fontsize)
|
---|
113 | {
|
---|
114 | unsigned char *buf;
|
---|
115 | int charwidth = 32 * ((width+7)/8);
|
---|
116 | int i;
|
---|
117 |
|
---|
118 | if (height < 1 || height > 32 || width < 1 || width > 32)
|
---|
119 | bb_error_msg_and_die("bad character size %dx%d", height, width);
|
---|
120 |
|
---|
121 | buf = xzalloc(charwidth * ((fontsize < 128) ? 128 : fontsize));
|
---|
122 | for (i = 0; i < fontsize; i++)
|
---|
123 | memcpy(buf + (i*charwidth), inbuf + (i*charsize), charsize);
|
---|
124 |
|
---|
125 | { /* KDFONTOP */
|
---|
126 | struct console_font_op cfo;
|
---|
127 | cfo.op = KD_FONT_OP_SET;
|
---|
128 | cfo.flags = 0;
|
---|
129 | cfo.width = width;
|
---|
130 | cfo.height = height;
|
---|
131 | cfo.charcount = fontsize;
|
---|
132 | cfo.data = buf;
|
---|
133 | xioctl(fd, KDFONTOP, &cfo);
|
---|
134 | }
|
---|
135 |
|
---|
136 | free(buf);
|
---|
137 | }
|
---|
138 |
|
---|
139 | /*
|
---|
140 | * Format of the Unicode information:
|
---|
141 | *
|
---|
142 | * For each font position <uc>*<seq>*<term>
|
---|
143 | * where <uc> is a 2-byte little endian Unicode value (PSF1)
|
---|
144 | * or an UTF-8 coded value (PSF2),
|
---|
145 | * <seq> = <ss><uc><uc>*, <ss> = psf1 ? 0xFFFE : 0xFE,
|
---|
146 | * <term> = psf1 ? 0xFFFF : 0xFF.
|
---|
147 | * and * denotes zero or more occurrences of the preceding item.
|
---|
148 | *
|
---|
149 | * Semantics:
|
---|
150 | * The leading <uc>* part gives Unicode symbols that are all
|
---|
151 | * represented by this font position. The following sequences
|
---|
152 | * are sequences of Unicode symbols - probably a symbol
|
---|
153 | * together with combining accents - also represented by
|
---|
154 | * this font position.
|
---|
155 | *
|
---|
156 | * Example:
|
---|
157 | * At the font position for a capital A-ring glyph, we
|
---|
158 | * may have:
|
---|
159 | * 00C5,212B,FFFE,0041,030A,FFFF
|
---|
160 | * Some font positions may be described by sequences only,
|
---|
161 | * namely when there is no precomposed Unicode value for the glyph.
|
---|
162 | */
|
---|
163 | #if !ENABLE_FEATURE_LOADFONT_PSF2
|
---|
164 | #define do_loadtable(fd, inbuf, tailsz, fontsize, psf2) \
|
---|
165 | do_loadtable(fd, inbuf, tailsz, fontsize)
|
---|
166 | #endif
|
---|
167 | static void do_loadtable(int fd, unsigned char *inbuf, int tailsz, int fontsize, int psf2)
|
---|
168 | {
|
---|
169 | #if !ENABLE_FEATURE_LOADFONT_PSF2
|
---|
170 | /* gcc 4.3.1 code size: */
|
---|
171 | # define psf2 0 /* +0 bytes */
|
---|
172 | // const int psf2 = 0; /* +8 bytes */
|
---|
173 | // enum { psf2 = 0 }; /* +13 bytes */
|
---|
174 | #endif
|
---|
175 | struct unimapinit advice;
|
---|
176 | struct unimapdesc ud;
|
---|
177 | struct unipair *up;
|
---|
178 | int ct = 0, maxct;
|
---|
179 | int glyph;
|
---|
180 | uint16_t unicode;
|
---|
181 |
|
---|
182 | maxct = tailsz; /* more than enough */
|
---|
183 | up = xmalloc(maxct * sizeof(*up));
|
---|
184 |
|
---|
185 | for (glyph = 0; glyph < fontsize; glyph++) {
|
---|
186 | while (tailsz > 0) {
|
---|
187 | if (!psf2) { /* PSF1 */
|
---|
188 | unicode = (((uint16_t) inbuf[1]) << 8) + inbuf[0];
|
---|
189 | tailsz -= 2;
|
---|
190 | inbuf += 2;
|
---|
191 | if (unicode == PSF1_SEPARATOR)
|
---|
192 | break;
|
---|
193 | } else { /* PSF2 */
|
---|
194 | #if ENABLE_FEATURE_LOADFONT_PSF2
|
---|
195 | --tailsz;
|
---|
196 | unicode = *inbuf++;
|
---|
197 | if (unicode == PSF2_SEPARATOR) {
|
---|
198 | break;
|
---|
199 | } else if (unicode == PSF2_STARTSEQ) {
|
---|
200 | bb_error_msg_and_die("unicode sequences not implemented");
|
---|
201 | } else if (unicode >= 0xC0) {
|
---|
202 | if (unicode >= 0xFC)
|
---|
203 | unicode &= 0x01, maxct = 5;
|
---|
204 | else if (unicode >= 0xF8)
|
---|
205 | unicode &= 0x03, maxct = 4;
|
---|
206 | else if (unicode >= 0xF0)
|
---|
207 | unicode &= 0x07, maxct = 3;
|
---|
208 | else if (unicode >= 0xE0)
|
---|
209 | unicode &= 0x0F, maxct = 2;
|
---|
210 | else
|
---|
211 | unicode &= 0x1F, maxct = 1;
|
---|
212 | do {
|
---|
213 | if (tailsz <= 0 || *inbuf < 0x80 || *inbuf > 0xBF)
|
---|
214 | bb_error_msg_and_die("illegal UTF-8 character");
|
---|
215 | --tailsz;
|
---|
216 | unicode = (unicode << 6) + (*inbuf++ & 0x3F);
|
---|
217 | } while (--maxct > 0);
|
---|
218 | } else if (unicode >= 0x80) {
|
---|
219 | bb_error_msg_and_die("illegal UTF-8 character");
|
---|
220 | }
|
---|
221 | #else
|
---|
222 | return;
|
---|
223 | #endif
|
---|
224 | }
|
---|
225 | up[ct].unicode = unicode;
|
---|
226 | up[ct].fontpos = glyph;
|
---|
227 | ct++;
|
---|
228 | }
|
---|
229 | }
|
---|
230 |
|
---|
231 | /* Note: after PIO_UNIMAPCLR and before PIO_UNIMAP
|
---|
232 | * this printf did not work on many kernels */
|
---|
233 |
|
---|
234 | advice.advised_hashsize = 0;
|
---|
235 | advice.advised_hashstep = 0;
|
---|
236 | advice.advised_hashlevel = 0;
|
---|
237 | xioctl(fd, PIO_UNIMAPCLR, &advice);
|
---|
238 | ud.entry_ct = ct;
|
---|
239 | ud.entries = up;
|
---|
240 | xioctl(fd, PIO_UNIMAP, &ud);
|
---|
241 | #undef psf2
|
---|
242 | }
|
---|
243 |
|
---|
244 | static void do_load(int fd, unsigned char *buffer, size_t len)
|
---|
245 | {
|
---|
246 | int height;
|
---|
247 | int width = 8;
|
---|
248 | int charsize;
|
---|
249 | int fontsize = 256;
|
---|
250 | int has_table = 0;
|
---|
251 | unsigned char *font = buffer;
|
---|
252 | unsigned char *table;
|
---|
253 |
|
---|
254 | if (len >= sizeof(struct psf1_header) && PSF1_MAGIC_OK(psf1h(buffer))) {
|
---|
255 | if (psf1h(buffer)->mode > PSF1_MAXMODE)
|
---|
256 | bb_error_msg_and_die("unsupported psf file mode");
|
---|
257 | if (psf1h(buffer)->mode & PSF1_MODE512)
|
---|
258 | fontsize = 512;
|
---|
259 | if (psf1h(buffer)->mode & PSF1_MODEHASTAB)
|
---|
260 | has_table = 1;
|
---|
261 | height = charsize = psf1h(buffer)->charsize;
|
---|
262 | font += sizeof(struct psf1_header);
|
---|
263 | } else
|
---|
264 | #if ENABLE_FEATURE_LOADFONT_PSF2
|
---|
265 | if (len >= sizeof(struct psf2_header) && PSF2_MAGIC_OK(psf2h(buffer))) {
|
---|
266 | if (psf2h(buffer)->version > PSF2_MAXVERSION)
|
---|
267 | bb_error_msg_and_die("unsupported psf file version");
|
---|
268 | fontsize = psf2h(buffer)->length;
|
---|
269 | if (psf2h(buffer)->flags & PSF2_HAS_UNICODE_TABLE)
|
---|
270 | has_table = 2;
|
---|
271 | charsize = psf2h(buffer)->charsize;
|
---|
272 | height = psf2h(buffer)->height;
|
---|
273 | width = psf2h(buffer)->width;
|
---|
274 | font += psf2h(buffer)->headersize;
|
---|
275 | } else
|
---|
276 | #endif
|
---|
277 | #if ENABLE_FEATURE_LOADFONT_RAW
|
---|
278 | if (len == 9780) { /* file with three code pages? */
|
---|
279 | charsize = height = 16;
|
---|
280 | font += 40;
|
---|
281 | } else if ((len & 0377) == 0) { /* bare font */
|
---|
282 | charsize = height = len / 256;
|
---|
283 | } else
|
---|
284 | #endif
|
---|
285 | {
|
---|
286 | bb_error_msg_and_die("input file: bad length or unsupported font type");
|
---|
287 | }
|
---|
288 |
|
---|
289 | #if !defined(PIO_FONTX) || defined(__sparc__)
|
---|
290 | if (fontsize != 256)
|
---|
291 | bb_error_msg_and_die("only fontsize 256 supported");
|
---|
292 | #endif
|
---|
293 |
|
---|
294 | table = font + fontsize * charsize;
|
---|
295 | buffer += len;
|
---|
296 |
|
---|
297 | if (table > buffer || (!has_table && table != buffer))
|
---|
298 | bb_error_msg_and_die("input file: bad length");
|
---|
299 |
|
---|
300 | do_loadfont(fd, font, height, width, charsize, fontsize);
|
---|
301 |
|
---|
302 | if (has_table)
|
---|
303 | do_loadtable(fd, table, buffer - table, fontsize, has_table - 1);
|
---|
304 | }
|
---|
305 |
|
---|
306 |
|
---|
307 | #if ENABLE_LOADFONT
|
---|
308 | int loadfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
309 | int loadfont_main(int argc UNUSED_PARAM, char **argv)
|
---|
310 | {
|
---|
311 | size_t len;
|
---|
312 | unsigned char *buffer;
|
---|
313 |
|
---|
314 | // no arguments allowed!
|
---|
315 | opt_complementary = "=0";
|
---|
316 | getopt32(argv, "");
|
---|
317 |
|
---|
318 | /*
|
---|
319 | * We used to look at the length of the input file
|
---|
320 | * with stat(); now that we accept compressed files,
|
---|
321 | * just read the entire file.
|
---|
322 | */
|
---|
323 | len = 32*1024; // can't be larger
|
---|
324 | buffer = xmalloc_read(STDIN_FILENO, &len);
|
---|
325 | // xmalloc_open_zipped_read_close(filename, &len);
|
---|
326 | if (!buffer)
|
---|
327 | bb_perror_msg_and_die("error reading input font");
|
---|
328 | do_load(get_console_fd_or_die(), buffer, len);
|
---|
329 |
|
---|
330 | return EXIT_SUCCESS;
|
---|
331 | }
|
---|
332 | #endif
|
---|
333 |
|
---|
334 | #if ENABLE_SETFONT
|
---|
335 |
|
---|
336 | /*
|
---|
337 | kbd-1.12:
|
---|
338 |
|
---|
339 | setfont [-O font+umap.orig] [-o font.orig] [-om cmap.orig]
|
---|
340 | [-ou umap.orig] [-N] [font.new ...] [-m cmap] [-u umap] [-C console]
|
---|
341 | [-hNN] [-v] [-V]
|
---|
342 |
|
---|
343 | -h NN Override font height
|
---|
344 | -o file
|
---|
345 | Save previous font in file
|
---|
346 | -O file
|
---|
347 | Save previous font and Unicode map in file
|
---|
348 | -om file
|
---|
349 | Store console map in file
|
---|
350 | -ou file
|
---|
351 | Save previous Unicode map in file
|
---|
352 | -m file
|
---|
353 | Load console map or Unicode console map from file
|
---|
354 | -u file
|
---|
355 | Load Unicode table describing the font from file
|
---|
356 | Example:
|
---|
357 | # cp866
|
---|
358 | 0x00-0x7f idem
|
---|
359 | #
|
---|
360 | 0x80 U+0410 # CYRILLIC CAPITAL LETTER A
|
---|
361 | 0x81 U+0411 # CYRILLIC CAPITAL LETTER BE
|
---|
362 | 0x82 U+0412 # CYRILLIC CAPITAL LETTER VE
|
---|
363 | -C console
|
---|
364 | Set the font for the indicated console
|
---|
365 | -v Verbose
|
---|
366 | -V Version
|
---|
367 | */
|
---|
368 |
|
---|
369 | #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP
|
---|
370 | static int ctoi(char *s)
|
---|
371 | {
|
---|
372 | if (s[0] == '\'' && s[1] != '\0' && s[2] == '\'' && s[3] == '\0')
|
---|
373 | return s[1];
|
---|
374 | // U+ means 0x
|
---|
375 | if (s[0] == 'U' && s[1] == '+') {
|
---|
376 | s[0] = '0';
|
---|
377 | s[1] = 'x';
|
---|
378 | }
|
---|
379 | if (!isdigit(s[0]))
|
---|
380 | return -1;
|
---|
381 | return xstrtoul(s, 0);
|
---|
382 | }
|
---|
383 | #endif
|
---|
384 |
|
---|
385 | int setfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
386 | int setfont_main(int argc UNUSED_PARAM, char **argv)
|
---|
387 | {
|
---|
388 | size_t len;
|
---|
389 | unsigned opts;
|
---|
390 | int fd;
|
---|
391 | unsigned char *buffer;
|
---|
392 | char *mapfilename;
|
---|
393 | const char *tty_name = CURRENT_TTY;
|
---|
394 |
|
---|
395 | opt_complementary = "=1";
|
---|
396 | opts = getopt32(argv, "m:C:", &mapfilename, &tty_name);
|
---|
397 | argv += optind;
|
---|
398 |
|
---|
399 | fd = xopen_nonblocking(tty_name);
|
---|
400 |
|
---|
401 | if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not ""
|
---|
402 | if (*argv[0] != '/') {
|
---|
403 | // goto default fonts location. don't die if doesn't exist
|
---|
404 | chdir(CONFIG_DEFAULT_SETFONT_DIR "/consolefonts");
|
---|
405 | }
|
---|
406 | }
|
---|
407 | // load font
|
---|
408 | len = 32*1024; // can't be larger
|
---|
409 | buffer = xmalloc_open_zipped_read_close(*argv, &len);
|
---|
410 | if (!buffer)
|
---|
411 | bb_simple_perror_msg_and_die(*argv);
|
---|
412 | do_load(fd, buffer, len);
|
---|
413 |
|
---|
414 | // load the screen map, if any
|
---|
415 | if (opts & 1) { // -m
|
---|
416 | unsigned mode = PIO_SCRNMAP;
|
---|
417 | void *map;
|
---|
418 |
|
---|
419 | if (sizeof(CONFIG_DEFAULT_SETFONT_DIR) > 1) { // if not ""
|
---|
420 | if (mapfilename[0] != '/') {
|
---|
421 | // goto default keymaps location
|
---|
422 | chdir(CONFIG_DEFAULT_SETFONT_DIR "/consoletrans");
|
---|
423 | }
|
---|
424 | }
|
---|
425 | // fetch keymap
|
---|
426 | map = xmalloc_open_zipped_read_close(mapfilename, &len);
|
---|
427 | if (!map)
|
---|
428 | bb_simple_perror_msg_and_die(mapfilename);
|
---|
429 | // file size is 256 or 512 bytes? -> assume binary map
|
---|
430 | if (len == E_TABSZ || len == 2*E_TABSZ) {
|
---|
431 | if (len == 2*E_TABSZ)
|
---|
432 | mode = PIO_UNISCRNMAP;
|
---|
433 | }
|
---|
434 | #if ENABLE_FEATURE_SETFONT_TEXTUAL_MAP
|
---|
435 | // assume textual Unicode console maps:
|
---|
436 | // 0x00 U+0000 # NULL (NUL)
|
---|
437 | // 0x01 U+0001 # START OF HEADING (SOH)
|
---|
438 | // 0x02 U+0002 # START OF TEXT (STX)
|
---|
439 | // 0x03 U+0003 # END OF TEXT (ETX)
|
---|
440 | else {
|
---|
441 | int i;
|
---|
442 | char *token[2];
|
---|
443 | parser_t *parser;
|
---|
444 |
|
---|
445 | if (ENABLE_FEATURE_CLEAN_UP)
|
---|
446 | free(map);
|
---|
447 | map = xmalloc(E_TABSZ * sizeof(unsigned short));
|
---|
448 |
|
---|
449 | #define unicodes ((unsigned short *)map)
|
---|
450 | // fill vanilla map
|
---|
451 | for (i = 0; i < E_TABSZ; i++)
|
---|
452 | unicodes[i] = 0xf000 + i;
|
---|
453 |
|
---|
454 | parser = config_open(mapfilename);
|
---|
455 | while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL | PARSE_MIN_DIE)) {
|
---|
456 | // parse code/value pair
|
---|
457 | int a = ctoi(token[0]);
|
---|
458 | int b = ctoi(token[1]);
|
---|
459 | if (a < 0 || a >= E_TABSZ
|
---|
460 | || b < 0 || b > 65535
|
---|
461 | ) {
|
---|
462 | bb_error_msg_and_die("map format");
|
---|
463 | }
|
---|
464 | // patch map
|
---|
465 | unicodes[a] = b;
|
---|
466 | // unicode character is met?
|
---|
467 | if (b > 255)
|
---|
468 | mode = PIO_UNISCRNMAP;
|
---|
469 | }
|
---|
470 | if (ENABLE_FEATURE_CLEAN_UP)
|
---|
471 | config_close(parser);
|
---|
472 |
|
---|
473 | if (mode != PIO_UNISCRNMAP) {
|
---|
474 | #define asciis ((unsigned char *)map)
|
---|
475 | for (i = 0; i < E_TABSZ; i++)
|
---|
476 | asciis[i] = unicodes[i];
|
---|
477 | #undef asciis
|
---|
478 | }
|
---|
479 | #undef unicodes
|
---|
480 | }
|
---|
481 | #endif // ENABLE_FEATURE_SETFONT_TEXTUAL_MAP
|
---|
482 |
|
---|
483 | // do set screen map
|
---|
484 | xioctl(fd, mode, map);
|
---|
485 |
|
---|
486 | if (ENABLE_FEATURE_CLEAN_UP)
|
---|
487 | free(map);
|
---|
488 | }
|
---|
489 |
|
---|
490 | return EXIT_SUCCESS;
|
---|
491 | }
|
---|
492 | #endif
|
---|