SecBSD/xenocara
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

revert to xkbcomp 1.4.6 for now

Browse source
This commit is contained in:
purplerain 2024-05-11 19:43:34 +00:00
parent 155eb8555e
commit f60577aa63
Signed by: purplerain
GPG key ID: F42C07F07E2E35B7
34 changed files with 5337 additions and 6152 deletions
Download patch file Download diff file Expand all files Collapse all files

267
app/xkbcomp/misc.c
View file

@ -53,6 +53,7 @@ ProcessIncludeFile(IncludeStmt * stmt,
unsigned file_type,
XkbFile ** file_rtrn, unsigned *merge_rtrn)
{
FILE *file;
XkbFile *rtrn, *mapToUse;
char oldFile[1024] = {0};
int oldLine = lineNum;
@ -62,7 +63,7 @@ ProcessIncludeFile(IncludeStmt * stmt,
{
/* file not in cache, open it, parse it and store it in cache for next
time. */
FILE *file = XkbFindFileInPath(stmt->file, file_type, &stmt->path);
file = XkbFindFileInPath(stmt->file, file_type, &stmt->path);
if (file == NULL)
{
ERROR("Can't find file \"%s\" for %s include\n", stmt->file,
@ -73,10 +74,8 @@ ProcessIncludeFile(IncludeStmt * stmt,
strcpy(oldFile, scanFile);
oldLine = lineNum;
setScanState(stmt->file, 1);
#ifdef DEBUG
if (debugFlags & 2)
INFO("About to parse include file %s\n", stmt->file);
#endif
/* parse the file */
if ((XKBParseFile(file, &rtrn) == 0) || (rtrn == NULL))
{
@ -177,7 +176,6 @@ ReportBadType(const char *type, const char *field,
return False;
}
#if 0
int
ReportBadIndexType(char *type, char *field, char *name, char *wanted)
{
@ -185,7 +183,6 @@ ReportBadIndexType(char *type, char *field, char *name, char *wanted)
ACTION("Ignoring assignment to illegal field in %s\n", name);
return False;
}
#endif
int
ReportBadField(const char *type, const char *field, const char *name)
@ -195,7 +192,6 @@ ReportBadField(const char *type, const char *field, const char *name)
return False;
}
#if 0
int
ReportMultipleDefs(char *type, char *field, char *name)
{
@ -203,13 +199,12 @@ ReportMultipleDefs(char *type, char *field, char *name)
ACTION("Using last definition\n");
return False;
}
#endif
/***====================================================================***/
Bool
UseNewField(unsigned field, const CommonInfo *oldDefs,
const CommonInfo *newDefs, unsigned *pCollide)
UseNewField(unsigned field,
CommonInfo * oldDefs, CommonInfo * newDefs, unsigned *pCollide)
{
Bool useNew;
@ -232,10 +227,9 @@ UseNewField(unsigned field, const CommonInfo *oldDefs,
return useNew;
}
#if 0
static Bool
MergeNewField(unsigned field, const CommonInfo *oldDefs,
const CommonInfo *newDefs, unsigned *pCollide)
Bool
MergeNewField(unsigned field,
CommonInfo * oldDefs, CommonInfo * newDefs, unsigned *pCollide)
{
if ((oldDefs->defined & field) && (newDefs->defined & field))
{
@ -249,7 +243,6 @@ MergeNewField(unsigned field, const CommonInfo *oldDefs,
}
return False;
}
#endif
XPointer
ClearCommonInfo(CommonInfo * cmn)
@ -260,7 +253,7 @@ ClearCommonInfo(CommonInfo * cmn)
for (this = cmn; this != NULL; this = next)
{
next = this->next;
free(this);
uFree(this);
}
}
return NULL;
@ -296,140 +289,141 @@ typedef struct _KeyNameDesc
} KeyNameDesc;
static KeyNameDesc dfltKeys[] = {
{XK_Escape, NoSymbol, "ESC\0", 0},
{XK_quoteleft, XK_asciitilde, "TLDE", 0},
{XK_1, XK_exclam, "AE01", 0},
{XK_2, XK_at, "AE02", 0},
{XK_3, XK_numbersign, "AE03", 0},
{XK_4, XK_dollar, "AE04", 0},
{XK_5, XK_percent, "AE05", 0},
{XK_6, XK_asciicircum, "AE06", 0},
{XK_7, XK_ampersand, "AE07", 0},
{XK_8, XK_asterisk, "AE08", 0},
{XK_9, XK_parenleft, "AE09", 0},
{XK_0, XK_parenright, "AE10", 0},
{XK_minus, XK_underscore, "AE11", 0},
{XK_equal, XK_plus, "AE12", 0},
{XK_BackSpace, NoSymbol, "BKSP", 0},
{XK_Tab, NoSymbol, "TAB\0", 0},
{XK_q, XK_Q, "AD01", 0},
{XK_w, XK_W, "AD02", 0},
{XK_e, XK_E, "AD03", 0},
{XK_r, XK_R, "AD04", 0},
{XK_t, XK_T, "AD05", 0},
{XK_y, XK_Y, "AD06", 0},
{XK_u, XK_U, "AD07", 0},
{XK_i, XK_I, "AD08", 0},
{XK_o, XK_O, "AD09", 0},
{XK_p, XK_P, "AD10", 0},
{XK_bracketleft, XK_braceleft, "AD11", 0},
{XK_bracketright, XK_braceright, "AD12", 0},
{XK_Return, NoSymbol, "RTRN", 0},
{XK_Caps_Lock, NoSymbol, "CAPS", 0},
{XK_a, XK_A, "AC01", 0},
{XK_s, XK_S, "AC02", 0},
{XK_d, XK_D, "AC03", 0},
{XK_f, XK_F, "AC04", 0},
{XK_g, XK_G, "AC05", 0},
{XK_h, XK_H, "AC06", 0},
{XK_j, XK_J, "AC07", 0},
{XK_k, XK_K, "AC08", 0},
{XK_l, XK_L, "AC09", 0},
{XK_semicolon, XK_colon, "AC10", 0},
{XK_quoteright, XK_quotedbl, "AC11", 0},
{XK_Shift_L, NoSymbol, "LFSH", 0},
{XK_z, XK_Z, "AB01", 0},
{XK_x, XK_X, "AB02", 0},
{XK_c, XK_C, "AB03", 0},
{XK_v, XK_V, "AB04", 0},
{XK_b, XK_B, "AB05", 0},
{XK_n, XK_N, "AB06", 0},
{XK_m, XK_M, "AB07", 0},
{XK_comma, XK_less, "AB08", 0},
{XK_period, XK_greater, "AB09", 0},
{XK_slash, XK_question, "AB10", 0},
{XK_backslash, XK_bar, "BKSL", 0},
{XK_Control_L, NoSymbol, "LCTL", 0},
{XK_space, NoSymbol, "SPCE", 0},
{XK_Shift_R, NoSymbol, "RTSH", 0},
{XK_Alt_L, NoSymbol, "LALT", 0},
{XK_space, NoSymbol, "SPCE", 0},
{XK_Control_R, NoSymbol, "RCTL", 0},
{XK_Alt_R, NoSymbol, "RALT", 0},
{XK_F1, NoSymbol, "FK01", 0},
{XK_F2, NoSymbol, "FK02", 0},
{XK_F3, NoSymbol, "FK03", 0},
{XK_F4, NoSymbol, "FK04", 0},
{XK_F5, NoSymbol, "FK05", 0},
{XK_F6, NoSymbol, "FK06", 0},
{XK_F7, NoSymbol, "FK07", 0},
{XK_F8, NoSymbol, "FK08", 0},
{XK_F9, NoSymbol, "FK09", 0},
{XK_F10, NoSymbol, "FK10", 0},
{XK_F11, NoSymbol, "FK11", 0},
{XK_F12, NoSymbol, "FK12", 0},
{XK_Print, NoSymbol, "PRSC", 0},
{XK_Scroll_Lock, NoSymbol, "SCLK", 0},
{XK_Pause, NoSymbol, "PAUS", 0},
{XK_Insert, NoSymbol, "INS\0", 0},
{XK_Home, NoSymbol, "HOME", 0},
{XK_Prior, NoSymbol, "PGUP", 0},
{XK_Delete, NoSymbol, "DELE", 0},
{XK_End, NoSymbol, "END", 0},
{XK_Next, NoSymbol, "PGDN", 0},
{XK_Up, NoSymbol, "UP\0\0", 0},
{XK_Left, NoSymbol, "LEFT", 0},
{XK_Down, NoSymbol, "DOWN", 0},
{XK_Right, NoSymbol, "RGHT", 0},
{XK_Num_Lock, NoSymbol, "NMLK", 0},
{XK_KP_Divide, NoSymbol, "KPDV", 0},
{XK_KP_Multiply, NoSymbol, "KPMU", 0},
{XK_KP_Subtract, NoSymbol, "KPSU", 0},
{NoSymbol, XK_KP_7, "KP7\0", 0},
{NoSymbol, XK_KP_8, "KP8\0", 0},
{NoSymbol, XK_KP_9, "KP9\0", 0},
{XK_KP_Add, NoSymbol, "KPAD", 0},
{NoSymbol, XK_KP_4, "KP4\0", 0},
{NoSymbol, XK_KP_5, "KP5\0", 0},
{NoSymbol, XK_KP_6, "KP6\0", 0},
{NoSymbol, XK_KP_1, "KP1\0", 0},
{NoSymbol, XK_KP_2, "KP2\0", 0},
{NoSymbol, XK_KP_3, "KP3\0", 0},
{XK_KP_Enter, NoSymbol, "KPEN", 0},
{NoSymbol, XK_KP_0, "KP0\0", 0},
{XK_KP_Delete, NoSymbol, "KPDL", 0},
{XK_less, XK_greater, "LSGT", 0},
{XK_KP_Separator, NoSymbol, "KPCO", 0},
{XK_Find, NoSymbol, "FIND", 0},
{NoSymbol, NoSymbol, "\0\0\0\0", 0}
{XK_Escape, NoSymbol, "ESC\0"},
{XK_quoteleft, XK_asciitilde, "TLDE"},
{XK_1, XK_exclam, "AE01"},
{XK_2, XK_at, "AE02"},
{XK_3, XK_numbersign, "AE03"},
{XK_4, XK_dollar, "AE04"},
{XK_5, XK_percent, "AE05"},
{XK_6, XK_asciicircum, "AE06"},
{XK_7, XK_ampersand, "AE07"},
{XK_8, XK_asterisk, "AE08"},
{XK_9, XK_parenleft, "AE09"},
{XK_0, XK_parenright, "AE10"},
{XK_minus, XK_underscore, "AE11"},
{XK_equal, XK_plus, "AE12"},
{XK_BackSpace, NoSymbol, "BKSP"},
{XK_Tab, NoSymbol, "TAB\0"},
{XK_q, XK_Q, "AD01"},
{XK_w, XK_W, "AD02"},
{XK_e, XK_E, "AD03"},
{XK_r, XK_R, "AD04"},
{XK_t, XK_T, "AD05"},
{XK_y, XK_Y, "AD06"},
{XK_u, XK_U, "AD07"},
{XK_i, XK_I, "AD08"},
{XK_o, XK_O, "AD09"},
{XK_p, XK_P, "AD10"},
{XK_bracketleft, XK_braceleft, "AD11"},
{XK_bracketright, XK_braceright, "AD12"},
{XK_Return, NoSymbol, "RTRN"},
{XK_Caps_Lock, NoSymbol, "CAPS"},
{XK_a, XK_A, "AC01"},
{XK_s, XK_S, "AC02"},
{XK_d, XK_D, "AC03"},
{XK_f, XK_F, "AC04"},
{XK_g, XK_G, "AC05"},
{XK_h, XK_H, "AC06"},
{XK_j, XK_J, "AC07"},
{XK_k, XK_K, "AC08"},
{XK_l, XK_L, "AC09"},
{XK_semicolon, XK_colon, "AC10"},
{XK_quoteright, XK_quotedbl, "AC11"},
{XK_Shift_L, NoSymbol, "LFSH"},
{XK_z, XK_Z, "AB01"},
{XK_x, XK_X, "AB02"},
{XK_c, XK_C, "AB03"},
{XK_v, XK_V, "AB04"},
{XK_b, XK_B, "AB05"},
{XK_n, XK_N, "AB06"},
{XK_m, XK_M, "AB07"},
{XK_comma, XK_less, "AB08"},
{XK_period, XK_greater, "AB09"},
{XK_slash, XK_question, "AB10"},
{XK_backslash, XK_bar, "BKSL"},
{XK_Control_L, NoSymbol, "LCTL"},
{XK_space, NoSymbol, "SPCE"},
{XK_Shift_R, NoSymbol, "RTSH"},
{XK_Alt_L, NoSymbol, "LALT"},
{XK_space, NoSymbol, "SPCE"},
{XK_Control_R, NoSymbol, "RCTL"},
{XK_Alt_R, NoSymbol, "RALT"},
{XK_F1, NoSymbol, "FK01"},
{XK_F2, NoSymbol, "FK02"},
{XK_F3, NoSymbol, "FK03"},
{XK_F4, NoSymbol, "FK04"},
{XK_F5, NoSymbol, "FK05"},
{XK_F6, NoSymbol, "FK06"},
{XK_F7, NoSymbol, "FK07"},
{XK_F8, NoSymbol, "FK08"},
{XK_F9, NoSymbol, "FK09"},
{XK_F10, NoSymbol, "FK10"},
{XK_F11, NoSymbol, "FK11"},
{XK_F12, NoSymbol, "FK12"},
{XK_Print, NoSymbol, "PRSC"},
{XK_Scroll_Lock, NoSymbol, "SCLK"},
{XK_Pause, NoSymbol, "PAUS"},
{XK_Insert, NoSymbol, "INS\0"},
{XK_Home, NoSymbol, "HOME"},
{XK_Prior, NoSymbol, "PGUP"},
{XK_Delete, NoSymbol, "DELE"},
{XK_End, NoSymbol, "END"},
{XK_Next, NoSymbol, "PGDN"},
{XK_Up, NoSymbol, "UP\0\0"},
{XK_Left, NoSymbol, "LEFT"},
{XK_Down, NoSymbol, "DOWN"},
{XK_Right, NoSymbol, "RGHT"},
{XK_Num_Lock, NoSymbol, "NMLK"},
{XK_KP_Divide, NoSymbol, "KPDV"},
{XK_KP_Multiply, NoSymbol, "KPMU"},
{XK_KP_Subtract, NoSymbol, "KPSU"},
{NoSymbol, XK_KP_7, "KP7\0"},
{NoSymbol, XK_KP_8, "KP8\0"},
{NoSymbol, XK_KP_9, "KP9\0"},
{XK_KP_Add, NoSymbol, "KPAD"},
{NoSymbol, XK_KP_4, "KP4\0"},
{NoSymbol, XK_KP_5, "KP5\0"},
{NoSymbol, XK_KP_6, "KP6\0"},
{NoSymbol, XK_KP_1, "KP1\0"},
{NoSymbol, XK_KP_2, "KP2\0"},
{NoSymbol, XK_KP_3, "KP3\0"},
{XK_KP_Enter, NoSymbol, "KPEN"},
{NoSymbol, XK_KP_0, "KP0\0"},
{XK_KP_Delete, NoSymbol, "KPDL"},
{XK_less, XK_greater, "LSGT"},
{XK_KP_Separator, NoSymbol, "KPCO"},
{XK_Find, NoSymbol, "FIND"},
{NoSymbol, NoSymbol, "\0\0\0\0"}
};
Status
ComputeKbdDefaults(XkbDescPtr xkb)
{
int nUnknown;
Status rtrn;
register int i, tmp, nUnknown;
KeyNameDesc *name;
KeySym *syms;
char tmpname[XkbKeyNameLength + 1];
if ((xkb->names == NULL) || (xkb->names->keys == NULL))
{
Status rtrn;
if ((rtrn = XkbAllocNames(xkb, XkbKeyNamesMask, 0, 0)) != Success)
return rtrn;
}
for (KeyNameDesc *name = dfltKeys; (name->name[0] != '\0'); name++)
for (name = dfltKeys; (name->name[0] != '\0'); name++)
{
name->used = False;
}
nUnknown = 0;
for (int i = xkb->min_key_code; i <= xkb->max_key_code; i++)
for (i = xkb->min_key_code; i <= xkb->max_key_code; i++)
{
int tmp = XkbKeyNumSyms(xkb, i);
tmp = XkbKeyNumSyms(xkb, i);
if ((xkb->names->keys[i].name[0] == '\0') && (tmp > 0))
{
KeySym *syms;
tmp = XkbKeyGroupsWidth(xkb, i);
syms = XkbKeySymsPtr(xkb, i);
for (KeyNameDesc *name = dfltKeys; (name->name[0] != '\0'); name++)
for (name = dfltKeys; (name->name[0] != '\0'); name++)
{
Bool match = True;
if (((name->level1 != syms[0])
@ -450,8 +444,6 @@ ComputeKbdDefaults(XkbDescPtr xkb)
}
else
{
char tmpname[XkbKeyNameLength + 1];
if (warningLevel > 2)
{
WARN
@ -472,8 +464,6 @@ ComputeKbdDefaults(XkbDescPtr xkb)
{
if (warningLevel > 2)
{
char tmpname[XkbKeyNameLength + 1];
WARN("Key %d does not match any defaults\n", i);
ACTION("Using name <U%03d>\n", nUnknown);
snprintf(tmpname, sizeof(tmpname), "U%03d", nUnknown++);
@ -504,6 +494,8 @@ FindNamedKey(XkbDescPtr xkb,
unsigned int *kc_rtrn,
Bool use_aliases, Bool create, int start_from)
{
register unsigned n;
if (start_from < xkb->min_key_code)
{
start_from = xkb->min_key_code;
@ -516,7 +508,7 @@ FindNamedKey(XkbDescPtr xkb,
*kc_rtrn = 0; /* some callers rely on this */
if (xkb && xkb->names && xkb->names->keys)
{
for (unsigned n = start_from; n <= xkb->max_key_code; n++)
for (n = start_from; n <= xkb->max_key_code; n++)
{
unsigned long tmp;
tmp = KeyNameToLong(xkb->names->keys[n].name);
@ -554,7 +546,7 @@ FindNamedKey(XkbDescPtr xkb,
}
}
/* Find first unused keycode and store our key here */
for (unsigned n = xkb->min_key_code; n <= xkb->max_key_code; n++)
for (n = xkb->min_key_code; n <= xkb->max_key_code; n++)
{
if (xkb->names->keys[n].name[0] == '\0')
{
@ -573,6 +565,7 @@ Bool
FindKeyNameForAlias(XkbDescPtr xkb, unsigned long lname,
unsigned long *real_name)
{
register int i;
char name[XkbKeyNameLength + 1];
if (xkb && xkb->geom && xkb->geom->key_aliases)
@ -581,7 +574,7 @@ FindKeyNameForAlias(XkbDescPtr xkb, unsigned long lname,
a = xkb->geom->key_aliases;
LongToKeyName(lname, name);
name[XkbKeyNameLength] = '\0';
for (int i = 0; i < xkb->geom->num_key_aliases; i++, a++)
for (i = 0; i < xkb->geom->num_key_aliases; i++, a++)
{
if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
{
@ -596,7 +589,7 @@ FindKeyNameForAlias(XkbDescPtr xkb, unsigned long lname,
a = xkb->names->key_aliases;
LongToKeyName(lname, name);
name[XkbKeyNameLength] = '\0';
for (int i = 0; i < xkb->names->num_key_aliases; i++, a++)
for (i = 0; i < xkb->names->num_key_aliases; i++, a++)
{
if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
{