| /************************************************************ |
| * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc. |
| * |
| * Permission to use, copy, modify, and distribute this |
| * software and its documentation for any purpose and without |
| * fee is hereby granted, provided that the above copyright |
| * notice appear in all copies and that both that copyright |
| * notice and this permission notice appear in supporting |
| * documentation, and that the name of Silicon Graphics not be |
| * used in advertising or publicity pertaining to distribution |
| * of the software without specific prior written permission. |
| * Silicon Graphics makes no representation about the suitability |
| * of this software for any purpose. It is provided "as is" |
| * without any express or implied warranty. |
| * |
| * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS |
| * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
| * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON |
| * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
| * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE |
| * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH |
| * THE USE OR PERFORMANCE OF THIS SOFTWARE. |
| * |
| ********************************************************/ |
| |
| #include "xkbcomp-priv.h" |
| #include "text.h" |
| #include "vmod.h" |
| #include "expr.h" |
| #include "include.h" |
| |
| enum type_field { |
| TYPE_FIELD_MASK = (1 << 0), |
| TYPE_FIELD_MAP = (1 << 1), |
| TYPE_FIELD_PRESERVE = (1 << 2), |
| TYPE_FIELD_LEVEL_NAME = (1 << 3), |
| }; |
| |
| typedef struct { |
| enum type_field defined; |
| enum merge_mode merge; |
| |
| xkb_atom_t name; |
| xkb_mod_mask_t mods; |
| xkb_level_index_t num_levels; |
| darray(struct xkb_key_type_entry) entries; |
| darray(xkb_atom_t) level_names; |
| } KeyTypeInfo; |
| |
| typedef struct { |
| char *name; |
| int errorCount; |
| |
| darray(KeyTypeInfo) types; |
| struct xkb_mod_set mods; |
| |
| struct xkb_context *ctx; |
| } KeyTypesInfo; |
| |
| /***====================================================================***/ |
| |
| static inline const char * |
| MapEntryTxt(KeyTypesInfo *info, struct xkb_key_type_entry *entry) |
| { |
| return ModMaskText(info->ctx, &info->mods, entry->mods.mods); |
| } |
| |
| static inline const char * |
| TypeTxt(KeyTypesInfo *info, KeyTypeInfo *type) |
| { |
| return xkb_atom_text(info->ctx, type->name); |
| } |
| |
| static inline const char * |
| TypeMaskTxt(KeyTypesInfo *info, KeyTypeInfo *type) |
| { |
| return ModMaskText(info->ctx, &info->mods, type->mods); |
| } |
| |
| static inline bool |
| ReportTypeShouldBeArray(KeyTypesInfo *info, KeyTypeInfo *type, |
| const char *field) |
| { |
| return ReportShouldBeArray(info->ctx, "key type", field, |
| TypeTxt(info, type)); |
| } |
| |
| static inline bool |
| ReportTypeBadType(KeyTypesInfo *info, KeyTypeInfo *type, |
| const char *field, const char *wanted) |
| { |
| return ReportBadType(info->ctx, "key type", field, |
| TypeTxt(info, type), wanted); |
| } |
| |
| /***====================================================================***/ |
| |
| static void |
| InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_context *ctx, |
| const struct xkb_mod_set *mods) |
| { |
| memset(info, 0, sizeof(*info)); |
| info->ctx = ctx; |
| info->mods = *mods; |
| } |
| |
| static void |
| ClearKeyTypeInfo(KeyTypeInfo *type) |
| { |
| darray_free(type->entries); |
| darray_free(type->level_names); |
| } |
| |
| static void |
| ClearKeyTypesInfo(KeyTypesInfo *info) |
| { |
| free(info->name); |
| darray_free(info->types); |
| } |
| |
| static KeyTypeInfo * |
| FindMatchingKeyType(KeyTypesInfo *info, xkb_atom_t name) |
| { |
| KeyTypeInfo *old; |
| |
| darray_foreach(old, info->types) |
| if (old->name == name) |
| return old; |
| |
| return NULL; |
| } |
| |
| static bool |
| AddKeyType(KeyTypesInfo *info, KeyTypeInfo *new, bool same_file) |
| { |
| KeyTypeInfo *old; |
| const int verbosity = xkb_context_get_log_verbosity(info->ctx); |
| |
| old = FindMatchingKeyType(info, new->name); |
| if (old) { |
| if (new->merge == MERGE_REPLACE || new->merge == MERGE_OVERRIDE) { |
| if ((same_file && verbosity > 0) || verbosity > 9) { |
| log_warn(info->ctx, |
| "Multiple definitions of the %s key type; " |
| "Earlier definition ignored\n", |
| xkb_atom_text(info->ctx, new->name)); |
| } |
| |
| ClearKeyTypeInfo(old); |
| *old = *new; |
| darray_init(new->entries); |
| darray_init(new->level_names); |
| return true; |
| } |
| |
| if (same_file) |
| log_vrb(info->ctx, 4, |
| "Multiple definitions of the %s key type; " |
| "Later definition ignored\n", |
| xkb_atom_text(info->ctx, new->name)); |
| |
| ClearKeyTypeInfo(new); |
| return true; |
| } |
| |
| darray_append(info->types, *new); |
| return true; |
| } |
| |
| /***====================================================================***/ |
| |
| static void |
| MergeIncludedKeyTypes(KeyTypesInfo *into, KeyTypesInfo *from, |
| enum merge_mode merge) |
| { |
| KeyTypeInfo *type; |
| |
| if (from->errorCount > 0) { |
| into->errorCount += from->errorCount; |
| return; |
| } |
| |
| into->mods = from->mods; |
| |
| if (into->name == NULL) { |
| into->name = from->name; |
| from->name = NULL; |
| } |
| |
| if (darray_empty(into->types)) { |
| into->types = from->types; |
| darray_init(from->types); |
| } |
| else { |
| darray_foreach(type, from->types) { |
| type->merge = (merge == MERGE_DEFAULT ? type->merge : merge); |
| if (!AddKeyType(into, type, false)) |
| into->errorCount++; |
| } |
| } |
| } |
| |
| static void |
| HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge); |
| |
| static bool |
| HandleIncludeKeyTypes(KeyTypesInfo *info, IncludeStmt *include) |
| { |
| KeyTypesInfo included; |
| |
| InitKeyTypesInfo(&included, info->ctx, &info->mods); |
| included.name = include->stmt; |
| include->stmt = NULL; |
| |
| for (IncludeStmt *stmt = include; stmt; stmt = stmt->next_incl) { |
| KeyTypesInfo next_incl; |
| XkbFile *file; |
| |
| file = ProcessIncludeFile(info->ctx, stmt, FILE_TYPE_TYPES); |
| if (!file) { |
| info->errorCount += 10; |
| ClearKeyTypesInfo(&included); |
| return false; |
| } |
| |
| InitKeyTypesInfo(&next_incl, info->ctx, &included.mods); |
| |
| HandleKeyTypesFile(&next_incl, file, stmt->merge); |
| |
| MergeIncludedKeyTypes(&included, &next_incl, stmt->merge); |
| |
| ClearKeyTypesInfo(&next_incl); |
| FreeXkbFile(file); |
| } |
| |
| MergeIncludedKeyTypes(info, &included, include->merge); |
| ClearKeyTypesInfo(&included); |
| |
| return (info->errorCount == 0); |
| } |
| |
| /***====================================================================***/ |
| |
| static bool |
| SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx, |
| ExprDef *value) |
| { |
| xkb_mod_mask_t mods; |
| |
| if (arrayNdx) |
| log_warn(info->ctx, |
| "The modifiers field of a key type is not an array; " |
| "Illegal array subscript ignored\n"); |
| |
| if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, &mods)) { |
| log_err(info->ctx, |
| "Key type mask field must be a modifier mask; " |
| "Key type definition ignored\n"); |
| return false; |
| } |
| |
| if (type->defined & TYPE_FIELD_MASK) { |
| log_warn(info->ctx, |
| "Multiple modifier mask definitions for key type %s; " |
| "Using %s, ignoring %s\n", |
| xkb_atom_text(info->ctx, type->name), |
| TypeMaskTxt(info, type), |
| ModMaskText(info->ctx, &info->mods, mods)); |
| return false; |
| } |
| |
| type->mods = mods; |
| return true; |
| } |
| |
| /***====================================================================***/ |
| |
| static struct xkb_key_type_entry * |
| FindMatchingMapEntry(KeyTypeInfo *type, xkb_mod_mask_t mods) |
| { |
| struct xkb_key_type_entry *entry; |
| |
| darray_foreach(entry, type->entries) |
| if (entry->mods.mods == mods) |
| return entry; |
| |
| return NULL; |
| } |
| |
| static bool |
| AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, |
| struct xkb_key_type_entry *new, bool clobber, bool report) |
| { |
| struct xkb_key_type_entry *old; |
| |
| old = FindMatchingMapEntry(type, new->mods.mods); |
| if (old) { |
| if (report && old->level != new->level) { |
| log_warn(info->ctx, |
| "Multiple map entries for %s in %s; " |
| "Using %d, ignoring %d\n", |
| MapEntryTxt(info, new), TypeTxt(info, type), |
| (clobber ? new->level : old->level) + 1, |
| (clobber ? old->level : new->level) + 1); |
| } |
| else { |
| log_vrb(info->ctx, 10, |
| "Multiple occurrences of map[%s]= %d in %s; Ignored\n", |
| MapEntryTxt(info, new), new->level + 1, |
| TypeTxt(info, type)); |
| return true; |
| } |
| |
| if (clobber) { |
| if (new->level >= type->num_levels) |
| type->num_levels = new->level + 1; |
| old->level = new->level; |
| } |
| |
| return true; |
| } |
| |
| if (new->level >= type->num_levels) |
| type->num_levels = new->level + 1; |
| |
| darray_append(type->entries, *new); |
| return true; |
| } |
| |
| static bool |
| SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx, |
| ExprDef *value) |
| { |
| struct xkb_key_type_entry entry; |
| |
| if (arrayNdx == NULL) |
| return ReportTypeShouldBeArray(info, type, "map entry"); |
| |
| if (!ExprResolveModMask(info->ctx, arrayNdx, MOD_BOTH, &info->mods, |
| &entry.mods.mods)) |
| return ReportTypeBadType(info, type, "map entry", "modifier mask"); |
| |
| if (entry.mods.mods & (~type->mods)) { |
| log_vrb(info->ctx, 1, |
| "Map entry for unused modifiers in %s; " |
| "Using %s instead of %s\n", |
| TypeTxt(info, type), |
| ModMaskText(info->ctx, &info->mods, |
| entry.mods.mods & type->mods), |
| MapEntryTxt(info, &entry)); |
| entry.mods.mods &= type->mods; |
| } |
| |
| if (!ExprResolveLevel(info->ctx, value, &entry.level)) { |
| log_err(info->ctx, |
| "Level specifications in a key type must be integer; " |
| "Ignoring malformed level specification\n"); |
| return false; |
| } |
| |
| entry.preserve.mods = 0; |
| |
| return AddMapEntry(info, type, &entry, true, true); |
| } |
| |
| /***====================================================================***/ |
| |
| static bool |
| AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type, |
| xkb_mod_mask_t mods, xkb_mod_mask_t preserve_mods) |
| { |
| struct xkb_key_type_entry *entry; |
| struct xkb_key_type_entry new; |
| |
| darray_foreach(entry, type->entries) { |
| if (entry->mods.mods != mods) |
| continue; |
| |
| /* Map exists without previous preserve (or "None"); override. */ |
| if (entry->preserve.mods == 0) { |
| entry->preserve.mods = preserve_mods; |
| return true; |
| } |
| |
| /* Map exists with same preserve; do nothing. */ |
| if (entry->preserve.mods == preserve_mods) { |
| log_vrb(info->ctx, 10, |
| "Identical definitions for preserve[%s] in %s; " |
| "Ignored\n", |
| ModMaskText(info->ctx, &info->mods, mods), |
| TypeTxt(info, type)); |
| return true; |
| } |
| |
| /* Map exists with different preserve; latter wins. */ |
| log_vrb(info->ctx, 1, |
| "Multiple definitions for preserve[%s] in %s; " |
| "Using %s, ignoring %s\n", |
| ModMaskText(info->ctx, &info->mods, mods), |
| TypeTxt(info, type), |
| ModMaskText(info->ctx, &info->mods, preserve_mods), |
| ModMaskText(info->ctx, &info->mods, entry->preserve.mods)); |
| |
| entry->preserve.mods = preserve_mods; |
| return true; |
| } |
| |
| /* |
| * Map does not exist, i.e. preserve[] came before map[]. |
| * Create a map with the specified mask mapping to Level1. The level |
| * may be overridden later with an explicit map[] statement. |
| */ |
| new.level = 0; |
| new.mods.mods = mods; |
| new.preserve.mods = preserve_mods; |
| darray_append(type->entries, new); |
| return true; |
| } |
| |
| static bool |
| SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx, |
| ExprDef *value) |
| { |
| xkb_mod_mask_t mods, preserve_mods; |
| |
| if (arrayNdx == NULL) |
| return ReportTypeShouldBeArray(info, type, "preserve entry"); |
| |
| if (!ExprResolveModMask(info->ctx, arrayNdx, MOD_BOTH, &info->mods, &mods)) |
| return ReportTypeBadType(info, type, "preserve entry", |
| "modifier mask"); |
| |
| if (mods & ~type->mods) { |
| const char *before, *after; |
| |
| before = ModMaskText(info->ctx, &info->mods, mods); |
| mods &= type->mods; |
| after = ModMaskText(info->ctx, &info->mods, mods); |
| |
| log_vrb(info->ctx, 1, |
| "Preserve for modifiers not used by the %s type; " |
| "Index %s converted to %s\n", |
| TypeTxt(info, type), before, after); |
| } |
| |
| if (!ExprResolveModMask(info->ctx, value, MOD_BOTH, &info->mods, |
| &preserve_mods)) { |
| log_err(info->ctx, |
| "Preserve value in a key type is not a modifier mask; " |
| "Ignoring preserve[%s] in type %s\n", |
| ModMaskText(info->ctx, &info->mods, mods), |
| TypeTxt(info, type)); |
| return false; |
| } |
| |
| if (preserve_mods & ~mods) { |
| const char *before, *after; |
| |
| before = ModMaskText(info->ctx, &info->mods, preserve_mods); |
| preserve_mods &= mods; |
| after = ModMaskText(info->ctx, &info->mods, preserve_mods); |
| |
| log_vrb(info->ctx, 1, |
| "Illegal value for preserve[%s] in type %s; " |
| "Converted %s to %s\n", |
| ModMaskText(info->ctx, &info->mods, mods), |
| TypeTxt(info, type), before, after); |
| } |
| |
| return AddPreserve(info, type, mods, preserve_mods); |
| } |
| |
| /***====================================================================***/ |
| |
| static bool |
| AddLevelName(KeyTypesInfo *info, KeyTypeInfo *type, |
| xkb_level_index_t level, xkb_atom_t name, bool clobber) |
| { |
| /* New name. */ |
| if (level >= darray_size(type->level_names)) { |
| darray_resize0(type->level_names, level + 1); |
| goto finish; |
| } |
| |
| /* Same level, same name. */ |
| if (darray_item(type->level_names, level) == name) { |
| log_vrb(info->ctx, 10, |
| "Duplicate names for level %d of key type %s; Ignored\n", |
| level + 1, TypeTxt(info, type)); |
| return true; |
| } |
| |
| /* Same level, different name. */ |
| if (darray_item(type->level_names, level) != XKB_ATOM_NONE) { |
| const char *old, *new; |
| old = xkb_atom_text(info->ctx, |
| darray_item(type->level_names, level)); |
| new = xkb_atom_text(info->ctx, name); |
| log_vrb(info->ctx, 1, |
| "Multiple names for level %d of key type %s; " |
| "Using %s, ignoring %s\n", |
| level + 1, TypeTxt(info, type), |
| (clobber ? new : old), (clobber ? old : new)); |
| |
| if (!clobber) |
| return true; |
| } |
| |
| /* XXX: What about different level, same name? */ |
| |
| finish: |
| darray_item(type->level_names, level) = name; |
| return true; |
| } |
| |
| static bool |
| SetLevelName(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx, |
| ExprDef *value) |
| { |
| xkb_level_index_t level; |
| xkb_atom_t level_name; |
| |
| if (arrayNdx == NULL) |
| return ReportTypeShouldBeArray(info, type, "level name"); |
| |
| if (!ExprResolveLevel(info->ctx, arrayNdx, &level)) |
| return ReportTypeBadType(info, type, "level name", "integer"); |
| |
| if (!ExprResolveString(info->ctx, value, &level_name)) { |
| log_err(info->ctx, |
| "Non-string name for level %d in key type %s; " |
| "Ignoring illegal level name definition\n", |
| level + 1, xkb_atom_text(info->ctx, type->name)); |
| return false; |
| } |
| |
| return AddLevelName(info, type, level, level_name, true); |
| } |
| |
| /***====================================================================***/ |
| |
| static bool |
| SetKeyTypeField(KeyTypesInfo *info, KeyTypeInfo *type, |
| const char *field, ExprDef *arrayNdx, ExprDef *value) |
| { |
| bool ok = false; |
| enum type_field type_field = 0; |
| |
| if (istreq(field, "modifiers")) { |
| type_field = TYPE_FIELD_MASK; |
| ok = SetModifiers(info, type, arrayNdx, value); |
| } |
| else if (istreq(field, "map")) { |
| type_field = TYPE_FIELD_MAP; |
| ok = SetMapEntry(info, type, arrayNdx, value); |
| } |
| else if (istreq(field, "preserve")) { |
| type_field = TYPE_FIELD_PRESERVE; |
| ok = SetPreserve(info, type, arrayNdx, value); |
| } |
| else if (istreq(field, "levelname") || istreq(field, "level_name")) { |
| type_field = TYPE_FIELD_LEVEL_NAME; |
| ok = SetLevelName(info, type, arrayNdx, value); |
| } else { |
| log_err(info->ctx, |
| "Unknown field %s in key type %s; Definition ignored\n", |
| field, TypeTxt(info, type)); |
| } |
| |
| type->defined |= type_field; |
| return ok; |
| } |
| |
| static bool |
| HandleKeyTypeBody(KeyTypesInfo *info, VarDef *def, KeyTypeInfo *type) |
| { |
| bool ok = true; |
| const char *elem, *field; |
| ExprDef *arrayNdx; |
| |
| for (; def; def = (VarDef *) def->common.next) { |
| ok = ExprResolveLhs(info->ctx, def->name, &elem, &field, |
| &arrayNdx); |
| if (!ok) |
| continue; |
| |
| if (elem && istreq(elem, "type")) { |
| log_err(info->ctx, |
| "Support for changing the default type has been removed; " |
| "Statement ignored\n"); |
| continue; |
| } |
| |
| ok = SetKeyTypeField(info, type, field, arrayNdx, def->value); |
| } |
| |
| return ok; |
| } |
| |
| static bool |
| HandleKeyTypeDef(KeyTypesInfo *info, KeyTypeDef *def, enum merge_mode merge) |
| { |
| KeyTypeInfo type = { |
| .defined = 0, |
| .merge = (def->merge == MERGE_DEFAULT ? merge : def->merge), |
| .name = def->name, |
| .mods = 0, |
| .num_levels = 1, |
| .entries = darray_new(), |
| .level_names = darray_new(), |
| }; |
| |
| if (!HandleKeyTypeBody(info, def->body, &type)) { |
| info->errorCount++; |
| return false; |
| } |
| |
| if (!AddKeyType(info, &type, true)) { |
| info->errorCount++; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| static void |
| HandleKeyTypesFile(KeyTypesInfo *info, XkbFile *file, enum merge_mode merge) |
| { |
| bool ok; |
| |
| free(info->name); |
| info->name = strdup_safe(file->name); |
| |
| for (ParseCommon *stmt = file->defs; stmt; stmt = stmt->next) { |
| switch (stmt->type) { |
| case STMT_INCLUDE: |
| ok = HandleIncludeKeyTypes(info, (IncludeStmt *) stmt); |
| break; |
| case STMT_TYPE: |
| ok = HandleKeyTypeDef(info, (KeyTypeDef *) stmt, merge); |
| break; |
| case STMT_VAR: |
| log_err(info->ctx, |
| "Support for changing the default type has been removed; " |
| "Statement ignored\n"); |
| ok = true; |
| break; |
| case STMT_VMOD: |
| ok = HandleVModDef(info->ctx, &info->mods, (VModDef *) stmt, merge); |
| break; |
| default: |
| log_err(info->ctx, |
| "Key type files may not include other declarations; " |
| "Ignoring %s\n", stmt_type_to_string(stmt->type)); |
| ok = false; |
| break; |
| } |
| |
| if (!ok) |
| info->errorCount++; |
| |
| if (info->errorCount > 10) { |
| log_err(info->ctx, |
| "Abandoning keytypes file \"%s\"\n", file->topName); |
| break; |
| } |
| } |
| } |
| |
| /***====================================================================***/ |
| |
| static bool |
| CopyKeyTypesToKeymap(struct xkb_keymap *keymap, KeyTypesInfo *info) |
| { |
| unsigned num_types; |
| struct xkb_key_type *types; |
| |
| num_types = darray_empty(info->types) ? 1 : darray_size(info->types); |
| types = calloc(num_types, sizeof(*types)); |
| if (!types) |
| return false; |
| |
| /* |
| * If no types were specified, a default unnamed one-level type is |
| * used for all keys. |
| */ |
| if (darray_empty(info->types)) { |
| struct xkb_key_type *type = &types[0]; |
| |
| type->mods.mods = 0; |
| type->num_levels = 1; |
| type->entries = NULL; |
| type->num_entries = 0; |
| type->name = xkb_atom_intern_literal(keymap->ctx, "default"); |
| type->level_names = NULL; |
| } |
| else { |
| for (unsigned i = 0; i < num_types; i++) { |
| KeyTypeInfo *def = &darray_item(info->types, i); |
| struct xkb_key_type *type = &types[i]; |
| |
| type->name = def->name; |
| type->mods.mods = def->mods; |
| darray_steal(def->level_names, |
| &type->level_names, &type->num_levels); |
| darray_steal(def->entries, |
| &type->entries, &type->num_entries); |
| } |
| } |
| |
| keymap->types_section_name = strdup_safe(info->name); |
| XkbEscapeMapName(keymap->types_section_name); |
| keymap->num_types = num_types; |
| keymap->types = types; |
| keymap->mods = info->mods; |
| return true; |
| } |
| |
| /***====================================================================***/ |
| |
| bool |
| CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, |
| enum merge_mode merge) |
| { |
| KeyTypesInfo info; |
| |
| InitKeyTypesInfo(&info, keymap->ctx, &keymap->mods); |
| |
| HandleKeyTypesFile(&info, file, merge); |
| if (info.errorCount != 0) |
| goto err_info; |
| |
| if (!CopyKeyTypesToKeymap(keymap, &info)) |
| goto err_info; |
| |
| ClearKeyTypesInfo(&info); |
| return true; |
| |
| err_info: |
| ClearKeyTypesInfo(&info); |
| return false; |
| } |
