2 * Copyright 2009 Dan Nicholson
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17 * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
18 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 * Except as contained in this notice, the names of the authors or their
22 * institutions shall not be used in advertising or otherwise to promote the
23 * sale, use or other dealings in this Software without prior written
24 * authorization from the authors.
27 #include "xkbcomp-priv.h"
29 #include "parseutils.h"
31 #define ISEMPTY(str) (!(str) || (strlen(str) == 0))
34 keymap_file_from_components(struct xkb_context *ctx,
35 const struct xkb_component_names *ktcsg)
37 XkbFile *keycodes, *types, *compat, *symbols;
40 inc = IncludeCreate(ctx, ktcsg->keycodes, MERGE_DEFAULT);
41 keycodes = CreateXKBFile(ctx, FILE_TYPE_KEYCODES, NULL,
42 (ParseCommon *) inc, 0);
44 inc = IncludeCreate(ctx, ktcsg->types, MERGE_DEFAULT);
45 types = CreateXKBFile(ctx, FILE_TYPE_TYPES, NULL,
46 (ParseCommon *) inc, 0);
47 AppendStmt(&keycodes->common, &types->common);
49 inc = IncludeCreate(ctx, ktcsg->compat, MERGE_DEFAULT);
50 compat = CreateXKBFile(ctx, FILE_TYPE_COMPAT, NULL,
51 (ParseCommon *) inc, 0);
52 AppendStmt(&keycodes->common, &compat->common);
54 inc = IncludeCreate(ctx, ktcsg->symbols, MERGE_DEFAULT);
55 symbols = CreateXKBFile(ctx, FILE_TYPE_SYMBOLS, NULL,
56 (ParseCommon *) inc, 0);
57 AppendStmt(&keycodes->common, &symbols->common);
59 return CreateXKBFile(ctx, FILE_TYPE_KEYMAP, strdup(""),
60 &keycodes->common, 0);
63 static struct xkb_keymap *
64 new_keymap(struct xkb_context *ctx)
66 struct xkb_keymap *keymap;
68 keymap = calloc(1, sizeof(*keymap));
73 keymap->ctx = xkb_context_ref(ctx);
79 * Compile the given file and store the output in keymap.
80 * @param file A list of XkbFiles, each denoting one type (e.g.
81 * FILE_TYPE_KEYCODES, etc.)
83 static struct xkb_keymap *
84 compile_keymap(struct xkb_context *ctx, XkbFile *file)
88 const char *main_name;
89 struct xkb_keymap *keymap;
90 XkbFile *keycodes = NULL;
91 XkbFile *types = NULL;
92 XkbFile *compat = NULL;
93 XkbFile *symbols = NULL;
95 keymap = new_keymap(ctx);
99 main_name = file->name ? file->name : "(unnamed)";
102 * Other aggregate file types are converted to FILE_TYPE_KEYMAP
105 if (file->file_type != FILE_TYPE_KEYMAP) {
106 log_err(ctx, "Cannot compile a %s file alone into a keymap\n",
107 FileTypeText(file->file_type));
111 /* Check for duplicate entries in the input file */
112 for (file = (XkbFile *) file->defs; file;
113 file = (XkbFile *) file->common.next) {
114 if (have & file->file_type) {
116 "More than one %s section in a keymap file; "
117 "All sections after the first ignored\n",
118 FileTypeText(file->file_type));
122 switch (file->file_type) {
123 case FILE_TYPE_KEYCODES:
127 case FILE_TYPE_TYPES:
131 case FILE_TYPE_SYMBOLS:
135 case FILE_TYPE_COMPAT:
140 log_err(ctx, "Cannot define %s in a keymap file\n",
141 FileTypeText(file->file_type));
145 if (!file->topName) {
147 file->topName = strdup(main_name);
150 have |= file->file_type;
153 if (REQUIRED_FILE_TYPES & (~have)) {
154 enum xkb_file_type bit;
155 enum xkb_file_type missing;
157 missing = REQUIRED_FILE_TYPES & (~have);
159 for (bit = 1; missing != 0; bit <<= 1) {
161 log_err(ctx, "Required section %s missing from keymap\n",
170 ok = CompileKeycodes(keycodes, keymap, MERGE_OVERRIDE);
172 log_err(ctx, "Failed to compile keycodes\n");
175 ok = CompileKeyTypes(types, keymap, MERGE_OVERRIDE);
177 log_err(ctx, "Failed to compile key types\n");
180 ok = CompileCompatMap(compat, keymap, MERGE_OVERRIDE);
182 log_err(ctx, "Failed to compile compat map\n");
185 ok = CompileSymbols(symbols, keymap, MERGE_OVERRIDE);
187 log_err(ctx, "Failed to compile symbols\n");
191 ok = UpdateModifiersFromCompat(keymap);
198 log_err(ctx, "Failed to compile keymap\n");
199 xkb_map_unref(keymap);
204 xkb_map_new_from_kccgst(struct xkb_context *ctx,
205 const struct xkb_component_names *kccgst,
206 enum xkb_map_compile_flags flags)
209 struct xkb_keymap *keymap;
212 log_err(ctx, "No components specified\n");
216 if (ISEMPTY(kccgst->keycodes)) {
217 log_err(ctx, "Keycodes required to generate XKB keymap\n");
221 if (ISEMPTY(kccgst->compat)) {
222 log_err(ctx, "Compat map required to generate XKB keymap\n");
226 if (ISEMPTY(kccgst->types)) {
227 log_err(ctx, "Types required to generate XKB keymap\n");
231 if (ISEMPTY(kccgst->symbols)) {
232 log_err(ctx, "Symbols required to generate XKB keymap\n");
236 file = keymap_file_from_components(ctx, kccgst);
238 log_err(ctx, "Failed to generate parsed XKB file from components\n");
242 keymap = compile_keymap(ctx, file);
247 XKB_EXPORT struct xkb_keymap *
248 xkb_map_new_from_names(struct xkb_context *ctx,
249 const struct xkb_rule_names *rmlvo,
250 enum xkb_map_compile_flags flags)
252 struct xkb_component_names *kkctgs;
253 struct xkb_keymap *keymap;
255 if (!rmlvo || ISEMPTY(rmlvo->rules) || ISEMPTY(rmlvo->layout)) {
256 log_err(ctx, "rules and layout required to generate XKB keymap\n");
260 kkctgs = xkb_components_from_rules(ctx, rmlvo);
262 log_err(ctx, "failed to generate XKB components from rules \"%s\"\n",
267 keymap = xkb_map_new_from_kccgst(ctx, kkctgs, 0);
269 free(kkctgs->keycodes);
271 free(kkctgs->compat);
272 free(kkctgs->symbols);
278 XKB_EXPORT struct xkb_keymap *
279 xkb_map_new_from_string(struct xkb_context *ctx,
281 enum xkb_keymap_format format,
282 enum xkb_map_compile_flags flags)
286 struct xkb_keymap *keymap;
288 if (format != XKB_KEYMAP_FORMAT_TEXT_V1) {
289 log_err(ctx, "unsupported keymap format %d\n", format);
294 log_err(ctx, "No string specified to generate XKB keymap\n");
298 ok = XKBParseString(ctx, string, "input", &file);
300 log_err(ctx, "Failed to parse input xkb file\n");
304 keymap = compile_keymap(ctx, file);
309 XKB_EXPORT struct xkb_keymap *
310 xkb_map_new_from_file(struct xkb_context *ctx,
312 enum xkb_keymap_format format,
313 enum xkb_map_compile_flags flags)
317 struct xkb_keymap *keymap;
319 if (format != XKB_KEYMAP_FORMAT_TEXT_V1) {
320 log_err(ctx, "Unsupported keymap format %d\n", format);
325 log_err(ctx, "No file specified to generate XKB keymap\n");
329 ok = XKBParseFile(ctx, file, "(unknown file)", &xkb_file);
331 log_err(ctx, "Failed to parse input xkb file\n");
335 keymap = compile_keymap(ctx, xkb_file);
336 FreeXKBFile(xkb_file);
340 XKB_EXPORT struct xkb_keymap *
341 xkb_map_ref(struct xkb_keymap *keymap)
348 xkb_map_unref(struct xkb_keymap *keymap)
353 if (!keymap || --keymap->refcnt > 0)
356 for (i = 0; i < keymap->num_types; i++) {
357 free(keymap->types[i].map);
358 free(keymap->types[i].level_names);
362 darray_foreach(key, keymap->keys) {
363 free(key->sym_index);
365 darray_free(key->syms);
367 darray_free(keymap->keys);
369 darray_free(keymap->acts);
371 darray_free(keymap->sym_interpret);
373 darray_free(keymap->key_aliases);
375 free(keymap->keycodes_section_name);
376 free(keymap->symbols_section_name);
377 free(keymap->types_section_name);
378 free(keymap->compat_section_name);
380 xkb_context_unref(keymap->ctx);