1 /************************************************************
2 * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc.
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.
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.
25 ********************************************************/
28 * Copyright © 2012 Intel Corporation
29 * Copyright © 2012 Ran Benita <ran234@gmail.com>
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:
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
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.
50 * Author: Daniel Stone <daniel@fooishbar.org>
51 * Ran Benita <ran234@gmail.com>
54 #include "xkbcomp-priv.h"
55 #include "ast-build.h"
59 AppendStmt(ParseCommon *to, ParseCommon *append)
66 for (iter = to; iter->next; iter = iter->next);
73 ExprCreate(enum expr_op_type op, enum expr_value_type type, size_t size)
75 ExprDef *expr = malloc(size);
79 expr->common.type = STMT_EXPR;
80 expr->common.next = NULL;
82 expr->expr.value_type = type;
87 #define EXPR_CREATE(type_, name_, op_, value_type_) \
88 ExprDef *name_ = ExprCreate(op_, value_type_, sizeof(type_)); \
93 ExprCreateString(xkb_atom_t str)
95 EXPR_CREATE(ExprString, expr, EXPR_VALUE, EXPR_TYPE_STRING);
96 expr->string.str = str;
101 ExprCreateInteger(int ival)
103 EXPR_CREATE(ExprInteger, expr, EXPR_VALUE, EXPR_TYPE_INT);
104 expr->integer.ival = ival;
109 ExprCreateBoolean(bool set)
111 EXPR_CREATE(ExprBoolean, expr, EXPR_VALUE, EXPR_TYPE_BOOLEAN);
112 expr->boolean.set = set;
117 ExprCreateKeyName(xkb_atom_t key_name)
119 EXPR_CREATE(ExprKeyName, expr, EXPR_VALUE, EXPR_TYPE_KEYNAME);
120 expr->key_name.key_name = key_name;
125 ExprCreateIdent(xkb_atom_t ident)
127 EXPR_CREATE(ExprIdent, expr, EXPR_IDENT, EXPR_TYPE_UNKNOWN);
128 expr->ident.ident = ident;
133 ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
136 EXPR_CREATE(ExprUnary, expr, op, type);
137 expr->unary.child = child;
142 ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right)
144 EXPR_CREATE(ExprBinary, expr, op, EXPR_TYPE_UNKNOWN);
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;
158 ExprCreateFieldRef(xkb_atom_t element, xkb_atom_t field)
160 EXPR_CREATE(ExprFieldRef, expr, EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN);
161 expr->field_ref.element = element;
162 expr->field_ref.field = field;
167 ExprCreateArrayRef(xkb_atom_t element, xkb_atom_t field, ExprDef *entry)
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;
177 ExprCreateAction(xkb_atom_t name, ExprDef *args)
179 EXPR_CREATE(ExprAction, expr, EXPR_ACTION_DECL, EXPR_TYPE_UNKNOWN);
180 expr->action.name = name;
181 expr->action.args = args;
186 ExprCreateKeysymList(xkb_keysym_t sym)
188 EXPR_CREATE(ExprKeysymList, expr, EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS);
190 darray_init(expr->keysym_list.syms);
191 darray_init(expr->keysym_list.symsMapIndex);
192 darray_init(expr->keysym_list.symsNumEntries);
194 darray_append(expr->keysym_list.syms, sym);
195 darray_append(expr->keysym_list.symsMapIndex, 0);
196 darray_append(expr->keysym_list.symsNumEntries, 1);
202 ExprCreateMultiKeysymList(ExprDef *expr)
204 unsigned nLevels = darray_size(expr->keysym_list.symsMapIndex);
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;
215 ExprAppendKeysymList(ExprDef *expr, xkb_keysym_t sym)
217 unsigned nSyms = darray_size(expr->keysym_list.syms);
219 darray_append(expr->keysym_list.symsMapIndex, nSyms);
220 darray_append(expr->keysym_list.symsNumEntries, 1);
221 darray_append(expr->keysym_list.syms, sym);
227 ExprAppendMultiKeysymList(ExprDef *expr, ExprDef *append)
229 unsigned nSyms = darray_size(expr->keysym_list.syms);
230 unsigned numEntries = darray_size(append->keysym_list.syms);
232 darray_append(expr->keysym_list.symsMapIndex, nSyms);
233 darray_append(expr->keysym_list.symsNumEntries, numEntries);
234 darray_append_items(expr->keysym_list.syms,
235 darray_mem(append->keysym_list.syms, 0), numEntries);
237 darray_resize(append->keysym_list.syms, 0);
238 FreeStmt((ParseCommon *) &append);
244 KeycodeCreate(xkb_atom_t name, int64_t value)
246 KeycodeDef *def = malloc(sizeof(*def));
250 def->common.type = STMT_KEYCODE;
251 def->common.next = NULL;
259 KeyAliasCreate(xkb_atom_t alias, xkb_atom_t real)
261 KeyAliasDef *def = malloc(sizeof(*def));
265 def->common.type = STMT_ALIAS;
266 def->common.next = NULL;
274 VModCreate(xkb_atom_t name, ExprDef *value)
276 VModDef *def = malloc(sizeof(*def));
280 def->common.type = STMT_VMOD;
281 def->common.next = NULL;
289 VarCreate(ExprDef *name, ExprDef *value)
291 VarDef *def = malloc(sizeof(*def));
295 def->common.type = STMT_VAR;
296 def->common.next = NULL;
304 BoolVarCreate(xkb_atom_t ident, bool set)
306 ExprDef *name, *value;
307 if (!(name = ExprCreateIdent(ident))) {
310 if (!(value = ExprCreateBoolean(set))) {
311 FreeStmt((ParseCommon *) name);
314 return VarCreate(name, value);
318 InterpCreate(xkb_keysym_t sym, ExprDef *match)
320 InterpDef *def = malloc(sizeof(*def));
324 def->common.type = STMT_INTERP;
325 def->common.next = NULL;
333 KeyTypeCreate(xkb_atom_t name, VarDef *body)
335 KeyTypeDef *def = malloc(sizeof(*def));
339 def->common.type = STMT_TYPE;
340 def->common.next = NULL;
341 def->merge = MERGE_DEFAULT;
349 SymbolsCreate(xkb_atom_t keyName, VarDef *symbols)
351 SymbolsDef *def = malloc(sizeof(*def));
355 def->common.type = STMT_SYMBOLS;
356 def->common.next = NULL;
357 def->merge = MERGE_DEFAULT;
358 def->keyName = keyName;
359 def->symbols = symbols;
365 GroupCompatCreate(unsigned group, ExprDef *val)
367 GroupCompatDef *def = malloc(sizeof(*def));
371 def->common.type = STMT_GROUP_COMPAT;
372 def->common.next = NULL;
373 def->merge = MERGE_DEFAULT;
381 ModMapCreate(xkb_atom_t modifier, ExprDef *keys)
383 ModMapDef *def = malloc(sizeof(*def));
387 def->common.type = STMT_MODMAP;
388 def->common.next = NULL;
389 def->merge = MERGE_DEFAULT;
390 def->modifier = modifier;
397 LedMapCreate(xkb_atom_t name, VarDef *body)
399 LedMapDef *def = malloc(sizeof(*def));
403 def->common.type = STMT_LED_MAP;
404 def->common.next = NULL;
405 def->merge = MERGE_DEFAULT;
413 LedNameCreate(unsigned ndx, ExprDef *name, bool virtual)
415 LedNameDef *def = malloc(sizeof(*def));
419 def->common.type = STMT_LED_NAME;
420 def->common.next = NULL;
421 def->merge = MERGE_DEFAULT;
424 def->virtual = virtual;
430 FreeInclude(IncludeStmt *incl);
433 IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge)
435 IncludeStmt *incl, *first;
436 char *file, *map, *stmt, *tmp, *extra_data;
442 stmt = strdup_safe(str);
445 if (!ParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
449 * Given an RMLVO (here layout) like 'us,,fr', the rules parser
450 * will give out something like 'pc+us+:2+fr:3+inet(evdev)'.
451 * We should just skip the ':2' in this case and leave it to the
452 * appropriate section to deal with the empty group.
462 first = incl = malloc(sizeof(*first));
464 incl->next_incl = malloc(sizeof(*first));
465 incl = incl->next_incl;
470 "Allocation failure in IncludeCreate; "
471 "Using only part of the include\n");
475 incl->common.type = STMT_INCLUDE;
476 incl->common.next = NULL;
481 incl->modifier = extra_data;
482 incl->next_incl = NULL;
485 merge = MERGE_AUGMENT;
487 merge = MERGE_OVERRIDE;
498 log_err(ctx, "Illegal include statement \"%s\"; Ignored\n", stmt);
505 XkbFileCreate(enum xkb_file_type type, char *name, ParseCommon *defs,
506 enum xkb_map_flags flags)
510 file = calloc(1, sizeof(*file));
514 XkbEscapeMapName(name);
515 file->file_type = type;
516 file->topName = strdup_safe(name);
525 XkbFileFromComponents(struct xkb_context *ctx,
526 const struct xkb_component_names *kkctgs)
528 char *const components[] = {
529 kkctgs->keycodes, kkctgs->types,
530 kkctgs->compat, kkctgs->symbols,
532 enum xkb_file_type type;
533 IncludeStmt *include = NULL;
534 XkbFile *file = NULL;
535 ParseCommon *defs = NULL;
537 for (type = FIRST_KEYMAP_FILE_TYPE; type <= LAST_KEYMAP_FILE_TYPE; type++) {
538 include = IncludeCreate(ctx, components[type], MERGE_DEFAULT);
542 file = XkbFileCreate(type, NULL, (ParseCommon *) include, 0);
544 FreeInclude(include);
548 defs = AppendStmt(defs, &file->common);
551 file = XkbFileCreate(FILE_TYPE_KEYMAP, NULL, defs, 0);
558 FreeXkbFile((XkbFile *) defs);
563 FreeExpr(ExprDef *expr)
568 switch (expr->expr.op) {
569 case EXPR_ACTION_LIST:
571 case EXPR_UNARY_PLUS:
574 FreeStmt((ParseCommon *) expr->unary.child);
582 FreeStmt((ParseCommon *) expr->binary.left);
583 FreeStmt((ParseCommon *) expr->binary.right);
586 case EXPR_ACTION_DECL:
587 FreeStmt((ParseCommon *) expr->action.args);
591 FreeStmt((ParseCommon *) expr->array_ref.entry);
594 case EXPR_KEYSYM_LIST:
595 darray_free(expr->keysym_list.syms);
596 darray_free(expr->keysym_list.symsMapIndex);
597 darray_free(expr->keysym_list.symsNumEntries);
606 FreeInclude(IncludeStmt *incl)
612 next = incl->next_incl;
616 free(incl->modifier);
625 FreeStmt(ParseCommon *stmt)
633 switch (stmt->type) {
635 FreeInclude((IncludeStmt *) stmt);
636 /* stmt is already free'd here. */
640 FreeExpr((ExprDef *) stmt);
643 FreeStmt((ParseCommon *) ((VarDef *) stmt)->name);
644 FreeStmt((ParseCommon *) ((VarDef *) stmt)->value);
647 FreeStmt((ParseCommon *) ((KeyTypeDef *) stmt)->body);
650 FreeStmt((ParseCommon *) ((InterpDef *) stmt)->match);
651 FreeStmt((ParseCommon *) ((InterpDef *) stmt)->def);
654 FreeStmt((ParseCommon *) ((VModDef *) stmt)->value);
657 FreeStmt((ParseCommon *) ((SymbolsDef *) stmt)->symbols);
660 FreeStmt((ParseCommon *) ((ModMapDef *) stmt)->keys);
662 case STMT_GROUP_COMPAT:
663 FreeStmt((ParseCommon *) ((GroupCompatDef *) stmt)->def);
666 FreeStmt((ParseCommon *) ((LedMapDef *) stmt)->body);
669 FreeStmt((ParseCommon *) ((LedNameDef *) stmt)->name);
681 FreeXkbFile(XkbFile *file)
687 next = (XkbFile *) file->common.next;
689 switch (file->file_type) {
690 case FILE_TYPE_KEYMAP:
691 FreeXkbFile((XkbFile *) file->defs);
694 case FILE_TYPE_TYPES:
695 case FILE_TYPE_COMPAT:
696 case FILE_TYPE_SYMBOLS:
697 case FILE_TYPE_KEYCODES:
698 case FILE_TYPE_GEOMETRY:
699 FreeStmt(file->defs);
713 static const char *xkb_file_type_strings[_FILE_TYPE_NUM_ENTRIES] = {
714 [FILE_TYPE_KEYCODES] = "xkb_keycodes",
715 [FILE_TYPE_TYPES] = "xkb_types",
716 [FILE_TYPE_COMPAT] = "xkb_compatibility",
717 [FILE_TYPE_SYMBOLS] = "xkb_symbols",
718 [FILE_TYPE_GEOMETRY] = "xkb_geometry",
719 [FILE_TYPE_KEYMAP] = "xkb_keymap",
720 [FILE_TYPE_RULES] = "rules",
724 xkb_file_type_to_string(enum xkb_file_type type)
726 if (type > _FILE_TYPE_NUM_ENTRIES)
728 return xkb_file_type_strings[type];
731 static const char *stmt_type_strings[_STMT_NUM_VALUES] = {
732 [STMT_UNKNOWN] = "unknown statement",
733 [STMT_INCLUDE] = "include statement",
734 [STMT_KEYCODE] = "key name definition",
735 [STMT_ALIAS] = "key alias definition",
736 [STMT_EXPR] = "expression",
737 [STMT_VAR] = "variable definition",
738 [STMT_TYPE] = "key type definition",
739 [STMT_INTERP] = "symbol interpretation definition",
740 [STMT_VMOD] = "virtual modifiers definition",
741 [STMT_SYMBOLS] = "key symbols definition",
742 [STMT_MODMAP] = "modifier map declaration",
743 [STMT_GROUP_COMPAT] = "group declaration",
744 [STMT_LED_MAP] = "indicator map declaration",
745 [STMT_LED_NAME] = "indicator name declaration",
749 stmt_type_to_string(enum stmt_type type)
751 if (type >= _STMT_NUM_VALUES)
753 return stmt_type_strings[type];
756 static const char *expr_op_type_strings[_EXPR_NUM_VALUES] = {
757 [EXPR_VALUE] = "literal",
758 [EXPR_IDENT] = "identifier",
759 [EXPR_ACTION_DECL] = "action declaration",
760 [EXPR_FIELD_REF] = "field reference",
761 [EXPR_ARRAY_REF] = "array reference",
762 [EXPR_KEYSYM_LIST] = "list of keysyms",
763 [EXPR_ACTION_LIST] = "list of actions",
764 [EXPR_ADD] = "addition",
765 [EXPR_SUBTRACT] = "subtraction",
766 [EXPR_MULTIPLY] = "multiplication",
767 [EXPR_DIVIDE] = "division",
768 [EXPR_ASSIGN] = "assignment",
769 [EXPR_NOT] = "logical negation",
770 [EXPR_NEGATE] = "arithmetic negation",
771 [EXPR_INVERT] = "bitwise inversion",
772 [EXPR_UNARY_PLUS] = "unary plus",
776 expr_op_type_to_string(enum expr_op_type type)
778 if (type >= _EXPR_NUM_VALUES)
780 return expr_op_type_strings[type];
783 static const char *expr_value_type_strings[_EXPR_TYPE_NUM_VALUES] = {
784 [EXPR_TYPE_UNKNOWN] = "unknown",
785 [EXPR_TYPE_BOOLEAN] = "boolean",
786 [EXPR_TYPE_INT] = "int",
787 [EXPR_TYPE_STRING] = "string",
788 [EXPR_TYPE_ACTION] = "action",
789 [EXPR_TYPE_KEYNAME] = "keyname",
790 [EXPR_TYPE_SYMBOLS] = "symbols",
794 expr_value_type_to_string(enum expr_value_type type)
796 if (type >= _EXPR_TYPE_NUM_VALUES)
798 return expr_value_type_strings[type];