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 "path.h"
  29
  30 ATTR_MALLOC static void *
  31 malloc_or_die(size_t size)
  32 {
  33     void *p = malloc(size);
  34     if (!p) {
  35         fprintf(stderr, "Out of memory\n");
  36         exit(1);
  37     }
  38     return p;
  39 }
  40
  41 ParseCommon *
  42 AppendStmt(ParseCommon * to, ParseCommon * append)
  43 {
  44     ParseCommon *start = to;
  45
  46     if (append == NULL)
  47         return to;
  48     while ((to != NULL) && (to->next != NULL))
  49     {
  50         to = to->next;
  51     }
  52     if (to) {
  53         to->next = append;
  54         return start;
  55     }
  56     return append;
  57 }
  58
  59 ExprDef *
  60 ExprCreate(enum expr_op_type op, enum expr_value_type type)
  61 {
  62     ExprDef *expr;
  63
  64     expr = malloc_or_die(sizeof(*expr));
  65
  66     expr->common.type = STMT_EXPR;
  67     expr->common.next = NULL;
  68     expr->op = op;
  69     expr->value_type = type;
  70     return expr;
  71 }
  72
  73 ExprDef *
  74 ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
  75                 ExprDef *child)
  76 {
  77     ExprDef *expr;
  78     expr = malloc_or_die(sizeof(*expr));
  79
  80     expr->common.type = STMT_EXPR;
  81     expr->common.next = NULL;
  82     expr->op = op;
  83     expr->value_type = type;
  84     expr->value.child = child;
  85     return expr;
  86 }
  87
  88 ExprDef *
  89 ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right)
  90 {
  91     ExprDef *expr;
  92
  93     expr = malloc_or_die(sizeof(*expr));
  94
  95     expr->common.type = STMT_EXPR;
  96     expr->common.next = NULL;
  97     expr->op = op;
  98     if (op == EXPR_ASSIGN || left->value_type == EXPR_TYPE_UNKNOWN)
  99         expr->value_type = right->value_type;
 100     else if (left->value_type == right->value_type ||
 101              right->value_type == EXPR_TYPE_UNKNOWN)
 102         expr->value_type = left->value_type;
 103     else
 104         expr->value_type = EXPR_TYPE_UNKNOWN;
 105     expr->value.binary.left = left;
 106     expr->value.binary.right = right;
 107     return expr;
 108 }
 109
 110 KeycodeDef *
 111 KeycodeCreate(char keyName[XkbKeyNameLength], unsigned long value)
 112 {
 113     KeycodeDef *def;
 114
 115     def = malloc_or_die(sizeof(*def));
 116
 117     def->common.type = STMT_KEYCODE;
 118     def->common.next = NULL;
 119     strncpy(def->name, keyName, XkbKeyNameLength);
 120     def->name[XkbKeyNameLength] = '\0';
 121     def->value = value;
 122     return def;
 123 }
 124
 125 KeyAliasDef *
 126 KeyAliasCreate(char alias[XkbKeyNameLength], char real[XkbKeyNameLength])
 127 {
 128     KeyAliasDef *def;
 129
 130     def = malloc_or_die(sizeof(*def));
 131
 132     def->common.type = STMT_ALIAS;
 133     def->common.next = NULL;
 134     strncpy(def->alias, alias, XkbKeyNameLength);
 135     def->alias[XkbKeyNameLength] = '\0';
 136     strncpy(def->real, real, XkbKeyNameLength);
 137     def->real[XkbKeyNameLength] = '\0';
 138     return def;
 139 }
 140
 141 VModDef *
 142 VModCreate(xkb_atom_t name, ExprDef * value)
 143 {
 144     VModDef *def;
 145
 146     def = malloc_or_die(sizeof(*def));
 147
 148     def->common.type = STMT_VMOD;
 149     def->common.next = NULL;
 150     def->name = name;
 151     def->value = value;
 152     return def;
 153 }
 154
 155 VarDef *
 156 VarCreate(ExprDef * name, ExprDef * value)
 157 {
 158     VarDef *def;
 159     def = malloc_or_die(sizeof(*def));
 160
 161     def->common.type = STMT_VAR;
 162     def->common.next = NULL;
 163     def->name = name;
 164     def->value = value;
 165     return def;
 166 }
 167
 168 VarDef *
 169 BoolVarCreate(xkb_atom_t nameToken, unsigned set)
 170 {
 171     ExprDef *name, *value;
 172
 173     name = ExprCreate(EXPR_IDENT, EXPR_TYPE_UNKNOWN);
 174     name->value.str = nameToken;
 175     value = ExprCreate(EXPR_VALUE, EXPR_TYPE_BOOLEAN);
 176     value->value.uval = set;
 177     return VarCreate(name, value);
 178 }
 179
 180 InterpDef *
 181 InterpCreate(char *sym, ExprDef * match)
 182 {
 183     InterpDef *def;
 184
 185     def = malloc_or_die(sizeof(*def));
 186
 187     def->common.type = STMT_INTERP;
 188     def->common.next = NULL;
 189     def->sym = sym;
 190     def->match = match;
 191     return def;
 192 }
 193
 194 KeyTypeDef *
 195 KeyTypeCreate(xkb_atom_t name, VarDef * body)
 196 {
 197     KeyTypeDef *def;
 198
 199     def = malloc_or_die(sizeof(*def));
 200
 201     def->common.type = STMT_TYPE;
 202     def->common.next = NULL;
 203     def->merge = MERGE_DEFAULT;
 204     def->name = name;
 205     def->body = body;
 206     return def;
 207 }
 208
 209 SymbolsDef *
 210 SymbolsCreate(char keyName[XkbKeyNameLength], ExprDef *symbols)
 211 {
 212     SymbolsDef *def;
 213
 214     def = malloc_or_die(sizeof(*def));
 215
 216     def->common.type = STMT_SYMBOLS;
 217     def->common.next = NULL;
 218     def->merge = MERGE_DEFAULT;
 219     strncpy(def->keyName, keyName, XkbKeyNameLength);
 220     def->symbols = symbols;
 221     return def;
 222 }
 223
 224 GroupCompatDef *
 225 GroupCompatCreate(int group, ExprDef * val)
 226 {
 227     GroupCompatDef *def;
 228
 229     def = malloc_or_die(sizeof(*def));
 230
 231     def->common.type = STMT_GROUP_COMPAT;
 232     def->common.next = NULL;
 233     def->merge = MERGE_DEFAULT;
 234     def->group = group;
 235     def->def = val;
 236     return def;
 237 }
 238
 239 ModMapDef *
 240 ModMapCreate(uint32_t modifier, ExprDef * keys)
 241 {
 242     ModMapDef *def;
 243
 244     def = malloc_or_die(sizeof(*def));
 245
 246     def->common.type = STMT_MODMAP;
 247     def->common.next = NULL;
 248     def->merge = MERGE_DEFAULT;
 249     def->modifier = modifier;
 250     def->keys = keys;
 251     return def;
 252 }
 253
 254 IndicatorMapDef *
 255 IndicatorMapCreate(xkb_atom_t name, VarDef * body)
 256 {
 257     IndicatorMapDef *def;
 258
 259     def = malloc_or_die(sizeof(*def));
 260
 261     def->common.type = STMT_INDICATOR_MAP;
 262     def->common.next = NULL;
 263     def->merge = MERGE_DEFAULT;
 264     def->name = name;
 265     def->body = body;
 266     return def;
 267 }
 268
 269 IndicatorNameDef *
 270 IndicatorNameCreate(int ndx, ExprDef * name, bool virtual)
 271 {
 272     IndicatorNameDef *def;
 273
 274     def = malloc_or_die(sizeof(*def));
 275
 276     def->common.type = STMT_INDICATOR_NAME;
 277     def->common.next = NULL;
 278     def->merge = MERGE_DEFAULT;
 279     def->ndx = ndx;
 280     def->name = name;
 281     def->virtual = virtual;
 282     return def;
 283 }
 284
 285 ExprDef *
 286 ActionCreate(xkb_atom_t name, ExprDef * args)
 287 {
 288     ExprDef *act;
 289
 290     act = malloc_or_die(sizeof(*act));
 291
 292     act->common.type = STMT_EXPR;
 293     act->common.next = NULL;
 294     act->op = EXPR_ACTION_DECL;
 295     act->value.action.name = name;
 296     act->value.action.args = args;
 297     return act;
 298 }
 299
 300 ExprDef *
 301 CreateKeysymList(char *sym)
 302 {
 303     ExprDef *def;
 304
 305     def = ExprCreate(EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS);
 306
 307     darray_init(def->value.list.syms);
 308     darray_init(def->value.list.symsMapIndex);
 309     darray_init(def->value.list.symsNumEntries);
 310
 311     darray_append(def->value.list.syms, sym);
 312     darray_append(def->value.list.symsMapIndex, 0);
 313     darray_append(def->value.list.symsNumEntries, 1);
 314
 315     return def;
 316 }
 317
 318 ExprDef *
 319 CreateMultiKeysymList(ExprDef *list)
 320 {
 321     size_t nLevels = darray_size(list->value.list.symsMapIndex);
 322
 323     darray_resize(list->value.list.symsMapIndex, 1);
 324     darray_resize(list->value.list.symsNumEntries, 1);
 325     darray_item(list->value.list.symsMapIndex, 0) = 0;
 326     darray_item(list->value.list.symsNumEntries, 0) = nLevels;
 327
 328     return list;
 329 }
 330
 331 ExprDef *
 332 AppendKeysymList(ExprDef * list, char *sym)
 333 {
 334     size_t nSyms = darray_size(list->value.list.syms);
 335
 336     darray_append(list->value.list.symsMapIndex, nSyms);
 337     darray_append(list->value.list.symsNumEntries, 1);
 338     darray_append(list->value.list.syms, sym);
 339
 340     return list;
 341 }
 342
 343 ExprDef *
 344 AppendMultiKeysymList(ExprDef * list, ExprDef * append)
 345 {
 346     size_t nSyms = darray_size(list->value.list.syms);
 347     size_t numEntries = darray_size(append->value.list.syms);
 348
 349     darray_append(list->value.list.symsMapIndex, nSyms);
 350     darray_append(list->value.list.symsNumEntries, numEntries);
 351     darray_append_items(list->value.list.syms,
 352                         darray_mem(append->value.list.syms, 0),
 353                         numEntries);
 354
 355     darray_resize(append->value.list.syms, 0);
 356     FreeStmt(&append->common);
 357
 358     return list;
 359 }
 360
 361 bool
 362 LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
 363 {
 364     xkb_keysym_t sym;
 365
 366     if (!str || istreq(str, "any") || istreq(str, "nosymbol")) {
 367         *sym_rtrn = XKB_KEY_NoSymbol;
 368         return 1;
 369     }
 370
 371     if (istreq(str, "none") || istreq(str, "voidsymbol")) {
 372         *sym_rtrn = XKB_KEY_VoidSymbol;
 373         return 1;
 374     }
 375
 376     sym = xkb_keysym_from_name(str);
 377     if (sym != XKB_KEY_NoSymbol) {
 378         *sym_rtrn = sym;
 379         return 1;
 380     }
 381
 382     return 0;
 383 }
 384
 385 static void
 386 FreeInclude(IncludeStmt *incl);
 387
 388 IncludeStmt *
 389 IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge)
 390 {
 391     IncludeStmt *incl, *first;
 392     char *file, *map, *stmt, *tmp, *extra_data;
 393     char nextop;
 394
 395     incl = first = NULL;
 396     file = map = NULL;
 397     tmp = str;
 398     stmt = strdup_safe(str);
 399     while (tmp && *tmp)
 400     {
 401         if (!XkbParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
 402             goto err;
 403
 404         if (first == NULL) {
 405             first = incl = malloc(sizeof(*first));
 406         } else {
 407             incl->next_incl = malloc(sizeof(*first));
 408             incl = incl->next_incl;
 409         }
 410
 411         if (!incl) {
 412             log_wsgo(ctx,
 413                      "Allocation failure in IncludeCreate; "
 414                      "Using only part of the include\n");
 415             break;
 416         }
 417
 418         incl->common.type = STMT_INCLUDE;
 419         incl->common.next = NULL;
 420         incl->merge = merge;
 421         incl->stmt = NULL;
 422         incl->file = file;
 423         incl->map = map;
 424         incl->modifier = extra_data;
 425         incl->path = NULL;
 426         incl->next_incl = NULL;
 427
 428         if (nextop == '|')
 429             merge = MERGE_AUGMENT;
 430         else
 431             merge = MERGE_OVERRIDE;
 432     }
 433
 434     if (first)
 435         first->stmt = stmt;
 436     else
 437         free(stmt);
 438
 439     return first;
 440
 441 err:
 442     log_err(ctx, "Illegal include statement \"%s\"; Ignored\n", stmt);
 443     FreeInclude(first);
 444     free(stmt);
 445     return NULL;
 446 }
 447
 448 void
 449 CheckDefaultMap(struct xkb_context *ctx, XkbFile *maps, const char *fileName)
 450 {
 451     XkbFile *dflt = NULL, *tmp;
 452
 453     for (tmp = maps; tmp; tmp = (XkbFile *) tmp->common.next) {
 454         if (!(tmp->flags & XkbLC_Default))
 455             continue;
 456         if (!dflt) {
 457             dflt = tmp;
 458             continue;
 459         }
 460
 461         log_lvl(ctx, 3,
 462                 "Multiple default components in %s; "
 463                 "Using %s, ignoring %s\n",
 464                 (fileName ? fileName : "(unknown)"),
 465                 (dflt->name ? dflt->name : "(first)"),
 466                 (tmp->name ? tmp->name : "(subsequent)"));
 467
 468         tmp->flags &= (~XkbLC_Default);
 469     }
 470 }
 471
 472 /*
 473  * All latin-1 alphanumerics, plus parens, slash, minus, underscore and
 474  * wildcards.
 475  */
 476 static const unsigned char componentSpecLegal[] = {
 477     0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83,
 478     0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
 479     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 480     0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
 481 };
 482
 483 static void
 484 EnsureSafeMapName(char *name)
 485 {
 486     if (!name)
 487         return;
 488
 489     while (*name != '\0') {
 490         if ((componentSpecLegal[(*name) / 8] & (1 << ((*name) % 8))) == 0)
 491             *name = '_';
 492         name++;
 493     }
 494 }
 495
 496 XkbFile *
 497 CreateXKBFile(struct xkb_context *ctx, enum xkb_file_type type, char *name,
 498               ParseCommon *defs, unsigned flags)
 499 {
 500     XkbFile *file;
 501
 502     file = calloc(1, sizeof(*file));
 503     if (!file)
 504         return NULL;
 505
 506     EnsureSafeMapName(name);
 507     file->file_type = type;
 508     file->topName = strdup_safe(name);
 509     file->name = name;
 510     file->defs = defs;
 511     file->id = xkb_context_take_file_id(ctx);
 512     file->flags = flags;
 513     return file;
 514 }
 515
 516 static void
 517 FreeExpr(ExprDef *expr)
 518 {
 519     char **sym;
 520
 521     if (!expr)
 522         return;
 523
 524     switch (expr->op) {
 525     case EXPR_ACTION_LIST:
 526     case EXPR_NEGATE:
 527     case EXPR_UNARY_PLUS:
 528     case EXPR_NOT:
 529     case EXPR_INVERT:
 530         FreeStmt(&expr->value.child->common);
 531         break;
 532
 533     case EXPR_DIVIDE:
 534     case EXPR_ADD:
 535     case EXPR_SUBTRACT:
 536     case EXPR_MULTIPLY:
 537     case EXPR_ASSIGN:
 538         FreeStmt(&expr->value.binary.left->common);
 539         FreeStmt(&expr->value.binary.right->common);
 540         break;
 541
 542     case EXPR_ACTION_DECL:
 543         FreeStmt(&expr->value.action.args->common);
 544         break;
 545
 546     case EXPR_ARRAY_REF:
 547         FreeStmt(&expr->value.array.entry->common);
 548         break;
 549
 550     case EXPR_KEYSYM_LIST:
 551         darray_foreach(sym, expr->value.list.syms)
 552             free(*sym);
 553         darray_free(expr->value.list.syms);
 554         darray_free(expr->value.list.symsMapIndex);
 555         darray_free(expr->value.list.symsNumEntries);
 556         break;
 557
 558     default:
 559         break;
 560     }
 561 }
 562
 563 static void
 564 FreeInclude(IncludeStmt *incl)
 565 {
 566     IncludeStmt *next;
 567
 568     while (incl)
 569     {
 570         next = incl->next_incl;
 571
 572         free(incl->file);
 573         free(incl->map);
 574         free(incl->modifier);
 575         free(incl->path);
 576         free(incl->stmt);
 577
 578         free(incl);
 579         incl = next;
 580     }
 581 }
 582
 583 void
 584 FreeStmt(ParseCommon *stmt)
 585 {
 586     ParseCommon *next;
 587     YYSTYPE u;
 588
 589     while (stmt)
 590     {
 591         next = stmt->next;
 592         u.any = stmt;
 593
 594         switch (stmt->type) {
 595         case STMT_INCLUDE:
 596             FreeInclude((IncludeStmt *) stmt);
 597             /* stmt is already free'd here. */
 598             stmt = NULL;
 599             break;
 600         case STMT_EXPR:
 601             FreeExpr(u.expr);
 602             break;
 603         case STMT_VAR:
 604             FreeStmt(&u.var->name->common);
 605             FreeStmt(&u.var->value->common);
 606             break;
 607         case STMT_TYPE:
 608             FreeStmt(&u.keyType->body->common);
 609             break;
 610         case STMT_INTERP:
 611             free(u.interp->sym);
 612             FreeStmt(&u.interp->match->common);
 613             FreeStmt(&u.interp->def->common);
 614             break;
 615         case STMT_VMOD:
 616             FreeStmt(&u.vmod->value->common);
 617             break;
 618         case STMT_SYMBOLS:
 619             FreeStmt(&u.syms->symbols->common);
 620             break;
 621         case STMT_MODMAP:
 622             FreeStmt(&u.modMask->keys->common);
 623             break;
 624         case STMT_GROUP_COMPAT:
 625             FreeStmt(&u.groupCompat->def->common);
 626             break;
 627         case STMT_INDICATOR_MAP:
 628             FreeStmt(&u.ledMap->body->common);
 629             break;
 630         case STMT_INDICATOR_NAME:
 631             FreeStmt(&u.ledName->name->common);
 632             break;
 633         default:
 634             break;
 635         }
 636
 637         free(stmt);
 638         stmt = next;
 639     }
 640 }
 641
 642 void
 643 FreeXKBFile(XkbFile *file)
 644 {
 645     XkbFile *next;
 646
 647     while (file)
 648     {
 649         next = (XkbFile *) file->common.next;
 650
 651         switch (file->file_type) {
 652         case FILE_TYPE_KEYMAP:
 653             FreeXKBFile((XkbFile *) file->defs);
 654             break;
 655
 656         case FILE_TYPE_TYPES:
 657         case FILE_TYPE_COMPAT:
 658         case FILE_TYPE_SYMBOLS:
 659         case FILE_TYPE_KEYCODES:
 660         case FILE_TYPE_GEOMETRY:
 661             FreeStmt(file->defs);
 662             break;
 663
 664         default:
 665             break;
 666         }
 667
 668         free(file->name);
 669         free(file->topName);
 670         free(file);
 671         file = next;
 672     }
 673 }