From: Ran Benita Date: Sun, 15 Jul 2012 09:48:11 +0000 (+0300) Subject: Replace KeyInfo 'key' variable name by 'keyi' X-Git-Tag: xkbcommon-0.2.0~431 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e668d00956e81c9638ee0b7542cee17bec8a23e1;p=platform%2Fupstream%2Flibxkbcommon.git Replace KeyInfo 'key' variable name by 'keyi' We want to reserve the name 'key' for something else. Signed-off-by: Ran Benita --- diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c index d58c116..c67bf1d 100644 --- a/src/xkbcomp/symbols.c +++ b/src/xkbcomp/symbols.c @@ -89,60 +89,62 @@ typedef struct _KeyInfo { * Init the given key info to sane values. */ static void -InitKeyInfo(KeyInfo * info, unsigned file_id) +InitKeyInfo(KeyInfo *keyi, unsigned file_id) { int i; static const char dflt[4] = "*"; - info->defs.defined = 0; - info->defs.file_id = file_id; - info->defs.merge = MERGE_OVERRIDE; - info->defs.next = NULL; - info->name = KeyNameToLong(dflt); - info->groupInfo = 0; - info->typesDefined = info->symsDefined = info->actsDefined = 0; + keyi->defs.defined = 0; + keyi->defs.file_id = file_id; + keyi->defs.merge = MERGE_OVERRIDE; + keyi->defs.next = NULL; + keyi->name = KeyNameToLong(dflt); + keyi->groupInfo = 0; + keyi->typesDefined = keyi->symsDefined = keyi->actsDefined = 0; + for (i = 0; i < XkbNumKbdGroups; i++) { - info->numLevels[i] = 0; - info->types[i] = XKB_ATOM_NONE; - darray_init(info->syms[i]); - darray_init(info->symsMapIndex[i]); - darray_init(info->symsMapNumEntries[i]); - darray_init(info->acts[i]); - } - info->dfltType = XKB_ATOM_NONE; - info->behavior.type = XkbKB_Default; - info->behavior.data = 0; - info->vmodmap = 0; - info->repeat = RepeatUndefined; + keyi->numLevels[i] = 0; + keyi->types[i] = XKB_ATOM_NONE; + darray_init(keyi->syms[i]); + darray_init(keyi->symsMapIndex[i]); + darray_init(keyi->symsMapNumEntries[i]); + darray_init(keyi->acts[i]); + } + + keyi->dfltType = XKB_ATOM_NONE; + keyi->behavior.type = XkbKB_Default; + keyi->behavior.data = 0; + keyi->vmodmap = 0; + keyi->repeat = RepeatUndefined; } /** - * Free memory associated with this key info and reset to sane values. + * Free memory associated with this key keyi and reset to sane values. */ static void -FreeKeyInfo(KeyInfo * info) +FreeKeyInfo(KeyInfo *keyi) { int i; - info->defs.defined = 0; - info->defs.file_id = 0; - info->defs.merge = MERGE_OVERRIDE; - info->defs.next = NULL; - info->groupInfo = 0; - info->typesDefined = info->symsDefined = info->actsDefined = 0; + keyi->defs.defined = 0; + keyi->defs.file_id = 0; + keyi->defs.merge = MERGE_OVERRIDE; + keyi->defs.next = NULL; + keyi->groupkeyi = 0; + keyi->typesDefined = keyi->symsDefined = keyi->actsDefined = 0; for (i = 0; i < XkbNumKbdGroups; i++) { - info->numLevels[i] = 0; - info->types[i] = XKB_ATOM_NONE; - darray_free(info->syms[i]); - darray_free(info->symsMapIndex[i]); - darray_free(info->symsMapNumEntries[i]); - darray_free(info->acts[i]); - } - info->dfltType = XKB_ATOM_NONE; - info->behavior.type = XkbKB_Default; - info->behavior.data = 0; - info->vmodmap = 0; - info->repeat = RepeatUndefined; + keyi->numLevels[i] = 0; + keyi->types[i] = XKB_ATOM_NONE; + darray_free(keyi->syms[i]); + darray_free(keyi->symsMapIndex[i]); + darray_free(keyi->symsMapNumEntries[i]); + darray_free(keyi->acts[i]); + } + keyi->dfltType = XKB_ATOM_NONE; + keyi->behavior.type = XkbKB_Default; + keyi->behavior.data = 0; + keyi->vmodmap = 0; + keyi->repeat = RepeatUndefined; } /** @@ -232,11 +234,11 @@ InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap, static void FreeSymbolsInfo(SymbolsInfo * info) { - KeyInfo *key; + KeyInfo *keyi; free(info->name); - darray_foreach(key, info->keys) - FreeKeyInfo(key); + darray_foreach(keyi, info->keys) + FreeKeyInfo(keyi); darray_free(info->keys); if (info->modMap) ClearCommonInfo(&info->modMap->defs); @@ -246,32 +248,32 @@ FreeSymbolsInfo(SymbolsInfo * info) } static bool -ResizeKeyGroup(KeyInfo * key, unsigned int group, unsigned int numLevels, +ResizeKeyGroup(KeyInfo *keyi, unsigned int group, unsigned int numLevels, unsigned sizeSyms, bool forceActions) { int i; - if (darray_size(key->syms[group]) < sizeSyms) - darray_resize0(key->syms[group], sizeSyms); + if (darray_size(keyi->syms[group]) < sizeSyms) + darray_resize0(keyi->syms[group], sizeSyms); - if (darray_empty(key->symsMapIndex[group]) || - key->numLevels[group] < numLevels) { - darray_resize(key->symsMapIndex[group], numLevels); - for (i = key->numLevels[group]; i < numLevels; i++) - darray_item(key->symsMapIndex[group], i) = -1; + if (darray_empty(keyi->symsMapIndex[group]) || + keyi->numLevels[group] < numLevels) { + darray_resize(keyi->symsMapIndex[group], numLevels); + for (i = keyi->numLevels[group]; i < numLevels; i++) + darray_item(keyi->symsMapIndex[group], i) = -1; } - if (darray_empty(key->symsMapNumEntries[group]) || - key->numLevels[group] < numLevels) - darray_resize0(key->symsMapNumEntries[group], numLevels); + if (darray_empty(keyi->symsMapNumEntries[group]) || + keyi->numLevels[group] < numLevels) + darray_resize0(keyi->symsMapNumEntries[group], numLevels); - if ((forceActions && (key->numLevels[group] < numLevels || - darray_empty(key->acts[group]))) || - (key->numLevels[group] < numLevels && !darray_empty(key->acts[group]))) - darray_resize0(key->acts[group], numLevels); + if ((forceActions && (keyi->numLevels[group] < numLevels || + darray_empty(keyi->acts[group]))) || + (keyi->numLevels[group] < numLevels && !darray_empty(keyi->acts[group]))) + darray_resize0(keyi->acts[group], numLevels); - if (key->numLevels[group] < numLevels) - key->numLevels[group] = numLevels; + if (keyi->numLevels[group] < numLevels) + keyi->numLevels[group] = numLevels; return true; } @@ -594,23 +596,23 @@ MergeKeys(SymbolsInfo *info, struct xkb_keymap *keymap, } static bool -AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap) +AddKeySymbols(SymbolsInfo *info, KeyInfo *keyi, struct xkb_keymap *keymap) { unsigned long real_name; KeyInfo *iter, *new; darray_foreach(iter, info->keys) - if (iter->name == key->name) - return MergeKeys(info, keymap, iter, key); + if (iter->name == keyi->name) + return MergeKeys(info, keymap, iter, keyi); - if (FindKeyNameForAlias(keymap, key->name, &real_name)) + if (FindKeyNameForAlias(keymap, keyi->name, &real_name)) darray_foreach(iter, info->keys) - if (iter->name == real_name) - return MergeKeys(info, keymap, iter, key); + if (iter->name == real_name) + return MergeKeys(info, keymap, iter, keyi); darray_resize0(info->keys, darray_size(info->keys) + 1); new = &darray_item(info->keys, darray_size(info->keys) - 1); - return CopyKeyInfo(key, new, true); + return CopyKeyInfo(keyi, new, true); } static bool @@ -685,7 +687,7 @@ MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from, enum merge_mode merge, struct xkb_keymap *keymap) { unsigned int i; - KeyInfo *key; + KeyInfo *keyi; if (from->errorCount > 0) { into->errorCount += from->errorCount; @@ -703,11 +705,11 @@ MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from, } } - darray_foreach(key, from->keys) { + darray_foreach(keyi, from->keys) { if (merge != MERGE_DEFAULT) - key->defs.merge = merge; + keyi->defs.merge = merge; - if (!AddKeySymbols(into, key, keymap)) + if (!AddKeySymbols(into, keyi, keymap)) into->errorCount++; } @@ -818,7 +820,7 @@ HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap, #define ACTIONS 2 static bool -GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap, +GetGroupIndex(KeyInfo *keyi, struct xkb_keymap *keymap, ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn) { const char *name; @@ -833,9 +835,9 @@ GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap, int i; unsigned defined; if (what == SYMBOLS) - defined = key->symsDefined; + defined = keyi->symsDefined; else - defined = key->actsDefined; + defined = keyi->actsDefined; for (i = 0; i < XkbNumKbdGroups; i++) { if ((defined & (1 << i)) == 0) { @@ -844,13 +846,13 @@ GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap, } } ERROR("Too many groups of %s for key %s (max %d)\n", name, - longText(key->name), XkbNumKbdGroups + 1); + longText(keyi->name), XkbNumKbdGroups + 1); ACTION("Ignoring %s defined for extra groups\n", name); return false; } if (!ExprResolveGroup(keymap->ctx, arrayNdx, &tmp)) { ERROR("Illegal group index for %s of key %s\n", name, - longText(key->name)); + longText(keyi->name)); ACTION("Definition with non-integer array index ignored\n"); return false; } @@ -859,88 +861,88 @@ GetGroupIndex(KeyInfo *key, struct xkb_keymap *keymap, } static bool -AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap, +AddSymbolsToKey(KeyInfo *keyi, struct xkb_keymap *keymap, ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info) { unsigned ndx, nSyms, nLevels; unsigned int i; long j; - if (!GetGroupIndex(key, keymap, arrayNdx, SYMBOLS, &ndx)) + if (!GetGroupIndex(keyi, keymap, arrayNdx, SYMBOLS, &ndx)) return false; if (value == NULL) { - key->symsDefined |= (1 << ndx); + keyi->symsDefined |= (1 << ndx); return true; } if (value->op != ExprKeysymList) { ERROR("Expected a list of symbols, found %s\n", exprOpText(value->op)); ACTION("Ignoring symbols for group %d of %s\n", ndx + 1, - longText(key->name)); + longText(keyi->name)); return false; } - if (!darray_empty(key->syms[ndx])) { + if (!darray_empty(keyi->syms[ndx])) { ERROR("Symbols for key %s, group %d already defined\n", - longText(key->name), ndx + 1); + longText(keyi->name), ndx + 1); ACTION("Ignoring duplicate definition\n"); return false; } nSyms = darray_size(value->value.list.syms); nLevels = darray_size(value->value.list.symsMapIndex); - if ((key->numLevels[ndx] < nSyms || darray_empty(key->syms[ndx])) && - (!ResizeKeyGroup(key, ndx, nLevels, nSyms, false))) { + if ((keyi->numLevels[ndx] < nSyms || darray_empty(keyi->syms[ndx])) && + (!ResizeKeyGroup(keyi, ndx, nLevels, nSyms, false))) { WSGO("Could not resize group %d of key %s to contain %d levels\n", - ndx + 1, longText(key->name), nSyms); + ndx + 1, longText(keyi->name), nSyms); ACTION("Symbols lost\n"); return false; } - key->symsDefined |= (1 << ndx); + keyi->symsDefined |= (1 << ndx); for (i = 0; i < nLevels; i++) { - darray_item(key->symsMapIndex[ndx], i) = + darray_item(keyi->symsMapIndex[ndx], i) = darray_item(value->value.list.symsMapIndex, i); - darray_item(key->symsMapNumEntries[ndx], i) = + darray_item(keyi->symsMapNumEntries[ndx], i) = darray_item(value->value.list.symsNumEntries, i); - for (j = 0; j < darray_item(key->symsMapNumEntries[ndx], i); j++) { + for (j = 0; j < darray_item(keyi->symsMapNumEntries[ndx], i); j++) { /* FIXME: What's abort() doing here? */ - if (darray_item(key->symsMapIndex[ndx], i) + j >= nSyms) + if (darray_item(keyi->symsMapIndex[ndx], i) + j >= nSyms) abort(); if (!LookupKeysym(darray_item(value->value.list.syms, - darray_item(value->value.list. - symsMapIndex, i) + j), - &darray_item(key->syms[ndx], - darray_item(key->symsMapIndex[ndx], + darray_item(value->value.list.symsMapIndex, + i) + j), + &darray_item(keyi->syms[ndx], + darray_item(keyi->symsMapIndex[ndx], i) + j))) { WARN( "Could not resolve keysym %s for key %s, group %d (%s), level %d\n", darray_item(value->value.list.syms, i), - longText(key->name), + longText(keyi->name), ndx + 1, xkb_atom_text(keymap->ctx, info->groupNames[ndx]), nSyms); while (--j >= 0) - darray_item(key->syms[ndx], - darray_item(key->symsMapIndex[ndx], + darray_item(keyi->syms[ndx], + darray_item(keyi->symsMapIndex[ndx], i) + j) = XKB_KEY_NoSymbol; - darray_item(key->symsMapIndex[ndx], i) = -1; - darray_item(key->symsMapNumEntries[ndx], i) = 0; + darray_item(keyi->symsMapIndex[ndx], i) = -1; + darray_item(keyi->symsMapNumEntries[ndx], i) = 0; break; } - if (darray_item(key->symsMapNumEntries[ndx], i) == 1 && - darray_item(key->syms[ndx], - darray_item(key->symsMapIndex[ndx], + if (darray_item(keyi->symsMapNumEntries[ndx], i) == 1 && + darray_item(keyi->syms[ndx], + darray_item(keyi->symsMapIndex[ndx], i) + j) == XKB_KEY_NoSymbol) { - darray_item(key->symsMapIndex[ndx], i) = -1; - darray_item(key->symsMapNumEntries[ndx], i) = 0; + darray_item(keyi->symsMapIndex[ndx], i) = -1; + darray_item(keyi->symsMapNumEntries[ndx], i) = 0; } } } - for (j = key->numLevels[ndx] - 1; - j >= 0 && darray_item(key->symsMapNumEntries[ndx], j) == 0; j--) - key->numLevels[ndx]--; + for (j = keyi->numLevels[ndx] - 1; + j >= 0 && darray_item(keyi->symsMapNumEntries[ndx], j) == 0; j--) + keyi->numLevels[ndx]--; return true; } static bool -AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx, +AddActionsToKey(KeyInfo *keyi, struct xkb_keymap *keymap, ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info) { unsigned int i; @@ -948,22 +950,22 @@ AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx, ExprDef *act; struct xkb_any_action *toAct; - if (!GetGroupIndex(key, keymap, arrayNdx, ACTIONS, &ndx)) + if (!GetGroupIndex(keyi, keymap, arrayNdx, ACTIONS, &ndx)) return false; if (value == NULL) { - key->actsDefined |= (1 << ndx); + keyi->actsDefined |= (1 << ndx); return true; } if (value->op != ExprActionList) { WSGO("Bad expression type (%d) for action list value\n", value->op); ACTION("Ignoring actions for group %d of %s\n", ndx, - longText(key->name)); + longText(keyi->name)); return false; } - if (!darray_empty(key->acts[ndx])) { + if (!darray_empty(keyi->acts[ndx])) { WSGO("Actions for key %s, group %d already defined\n", - longText(key->name), ndx); + longText(keyi->name), ndx); return false; } for (nActs = 0, act = value->value.child; act != NULL; nActs++) { @@ -973,21 +975,21 @@ AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx, WSGO("Action list but not actions in AddActionsToKey\n"); return false; } - if ((key->numLevels[ndx] < nActs || darray_empty(key->acts[ndx])) && - !ResizeKeyGroup(key, ndx, nActs, nActs, true)) { + if ((keyi->numLevels[ndx] < nActs || darray_empty(keyi->acts[ndx])) && + !ResizeKeyGroup(keyi, ndx, nActs, nActs, true)) { WSGO("Could not resize group %d of key %s\n", ndx, - longText(key->name)); + longText(keyi->name)); ACTION("Actions lost\n"); return false; } - key->actsDefined |= (1 << ndx); + keyi->actsDefined |= (1 << ndx); - toAct = (struct xkb_any_action *) darray_mem(key->acts[ndx], 0); + toAct = (struct xkb_any_action *) darray_mem(keyi->acts[ndx], 0); act = value->value.child; for (i = 0; i < nActs; i++, toAct++) { if (!HandleActionDef(act, keymap, toAct, info->action)) { ERROR("Illegal action definition for %s\n", - longText(key->name)); + longText(keyi->name)); ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1); } act = (ExprDef *) act->common.next; @@ -1018,7 +1020,7 @@ static const LookupEntry repeatEntries[] = { }; static bool -SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, +SetSymbolsField(KeyInfo *keyi, struct xkb_keymap *keymap, char *field, ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info) { bool ok = true; @@ -1032,39 +1034,39 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, ACTION("Ignoring illegal type definition\n"); } if (arrayNdx == NULL) { - key->dfltType = xkb_atom_intern(keymap->ctx, tmp.str); - key->defs.defined |= _Key_Type_Dflt; + keyi->dfltType = xkb_atom_intern(keymap->ctx, tmp.str); + keyi->defs.defined |= _Key_Type_Dflt; } else if (!ExprResolveGroup(keymap->ctx, arrayNdx, &ndx)) { ERROR("Illegal group index for type of key %s\n", - longText(key->name)); + longText(keyi->name)); ACTION("Definition with non-integer array index ignored\n"); free(tmp.str); return false; } else { - key->types[ndx.uval - 1] = xkb_atom_intern(keymap->ctx, tmp.str); - key->typesDefined |= (1 << (ndx.uval - 1)); + keyi->types[ndx.uval - 1] = xkb_atom_intern(keymap->ctx, tmp.str); + keyi->typesDefined |= (1 << (ndx.uval - 1)); } free(tmp.str); } else if (strcasecmp(field, "symbols") == 0) - return AddSymbolsToKey(key, keymap, arrayNdx, value, info); + return AddSymbolsToKey(keyi, keymap, arrayNdx, value, info); else if (strcasecmp(field, "actions") == 0) - return AddActionsToKey(key, keymap, arrayNdx, value, info); + return AddActionsToKey(keyi, keymap, arrayNdx, value, info); else if ((strcasecmp(field, "vmods") == 0) || (strcasecmp(field, "virtualmods") == 0) || (strcasecmp(field, "virtualmodifiers") == 0)) { ok = ExprResolveVModMask(value, &tmp, keymap); if (ok) { - key->vmodmap = (tmp.uval >> 8); - key->defs.defined |= _Key_VModMap; + keyi->vmodmap = (tmp.uval >> 8); + keyi->defs.defined |= _Key_VModMap; } else { ERROR("Expected a virtual modifier mask, found %s\n", exprOpText(value->op)); ACTION("Ignoring virtual modifiers definition for key %s\n", - longText(key->name)); + longText(keyi->name)); } } else if ((strcasecmp(field, "locking") == 0) || @@ -1072,22 +1074,22 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, (strcasecmp(field, "locks") == 0)) { ok = ExprResolveEnum(keymap->ctx, value, &tmp, lockingEntries); if (ok) - key->behavior.type = tmp.uval; - key->defs.defined |= _Key_Behavior; + keyi->behavior.type = tmp.uval; + keyi->defs.defined |= _Key_Behavior; } else if ((strcasecmp(field, "radiogroup") == 0) || (strcasecmp(field, "permanentradiogroup") == 0) || (strcasecmp(field, "allownone") == 0)) { ERROR("Radio groups not supported\n"); ACTION("Ignoring radio group specification for key %s\n", - longText(key->name)); + longText(keyi->name)); return false; } else if (uStrCasePrefix("overlay", field) || uStrCasePrefix("permanentoverlay", field)) { ERROR("Overlays not supported\n"); ACTION("Ignoring overlay specification for key %s\n", - longText(key->name)); + longText(keyi->name)); } else if ((strcasecmp(field, "repeating") == 0) || (strcasecmp(field, "repeats") == 0) || @@ -1095,54 +1097,54 @@ SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field, ok = ExprResolveEnum(keymap->ctx, value, &tmp, repeatEntries); if (!ok) { ERROR("Illegal repeat setting for %s\n", - longText(key->name)); + longText(keyi->name)); ACTION("Non-boolean repeat setting ignored\n"); return false; } - key->repeat = tmp.uval; - key->defs.defined |= _Key_Repeat; + keyi->repeat = tmp.uval; + keyi->defs.defined |= _Key_Repeat; } else if ((strcasecmp(field, "groupswrap") == 0) || (strcasecmp(field, "wrapgroups") == 0)) { ok = ExprResolveBoolean(keymap->ctx, value, &tmp); if (!ok) { ERROR("Illegal groupsWrap setting for %s\n", - longText(key->name)); + longText(keyi->name)); ACTION("Non-boolean value ignored\n"); return false; } if (tmp.uval) - key->groupInfo = XkbWrapIntoRange; + keyi->groupInfo = XkbWrapIntoRange; else - key->groupInfo = XkbClampIntoRange; - key->defs.defined |= _Key_GroupInfo; + keyi->groupInfo = XkbClampIntoRange; + keyi->defs.defined |= _Key_GroupInfo; } else if ((strcasecmp(field, "groupsclamp") == 0) || (strcasecmp(field, "clampgroups") == 0)) { ok = ExprResolveBoolean(keymap->ctx, value, &tmp); if (!ok) { ERROR("Illegal groupsClamp setting for %s\n", - longText(key->name)); + longText(keyi->name)); ACTION("Non-boolean value ignored\n"); return false; } if (tmp.uval) - key->groupInfo = XkbClampIntoRange; + keyi->groupInfo = XkbClampIntoRange; else - key->groupInfo = XkbWrapIntoRange; - key->defs.defined |= _Key_GroupInfo; + keyi->groupInfo = XkbWrapIntoRange; + keyi->defs.defined |= _Key_GroupInfo; } else if ((strcasecmp(field, "groupsredirect") == 0) || (strcasecmp(field, "redirectgroups") == 0)) { if (!ExprResolveGroup(keymap->ctx, value, &tmp)) { ERROR("Illegal group index for redirect of key %s\n", - longText(key->name)); + longText(keyi->name)); ACTION("Definition with non-integer group ignored\n"); return false; } - key->groupInfo = + keyi->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1); - key->defs.defined |= _Key_GroupInfo; + keyi->defs.defined |= _Key_GroupInfo; } else { ERROR("Unknown field %s in a symbol interpretation\n", field); @@ -1236,7 +1238,7 @@ HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) } static bool -HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key, +HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *keyi, SymbolsInfo *info) { bool ok = true; @@ -1262,7 +1264,7 @@ HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key, &arrayNdx); } if (ok) - ok = SetSymbolsField(key, keymap, field.str, arrayNdx, + ok = SetSymbolsField(keyi, keymap, field.str, arrayNdx, def->value, info); free(field.str); } @@ -1271,40 +1273,40 @@ HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key, } static bool -SetExplicitGroup(SymbolsInfo *info, KeyInfo *key) +SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi) { unsigned group = info->explicit_group; if (group == 0) return true; - if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1) { + if ((keyi->typesDefined | keyi->symsDefined | keyi->actsDefined) & ~1) { int i; WARN("For the map %s an explicit group specified\n", info->name); WARN("but key %s has more than one group defined\n", - longText(key->name)); + longText(keyi->name)); ACTION("All groups except first one will be ignored\n"); for (i = 1; i < XkbNumKbdGroups; i++) { - key->numLevels[i] = 0; - darray_free(key->syms[i]); - darray_free(key->acts[i]); - key->types[i] = 0; - } - } - key->typesDefined = key->symsDefined = key->actsDefined = 1 << group; - - key->numLevels[group] = key->numLevels[0]; - key->numLevels[0] = 0; - key->syms[group] = key->syms[0]; - darray_init(key->syms[0]); - key->symsMapIndex[group] = key->symsMapIndex[0]; - darray_init(key->symsMapIndex[0]); - key->symsMapNumEntries[group] = key->symsMapNumEntries[0]; - darray_init(key->symsMapNumEntries[0]); - key->acts[group] = key->acts[0]; - darray_init(key->acts[0]); - key->types[group] = key->types[0]; - key->types[0] = 0; + keyi->numLevels[i] = 0; + darray_free(keyi->syms[i]); + darray_free(keyi->acts[i]); + keyi->types[i] = 0; + } + } + keyi->typesDefined = keyi->symsDefined = keyi->actsDefined = 1 << group; + + keyi->numLevels[group] = keyi->numLevels[0]; + keyi->numLevels[0] = 0; + keyi->syms[group] = keyi->syms[0]; + darray_init(keyi->syms[0]); + keyi->symsMapIndex[group] = keyi->symsMapIndex[0]; + darray_init(keyi->symsMapIndex[0]); + keyi->symsMapNumEntries[group] = keyi->symsMapNumEntries[0]; + darray_init(keyi->symsMapNumEntries[0]); + keyi->acts[group] = keyi->acts[0]; + darray_init(keyi->acts[0]); + keyi->types[group] = keyi->types[0]; + keyi->types[0] = 0; return true; } @@ -1312,23 +1314,23 @@ static int HandleSymbolsDef(SymbolsDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info) { - KeyInfo key; + KeyInfo keyi; - InitKeyInfo(&key, info->file_id); - CopyKeyInfo(&info->dflt, &key, false); - key.defs.merge = stmt->merge; - key.name = KeyNameToLong(stmt->keyName); - if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &key, info)) { + InitKeyInfo(&keyi, info->file_id); + CopyKeyInfo(&info->dflt, &keyi, false); + keyi.defs.merge = stmt->merge; + keyi.name = KeyNameToLong(stmt->keyName); + if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &keyi, info)) { info->errorCount++; return false; } - if (!SetExplicitGroup(info, &key)) { + if (!SetExplicitGroup(info, &keyi)) { info->errorCount++; return false; } - if (!AddKeySymbols(info, &key, keymap)) { + if (!AddKeySymbols(info, &keyi, keymap)) { info->errorCount++; return false; } @@ -1576,12 +1578,12 @@ FindAutomaticType(struct xkb_keymap *keymap, int width, * groups, and reduce to one group if all groups are identical anyway. */ static void -PrepareKeyDef(KeyInfo * key) +PrepareKeyDef(KeyInfo *keyi) { int i, j, width, defined, lastGroup; bool identical; - defined = key->symsDefined | key->actsDefined | key->typesDefined; + defined = keyi->symsDefined | keyi->actsDefined | keyi->typesDefined; /* get highest group number */ for (i = XkbNumKbdGroups - 1; i >= 0; i--) { if (defined & (1 << i)) @@ -1598,85 +1600,86 @@ PrepareKeyDef(KeyInfo * key) for (i = lastGroup; i > 0; i--) { if (defined & (1 << i)) continue; - width = key->numLevels[0]; - if (key->typesDefined & 1) { + width = keyi->numLevels[0]; + if (keyi->typesDefined & 1) { for (j = 0; j < width; j++) { - key->types[i] = key->types[0]; + keyi->types[i] = keyi->types[0]; } - key->typesDefined |= 1 << i; + keyi->typesDefined |= 1 << i; } - if ((key->actsDefined & 1) && !darray_empty(key->acts[0])) { - darray_copy(key->acts[i], key->acts[0]); - key->actsDefined |= 1 << i; + if ((keyi->actsDefined & 1) && !darray_empty(keyi->acts[0])) { + darray_copy(keyi->acts[i], keyi->acts[0]); + keyi->actsDefined |= 1 << i; } - if ((key->symsDefined & 1) && !darray_empty(key->syms[0])) { - darray_copy(key->syms[i], key->syms[0]); - darray_copy(key->symsMapIndex[i], key->symsMapIndex[0]); - darray_copy(key->symsMapNumEntries[i], key->symsMapNumEntries[0]); - key->symsDefined |= 1 << i; + if ((keyi->symsDefined & 1) && !darray_empty(keyi->syms[0])) { + darray_copy(keyi->syms[i], keyi->syms[0]); + darray_copy(keyi->symsMapIndex[i], keyi->symsMapIndex[0]); + darray_copy(keyi->symsMapNumEntries[i], + keyi->symsMapNumEntries[0]); + keyi->symsDefined |= 1 << i; } if (defined & 1) { - key->numLevels[i] = key->numLevels[0]; + keyi->numLevels[i] = keyi->numLevels[0]; } } /* If all groups are completely identical remove them all */ /* exept the first one. */ identical = true; for (i = lastGroup; i > 0; i--) { - if ((key->numLevels[i] != key->numLevels[0]) || - (key->types[i] != key->types[0])) { + if ((keyi->numLevels[i] != keyi->numLevels[0]) || + (keyi->types[i] != keyi->types[0])) { identical = false; break; } - if (!darray_same(key->syms[i], key->syms[0]) && - (darray_empty(key->syms[i]) || darray_empty(key->syms[0]) || - darray_size(key->syms[i]) != darray_size(key->syms[0]) || - memcmp(darray_mem(key->syms[i], 0), - darray_mem(key->syms[0], 0), - sizeof(xkb_keysym_t) * darray_size(key->syms[0])))) { + if (!darray_same(keyi->syms[i], keyi->syms[0]) && + (darray_empty(keyi->syms[i]) || darray_empty(keyi->syms[0]) || + darray_size(keyi->syms[i]) != darray_size(keyi->syms[0]) || + memcmp(darray_mem(keyi->syms[i], 0), + darray_mem(keyi->syms[0], 0), + sizeof(xkb_keysym_t) * darray_size(keyi->syms[0])))) { identical = false; break; } - if (!darray_same(key->symsMapIndex[i], key->symsMapIndex[0]) && - (darray_empty(key->symsMapIndex[i]) || - darray_empty(key->symsMapIndex[0]) || - memcmp(darray_mem(key->symsMapIndex[i], 0), - darray_mem(key->symsMapIndex[0], 0), - key->numLevels[0] * sizeof(int)))) { + if (!darray_same(keyi->symsMapIndex[i], keyi->symsMapIndex[0]) && + (darray_empty(keyi->symsMapIndex[i]) || + darray_empty(keyi->symsMapIndex[0]) || + memcmp(darray_mem(keyi->symsMapIndex[i], 0), + darray_mem(keyi->symsMapIndex[0], 0), + keyi->numLevels[0] * sizeof(int)))) { identical = false; continue; } - if (!darray_same(key->symsMapNumEntries[i], - key->symsMapNumEntries[0]) && - (darray_empty(key->symsMapNumEntries[i]) || - darray_empty(key->symsMapNumEntries[0]) || - memcmp(darray_mem(key->symsMapNumEntries[i], 0), - darray_mem(key->symsMapNumEntries[0], 0), - key->numLevels[0] * sizeof(size_t)))) { + if (!darray_same(keyi->symsMapNumEntries[i], + keyi->symsMapNumEntries[0]) && + (darray_empty(keyi->symsMapNumEntries[i]) || + darray_empty(keyi->symsMapNumEntries[0]) || + memcmp(darray_mem(keyi->symsMapNumEntries[i], 0), + darray_mem(keyi->symsMapNumEntries[0], 0), + keyi->numLevels[0] * sizeof(size_t)))) { identical = false; continue; } - if (!darray_same(key->acts[i], key->acts[0]) && - (darray_empty(key->acts[i]) || darray_empty(key->acts[0]) || - memcmp(darray_mem(key->acts[i], 0), - darray_mem(key->acts[0], 0), - key->numLevels[0] * sizeof(union xkb_action)))) { + if (!darray_same(keyi->acts[i], keyi->acts[0]) && + (darray_empty(keyi->acts[i]) || darray_empty(keyi->acts[0]) || + memcmp(darray_mem(keyi->acts[i], 0), + darray_mem(keyi->acts[0], 0), + keyi->numLevels[0] * sizeof(union xkb_action)))) { identical = false; break; } } if (identical) { for (i = lastGroup; i > 0; i--) { - key->numLevels[i] = 0; - darray_free(key->syms[i]); - darray_free(key->symsMapIndex[i]); - darray_free(key->symsMapNumEntries[i]); - darray_free(key->acts[i]); - key->types[i] = 0; + keyi->numLevels[i] = 0; + darray_free(keyi->syms[i]); + darray_free(keyi->symsMapIndex[i]); + darray_free(keyi->symsMapNumEntries[i]); + darray_free(keyi->acts[i]); + keyi->types[i] = 0; } - key->symsDefined &= 1; - key->actsDefined &= 1; - key->typesDefined &= 1; + keyi->symsDefined &= 1; + keyi->actsDefined &= 1; + keyi->typesDefined &= 1; } } @@ -1686,7 +1689,7 @@ PrepareKeyDef(KeyInfo * key) * This function recurses. */ static bool -CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) +CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *keyi, int start_from) { unsigned int i; xkb_keycode_t kc; @@ -1702,10 +1705,10 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) useAlias = (start_from == 0); /* get the keycode for the key. */ - if (!FindNamedKey(keymap, key->name, &kc, useAlias, + if (!FindNamedKey(keymap, keyi->name, &kc, useAlias, CreateKeyNames(keymap), start_from)) { if ((start_from == 0) && (warningLevel >= 5)) { - WARN("Key %s not found in keycodes\n", longText(key->name)); + WARN("Key %s not found in keycodes\n", longText(keyi->name)); ACTION("Symbols ignored\n"); } return false; @@ -1714,70 +1717,70 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) haveActions = false; for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++) { if (((i + 1) > nGroups) - && (((key->symsDefined | key->actsDefined) & (1 << i)) - || (key->typesDefined) & (1 << i))) + && (((keyi->symsDefined | keyi->actsDefined) & (1 << i)) + || (keyi->typesDefined) & (1 << i))) nGroups = i + 1; - if (!darray_empty(key->acts[i])) + if (!darray_empty(keyi->acts[i])) haveActions = true; autoType = false; /* Assign the type to the key, if it is missing. */ - if (key->types[i] == XKB_ATOM_NONE) { - if (key->dfltType != XKB_ATOM_NONE) - key->types[i] = key->dfltType; - else if (FindAutomaticType(keymap, key->numLevels[i], - darray_mem(key->syms[i], 0), - &key->types[i], &autoType)) { } + if (keyi->types[i] == XKB_ATOM_NONE) { + if (keyi->dfltType != XKB_ATOM_NONE) + keyi->types[i] = keyi->dfltType; + else if (FindAutomaticType(keymap, keyi->numLevels[i], + darray_mem(keyi->syms[i], 0), + &keyi->types[i], &autoType)) { } else { if (warningLevel >= 5) { WARN("No automatic type for %d symbols\n", - (unsigned int) key->numLevels[i]); + (unsigned int) keyi->numLevels[i]); ACTION("Using %s for the %s key (keycode %d)\n", - xkb_atom_text(keymap->ctx, key->types[i]), - longText(key->name), kc); + xkb_atom_text(keymap->ctx, keyi->types[i]), + longText(keyi->name), kc); } } } - if (FindNamedType(keymap, key->types[i], &types[i])) { - if (!autoType || key->numLevels[i] > 2) + if (FindNamedType(keymap, keyi->types[i], &types[i])) { + if (!autoType || keyi->numLevels[i] > 2) keymap->explicit[kc] |= (1 << i); } else { if (warningLevel >= 3) { WARN("Type \"%s\" is not defined\n", - xkb_atom_text(keymap->ctx, key->types[i])); + xkb_atom_text(keymap->ctx, keyi->types[i])); ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n", - longText(key->name), kc); + longText(keyi->name), kc); } types[i] = XkbTwoLevelIndex; } /* if the type specifies fewer levels than the key has, shrink the key */ type = &darray_item(keymap->types, types[i]); - if (type->num_levels < key->numLevels[i]) { + if (type->num_levels < keyi->numLevels[i]) { if (warningLevel > 0) { WARN("Type \"%s\" has %d levels, but %s has %d symbols\n", type->name, type->num_levels, - xkb_atom_text(keymap->ctx, key->name), key->numLevels[i]); + xkb_atom_text(keymap->ctx, keyi->name), keyi->numLevels[i]); ACTION("Ignoring extra symbols\n"); } - key->numLevels[i] = type->num_levels; + keyi->numLevels[i] = type->num_levels; } - if (key->numLevels[i] > width) - width = key->numLevels[i]; + if (keyi->numLevels[i] > width) + width = keyi->numLevels[i]; if (type->num_levels > width) width = type->num_levels; - sizeSyms += darray_size(key->syms[i]); + sizeSyms += darray_size(keyi->syms[i]); } if (!XkbcResizeKeySyms(keymap, kc, sizeSyms)) { WSGO("Could not enlarge symbols for %s (keycode %d)\n", - longText(key->name), kc); + longText(keyi->name), kc); return false; } if (haveActions) { outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups); if (outActs == NULL) { WSGO("Could not enlarge actions for %s (key %d)\n", - longText(key->name), kc); + longText(keyi->name), kc); return false; } keymap->explicit[kc] |= XkbExplicitInterpretMask; @@ -1787,8 +1790,8 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) sym_map = &darray_item(keymap->key_sym_map, kc); - if (key->defs.defined & _Key_GroupInfo) - i = key->groupInfo; + if (keyi->defs.defined & _Key_GroupInfo) + i = keyi->groupInfo; else i = sym_map->group_info; @@ -1805,51 +1808,51 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) * * FIXME: There should be a better fix for this. */ - if (key->numLevels[i]) + if (keyi->numLevels[i]) sym_map->kt_index[i] = types[i]; - if (!darray_empty(key->syms[i])) { + if (!darray_empty(keyi->syms[i])) { /* fill key to "width" symbols*/ for (tmp = 0; tmp < width; tmp++) { - if (tmp < key->numLevels[i] && - darray_item(key->symsMapNumEntries[i], tmp) != 0) { + if (tmp < keyi->numLevels[i] && + darray_item(keyi->symsMapNumEntries[i], tmp) != 0) { memcpy(darray_mem(sym_map->syms, symIndex), - darray_mem(key->syms[i], - darray_item(key->symsMapIndex[i], tmp)), - darray_item(key->symsMapNumEntries[i], + darray_mem(keyi->syms[i], + darray_item(keyi->symsMapIndex[i], tmp)), + darray_item(keyi->symsMapNumEntries[i], tmp) * sizeof(xkb_keysym_t)); sym_map->sym_index[(i * width) + tmp] = symIndex; sym_map->num_syms[(i * width) + tmp] = - darray_item(key->symsMapNumEntries[i], tmp); + darray_item(keyi->symsMapNumEntries[i], tmp); symIndex += sym_map->num_syms[(i * width) + tmp]; } else { sym_map->sym_index[(i * width) + tmp] = -1; sym_map->num_syms[(i * width) + tmp] = 0; } - if (outActs != NULL && !darray_empty(key->acts[i])) { - if (tmp < key->numLevels[i]) - outActs[tmp] = darray_item(key->acts[i], tmp); + if (outActs != NULL && !darray_empty(keyi->acts[i])) { + if (tmp < keyi->numLevels[i]) + outActs[tmp] = darray_item(keyi->acts[i], tmp); else outActs[tmp].type = XkbSA_NoAction; } } } } - switch (key->behavior.type & XkbKB_OpMask) { + switch (keyi->behavior.type & XkbKB_OpMask) { case XkbKB_Default: break; default: - keymap->behaviors[kc] = key->behavior; + keymap->behaviors[kc] = keyi->behavior; keymap->explicit[kc] |= XkbExplicitBehaviorMask; break; } - if (key->defs.defined & _Key_VModMap) { - keymap->vmodmap[kc] = key->vmodmap; + if (keyi->defs.defined & _Key_VModMap) { + keymap->vmodmap[kc] = keyi->vmodmap; keymap->explicit[kc] |= XkbExplicitVModMapMask; } - if (key->repeat != RepeatUndefined) { - if (key->repeat == RepeatYes) + if (keyi->repeat != RepeatUndefined) { + if (keyi->repeat == RepeatYes) keymap->per_key_repeat[kc / 8] |= (1 << (kc % 8)); else keymap->per_key_repeat[kc / 8] &= ~(1 << (kc % 8)); @@ -1857,7 +1860,7 @@ CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from) } /* do the same thing for the next key */ - CopySymbolsDef(keymap, key, kc + 1); + CopySymbolsDef(keymap, keyi, kc + 1); return true; } @@ -1939,7 +1942,7 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, bool ok; xkb_keycode_t kc; SymbolsInfo info; - KeyInfo *key; + KeyInfo *keyi; InitSymbolsInfo(&info, keymap, file->id); info.dflt.defs.merge = merge; @@ -1971,13 +1974,13 @@ CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, } /* sanitize keys */ - darray_foreach(key, info.keys) - PrepareKeyDef(key); + darray_foreach(keyi, info.keys) + PrepareKeyDef(keyi); /* copy! */ - darray_foreach(key, info.keys) - if (!CopySymbolsDef(keymap, key, 0)) - info.errorCount++; + darray_foreach(keyi, info.keys) + if (!CopySymbolsDef(keymap, keyi, 0)) + info.errorCount++; if (warningLevel > 3) { for (kc = keymap->min_key_code; kc <= keymap->max_key_code; kc++) {