Author: emaste
Date: Sat Dec 21 13:58:55 2013
New Revision: 259680
URL: http://svnweb.freebsd.org/changeset/base/259680
Log:
Support double-width characters in vt(9)
Normal and bold fonts each have a glyph map for single or left half-
glyphs, and right half glyphs. The flag TF_CJK_RIGHT in term_char_t
requests the right half-glyph.
Reviewed by: ed@
Sponsored by: The FreeBSD Foundation
Modified:
head/sys/dev/vt/font/vt_font_default.c
head/sys/dev/vt/vt.h
head/sys/dev/vt/vt_font.c
head/sys/sys/consio.h
head/tools/tools/vt/fontcvt/fontcvt.c
head/tools/tools/vt/mkkfont/mkkfont.c
head/tools/tools/vt/setfont/setfont.c
Modified: head/sys/dev/vt/font/vt_font_default.c
==============================================================================
--- head/sys/dev/vt/font/vt_font_default.c Sat Dec 21 12:55:42 2013
(r259679)
+++ head/sys/dev/vt/font/vt_font_default.c Sat Dec 21 13:58:55 2013
(r259680)
@@ -2194,9 +2194,8 @@ struct vt_font vt_font_default = {
.vf_width = 8,
.vf_height = 16,
.vf_bytes = font_bytes,
- .vf_normal = font_mapping_normal,
- .vf_normal_length = 248,
- .vf_bold = font_mapping_bold,
- .vf_bold_length = 260,
+ .vf_map = { font_mapping_normal, NULL,
+ font_mapping_bold, NULL },
+ .vf_map_count = { 248, 0, 260, 0 },
.vf_refcount = 1,
};
Modified: head/sys/dev/vt/vt.h
==============================================================================
--- head/sys/dev/vt/vt.h Sat Dec 21 12:55:42 2013 (r259679)
+++ head/sys/dev/vt/vt.h Sat Dec 21 13:58:55 2013 (r259680)
@@ -388,11 +388,10 @@ struct vt_font_map {
};
struct vt_font {
- struct vt_font_map *vf_bold;
- struct vt_font_map *vf_normal;
+ struct vt_font_map *vf_map[VFNT_MAPS];
uint8_t *vf_bytes;
- unsigned int vf_height, vf_width,
- vf_normal_length, vf_bold_length;
+ unsigned int vf_height, vf_width;
+ unsigned int vf_map_count[VFNT_MAPS];
unsigned int vf_refcount;
};
Modified: head/sys/dev/vt/vt_font.c
==============================================================================
--- head/sys/dev/vt/vt_font.c Sat Dec 21 12:55:42 2013 (r259679)
+++ head/sys/dev/vt/vt_font.c Sat Dec 21 13:58:55 2013 (r259680)
@@ -41,7 +41,7 @@ __FBSDID("$FreeBSD$");
static MALLOC_DEFINE(M_VTFONT, "vtfont", "vt font");
/* Some limits to prevent abnormal fonts from being loaded. */
-#define VTFONT_MAXMAPPINGS 1024
+#define VTFONT_MAXMAPPINGS 8192
#define VTFONT_MAXGLYPHSIZE 262144
#define VTFONT_MAXDIMENSION 128
@@ -86,6 +86,8 @@ vtfont_lookup(const struct vt_font *vf,
uint32_t src;
uint16_t dst;
size_t stride;
+ unsigned int normal_map;
+ unsigned int bold_map;
/*
* No support for printing right hand sides for CJK fullwidth
@@ -93,15 +95,22 @@ vtfont_lookup(const struct vt_font *vf,
* hand side describes the entire character.
*/
src = TCHAR_CHARACTER(c);
- if (TCHAR_FORMAT(c) & TF_CJK_RIGHT)
- src = ' ';
+ if (TCHAR_FORMAT(c) & TF_CJK_RIGHT) {
+ normal_map = VFNT_MAP_NORMAL_RIGHT;
+ bold_map = VFNT_MAP_BOLD_RIGHT;
+ } else {
+ normal_map = VFNT_MAP_NORMAL;
+ bold_map = VFNT_MAP_BOLD;
+ }
if (TCHAR_FORMAT(c) & TF_BOLD) {
- dst = vtfont_bisearch(vf->vf_bold, vf->vf_bold_length, src);
+ dst = vtfont_bisearch(vf->vf_map[bold_map],
+ vf->vf_map_count[bold_map], src);
if (dst != 0)
goto found;
}
- dst = vtfont_bisearch(vf->vf_normal, vf->vf_normal_length, src);
+ dst = vtfont_bisearch(vf->vf_map[normal_map],
+ vf->vf_map_count[normal_map], src);
found:
stride = howmany(vf->vf_width, 8) * vf->vf_height;
@@ -119,10 +128,11 @@ vtfont_ref(struct vt_font *vf)
void
vtfont_unref(struct vt_font *vf)
{
+ unsigned int i;
if (refcount_release(&vf->vf_refcount)) {
- free(vf->vf_normal, M_VTFONT);
- free(vf->vf_bold, M_VTFONT);
+ for (i = 0; i < VFNT_MAPS; i++)
+ free(vf->vf_map[i], M_VTFONT);
free(vf->vf_bytes, M_VTFONT);
free(vf, M_VTFONT);
}
@@ -130,7 +140,7 @@ vtfont_unref(struct vt_font *vf)
static int
vtfont_validate_map(struct vt_font_map *vfm, unsigned int length,
- unsigned int nglyphs)
+ unsigned int glyph_count)
{
unsigned int i, last = 0;
@@ -141,8 +151,8 @@ vtfont_validate_map(struct vt_font_map *
/*
* Destination extends amount of glyphs.
*/
- if (vfm[i].vfm_dst >= nglyphs ||
- vfm[i].vfm_dst + vfm[i].vfm_len >= nglyphs)
+ if (vfm[i].vfm_dst >= glyph_count ||
+ vfm[i].vfm_dst + vfm[i].vfm_len >= glyph_count)
return (EINVAL);
last = vfm[i].vfm_src + vfm[i].vfm_len;
}
@@ -153,9 +163,10 @@ vtfont_validate_map(struct vt_font_map *
int
vtfont_load(vfnt_t *f, struct vt_font **ret)
{
- size_t glyphsize;
+ size_t glyphsize, mapsize;
struct vt_font *vf;
int error;
+ unsigned int i;
/* Make sure the dimensions are valid. */
if (f->width < 1 || f->height < 1)
@@ -164,50 +175,43 @@ vtfont_load(vfnt_t *f, struct vt_font **
return (E2BIG);
/* Not too many mappings. */
- if (f->nnormal > VTFONT_MAXMAPPINGS || f->nbold > VTFONT_MAXMAPPINGS)
- return (E2BIG);
+ for (i = 0; i < VFNT_MAPS; i++)
+ if (f->map_count[i] > VTFONT_MAXMAPPINGS)
+ return (E2BIG);
/* Character 0 must always be present. */
- if (f->nglyphs < 1)
+ if (f->glyph_count < 1)
return (EINVAL);
- glyphsize = howmany(f->width, 8) * f->height * f->nglyphs;
+ glyphsize = howmany(f->width, 8) * f->height * f->glyph_count;
if (glyphsize > VTFONT_MAXGLYPHSIZE)
return (E2BIG);
/* Allocate new font structure. */
- vf = malloc(sizeof *vf, M_VTFONT, M_WAITOK);
- vf->vf_normal = malloc(f->nnormal * sizeof(struct vt_font_map),
- M_VTFONT, M_WAITOK);
- vf->vf_bold = malloc(f->nbold * sizeof(struct vt_font_map),
- M_VTFONT, M_WAITOK);
+ vf = malloc(sizeof *vf, M_VTFONT, M_WAITOK | M_ZERO);
vf->vf_bytes = malloc(glyphsize, M_VTFONT, M_WAITOK);
vf->vf_height = f->height;
vf->vf_width = f->width;
- vf->vf_normal_length = f->nnormal;
- vf->vf_bold_length = f->nbold;
vf->vf_refcount = 1;
- /* Copy in data. */
- error = copyin(f->normal, vf->vf_normal,
- vf->vf_normal_length * sizeof(struct vt_font_map));
- if (error)
- goto bad;
- error = copyin(f->bold, vf->vf_bold,
- vf->vf_bold_length * sizeof(struct vt_font_map));
- if (error)
- goto bad;
- error = copyin(f->glyphs, vf->vf_bytes, glyphsize);
- if (error)
- goto bad;
+ /* Allocate, copy in, and validate mappings. */
+ for (i = 0; i < VFNT_MAPS; i++) {
+ vf->vf_map_count[i] = f->map_count[i];
+ if (f->map_count[i] == 0)
+ continue;
+ mapsize = f->map_count[i] * sizeof(struct vt_font_map);
+ vf->vf_map[i] = malloc(mapsize, M_VTFONT, M_WAITOK);
+ error = copyin(f->map[i], vf->vf_map[i], mapsize);
+ if (error)
+ goto bad;
+ error = vtfont_validate_map(vf->vf_map[i], vf->vf_map_count[i],
+ f->glyph_count);
+ if (error)
+ goto bad;
+ }
- /* Validate mappings. */
- error = vtfont_validate_map(vf->vf_normal, vf->vf_normal_length,
- f->nglyphs);
- if (error)
- goto bad;
- error = vtfont_validate_map(vf->vf_bold, vf->vf_bold_length,
- f->nglyphs);
+ /* Copy in glyph data. */
+ error = copyin(f->glyphs, vf->vf_bytes, glyphsize);
if (error)
goto bad;
Modified: head/sys/sys/consio.h
==============================================================================
--- head/sys/sys/consio.h Sat Dec 21 12:55:42 2013 (r259679)
+++ head/sys/sys/consio.h Sat Dec 21 13:58:55 2013 (r259680)
@@ -216,13 +216,16 @@ struct vfnt_map {
};
typedef struct vfnt_map vfnt_map_t;
+#define VFNT_MAP_NORMAL 0
+#define VFNT_MAP_NORMAL_RIGHT 1
+#define VFNT_MAP_BOLD 2
+#define VFNT_MAP_BOLD_RIGHT 3
+#define VFNT_MAPS 4
struct vfnt {
- vfnt_map_t *normal;
- vfnt_map_t *bold;
+ vfnt_map_t *map[VFNT_MAPS];
uint8_t *glyphs;
- unsigned int nnormal;
- unsigned int nbold;
- unsigned int nglyphs;
+ unsigned int map_count[VFNT_MAPS];
+ unsigned int glyph_count;
unsigned int width;
unsigned int height;
};
Modified: head/tools/tools/vt/fontcvt/fontcvt.c
==============================================================================
--- head/tools/tools/vt/fontcvt/fontcvt.c Sat Dec 21 12:55:42 2013
(r259679)
+++ head/tools/tools/vt/fontcvt/fontcvt.c Sat Dec 21 13:58:55 2013
(r259680)
@@ -40,6 +40,10 @@ __FBSDID("$FreeBSD$");
#include <stdlib.h>
#include <string.h>
+#define VFNT_MAPS 4
+#define VFNT_MAP_NORMAL 0
+#define VFNT_MAP_BOLD 2
+
static unsigned int width, wbytes, height;
struct glyph {
@@ -48,9 +52,14 @@ struct glyph {
unsigned int g_index;
};
-static TAILQ_HEAD(, glyph) glyph_list = TAILQ_HEAD_INITIALIZER(glyph_list);
-static unsigned int glyph_total, glyph_normal, glyph_bold,
- glyph_unique, glyph_dupe;
+TAILQ_HEAD(glyph_list, glyph);
+static struct glyph_list glyphs[VFNT_MAPS] = {
+ TAILQ_HEAD_INITIALIZER(glyphs[0]),
+ TAILQ_HEAD_INITIALIZER(glyphs[1]),
+ TAILQ_HEAD_INITIALIZER(glyphs[2]),
+ TAILQ_HEAD_INITIALIZER(glyphs[3]),
+};
+static unsigned int glyph_total, glyph_count[4], glyph_unique, glyph_dupe;
struct mapping {
TAILQ_ENTRY(mapping) m_list;
@@ -60,12 +69,14 @@ struct mapping {
};
TAILQ_HEAD(mapping_list, mapping);
-static struct mapping_list mapping_list_normal =
- TAILQ_HEAD_INITIALIZER(mapping_list_normal);
-static struct mapping_list mapping_list_bold =
- TAILQ_HEAD_INITIALIZER(mapping_list_bold);
-static unsigned int mapping_total, mapping_normal, mapping_normal_folded,
- mapping_bold, mapping_bold_folded, mapping_unique, mapping_dupe;
+static struct mapping_list maps[VFNT_MAPS] = {
+ TAILQ_HEAD_INITIALIZER(maps[0]),
+ TAILQ_HEAD_INITIALIZER(maps[1]),
+ TAILQ_HEAD_INITIALIZER(maps[2]),
+ TAILQ_HEAD_INITIALIZER(maps[3]),
+};
+static unsigned int mapping_total, map_count[4], map_folded_count[4],
+ mapping_unique, mapping_dupe;
static void
usage(void)
@@ -77,17 +88,18 @@ usage(void)
}
static int
-add_mapping(struct glyph *gl, unsigned int c, int bold)
+add_mapping(struct glyph *gl, unsigned int c, unsigned int map_idx)
{
struct mapping *mp;
struct mapping_list *ml;
mapping_total++;
- if (bold) {
+ if (map_idx >= VFNT_MAP_BOLD) {
int found = 0;
+ unsigned normal_map_idx = map_idx - VFNT_MAP_BOLD;
- TAILQ_FOREACH(mp, &mapping_list_normal, m_list) {
+ TAILQ_FOREACH(mp, &maps[normal_map_idx], m_list) {
if (mp->m_char < c)
continue;
else if (mp->m_char > c)
@@ -116,7 +128,7 @@ add_mapping(struct glyph *gl, unsigned i
mp->m_glyph = gl;
mp->m_length = 0;
- ml = bold ? &mapping_list_bold : &mapping_list_normal;
+ ml = &maps[map_idx];
if (TAILQ_LAST(ml, mapping_list) != NULL &&
TAILQ_LAST(ml, mapping_list)->m_char >= c) {
fprintf(stderr, "Bad ordering at character %u\n", c);
@@ -124,30 +136,27 @@ add_mapping(struct glyph *gl, unsigned i
}
TAILQ_INSERT_TAIL(ml, mp, m_list);
- if (bold)
- mapping_bold++;
- else
- mapping_normal++;
+ map_count[map_idx]++;
mapping_unique++;
return (0);
}
static struct glyph *
-add_glyph(const uint8_t *bytes, int bold, int fallback)
+add_glyph(const uint8_t *bytes, unsigned int map_idx, int fallback)
{
struct glyph *gl;
+ unsigned int i;
glyph_total++;
- if (bold)
- glyph_bold++;
- else
- glyph_normal++;
+ glyph_count[map_idx]++;
- TAILQ_FOREACH(gl, &glyph_list, g_list) {
- if (memcmp(gl->g_data, bytes, wbytes * height) == 0) {
- glyph_dupe++;
- return (gl);
+ for (i = 0; i < VFNT_MAPS; i++) {
+ TAILQ_FOREACH(gl, &glyphs[i], g_list) {
+ if (memcmp(gl->g_data, bytes, wbytes * height) == 0) {
+ glyph_dupe++;
+ return (gl);
+ }
}
}
@@ -155,22 +164,61 @@ add_glyph(const uint8_t *bytes, int bold
gl->g_data = malloc(wbytes * height);
memcpy(gl->g_data, bytes, wbytes * height);
if (fallback)
- TAILQ_INSERT_HEAD(&glyph_list, gl, g_list);
+ TAILQ_INSERT_HEAD(&glyphs[map_idx], gl, g_list);
else
- TAILQ_INSERT_TAIL(&glyph_list, gl, g_list);
+ TAILQ_INSERT_TAIL(&glyphs[map_idx], gl, g_list);
glyph_unique++;
return (gl);
}
static int
-parse_bdf(const char *filename, int bold __unused)
+parse_bitmap_line(uint8_t *left, uint8_t *right, unsigned int line,
+ unsigned int dwidth)
+{
+ uint8_t *p;
+ unsigned int i, subline;
+
+ if (dwidth != width && dwidth != width * 2) {
+ fprintf(stderr,
+ "Unsupported width %u!\n", dwidth);
+ return (1);
+ }
+
+ /* Move pixel data right to simplify splitting double characters. */
+ line >>= (howmany(dwidth, 8) * 8) - dwidth;
+
+ for (i = dwidth / width; i > 0; i--) {
+ p = (i == 2) ? right : left;
+
+ subline = line & ((1 << width) - 1);
+ subline <<= (howmany(width, 8) * 8) - width;
+
+ if (wbytes == 1) {
+ *p = subline;
+ } else if (wbytes == 2) {
+ *p++ = subline >> 8;
+ *p = subline;
+ } else {
+ fprintf(stderr,
+ "Unsupported wbytes %u!\n", wbytes);
+ return (1);
+ }
+
+ line >>= width;
+ }
+
+ return (0);
+}
+
+static int
+parse_bdf(const char *filename, unsigned int map_idx)
{
FILE *fp;
char *ln;
size_t length;
- uint8_t bytes[wbytes * height];
- unsigned int curchar = 0, i, line;
+ uint8_t bytes[wbytes * height], bytes_r[wbytes * height];
+ unsigned int curchar = 0, dwidth = 0, i, line;
struct glyph *gl;
fp = fopen(filename, "r");
@@ -186,6 +234,10 @@ parse_bdf(const char *filename, int bold
curchar = atoi(ln + 9);
}
+ if (strncmp(ln, "DWIDTH ", 7) == 0) {
+ dwidth = atoi(ln + 7);
+ }
+
if (strcmp(ln, "BITMAP") == 0) {
for (i = 0; i < height; i++) {
if ((ln = fgetln(fp, &length)) == NULL) {
@@ -194,26 +246,25 @@ parse_bdf(const char *filename, int bold
}
ln[length - 1] = '\0';
sscanf(ln, "%x", &line);
- if (wbytes == 1) {
- bytes[i] = line;
- } else if (wbytes == 2) {
- bytes[i * 2 + 0] = line >> 8;
- bytes[i * 2 + 1] = line;
- } else {
- fprintf(stderr,
- "Unsupported wbytes!\n");
+ if (parse_bitmap_line(bytes + i * wbytes,
+ bytes_r + i * wbytes, line, dwidth) != 0)
return (1);
- }
}
/* Prevent adding two glyphs for 0xFFFD */
if (curchar == 0xFFFD) {
- if (!bold)
- gl = add_glyph(bytes, bold, 1);
+ if (map_idx < VFNT_MAP_BOLD)
+ gl = add_glyph(bytes, 0, 1);
} else if (curchar >= 0x20) {
- gl = add_glyph(bytes, bold, 0);
- if (add_mapping(gl, curchar, bold) != 0)
+ gl = add_glyph(bytes, map_idx, 0);
+ if (add_mapping(gl, curchar, map_idx) != 0)
return (1);
+ if (dwidth == width * 2) {
+ gl = add_glyph(bytes_r, map_idx + 1, 0);
+ if (add_mapping(gl, curchar,
+ map_idx + 1) != 0)
+ return (1);
+ }
}
}
}
@@ -225,32 +276,31 @@ static void
number_glyphs(void)
{
struct glyph *gl;
- unsigned int idx = 0;
+ unsigned int i, idx = 0;
- TAILQ_FOREACH(gl, &glyph_list, g_list)
- gl->g_index = idx++;
+ for (i = 0; i < VFNT_MAPS; i++)
+ TAILQ_FOREACH(gl, &glyphs[i], g_list)
+ gl->g_index = idx++;
}
static void
write_glyphs(FILE *fp)
{
struct glyph *gl;
+ unsigned int i;
- TAILQ_FOREACH(gl, &glyph_list, g_list)
- fwrite(gl->g_data, wbytes * height, 1, fp);
+ for (i = 0; i < VFNT_MAPS; i++) {
+ TAILQ_FOREACH(gl, &glyphs[i], g_list)
+ fwrite(gl->g_data, wbytes * height, 1, fp);
+ }
}
static void
-fold_mappings(int bold)
+fold_mappings(unsigned int map_idx)
{
- struct mapping_list *ml;
+ struct mapping_list *ml = &maps[map_idx];
struct mapping *mn, *mp, *mbase;
- if (bold)
- ml = &mapping_list_bold;
- else
- ml = &mapping_list_normal;
-
mp = mbase = TAILQ_FIRST(ml);
for (mp = mbase = TAILQ_FIRST(ml); mp != NULL; mp = mn) {
mn = TAILQ_NEXT(mp, m_list);
@@ -259,10 +309,7 @@ fold_mappings(int bold)
continue;
mbase->m_length = mp->m_char - mbase->m_char + 1;
mbase = mp = mn;
- if (bold)
- mapping_bold_folded++;
- else
- mapping_normal_folded++;
+ map_folded_count[map_idx]++;
}
}
@@ -273,18 +320,13 @@ struct file_mapping {
} __packed;
static void
-write_mappings(FILE *fp, int bold)
+write_mappings(FILE *fp, unsigned int map_idx)
{
- struct mapping_list *ml;
+ struct mapping_list *ml = &maps[map_idx];
struct mapping *mp;
struct file_mapping fm;
unsigned int i = 0, j = 0;
- if (bold)
- ml = &mapping_list_bold;
- else
- ml = &mapping_list_normal;
-
TAILQ_FOREACH(mp, ml, m_list) {
j++;
if (mp->m_length > 0) {
@@ -302,9 +344,9 @@ struct file_header {
uint8_t magic[8];
uint8_t width;
uint8_t height;
- uint16_t nglyphs;
- uint16_t nmappings_normal;
- uint16_t nmappings_bold;
+ uint16_t pad;
+ uint32_t glyph_count;
+ uint32_t map_count[4];
} __packed;
static int
@@ -312,7 +354,7 @@ write_fnt(const char *filename)
{
FILE *fp;
struct file_header fh = {
- .magic = "VFNT 1.0",
+ .magic = "VFNT0002",
};
fp = fopen(filename, "wb");
@@ -323,14 +365,18 @@ write_fnt(const char *filename)
fh.width = width;
fh.height = height;
- fh.nglyphs = htobe16(glyph_unique);
- fh.nmappings_normal = htobe16(mapping_normal_folded);
- fh.nmappings_bold = htobe16(mapping_bold_folded);
+ fh.glyph_count = htobe32(glyph_unique);
+ fh.map_count[0] = htobe32(map_folded_count[0]);
+ fh.map_count[1] = htobe32(map_folded_count[1]);
+ fh.map_count[2] = htobe32(map_folded_count[2]);
+ fh.map_count[3] = htobe32(map_folded_count[3]);
fwrite(&fh, sizeof fh, 1, fp);
write_glyphs(fp);
- write_mappings(fp, 0);
+ write_mappings(fp, VFNT_MAP_NORMAL);
write_mappings(fp, 1);
+ write_mappings(fp, VFNT_MAP_BOLD);
+ write_mappings(fp, 3);
return (0);
}
@@ -339,7 +385,7 @@ int
main(int argc, char *argv[])
{
- assert(sizeof(struct file_header) == 16);
+ assert(sizeof(struct file_header) == 32);
assert(sizeof(struct file_mapping) == 8);
if (argc != 6)
@@ -349,36 +395,49 @@ main(int argc, char *argv[])
wbytes = howmany(width, 8);
height = atoi(argv[2]);
- if (parse_bdf(argv[3], 0) != 0)
+ if (parse_bdf(argv[3], VFNT_MAP_NORMAL) != 0)
return (1);
- if (parse_bdf(argv[4], 1) != 0)
+ if (parse_bdf(argv[4], VFNT_MAP_BOLD) != 0)
return (1);
number_glyphs();
fold_mappings(0);
fold_mappings(1);
+ fold_mappings(2);
+ fold_mappings(3);
if (write_fnt(argv[5]) != 0)
return (1);
printf(
"Statistics:\n"
-"- glyph_total: %5u\n"
-"- glyph_normal: %5u\n"
-"- glyph_bold: %5u\n"
-"- glyph_unique: %5u\n"
-"- glyph_dupe: %5u\n"
-"- mapping_total: %5u\n"
-"- mapping_normal: %5u\n"
-"- mapping_normal_folded: %5u\n"
-"- mapping_bold: %5u\n"
-"- mapping_bold_folded: %5u\n"
-"- mapping_unique: %5u\n"
-"- mapping_dupe: %5u\n",
+"- glyph_total: %5u\n"
+"- glyph_normal: %5u\n"
+"- glyph_normal_right: %5u\n"
+"- glyph_bold: %5u\n"
+"- glyph_bold_right: %5u\n"
+"- glyph_unique: %5u\n"
+"- glyph_dupe: %5u\n"
+"- mapping_total: %5u\n"
+"- mapping_normal: %5u\n"
+"- mapping_normal_folded: %5u\n"
+"- mapping_normal_right: %5u\n"
+"- mapping_normal_right_folded: %5u\n"
+"- mapping_bold: %5u\n"
+"- mapping_bold_folded: %5u\n"
+"- mapping_bold_right: %5u\n"
+"- mapping_bold_right_folded: %5u\n"
+"- mapping_unique: %5u\n"
+"- mapping_dupe: %5u\n",
glyph_total,
- glyph_normal, glyph_bold,
+ glyph_count[0],
+ glyph_count[1],
+ glyph_count[2],
+ glyph_count[3],
glyph_unique, glyph_dupe,
mapping_total,
- mapping_normal, mapping_normal_folded,
- mapping_bold, mapping_bold_folded,
+ map_count[0], map_folded_count[0],
+ map_count[1], map_folded_count[1],
+ map_count[2], map_folded_count[2],
+ map_count[3], map_folded_count[3],
mapping_unique, mapping_dupe);
return (0);
Modified: head/tools/tools/vt/mkkfont/mkkfont.c
==============================================================================
--- head/tools/tools/vt/mkkfont/mkkfont.c Sat Dec 21 12:55:42 2013
(r259679)
+++ head/tools/tools/vt/mkkfont/mkkfont.c Sat Dec 21 13:58:55 2013
(r259680)
@@ -48,22 +48,22 @@ struct file_header {
uint8_t magic[8];
uint8_t width;
uint8_t height;
- uint16_t nglyphs;
- uint16_t nmappings_normal;
- uint16_t nmappings_bold;
+ uint16_t pad;
+ uint32_t glyph_count;
+ uint32_t map_count[4];
} __packed;
static int
print_glyphs(struct file_header *fh)
{
- unsigned int gbytes, nglyphs, j, k, total;
+ unsigned int gbytes, glyph_count, j, k, total;
uint8_t *gbuf;
gbytes = howmany(fh->width, 8) * fh->height;
- nglyphs = be16toh(fh->nglyphs);
+ glyph_count = be32toh(fh->glyph_count);
- printf("\nstatic uint8_t font_bytes[%u * %u] = {", nglyphs, gbytes);
- total = nglyphs * gbytes;
+ printf("\nstatic uint8_t font_bytes[%u * %u] = {", glyph_count, gbytes);
+ total = glyph_count * gbytes;
gbuf = malloc(total);
if (fread(gbuf, total, 1, stdin) != 1) {
@@ -84,26 +84,23 @@ print_glyphs(struct file_header *fh)
return (0);
}
+static const char *map_names[4] = {
+ "normal", "normal_right", "bold", "bold_right" };
+
static int
-print_mappings(struct file_header *fh, int bold)
+print_mappings(struct file_header *fh, int map_index)
{
struct file_mapping fm;
- const char *name;
unsigned int nmappings, i, col = 0;
- if (bold) {
- nmappings = be16toh(fh->nmappings_bold);
- name = "bold";
- } else {
- nmappings = be16toh(fh->nmappings_normal);
- name = "normal";
- }
+
+ nmappings = be32toh(fh->map_count[map_index]);
if (nmappings == 0)
return (0);
printf("\nstatic struct vt_font_map font_mapping_%s[%u] = {",
- name, nmappings);
+ map_names[map_index], nmappings);
for (i = 0; i < nmappings; i++) {
if (fread(&fm, sizeof fm, 1, stdin) != 1) {
@@ -126,7 +123,7 @@ print_mappings(struct file_header *fh, i
static int
print_info(struct file_header *fh)
{
- unsigned int nnormal, nbold;
+ unsigned int i;
printf(
"\nstruct vt_font vt_font_default = {\n"
@@ -135,17 +132,19 @@ print_info(struct file_header *fh)
"\t.vf_bytes\t\t= font_bytes,\n",
fh->width, fh->height);
- nnormal = be16toh(fh->nmappings_normal);
- nbold = be16toh(fh->nmappings_bold);
-
- if (nnormal != 0)
- printf(
- "\t.vf_normal\t\t= font_mapping_normal,\n"
- "\t.vf_normal_length\t= %u,\n", nnormal);
- if (nbold != 0)
- printf(
- "\t.vf_bold\t\t= font_mapping_bold,\n"
- "\t.vf_bold_length\t\t= %u,\n", nbold);
+ printf("\t.vf_map\t\t\t= {\n");
+ for (i = 0; i < 4; i++) {
+ if (fh->map_count[i] > 0)
+ printf("\t\t\t\t font_mapping_%s,\n", map_names[i]);
+ else
+ printf("\t\t\t\t NULL,\n");
+ }
+ printf("\t\t\t\t }\n");
+ printf("\t.vf_map_count\t\t= { %u, %u, %u, %u },\n",
+ be32toh(fh->map_count[0]),
+ be32toh(fh->map_count[1]),
+ be32toh(fh->map_count[2]),
+ be32toh(fh->map_count[3]));
printf("\t.vf_refcount\t\t= 1,\n};\n");
return (0);
@@ -161,7 +160,7 @@ main(int argc __unused, char *argv[] __u
return (1);
}
- if (memcmp(fh.magic, "VFNT 1.0", 8) != 0) {
+ if (memcmp(fh.magic, "VFNT0002", 8) != 0) {
fprintf(stderr, "Bad magic\n");
return (1);
}
Modified: head/tools/tools/vt/setfont/setfont.c
==============================================================================
--- head/tools/tools/vt/setfont/setfont.c Sat Dec 21 12:55:42 2013
(r259679)
+++ head/tools/tools/vt/setfont/setfont.c Sat Dec 21 13:58:55 2013
(r259680)
@@ -1,3 +1,6 @@
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
#include <sys/consio.h>
#include <sys/endian.h>
#include <sys/ioctl.h>
@@ -12,9 +15,9 @@ struct file_header {
uint8_t magic[8];
uint8_t width;
uint8_t height;
- uint16_t nglyphs;
- uint16_t nmappings_normal;
- uint16_t nmappings_bold;
+ uint16_t pad;
+ uint32_t glyph_count;
+ uint32_t map_count[4];
} __packed;
static vfnt_map_t *
@@ -48,24 +51,25 @@ main(int argc __unused, char *argv[] __u
struct file_header fh;
static vfnt_t vfnt;
size_t glyphsize;
+ unsigned int i;
if (fread(&fh, sizeof fh, 1, stdin) != 1) {
perror("file_header");
return (1);
}
- if (memcmp(fh.magic, "VFNT 1.0", 8) != 0) {
+ if (memcmp(fh.magic, "VFNT0002", 8) != 0) {
fprintf(stderr, "Bad magic\n");
return (1);
}
- vfnt.nnormal = be16toh(fh.nmappings_normal);
- vfnt.nbold = be16toh(fh.nmappings_bold);
- vfnt.nglyphs = be16toh(fh.nglyphs);
+ for (i = 0; i < VFNT_MAPS; i++)
+ vfnt.map_count[i] = be32toh(fh.map_count[i]);
+ vfnt.glyph_count = be32toh(fh.glyph_count);
vfnt.width = fh.width;
vfnt.height = fh.height;
- glyphsize = howmany(vfnt.width, 8) * vfnt.height * vfnt.nglyphs;
+ glyphsize = howmany(vfnt.width, 8) * vfnt.height * vfnt.glyph_count;
vfnt.glyphs = malloc(glyphsize);
if (fread(vfnt.glyphs, glyphsize, 1, stdin) != 1) {
@@ -73,8 +77,8 @@ main(int argc __unused, char *argv[] __u
return (1);
}
- vfnt.normal = load_mappingtable(vfnt.nnormal);
- vfnt.bold = load_mappingtable(vfnt.nbold);
+ for (i = 0; i < VFNT_MAPS; i++)
+ vfnt.map[i] = load_mappingtable(vfnt.map_count[i]);
if (ioctl(STDOUT_FILENO, PIO_VFONT, &vfnt) == -1) {
perror("PIO_VFONT");
_______________________________________________
svn-src-head@freebsd.org mailing list
http://lists.freebsd.org/mailman/listinfo/svn-src-head
To unsubscribe, send any mail to "svn-src-head-unsubscr...@freebsd.org"
