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"
32 keymap_file_from_names(struct xkb_context *ctx,
33 const struct xkb_rule_names *rmlvo)
35 struct xkb_component_names kkctgs;
36 XkbFile *keycodes, *types, *compat, *symbols;
39 if (!xkb_components_from_rules(ctx, rmlvo, &kkctgs)) {
41 "Couldn't look up rules '%s', model '%s', layout '%s', "
42 "variant '%s', options '%s'\n",
43 rmlvo->rules, rmlvo->model, rmlvo->layout, rmlvo->variant,
48 inc = IncludeCreate(ctx, kkctgs.keycodes, MERGE_DEFAULT);
49 keycodes = CreateXKBFile(ctx, FILE_TYPE_KEYCODES, NULL,
50 (ParseCommon *) inc, 0);
52 inc = IncludeCreate(ctx, kkctgs.types, MERGE_DEFAULT);
53 types = CreateXKBFile(ctx, FILE_TYPE_TYPES, NULL,
54 (ParseCommon *) inc, 0);
55 AppendStmt(&keycodes->common, &types->common);
57 inc = IncludeCreate(ctx, kkctgs.compat, MERGE_DEFAULT);
58 compat = CreateXKBFile(ctx, FILE_TYPE_COMPAT, NULL,
59 (ParseCommon *) inc, 0);
60 AppendStmt(&keycodes->common, &compat->common);
62 inc = IncludeCreate(ctx, kkctgs.symbols, MERGE_DEFAULT);
63 symbols = CreateXKBFile(ctx, FILE_TYPE_SYMBOLS, NULL,
64 (ParseCommon *) inc, 0);
65 AppendStmt(&keycodes->common, &symbols->common);
67 free(kkctgs.keycodes);
72 return CreateXKBFile(ctx, FILE_TYPE_KEYMAP, strdup(""),
73 &keycodes->common, 0);
76 static struct xkb_keymap *
77 new_keymap(struct xkb_context *ctx)
79 struct xkb_keymap *keymap;
81 keymap = calloc(1, sizeof(*keymap));
86 keymap->ctx = xkb_context_ref(ctx);
92 * Compile the given file and store the output in keymap.
93 * @param file A list of XkbFiles, each denoting one type (e.g.
94 * FILE_TYPE_KEYCODES, etc.)
96 static struct xkb_keymap *
97 compile_keymap(struct xkb_context *ctx, XkbFile *file)
101 const char *main_name;
102 struct xkb_keymap *keymap;
103 XkbFile *keycodes = NULL;
104 XkbFile *types = NULL;
105 XkbFile *compat = NULL;
106 XkbFile *symbols = NULL;
108 keymap = new_keymap(ctx);
112 main_name = file->name ? file->name : "(unnamed)";
115 * Other aggregate file types are converted to FILE_TYPE_KEYMAP
118 if (file->file_type != FILE_TYPE_KEYMAP) {
119 log_err(ctx, "Cannot compile a %s file alone into a keymap\n",
120 FileTypeText(file->file_type));
124 /* Check for duplicate entries in the input file */
125 for (file = (XkbFile *) file->defs; file;
126 file = (XkbFile *) file->common.next) {
127 if (have & file->file_type) {
129 "More than one %s section in a keymap file; "
130 "All sections after the first ignored\n",
131 FileTypeText(file->file_type));
135 switch (file->file_type) {
136 case FILE_TYPE_KEYCODES:
140 case FILE_TYPE_TYPES:
144 case FILE_TYPE_SYMBOLS:
148 case FILE_TYPE_COMPAT:
153 log_err(ctx, "Cannot define %s in a keymap file\n",
154 FileTypeText(file->file_type));
158 if (!file->topName) {
160 file->topName = strdup(main_name);
163 have |= file->file_type;
166 if (REQUIRED_FILE_TYPES & (~have)) {
167 enum xkb_file_type bit;
168 enum xkb_file_type missing;
170 missing = REQUIRED_FILE_TYPES & (~have);
172 for (bit = 1; missing != 0; bit <<= 1) {
174 log_err(ctx, "Required section %s missing from keymap\n",
183 ok = CompileKeycodes(keycodes, keymap, MERGE_OVERRIDE);
185 log_err(ctx, "Failed to compile keycodes\n");
188 ok = CompileKeyTypes(types, keymap, MERGE_OVERRIDE);
190 log_err(ctx, "Failed to compile key types\n");
193 ok = CompileCompatMap(compat, keymap, MERGE_OVERRIDE);
195 log_err(ctx, "Failed to compile compat map\n");
198 ok = CompileSymbols(symbols, keymap, MERGE_OVERRIDE);
200 log_err(ctx, "Failed to compile symbols\n");
204 ok = UpdateModifiersFromCompat(keymap);
211 log_err(ctx, "Failed to compile keymap\n");
212 xkb_map_unref(keymap);
216 XKB_EXPORT struct xkb_keymap *
217 xkb_map_new_from_names(struct xkb_context *ctx,
218 const struct xkb_rule_names *rmlvo_in,
219 enum xkb_map_compile_flags flags)
221 struct xkb_rule_names rmlvo = *rmlvo_in;
223 struct xkb_keymap *keymap;
225 if (isempty(rmlvo.rules))
226 rmlvo.rules = DEFAULT_XKB_RULES;
227 if (isempty(rmlvo.model))
228 rmlvo.model = DEFAULT_XKB_MODEL;
229 if (isempty(rmlvo.layout))
230 rmlvo.layout = DEFAULT_XKB_LAYOUT;
232 file = keymap_file_from_names(ctx, &rmlvo);
235 "Failed to generate parsed XKB file from components\n");
239 keymap = compile_keymap(ctx, file);
244 XKB_EXPORT struct xkb_keymap *
245 xkb_map_new_from_string(struct xkb_context *ctx,
247 enum xkb_keymap_format format,
248 enum xkb_map_compile_flags flags)
252 struct xkb_keymap *keymap;
254 if (format != XKB_KEYMAP_FORMAT_TEXT_V1) {
255 log_err(ctx, "Unsupported keymap format %d\n", format);
260 log_err(ctx, "No string specified to generate XKB keymap\n");
264 ok = XKBParseString(ctx, string, "input", &file);
266 log_err(ctx, "Failed to parse input xkb file\n");
270 keymap = compile_keymap(ctx, file);
275 XKB_EXPORT struct xkb_keymap *
276 xkb_map_new_from_file(struct xkb_context *ctx,
278 enum xkb_keymap_format format,
279 enum xkb_map_compile_flags flags)
283 struct xkb_keymap *keymap;
285 if (format != XKB_KEYMAP_FORMAT_TEXT_V1) {
286 log_err(ctx, "Unsupported keymap format %d\n", format);
291 log_err(ctx, "No file specified to generate XKB keymap\n");
295 ok = XKBParseFile(ctx, file, "(unknown file)", &xkb_file);
297 log_err(ctx, "Failed to parse input xkb file\n");
301 keymap = compile_keymap(ctx, xkb_file);
302 FreeXKBFile(xkb_file);
306 XKB_EXPORT struct xkb_keymap *
307 xkb_map_ref(struct xkb_keymap *keymap)
314 xkb_map_unref(struct xkb_keymap *keymap)
319 if (!keymap || --keymap->refcnt > 0)
322 for (i = 0; i < keymap->num_types; i++) {
323 free(keymap->types[i].map);
324 free(keymap->types[i].level_names);
328 darray_foreach(key, keymap->keys) {
329 free(key->sym_index);
331 darray_free(key->syms);
334 darray_free(keymap->keys);
336 darray_free(keymap->sym_interpret);
338 darray_free(keymap->key_aliases);
340 free(keymap->keycodes_section_name);
341 free(keymap->symbols_section_name);
342 free(keymap->types_section_name);
343 free(keymap->compat_section_name);
345 xkb_context_unref(keymap->ctx);