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 ********************************************************/
27 #include "xkbcomp-priv.h"
28 #include "ast-build.h"
29 #include "parser-priv.h"
32 ATTR_MALLOC static void *
33 malloc_or_die(size_t size)
35 void *p = malloc(size);
37 fprintf(stderr, "Out of memory\n");
44 AppendStmt(ParseCommon * to, ParseCommon * append)
46 ParseCommon *start = to;
50 while ((to != NULL) && (to->next != NULL))
62 ExprCreate(enum expr_op_type op, enum expr_value_type type)
66 expr = malloc_or_die(sizeof(*expr));
68 expr->common.type = STMT_EXPR;
69 expr->common.next = NULL;
71 expr->value_type = type;
76 ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
80 expr = malloc_or_die(sizeof(*expr));
82 expr->common.type = STMT_EXPR;
83 expr->common.next = NULL;
85 expr->value_type = type;
86 expr->value.child = child;
91 ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right)
95 expr = malloc_or_die(sizeof(*expr));
97 expr->common.type = STMT_EXPR;
98 expr->common.next = NULL;
100 if (op == EXPR_ASSIGN || left->value_type == EXPR_TYPE_UNKNOWN)
101 expr->value_type = right->value_type;
102 else if (left->value_type == right->value_type ||
103 right->value_type == EXPR_TYPE_UNKNOWN)
104 expr->value_type = left->value_type;
106 expr->value_type = EXPR_TYPE_UNKNOWN;
107 expr->value.binary.left = left;
108 expr->value.binary.right = right;
113 KeycodeCreate(char keyName[XKB_KEY_NAME_LENGTH], unsigned long value)
117 def = malloc_or_die(sizeof(*def));
119 def->common.type = STMT_KEYCODE;
120 def->common.next = NULL;
121 strncpy(def->name, keyName, XKB_KEY_NAME_LENGTH);
127 KeyAliasCreate(char alias[XKB_KEY_NAME_LENGTH], char real[XKB_KEY_NAME_LENGTH])
131 def = malloc_or_die(sizeof(*def));
133 def->common.type = STMT_ALIAS;
134 def->common.next = NULL;
135 strncpy(def->alias, alias, XKB_KEY_NAME_LENGTH);
136 strncpy(def->real, real, XKB_KEY_NAME_LENGTH);
141 VModCreate(xkb_atom_t name, ExprDef * value)
145 def = malloc_or_die(sizeof(*def));
147 def->common.type = STMT_VMOD;
148 def->common.next = NULL;
155 VarCreate(ExprDef * name, ExprDef * value)
158 def = malloc_or_die(sizeof(*def));
160 def->common.type = STMT_VAR;
161 def->common.next = NULL;
168 BoolVarCreate(xkb_atom_t nameToken, unsigned set)
170 ExprDef *name, *value;
172 name = ExprCreate(EXPR_IDENT, EXPR_TYPE_UNKNOWN);
173 name->value.str = nameToken;
174 value = ExprCreate(EXPR_VALUE, EXPR_TYPE_BOOLEAN);
175 value->value.uval = set;
176 return VarCreate(name, value);
180 InterpCreate(char *sym, ExprDef * match)
184 def = malloc_or_die(sizeof(*def));
186 def->common.type = STMT_INTERP;
187 def->common.next = NULL;
194 KeyTypeCreate(xkb_atom_t name, VarDef * body)
198 def = malloc_or_die(sizeof(*def));
200 def->common.type = STMT_TYPE;
201 def->common.next = NULL;
202 def->merge = MERGE_DEFAULT;
209 SymbolsCreate(char keyName[XKB_KEY_NAME_LENGTH], ExprDef *symbols)
213 def = malloc_or_die(sizeof(*def));
215 def->common.type = STMT_SYMBOLS;
216 def->common.next = NULL;
217 def->merge = MERGE_DEFAULT;
218 strncpy(def->keyName, keyName, XKB_KEY_NAME_LENGTH);
219 def->symbols = symbols;
224 GroupCompatCreate(int group, ExprDef * val)
228 def = malloc_or_die(sizeof(*def));
230 def->common.type = STMT_GROUP_COMPAT;
231 def->common.next = NULL;
232 def->merge = MERGE_DEFAULT;
239 ModMapCreate(uint32_t modifier, ExprDef * keys)
243 def = malloc_or_die(sizeof(*def));
245 def->common.type = STMT_MODMAP;
246 def->common.next = NULL;
247 def->merge = MERGE_DEFAULT;
248 def->modifier = modifier;
254 IndicatorMapCreate(xkb_atom_t name, VarDef * body)
256 IndicatorMapDef *def;
258 def = malloc_or_die(sizeof(*def));
260 def->common.type = STMT_INDICATOR_MAP;
261 def->common.next = NULL;
262 def->merge = MERGE_DEFAULT;
269 IndicatorNameCreate(int ndx, ExprDef * name, bool virtual)
271 IndicatorNameDef *def;
273 def = malloc_or_die(sizeof(*def));
275 def->common.type = STMT_INDICATOR_NAME;
276 def->common.next = NULL;
277 def->merge = MERGE_DEFAULT;
280 def->virtual = virtual;
285 ActionCreate(xkb_atom_t name, ExprDef * args)
289 act = malloc_or_die(sizeof(*act));
291 act->common.type = STMT_EXPR;
292 act->common.next = NULL;
293 act->op = EXPR_ACTION_DECL;
294 act->value.action.name = name;
295 act->value.action.args = args;
300 CreateKeysymList(char *sym)
304 def = ExprCreate(EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS);
306 darray_init(def->value.list.syms);
307 darray_init(def->value.list.symsMapIndex);
308 darray_init(def->value.list.symsNumEntries);
310 darray_append(def->value.list.syms, sym);
311 darray_append(def->value.list.symsMapIndex, 0);
312 darray_append(def->value.list.symsNumEntries, 1);
318 CreateMultiKeysymList(ExprDef *list)
320 size_t nLevels = darray_size(list->value.list.symsMapIndex);
322 darray_resize(list->value.list.symsMapIndex, 1);
323 darray_resize(list->value.list.symsNumEntries, 1);
324 darray_item(list->value.list.symsMapIndex, 0) = 0;
325 darray_item(list->value.list.symsNumEntries, 0) = nLevels;
331 AppendKeysymList(ExprDef * list, char *sym)
333 size_t nSyms = darray_size(list->value.list.syms);
335 darray_append(list->value.list.symsMapIndex, nSyms);
336 darray_append(list->value.list.symsNumEntries, 1);
337 darray_append(list->value.list.syms, sym);
343 AppendMultiKeysymList(ExprDef * list, ExprDef * append)
345 size_t nSyms = darray_size(list->value.list.syms);
346 size_t numEntries = darray_size(append->value.list.syms);
348 darray_append(list->value.list.symsMapIndex, nSyms);
349 darray_append(list->value.list.symsNumEntries, numEntries);
350 darray_append_items(list->value.list.syms,
351 darray_mem(append->value.list.syms, 0),
354 darray_resize(append->value.list.syms, 0);
355 FreeStmt(&append->common);
361 FreeInclude(IncludeStmt *incl);
364 IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge)
366 IncludeStmt *incl, *first;
367 char *file, *map, *stmt, *tmp, *extra_data;
373 stmt = strdup_safe(str);
376 if (!ParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
380 first = incl = malloc(sizeof(*first));
382 incl->next_incl = malloc(sizeof(*first));
383 incl = incl->next_incl;
388 "Allocation failure in IncludeCreate; "
389 "Using only part of the include\n");
393 incl->common.type = STMT_INCLUDE;
394 incl->common.next = NULL;
399 incl->modifier = extra_data;
400 incl->next_incl = NULL;
403 merge = MERGE_AUGMENT;
405 merge = MERGE_OVERRIDE;
416 log_err(ctx, "Illegal include statement \"%s\"; Ignored\n", stmt);
423 * All latin-1 alphanumerics, plus parens, slash, minus, underscore and
426 static const unsigned char componentSpecLegal[] = {
427 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7, 0xff, 0x83,
428 0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x07,
429 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
430 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f, 0xff
434 EnsureSafeMapName(char *name)
439 while (*name != '\0') {
440 if ((componentSpecLegal[(*name) / 8] & (1 << ((*name) % 8))) == 0)
447 XkbFileCreate(struct xkb_context *ctx, enum xkb_file_type type, char *name,
448 ParseCommon *defs, unsigned flags)
452 file = calloc(1, sizeof(*file));
456 EnsureSafeMapName(name);
457 file->file_type = type;
458 file->topName = strdup_safe(name);
461 file->id = xkb_context_take_file_id(ctx);
467 XkbFileFromComponents(struct xkb_context *ctx,
468 struct xkb_component_names *kkctgs)
471 XkbFile *keycodes, *types, *compat, *symbols;
473 inc = IncludeCreate(ctx, kkctgs->keycodes, MERGE_DEFAULT);
474 keycodes = XkbFileCreate(ctx, FILE_TYPE_KEYCODES, NULL,
475 (ParseCommon *) inc, 0);
477 inc = IncludeCreate(ctx, kkctgs->types, MERGE_DEFAULT);
478 types = XkbFileCreate(ctx, FILE_TYPE_TYPES, NULL,
479 (ParseCommon *) inc, 0);
480 AppendStmt(&keycodes->common, &types->common);
482 inc = IncludeCreate(ctx, kkctgs->compat, MERGE_DEFAULT);
483 compat = XkbFileCreate(ctx, FILE_TYPE_COMPAT, NULL,
484 (ParseCommon *) inc, 0);
485 AppendStmt(&keycodes->common, &compat->common);
487 inc = IncludeCreate(ctx, kkctgs->symbols, MERGE_DEFAULT);
488 symbols = XkbFileCreate(ctx, FILE_TYPE_SYMBOLS, NULL,
489 (ParseCommon *) inc, 0);
490 AppendStmt(&keycodes->common, &symbols->common);
492 return XkbFileCreate(ctx, FILE_TYPE_KEYMAP, NULL,
493 &keycodes->common, 0);
497 FreeExpr(ExprDef *expr)
505 case EXPR_ACTION_LIST:
507 case EXPR_UNARY_PLUS:
510 FreeStmt(&expr->value.child->common);
518 FreeStmt(&expr->value.binary.left->common);
519 FreeStmt(&expr->value.binary.right->common);
522 case EXPR_ACTION_DECL:
523 FreeStmt(&expr->value.action.args->common);
527 FreeStmt(&expr->value.array.entry->common);
530 case EXPR_KEYSYM_LIST:
531 darray_foreach(sym, expr->value.list.syms)
533 darray_free(expr->value.list.syms);
534 darray_free(expr->value.list.symsMapIndex);
535 darray_free(expr->value.list.symsNumEntries);
544 FreeInclude(IncludeStmt *incl)
550 next = incl->next_incl;
554 free(incl->modifier);
563 FreeStmt(ParseCommon *stmt)
573 switch (stmt->type) {
575 FreeInclude((IncludeStmt *) stmt);
576 /* stmt is already free'd here. */
583 FreeStmt(&u.var->name->common);
584 FreeStmt(&u.var->value->common);
587 FreeStmt(&u.keyType->body->common);
591 FreeStmt(&u.interp->match->common);
592 FreeStmt(&u.interp->def->common);
595 FreeStmt(&u.vmod->value->common);
598 FreeStmt(&u.syms->symbols->common);
601 FreeStmt(&u.modMask->keys->common);
603 case STMT_GROUP_COMPAT:
604 FreeStmt(&u.groupCompat->def->common);
606 case STMT_INDICATOR_MAP:
607 FreeStmt(&u.ledMap->body->common);
609 case STMT_INDICATOR_NAME:
610 FreeStmt(&u.ledName->name->common);
622 FreeXkbFile(XkbFile *file)
628 next = (XkbFile *) file->common.next;
630 switch (file->file_type) {
631 case FILE_TYPE_KEYMAP:
632 FreeXkbFile((XkbFile *) file->defs);
635 case FILE_TYPE_TYPES:
636 case FILE_TYPE_COMPAT:
637 case FILE_TYPE_SYMBOLS:
638 case FILE_TYPE_KEYCODES:
639 case FILE_TYPE_GEOMETRY:
640 FreeStmt(file->defs);
654 static const char *xkb_file_type_strings[_FILE_TYPE_NUM_ENTRIES] = {
655 [FILE_TYPE_KEYCODES] = "xkb_keycodes",
656 [FILE_TYPE_TYPES] = "xkb_types",
657 [FILE_TYPE_COMPAT] = "xkb_compatibility",
658 [FILE_TYPE_SYMBOLS] = "xkb_symbols",
659 [FILE_TYPE_KEYMAP] = "xkb_keymap",
660 [FILE_TYPE_RULES] = "rules",
664 xkb_file_type_to_string(enum xkb_file_type type)
666 if (type > _FILE_TYPE_NUM_ENTRIES)
668 return xkb_file_type_strings[type];
671 static const char *stmt_type_strings[_STMT_NUM_VALUES] = {
672 [STMT_UNKNOWN] = "unknown statement",
673 [STMT_INCLUDE] = "include statement",
674 [STMT_KEYCODE] = "key name definition",
675 [STMT_ALIAS] = "key alias definition",
676 [STMT_EXPR] = "expression",
677 [STMT_VAR] = "variable definition",
678 [STMT_TYPE] = "key type definition",
679 [STMT_INTERP] = "symbol interpretation definition",
680 [STMT_VMOD] = "virtual modifiers definition",
681 [STMT_SYMBOLS] = "key symbols definition",
682 [STMT_MODMAP] = "modifier map declaration",
683 [STMT_GROUP_COMPAT] = "group declaration",
684 [STMT_INDICATOR_MAP] = "indicator map declaration",
685 [STMT_INDICATOR_NAME] = "indicator name declaration",
689 stmt_type_to_string(enum stmt_type type)
691 if (type >= _STMT_NUM_VALUES)
693 return stmt_type_strings[type];
696 static const char *expr_op_type_strings[_EXPR_NUM_VALUES] = {
697 [EXPR_VALUE] = "literal",
698 [EXPR_IDENT] = "identifier",
699 [EXPR_ACTION_DECL] = "action declaration",
700 [EXPR_FIELD_REF] = "field reference",
701 [EXPR_ARRAY_REF] = "array reference",
702 [EXPR_KEYSYM_LIST] = "list of keysyms",
703 [EXPR_ACTION_LIST] = "list of actions",
704 [EXPR_ADD] = "addition",
705 [EXPR_SUBTRACT] = "subtraction",
706 [EXPR_MULTIPLY] = "multiplication",
707 [EXPR_DIVIDE] = "division",
708 [EXPR_ASSIGN] = "assignment",
709 [EXPR_NOT] = "logical negation",
710 [EXPR_NEGATE] = "arithmetic negation",
711 [EXPR_INVERT] = "bitwise inversion",
712 [EXPR_UNARY_PLUS] = "unary plus",
716 expr_op_type_to_string(enum expr_op_type type)
718 if (type >= _EXPR_NUM_VALUES)
720 return expr_op_type_strings[type];
723 static const char *expr_value_type_strings[_EXPR_TYPE_NUM_VALUES] = {
724 [EXPR_TYPE_UNKNOWN] = "unknown",
725 [EXPR_TYPE_BOOLEAN] = "boolean",
726 [EXPR_TYPE_INT] = "int",
727 [EXPR_TYPE_STRING] = "string",
728 [EXPR_TYPE_ACTION] = "action",
729 [EXPR_TYPE_KEYNAME] = "keyname",
730 [EXPR_TYPE_SYMBOLS] = "symbols",
734 expr_value_type_to_string(enum expr_value_type type)
736 if (type >= _EXPR_TYPE_NUM_VALUES)
738 return expr_value_type_strings[type];