src/xkbcomp/ast-build.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 /*
  28  * Copyright © 2012 Intel Corporation
  29  * Copyright © 2012 Ran Benita <ran234@gmail.com>
  30  *
  31  * Permission is hereby granted, free of charge, to any person obtaining a
  32  * copy of this software and associated documentation files (the "Software"),
  33  * to deal in the Software without restriction, including without limitation
  34  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  35  * and/or sell copies of the Software, and to permit persons to whom the
  36  * Software is furnished to do so, subject to the following conditions:
  37  *
  38  * The above copyright notice and this permission notice (including the next
  39  * paragraph) shall be included in all copies or substantial portions of the
  40  * Software.
  41  *
  42  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  43  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  44  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  45  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  46  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  47  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  48  * DEALINGS IN THE SOFTWARE.
  49  *
  50  * Author: Daniel Stone <daniel@fooishbar.org>
  51  *         Ran Benita <ran234@gmail.com>
  52  */
  53
  54 #include "xkbcomp-priv.h"
  55 #include "ast-build.h"
  56 #include "include.h"
  57
  58 ParseCommon *
  59 AppendStmt(ParseCommon *to, ParseCommon *append)
  60 {
  61     ParseCommon *iter;
  62
  63     if (!to)
  64         return append;
  65
  66     for (iter = to; iter->next; iter = iter->next);
  67
  68     iter->next = append;
  69     return to;
  70 }
  71
  72 static ExprDef *
  73 ExprCreate(enum expr_op_type op, enum expr_value_type type, size_t size)
  74 {
  75     ExprDef *expr = malloc(size);
  76     if (!expr)
  77         return NULL;
  78
  79     expr->common.type = STMT_EXPR;
  80     expr->common.next = NULL;
  81     expr->expr.op = op;
  82     expr->expr.value_type = type;
  83
  84     return expr;
  85 }
  86
  87 #define EXPR_CREATE(type_, name_, op_, value_type_) \
  88     ExprDef *name_ = ExprCreate(op_, value_type_, sizeof(type_)); \
  89     if (!name_) \
  90         return NULL;
  91
  92 ExprDef *
  93 ExprCreateString(xkb_atom_t str)
  94 {
  95     EXPR_CREATE(ExprString, expr, EXPR_VALUE, EXPR_TYPE_STRING);
  96     expr->string.str = str;
  97     return expr;
  98 }
  99
 100 ExprDef *
 101 ExprCreateInteger(int ival)
 102 {
 103     EXPR_CREATE(ExprInteger, expr, EXPR_VALUE, EXPR_TYPE_INT);
 104     expr->integer.ival = ival;
 105     return expr;
 106 }
 107
 108 ExprDef *
 109 ExprCreateBoolean(bool set)
 110 {
 111     EXPR_CREATE(ExprBoolean, expr, EXPR_VALUE, EXPR_TYPE_BOOLEAN);
 112     expr->boolean.set = set;
 113     return expr;
 114 }
 115
 116 ExprDef *
 117 ExprCreateKeyName(xkb_atom_t key_name)
 118 {
 119     EXPR_CREATE(ExprKeyName, expr, EXPR_VALUE, EXPR_TYPE_KEYNAME);
 120     expr->key_name.key_name = key_name;
 121     return expr;
 122 }
 123
 124 ExprDef *
 125 ExprCreateIdent(xkb_atom_t ident)
 126 {
 127     EXPR_CREATE(ExprIdent, expr, EXPR_IDENT, EXPR_TYPE_UNKNOWN);
 128     expr->ident.ident = ident;
 129     return expr;
 130 }
 131
 132 ExprDef *
 133 ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
 134                 ExprDef *child)
 135 {
 136     EXPR_CREATE(ExprUnary, expr, op, type);
 137     expr->unary.child = child;
 138     return expr;
 139 }
 140
 141 ExprDef *
 142 ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right)
 143 {
 144     EXPR_CREATE(ExprBinary, expr, op, EXPR_TYPE_UNKNOWN);
 145
 146     if (op == EXPR_ASSIGN || left->expr.value_type == EXPR_TYPE_UNKNOWN)
 147         expr->expr.value_type = right->expr.value_type;
 148     else if (left->expr.value_type == right->expr.value_type ||
 149              right->expr.value_type == EXPR_TYPE_UNKNOWN)
 150         expr->expr.value_type = left->expr.value_type;
 151     expr->binary.left = left;
 152     expr->binary.right = right;
 153
 154     return expr;
 155 }
 156
 157 ExprDef *
 158 ExprCreateFieldRef(xkb_atom_t element, xkb_atom_t field)
 159 {
 160     EXPR_CREATE(ExprFieldRef, expr, EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN);
 161     expr->field_ref.element = element;
 162     expr->field_ref.field = field;
 163     return expr;
 164 }
 165
 166 ExprDef *
 167 ExprCreateArrayRef(xkb_atom_t element, xkb_atom_t field, ExprDef *entry)
 168 {
 169     EXPR_CREATE(ExprArrayRef, expr, EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN);
 170     expr->array_ref.element = element;
 171     expr->array_ref.field = field;
 172     expr->array_ref.entry = entry;
 173     return expr;
 174 }
 175
 176 ExprDef *
 177 ExprCreateAction(xkb_atom_t name, ExprDef *args)
 178 {
 179     EXPR_CREATE(ExprAction, expr, EXPR_ACTION_DECL, EXPR_TYPE_UNKNOWN);
 180     expr->action.name = name;
 181     expr->action.args = args;
 182     return expr;
 183 }
 184
 185 ExprDef *
 186 ExprCreateKeysymList(xkb_keysym_t sym)
 187 {
 188     EXPR_CREATE(ExprKeysymList, expr, EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS);
 189
 190     darray_init(expr->keysym_list.syms);
 191     darray_init(expr->keysym_list.symsMapIndex);
 192     darray_init(expr->keysym_list.symsNumEntries);
 193
 194     darray_append(expr->keysym_list.syms, sym);
 195     darray_append(expr->keysym_list.symsMapIndex, 0);
 196     darray_append(expr->keysym_list.symsNumEntries, 1);
 197
 198     return expr;
 199 }
 200
 201 ExprDef *
 202 ExprCreateMultiKeysymList(ExprDef *expr)
 203 {
 204     unsigned nLevels = darray_size(expr->keysym_list.symsMapIndex);
 205
 206     darray_resize(expr->keysym_list.symsMapIndex, 1);
 207     darray_resize(expr->keysym_list.symsNumEntries, 1);
 208     darray_item(expr->keysym_list.symsMapIndex, 0) = 0;
 209     darray_item(expr->keysym_list.symsNumEntries, 0) = nLevels;
 210
 211     return expr;
 212 }
 213
 214 ExprDef *
 215 ExprAppendKeysymList(ExprDef *expr, xkb_keysym_t sym)
 216 {
 217     unsigned nSyms = darray_size(expr->keysym_list.syms);
 218
 219     darray_append(expr->keysym_list.symsMapIndex, nSyms);
 220     darray_append(expr->keysym_list.symsNumEntries, 1);
 221     darray_append(expr->keysym_list.syms, sym);
 222
 223     return expr;
 224 }
 225
 226 ExprDef *
 227 ExprAppendMultiKeysymList(ExprDef *expr, ExprDef *append)
 228 {
 229     xkb_keysym_t *syms;
 230     unsigned nSyms = darray_size(expr->keysym_list.syms);
 231     unsigned numEntries = darray_size(append->keysym_list.syms);
 232
 233     darray_append(expr->keysym_list.symsMapIndex, nSyms);
 234     darray_append(expr->keysym_list.symsNumEntries, numEntries);
 235     darray_steal(append->keysym_list.syms, &syms, NULL);
 236     darray_append_items(expr->keysym_list.syms, syms, numEntries);
 237
 238     FreeStmt((ParseCommon *) &append);
 239
 240     return expr;
 241 }
 242
 243 KeycodeDef *
 244 KeycodeCreate(xkb_atom_t name, int64_t value)
 245 {
 246     KeycodeDef *def = malloc(sizeof(*def));
 247     if (!def)
 248         return NULL;
 249
 250     def->common.type = STMT_KEYCODE;
 251     def->common.next = NULL;
 252     def->name = name;
 253     def->value = value;
 254
 255     return def;
 256 }
 257
 258 KeyAliasDef *
 259 KeyAliasCreate(xkb_atom_t alias, xkb_atom_t real)
 260 {
 261     KeyAliasDef *def = malloc(sizeof(*def));
 262     if (!def)
 263         return NULL;
 264
 265     def->common.type = STMT_ALIAS;
 266     def->common.next = NULL;
 267     def->alias = alias;
 268     def->real = real;
 269
 270     return def;
 271 }
 272
 273 VModDef *
 274 VModCreate(xkb_atom_t name, ExprDef *value)
 275 {
 276     VModDef *def = malloc(sizeof(*def));
 277     if (!def)
 278         return NULL;
 279
 280     def->common.type = STMT_VMOD;
 281     def->common.next = NULL;
 282     def->name = name;
 283     def->value = value;
 284
 285     return def;
 286 }
 287
 288 VarDef *
 289 VarCreate(ExprDef *name, ExprDef *value)
 290 {
 291     VarDef *def = malloc(sizeof(*def));
 292     if (!def)
 293         return NULL;
 294
 295     def->common.type = STMT_VAR;
 296     def->common.next = NULL;
 297     def->name = name;
 298     def->value = value;
 299
 300     return def;
 301 }
 302
 303 VarDef *
 304 BoolVarCreate(xkb_atom_t ident, bool set)
 305 {
 306     ExprDef *name, *value;
 307     VarDef *def;
 308     if (!(name = ExprCreateIdent(ident))) {
 309         return NULL;
 310     }
 311     if (!(value = ExprCreateBoolean(set))) {
 312         FreeStmt((ParseCommon *) name);
 313         return NULL;
 314     }
 315     if (!(def = VarCreate(name, value))) {
 316         FreeStmt((ParseCommon *) name);
 317         FreeStmt((ParseCommon *) value);
 318         return NULL;
 319     }
 320     return def;
 321 }
 322
 323 InterpDef *
 324 InterpCreate(xkb_keysym_t sym, ExprDef *match)
 325 {
 326     InterpDef *def = malloc(sizeof(*def));
 327     if (!def)
 328         return NULL;
 329
 330     def->common.type = STMT_INTERP;
 331     def->common.next = NULL;
 332     def->sym = sym;
 333     def->match = match;
 334     def->def = NULL;
 335
 336     return def;
 337 }
 338
 339 KeyTypeDef *
 340 KeyTypeCreate(xkb_atom_t name, VarDef *body)
 341 {
 342     KeyTypeDef *def = malloc(sizeof(*def));
 343     if (!def)
 344         return NULL;
 345
 346     def->common.type = STMT_TYPE;
 347     def->common.next = NULL;
 348     def->merge = MERGE_DEFAULT;
 349     def->name = name;
 350     def->body = body;
 351
 352     return def;
 353 }
 354
 355 SymbolsDef *
 356 SymbolsCreate(xkb_atom_t keyName, VarDef *symbols)
 357 {
 358     SymbolsDef *def = malloc(sizeof(*def));
 359     if (!def)
 360         return NULL;
 361
 362     def->common.type = STMT_SYMBOLS;
 363     def->common.next = NULL;
 364     def->merge = MERGE_DEFAULT;
 365     def->keyName = keyName;
 366     def->symbols = symbols;
 367
 368     return def;
 369 }
 370
 371 GroupCompatDef *
 372 GroupCompatCreate(unsigned group, ExprDef *val)
 373 {
 374     GroupCompatDef *def = malloc(sizeof(*def));
 375     if (!def)
 376         return NULL;
 377
 378     def->common.type = STMT_GROUP_COMPAT;
 379     def->common.next = NULL;
 380     def->merge = MERGE_DEFAULT;
 381     def->group = group;
 382     def->def = val;
 383
 384     return def;
 385 }
 386
 387 ModMapDef *
 388 ModMapCreate(xkb_atom_t modifier, ExprDef *keys)
 389 {
 390     ModMapDef *def = malloc(sizeof(*def));
 391     if (!def)
 392         return NULL;
 393
 394     def->common.type = STMT_MODMAP;
 395     def->common.next = NULL;
 396     def->merge = MERGE_DEFAULT;
 397     def->modifier = modifier;
 398     def->keys = keys;
 399
 400     return def;
 401 }
 402
 403 LedMapDef *
 404 LedMapCreate(xkb_atom_t name, VarDef *body)
 405 {
 406     LedMapDef *def = malloc(sizeof(*def));
 407     if (!def)
 408         return NULL;
 409
 410     def->common.type = STMT_LED_MAP;
 411     def->common.next = NULL;
 412     def->merge = MERGE_DEFAULT;
 413     def->name = name;
 414     def->body = body;
 415
 416     return def;
 417 }
 418
 419 LedNameDef *
 420 LedNameCreate(unsigned ndx, ExprDef *name, bool virtual)
 421 {
 422     LedNameDef *def = malloc(sizeof(*def));
 423     if (!def)
 424         return NULL;
 425
 426     def->common.type = STMT_LED_NAME;
 427     def->common.next = NULL;
 428     def->merge = MERGE_DEFAULT;
 429     def->ndx = ndx;
 430     def->name = name;
 431     def->virtual = virtual;
 432
 433     return def;
 434 }
 435
 436 static void
 437 FreeInclude(IncludeStmt *incl);
 438
 439 IncludeStmt *
 440 IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge)
 441 {
 442     IncludeStmt *incl, *first;
 443     char *file, *map, *stmt, *tmp, *extra_data;
 444     char nextop;
 445
 446     incl = first = NULL;
 447     file = map = NULL;
 448     tmp = str;
 449     stmt = strdup_safe(str);
 450     while (tmp && *tmp)
 451     {
 452         if (!ParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
 453             goto err;
 454
 455         /*
 456          * Given an RMLVO (here layout) like 'us,,fr', the rules parser
 457          * will give out something like 'pc+us+:2+fr:3+inet(evdev)'.
 458          * We should just skip the ':2' in this case and leave it to the
 459          * appropriate section to deal with the empty group.
 460          */
 461         if (isempty(file)) {
 462             free(file);
 463             free(map);
 464             free(extra_data);
 465             continue;
 466         }
 467
 468         if (first == NULL) {
 469             first = incl = malloc(sizeof(*first));
 470         } else {
 471             incl->next_incl = malloc(sizeof(*first));
 472             incl = incl->next_incl;
 473         }
 474
 475         if (!incl)
 476             break;
 477
 478         incl->common.type = STMT_INCLUDE;
 479         incl->common.next = NULL;
 480         incl->merge = merge;
 481         incl->stmt = NULL;
 482         incl->file = file;
 483         incl->map = map;
 484         incl->modifier = extra_data;
 485         incl->next_incl = NULL;
 486
 487         if (nextop == '|')
 488             merge = MERGE_AUGMENT;
 489         else
 490             merge = MERGE_OVERRIDE;
 491     }
 492
 493     if (first)
 494         first->stmt = stmt;
 495     else
 496         free(stmt);
 497
 498     return first;
 499
 500 err:
 501     log_err(ctx, "Illegal include statement \"%s\"; Ignored\n", stmt);
 502     FreeInclude(first);
 503     free(stmt);
 504     return NULL;
 505 }
 506
 507 XkbFile *
 508 XkbFileCreate(enum xkb_file_type type, char *name, ParseCommon *defs,
 509               enum xkb_map_flags flags)
 510 {
 511     XkbFile *file;
 512
 513     file = calloc(1, sizeof(*file));
 514     if (!file)
 515         return NULL;
 516
 517     XkbEscapeMapName(name);
 518     file->file_type = type;
 519     file->name = name ? name : strdup("(unnamed)");
 520     file->defs = defs;
 521     file->flags = flags;
 522
 523     return file;
 524 }
 525
 526 XkbFile *
 527 XkbFileFromComponents(struct xkb_context *ctx,
 528                       const struct xkb_component_names *kkctgs)
 529 {
 530     char *const components[] = {
 531         kkctgs->keycodes, kkctgs->types,
 532         kkctgs->compat, kkctgs->symbols,
 533     };
 534     enum xkb_file_type type;
 535     IncludeStmt *include = NULL;
 536     XkbFile *file = NULL;
 537     ParseCommon *defs = NULL;
 538
 539     for (type = FIRST_KEYMAP_FILE_TYPE; type <= LAST_KEYMAP_FILE_TYPE; type++) {
 540         include = IncludeCreate(ctx, components[type], MERGE_DEFAULT);
 541         if (!include)
 542             goto err;
 543
 544         file = XkbFileCreate(type, NULL, (ParseCommon *) include, 0);
 545         if (!file) {
 546             FreeInclude(include);
 547             goto err;
 548         }
 549
 550         defs = AppendStmt(defs, &file->common);
 551     }
 552
 553     file = XkbFileCreate(FILE_TYPE_KEYMAP, NULL, defs, 0);
 554     if (!file)
 555         goto err;
 556
 557     return file;
 558
 559 err:
 560     FreeXkbFile((XkbFile *) defs);
 561     return NULL;
 562 }
 563
 564 static void
 565 FreeExpr(ExprDef *expr)
 566 {
 567     if (!expr)
 568         return;
 569
 570     switch (expr->expr.op) {
 571     case EXPR_ACTION_LIST:
 572     case EXPR_NEGATE:
 573     case EXPR_UNARY_PLUS:
 574     case EXPR_NOT:
 575     case EXPR_INVERT:
 576         FreeStmt((ParseCommon *) expr->unary.child);
 577         break;
 578
 579     case EXPR_DIVIDE:
 580     case EXPR_ADD:
 581     case EXPR_SUBTRACT:
 582     case EXPR_MULTIPLY:
 583     case EXPR_ASSIGN:
 584         FreeStmt((ParseCommon *) expr->binary.left);
 585         FreeStmt((ParseCommon *) expr->binary.right);
 586         break;
 587
 588     case EXPR_ACTION_DECL:
 589         FreeStmt((ParseCommon *) expr->action.args);
 590         break;
 591
 592     case EXPR_ARRAY_REF:
 593         FreeStmt((ParseCommon *) expr->array_ref.entry);
 594         break;
 595
 596     case EXPR_KEYSYM_LIST:
 597         darray_free(expr->keysym_list.syms);
 598         darray_free(expr->keysym_list.symsMapIndex);
 599         darray_free(expr->keysym_list.symsNumEntries);
 600         break;
 601
 602     default:
 603         break;
 604     }
 605 }
 606
 607 static void
 608 FreeInclude(IncludeStmt *incl)
 609 {
 610     IncludeStmt *next;
 611
 612     while (incl)
 613     {
 614         next = incl->next_incl;
 615
 616         free(incl->file);
 617         free(incl->map);
 618         free(incl->modifier);
 619         free(incl->stmt);
 620
 621         free(incl);
 622         incl = next;
 623     }
 624 }
 625
 626 void
 627 FreeStmt(ParseCommon *stmt)
 628 {
 629     ParseCommon *next;
 630
 631     while (stmt)
 632     {
 633         next = stmt->next;
 634
 635         switch (stmt->type) {
 636         case STMT_INCLUDE:
 637             FreeInclude((IncludeStmt *) stmt);
 638             /* stmt is already free'd here. */
 639             stmt = NULL;
 640             break;
 641         case STMT_EXPR:
 642             FreeExpr((ExprDef *) stmt);
 643             break;
 644         case STMT_VAR:
 645             FreeStmt((ParseCommon *) ((VarDef *) stmt)->name);
 646             FreeStmt((ParseCommon *) ((VarDef *) stmt)->value);
 647             break;
 648         case STMT_TYPE:
 649             FreeStmt((ParseCommon *) ((KeyTypeDef *) stmt)->body);
 650             break;
 651         case STMT_INTERP:
 652             FreeStmt((ParseCommon *) ((InterpDef *) stmt)->match);
 653             FreeStmt((ParseCommon *) ((InterpDef *) stmt)->def);
 654             break;
 655         case STMT_VMOD:
 656             FreeStmt((ParseCommon *) ((VModDef *) stmt)->value);
 657             break;
 658         case STMT_SYMBOLS:
 659             FreeStmt((ParseCommon *) ((SymbolsDef *) stmt)->symbols);
 660             break;
 661         case STMT_MODMAP:
 662             FreeStmt((ParseCommon *) ((ModMapDef *) stmt)->keys);
 663             break;
 664         case STMT_GROUP_COMPAT:
 665             FreeStmt((ParseCommon *) ((GroupCompatDef *) stmt)->def);
 666             break;
 667         case STMT_LED_MAP:
 668             FreeStmt((ParseCommon *) ((LedMapDef *) stmt)->body);
 669             break;
 670         case STMT_LED_NAME:
 671             FreeStmt((ParseCommon *) ((LedNameDef *) stmt)->name);
 672             break;
 673         default:
 674             break;
 675         }
 676
 677         free(stmt);
 678         stmt = next;
 679     }
 680 }
 681
 682 void
 683 FreeXkbFile(XkbFile *file)
 684 {
 685     XkbFile *next;
 686
 687     while (file)
 688     {
 689         next = (XkbFile *) file->common.next;
 690
 691         switch (file->file_type) {
 692         case FILE_TYPE_KEYMAP:
 693             FreeXkbFile((XkbFile *) file->defs);
 694             break;
 695
 696         case FILE_TYPE_TYPES:
 697         case FILE_TYPE_COMPAT:
 698         case FILE_TYPE_SYMBOLS:
 699         case FILE_TYPE_KEYCODES:
 700         case FILE_TYPE_GEOMETRY:
 701             FreeStmt(file->defs);
 702             break;
 703
 704         default:
 705             break;
 706         }
 707
 708         free(file->name);
 709         free(file);
 710         file = next;
 711     }
 712 }
 713
 714 static const char *xkb_file_type_strings[_FILE_TYPE_NUM_ENTRIES] = {
 715     [FILE_TYPE_KEYCODES] = "xkb_keycodes",
 716     [FILE_TYPE_TYPES] = "xkb_types",
 717     [FILE_TYPE_COMPAT] = "xkb_compatibility",
 718     [FILE_TYPE_SYMBOLS] = "xkb_symbols",
 719     [FILE_TYPE_GEOMETRY] = "xkb_geometry",
 720     [FILE_TYPE_KEYMAP] = "xkb_keymap",
 721     [FILE_TYPE_RULES] = "rules",
 722 };
 723
 724 const char *
 725 xkb_file_type_to_string(enum xkb_file_type type)
 726 {
 727     if (type > _FILE_TYPE_NUM_ENTRIES)
 728         return "unknown";
 729     return xkb_file_type_strings[type];
 730 }
 731
 732 static const char *stmt_type_strings[_STMT_NUM_VALUES] = {
 733     [STMT_UNKNOWN] = "unknown statement",
 734     [STMT_INCLUDE] = "include statement",
 735     [STMT_KEYCODE] = "key name definition",
 736     [STMT_ALIAS] = "key alias definition",
 737     [STMT_EXPR] = "expression",
 738     [STMT_VAR] = "variable definition",
 739     [STMT_TYPE] = "key type definition",
 740     [STMT_INTERP] = "symbol interpretation definition",
 741     [STMT_VMOD] = "virtual modifiers definition",
 742     [STMT_SYMBOLS] = "key symbols definition",
 743     [STMT_MODMAP] = "modifier map declaration",
 744     [STMT_GROUP_COMPAT] = "group declaration",
 745     [STMT_LED_MAP] = "indicator map declaration",
 746     [STMT_LED_NAME] = "indicator name declaration",
 747 };
 748
 749 const char *
 750 stmt_type_to_string(enum stmt_type type)
 751 {
 752     if (type >= _STMT_NUM_VALUES)
 753         return NULL;
 754     return stmt_type_strings[type];
 755 }
 756
 757 static const char *expr_op_type_strings[_EXPR_NUM_VALUES] = {
 758     [EXPR_VALUE] = "literal",
 759     [EXPR_IDENT] = "identifier",
 760     [EXPR_ACTION_DECL] = "action declaration",
 761     [EXPR_FIELD_REF] = "field reference",
 762     [EXPR_ARRAY_REF] = "array reference",
 763     [EXPR_KEYSYM_LIST] = "list of keysyms",
 764     [EXPR_ACTION_LIST] = "list of actions",
 765     [EXPR_ADD] = "addition",
 766     [EXPR_SUBTRACT] = "subtraction",
 767     [EXPR_MULTIPLY] = "multiplication",
 768     [EXPR_DIVIDE] = "division",
 769     [EXPR_ASSIGN] = "assignment",
 770     [EXPR_NOT] = "logical negation",
 771     [EXPR_NEGATE] = "arithmetic negation",
 772     [EXPR_INVERT] = "bitwise inversion",
 773     [EXPR_UNARY_PLUS] = "unary plus",
 774 };
 775
 776 const char *
 777 expr_op_type_to_string(enum expr_op_type type)
 778 {
 779     if (type >= _EXPR_NUM_VALUES)
 780         return NULL;
 781     return expr_op_type_strings[type];
 782 }
 783
 784 static const char *expr_value_type_strings[_EXPR_TYPE_NUM_VALUES] = {
 785     [EXPR_TYPE_UNKNOWN] = "unknown",
 786     [EXPR_TYPE_BOOLEAN] = "boolean",
 787     [EXPR_TYPE_INT] = "int",
 788     [EXPR_TYPE_STRING] = "string",
 789     [EXPR_TYPE_ACTION] = "action",
 790     [EXPR_TYPE_KEYNAME] = "keyname",
 791     [EXPR_TYPE_SYMBOLS] = "symbols",
 792 };
 793
 794 const char *
 795 expr_value_type_to_string(enum expr_value_type type)
 796 {
 797     if (type >= _EXPR_TYPE_NUM_VALUES)
 798         return NULL;
 799     return expr_value_type_strings[type];
 800 }