src/xkbcomp/xkbcomp.c

   1 /*
   2 Copyright 2009  Dan Nicholson
   3
   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:
  10
  11 The above copyright notice and this permission notice shall be included in
  12 all copies or substantial portions of the Software.
  13
  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.
  20
  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.
  25 */
  26
  27 #include <limits.h>
  28 #include "xkbcomp.h"
  29 #include "xkballoc.h"
  30 #include "xkbrules.h"
  31 #include "xkbpath.h"
  32 #include "xkbmisc.h"
  33 #include "parseutils.h"
  34 #include "utils.h"
  35
  36 /* Global debugging flags */
  37 unsigned int debugFlags = 0;
  38 unsigned int warningLevel = 0;
  39
  40 #define ISEMPTY(str) (!(str) || (strlen(str) == 0))
  41
  42 static XkbFile *
  43 XkbKeymapFileFromComponents(const struct xkb_component_names * ktcsg)
  44 {
  45     XkbFile *keycodes, *types, *compat, *symbols;
  46     IncludeStmt *inc;
  47
  48     if (!ktcsg) {
  49         ERROR("no components to generate keymap file from\n");
  50         return NULL;
  51     }
  52
  53     inc = IncludeCreate(ktcsg->keycodes, MergeDefault);
  54     keycodes = CreateXKBFile(XkmKeyNamesIndex, NULL, (ParseCommon *)inc, 0);
  55
  56     inc = IncludeCreate(ktcsg->types, MergeDefault);
  57     types = CreateXKBFile(XkmTypesIndex, NULL, (ParseCommon *)inc, 0);
  58     AppendStmt(&keycodes->common, &types->common);
  59
  60     inc = IncludeCreate(ktcsg->compat, MergeDefault);
  61     compat = CreateXKBFile(XkmCompatMapIndex, NULL, (ParseCommon *)inc, 0);
  62     AppendStmt(&keycodes->common, &compat->common);
  63
  64     inc = IncludeCreate(ktcsg->symbols, MergeDefault);
  65     symbols = CreateXKBFile(XkmSymbolsIndex, NULL, (ParseCommon *)inc, 0);
  66     AppendStmt(&keycodes->common, &symbols->common);
  67
  68     return CreateXKBFile(XkmKeymapFile, ktcsg->keymap ? ktcsg->keymap : strdup(""),
  69                          &keycodes->common, 0);
  70 }
  71
  72 static struct xkb_component_names *
  73 XkbComponentsFromRules(const char *rules, const XkbRF_VarDefsPtr defs)
  74 {
  75     FILE *rulesFile = NULL;
  76     char *rulesPath = NULL;
  77     XkbRF_RulesPtr loaded = NULL;
  78     struct xkb_component_names * names = NULL;
  79
  80     rulesFile = XkbFindFileInPath(rules, XkmRulesFile, &rulesPath);
  81     if (!rulesFile) {
  82         ERROR("could not find \"%s\" rules in XKB path\n", rules);
  83         return NULL;
  84     }
  85
  86     if (!(loaded = _XkbTypedCalloc(1, XkbRF_RulesRec))) {
  87         ERROR("failed to allocate XKB rules\n");
  88         goto unwind_file;
  89     }
  90
  91     if (!XkbcRF_LoadRules(rulesFile, loaded)) {
  92         ERROR("failed to load XKB rules \"%s\"\n", rulesPath);
  93         goto unwind_file;
  94     }
  95
  96     if (!(names = _XkbTypedCalloc(1, struct xkb_component_names))) {
  97         ERROR("failed to allocate XKB components\n");
  98         goto unwind_file;
  99     }
 100
 101     if (!XkbcRF_GetComponents(loaded, defs, names)) {
 102         free(names->keymap);
 103         free(names->keycodes);
 104         free(names->types);
 105         free(names->compat);
 106         free(names->symbols);
 107         free(names);
 108         names = NULL;
 109         ERROR("no components returned from XKB rules \"%s\"\n", rulesPath);
 110     }
 111
 112 unwind_file:
 113     XkbcRF_Free(loaded);
 114     if (rulesFile)
 115         fclose(rulesFile);
 116     free(rulesPath);
 117     return names;
 118 }
 119
 120 struct xkb_desc *
 121 xkb_compile_keymap_from_rules(const struct xkb_rule_names *rmlvo)
 122 {
 123     XkbRF_VarDefsRec defs;
 124     struct xkb_component_names * names;
 125     struct xkb_desc * xkb;
 126
 127     if (!rmlvo || ISEMPTY(rmlvo->rules) || ISEMPTY(rmlvo->layout)) {
 128         ERROR("rules and layout required to generate XKB keymap\n");
 129         return NULL;
 130     }
 131
 132     defs.model = rmlvo->model;
 133     defs.layout = rmlvo->layout;
 134     defs.variant = rmlvo->variant;
 135     defs.options = rmlvo->options;
 136
 137     names = XkbComponentsFromRules(rmlvo->rules, &defs);
 138     if (!names) {
 139         ERROR("failed to generate XKB components from rules \"%s\"\n",
 140               rmlvo->rules);
 141         return NULL;
 142     }
 143
 144     xkb = xkb_compile_keymap_from_components(names);
 145
 146     free(names->keymap);
 147     free(names->keycodes);
 148     free(names->types);
 149     free(names->compat);
 150     free(names->symbols);
 151     free(names);
 152
 153     return xkb;
 154 }
 155
 156 static XkbFile *
 157 XkbChooseMap(XkbFile *file, const char *name)
 158 {
 159     XkbFile *map = file;
 160
 161     /* map specified? */
 162     if (name) {
 163         while (map) {
 164             if (map->name && strcmp(map->name, name) == 0)
 165                 break;
 166             map = (XkbFile *) map->common.next;
 167         }
 168
 169         if (!map)
 170             ERROR("no map named \"%s\" in input file\n", name);
 171     }
 172     else if (file->common.next) {
 173         /* look for map with XkbLC_Default flag. */
 174         for (; map; map = (XkbFile *) map->common.next) {
 175             if (map->flags & XkbLC_Default)
 176                 break;
 177         }
 178
 179         if (!map) {
 180             map = file;
 181             WARN("no map specified, but components have several\n");
 182             WARN("using the first defined map, \"%s\"\n",
 183                  map->name ? map->name : "");
 184         }
 185     }
 186
 187     return map;
 188 }
 189
 190 static struct xkb_desc *
 191 compile_keymap(XkbFile *file, const char *mapName)
 192 {
 193     XkbFile *mapToUse;
 194     struct xkb_desc * xkb = NULL;
 195
 196     /* Find map to use */
 197     if (!(mapToUse = XkbChooseMap(file, mapName)))
 198         goto unwind_file;
 199
 200     switch (mapToUse->type) {
 201     case XkmSemanticsFile:
 202     case XkmLayoutFile:
 203     case XkmKeymapFile:
 204         break;
 205     default:
 206         ERROR("file type %d not handled\n", mapToUse->type);
 207         goto unwind_file;
 208     }
 209
 210     /* Compile the keyboard */
 211     if (!(xkb = XkbcAllocKeyboard())) {
 212         ERROR("could not allocate keyboard description\n");
 213         goto unwind_file;
 214     }
 215
 216     if (!CompileKeymap(mapToUse, xkb, MergeReplace)) {
 217         ERROR("failed to compile keymap\n");
 218         XkbcFreeKeyboard(xkb);
 219         xkb = NULL;
 220     }
 221
 222 unwind_file:
 223     FreeXKBFile(file);
 224     free(scanFile);
 225     XkbFreeIncludePath();
 226     return xkb;
 227 }
 228
 229 struct xkb_desc *
 230 xkb_compile_keymap_from_components(const struct xkb_component_names * ktcsg)
 231 {
 232     XkbFile *file;
 233
 234     if (!ktcsg || ISEMPTY(ktcsg->keycodes)) {
 235         ERROR("keycodes required to generate XKB keymap\n");
 236         return NULL;
 237     }
 238
 239     if (!(file = XkbKeymapFileFromComponents(ktcsg))) {
 240         ERROR("failed to generate parsed XKB file from components\n");
 241         return NULL;
 242     }
 243
 244     return compile_keymap(file, NULL);
 245 }
 246
 247 struct xkb_desc *
 248 xkb_compile_keymap_from_string(const char *string, const char *mapName)
 249 {
 250     XkbFile *file;
 251
 252     if (!string) {
 253         ERROR("no string specified to generate XKB keymap\n");
 254         return NULL;
 255     }
 256
 257     setScanState("input", 1);
 258     if (!XKBParseString(string, &file) || !file) {
 259         ERROR("failed to parse input xkb file\n");
 260         return NULL;
 261     }
 262
 263     return compile_keymap(file, mapName);
 264 }
 265
 266 struct xkb_desc *
 267 xkb_compile_keymap_from_file(FILE *inputFile, const char *mapName)
 268 {
 269     XkbFile *file;
 270
 271     if (!inputFile) {
 272         ERROR("no file specified to generate XKB keymap\n");
 273         return NULL;
 274     }
 275
 276     setScanState("input", 1);
 277     if (!XKBParseFile(inputFile, &file) || !file) {
 278         ERROR("failed to parse input xkb file\n");
 279         return NULL;
 280     }
 281
 282     return compile_keymap(file, mapName);
 283 }
 284
 285 void
 286 xkb_free_keymap(struct xkb_desc *xkb)
 287 {
 288     XkbcFreeKeyboard(xkb);
 289     XkbcFreeAllAtoms();
 290 }