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 <X11/extensions/XKM.h>
  32 #include "parseutils.h"
  33 #include "utils.h"
  34
  35 #ifndef DFLT_XKB_CONFIG_ROOT
  36 #define DFLT_XKB_CONFIG_ROOT "/usr/share/X11/xkb"
  37 #endif
  38
  39 /* Global debugging flags */
  40 unsigned int debugFlags = 0;
  41 unsigned int warningLevel = 0;
  42
  43 #define ISEMPTY(str) (!(str) || (strlen(str) == 0))
  44
  45 static XkbFile *
  46 XkbKeymapFileFromComponents(const XkbComponentNamesPtr ktcsg)
  47 {
  48     XkbFile *keycodes, *types, *compat, *symbols, *geometry;
  49     IncludeStmt *inc;
  50
  51     if (!ktcsg) {
  52         ERROR("no components to generate keymap file from\n");
  53         return NULL;
  54     }
  55
  56     inc = IncludeCreate(ktcsg->keycodes, MergeDefault);
  57     keycodes = CreateXKBFile(XkmKeyNamesIndex, NULL, (ParseCommon *)inc, 0);
  58
  59     inc = IncludeCreate(ktcsg->types, MergeDefault);
  60     types = CreateXKBFile(XkmTypesIndex, NULL, (ParseCommon *)inc, 0);
  61     AppendStmt(&keycodes->common, &types->common);
  62
  63     inc = IncludeCreate(ktcsg->compat, MergeDefault);
  64     compat = CreateXKBFile(XkmCompatMapIndex, NULL, (ParseCommon *)inc, 0);
  65     AppendStmt(&keycodes->common, &compat->common);
  66
  67     inc = IncludeCreate(ktcsg->symbols, MergeDefault);
  68     symbols = CreateXKBFile(XkmSymbolsIndex, NULL, (ParseCommon *)inc, 0);
  69     AppendStmt(&keycodes->common, &symbols->common);
  70
  71     inc = IncludeCreate(ktcsg->geometry, MergeDefault);
  72     geometry = CreateXKBFile(XkmGeometryIndex, NULL, (ParseCommon *)inc, 0);
  73     AppendStmt(&keycodes->common, &geometry->common);
  74
  75     return CreateXKBFile(XkmKeymapFile, ktcsg->keymap ? ktcsg->keymap : "",
  76                          &keycodes->common, 0);
  77 }
  78
  79 static XkbComponentNamesPtr
  80 XkbComponentsFromRules(const char *rulesPath, const XkbRF_VarDefsPtr defs)
  81 {
  82     XkbRF_RulesPtr rules;
  83     XkbComponentNamesPtr names = NULL;
  84
  85     if (!(rules = XkbcRF_Load((char *)rulesPath, NULL, False, True))) {
  86         ERROR("failed to load XKB rules \"%s\"\n", rulesPath);
  87         goto fail;
  88     }
  89
  90     if (!(names = _XkbTypedCalloc(1, XkbComponentNamesRec))) {
  91         ERROR("failed to allocate XKB components\n");
  92         goto unwind_rules;
  93     }
  94
  95     if (!XkbcRF_GetComponents(rules, defs, names)) {
  96         _XkbFree(names->keymap);
  97         _XkbFree(names->keycodes);
  98         _XkbFree(names->types);
  99         _XkbFree(names->compat);
 100         _XkbFree(names->symbols);
 101         _XkbFree(names->geometry);
 102         _XkbFree(names);
 103         names = NULL;
 104         ERROR("no components returned from XKB rules \"%s\"\n", rulesPath);
 105     }
 106
 107 unwind_rules:
 108     XkbcRF_Free(rules, True);
 109 fail:
 110     return names;
 111 }
 112
 113 XkbcDescPtr
 114 XkbcCompileKeymapFromRules(XkbRMLVOSet *rmlvo)
 115 {
 116     char rulesPath[PATH_MAX];
 117     int pathlen;
 118     XkbRF_VarDefsRec defs;
 119     XkbComponentNamesPtr names;
 120     XkbcDescPtr xkb;
 121
 122     if (!rmlvo || ISEMPTY(rmlvo->rules) || ISEMPTY(rmlvo->layout)) {
 123         ERROR("rules and layout required to generate XKB keymap\n");
 124         return NULL;
 125     }
 126
 127     pathlen = snprintf(rulesPath, sizeof(rulesPath),
 128                        DFLT_XKB_CONFIG_ROOT "/rules/%s", rmlvo->rules);
 129     if (pathlen >= sizeof(rulesPath)) {
 130         ERROR("XKB rules path truncated\n");
 131         return NULL;
 132     }
 133
 134     defs.model = rmlvo->model;
 135     defs.layout = rmlvo->layout;
 136     defs.variant = rmlvo->variant;
 137     defs.options = rmlvo->options;
 138
 139     names = XkbComponentsFromRules(rulesPath, &defs);
 140     if (!names) {
 141         ERROR("failed to generate XKB components from rules \"%s\"\n",
 142               rmlvo->rules);
 143         return NULL;
 144     }
 145
 146     xkb = XkbcCompileKeymapFromComponents(names);
 147
 148     _XkbFree(names->keymap);
 149     _XkbFree(names->keycodes);
 150     _XkbFree(names->types);
 151     _XkbFree(names->compat);
 152     _XkbFree(names->symbols);
 153     _XkbFree(names->geometry);
 154     _XkbFree(names);
 155
 156     return xkb;
 157 }
 158
 159 XkbcDescPtr
 160 XkbcCompileKeymapFromComponents(XkbComponentNamesPtr ktcsg)
 161 {
 162     XkbFile *file, *mapToUse;
 163     XkbcDescPtr xkb;
 164
 165     if (!ktcsg || ISEMPTY(ktcsg->keycodes)) {
 166         ERROR("keycodes required to generate XKB keymap\n");
 167         goto fail;
 168     }
 169
 170     if (!(file = XkbKeymapFileFromComponents(ktcsg))) {
 171         ERROR("failed to generate parsed XKB file from components\n");
 172         goto fail;
 173     }
 174
 175     /* Find map to use */
 176     mapToUse = file;
 177     if (file->common.next) {
 178         for (; mapToUse; mapToUse = (XkbFile *)mapToUse->common.next) {
 179             if (mapToUse->flags & XkbLC_Default)
 180                 break;
 181         }
 182         if (!mapToUse) {
 183             mapToUse = file;
 184             WARN("no map specified, but components have several\n");
 185         }
 186     }
 187
 188     /* Compile the keyboard */
 189     if (!(xkb = XkbcAllocKeyboard())) {
 190         ERROR("could not allocate keyboard description\n");
 191         goto unwind_file;
 192     }
 193
 194     if (!CompileKeymap(mapToUse, xkb, MergeReplace)) {
 195         ERROR("failed to compile keymap\n");
 196         goto unwind_xkb;
 197     }
 198
 199     return xkb;
 200 unwind_xkb:
 201     XkbcFreeKeyboard(xkb, XkbAllComponentsMask, True);
 202 unwind_file:
 203     /* XXX: here's where we would free the XkbFile */
 204 fail:
 205     return NULL;
 206 }