[821] | 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.)
|
---|
[2725] | 9 | *
|
---|
| 10 | * Licensed under GPLv2, see file LICENSE in this source tree.
|
---|
[821] | 11 | */
|
---|
[3232] | 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 |
|
---|
[1765] | 32 | #include "libbb.h"
|
---|
[821] | 33 | #include <sys/kd.h>
|
---|
| 34 |
|
---|
[2725] | 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 |
|
---|
[1765] | 54 | enum {
|
---|
[2725] | 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,
|
---|
[821] | 63 | };
|
---|
| 64 |
|
---|
[2725] | 65 | struct psf1_header {
|
---|
| 66 | unsigned char magic[2]; /* Magic number */
|
---|
[1765] | 67 | unsigned char mode; /* PSF font mode */
|
---|
| 68 | unsigned char charsize; /* Character size */
|
---|
[821] | 69 | };
|
---|
| 70 |
|
---|
[2725] | 71 | #define psf1h(x) ((struct psf1_header*)(x))
|
---|
[821] | 72 |
|
---|
[2725] | 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)
|
---|
[821] | 113 | {
|
---|
[2725] | 114 | unsigned char *buf;
|
---|
| 115 | int charwidth = 32 * ((width+7)/8);
|
---|
[821] | 116 | int i;
|
---|
| 117 |
|
---|
[2725] | 118 | if (height < 1 || height > 32 || width < 1 || width > 32)
|
---|
| 119 | bb_error_msg_and_die("bad character size %dx%d", height, width);
|
---|
[821] | 120 |
|
---|
[2725] | 121 | buf = xzalloc(charwidth * ((fontsize < 128) ? 128 : fontsize));
|
---|
[821] | 122 | for (i = 0; i < fontsize; i++)
|
---|
[2725] | 123 | memcpy(buf + (i*charwidth), inbuf + (i*charsize), charsize);
|
---|
[821] | 124 |
|
---|
[2725] | 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 | }
|
---|
[821] | 135 |
|
---|
[1765] | 136 | free(buf);
|
---|
[821] | 137 | }
|
---|
| 138 |
|
---|
[2725] | 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)
|
---|
[821] | 168 | {
|
---|
[2725] | 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
|
---|
[821] | 175 | struct unimapinit advice;
|
---|
| 176 | struct unimapdesc ud;
|
---|
| 177 | struct unipair *up;
|
---|
| 178 | int ct = 0, maxct;
|
---|
| 179 | int glyph;
|
---|
[1765] | 180 | uint16_t unicode;
|
---|
[821] | 181 |
|
---|
[2725] | 182 | maxct = tailsz; /* more than enough */
|
---|
| 183 | up = xmalloc(maxct * sizeof(*up));
|
---|
[821] | 184 |
|
---|
| 185 | for (glyph = 0; glyph < fontsize; glyph++) {
|
---|
[2725] | 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 | }
|
---|
[821] | 225 | up[ct].unicode = unicode;
|
---|
| 226 | up[ct].fontpos = glyph;
|
---|
| 227 | ct++;
|
---|
| 228 | }
|
---|
| 229 | }
|
---|
| 230 |
|
---|
| 231 | /* Note: after PIO_UNIMAPCLR and before PIO_UNIMAP
|
---|
[3232] | 232 | * this printf did not work on many kernels */
|
---|
[821] | 233 |
|
---|
| 234 | advice.advised_hashsize = 0;
|
---|
| 235 | advice.advised_hashstep = 0;
|
---|
| 236 | advice.advised_hashlevel = 0;
|
---|
[1765] | 237 | xioctl(fd, PIO_UNIMAPCLR, &advice);
|
---|
[821] | 238 | ud.entry_ct = ct;
|
---|
| 239 | ud.entries = up;
|
---|
[1765] | 240 | xioctl(fd, PIO_UNIMAP, &ud);
|
---|
[2725] | 241 | #undef psf2
|
---|
[821] | 242 | }
|
---|
| 243 |
|
---|
[2725] | 244 | static void do_load(int fd, unsigned char *buffer, size_t len)
|
---|
[821] | 245 | {
|
---|
[2725] | 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;
|
---|
[1765] | 253 |
|
---|
[2725] | 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 | }
|
---|
[821] | 288 |
|
---|
[2725] | 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 |
|
---|
[821] | 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 | */
|
---|
[2725] | 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)
|
---|
[1765] | 327 | bb_perror_msg_and_die("error reading input font");
|
---|
[2725] | 328 | do_load(get_console_fd_or_die(), buffer, len);
|
---|
[821] | 329 |
|
---|
[2725] | 330 | return EXIT_SUCCESS;
|
---|
| 331 | }
|
---|
| 332 | #endif
|
---|
[821] | 333 |
|
---|
[2725] | 334 | #if ENABLE_SETFONT
|
---|
[821] | 335 |
|
---|
[2725] | 336 | /*
|
---|
| 337 | kbd-1.12:
|
---|
[821] | 338 |
|
---|
[2725] | 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]
|
---|
[821] | 342 |
|
---|
[2725] | 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 | */
|
---|
[821] | 368 |
|
---|
[2725] | 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';
|
---|
[821] | 378 | }
|
---|
[2725] | 379 | if (!isdigit(s[0]))
|
---|
| 380 | return -1;
|
---|
| 381 | return xstrtoul(s, 0);
|
---|
[821] | 382 | }
|
---|
[2725] | 383 | #endif
|
---|
[1765] | 384 |
|
---|
[2725] | 385 | int setfont_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
---|
| 386 | int setfont_main(int argc UNUSED_PARAM, char **argv)
|
---|
[1765] | 387 | {
|
---|
[2725] | 388 | size_t len;
|
---|
| 389 | unsigned opts;
|
---|
[1765] | 390 | int fd;
|
---|
[2725] | 391 | unsigned char *buffer;
|
---|
| 392 | char *mapfilename;
|
---|
| 393 | const char *tty_name = CURRENT_TTY;
|
---|
[1765] | 394 |
|
---|
[2725] | 395 | opt_complementary = "=1";
|
---|
| 396 | opts = getopt32(argv, "m:C:", &mapfilename, &tty_name);
|
---|
| 397 | argv += optind;
|
---|
[1765] | 398 |
|
---|
[2725] | 399 | fd = xopen_nonblocking(tty_name);
|
---|
[1765] | 400 |
|
---|
[2725] | 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 |
|
---|
[1765] | 490 | return EXIT_SUCCESS;
|
---|
| 491 | }
|
---|
[2725] | 492 | #endif
|
---|