303 lines
8.3 KiB
C
303 lines
8.3 KiB
C
/*
|
|
*
|
|
* Copyright 1990, 1998 The Open Group
|
|
*
|
|
* Permission to use, copy, modify, distribute, and sell this software and its
|
|
* documentation for any purpose is hereby granted without fee, provided that
|
|
* the above copyright notice appear in all copies and that both that
|
|
* copyright notice and this permission notice appear in supporting
|
|
* documentation.
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
* OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
* Except as contained in this notice, the name of The Open Group shall
|
|
* not be used in advertising or otherwise to promote the sale, use or
|
|
* other dealings in this Software without prior written authorization
|
|
* from The Open Group.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Constructs hash tables for xkb_keysym_to_string and
|
|
* xkb_string_from_keysym.
|
|
*/
|
|
|
|
#include "xkbcommon/xkbcommon.h"
|
|
|
|
#include <inttypes.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
typedef uint32_t Signature;
|
|
|
|
#define KTNUM 4000
|
|
|
|
static struct info {
|
|
char *name;
|
|
xkb_keysym_t val;
|
|
} info[KTNUM];
|
|
|
|
#define MIN_REHASH 15
|
|
#define MATCHES 10
|
|
|
|
static char tab[KTNUM];
|
|
static unsigned short offsets[KTNUM];
|
|
static unsigned short indexes[KTNUM];
|
|
static xkb_keysym_t values[KTNUM];
|
|
static int ksnum = 0;
|
|
|
|
static int
|
|
parse_line(const char *buf, char *key, xkb_keysym_t *val, char *prefix)
|
|
{
|
|
int i;
|
|
char alias[128];
|
|
|
|
/* See if we can catch a straight XK_foo 0x1234-style definition first;
|
|
* the trickery around tmp is to account for prefices. */
|
|
i = sscanf(buf, "#define %127s 0x%" SCNx32, key, val);
|
|
if (i == 2 && strncmp(key, "XKB_KEY_", 8) == 0) {
|
|
prefix[0] = '\0';
|
|
memmove(key, key + 8, strlen(key + 8) + 1);
|
|
return 1;
|
|
}
|
|
|
|
i = sscanf(buf, "#define %127s %127s", key, alias);
|
|
if (i == 2)
|
|
fprintf(stderr, "can't parse keysym definition: %s", buf);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
FILE *fptr;
|
|
int max_rehash;
|
|
Signature sig;
|
|
int i, j, k, l, z;
|
|
char *name;
|
|
char c;
|
|
int first;
|
|
int best_max_rehash;
|
|
int best_z = 0;
|
|
int num_found;
|
|
xkb_keysym_t val;
|
|
char key[128], prefix[128];
|
|
char buf[1024];
|
|
|
|
for (l = 1; l < argc; l++) {
|
|
fptr = fopen(argv[l], "r");
|
|
if (!fptr) {
|
|
fprintf(stderr, "couldn't open %s\n", argv[l]);
|
|
continue;
|
|
}
|
|
|
|
while (fgets(buf, sizeof(buf), fptr)) {
|
|
if (!parse_line(buf, key, &val, prefix))
|
|
continue;
|
|
|
|
if (val == XKB_KEY_VoidSymbol)
|
|
val = 0;
|
|
if (val > 0x1fffffff) {
|
|
fprintf(stderr, "ignoring illegal keysym (%s, %" PRIx32 ")\n",
|
|
key,
|
|
val);
|
|
continue;
|
|
}
|
|
|
|
name = malloc(strlen(prefix) + strlen(key) + 1);
|
|
if (!name) {
|
|
fprintf(stderr, "makekeys: out of memory!\n");
|
|
exit(1);
|
|
}
|
|
sprintf(name, "%s%s", prefix, key);
|
|
info[ksnum].name = name;
|
|
info[ksnum].val = val;
|
|
ksnum++;
|
|
if (ksnum == KTNUM) {
|
|
fprintf(stderr, "makekeys: too many keysyms!\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
fclose(fptr);
|
|
}
|
|
|
|
printf("/* This file is generated from keysymdef.h. */\n");
|
|
printf("/* Do not edit. */\n");
|
|
printf("\n");
|
|
|
|
best_max_rehash = ksnum;
|
|
num_found = 0;
|
|
for (z = ksnum; z < KTNUM; z++) {
|
|
max_rehash = 0;
|
|
for (name = tab, i = z; --i >= 0; )
|
|
*name++ = 0;
|
|
for (i = 0; i < ksnum; i++) {
|
|
name = info[i].name;
|
|
sig = 0;
|
|
while ((c = *name++))
|
|
sig = (sig << 1) + c;
|
|
first = j = sig % z;
|
|
for (k = 0; tab[j]; k++) {
|
|
j += first + 1;
|
|
if (j >= z)
|
|
j -= z;
|
|
if (j == first)
|
|
goto next1;
|
|
}
|
|
tab[j] = 1;
|
|
if (k > max_rehash)
|
|
max_rehash = k;
|
|
}
|
|
if (max_rehash < MIN_REHASH) {
|
|
if (max_rehash < best_max_rehash) {
|
|
best_max_rehash = max_rehash;
|
|
best_z = z;
|
|
}
|
|
num_found++;
|
|
if (num_found >= MATCHES)
|
|
break;
|
|
}
|
|
next1:;
|
|
}
|
|
|
|
z = best_z;
|
|
printf("#ifndef KS_TABLES_H\n");
|
|
printf("#define KS_TABLES_H\n\n");
|
|
printf("static const unsigned char _XkeyTable[] = {\n");
|
|
if (z == 0) {
|
|
fprintf(stderr, "makekeys: failed to find small enough hash!\n"
|
|
"Try increasing KTNUM in makekeys.c\n");
|
|
exit(1);
|
|
}
|
|
printf("0,\n");
|
|
k = 1;
|
|
for (i = 0; i < ksnum; i++) {
|
|
name = info[i].name;
|
|
sig = 0;
|
|
while ((c = *name++))
|
|
sig = (sig << 1) + c;
|
|
first = j = sig % z;
|
|
while (offsets[j]) {
|
|
j += first + 1;
|
|
if (j >= z)
|
|
j -= z;
|
|
}
|
|
offsets[j] = k;
|
|
indexes[i] = k;
|
|
val = info[i].val;
|
|
printf("0x%.2" PRIx32 ", 0x%.2" PRIx32 ", 0x%.2" PRIx32 ", "
|
|
"0x%.2" PRIx32 ", 0x%.2" PRIx32 ", 0x%.2" PRIx32 ", ",
|
|
(sig >> 8) & 0xff, sig & 0xff, (val >> 24) & 0xff,
|
|
(val >> 16) & 0xff, (val >> 8) & 0xff, val & 0xff);
|
|
for (name = info[i].name, k += 7; (c = *name++); k++)
|
|
printf("'%c',", c);
|
|
printf((i == (ksnum - 1)) ? "0\n" : "0,\n");
|
|
}
|
|
printf("};\n");
|
|
printf("\n");
|
|
printf("#define KTABLESIZE %d\n", z);
|
|
printf("#define KMAXHASH %d\n", best_max_rehash + 1);
|
|
printf("\n");
|
|
printf("static const unsigned short hashString[KTABLESIZE] = {\n");
|
|
for (i = 0; i < z; ) {
|
|
printf("0x%.4x", offsets[i]);
|
|
i++;
|
|
if (i == z)
|
|
break;
|
|
printf((i & 7) ? ", " : ",\n");
|
|
}
|
|
printf("\n");
|
|
printf("};\n");
|
|
|
|
best_max_rehash = ksnum;
|
|
num_found = 0;
|
|
for (z = ksnum; z < KTNUM; z++) {
|
|
max_rehash = 0;
|
|
for (name = tab, i = z; --i >= 0; )
|
|
*name++ = 0;
|
|
for (i = 0; i < ksnum; i++) {
|
|
val = info[i].val;
|
|
first = j = val % z;
|
|
for (k = 0; tab[j]; k++) {
|
|
if (values[j] == val)
|
|
goto skip1;
|
|
j += first + 1;
|
|
if (j >= z)
|
|
j -= z;
|
|
if (j == first)
|
|
goto next2;
|
|
}
|
|
tab[j] = 1;
|
|
values[j] = val;
|
|
if (k > max_rehash)
|
|
max_rehash = k;
|
|
skip1:;
|
|
}
|
|
if (max_rehash < MIN_REHASH) {
|
|
if (max_rehash < best_max_rehash) {
|
|
best_max_rehash = max_rehash;
|
|
best_z = z;
|
|
}
|
|
num_found++;
|
|
if (num_found >= MATCHES)
|
|
break;
|
|
}
|
|
next2:;
|
|
}
|
|
|
|
z = best_z;
|
|
if (z == 0) {
|
|
fprintf(stderr, "makekeys: failed to find small enough hash!\n"
|
|
"Try increasing KTNUM in makekeys.c\n");
|
|
exit(1);
|
|
}
|
|
for (i = z; --i >= 0; )
|
|
offsets[i] = 0;
|
|
for (i = 0; i < ksnum; i++) {
|
|
val = info[i].val;
|
|
first = j = val % z;
|
|
while (offsets[j]) {
|
|
if (values[j] == val)
|
|
goto skip2;
|
|
j += first + 1;
|
|
if (j >= z)
|
|
j -= z;
|
|
}
|
|
offsets[j] = indexes[i] + 2;
|
|
values[j] = val;
|
|
skip2:;
|
|
}
|
|
printf("\n");
|
|
printf("#define VTABLESIZE %d\n", z);
|
|
printf("#define VMAXHASH %d\n", best_max_rehash + 1);
|
|
printf("\n");
|
|
printf("static const unsigned short hashKeysym[VTABLESIZE] = {\n");
|
|
for (i = 0; i < z; ) {
|
|
printf("0x%.4x", offsets[i]);
|
|
i++;
|
|
if (i == z)
|
|
break;
|
|
printf((i & 7) ? ", " : ",\n");
|
|
}
|
|
printf("\n");
|
|
printf("};\n");
|
|
printf("\n#endif /* KS_TABLES_H */\n");
|
|
|
|
for (i = 0; i < ksnum; i++)
|
|
free(info[i].name);
|
|
|
|
exit(0);
|
|
}
|