src/xkbcomp/parseutils.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 "parseutils.h"
  28 #include "xkbmisc.h"
  29 #include "xkbpath.h"
  30 #include "xkbparse.h"
  31
  32 #include <X11/keysym.h>
  33
  34 ParseCommon *
  35 AppendStmt(ParseCommon * to, ParseCommon * append)
  36 {
  37     ParseCommon *start = to;
  38
  39     if (append == NULL)
  40         return to;
  41     while ((to != NULL) && (to->next != NULL))
  42     {
  43         to = to->next;
  44     }
  45     if (to)
  46     {
  47         to->next = append;
  48         return start;
  49     }
  50     return append;
  51 }
  52
  53 ExprDef *
  54 ExprCreate(unsigned op, unsigned type)
  55 {
  56     ExprDef *expr;
  57     expr = uTypedAlloc(ExprDef);
  58     if (expr)
  59     {
  60         expr->common.stmtType = StmtExpr;
  61         expr->common.next = NULL;
  62         expr->op = op;
  63         expr->type = type;
  64     }
  65     else
  66     {
  67         FATAL("Couldn't allocate expression in parser\n");
  68         /* NOTREACHED */
  69     }
  70     return expr;
  71 }
  72
  73 ExprDef *
  74 ExprCreateUnary(unsigned op, unsigned type, ExprDef * child)
  75 {
  76     ExprDef *expr;
  77     expr = uTypedAlloc(ExprDef);
  78     if (expr)
  79     {
  80         expr->common.stmtType = StmtExpr;
  81         expr->common.next = NULL;
  82         expr->op = op;
  83         expr->type = type;
  84         expr->value.child = child;
  85     }
  86     else
  87     {
  88         FATAL("Couldn't allocate expression in parser\n");
  89         /* NOTREACHED */
  90     }
  91     return expr;
  92 }
  93
  94 ExprDef *
  95 ExprCreateBinary(unsigned op, ExprDef * left, ExprDef * right)
  96 {
  97     ExprDef *expr;
  98     expr = uTypedAlloc(ExprDef);
  99     if (expr)
 100     {
 101         expr->common.stmtType = StmtExpr;
 102         expr->common.next = NULL;
 103         expr->op = op;
 104         if ((op == OpAssign) || (left->type == TypeUnknown))
 105             expr->type = right->type;
 106         else if ((left->type == right->type) || (right->type == TypeUnknown))
 107             expr->type = left->type;
 108         else
 109             expr->type = TypeUnknown;
 110         expr->value.binary.left = left;
 111         expr->value.binary.right = right;
 112     }
 113     else
 114     {
 115         FATAL("Couldn't allocate expression in parser\n");
 116         /* NOTREACHED */
 117     }
 118     return expr;
 119 }
 120
 121 KeycodeDef *
 122 KeycodeCreate(const char *name, unsigned long value)
 123 {
 124     KeycodeDef *def;
 125
 126     def = uTypedAlloc(KeycodeDef);
 127     if (def)
 128     {
 129         def->common.stmtType = StmtKeycodeDef;
 130         def->common.next = NULL;
 131         strncpy(def->name, name, XkbKeyNameLength);
 132         def->name[XkbKeyNameLength] = '\0';
 133         def->value = value;
 134     }
 135     else
 136     {
 137         FATAL("Couldn't allocate key name definition in parser\n");
 138         /* NOTREACHED */
 139     }
 140     return def;
 141 }
 142
 143 KeyAliasDef *
 144 KeyAliasCreate(const char *alias, const char *real)
 145 {
 146     KeyAliasDef *def;
 147
 148     def = uTypedAlloc(KeyAliasDef);
 149     if (def)
 150     {
 151         def->common.stmtType = StmtKeyAliasDef;
 152         def->common.next = NULL;
 153         strncpy(def->alias, alias, XkbKeyNameLength);
 154         def->alias[XkbKeyNameLength] = '\0';
 155         strncpy(def->real, real, XkbKeyNameLength);
 156         def->real[XkbKeyNameLength] = '\0';
 157     }
 158     else
 159     {
 160         FATAL("Couldn't allocate key alias definition in parser\n");
 161         /* NOTREACHED */
 162     }
 163     return def;
 164 }
 165
 166 VModDef *
 167 VModCreate(xkb_atom_t name, ExprDef * value)
 168 {
 169     VModDef *def;
 170     def = uTypedAlloc(VModDef);
 171     if (def)
 172     {
 173         def->common.stmtType = StmtVModDef;
 174         def->common.next = NULL;
 175         def->name = name;
 176         def->value = value;
 177     }
 178     else
 179     {
 180         FATAL("Couldn't allocate variable definition in parser\n");
 181         /* NOTREACHED */
 182     }
 183     return def;
 184 }
 185
 186 VarDef *
 187 VarCreate(ExprDef * name, ExprDef * value)
 188 {
 189     VarDef *def;
 190     def = uTypedAlloc(VarDef);
 191     if (def)
 192     {
 193         def->common.stmtType = StmtVarDef;
 194         def->common.next = NULL;
 195         def->name = name;
 196         def->value = value;
 197     }
 198     else
 199     {
 200         FATAL("Couldn't allocate variable definition in parser\n");
 201         /* NOTREACHED */
 202     }
 203     return def;
 204 }
 205
 206 VarDef *
 207 BoolVarCreate(xkb_atom_t nameToken, unsigned set)
 208 {
 209     ExprDef *name, *value;
 210
 211     name = ExprCreate(ExprIdent, TypeUnknown);
 212     name->value.str = nameToken;
 213     value = ExprCreate(ExprValue, TypeBoolean);
 214     value->value.uval = set;
 215     return VarCreate(name, value);
 216 }
 217
 218 InterpDef *
 219 InterpCreate(char *sym, ExprDef * match)
 220 {
 221     InterpDef *def;
 222
 223     def = uTypedAlloc(InterpDef);
 224     if (def)
 225     {
 226         def->common.stmtType = StmtInterpDef;
 227         def->common.next = NULL;
 228         def->sym = sym;
 229         def->match = match;
 230     }
 231     else
 232     {
 233         FATAL("Couldn't allocate interp definition in parser\n");
 234         /* NOTREACHED */
 235     }
 236     return def;
 237 }
 238
 239 KeyTypeDef *
 240 KeyTypeCreate(xkb_atom_t name, VarDef * body)
 241 {
 242     KeyTypeDef *def;
 243
 244     def = uTypedAlloc(KeyTypeDef);
 245     if (def)
 246     {
 247         def->common.stmtType = StmtKeyTypeDef;
 248         def->common.next = NULL;
 249         def->merge = MergeDefault;
 250         def->name = name;
 251         def->body = body;
 252     }
 253     else
 254     {
 255         FATAL("Couldn't allocate key type definition in parser\n");
 256         /* NOTREACHED */
 257     }
 258     return def;
 259 }
 260
 261 SymbolsDef *
 262 SymbolsCreate(const char *keyName, ExprDef *symbols)
 263 {
 264     SymbolsDef *def;
 265
 266     def = uTypedAlloc(SymbolsDef);
 267     if (def)
 268     {
 269         def->common.stmtType = StmtSymbolsDef;
 270         def->common.next = NULL;
 271         def->merge = MergeDefault;
 272         memset(def->keyName, 0, 5);
 273         strncpy(def->keyName, keyName, 4);
 274         def->symbols = symbols;
 275     }
 276     else
 277     {
 278         FATAL("Couldn't allocate symbols definition in parser\n");
 279         /* NOTREACHED */
 280     }
 281     return def;
 282 }
 283
 284 GroupCompatDef *
 285 GroupCompatCreate(int group, ExprDef * val)
 286 {
 287     GroupCompatDef *def;
 288
 289     def = uTypedAlloc(GroupCompatDef);
 290     if (def)
 291     {
 292         def->common.stmtType = StmtGroupCompatDef;
 293         def->common.next = NULL;
 294         def->merge = MergeDefault;
 295         def->group = group;
 296         def->def = val;
 297     }
 298     else
 299     {
 300         FATAL("Couldn't allocate group compat definition in parser\n");
 301         /* NOTREACHED */
 302     }
 303     return def;
 304 }
 305
 306 ModMapDef *
 307 ModMapCreate(uint32_t modifier, ExprDef * keys)
 308 {
 309     ModMapDef *def;
 310
 311     def = uTypedAlloc(ModMapDef);
 312     if (def)
 313     {
 314         def->common.stmtType = StmtModMapDef;
 315         def->common.next = NULL;
 316         def->merge = MergeDefault;
 317         def->modifier = modifier;
 318         def->keys = keys;
 319     }
 320     else
 321     {
 322         FATAL("Couldn't allocate mod mask definition in parser\n");
 323         /* NOTREACHED */
 324     }
 325     return def;
 326 }
 327
 328 IndicatorMapDef *
 329 IndicatorMapCreate(xkb_atom_t name, VarDef * body)
 330 {
 331     IndicatorMapDef *def;
 332
 333     def = uTypedAlloc(IndicatorMapDef);
 334     if (def)
 335     {
 336         def->common.stmtType = StmtIndicatorMapDef;
 337         def->common.next = NULL;
 338         def->merge = MergeDefault;
 339         def->name = name;
 340         def->body = body;
 341     }
 342     else
 343     {
 344         FATAL("Couldn't allocate indicator map definition in parser\n");
 345         /* NOTREACHED */
 346     }
 347     return def;
 348 }
 349
 350 IndicatorNameDef *
 351 IndicatorNameCreate(int ndx, ExprDef * name, bool virtual)
 352 {
 353     IndicatorNameDef *def;
 354
 355     def = uTypedAlloc(IndicatorNameDef);
 356     if (def)
 357     {
 358         def->common.stmtType = StmtIndicatorNameDef;
 359         def->common.next = NULL;
 360         def->merge = MergeDefault;
 361         def->ndx = ndx;
 362         def->name = name;
 363         def->virtual = virtual;
 364     }
 365     else
 366     {
 367         FATAL("Couldn't allocate indicator index definition in parser\n");
 368         /* NOTREACHED */
 369     }
 370     return def;
 371 }
 372
 373 ExprDef *
 374 ActionCreate(xkb_atom_t name, ExprDef * args)
 375 {
 376     ExprDef *act;
 377
 378     act = uTypedAlloc(ExprDef);
 379     if (act)
 380     {
 381         act->common.stmtType = StmtExpr;
 382         act->common.next = NULL;
 383         act->op = ExprActionDecl;
 384         act->value.action.name = name;
 385         act->value.action.args = args;
 386         return act;
 387     }
 388     FATAL("Couldn't allocate ActionDef in parser\n");
 389     return NULL;
 390 }
 391
 392 static bool
 393 ResizeKeysymList(ExprDef *list, unsigned int extra)
 394 {
 395     int i;
 396
 397     if (list->value.list.nSyms + extra > list->value.list.szSyms)
 398     {
 399         list->value.list.szSyms *= 2;
 400         list->value.list.szSyms += extra;
 401         if (list->value.list.szSyms == 1)
 402             list->value.list.szSyms = 4;
 403         list->value.list.syms = uTypedRecalloc(list->value.list.syms,
 404                                                list->value.list.nSyms,
 405                                                list->value.list.szSyms,
 406                                                char *);
 407         if (list->value.list.syms == NULL)
 408         {
 409             FATAL("Couldn't resize list of symbols for append\n");
 410             return false;
 411         }
 412     }
 413     if (list->value.list.nLevels >= list->value.list.szLevels)
 414     {
 415         list->value.list.szLevels *= 2;
 416         if (list->value.list.szLevels == 0)
 417             list->value.list.szLevels = 4;
 418         list->value.list.symsMapIndex =
 419             uTypedRecalloc(list->value.list.symsMapIndex,
 420                            list->value.list.nLevels,
 421                            list->value.list.szLevels,
 422                            int);
 423         if (list->value.list.symsMapIndex == NULL)
 424         {
 425             FATAL("Couldn't resize keysym index map for append\n");
 426             return false;
 427         }
 428         list->value.list.symsNumEntries =
 429             uTypedRecalloc(list->value.list.symsNumEntries,
 430                            list->value.list.nLevels,
 431                            list->value.list.szLevels,
 432                            unsigned int);
 433         if (list->value.list.symsNumEntries == NULL)
 434         {
 435             FATAL("Couldn't resize num keysym entries for append\n");
 436             return false;
 437         }
 438         for (i = list->value.list.nLevels; i < list->value.list.szLevels; i++)
 439             list->value.list.symsMapIndex[i] = -1;
 440     }
 441
 442     return true;
 443 }
 444
 445 ExprDef *
 446 CreateKeysymList(char *sym)
 447 {
 448     ExprDef *def;
 449
 450     def = ExprCreate(ExprKeysymList, TypeSymbols);
 451     if (!def)
 452     {
 453         FATAL("Couldn't allocate expression for keysym list in parser\n");
 454         return NULL;
 455     }
 456
 457     def->value.list.nSyms = 0;
 458     def->value.list.szSyms = 0;
 459     def->value.list.nLevels = 0;
 460     def->value.list.szLevels = 0;
 461     def->value.list.syms = NULL;
 462     def->value.list.symsMapIndex = NULL;
 463     def->value.list.symsNumEntries = NULL;
 464
 465     if (!ResizeKeysymList(def, 1))
 466     {
 467         FreeStmt(&def->common);
 468         return NULL;
 469     }
 470
 471     def->value.list.syms[0] = sym;
 472     def->value.list.symsMapIndex[0] = 0;
 473     def->value.list.symsNumEntries[0] = 1;
 474     def->value.list.nLevels = 1;
 475     def->value.list.nSyms = 1;
 476
 477     return def;
 478 }
 479
 480 ExprDef *
 481 CreateMultiKeysymList(ExprDef *list)
 482 {
 483     int i;
 484
 485     for (i = 1; i < list->value.list.szLevels; i++)
 486     {
 487         list->value.list.symsMapIndex[i] = -1;
 488         list->value.list.symsNumEntries[i] = 0;
 489     }
 490     list->value.list.symsMapIndex[0] = 0;
 491     list->value.list.symsNumEntries[0] = list->value.list.nLevels;
 492     list->value.list.nLevels = 1;
 493
 494     return list;
 495 }
 496
 497 ExprDef *
 498 AppendKeysymList(ExprDef * list, char *sym)
 499 {
 500     if (!ResizeKeysymList(list, 1))
 501         return NULL;
 502
 503     list->value.list.symsMapIndex[list->value.list.nLevels] =
 504         list->value.list.nSyms;
 505     list->value.list.symsNumEntries[list->value.list.nLevels] = 1;
 506     list->value.list.syms[list->value.list.nSyms++] = sym;
 507     list->value.list.nLevels++;
 508     return list;
 509 }
 510
 511 ExprDef *
 512 AppendMultiKeysymList(ExprDef * list, ExprDef * append)
 513 {
 514     int i;
 515
 516     if (!ResizeKeysymList(list, append->value.list.nSyms))
 517         return NULL;
 518
 519     list->value.list.symsMapIndex[list->value.list.nLevels] =
 520         list->value.list.nSyms;
 521     list->value.list.symsNumEntries[list->value.list.nLevels] =
 522         append->value.list.nSyms;
 523     for (i = 0; i < append->value.list.nSyms; i++) {
 524         list->value.list.syms[list->value.list.nSyms++] =
 525             append->value.list.syms[i];
 526         append->value.list.syms[i] = NULL;
 527     }
 528     list->value.list.nLevels++;
 529
 530     FreeStmt(&append->common);
 531
 532     return list;
 533 }
 534
 535 int
 536 LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
 537 {
 538     xkb_keysym_t sym;
 539
 540     if ((!str) || (strcasecmp(str, "any") == 0) ||
 541         (strcasecmp(str, "nosymbol") == 0))
 542     {
 543         *sym_rtrn = XKB_KEYSYM_NO_SYMBOL;
 544         return 1;
 545     }
 546     else if ((strcasecmp(str, "none") == 0) ||
 547              (strcasecmp(str, "voidsymbol") == 0))
 548     {
 549         *sym_rtrn = XK_VoidSymbol;
 550         return 1;
 551     }
 552     sym = xkb_string_to_keysym(str);
 553     if (sym != XKB_KEYSYM_NO_SYMBOL)
 554     {
 555         *sym_rtrn = sym;
 556         return 1;
 557     }
 558     return 0;
 559 }
 560
 561 static void
 562 FreeInclude(IncludeStmt *incl);
 563
 564 IncludeStmt *
 565 IncludeCreate(char *str, unsigned merge)
 566 {
 567     IncludeStmt *incl, *first;
 568     char *file, *map, *stmt, *tmp, *extra_data;
 569     char nextop;
 570     bool haveSelf;
 571
 572     haveSelf = false;
 573     incl = first = NULL;
 574     file = map = NULL;
 575     tmp = str;
 576     stmt = uDupString(str);
 577     while ((tmp) && (*tmp))
 578     {
 579         if (XkbParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
 580         {
 581             if ((file == NULL) && (map == NULL))
 582             {
 583                 if (haveSelf)
 584                     goto BAIL;
 585                 haveSelf = true;
 586             }
 587             if (first == NULL)
 588                 first = incl = uTypedAlloc(IncludeStmt);
 589             else
 590             {
 591                 incl->next = uTypedAlloc(IncludeStmt);
 592                 incl = incl->next;
 593             }
 594             if (incl)
 595             {
 596                 incl->common.stmtType = StmtInclude;
 597                 incl->common.next = NULL;
 598                 incl->merge = merge;
 599                 incl->stmt = NULL;
 600                 incl->file = file;
 601                 incl->map = map;
 602                 incl->modifier = extra_data;
 603                 incl->path = NULL;
 604                 incl->next = NULL;
 605             }
 606             else
 607             {
 608                 WSGO("Allocation failure in IncludeCreate\n");
 609                 ACTION("Using only part of the include\n");
 610                 break;
 611             }
 612             if (nextop == '|')
 613                 merge = MergeAugment;
 614             else
 615                 merge = MergeOverride;
 616         }
 617         else
 618         {
 619             goto BAIL;
 620         }
 621     }
 622     if (first)
 623         first->stmt = stmt;
 624     else
 625         free(stmt);
 626     return first;
 627
 628 BAIL:
 629     ERROR("Illegal include statement \"%s\"\n", stmt);
 630     ACTION("Ignored\n");
 631     FreeInclude(first);
 632     free(stmt);
 633     return NULL;
 634 }
 635
 636 #ifdef DEBUG
 637 void
 638 PrintStmtAddrs(ParseCommon * stmt)
 639 {
 640     fprintf(stderr, "0x%x", stmt);
 641     if (stmt)
 642     {
 643         do
 644         {
 645             fprintf(stderr, "->0x%x", stmt->next);
 646             stmt = stmt->next;
 647         }
 648         while (stmt);
 649     }
 650     fprintf(stderr, "\n");
 651 }
 652 #endif
 653
 654 void
 655 CheckDefaultMap(XkbFile * maps, const char *fileName)
 656 {
 657     XkbFile *dflt, *tmp;
 658
 659     dflt = NULL;
 660     for (tmp = maps, dflt = NULL; tmp != NULL;
 661          tmp = (XkbFile *) tmp->common.next)
 662     {
 663         if (tmp->flags & XkbLC_Default)
 664         {
 665             if (dflt == NULL)
 666                 dflt = tmp;
 667             else
 668             {
 669                 if (warningLevel > 2)
 670                 {
 671                     WARN("Multiple default components in %s\n",
 672                           (fileName ? fileName : "(unknown)"));
 673                     ACTION("Using %s, ignoring %s\n",
 674                             (dflt->name ? dflt->name : "(first)"),
 675                             (tmp->name ? tmp->name : "(subsequent)"));
 676                 }
 677                 tmp->flags &= (~XkbLC_Default);
 678             }
 679         }
 680     }
 681 }
 682
 683 XkbFile *
 684 CreateXKBFile(int type, char *name, ParseCommon * defs, unsigned flags)
 685 {
 686     XkbFile *file;
 687     static int fileID;
 688
 689     file = uTypedAlloc(XkbFile);
 690     if (file)
 691     {
 692         XkbcEnsureSafeMapName(name);
 693         memset(file, 0, sizeof(XkbFile));
 694         file->type = type;
 695         file->topName = uDupString(name);
 696         file->name = name;
 697         file->defs = defs;
 698         file->id = fileID++;
 699         file->compiled = false;
 700         file->flags = flags;
 701     }
 702     return file;
 703 }
 704
 705 unsigned
 706 StmtSetMerge(ParseCommon * stmt, unsigned merge, YYLTYPE *loc, void *scanner)
 707 {
 708     if ((merge == MergeAltForm) && (stmt->stmtType != StmtKeycodeDef))
 709     {
 710         yyerror(loc, scanner, "illegal use of 'alternate' merge mode");
 711         merge = MergeDefault;
 712     }
 713     return merge;
 714 }
 715
 716 static void
 717 FreeExpr(ExprDef *expr)
 718 {
 719     int i;
 720
 721     if (!expr)
 722         return;
 723
 724     switch (expr->op)
 725     {
 726     case ExprActionList:
 727     case OpNegate:
 728     case OpUnaryPlus:
 729     case OpNot:
 730     case OpInvert:
 731         FreeStmt(&expr->value.child->common);
 732         break;
 733     case OpDivide:
 734     case OpAdd:
 735     case OpSubtract:
 736     case OpMultiply:
 737     case OpAssign:
 738         FreeStmt(&expr->value.binary.left->common);
 739         FreeStmt(&expr->value.binary.right->common);
 740         break;
 741     case ExprActionDecl:
 742         FreeStmt(&expr->value.action.args->common);
 743         break;
 744     case ExprArrayRef:
 745         FreeStmt(&expr->value.array.entry->common);
 746         break;
 747     case ExprKeysymList:
 748         for (i = 0; i < expr->value.list.nSyms; i++)
 749             free(expr->value.list.syms[i]);
 750         free(expr->value.list.syms);
 751         free(expr->value.list.symsMapIndex);
 752         free(expr->value.list.symsNumEntries);
 753         break;
 754     default:
 755         break;
 756     }
 757 }
 758
 759 static void
 760 FreeInclude(IncludeStmt *incl)
 761 {
 762     IncludeStmt *next;
 763
 764     while (incl)
 765     {
 766         next = incl->next;
 767
 768         free(incl->file);
 769         free(incl->map);
 770         free(incl->modifier);
 771         free(incl->path);
 772         free(incl->stmt);
 773
 774         free(incl);
 775         incl = next;
 776     }
 777 }
 778
 779 void
 780 FreeStmt(ParseCommon *stmt)
 781 {
 782     ParseCommon *next;
 783     YYSTYPE u;
 784
 785     while (stmt)
 786     {
 787         next = stmt->next;
 788         u.any = stmt;
 789
 790         switch (stmt->stmtType)
 791         {
 792         case StmtInclude:
 793             FreeInclude((IncludeStmt *)stmt);
 794             /* stmt is already free'd here. */
 795             stmt = NULL;
 796             break;
 797         case StmtExpr:
 798             FreeExpr(u.expr);
 799             break;
 800         case StmtVarDef:
 801             FreeStmt(&u.var->name->common);
 802             FreeStmt(&u.var->value->common);
 803             break;
 804         case StmtKeyTypeDef:
 805             FreeStmt(&u.keyType->body->common);
 806             break;
 807         case StmtInterpDef:
 808             free(u.interp->sym);
 809             FreeStmt(&u.interp->match->common);
 810             FreeStmt(&u.interp->def->common);
 811             break;
 812         case StmtVModDef:
 813             FreeStmt(&u.vmod->value->common);
 814             break;
 815         case StmtSymbolsDef:
 816             FreeStmt(&u.syms->symbols->common);
 817             break;
 818         case StmtModMapDef:
 819             FreeStmt(&u.modMask->keys->common);
 820             break;
 821         case StmtGroupCompatDef:
 822             FreeStmt(&u.groupCompat->def->common);
 823             break;
 824         case StmtIndicatorMapDef:
 825             FreeStmt(&u.ledMap->body->common);
 826             break;
 827         case StmtIndicatorNameDef:
 828             FreeStmt(&u.ledName->name->common);
 829             break;
 830         default:
 831             break;
 832         }
 833
 834         free(stmt);
 835         stmt = next;
 836     }
 837 }
 838
 839 void
 840 FreeXKBFile(XkbFile *file)
 841 {
 842     XkbFile *next;
 843
 844     while (file)
 845     {
 846         next = (XkbFile *)file->common.next;
 847
 848         switch (file->type)
 849         {
 850         case XkmKeymapFile:
 851         case XkmSemanticsFile:
 852         case XkmLayoutFile:
 853             FreeXKBFile((XkbFile *)file->defs);
 854             break;
 855         case XkmTypesIndex:
 856         case XkmCompatMapIndex:
 857         case XkmSymbolsIndex:
 858         case XkmKeyNamesIndex:
 859         case XkmGeometryIndex:
 860         case XkmGeometryFile:
 861             FreeStmt(file->defs);
 862             break;
 863         }
 864
 865         free(file->name);
 866         free(file->topName);
 867         free(file);
 868         file = next;
 869     }
 870 }