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