src/xkbcomp/symbols.c

   1 /************************************************************
   2  Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
   3
   4  Permission to use, copy, modify, and distribute this
   5  software and its documentation for any purpose and without
   6  fee is hereby granted, provided that the above copyright
   7  notice appear in all copies and that both that copyright
   8  notice and this permission notice appear in supporting
   9  documentation, and that the name of Silicon Graphics not be
  10  used in advertising or publicity pertaining to distribution
  11  of the software without specific prior written permission.
  12  Silicon Graphics makes no representation about the suitability
  13  of this software for any purpose. It is provided "as is"
  14  without any express or implied warranty.
  15
  16  SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17  SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18  AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19  GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20  DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21  DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22  OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23  THE USE OR PERFORMANCE OF THIS SOFTWARE.
  24
  25  ********************************************************/
  26
  27 #include "xkbcomp.h"
  28 #include "xkballoc.h"
  29 #include "xkbmisc.h"
  30 #include "expr.h"
  31 #include "parseutils.h"
  32
  33 #include <X11/keysym.h>
  34 #include <stdlib.h>
  35
  36 #include "expr.h"
  37 #include "vmod.h"
  38 #include "action.h"
  39 #include "keycodes.h"
  40 #include "misc.h"
  41 #include "alias.h"
  42
  43 /***====================================================================***/
  44
  45 #define RepeatYes       1
  46 #define RepeatNo        0
  47 #define RepeatUndefined ~((unsigned)0)
  48
  49 #define _Key_Syms       (1<<0)
  50 #define _Key_Acts       (1<<1)
  51 #define _Key_Repeat     (1<<2)
  52 #define _Key_Behavior   (1<<3)
  53 #define _Key_Type_Dflt  (1<<4)
  54 #define _Key_Types      (1<<5)
  55 #define _Key_GroupInfo  (1<<6)
  56 #define _Key_VModMap    (1<<7)
  57
  58 typedef struct _KeyInfo
  59 {
  60     CommonInfo defs;
  61     unsigned long name; /* the 4 chars of the key name, as long */
  62     unsigned char groupInfo;
  63     unsigned char typesDefined;
  64     unsigned char symsDefined;
  65     unsigned char actsDefined;
  66     short numLevels[XkbNumKbdGroups];
  67     xkb_keysym_t *syms[XkbNumKbdGroups];
  68     union xkb_action *acts[XkbNumKbdGroups];
  69     xkb_atom_t types[XkbNumKbdGroups];
  70     unsigned repeat;
  71     struct xkb_behavior behavior;
  72     unsigned short vmodmap;
  73     unsigned long allowNone;
  74     xkb_atom_t dfltType;
  75 } KeyInfo;
  76
  77 /**
  78  * Init the given key info to sane values.
  79  */
  80 static void
  81 InitKeyInfo(KeyInfo * info)
  82 {
  83     int i;
  84     static char dflt[4] = "*";
  85
  86     info->defs.defined = 0;
  87     info->defs.fileID = 0;
  88     info->defs.merge = MergeOverride;
  89     info->defs.next = NULL;
  90     info->name = KeyNameToLong(dflt);
  91     info->groupInfo = 0;
  92     info->typesDefined = info->symsDefined = info->actsDefined = 0;
  93     for (i = 0; i < XkbNumKbdGroups; i++)
  94     {
  95         info->numLevels[i] = 0;
  96         info->types[i] = None;
  97         info->syms[i] = NULL;
  98         info->acts[i] = NULL;
  99     }
 100     info->dfltType = None;
 101     info->behavior.type = XkbKB_Default;
 102     info->behavior.data = 0;
 103     info->vmodmap = 0;
 104     info->repeat = RepeatUndefined;
 105     info->allowNone = 0;
 106 }
 107
 108 /**
 109  * Free memory associated with this key info and reset to sane values.
 110  */
 111 static void
 112 FreeKeyInfo(KeyInfo * info)
 113 {
 114     int i;
 115
 116     info->defs.defined = 0;
 117     info->defs.fileID = 0;
 118     info->defs.merge = MergeOverride;
 119     info->defs.next = NULL;
 120     info->groupInfo = 0;
 121     info->typesDefined = info->symsDefined = info->actsDefined = 0;
 122     for (i = 0; i < XkbNumKbdGroups; i++)
 123     {
 124         info->numLevels[i] = 0;
 125         info->types[i] = None;
 126         free(info->syms[i]);
 127         info->syms[i] = NULL;
 128         free(info->acts[i]);
 129         info->acts[i] = NULL;
 130     }
 131     info->dfltType = None;
 132     info->behavior.type = XkbKB_Default;
 133     info->behavior.data = 0;
 134     info->vmodmap = 0;
 135     info->repeat = RepeatUndefined;
 136     info->allowNone = 0;
 137 }
 138
 139 /**
 140  * Copy old into new, optionally reset old to 0.
 141  * If old is reset, new simply re-uses old's memory. Otherwise, the memory is
 142  * newly allocated and new points to the new memory areas.
 143  */
 144 static Bool
 145 CopyKeyInfo(KeyInfo * old, KeyInfo * new, Bool clearOld)
 146 {
 147     int i;
 148
 149     *new = *old;
 150     new->defs.next = NULL;
 151     if (clearOld)
 152     {
 153         for (i = 0; i < XkbNumKbdGroups; i++)
 154         {
 155             old->numLevels[i] = 0;
 156             old->syms[i] = NULL;
 157             old->acts[i] = NULL;
 158         }
 159     }
 160     else
 161     {
 162         int width;
 163         for (i = 0; i < XkbNumKbdGroups; i++)
 164         {
 165             width = new->numLevels[i];
 166             if (old->syms[i] != NULL)
 167             {
 168                 new->syms[i] = uTypedCalloc(width, xkb_keysym_t);
 169                 if (!new->syms[i])
 170                 {
 171                     new->syms[i] = NULL;
 172                     new->numLevels[i] = 0;
 173                     return False;
 174                 }
 175                 memcpy(new->syms[i], old->syms[i], width * sizeof(xkb_keysym_t));
 176             }
 177             if (old->acts[i] != NULL)
 178             {
 179                 new->acts[i] = uTypedCalloc(width, union xkb_action);
 180                 if (!new->acts[i])
 181                 {
 182                     new->acts[i] = NULL;
 183                     return False;
 184                 }
 185                 memcpy(new->acts[i], old->acts[i],
 186                        width * sizeof(union xkb_action));
 187             }
 188         }
 189     }
 190     return True;
 191 }
 192
 193 /***====================================================================***/
 194
 195 typedef struct _ModMapEntry
 196 {
 197     CommonInfo defs;
 198     Bool haveSymbol;
 199     int modifier;
 200     union
 201     {
 202         unsigned long keyName;
 203         xkb_keysym_t keySym;
 204     } u;
 205 } ModMapEntry;
 206
 207 #define SYMBOLS_INIT_SIZE       110
 208 #define SYMBOLS_CHUNK           20
 209 typedef struct _SymbolsInfo
 210 {
 211     char *name;         /* e.g. pc+us+inet(evdev) */
 212     int errorCount;
 213     unsigned fileID;
 214     unsigned merge;
 215     unsigned explicit_group;
 216     unsigned groupInfo;
 217     unsigned szKeys;
 218     unsigned nKeys;
 219     KeyInfo *keys;
 220     KeyInfo dflt;
 221     VModInfo vmods;
 222     ActionInfo *action;
 223     xkb_atom_t groupNames[XkbNumKbdGroups];
 224
 225     ModMapEntry *modMap;
 226     AliasInfo *aliases;
 227 } SymbolsInfo;
 228
 229 static void
 230 InitSymbolsInfo(SymbolsInfo * info, struct xkb_desc * xkb)
 231 {
 232     int i;
 233
 234     info->name = NULL;
 235     info->explicit_group = 0;
 236     info->errorCount = 0;
 237     info->fileID = 0;
 238     info->merge = MergeOverride;
 239     info->groupInfo = 0;
 240     info->szKeys = SYMBOLS_INIT_SIZE;
 241     info->nKeys = 0;
 242     info->keys = uTypedCalloc(SYMBOLS_INIT_SIZE, KeyInfo);
 243     info->modMap = NULL;
 244     for (i = 0; i < XkbNumKbdGroups; i++)
 245         info->groupNames[i] = None;
 246     InitKeyInfo(&info->dflt);
 247     InitVModInfo(&info->vmods, xkb);
 248     info->action = NULL;
 249     info->aliases = NULL;
 250 }
 251
 252 static void
 253 FreeSymbolsInfo(SymbolsInfo * info)
 254 {
 255     int i;
 256
 257     free(info->name);
 258     if (info->keys)
 259     {
 260         for (i = 0; i < info->nKeys; i++)
 261             FreeKeyInfo(&info->keys[i]);
 262         free(info->keys);
 263     }
 264     if (info->modMap)
 265         ClearCommonInfo(&info->modMap->defs);
 266     if (info->aliases)
 267         ClearAliases(&info->aliases);
 268     memset(info, 0, sizeof(SymbolsInfo));
 269 }
 270
 271 static Bool
 272 ResizeKeyGroup(KeyInfo * key,
 273                unsigned group, unsigned atLeastSize, Bool forceActions)
 274 {
 275     Bool tooSmall;
 276     unsigned newWidth;
 277
 278     tooSmall = (key->numLevels[group] < atLeastSize);
 279     if (tooSmall)
 280         newWidth = atLeastSize;
 281     else
 282         newWidth = key->numLevels[group];
 283
 284     if ((key->syms[group] == NULL) || tooSmall)
 285     {
 286         key->syms[group] = uTypedRecalloc(key->syms[group],
 287                                           key->numLevels[group], newWidth,
 288                                           xkb_keysym_t);
 289         if (!key->syms[group])
 290             return False;
 291     }
 292     if (((forceActions) && (tooSmall || (key->acts[group] == NULL))) ||
 293         (tooSmall && (key->acts[group] != NULL)))
 294     {
 295         key->acts[group] = uTypedRecalloc(key->acts[group],
 296                                           key->numLevels[group], newWidth,
 297                                           union xkb_action);
 298         if (!key->acts[group])
 299             return False;
 300     }
 301     key->numLevels[group] = newWidth;
 302     return True;
 303 }
 304
 305 static Bool
 306 MergeKeyGroups(SymbolsInfo * info,
 307                KeyInfo * into, KeyInfo * from, unsigned group)
 308 {
 309     xkb_keysym_t *resultSyms;
 310     union xkb_action *resultActs;
 311     int resultWidth;
 312     int i;
 313     Bool report, clobber;
 314
 315     clobber = (from->defs.merge != MergeAugment);
 316     report = (warningLevel > 9) ||
 317         ((into->defs.fileID == from->defs.fileID) && (warningLevel > 0));
 318     if (into->numLevels[group] >= from->numLevels[group])
 319     {
 320         resultSyms = into->syms[group];
 321         resultActs = into->acts[group];
 322         resultWidth = into->numLevels[group];
 323     }
 324     else
 325     {
 326         resultSyms = from->syms[group];
 327         resultActs = from->acts[group];
 328         resultWidth = from->numLevels[group];
 329     }
 330     if (resultSyms == NULL)
 331     {
 332         resultSyms = uTypedCalloc(resultWidth, xkb_keysym_t);
 333         if (!resultSyms)
 334         {
 335             WSGO("Could not allocate symbols for group merge\n");
 336             ACTION("Group %d of key %s not merged\n", group,
 337                     longText(into->name));
 338             return False;
 339         }
 340     }
 341     if ((resultActs == NULL) && (into->acts[group] || from->acts[group]))
 342     {
 343         resultActs = uTypedCalloc(resultWidth, union xkb_action);
 344         if (!resultActs)
 345         {
 346             WSGO("Could not allocate actions for group merge\n");
 347             ACTION("Group %d of key %s not merged\n", group,
 348                     longText(into->name));
 349             if (resultSyms != into->syms[group] &&
 350                 resultSyms != from->syms[group])
 351                 free(resultSyms);
 352             return False;
 353         }
 354     }
 355     for (i = 0; i < resultWidth; i++)
 356     {
 357         xkb_keysym_t fromSym, toSym;
 358         if (from->syms[group] && (i < from->numLevels[group]))
 359             fromSym = from->syms[group][i];
 360         else
 361             fromSym = NoSymbol;
 362         if (into->syms[group] && (i < into->numLevels[group]))
 363             toSym = into->syms[group][i];
 364         else
 365             toSym = NoSymbol;
 366         if ((fromSym == NoSymbol) || (fromSym == toSym))
 367             resultSyms[i] = toSym;
 368         else if (toSym == NoSymbol)
 369             resultSyms[i] = fromSym;
 370         else
 371         {
 372             xkb_keysym_t use, ignore;
 373             if (clobber)
 374             {
 375                 use = fromSym;
 376                 ignore = toSym;
 377             }
 378             else
 379             {
 380                 use = toSym;
 381                 ignore = fromSym;
 382             }
 383             if (report)
 384             {
 385                 WARN
 386                     ("Multiple symbols for level %d/group %d on key %s\n",
 387                      i + 1, group + 1, longText(into->name));
 388                 ACTION("Using %s, ignoring %s\n",
 389                         XkbcKeysymText(use), XkbcKeysymText(ignore));
 390             }
 391             resultSyms[i] = use;
 392         }
 393         if (resultActs != NULL)
 394         {
 395             union xkb_action *fromAct, *toAct;
 396             fromAct = (from->acts[group] ? &from->acts[group][i] : NULL);
 397             toAct = (into->acts[group] ? &into->acts[group][i] : NULL);
 398             if (((fromAct == NULL) || (fromAct->type == XkbSA_NoAction))
 399                 && (toAct != NULL))
 400             {
 401                 resultActs[i] = *toAct;
 402             }
 403             else if (((toAct == NULL) || (toAct->type == XkbSA_NoAction))
 404                      && (fromAct != NULL))
 405             {
 406                 resultActs[i] = *fromAct;
 407             }
 408             else
 409             {
 410                 union xkb_action *use, *ignore;
 411                 if (clobber)
 412                 {
 413                     use = fromAct;
 414                     ignore = toAct;
 415                 }
 416                 else
 417                 {
 418                     use = toAct;
 419                     ignore = fromAct;
 420                 }
 421                 if (report)
 422                 {
 423                     WARN
 424                         ("Multiple actions for level %d/group %d on key %s\n",
 425                          i + 1, group + 1, longText(into->name));
 426                     ACTION("Using %s, ignoring %s\n",
 427                             XkbcActionTypeText(use->type),
 428                             XkbcActionTypeText(ignore->type));
 429                 }
 430                 if (use)
 431                     resultActs[i] = *use;
 432             }
 433         }
 434     }
 435     if (resultSyms != into->syms[group])
 436         free(into->syms[group]);
 437     if (resultSyms != from->syms[group])
 438         free(from->syms[group]);
 439     if (resultActs != into->acts[group])
 440         free(into->acts[group]);
 441     if (resultActs != from->acts[group])
 442         free(from->acts[group]);
 443     into->numLevels[group] = resultWidth;
 444     into->syms[group] = resultSyms;
 445     from->syms[group] = NULL;
 446     into->acts[group] = resultActs;
 447     from->acts[group] = NULL;
 448     into->symsDefined |= (1 << group);
 449     from->symsDefined &= ~(1 << group);
 450     into->actsDefined |= (1 << group);
 451     from->actsDefined &= ~(1 << group);
 452     return True;
 453 }
 454
 455 static Bool
 456 MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from)
 457 {
 458     int i;
 459     unsigned collide = 0;
 460     Bool report;
 461
 462     if (from->defs.merge == MergeReplace)
 463     {
 464         for (i = 0; i < XkbNumKbdGroups; i++)
 465         {
 466             if (into->numLevels[i] != 0)
 467             {
 468                 free(into->syms[i]);
 469                 free(into->acts[i]);
 470             }
 471         }
 472         *into = *from;
 473         memset(from, 0, sizeof(KeyInfo));
 474         return True;
 475     }
 476     report = ((warningLevel > 9) ||
 477               ((into->defs.fileID == from->defs.fileID)
 478                && (warningLevel > 0)));
 479     for (i = 0; i < XkbNumKbdGroups; i++)
 480     {
 481         if (from->numLevels[i] > 0)
 482         {
 483             if (into->numLevels[i] == 0)
 484             {
 485                 into->numLevels[i] = from->numLevels[i];
 486                 into->syms[i] = from->syms[i];
 487                 into->acts[i] = from->acts[i];
 488                 into->symsDefined |= (1 << i);
 489                 from->syms[i] = NULL;
 490                 from->acts[i] = NULL;
 491                 from->numLevels[i] = 0;
 492                 from->symsDefined &= ~(1 << i);
 493                 if (into->syms[i])
 494                     into->defs.defined |= _Key_Syms;
 495                 if (into->acts[i])
 496                     into->defs.defined |= _Key_Acts;
 497             }
 498             else
 499             {
 500                 if (report)
 501                 {
 502                     if (into->syms[i])
 503                         collide |= _Key_Syms;
 504                     if (into->acts[i])
 505                         collide |= _Key_Acts;
 506                 }
 507                 MergeKeyGroups(info, into, from, (unsigned) i);
 508             }
 509         }
 510         if (from->types[i] != None)
 511         {
 512             if ((into->types[i] != None) && (report) &&
 513                 (into->types[i] != from->types[i]))
 514             {
 515                 xkb_atom_t use, ignore;
 516                 collide |= _Key_Types;
 517                 if (from->defs.merge != MergeAugment)
 518                 {
 519                     use = from->types[i];
 520                     ignore = into->types[i];
 521                 }
 522                 else
 523                 {
 524                     use = into->types[i];
 525                     ignore = from->types[i];
 526                 }
 527                 WARN
 528                     ("Multiple definitions for group %d type of key %s\n",
 529                      i, longText(into->name));
 530                 ACTION("Using %s, ignoring %s\n",
 531                         XkbcAtomText(use),
 532                         XkbcAtomText(ignore));
 533             }
 534             if ((from->defs.merge != MergeAugment)
 535                 || (into->types[i] == None))
 536             {
 537                 into->types[i] = from->types[i];
 538             }
 539         }
 540     }
 541     if (UseNewField(_Key_Behavior, &into->defs, &from->defs, &collide))
 542     {
 543         into->behavior = from->behavior;
 544         into->defs.defined |= _Key_Behavior;
 545     }
 546     if (UseNewField(_Key_VModMap, &into->defs, &from->defs, &collide))
 547     {
 548         into->vmodmap = from->vmodmap;
 549         into->defs.defined |= _Key_VModMap;
 550     }
 551     if (UseNewField(_Key_Repeat, &into->defs, &from->defs, &collide))
 552     {
 553         into->repeat = from->repeat;
 554         into->defs.defined |= _Key_Repeat;
 555     }
 556     if (UseNewField(_Key_Type_Dflt, &into->defs, &from->defs, &collide))
 557     {
 558         into->dfltType = from->dfltType;
 559         into->defs.defined |= _Key_Type_Dflt;
 560     }
 561     if (UseNewField(_Key_GroupInfo, &into->defs, &from->defs, &collide))
 562     {
 563         into->groupInfo = from->groupInfo;
 564         into->defs.defined |= _Key_GroupInfo;
 565     }
 566     if (collide)
 567     {
 568         WARN("Symbol map for key %s redefined\n",
 569               longText(into->name));
 570         ACTION("Using %s definition for conflicting fields\n",
 571                 (from->defs.merge == MergeAugment ? "first" : "last"));
 572     }
 573     return True;
 574 }
 575
 576 static Bool
 577 AddKeySymbols(SymbolsInfo * info, KeyInfo * key, struct xkb_desc * xkb)
 578 {
 579     int i;
 580     unsigned long real_name;
 581
 582     for (i = 0; i < info->nKeys; i++)
 583     {
 584         if (info->keys[i].name == key->name)
 585             return MergeKeys(info, &info->keys[i], key);
 586     }
 587     if (FindKeyNameForAlias(xkb, key->name, &real_name))
 588     {
 589         for (i = 0; i < info->nKeys; i++)
 590         {
 591             if (info->keys[i].name == real_name)
 592                 return MergeKeys(info, &info->keys[i], key);
 593         }
 594     }
 595     if (info->nKeys >= info->szKeys)
 596     {
 597         info->szKeys += SYMBOLS_CHUNK;
 598         info->keys =
 599             uTypedRecalloc(info->keys, info->nKeys, info->szKeys, KeyInfo);
 600         if (!info->keys)
 601         {
 602             WSGO("Could not allocate key symbols descriptions\n");
 603             ACTION("Some key symbols definitions may be lost\n");
 604             return False;
 605         }
 606     }
 607     return CopyKeyInfo(key, &info->keys[info->nKeys++], True);
 608 }
 609
 610 static Bool
 611 AddModMapEntry(SymbolsInfo * info, ModMapEntry * new)
 612 {
 613     ModMapEntry *mm;
 614     Bool clobber;
 615
 616     clobber = (new->defs.merge != MergeAugment);
 617     for (mm = info->modMap; mm != NULL; mm = (ModMapEntry *) mm->defs.next)
 618     {
 619         if (new->haveSymbol && mm->haveSymbol
 620             && (new->u.keySym == mm->u.keySym))
 621         {
 622             unsigned use, ignore;
 623             if (mm->modifier != new->modifier)
 624             {
 625                 if (clobber)
 626                 {
 627                     use = new->modifier;
 628                     ignore = mm->modifier;
 629                 }
 630                 else
 631                 {
 632                     use = mm->modifier;
 633                     ignore = new->modifier;
 634                 }
 635                 ERROR
 636                     ("%s added to symbol map for multiple modifiers\n",
 637                      XkbcKeysymText(new->u.keySym));
 638                 ACTION("Using %s, ignoring %s.\n",
 639                         XkbcModIndexText(use),
 640                         XkbcModIndexText(ignore));
 641                 mm->modifier = use;
 642             }
 643             return True;
 644         }
 645         if ((!new->haveSymbol) && (!mm->haveSymbol) &&
 646             (new->u.keyName == mm->u.keyName))
 647         {
 648             unsigned use, ignore;
 649             if (mm->modifier != new->modifier)
 650             {
 651                 if (clobber)
 652                 {
 653                     use = new->modifier;
 654                     ignore = mm->modifier;
 655                 }
 656                 else
 657                 {
 658                     use = mm->modifier;
 659                     ignore = new->modifier;
 660                 }
 661                 ERROR("Key %s added to map for multiple modifiers\n",
 662                        longText(new->u.keyName));
 663                 ACTION("Using %s, ignoring %s.\n",
 664                         XkbcModIndexText(use),
 665                         XkbcModIndexText(ignore));
 666                 mm->modifier = use;
 667             }
 668             return True;
 669         }
 670     }
 671     mm = uTypedAlloc(ModMapEntry);
 672     if (mm == NULL)
 673     {
 674         WSGO("Could not allocate modifier map entry\n");
 675         ACTION("Modifier map for %s will be incomplete\n",
 676                 XkbcModIndexText(new->modifier));
 677         return False;
 678     }
 679     *mm = *new;
 680     mm->defs.next = &info->modMap->defs;
 681     info->modMap = mm;
 682     return True;
 683 }
 684
 685 /***====================================================================***/
 686
 687 static void
 688 MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from,
 689                      unsigned merge, struct xkb_desc * xkb)
 690 {
 691     int i;
 692     KeyInfo *key;
 693
 694     if (from->errorCount > 0)
 695     {
 696         into->errorCount += from->errorCount;
 697         return;
 698     }
 699     if (into->name == NULL)
 700     {
 701         into->name = from->name;
 702         from->name = NULL;
 703     }
 704     for (i = 0; i < XkbNumKbdGroups; i++)
 705     {
 706         if (from->groupNames[i] != None)
 707         {
 708             if ((merge != MergeAugment) || (into->groupNames[i] == None))
 709                 into->groupNames[i] = from->groupNames[i];
 710         }
 711     }
 712     for (i = 0, key = from->keys; i < from->nKeys; i++, key++)
 713     {
 714         if (merge != MergeDefault)
 715             key->defs.merge = merge;
 716         if (!AddKeySymbols(into, key, xkb))
 717             into->errorCount++;
 718     }
 719     if (from->modMap != NULL)
 720     {
 721         ModMapEntry *mm, *next;
 722         for (mm = from->modMap; mm != NULL; mm = next)
 723         {
 724             if (merge != MergeDefault)
 725                 mm->defs.merge = merge;
 726             if (!AddModMapEntry(into, mm))
 727                 into->errorCount++;
 728             next = (ModMapEntry *) mm->defs.next;
 729             free(mm);
 730         }
 731         from->modMap = NULL;
 732     }
 733     if (!MergeAliases(&into->aliases, &from->aliases, merge))
 734         into->errorCount++;
 735 }
 736
 737 typedef void (*FileHandler) (XkbFile * /* rtrn */ ,
 738                              struct xkb_desc * /* xkb */ ,
 739                              unsigned /* merge */ ,
 740                              SymbolsInfo *      /* included */
 741     );
 742
 743 static Bool
 744 HandleIncludeSymbols(IncludeStmt * stmt,
 745                      struct xkb_desc * xkb, SymbolsInfo * info, FileHandler hndlr)
 746 {
 747     unsigned newMerge;
 748     XkbFile *rtrn;
 749     SymbolsInfo included;
 750     Bool haveSelf;
 751
 752     haveSelf = False;
 753     if ((stmt->file == NULL) && (stmt->map == NULL))
 754     {
 755         haveSelf = True;
 756         included = *info;
 757         memset(info, 0, sizeof(SymbolsInfo));
 758     }
 759     else if (ProcessIncludeFile(stmt, XkmSymbolsIndex, &rtrn, &newMerge))
 760     {
 761         InitSymbolsInfo(&included, xkb);
 762         included.fileID = included.dflt.defs.fileID = rtrn->id;
 763         included.merge = included.dflt.defs.merge = MergeOverride;
 764         if (stmt->modifier)
 765         {
 766             included.explicit_group = atoi(stmt->modifier) - 1;
 767         }
 768         else
 769         {
 770             included.explicit_group = info->explicit_group;
 771         }
 772         (*hndlr) (rtrn, xkb, MergeOverride, &included);
 773         if (stmt->stmt != NULL)
 774         {
 775             free(included.name);
 776             included.name = stmt->stmt;
 777             stmt->stmt = NULL;
 778         }
 779         FreeXKBFile(rtrn);
 780     }
 781     else
 782     {
 783         info->errorCount += 10;
 784         return False;
 785     }
 786     if ((stmt->next != NULL) && (included.errorCount < 1))
 787     {
 788         IncludeStmt *next;
 789         unsigned op;
 790         SymbolsInfo next_incl;
 791
 792         for (next = stmt->next; next != NULL; next = next->next)
 793         {
 794             if ((next->file == NULL) && (next->map == NULL))
 795             {
 796                 haveSelf = True;
 797                 MergeIncludedSymbols(&included, info, next->merge, xkb);
 798                 FreeSymbolsInfo(info);
 799             }
 800             else if (ProcessIncludeFile(next, XkmSymbolsIndex, &rtrn, &op))
 801             {
 802                 InitSymbolsInfo(&next_incl, xkb);
 803                 next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
 804                 next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
 805                 if (next->modifier)
 806                 {
 807                     next_incl.explicit_group = atoi(next->modifier) - 1;
 808                 }
 809                 else
 810                 {
 811                     next_incl.explicit_group = info->explicit_group;
 812                 }
 813                 (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
 814                 MergeIncludedSymbols(&included, &next_incl, op, xkb);
 815                 FreeSymbolsInfo(&next_incl);
 816                 FreeXKBFile(rtrn);
 817             }
 818             else
 819             {
 820                 info->errorCount += 10;
 821                 return False;
 822             }
 823         }
 824     }
 825     if (haveSelf)
 826         *info = included;
 827     else
 828     {
 829         MergeIncludedSymbols(info, &included, newMerge, xkb);
 830         FreeSymbolsInfo(&included);
 831     }
 832     return (info->errorCount == 0);
 833 }
 834
 835 #define SYMBOLS 1
 836 #define ACTIONS 2
 837
 838 static Bool
 839 GetGroupIndex(KeyInfo * key,
 840               ExprDef * arrayNdx, unsigned what, unsigned *ndx_rtrn)
 841 {
 842     const char *name;
 843     ExprResult tmp;
 844
 845     if (what == SYMBOLS)
 846         name = "symbols";
 847     else
 848         name = "actions";
 849
 850     if (arrayNdx == NULL)
 851     {
 852         int i;
 853         unsigned defined;
 854         if (what == SYMBOLS)
 855             defined = key->symsDefined;
 856         else
 857             defined = key->actsDefined;
 858
 859         for (i = 0; i < XkbNumKbdGroups; i++)
 860         {
 861             if ((defined & (1 << i)) == 0)
 862             {
 863                 *ndx_rtrn = i;
 864                 return True;
 865             }
 866         }
 867         ERROR("Too many groups of %s for key %s (max %d)\n", name,
 868                longText(key->name), XkbNumKbdGroups + 1);
 869         ACTION("Ignoring %s defined for extra groups\n", name);
 870         return False;
 871     }
 872     if (!ExprResolveGroup(arrayNdx, &tmp))
 873     {
 874         ERROR("Illegal group index for %s of key %s\n", name,
 875                longText(key->name));
 876         ACTION("Definition with non-integer array index ignored\n");
 877         return False;
 878     }
 879     *ndx_rtrn = tmp.uval - 1;
 880     return True;
 881 }
 882
 883 static Bool
 884 AddSymbolsToKey(KeyInfo * key,
 885                 struct xkb_desc * xkb,
 886                 char *field,
 887                 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
 888 {
 889     unsigned ndx, nSyms;
 890     int i;
 891
 892     if (!GetGroupIndex(key, arrayNdx, SYMBOLS, &ndx))
 893         return False;
 894     if (value == NULL)
 895     {
 896         key->symsDefined |= (1 << ndx);
 897         return True;
 898     }
 899     if (value->op != ExprKeysymList)
 900     {
 901         ERROR("Expected a list of symbols, found %s\n",
 902                exprOpText(value->op));
 903         ACTION("Ignoring symbols for group %d of %s\n", ndx,
 904                 longText(key->name));
 905         return False;
 906     }
 907     if (key->syms[ndx] != NULL)
 908     {
 909         WSGO("Symbols for key %s, group %d already defined\n",
 910               longText(key->name), ndx);
 911         return False;
 912     }
 913     nSyms = value->value.list.nSyms;
 914     if (((key->numLevels[ndx] < nSyms) || (key->syms[ndx] == NULL)) &&
 915         (!ResizeKeyGroup(key, ndx, nSyms, False)))
 916     {
 917         WSGO("Could not resize group %d of key %s\n", ndx,
 918               longText(key->name));
 919         ACTION("Symbols lost\n");
 920         return False;
 921     }
 922     key->symsDefined |= (1 << ndx);
 923     for (i = 0; i < nSyms; i++) {
 924         if (!LookupKeysym(value->value.list.syms[i], &key->syms[ndx][i])) {
 925             WSGO("Could not resolve keysym %s\n", value->value.list.syms[i]);
 926             key->syms[ndx][i] = NoSymbol;
 927         }
 928     }
 929     for (i = key->numLevels[ndx] - 1;
 930          (i >= 0) && (key->syms[ndx][i] == NoSymbol); i--)
 931     {
 932         key->numLevels[ndx]--;
 933     }
 934     return True;
 935 }
 936
 937 static Bool
 938 AddActionsToKey(KeyInfo * key,
 939                 struct xkb_desc * xkb,
 940                 char *field,
 941                 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
 942 {
 943     int i;
 944     unsigned ndx, nActs;
 945     ExprDef *act;
 946     struct xkb_any_action *toAct;
 947
 948     if (!GetGroupIndex(key, arrayNdx, ACTIONS, &ndx))
 949         return False;
 950
 951     if (value == NULL)
 952     {
 953         key->actsDefined |= (1 << ndx);
 954         return True;
 955     }
 956     if (value->op != ExprActionList)
 957     {
 958         WSGO("Bad expression type (%d) for action list value\n", value->op);
 959         ACTION("Ignoring actions for group %d of %s\n", ndx,
 960                 longText(key->name));
 961         return False;
 962     }
 963     if (key->acts[ndx] != NULL)
 964     {
 965         WSGO("Actions for key %s, group %d already defined\n",
 966               longText(key->name), ndx);
 967         return False;
 968     }
 969     for (nActs = 0, act = value->value.child; act != NULL; nActs++)
 970     {
 971         act = (ExprDef *) act->common.next;
 972     }
 973     if (nActs < 1)
 974     {
 975         WSGO("Action list but not actions in AddActionsToKey\n");
 976         return False;
 977     }
 978     if (((key->numLevels[ndx] < nActs) || (key->acts[ndx] == NULL)) &&
 979         (!ResizeKeyGroup(key, ndx, nActs, True)))
 980     {
 981         WSGO("Could not resize group %d of key %s\n", ndx,
 982               longText(key->name));
 983         ACTION("Actions lost\n");
 984         return False;
 985     }
 986     key->actsDefined |= (1 << ndx);
 987
 988     toAct = (struct xkb_any_action *) key->acts[ndx];
 989     act = value->value.child;
 990     for (i = 0; i < nActs; i++, toAct++)
 991     {
 992         if (!HandleActionDef(act, xkb, toAct, MergeOverride, info->action))
 993         {
 994             ERROR("Illegal action definition for %s\n",
 995                    longText(key->name));
 996             ACTION("Action for group %d/level %d ignored\n", ndx + 1, i + 1);
 997         }
 998         act = (ExprDef *) act->common.next;
 999     }
1000     return True;
1001 }
1002
1003 static const LookupEntry lockingEntries[] = {
1004     {"true", XkbKB_Lock},
1005     {"yes", XkbKB_Lock},
1006     {"on", XkbKB_Lock},
1007     {"false", XkbKB_Default},
1008     {"no", XkbKB_Default},
1009     {"off", XkbKB_Default},
1010     {"permanent", XkbKB_Lock | XkbKB_Permanent},
1011     {NULL, 0}
1012 };
1013
1014 static const LookupEntry repeatEntries[] = {
1015     {"true", RepeatYes},
1016     {"yes", RepeatYes},
1017     {"on", RepeatYes},
1018     {"false", RepeatNo},
1019     {"no", RepeatNo},
1020     {"off", RepeatNo},
1021     {"default", RepeatUndefined},
1022     {NULL, 0}
1023 };
1024
1025 static Bool
1026 SetSymbolsField(KeyInfo * key,
1027                 struct xkb_desc * xkb,
1028                 char *field,
1029                 ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
1030 {
1031     Bool ok = True;
1032     ExprResult tmp;
1033
1034     if (uStrCaseCmp(field, "type") == 0)
1035     {
1036         ExprResult ndx;
1037         if ((!ExprResolveString(value, &tmp))
1038             && (warningLevel > 0))
1039         {
1040             WARN("The type field of a key symbol map must be a string\n");
1041             ACTION("Ignoring illegal type definition\n");
1042         }
1043         if (arrayNdx == NULL)
1044         {
1045             key->dfltType = xkb_intern_atom(tmp.str);
1046             key->defs.defined |= _Key_Type_Dflt;
1047         }
1048         else if (!ExprResolveGroup(arrayNdx, &ndx))
1049         {
1050             ERROR("Illegal group index for type of key %s\n",
1051                    longText(key->name));
1052             ACTION("Definition with non-integer array index ignored\n");
1053             free(tmp.str);
1054             return False;
1055         }
1056         else
1057         {
1058             key->types[ndx.uval - 1] = xkb_intern_atom(tmp.str);
1059             key->typesDefined |= (1 << (ndx.uval - 1));
1060         }
1061         free(tmp.str);
1062     }
1063     else if (uStrCaseCmp(field, "symbols") == 0)
1064         return AddSymbolsToKey(key, xkb, field, arrayNdx, value, info);
1065     else if (uStrCaseCmp(field, "actions") == 0)
1066         return AddActionsToKey(key, xkb, field, arrayNdx, value, info);
1067     else if ((uStrCaseCmp(field, "vmods") == 0) ||
1068              (uStrCaseCmp(field, "virtualmods") == 0) ||
1069              (uStrCaseCmp(field, "virtualmodifiers") == 0))
1070     {
1071         ok = ExprResolveVModMask(value, &tmp, xkb);
1072         if (ok)
1073         {
1074             key->vmodmap = (tmp.uval >> 8);
1075             key->defs.defined |= _Key_VModMap;
1076         }
1077         else
1078         {
1079             ERROR("Expected a virtual modifier mask, found %s\n",
1080                    exprOpText(value->op));
1081             ACTION("Ignoring virtual modifiers definition for key %s\n",
1082                     longText(key->name));
1083         }
1084     }
1085     else if ((uStrCaseCmp(field, "locking") == 0)
1086              || (uStrCaseCmp(field, "lock") == 0)
1087              || (uStrCaseCmp(field, "locks") == 0))
1088     {
1089         ok = ExprResolveEnum(value, &tmp, lockingEntries);
1090         if (ok)
1091             key->behavior.type = tmp.uval;
1092         key->defs.defined |= _Key_Behavior;
1093     }
1094     else if ((uStrCaseCmp(field, "radiogroup") == 0) ||
1095              (uStrCaseCmp(field, "permanentradiogroup") == 0) ||
1096              (uStrCaseEqual(field, "allownone")))
1097     {
1098         ERROR("Radio groups not supported\n");
1099         ACTION("Ignoring radio group specification for key %s\n", longText(key->name));
1100         return False;
1101     }
1102     else if (uStrCasePrefix("overlay", field) ||
1103              uStrCasePrefix("permanentoverlay", field))
1104     {
1105         ERROR("Overlays not supported\n");
1106         ACTION("Ignoring overlay specification for key %s\n", longText(key->name));
1107     }
1108     else if ((uStrCaseCmp(field, "repeating") == 0) ||
1109              (uStrCaseCmp(field, "repeats") == 0) ||
1110              (uStrCaseCmp(field, "repeat") == 0))
1111     {
1112         ok = ExprResolveEnum(value, &tmp, repeatEntries);
1113         if (!ok)
1114         {
1115             ERROR("Illegal repeat setting for %s\n",
1116                    longText(key->name));
1117             ACTION("Non-boolean repeat setting ignored\n");
1118             return False;
1119         }
1120         key->repeat = tmp.uval;
1121         key->defs.defined |= _Key_Repeat;
1122     }
1123     else if ((uStrCaseCmp(field, "groupswrap") == 0) ||
1124              (uStrCaseCmp(field, "wrapgroups") == 0))
1125     {
1126         ok = ExprResolveBoolean(value, &tmp);
1127         if (!ok)
1128         {
1129             ERROR("Illegal groupsWrap setting for %s\n",
1130                    longText(key->name));
1131             ACTION("Non-boolean value ignored\n");
1132             return False;
1133         }
1134         if (tmp.uval)
1135             key->groupInfo = XkbWrapIntoRange;
1136         else
1137             key->groupInfo = XkbClampIntoRange;
1138         key->defs.defined |= _Key_GroupInfo;
1139     }
1140     else if ((uStrCaseCmp(field, "groupsclamp") == 0) ||
1141              (uStrCaseCmp(field, "clampgroups") == 0))
1142     {
1143         ok = ExprResolveBoolean(value, &tmp);
1144         if (!ok)
1145         {
1146             ERROR("Illegal groupsClamp setting for %s\n",
1147                    longText(key->name));
1148             ACTION("Non-boolean value ignored\n");
1149             return False;
1150         }
1151         if (tmp.uval)
1152             key->groupInfo = XkbClampIntoRange;
1153         else
1154             key->groupInfo = XkbWrapIntoRange;
1155         key->defs.defined |= _Key_GroupInfo;
1156     }
1157     else if ((uStrCaseCmp(field, "groupsredirect") == 0) ||
1158              (uStrCaseCmp(field, "redirectgroups") == 0))
1159     {
1160         if (!ExprResolveGroup(value, &tmp))
1161         {
1162             ERROR("Illegal group index for redirect of key %s\n",
1163                    longText(key->name));
1164             ACTION("Definition with non-integer group ignored\n");
1165             return False;
1166         }
1167         key->groupInfo =
1168             XkbSetGroupInfo(0, XkbRedirectIntoRange, tmp.uval - 1);
1169         key->defs.defined |= _Key_GroupInfo;
1170     }
1171     else
1172     {
1173         ERROR("Unknown field %s in a symbol interpretation\n", field);
1174         ACTION("Definition ignored\n");
1175         ok = False;
1176     }
1177     return ok;
1178 }
1179
1180 static int
1181 SetGroupName(SymbolsInfo * info, ExprDef * arrayNdx, ExprDef * value)
1182 {
1183     ExprResult tmp, name;
1184
1185     if ((arrayNdx == NULL) && (warningLevel > 0))
1186     {
1187         WARN("You must specify an index when specifying a group name\n");
1188         ACTION("Group name definition without array subscript ignored\n");
1189         return False;
1190     }
1191     if (!ExprResolveGroup(arrayNdx, &tmp))
1192     {
1193         ERROR("Illegal index in group name definition\n");
1194         ACTION("Definition with non-integer array index ignored\n");
1195         return False;
1196     }
1197     if (!ExprResolveString(value, &name))
1198     {
1199         ERROR("Group name must be a string\n");
1200         ACTION("Illegal name for group %d ignored\n", tmp.uval);
1201         return False;
1202     }
1203     info->groupNames[tmp.uval - 1 + info->explicit_group] =
1204         xkb_intern_atom(name.str);
1205     free(name.str);
1206
1207     return True;
1208 }
1209
1210 static int
1211 HandleSymbolsVar(VarDef * stmt, struct xkb_desc * xkb, SymbolsInfo * info)
1212 {
1213     ExprResult elem, field, tmp;
1214     ExprDef *arrayNdx;
1215     Bool ret;
1216
1217     if (ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx) == 0)
1218         return 0;               /* internal error, already reported */
1219     if (elem.str && (uStrCaseCmp(elem.str, "key") == 0))
1220     {
1221         ret = SetSymbolsField(&info->dflt, xkb, field.str, arrayNdx,
1222                               stmt->value, info);
1223     }
1224     else if ((elem.str == NULL) && ((uStrCaseCmp(field.str, "name") == 0) ||
1225                                     (uStrCaseCmp(field.str, "groupname") ==
1226                                      0)))
1227     {
1228         ret = SetGroupName(info, arrayNdx, stmt->value);
1229     }
1230     else if ((elem.str == NULL)
1231              && ((uStrCaseCmp(field.str, "groupswrap") == 0)
1232                  || (uStrCaseCmp(field.str, "wrapgroups") == 0)))
1233     {
1234         if (!ExprResolveBoolean(stmt->value, &tmp))
1235         {
1236             ERROR("Illegal setting for global groupsWrap\n");
1237             ACTION("Non-boolean value ignored\n");
1238             ret = False;
1239         }
1240         else {
1241             if (tmp.uval)
1242                 info->groupInfo = XkbWrapIntoRange;
1243             else
1244                 info->groupInfo = XkbClampIntoRange;
1245             ret = True;
1246         }
1247     }
1248     else if ((elem.str == NULL)
1249              && ((uStrCaseCmp(field.str, "groupsclamp") == 0)
1250                  || (uStrCaseCmp(field.str, "clampgroups") == 0)))
1251     {
1252         if (!ExprResolveBoolean(stmt->value, &tmp))
1253         {
1254             ERROR("Illegal setting for global groupsClamp\n");
1255             ACTION("Non-boolean value ignored\n");
1256             return False;
1257         }
1258         else {
1259             if (tmp.uval)
1260                 info->groupInfo = XkbClampIntoRange;
1261             else
1262                 info->groupInfo = XkbWrapIntoRange;
1263             ret = True;
1264         }
1265     }
1266     else if ((elem.str == NULL)
1267              && ((uStrCaseCmp(field.str, "groupsredirect") == 0)
1268                  || (uStrCaseCmp(field.str, "redirectgroups") == 0)))
1269     {
1270         if (!ExprResolveGroup(stmt->value, &tmp))
1271         {
1272             ERROR("Illegal group index for global groupsRedirect\n");
1273             ACTION("Definition with non-integer group ignored\n");
1274             ret = False;
1275         }
1276         else {
1277             info->groupInfo = XkbSetGroupInfo(0, XkbRedirectIntoRange,
1278                                               tmp.uval);
1279             ret = True;
1280         }
1281     }
1282     else if ((elem.str == NULL) && (uStrCaseCmp(field.str, "allownone") == 0))
1283     {
1284         ERROR("Radio groups not supported\n");
1285         ACTION("Ignoring \"allow none\" specification\n");
1286         ret = False;
1287     }
1288     else {
1289         ret = SetActionField(xkb, elem.str, field.str, arrayNdx, stmt->value,
1290                              &info->action);
1291     }
1292
1293     free(elem.str);
1294     free(field.str);
1295     return ret;
1296 }
1297
1298 static Bool
1299 HandleSymbolsBody(VarDef * def,
1300                   struct xkb_desc * xkb, KeyInfo * key, SymbolsInfo * info)
1301 {
1302     Bool ok = True;
1303     ExprResult tmp, field;
1304     ExprDef *arrayNdx;
1305
1306     for (; def != NULL; def = (VarDef *) def->common.next)
1307     {
1308         if ((def->name) && (def->name->type == ExprFieldRef))
1309         {
1310             ok = HandleSymbolsVar(def, xkb, info);
1311             continue;
1312         }
1313         else
1314         {
1315             if (def->name == NULL)
1316             {
1317                 if ((def->value == NULL)
1318                     || (def->value->op == ExprKeysymList))
1319                     field.str = strdup("symbols");
1320                 else
1321                     field.str = strdup("actions");
1322                 arrayNdx = NULL;
1323             }
1324             else
1325             {
1326                 ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
1327             }
1328             if (ok)
1329                 ok = SetSymbolsField(key, xkb, field.str, arrayNdx,
1330                                      def->value, info);
1331             free(field.str);
1332         }
1333     }
1334     return ok;
1335 }
1336
1337 static Bool
1338 SetExplicitGroup(SymbolsInfo * info, KeyInfo * key)
1339 {
1340     unsigned group = info->explicit_group;
1341
1342     if (group == 0)
1343         return True;
1344
1345     if ((key->typesDefined | key->symsDefined | key->actsDefined) & ~1)
1346     {
1347         int i;
1348         WARN("For the map %s an explicit group specified\n", info->name);
1349         WARN("but key %s has more than one group defined\n",
1350               longText(key->name));
1351         ACTION("All groups except first one will be ignored\n");
1352         for (i = 1; i < XkbNumKbdGroups; i++)
1353         {
1354             key->numLevels[i] = 0;
1355             free(key->syms[i]);
1356             key->syms[i] = NULL;
1357             free(key->acts[i]);
1358             key->acts[i] = NULL;
1359             key->types[i] = 0;
1360         }
1361     }
1362     key->typesDefined = key->symsDefined = key->actsDefined = 1 << group;
1363
1364     key->numLevels[group] = key->numLevels[0];
1365     key->numLevels[0] = 0;
1366     key->syms[group] = key->syms[0];
1367     key->syms[0] = NULL;
1368     key->acts[group] = key->acts[0];
1369     key->acts[0] = NULL;
1370     key->types[group] = key->types[0];
1371     key->types[0] = 0;
1372     return True;
1373 }
1374
1375 static int
1376 HandleSymbolsDef(SymbolsDef * stmt,
1377                  struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1378 {
1379     KeyInfo key;
1380
1381     InitKeyInfo(&key);
1382     CopyKeyInfo(&info->dflt, &key, False);
1383     key.defs.merge = stmt->merge;
1384     key.name = KeyNameToLong(stmt->keyName);
1385     if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info))
1386     {
1387         info->errorCount++;
1388         return False;
1389     }
1390
1391     if (!SetExplicitGroup(info, &key))
1392     {
1393         info->errorCount++;
1394         return False;
1395     }
1396
1397     if (!AddKeySymbols(info, &key, xkb))
1398     {
1399         info->errorCount++;
1400         return False;
1401     }
1402     return True;
1403 }
1404
1405 static Bool
1406 HandleModMapDef(ModMapDef * def,
1407                 struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1408 {
1409     ExprDef *key;
1410     ModMapEntry tmp;
1411     ExprResult rtrn;
1412     Bool ok;
1413
1414     if (!LookupModIndex(NULL, def->modifier, TypeInt, &rtrn))
1415     {
1416         ERROR("Illegal modifier map definition\n");
1417         ACTION("Ignoring map for non-modifier \"%s\"\n",
1418                 XkbcAtomText(def->modifier));
1419         return False;
1420     }
1421     ok = True;
1422     tmp.modifier = rtrn.uval;
1423     for (key = def->keys; key != NULL; key = (ExprDef *) key->common.next)
1424     {
1425         if ((key->op == ExprValue) && (key->type == TypeKeyName))
1426         {
1427             tmp.haveSymbol = False;
1428             tmp.u.keyName = KeyNameToLong(key->value.keyName);
1429         }
1430         else if (ExprResolveKeySym(key, &rtrn))
1431         {
1432             tmp.haveSymbol = True;
1433             tmp.u.keySym = rtrn.uval;
1434         }
1435         else
1436         {
1437             ERROR("Modmap entries may contain only key names or keysyms\n");
1438             ACTION("Illegal definition for %s modifier ignored\n",
1439                     XkbcModIndexText(tmp.modifier));
1440             continue;
1441         }
1442
1443         ok = AddModMapEntry(info, &tmp) && ok;
1444     }
1445     return ok;
1446 }
1447
1448 static void
1449 HandleSymbolsFile(XkbFile * file,
1450                   struct xkb_desc * xkb, unsigned merge, SymbolsInfo * info)
1451 {
1452     ParseCommon *stmt;
1453
1454     free(info->name);
1455     info->name = _XkbDupString(file->name);
1456     stmt = file->defs;
1457     while (stmt)
1458     {
1459         switch (stmt->stmtType)
1460         {
1461         case StmtInclude:
1462             if (!HandleIncludeSymbols((IncludeStmt *) stmt, xkb, info,
1463                                       HandleSymbolsFile))
1464                 info->errorCount++;
1465             break;
1466         case StmtSymbolsDef:
1467             if (!HandleSymbolsDef((SymbolsDef *) stmt, xkb, merge, info))
1468                 info->errorCount++;
1469             break;
1470         case StmtVarDef:
1471             if (!HandleSymbolsVar((VarDef *) stmt, xkb, info))
1472                 info->errorCount++;
1473             break;
1474         case StmtVModDef:
1475             if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
1476                 info->errorCount++;
1477             break;
1478         case StmtInterpDef:
1479             ERROR("Interpretation files may not include other types\n");
1480             ACTION("Ignoring definition of symbol interpretation\n");
1481             info->errorCount++;
1482             break;
1483         case StmtKeycodeDef:
1484             ERROR("Interpretation files may not include other types\n");
1485             ACTION("Ignoring definition of key name\n");
1486             info->errorCount++;
1487             break;
1488         case StmtModMapDef:
1489             if (!HandleModMapDef((ModMapDef *) stmt, xkb, merge, info))
1490                 info->errorCount++;
1491             break;
1492         default:
1493             WSGO("Unexpected statement type %d in HandleSymbolsFile\n",
1494                   stmt->stmtType);
1495             break;
1496         }
1497         stmt = stmt->next;
1498         if (info->errorCount > 10)
1499         {
1500 #ifdef NOISY
1501             ERROR("Too many errors\n");
1502 #endif
1503             ACTION("Abandoning symbols file \"%s\"\n", file->topName);
1504             break;
1505         }
1506     }
1507 }
1508
1509 static Bool
1510 FindKeyForSymbol(struct xkb_desc * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rtrn)
1511 {
1512     int i, j;
1513     Bool gotOne;
1514
1515     j = 0;
1516     do
1517     {
1518         gotOne = False;
1519         for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++)
1520         {
1521             if (j < (int) XkbKeyNumSyms(xkb, i))
1522             {
1523                 gotOne = True;
1524                 if (XkbKeySym(xkb, i, j) == sym)
1525                 {
1526                     *kc_rtrn = i;
1527                     return True;
1528                 }
1529             }
1530         }
1531         j++;
1532     }
1533     while (gotOne);
1534     return False;
1535 }
1536
1537 /**
1538  * Find the given name in the xkb->map->types and return its index.
1539  *
1540  * @param atom The atom to search for.
1541  * @param type_rtrn Set to the index of the name if found.
1542  *
1543  * @return True if found, False otherwise.
1544  */
1545 static Bool
1546 FindNamedType(struct xkb_desc * xkb, xkb_atom_t atom, unsigned *type_rtrn)
1547 {
1548     unsigned n;
1549     const char *name = XkbcAtomText(atom);
1550
1551     if (xkb && xkb->map && xkb->map->types)
1552     {
1553         for (n = 0; n < xkb->map->num_types; n++)
1554         {
1555             if (strcmp(xkb->map->types[n].name, name) == 0)
1556             {
1557                 *type_rtrn = n;
1558                 return True;
1559             }
1560         }
1561     }
1562     return False;
1563 }
1564
1565 /**
1566  * Assign a type to the given sym and return the Atom for the type assigned.
1567  *
1568  * Simple recipe:
1569  * - ONE_LEVEL for width 0/1
1570  * - ALPHABETIC for 2 shift levels, with lower/upercase
1571  * - KEYPAD for keypad keys.
1572  * - TWO_LEVEL for other 2 shift level keys.
1573  * and the same for four level keys.
1574  *
1575  * @param width Number of sysms in syms.
1576  * @param syms The keysyms for the given key (must be size width).
1577  * @param typeNameRtrn Set to the Atom of the type name.
1578  *
1579  * @returns True if a type could be found, False otherwise.
1580  */
1581 static Bool
1582 FindAutomaticType(int width, xkb_keysym_t * syms, xkb_atom_t * typeNameRtrn,
1583                   Bool * autoType)
1584 {
1585     *autoType = False;
1586     if ((width == 1) || (width == 0))
1587     {
1588         *typeNameRtrn = xkb_intern_atom("ONE_LEVEL");
1589         *autoType = True;
1590     }
1591     else if (width == 2)
1592     {
1593         if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1594         {
1595             *typeNameRtrn = xkb_intern_atom("ALPHABETIC");
1596         }
1597         else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1598         {
1599             *typeNameRtrn = xkb_intern_atom("KEYPAD");
1600             *autoType = True;
1601         }
1602         else
1603         {
1604             *typeNameRtrn = xkb_intern_atom("TWO_LEVEL");
1605             *autoType = True;
1606         }
1607     }
1608     else if (width <= 4)
1609     {
1610         if (syms && XkbcKSIsLower(syms[0]) && XkbcKSIsUpper(syms[1]))
1611             if (XkbcKSIsLower(syms[2]) && XkbcKSIsUpper(syms[3]))
1612                 *typeNameRtrn =
1613                     xkb_intern_atom("FOUR_LEVEL_ALPHABETIC");
1614             else
1615                 *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_SEMIALPHABETIC");
1616
1617         else if (syms && (XkbKSIsKeypad(syms[0]) || XkbKSIsKeypad(syms[1])))
1618             *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL_KEYPAD");
1619         else
1620             *typeNameRtrn = xkb_intern_atom("FOUR_LEVEL");
1621         /* XXX: why not set autoType here? */
1622     }
1623     return ((width >= 0) && (width <= 4));
1624 }
1625
1626 /**
1627  * Ensure the given KeyInfo is in a coherent state, i.e. no gaps between the
1628  * groups, and reduce to one group if all groups are identical anyway.
1629  */
1630 static void
1631 PrepareKeyDef(KeyInfo * key)
1632 {
1633     int i, j, width, defined, lastGroup;
1634     Bool identical;
1635
1636     defined = key->symsDefined | key->actsDefined | key->typesDefined;
1637     /* get highest group number */
1638     for (i = XkbNumKbdGroups - 1; i >= 0; i--)
1639     {
1640         if (defined & (1 << i))
1641             break;
1642     }
1643     lastGroup = i;
1644
1645     if (lastGroup == 0)
1646         return;
1647
1648     /* If there are empty groups between non-empty ones fill them with data */
1649     /* from the first group. */
1650     /* We can make a wrong assumption here. But leaving gaps is worse. */
1651     for (i = lastGroup; i > 0; i--)
1652     {
1653         if (defined & (1 << i))
1654             continue;
1655         width = key->numLevels[0];
1656         if (key->typesDefined & 1)
1657         {
1658             for (j = 0; j < width; j++)
1659             {
1660                 key->types[i] = key->types[0];
1661             }
1662             key->typesDefined |= 1 << i;
1663         }
1664         if ((key->actsDefined & 1) && key->acts[0])
1665         {
1666             key->acts[i] = uTypedCalloc(width, union xkb_action);
1667             if (key->acts[i] == NULL)
1668                 continue;
1669             memcpy(key->acts[i], key->acts[0],
1670                    width * sizeof(union xkb_action));
1671             key->actsDefined |= 1 << i;
1672         }
1673         if ((key->symsDefined & 1) && key->syms[0])
1674         {
1675             key->syms[i] = uTypedCalloc(width, xkb_keysym_t);
1676             if (key->syms[i] == NULL)
1677                 continue;
1678             memcpy(key->syms[i], key->syms[0], width * sizeof(xkb_keysym_t));
1679             key->symsDefined |= 1 << i;
1680         }
1681         if (defined & 1)
1682         {
1683             key->numLevels[i] = key->numLevels[0];
1684         }
1685     }
1686     /* If all groups are completely identical remove them all */
1687     /* exept the first one. */
1688     identical = True;
1689     for (i = lastGroup; i > 0; i--)
1690     {
1691         if ((key->numLevels[i] != key->numLevels[0]) ||
1692             (key->types[i] != key->types[0]))
1693         {
1694             identical = False;
1695             break;
1696         }
1697         if ((key->syms[i] != key->syms[0]) &&
1698             (key->syms[i] == NULL || key->syms[0] == NULL ||
1699              memcmp(key->syms[i], key->syms[0],
1700                     sizeof(xkb_keysym_t) * key->numLevels[0])))
1701         {
1702             identical = False;
1703             break;
1704         }
1705         if ((key->acts[i] != key->acts[0]) &&
1706             (key->acts[i] == NULL || key->acts[0] == NULL ||
1707              memcmp(key->acts[i], key->acts[0],
1708                     sizeof(union xkb_action) * key->numLevels[0])))
1709         {
1710             identical = False;
1711             break;
1712         }
1713     }
1714     if (identical)
1715     {
1716         for (i = lastGroup; i > 0; i--)
1717         {
1718             key->numLevels[i] = 0;
1719             free(key->syms[i]);
1720             key->syms[i] = NULL;
1721             free(key->acts[i]);
1722             key->acts[i] = NULL;
1723             key->types[i] = 0;
1724         }
1725         key->symsDefined &= 1;
1726         key->actsDefined &= 1;
1727         key->typesDefined &= 1;
1728     }
1729 }
1730
1731 /**
1732  * Copy the KeyInfo into the keyboard description.
1733  *
1734  * This function recurses.
1735  */
1736 static Bool
1737 CopySymbolsDef(struct xkb_desc * xkb, KeyInfo *key, int start_from)
1738 {
1739     int i;
1740     xkb_keycode_t kc;
1741     unsigned width, tmp, nGroups;
1742     struct xkb_key_type * type;
1743     Bool haveActions, autoType, useAlias;
1744     xkb_keysym_t *outSyms;
1745     union xkb_action *outActs;
1746     unsigned types[XkbNumKbdGroups];
1747
1748     useAlias = (start_from == 0);
1749
1750     /* get the keycode for the key. */
1751     if (!FindNamedKey(xkb, key->name, &kc, useAlias, CreateKeyNames(xkb),
1752                       start_from))
1753     {
1754         if ((start_from == 0) && (warningLevel >= 5))
1755         {
1756             WARN("Key %s not found in keycodes\n", longText(key->name));
1757             ACTION("Symbols ignored\n");
1758         }
1759         return False;
1760     }
1761
1762     haveActions = False;
1763     for (i = width = nGroups = 0; i < XkbNumKbdGroups; i++)
1764     {
1765         if (((i + 1) > nGroups)
1766             && (((key->symsDefined | key->actsDefined) & (1 << i))
1767                 || (key->typesDefined) & (1 << i)))
1768             nGroups = i + 1;
1769         if (key->acts[i])
1770             haveActions = True;
1771         autoType = False;
1772         /* Assign the type to the key, if it is missing. */
1773         if (key->types[i] == None)
1774         {
1775             if (key->dfltType != None)
1776                 key->types[i] = key->dfltType;
1777             else if (FindAutomaticType(key->numLevels[i], key->syms[i],
1778                                        &key->types[i], &autoType))
1779             {
1780             }
1781             else
1782             {
1783                 if (warningLevel >= 5)
1784                 {
1785                     WARN("No automatic type for %d symbols\n",
1786                           (unsigned int) key->numLevels[i]);
1787                     ACTION("Using %s for the %s key (keycode %d)\n",
1788                             XkbcAtomText(key->types[i]),
1789                             longText(key->name), kc);
1790                 }
1791             }
1792         }
1793         if (FindNamedType(xkb, key->types[i], &types[i]))
1794         {
1795             if (!autoType || key->numLevels[i] > 2)
1796                 xkb->server->explicit[kc] |= (1 << i);
1797         }
1798         else
1799         {
1800             if (warningLevel >= 3)
1801             {
1802                 WARN("Type \"%s\" is not defined\n",
1803                       XkbcAtomText(key->types[i]));
1804                 ACTION("Using TWO_LEVEL for the %s key (keycode %d)\n",
1805                         longText(key->name), kc);
1806             }
1807             types[i] = XkbTwoLevelIndex;
1808         }
1809         /* if the type specifies less syms than the key has, shrink the key */
1810         type = &xkb->map->types[types[i]];
1811         if (type->num_levels < key->numLevels[i])
1812         {
1813             if (warningLevel > 0)
1814             {
1815                 WARN("Type \"%s\" has %d levels, but %s has %d symbols\n",
1816                      type->name, type->num_levels,
1817                      XkbcAtomText(key->name), key->numLevels[i]);
1818                 ACTION("Ignoring extra symbols\n");
1819             }
1820             key->numLevels[i] = type->num_levels;
1821         }
1822         if (key->numLevels[i] > width)
1823             width = key->numLevels[i];
1824         if (type->num_levels > width)
1825             width = type->num_levels;
1826     }
1827
1828     /* width is now the largest width found */
1829
1830     i = width * nGroups;
1831     outSyms = XkbcResizeKeySyms(xkb, kc, i);
1832     if (outSyms == NULL)
1833     {
1834         WSGO("Could not enlarge symbols for %s (keycode %d)\n",
1835               longText(key->name), kc);
1836         return False;
1837     }
1838     if (haveActions)
1839     {
1840         outActs = XkbcResizeKeyActions(xkb, kc, i);
1841         if (outActs == NULL)
1842         {
1843             WSGO("Could not enlarge actions for %s (key %d)\n",
1844                   longText(key->name), kc);
1845             return False;
1846         }
1847         xkb->server->explicit[kc] |= XkbExplicitInterpretMask;
1848     }
1849     else
1850         outActs = NULL;
1851     if (key->defs.defined & _Key_GroupInfo)
1852         i = key->groupInfo;
1853     else
1854         i = xkb->map->key_sym_map[kc].group_info;
1855
1856     xkb->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
1857     xkb->map->key_sym_map[kc].width = width;
1858     for (i = 0; i < nGroups; i++)
1859     {
1860         /* assign kt_index[i] to the index of the type in map->types.
1861          * kt_index[i] may have been set by a previous run (if we have two
1862          * layouts specified). Let's not overwrite it with the ONE_LEVEL
1863          * default group if we dont even have keys for this group anyway.
1864          *
1865          * FIXME: There should be a better fix for this.
1866          */
1867         if (key->numLevels[i])
1868             xkb->map->key_sym_map[kc].kt_index[i] = types[i];
1869         if (key->syms[i] != NULL)
1870         {
1871             /* fill key to "width" symbols*/
1872             for (tmp = 0; tmp < width; tmp++)
1873             {
1874                 if (tmp < key->numLevels[i])
1875                     outSyms[tmp] = key->syms[i][tmp];
1876                 else
1877                     outSyms[tmp] = NoSymbol;
1878                 if ((outActs != NULL) && (key->acts[i] != NULL))
1879                 {
1880                     if (tmp < key->numLevels[i])
1881                         outActs[tmp] = key->acts[i][tmp];
1882                     else
1883                         outActs[tmp].type = XkbSA_NoAction;
1884                 }
1885             }
1886         }
1887         outSyms += width;
1888         if (outActs)
1889             outActs += width;
1890     }
1891     switch (key->behavior.type & XkbKB_OpMask)
1892     {
1893     case XkbKB_Default:
1894         break;
1895     default:
1896         xkb->server->behaviors[kc] = key->behavior;
1897         xkb->server->explicit[kc] |= XkbExplicitBehaviorMask;
1898         break;
1899     }
1900     if (key->defs.defined & _Key_VModMap)
1901     {
1902         xkb->server->vmodmap[kc] = key->vmodmap;
1903         xkb->server->explicit[kc] |= XkbExplicitVModMapMask;
1904     }
1905     if (key->repeat != RepeatUndefined)
1906     {
1907         if (key->repeat == RepeatYes)
1908             xkb->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
1909         else
1910             xkb->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
1911         xkb->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
1912     }
1913
1914     if (nGroups > xkb->ctrls->num_groups)
1915         xkb->ctrls->num_groups = nGroups;
1916
1917     /* do the same thing for the next key */
1918     CopySymbolsDef(xkb, key, kc + 1);
1919     return True;
1920 }
1921
1922 static Bool
1923 CopyModMapDef(struct xkb_desc * xkb, ModMapEntry *entry)
1924 {
1925     xkb_keycode_t kc;
1926
1927     if ((!entry->haveSymbol)
1928         &&
1929         (!FindNamedKey
1930          (xkb, entry->u.keyName, &kc, True, CreateKeyNames(xkb), 0)))
1931     {
1932         if (warningLevel >= 5)
1933         {
1934             WARN("Key %s not found in keycodes\n",
1935                   longText(entry->u.keyName));
1936             ACTION("Modifier map entry for %s not updated\n",
1937                     XkbcModIndexText(entry->modifier));
1938         }
1939         return False;
1940     }
1941     else if (entry->haveSymbol
1942              && (!FindKeyForSymbol(xkb, entry->u.keySym, &kc)))
1943     {
1944         if (warningLevel > 5)
1945         {
1946             WARN("Key \"%s\" not found in symbol map\n",
1947                   XkbcKeysymText(entry->u.keySym));
1948             ACTION("Modifier map entry for %s not updated\n",
1949                     XkbcModIndexText(entry->modifier));
1950         }
1951         return False;
1952     }
1953     xkb->map->modmap[kc] |= (1 << entry->modifier);
1954     return True;
1955 }
1956
1957 /**
1958  * Handle the xkb_symbols section of an xkb file.
1959  *
1960  * @param file The parsed xkb_symbols section of the xkb file.
1961  * @param xkb Handle to the keyboard description to store the symbols in.
1962  * @param merge Merge strategy (e.g. MergeOverride).
1963  */
1964 Bool
1965 CompileSymbols(XkbFile *file, struct xkb_desc * xkb, unsigned merge)
1966 {
1967     int i;
1968     SymbolsInfo info;
1969
1970     InitSymbolsInfo(&info, xkb);
1971     info.dflt.defs.fileID = file->id;
1972     info.dflt.defs.merge = merge;
1973     HandleSymbolsFile(file, xkb, merge, &info);
1974
1975     if (info.nKeys == 0) {
1976         FreeSymbolsInfo(&info);
1977         return True;
1978     }
1979
1980     if (info.errorCount == 0)
1981     {
1982         KeyInfo *key;
1983
1984         /* alloc memory in the xkb struct */
1985         if (XkbcAllocNames(xkb, XkbGroupNamesMask, 0) != Success)
1986         {
1987             WSGO("Can not allocate names in CompileSymbols\n");
1988             ACTION("Symbols not added\n");
1989             return False;
1990         }
1991         if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0)
1992             != Success)
1993         {
1994             WSGO("Could not allocate client map in CompileSymbols\n");
1995             ACTION("Symbols not added\n");
1996             return False;
1997         }
1998         if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success)
1999         {
2000             WSGO("Could not allocate server map in CompileSymbols\n");
2001             ACTION("Symbols not added\n");
2002             return False;
2003         }
2004         if (XkbcAllocControls(xkb, XkbPerKeyRepeatMask) != Success)
2005         {
2006             WSGO("Could not allocate controls in CompileSymbols\n");
2007             ACTION("Symbols not added\n");
2008             return False;
2009         }
2010
2011         /* now copy info into xkb. */
2012         if (info.aliases)
2013             ApplyAliases(xkb, &info.aliases);
2014         for (i = 0; i < XkbNumKbdGroups; i++)
2015         {
2016             if (info.groupNames[i] != None)
2017             {
2018                 free((char *) xkb->names->groups[i]);
2019                 xkb->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
2020             }
2021         }
2022         /* sanitize keys */
2023         for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2024         {
2025             PrepareKeyDef(key);
2026         }
2027         /* copy! */
2028         for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
2029         {
2030             if (!CopySymbolsDef(xkb, key, 0))
2031                 info.errorCount++;
2032         }
2033         if (warningLevel > 3)
2034         {
2035             for (i = xkb->min_key_code; i <= xkb->max_key_code; i++)
2036             {
2037                 if (xkb->names->keys[i].name[0] == '\0')
2038                     continue;
2039                 if (XkbKeyNumGroups(xkb, i) < 1)
2040                 {
2041                     char buf[5];
2042                     memcpy(buf, xkb->names->keys[i].name, 4);
2043                     buf[4] = '\0';
2044                     WARN
2045                         ("No symbols defined for <%s> (keycode %d)\n",
2046                          buf, i);
2047                 }
2048             }
2049         }
2050         if (info.modMap)
2051         {
2052             ModMapEntry *mm, *next;
2053             for (mm = info.modMap; mm != NULL; mm = next)
2054             {
2055                 if (!CopyModMapDef(xkb, mm))
2056                     info.errorCount++;
2057                 next = (ModMapEntry *) mm->defs.next;
2058             }
2059         }
2060         FreeSymbolsInfo(&info);
2061         return True;
2062     }
2063
2064     FreeSymbolsInfo(&info);
2065     return False;
2066 }