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