src/libkeymap/dump.c - pub/scm/linux/kernel/git/legion/kbd - Git at Google

 /* dump.c
  *
  * This file is part of kbd project.
  * Copyright (C) 1993  Risto Kankkunen.
  * Copyright (C) 1993  Eugene G. Crosser.
  * Copyright (C) 1994-2007  Andries E. Brouwer.
  * Copyright (C) 2007-2013  Alexey Gladkov <gladkov.alexey@gmail.com>
  *
  * This file is covered by the GNU General Public License,
  * which should be included with kbd as the file COPYING.
  */
 #include "config.h"

 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 #include <unistd.h>

 #include "keymap.h"

 #include "contextP.h"
 #include "ksyms.h"
 #include "modifiers.h"
 #include "nls.h"

 #define U(x) ((x) ^ 0xf000)

 static void
 outchar(FILE *fd, unsigned char c, int comma)
 {
 	fprintf(fd, "'");
 	fprintf(fd, (c == '\'' || c == '\\') ? "\\%c"
 	                                     : isgraph(c) ? "%c"
 	                                                  : "\\%03o",
 	        c);
 	fprintf(fd, comma ? "', " : "'");
 }

 // FIXME: Merge outchar ?
 static void
 dumpchar(FILE *fd, unsigned char c, int comma)
 {
 	fprintf(fd, "'");
 	fprintf(fd, (c == '\'' || c == '\\') ? "\\%c"
 	                                     : (isgraph(c) || c == ' ' || c >= 0200) ? "%c"
 	                                                                             : "\\%03o",
 	        c);
 	fprintf(fd, comma ? "', " : "'");
 }

 int lk_dump_bkeymap(struct lk_ctx *ctx, FILE *fd)
 {
 	unsigned int i, j;
 	char magic[] = "bkeymap";

 	if (lk_add_constants(ctx) < 0)
 		return -1;

 	if (fwrite(magic, 7, 1, fd) != 1)
 		goto fail;

 	for (i = 0; i < MAX_NR_KEYMAPS; i++) {
 		char flag;
 		flag = lk_map_exists(ctx, i);

 		if (fwrite(&flag, sizeof(flag), 1, fd) != 1)
 			goto fail;
 	}

 	for (i = 0; i < MAX_NR_KEYMAPS; i++) {
 		if (!lk_map_exists(ctx, i))
 			continue;

 		for (j = 0; j < NR_KEYS / 2; j++) {
 			unsigned short v;
 			v = lk_get_key(ctx, i, j);

 			if (fwrite(&v, sizeof(v), 1, fd) != 1)
 				goto fail;
 		}
 	}

 	return 0;

 fail:
 	ERR(ctx, _("Error writing map to file"));
 	return -1;
 }

 static char *
 mk_mapname(char modifier)
 {
 	static char *mods[8] = {
 		"shift", "altgr", "ctrl", "alt", "shl", "shr", "ctl", "ctr"
 	};
 	static char buf[60];
 	int i;

 	if (!modifier)
 		return "plain";
 	buf[0] = 0;
 	for (i = 0; i < 8; i++)
 		if (modifier & (1 << i)) {
 			if (buf[0])
 				strcat(buf, "_");
 			strcat(buf, mods[i]);
 		}
 	return buf;
 }

 int lk_dump_ctable(struct lk_ctx *ctx, FILE *fd)
 {
 	int j;
 	unsigned int i, imax;

 	unsigned int maxfunc;
 	unsigned int func_table_offs[MAX_NR_FUNC];
 	unsigned int func_buf_offset = 0;
 	struct lk_kbdiacr *kddiac;

 	if (lk_add_constants(ctx) < 0)
 		return -1;

 	fprintf(fd,
 	        /* not to be translated... */
 	        "/* Do not edit this file! It was automatically generated by   */\n");
 	fprintf(fd, "/*    loadkeys --mktable defkeymap.map > defkeymap.c          */\n\n");
 	fprintf(fd, "#include <linux/keyboard.h>\n");
 	fprintf(fd, "#include <linux/kd.h>\n\n");

 	for (i = 0; i < MAX_NR_KEYMAPS; i++)
 		if (lk_map_exists(ctx, i)) {
 			if (i)
 				fprintf(fd, "static ");
 			fprintf(fd, "unsigned short %s_map[NR_KEYS] = {", mk_mapname(i));
 			for (j = 0; j < NR_KEYS; j++) {
 				if (!(j % 8))
 					fprintf(fd, "\n");
 				fprintf(fd, "\t0x%04x,", U(lk_get_key(ctx, i, j)));
 			}
 			fprintf(fd, "\n};\n\n");
 		}

 	for (imax = MAX_NR_KEYMAPS - 1; imax > 0; imax--)
 		if (lk_map_exists(ctx, imax))
 			break;
 	fprintf(fd, "ushort *key_maps[MAX_NR_KEYMAPS] = {");
 	for (i = 0; i <= imax; i++) {
 		fprintf(fd, (i % 4) ? " " : "\n\t");
 		if (lk_map_exists(ctx, i))
 			fprintf(fd, "%s_map,", mk_mapname(i));
 		else
 			fprintf(fd, "0,");
 	}
 	if (imax < MAX_NR_KEYMAPS - 1)
 		fprintf(fd, "\t0");
 	fprintf(fd, "\n};\n\nunsigned int keymap_count = %u;\n\n", (unsigned int)ctx->keymap->count);

 	/* uglified just for xgettext - it complains about nonterminated strings */
 	fprintf(fd,
 	        "/*\n"
 	        " * Philosophy: most people do not define more strings, but they who do\n"
 	        " * often want quite a lot of string space. So, we statically allocate\n"
 	        " * the default and allocate dynamically in chunks of 512 bytes.\n"
 	        " */\n"
 	        "\n");
 	for (maxfunc = MAX_NR_FUNC; maxfunc; maxfunc--)
 		if (lk_array_get_ptr(ctx->func_table, maxfunc - 1))
 			break;

 	fprintf(fd, "char func_buf[] = {\n");
 	for (i = 0; i < maxfunc; i++) {
 		char *ptr, *func;

 		func = ptr = lk_array_get_ptr(ctx->func_table, i);
 		if (!ptr)
 			continue;

 		func_table_offs[i] = func_buf_offset;
 		fprintf(fd, "\t");
 		for (; *ptr; ptr++)
 			outchar(fd, *ptr, 1);
 		fprintf(fd, "0, \n");
 		func_buf_offset += (ptr - func + 1);
 	}
 	if (!maxfunc)
 		fprintf(fd, "\t0\n");
 	fprintf(fd, "};\n\n");

 	fprintf(fd,
 	        "char *funcbufptr = func_buf;\n"
 	        "int funcbufsize = sizeof(func_buf);\n"
 	        "int funcbufleft = 0;          /* space left */\n"
 	        "\n");

 	fprintf(fd, "char *func_table[MAX_NR_FUNC] = {\n");
 	for (i = 0; i < maxfunc; i++) {
 		if (lk_array_get_ptr(ctx->func_table, i))
 			fprintf(fd, "\tfunc_buf + %u,\n", func_table_offs[i]);
 		else
 			fprintf(fd, "\t0,\n");
 	}
 	if (maxfunc < MAX_NR_FUNC)
 		fprintf(fd, "\t0,\n");
 	fprintf(fd, "};\n");

 	if (ctx->flags & LK_FLAG_PREFER_UNICODE) {
 		fprintf(fd, "\nstruct kbdiacruc accent_table[MAX_DIACR] = {\n");
 		for (i = 0; i < ctx->accent_table->count; i++) {
 			kddiac = lk_array_get_ptr(ctx->accent_table, i);

 			fprintf(fd, "\t{");
 			outchar(fd, kddiac->diacr, 1);
 			outchar(fd, kddiac->base, 1);
 			fprintf(fd, "0x%04x},", kddiac->result);
 			if (i % 2)
 				fprintf(fd, "\n");
 		}
 		if (i % 2)
 			fprintf(fd, "\n");
 		fprintf(fd, "};\n\n");
 	} else {
 		fprintf(fd, "\nstruct kbdiacr accent_table[MAX_DIACR] = {\n");
 		for (i = 0; i < ctx->accent_table->count; i++) {
 			kddiac = lk_array_get_ptr(ctx->accent_table, i);

 			fprintf(fd, "\t{");
 			outchar(fd, kddiac->diacr, 1);
 			outchar(fd, kddiac->base, 1);
 			outchar(fd, kddiac->result, 0);
 			fprintf(fd, "},");
 			if (i % 2)
 				fprintf(fd, "\n");
 		}
 		if (i % 2)
 			fprintf(fd, "\n");
 		fprintf(fd, "};\n\n");
 	}
 	fprintf(fd, "unsigned int accent_table_size = %u;\n",
 	        (unsigned int)ctx->accent_table->count);
 	return 0;
 }

 /* void dump_funcs(void) */
 void lk_dump_funcs(struct lk_ctx *ctx, FILE *fd)
 {
 	unsigned int i;

 	for (i = 0; i < ctx->func_table->total; i++) {
 		char *ptr = lk_array_get_ptr(ctx->func_table, i);
 		if (!ptr)
 			continue;

 		fprintf(fd, "string %s = \"", get_sym(ctx, KT_FN, i));

 		for (; *ptr; ptr++) {
 			if (*ptr == '"' || *ptr == '\\') {
 				fputc('\\', fd);
 				fputc(*ptr, fd);
 			} else if (isgraph(*ptr) || *ptr == ' ') {
 				fputc(*ptr, fd);
 			} else {
 				fprintf(fd, "\\%03hho", *ptr);
 			}
 		}
 		fputc('"', fd);
 		fputc('\n', fd);
 	}
 }

 /* void dump_diacs(void) */
 void lk_dump_diacs(struct lk_ctx *ctx, FILE *fd)
 {
 	unsigned int i;
 	struct lk_kbdiacr *ptr;
 	const char *ksym;

 	for (i = 0; i < ctx->accent_table->count; i++) {
 		ptr = lk_array_get_ptr(ctx->accent_table, i);
 		if (!ptr)
 			continue;

 		fprintf(fd, "compose ");
 		dumpchar(fd, ptr->diacr, 0);
 		fprintf(fd, " ");
 		dumpchar(fd, ptr->base, 0);
 #ifdef KDGKBDIACRUC
 		if (ctx->flags & LK_FLAG_PREFER_UNICODE) {
 			ksym = codetoksym(ctx, ptr->result ^ 0xf000);
 			if (ksym) {
 				fprintf(fd, " to %s\n", ksym);
 			} else {
 				fprintf(fd, " to U+%04x\n", ptr->result);
 			}
 		} else
 #endif
 		    if (ptr->result > 0xff) {
 			// impossible case?
 			fprintf(fd, " to 0x%x\n", ptr->result);
 		} else {
 			ksym = codetoksym(ctx, ptr->result);
 			if (ksym) {
 				fprintf(fd, " to %s\n", ksym);
 			} else {
 				fprintf(fd, " to ");
 				dumpchar(fd, ptr->result, 0);
 				fprintf(fd, "\n");
 			}
 		}
 	}
 }

 void lk_dump_keymaps(struct lk_ctx *ctx, FILE *fd)
 {
 	unsigned int i;
 	int n, m, s;
 	i = n = m = s = 0;

 	fprintf(fd, "keymaps");

 	for (i = 0; i < ctx->keymap->total; i++) {
 		if (ctx->keywords & LK_KEYWORD_ALTISMETA && i == (i | M_ALT))
 			continue;

 		if (!lk_map_exists(ctx, i)) {
 			if (!m)
 				continue;
 			n--, m--;
 			(n == m)
 			    ? fprintf(fd, "%c%d", (s ? ',' : ' '), n)
 			    : fprintf(fd, "%c%d-%d", (s ? ',' : ' '), n, m);
 			n = m = 0;
 			s     = 1;
 		} else {
 			if (!n)
 				n = i + 1;
 			m         = i + 1;
 		}
 	}

 	if (m) {
 		n--, m--;
 		(n == m)
 		    ? fprintf(fd, "%c%d", (s ? ',' : ' '), n)
 		    : fprintf(fd, "%c%d-%d", (s ? ',' : ' '), n, m);
 	}

 	fprintf(fd, "\n");
 }

 static void
 print_mod(FILE *fd, int x)
 {
 	if (x) {
 		modifier_t *mod = (modifier_t *)modifiers;
 		while (mod->name) {
 			if (x & (1 << mod->bit))
 				fprintf(fd, "%s\t", mod->name);
 			mod++;
 		}
 	} else {
 		fprintf(fd, "plain\t");
 	}
 }

 static void
 print_keysym(struct lk_ctx *ctx, FILE *fd, int code, char numeric)
 {
 	unsigned int t, v;
 	const char *p;
 	int plus;

 	fprintf(fd, " ");
 	t = KTYP(code);
 	v = KVAL(code);
 	if (t >= syms_size) {
 		if (!numeric && (p = codetoksym(ctx, code)) != NULL)
 			fprintf(fd, "%-16s", p);
 		else
 			fprintf(fd, "U+%04x          ", code ^ 0xf000);
 		return;
 	}
 	plus = 0;
 	if (t == KT_LETTER) {
 		t = KT_LATIN;
 		fprintf(fd, "+");
 		plus++;
 	}
 	if (!numeric && t == KT_LATIN &&
 	    (p = codetoksym(ctx, code)))
 		fprintf(fd, "%-*s", 16 - plus, p);
 	else if (!numeric && t < syms_size && v < get_sym_size(ctx, t) &&
 	         (p = get_sym(ctx, t, v))[0])
 		fprintf(fd, "%-*s", 16 - plus, p);
 	else if (!numeric && t == KT_META && v < 128 && v < get_sym_size(ctx, KT_LATIN) &&
 	         (p = get_sym(ctx, KT_LATIN, v))[0])
 		fprintf(fd, "Meta_%-11s", p);
 	else
 		fprintf(fd, "0x%04x         %s", code, plus ? "" : " ");
 }

 static void
 print_bind(struct lk_ctx *ctx, FILE *fd, int bufj, int i, int j, char numeric)
 {
 	if (j)
 		fprintf(fd, "\t");
 	print_mod(fd, j);
 	fprintf(fd, "keycode %3d =", i);
 	print_keysym(ctx, fd, bufj, numeric);
 	fprintf(fd, "\n");
 }

 void lk_dump_keys(struct lk_ctx *ctx, FILE *fd, lk_table_shape table, char numeric)
 {
 	unsigned int i, j;
 	int buf[MAX_NR_KEYMAPS];
 	int isletter, islatin, isasexpected;
 	int typ, val;
 	int alt_is_meta = 0;
 	int all_holes;
 	int zapped[MAX_NR_KEYMAPS];
 	unsigned int keymapnr = ctx->keymap->total;

 	if (!keymapnr)
 		return;

 	if (table == LK_SHAPE_FULL_TABLE || table == LK_SHAPE_SEPARATE_LINES)
 		goto no_shorthands;

 	/* first pass: determine whether to set alt_is_meta */
 	for (j = 0; j < ctx->keymap->total; j++) {
 		unsigned int ja = (j | M_ALT);

 		if (!(j != ja && lk_map_exists(ctx, j) && lk_map_exists(ctx, ja)))
 			continue;

 		for (i = 1; i < NR_KEYS; i++) {
 			int buf0, buf1, type;

 			buf0 = lk_get_key(ctx, j, i);

 			if (buf0 == -1)
 				break;

 			type = KTYP(buf0);

 			if ((type == KT_LATIN || type == KT_LETTER) && KVAL(buf0) < 128) {
 				buf1 = lk_map_exists(ctx, ja)
 				           ? lk_get_key(ctx, ja, i)
 				           : -1;

 				if (buf1 != K(KT_META, KVAL(buf0)))
 					goto not_alt_is_meta;
 			}
 		}
 	}
 	alt_is_meta = 1;
 	fprintf(fd, "alt_is_meta\n");

 not_alt_is_meta:
 no_shorthands:

 	for (i = 1; i < NR_KEYS; i++) {
 		all_holes = 1;

 		for (j = 0; j < keymapnr; j++) {
 			buf[j] = K_HOLE;

 			if (lk_map_exists(ctx, j))
 				buf[j] = lk_get_key(ctx, j, i);

 			if (buf[j] != K_HOLE)
 				all_holes = 0;
 		}

 		if (all_holes && table != LK_SHAPE_FULL_TABLE)
 			continue;

 		if (table == LK_SHAPE_FULL_TABLE) {
 			fprintf(fd, "keycode %3d =", i);

 			for (j = 0; j < keymapnr; j++) {
 				if (lk_map_exists(ctx, j))
 					print_keysym(ctx, fd, buf[j], numeric);
 			}

 			fprintf(fd, "\n");
 			continue;
 		}

 		if (table == LK_SHAPE_SEPARATE_LINES) {
 			for (j = 0; j < keymapnr; j++) {
 				//if (buf[j] != K_HOLE)
 				print_bind(ctx, fd, buf[j], i, j, numeric);
 			}

 			fprintf(fd, "\n");
 			continue;
 		}

 		typ      = KTYP(buf[0]);
 		val      = KVAL(buf[0]);
 		islatin  = (typ == KT_LATIN || typ == KT_LETTER);
 		isletter = (islatin &&
 		            ((val >= 'A' && val <= 'Z') ||
 		             (val >= 'a' && val <= 'z')));

 		isasexpected = 0;
 		if (isletter) {
 			unsigned short defs[16];
 			defs[0] = K(KT_LETTER, val);
 			defs[1] = K(KT_LETTER, val ^ 32);
 			defs[2] = defs[0];
 			defs[3] = defs[1];

 			for (j          = 4; j < 8; j++)
 				defs[j] = K(KT_LATIN, val & ~96);

 			for (j          = 8; j < 16; j++)
 				defs[j] = K(KT_META, KVAL(defs[j - 8]));

 			for (j = 0; j < keymapnr; j++) {
 				if ((j >= 16 && buf[j] != K_HOLE) || (j < 16 && buf[j] != defs[j]))
 					goto unexpected;
 			}

 			isasexpected = 1;
 		}
 	unexpected:

 		/* wipe out predictable meta bindings */
 		for (j            = 0; j < keymapnr; j++)
 			zapped[j] = 0;

 		if (alt_is_meta) {
 			for (j = 0; j < keymapnr; j++) {
 				unsigned int ja, ktyp;
 				ja = (j | M_ALT);

 				if (j != ja && lk_map_exists(ctx, ja) && ((ktyp = KTYP(buf[j])) == KT_LATIN || ktyp == KT_LETTER) && KVAL(buf[j]) < 128) {
 					if (buf[ja] != K(KT_META, KVAL(buf[j])))
 						fprintf(stderr, _("impossible: not meta?\n"));
 					buf[ja]    = K_HOLE;
 					zapped[ja] = 1;
 				}
 			}
 		}

 		fprintf(fd, "keycode %3d =", i);

 		if (isasexpected) {
 			/* print only a single entry */
 			/* suppress the + for ordinary a-zA-Z */
 			print_keysym(ctx, fd, K(KT_LATIN, val), numeric);
 			fprintf(fd, "\n");
 		} else {
 			/* choose between single entry line followed by exceptions,
 			   and long line followed by exceptions; avoid VoidSymbol */
 			unsigned int bad, count;
 			bad = count = 0;

 			for (j = 1; j < keymapnr; j++) {
 				if (zapped[j])
 					continue;

 				if (buf[j] != buf[0])
 					bad++;

 				if (buf[j] != K_HOLE)
 					count++;
 			}

 			if (bad <= count && bad < keymapnr - 1) {
 				if (buf[0] != K_HOLE) {
 					print_keysym(ctx, fd, buf[0], numeric);
 				}
 				fprintf(fd, "\n");

 				for (j = 1; j < keymapnr; j++) {
 					if (buf[j] != buf[0] && !zapped[j]) {
 						print_bind(ctx, fd, buf[j], i, j, numeric);
 					}
 				}
 			} else {
 				for (j = 0;
 				     j < keymapnr && buf[j] != K_HOLE &&
 				     (table != LK_SHAPE_UNTIL_HOLE || lk_map_exists(ctx, j));
 				     j++) {
 					//print_bind(ctx, fd, buf[j], i, j, numeric);
 					print_keysym(ctx, fd, buf[j], numeric);
 				}
 				fprintf(fd, "\n");

 				for (; j < keymapnr; j++) {
 					if (buf[j] != K_HOLE) {
 						print_bind(ctx, fd, buf[j], i, j, numeric);
 					}
 				}
 			}
 		}
 	}
 }

 void lk_dump_keymap(struct lk_ctx *ctx, FILE *fd, lk_table_shape table, char numeric)
 {
 	lk_dump_keymaps(ctx, fd);
 	lk_dump_keys(ctx, fd, table, numeric);
 	lk_dump_funcs(ctx, fd);
 }
	/* dump.c
	*
	* This file is part of kbd project.
	* Copyright (C) 1993 Risto Kankkunen.
	* Copyright (C) 1993 Eugene G. Crosser.
	* Copyright (C) 1994-2007 Andries E. Brouwer.
	* Copyright (C) 2007-2013 Alexey Gladkov <gladkov.alexey@gmail.com>
	*
	* This file is covered by the GNU General Public License,
	* which should be included with kbd as the file COPYING.
	*/
	#include "config.h"

	#include <stdio.h>
	#include <string.h>
	#include <ctype.h>
	#include <unistd.h>

	#include "keymap.h"

	#include "contextP.h"
	#include "ksyms.h"
	#include "modifiers.h"
	#include "nls.h"

	#define U(x) ((x) ^ 0xf000)

	static void
	outchar(FILE *fd, unsigned char c, int comma)
	{
	fprintf(fd, "'");
	fprintf(fd, (c == '\'' \|\| c == '\\') ? "\\%c"
	: isgraph(c) ? "%c"
	: "\\%03o",
	c);
	fprintf(fd, comma ? "', " : "'");
	}

	// FIXME: Merge outchar ?
	static void
	dumpchar(FILE *fd, unsigned char c, int comma)
	{
	fprintf(fd, "'");
	fprintf(fd, (c == '\'' \|\| c == '\\') ? "\\%c"
	: (isgraph(c) \|\| c == ' ' \|\| c >= 0200) ? "%c"
	: "\\%03o",
	c);
	fprintf(fd, comma ? "', " : "'");
	}

	int lk_dump_bkeymap(struct lk_ctx ctx, FILE fd)
	{
	unsigned int i, j;
	char magic[] = "bkeymap";

	if (lk_add_constants(ctx) < 0)
	return -1;

	if (fwrite(magic, 7, 1, fd) != 1)
	goto fail;

	for (i = 0; i < MAX_NR_KEYMAPS; i++) {
	char flag;
	flag = lk_map_exists(ctx, i);

	if (fwrite(&flag, sizeof(flag), 1, fd) != 1)
	goto fail;
	}

	for (i = 0; i < MAX_NR_KEYMAPS; i++) {
	if (!lk_map_exists(ctx, i))
	continue;

	for (j = 0; j < NR_KEYS / 2; j++) {
	unsigned short v;
	v = lk_get_key(ctx, i, j);

	if (fwrite(&v, sizeof(v), 1, fd) != 1)
	goto fail;
	}
	}

	return 0;

	fail:
	ERR(ctx, _("Error writing map to file"));
	return -1;
	}

	static char *
	mk_mapname(char modifier)
	{
	static char *mods[8] = {
	"shift", "altgr", "ctrl", "alt", "shl", "shr", "ctl", "ctr"
	};
	static char buf[60];
	int i;

	if (!modifier)
	return "plain";
	buf[0] = 0;
	for (i = 0; i < 8; i++)
	if (modifier & (1 << i)) {
	if (buf[0])
	strcat(buf, "_");
	strcat(buf, mods[i]);
	}
	return buf;
	}

	int lk_dump_ctable(struct lk_ctx ctx, FILE fd)
	{
	int j;
	unsigned int i, imax;

	unsigned int maxfunc;
	unsigned int func_table_offs[MAX_NR_FUNC];
	unsigned int func_buf_offset = 0;
	struct lk_kbdiacr *kddiac;

	if (lk_add_constants(ctx) < 0)
	return -1;

	fprintf(fd,
	/* not to be translated... */
	"/* Do not edit this file! It was automatically generated by */\n");
	fprintf(fd, "/* loadkeys --mktable defkeymap.map > defkeymap.c */\n\n");
	fprintf(fd, "#include <linux/keyboard.h>\n");
	fprintf(fd, "#include <linux/kd.h>\n\n");

	for (i = 0; i < MAX_NR_KEYMAPS; i++)
	if (lk_map_exists(ctx, i)) {
	if (i)
	fprintf(fd, "static ");
	fprintf(fd, "unsigned short %s_map[NR_KEYS] = {", mk_mapname(i));
	for (j = 0; j < NR_KEYS; j++) {
	if (!(j % 8))
	fprintf(fd, "\n");
	fprintf(fd, "\t0x%04x,", U(lk_get_key(ctx, i, j)));
	}
	fprintf(fd, "\n};\n\n");
	}

	for (imax = MAX_NR_KEYMAPS - 1; imax > 0; imax--)
	if (lk_map_exists(ctx, imax))
	break;
	fprintf(fd, "ushort *key_maps[MAX_NR_KEYMAPS] = {");
	for (i = 0; i <= imax; i++) {
	fprintf(fd, (i % 4) ? " " : "\n\t");
	if (lk_map_exists(ctx, i))
	fprintf(fd, "%s_map,", mk_mapname(i));
	else
	fprintf(fd, "0,");
	}
	if (imax < MAX_NR_KEYMAPS - 1)
	fprintf(fd, "\t0");
	fprintf(fd, "\n};\n\nunsigned int keymap_count = %u;\n\n", (unsigned int)ctx->keymap->count);

	/* uglified just for xgettext - it complains about nonterminated strings */
	fprintf(fd,
	"/*\n"
	" * Philosophy: most people do not define more strings, but they who do\n"
	" * often want quite a lot of string space. So, we statically allocate\n"
	" * the default and allocate dynamically in chunks of 512 bytes.\n"
	" */\n"
	"\n");
	for (maxfunc = MAX_NR_FUNC; maxfunc; maxfunc--)
	if (lk_array_get_ptr(ctx->func_table, maxfunc - 1))
	break;

	fprintf(fd, "char func_buf[] = {\n");
	for (i = 0; i < maxfunc; i++) {
	char ptr, func;

	func = ptr = lk_array_get_ptr(ctx->func_table, i);
	if (!ptr)
	continue;

	func_table_offs[i] = func_buf_offset;
	fprintf(fd, "\t");
	for (; *ptr; ptr++)
	outchar(fd, *ptr, 1);
	fprintf(fd, "0, \n");
	func_buf_offset += (ptr - func + 1);
	}
	if (!maxfunc)
	fprintf(fd, "\t0\n");
	fprintf(fd, "};\n\n");

	fprintf(fd,
	"char *funcbufptr = func_buf;\n"
	"int funcbufsize = sizeof(func_buf);\n"
	"int funcbufleft = 0; /* space left */\n"
	"\n");

	fprintf(fd, "char *func_table[MAX_NR_FUNC] = {\n");
	for (i = 0; i < maxfunc; i++) {
	if (lk_array_get_ptr(ctx->func_table, i))
	fprintf(fd, "\tfunc_buf + %u,\n", func_table_offs[i]);
	else
	fprintf(fd, "\t0,\n");
	}
	if (maxfunc < MAX_NR_FUNC)
	fprintf(fd, "\t0,\n");
	fprintf(fd, "};\n");

	if (ctx->flags & LK_FLAG_PREFER_UNICODE) {
	fprintf(fd, "\nstruct kbdiacruc accent_table[MAX_DIACR] = {\n");
	for (i = 0; i < ctx->accent_table->count; i++) {
	kddiac = lk_array_get_ptr(ctx->accent_table, i);

	fprintf(fd, "\t{");
	outchar(fd, kddiac->diacr, 1);
	outchar(fd, kddiac->base, 1);
	fprintf(fd, "0x%04x},", kddiac->result);
	if (i % 2)
	fprintf(fd, "\n");
	}
	if (i % 2)
	fprintf(fd, "\n");
	fprintf(fd, "};\n\n");
	} else {
	fprintf(fd, "\nstruct kbdiacr accent_table[MAX_DIACR] = {\n");
	for (i = 0; i < ctx->accent_table->count; i++) {
	kddiac = lk_array_get_ptr(ctx->accent_table, i);

	fprintf(fd, "\t{");
	outchar(fd, kddiac->diacr, 1);
	outchar(fd, kddiac->base, 1);
	outchar(fd, kddiac->result, 0);
	fprintf(fd, "},");
	if (i % 2)
	fprintf(fd, "\n");
	}
	if (i % 2)
	fprintf(fd, "\n");
	fprintf(fd, "};\n\n");
	}
	fprintf(fd, "unsigned int accent_table_size = %u;\n",
	(unsigned int)ctx->accent_table->count);
	return 0;
	}

	/* void dump_funcs(void) */
	void lk_dump_funcs(struct lk_ctx ctx, FILE fd)
	{
	unsigned int i;

	for (i = 0; i < ctx->func_table->total; i++) {
	char *ptr = lk_array_get_ptr(ctx->func_table, i);
	if (!ptr)
	continue;

	fprintf(fd, "string %s = \"", get_sym(ctx, KT_FN, i));

	for (; *ptr; ptr++) {
	if (ptr == '"' \|\| ptr == '\\') {
	fputc('\\', fd);
	fputc(*ptr, fd);
	} else if (isgraph(ptr) \|\| ptr == ' ') {
	fputc(*ptr, fd);
	} else {
	fprintf(fd, "\\%03hho", *ptr);
	}
	}
	fputc('"', fd);
	fputc('\n', fd);
	}
	}

	/* void dump_diacs(void) */
	void lk_dump_diacs(struct lk_ctx ctx, FILE fd)
	{
	unsigned int i;
	struct lk_kbdiacr *ptr;
	const char *ksym;

	for (i = 0; i < ctx->accent_table->count; i++) {
	ptr = lk_array_get_ptr(ctx->accent_table, i);
	if (!ptr)
	continue;

	fprintf(fd, "compose ");
	dumpchar(fd, ptr->diacr, 0);
	fprintf(fd, " ");
	dumpchar(fd, ptr->base, 0);
	#ifdef KDGKBDIACRUC
	if (ctx->flags & LK_FLAG_PREFER_UNICODE) {
	ksym = codetoksym(ctx, ptr->result ^ 0xf000);
	if (ksym) {
	fprintf(fd, " to %s\n", ksym);
	} else {
	fprintf(fd, " to U+%04x\n", ptr->result);
	}
	} else
	#endif
	if (ptr->result > 0xff) {
	// impossible case?
	fprintf(fd, " to 0x%x\n", ptr->result);
	} else {
	ksym = codetoksym(ctx, ptr->result);
	if (ksym) {
	fprintf(fd, " to %s\n", ksym);
	} else {
	fprintf(fd, " to ");
	dumpchar(fd, ptr->result, 0);
	fprintf(fd, "\n");
	}
	}
	}
	}

	void lk_dump_keymaps(struct lk_ctx ctx, FILE fd)
	{
	unsigned int i;
	int n, m, s;
	i = n = m = s = 0;

	fprintf(fd, "keymaps");

	for (i = 0; i < ctx->keymap->total; i++) {
	if (ctx->keywords & LK_KEYWORD_ALTISMETA && i == (i \| M_ALT))
	continue;

	if (!lk_map_exists(ctx, i)) {
	if (!m)
	continue;
	n--, m--;
	(n == m)
	? fprintf(fd, "%c%d", (s ? ',' : ' '), n)
	: fprintf(fd, "%c%d-%d", (s ? ',' : ' '), n, m);
	n = m = 0;
	s = 1;
	} else {
	if (!n)
	n = i + 1;
	m = i + 1;
	}
	}

	if (m) {
	n--, m--;
	(n == m)
	? fprintf(fd, "%c%d", (s ? ',' : ' '), n)
	: fprintf(fd, "%c%d-%d", (s ? ',' : ' '), n, m);
	}

	fprintf(fd, "\n");
	}

	static void
	print_mod(FILE *fd, int x)
	{
	if (x) {
	modifier_t mod = (modifier_t )modifiers;
	while (mod->name) {
	if (x & (1 << mod->bit))
	fprintf(fd, "%s\t", mod->name);
	mod++;
	}
	} else {
	fprintf(fd, "plain\t");
	}
	}

	static void
	print_keysym(struct lk_ctx ctx, FILE fd, int code, char numeric)
	{
	unsigned int t, v;
	const char *p;
	int plus;

	fprintf(fd, " ");
	t = KTYP(code);
	v = KVAL(code);
	if (t >= syms_size) {
	if (!numeric && (p = codetoksym(ctx, code)) != NULL)
	fprintf(fd, "%-16s", p);
	else
	fprintf(fd, "U+%04x ", code ^ 0xf000);
	return;
	}
	plus = 0;
	if (t == KT_LETTER) {
	t = KT_LATIN;
	fprintf(fd, "+");
	plus++;
	}
	if (!numeric && t == KT_LATIN &&
	(p = codetoksym(ctx, code)))
	fprintf(fd, "%-*s", 16 - plus, p);
	else if (!numeric && t < syms_size && v < get_sym_size(ctx, t) &&
	(p = get_sym(ctx, t, v))[0])
	fprintf(fd, "%-*s", 16 - plus, p);
	else if (!numeric && t == KT_META && v < 128 && v < get_sym_size(ctx, KT_LATIN) &&
	(p = get_sym(ctx, KT_LATIN, v))[0])
	fprintf(fd, "Meta_%-11s", p);
	else
	fprintf(fd, "0x%04x %s", code, plus ? "" : " ");
	}

	static void
	print_bind(struct lk_ctx ctx, FILE fd, int bufj, int i, int j, char numeric)
	{
	if (j)
	fprintf(fd, "\t");
	print_mod(fd, j);
	fprintf(fd, "keycode %3d =", i);
	print_keysym(ctx, fd, bufj, numeric);
	fprintf(fd, "\n");
	}

	void lk_dump_keys(struct lk_ctx ctx, FILE fd, lk_table_shape table, char numeric)
	{
	unsigned int i, j;
	int buf[MAX_NR_KEYMAPS];
	int isletter, islatin, isasexpected;
	int typ, val;
	int alt_is_meta = 0;
	int all_holes;
	int zapped[MAX_NR_KEYMAPS];
	unsigned int keymapnr = ctx->keymap->total;

	if (!keymapnr)
	return;

	if (table == LK_SHAPE_FULL_TABLE \|\| table == LK_SHAPE_SEPARATE_LINES)
	goto no_shorthands;

	/* first pass: determine whether to set alt_is_meta */
	for (j = 0; j < ctx->keymap->total; j++) {
	unsigned int ja = (j \| M_ALT);

	if (!(j != ja && lk_map_exists(ctx, j) && lk_map_exists(ctx, ja)))
	continue;

	for (i = 1; i < NR_KEYS; i++) {
	int buf0, buf1, type;

	buf0 = lk_get_key(ctx, j, i);

	if (buf0 == -1)
	break;

	type = KTYP(buf0);

	if ((type == KT_LATIN \|\| type == KT_LETTER) && KVAL(buf0) < 128) {
	buf1 = lk_map_exists(ctx, ja)
	? lk_get_key(ctx, ja, i)
	: -1;

	if (buf1 != K(KT_META, KVAL(buf0)))
	goto not_alt_is_meta;
	}
	}
	}
	alt_is_meta = 1;
	fprintf(fd, "alt_is_meta\n");

	not_alt_is_meta:
	no_shorthands:

	for (i = 1; i < NR_KEYS; i++) {
	all_holes = 1;

	for (j = 0; j < keymapnr; j++) {
	buf[j] = K_HOLE;

	if (lk_map_exists(ctx, j))
	buf[j] = lk_get_key(ctx, j, i);

	if (buf[j] != K_HOLE)
	all_holes = 0;
	}

	if (all_holes && table != LK_SHAPE_FULL_TABLE)
	continue;

	if (table == LK_SHAPE_FULL_TABLE) {
	fprintf(fd, "keycode %3d =", i);

	for (j = 0; j < keymapnr; j++) {
	if (lk_map_exists(ctx, j))
	print_keysym(ctx, fd, buf[j], numeric);
	}

	fprintf(fd, "\n");
	continue;
	}

	if (table == LK_SHAPE_SEPARATE_LINES) {
	for (j = 0; j < keymapnr; j++) {
	//if (buf[j] != K_HOLE)
	print_bind(ctx, fd, buf[j], i, j, numeric);
	}

	fprintf(fd, "\n");
	continue;
	}

	typ = KTYP(buf[0]);
	val = KVAL(buf[0]);
	islatin = (typ == KT_LATIN \|\| typ == KT_LETTER);
	isletter = (islatin &&
	((val >= 'A' && val <= 'Z') \|\|
	(val >= 'a' && val <= 'z')));

	isasexpected = 0;
	if (isletter) {
	unsigned short defs[16];
	defs[0] = K(KT_LETTER, val);
	defs[1] = K(KT_LETTER, val ^ 32);
	defs[2] = defs[0];
	defs[3] = defs[1];

	for (j = 4; j < 8; j++)
	defs[j] = K(KT_LATIN, val & ~96);

	for (j = 8; j < 16; j++)
	defs[j] = K(KT_META, KVAL(defs[j - 8]));

	for (j = 0; j < keymapnr; j++) {
	if ((j >= 16 && buf[j] != K_HOLE) \|\| (j < 16 && buf[j] != defs[j]))
	goto unexpected;
	}

	isasexpected = 1;
	}
	unexpected:

	/* wipe out predictable meta bindings */
	for (j = 0; j < keymapnr; j++)
	zapped[j] = 0;

	if (alt_is_meta) {
	for (j = 0; j < keymapnr; j++) {
	unsigned int ja, ktyp;
	ja = (j \| M_ALT);

	if (j != ja && lk_map_exists(ctx, ja) && ((ktyp = KTYP(buf[j])) == KT_LATIN \|\| ktyp == KT_LETTER) && KVAL(buf[j]) < 128) {
	if (buf[ja] != K(KT_META, KVAL(buf[j])))
	fprintf(stderr, _("impossible: not meta?\n"));
	buf[ja] = K_HOLE;
	zapped[ja] = 1;
	}
	}
	}

	fprintf(fd, "keycode %3d =", i);

	if (isasexpected) {
	/* print only a single entry */
	/* suppress the + for ordinary a-zA-Z */
	print_keysym(ctx, fd, K(KT_LATIN, val), numeric);
	fprintf(fd, "\n");
	} else {
	/* choose between single entry line followed by exceptions,
	and long line followed by exceptions; avoid VoidSymbol */
	unsigned int bad, count;
	bad = count = 0;

	for (j = 1; j < keymapnr; j++) {
	if (zapped[j])
	continue;

	if (buf[j] != buf[0])
	bad++;

	if (buf[j] != K_HOLE)
	count++;
	}

	if (bad <= count && bad < keymapnr - 1) {
	if (buf[0] != K_HOLE) {
	print_keysym(ctx, fd, buf[0], numeric);
	}
	fprintf(fd, "\n");

	for (j = 1; j < keymapnr; j++) {
	if (buf[j] != buf[0] && !zapped[j]) {
	print_bind(ctx, fd, buf[j], i, j, numeric);
	}
	}
	} else {
	for (j = 0;
	j < keymapnr && buf[j] != K_HOLE &&
	(table != LK_SHAPE_UNTIL_HOLE \|\| lk_map_exists(ctx, j));
	j++) {
	//print_bind(ctx, fd, buf[j], i, j, numeric);
	print_keysym(ctx, fd, buf[j], numeric);
	}
	fprintf(fd, "\n");

	for (; j < keymapnr; j++) {
	if (buf[j] != K_HOLE) {
	print_bind(ctx, fd, buf[j], i, j, numeric);
	}
	}
	}
	}
	}
	}

	void lk_dump_keymap(struct lk_ctx ctx, FILE fd, lk_table_shape table, char numeric)
	{
	lk_dump_keymaps(ctx, fd);
	lk_dump_keys(ctx, fd, table, numeric);
	lk_dump_funcs(ctx, fd);
	}