diff options
Diffstat (limited to 'src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c')
-rw-r--r-- | src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c | 792 |
1 files changed, 0 insertions, 792 deletions
diff --git a/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c b/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c deleted file mode 100644 index 11bc0912d1..0000000000 --- a/src/3rdparty/xkbcommon/src/xkbcomp/ast-build.c +++ /dev/null @@ -1,792 +0,0 @@ -/************************************************************ - * Copyright (c) 1994 by Silicon Graphics Computer Systems, Inc. - * - * Permission to use, copy, modify, and distribute this - * software and its documentation for any purpose and without - * fee is hereby granted, provided that the above copyright - * notice appear in all copies and that both that copyright - * notice and this permission notice appear in supporting - * documentation, and that the name of Silicon Graphics not be - * used in advertising or publicity pertaining to distribution - * of the software without specific prior written permission. - * Silicon Graphics makes no representation about the suitability - * of this software for any purpose. It is provided "as is" - * without any express or implied warranty. - * - * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS - * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON - * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL - * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, - * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE - * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH - * THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - ********************************************************/ - -/* - * Copyright © 2012 Intel Corporation - * Copyright © 2012 Ran Benita <ran234@gmail.com> - * - * Permission is hereby granted, free of charge, to any person obtaining a - * copy of this software and associated documentation files (the "Software"), - * to deal in the Software without restriction, including without limitation - * the rights to use, copy, modify, merge, publish, distribute, sublicense, - * and/or sell copies of the Software, and to permit persons to whom the - * Software is furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice (including the next - * paragraph) shall be included in all copies or substantial portions of the - * Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING - * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER - * DEALINGS IN THE SOFTWARE. - * - * Author: Daniel Stone <daniel@fooishbar.org> - * Ran Benita <ran234@gmail.com> - */ - -#include "xkbcomp-priv.h" -#include "ast-build.h" -#include "include.h" - -ParseCommon * -AppendStmt(ParseCommon *to, ParseCommon *append) -{ - ParseCommon *iter; - - if (!to) - return append; - - for (iter = to; iter->next; iter = iter->next); - - iter->next = append; - return to; -} - -static ExprDef * -ExprCreate(enum expr_op_type op, enum expr_value_type type, size_t size) -{ - ExprDef *expr = malloc(size); - if (!expr) - return NULL; - - expr->common.type = STMT_EXPR; - expr->common.next = NULL; - expr->expr.op = op; - expr->expr.value_type = type; - - return expr; -} - -#define EXPR_CREATE(type_, name_, op_, value_type_) \ - ExprDef *name_ = ExprCreate(op_, value_type_, sizeof(type_)); \ - if (!name_) \ - return NULL; - -ExprDef * -ExprCreateString(xkb_atom_t str) -{ - EXPR_CREATE(ExprString, expr, EXPR_VALUE, EXPR_TYPE_STRING); - expr->string.str = str; - return expr; -} - -ExprDef * -ExprCreateInteger(int ival) -{ - EXPR_CREATE(ExprInteger, expr, EXPR_VALUE, EXPR_TYPE_INT); - expr->integer.ival = ival; - return expr; -} - -ExprDef * -ExprCreateBoolean(bool set) -{ - EXPR_CREATE(ExprBoolean, expr, EXPR_VALUE, EXPR_TYPE_BOOLEAN); - expr->boolean.set = set; - return expr; -} - -ExprDef * -ExprCreateKeyName(xkb_atom_t key_name) -{ - EXPR_CREATE(ExprKeyName, expr, EXPR_VALUE, EXPR_TYPE_KEYNAME); - expr->key_name.key_name = key_name; - return expr; -} - -ExprDef * -ExprCreateIdent(xkb_atom_t ident) -{ - EXPR_CREATE(ExprIdent, expr, EXPR_IDENT, EXPR_TYPE_UNKNOWN); - expr->ident.ident = ident; - return expr; -} - -ExprDef * -ExprCreateUnary(enum expr_op_type op, enum expr_value_type type, - ExprDef *child) -{ - EXPR_CREATE(ExprUnary, expr, op, type); - expr->unary.child = child; - return expr; -} - -ExprDef * -ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right) -{ - EXPR_CREATE(ExprBinary, expr, op, EXPR_TYPE_UNKNOWN); - - if (op == EXPR_ASSIGN || left->expr.value_type == EXPR_TYPE_UNKNOWN) - expr->expr.value_type = right->expr.value_type; - else if (left->expr.value_type == right->expr.value_type || - right->expr.value_type == EXPR_TYPE_UNKNOWN) - expr->expr.value_type = left->expr.value_type; - expr->binary.left = left; - expr->binary.right = right; - - return expr; -} - -ExprDef * -ExprCreateFieldRef(xkb_atom_t element, xkb_atom_t field) -{ - EXPR_CREATE(ExprFieldRef, expr, EXPR_FIELD_REF, EXPR_TYPE_UNKNOWN); - expr->field_ref.element = element; - expr->field_ref.field = field; - return expr; -} - -ExprDef * -ExprCreateArrayRef(xkb_atom_t element, xkb_atom_t field, ExprDef *entry) -{ - EXPR_CREATE(ExprArrayRef, expr, EXPR_ARRAY_REF, EXPR_TYPE_UNKNOWN); - expr->array_ref.element = element; - expr->array_ref.field = field; - expr->array_ref.entry = entry; - return expr; -} - -ExprDef * -ExprCreateAction(xkb_atom_t name, ExprDef *args) -{ - EXPR_CREATE(ExprAction, expr, EXPR_ACTION_DECL, EXPR_TYPE_UNKNOWN); - expr->action.name = name; - expr->action.args = args; - return expr; -} - -ExprDef * -ExprCreateKeysymList(xkb_keysym_t sym) -{ - EXPR_CREATE(ExprKeysymList, expr, EXPR_KEYSYM_LIST, EXPR_TYPE_SYMBOLS); - - darray_init(expr->keysym_list.syms); - darray_init(expr->keysym_list.symsMapIndex); - darray_init(expr->keysym_list.symsNumEntries); - - darray_append(expr->keysym_list.syms, sym); - darray_append(expr->keysym_list.symsMapIndex, 0); - darray_append(expr->keysym_list.symsNumEntries, 1); - - return expr; -} - -ExprDef * -ExprCreateMultiKeysymList(ExprDef *expr) -{ - unsigned nLevels = darray_size(expr->keysym_list.symsMapIndex); - - darray_resize(expr->keysym_list.symsMapIndex, 1); - darray_resize(expr->keysym_list.symsNumEntries, 1); - darray_item(expr->keysym_list.symsMapIndex, 0) = 0; - darray_item(expr->keysym_list.symsNumEntries, 0) = nLevels; - - return expr; -} - -ExprDef * -ExprAppendKeysymList(ExprDef *expr, xkb_keysym_t sym) -{ - unsigned nSyms = darray_size(expr->keysym_list.syms); - - darray_append(expr->keysym_list.symsMapIndex, nSyms); - darray_append(expr->keysym_list.symsNumEntries, 1); - darray_append(expr->keysym_list.syms, sym); - - return expr; -} - -ExprDef * -ExprAppendMultiKeysymList(ExprDef *expr, ExprDef *append) -{ - unsigned nSyms = darray_size(expr->keysym_list.syms); - unsigned numEntries = darray_size(append->keysym_list.syms); - - darray_append(expr->keysym_list.symsMapIndex, nSyms); - darray_append(expr->keysym_list.symsNumEntries, numEntries); - darray_append_items(expr->keysym_list.syms, - darray_mem(append->keysym_list.syms, 0), numEntries); - - darray_resize(append->keysym_list.syms, 0); - FreeStmt(&append->common); - - return expr; -} - -KeycodeDef * -KeycodeCreate(xkb_atom_t name, int64_t value) -{ - KeycodeDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_KEYCODE; - def->common.next = NULL; - def->name = name; - def->value = value; - - return def; -} - -KeyAliasDef * -KeyAliasCreate(xkb_atom_t alias, xkb_atom_t real) -{ - KeyAliasDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_ALIAS; - def->common.next = NULL; - def->alias = alias; - def->real = real; - - return def; -} - -VModDef * -VModCreate(xkb_atom_t name, ExprDef *value) -{ - VModDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_VMOD; - def->common.next = NULL; - def->name = name; - def->value = value; - - return def; -} - -VarDef * -VarCreate(ExprDef *name, ExprDef *value) -{ - VarDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_VAR; - def->common.next = NULL; - def->name = name; - def->value = value; - - return def; -} - -VarDef * -BoolVarCreate(xkb_atom_t ident, bool set) -{ - return VarCreate((ExprDef *) ExprCreateIdent(ident), - (ExprDef *) ExprCreateBoolean(set)); -} - -InterpDef * -InterpCreate(xkb_keysym_t sym, ExprDef *match) -{ - InterpDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_INTERP; - def->common.next = NULL; - def->sym = sym; - def->match = match; - - return def; -} - -KeyTypeDef * -KeyTypeCreate(xkb_atom_t name, VarDef *body) -{ - KeyTypeDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_TYPE; - def->common.next = NULL; - def->merge = MERGE_DEFAULT; - def->name = name; - def->body = body; - - return def; -} - -SymbolsDef * -SymbolsCreate(xkb_atom_t keyName, VarDef *symbols) -{ - SymbolsDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_SYMBOLS; - def->common.next = NULL; - def->merge = MERGE_DEFAULT; - def->keyName = keyName; - def->symbols = symbols; - - return def; -} - -GroupCompatDef * -GroupCompatCreate(unsigned group, ExprDef *val) -{ - GroupCompatDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_GROUP_COMPAT; - def->common.next = NULL; - def->merge = MERGE_DEFAULT; - def->group = group; - def->def = val; - - return def; -} - -ModMapDef * -ModMapCreate(xkb_atom_t modifier, ExprDef *keys) -{ - ModMapDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_MODMAP; - def->common.next = NULL; - def->merge = MERGE_DEFAULT; - def->modifier = modifier; - def->keys = keys; - - return def; -} - -LedMapDef * -LedMapCreate(xkb_atom_t name, VarDef *body) -{ - LedMapDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_LED_MAP; - def->common.next = NULL; - def->merge = MERGE_DEFAULT; - def->name = name; - def->body = body; - - return def; -} - -LedNameDef * -LedNameCreate(unsigned ndx, ExprDef *name, bool virtual) -{ - LedNameDef *def = malloc(sizeof(*def)); - if (!def) - return NULL; - - def->common.type = STMT_LED_NAME; - def->common.next = NULL; - def->merge = MERGE_DEFAULT; - def->ndx = ndx; - def->name = name; - def->virtual = virtual; - - return def; -} - -static void -FreeInclude(IncludeStmt *incl); - -IncludeStmt * -IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge) -{ - IncludeStmt *incl, *first; - char *file, *map, *stmt, *tmp, *extra_data; - char nextop; - - incl = first = NULL; - file = map = NULL; - tmp = str; - stmt = strdup_safe(str); - while (tmp && *tmp) - { - if (!ParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data)) - goto err; - - /* - * Given an RMLVO (here layout) like 'us,,fr', the rules parser - * will give out something like 'pc+us+:2+fr:3+inet(evdev)'. - * We should just skip the ':2' in this case and leave it to the - * appropriate section to deal with the empty group. - */ - if (isempty(file)) { - free(file); - free(map); - free(extra_data); - continue; - } - - if (first == NULL) { - first = incl = malloc(sizeof(*first)); - } else { - incl->next_incl = malloc(sizeof(*first)); - incl = incl->next_incl; - } - - if (!incl) { - log_wsgo(ctx, - "Allocation failure in IncludeCreate; " - "Using only part of the include\n"); - break; - } - - incl->common.type = STMT_INCLUDE; - incl->common.next = NULL; - incl->merge = merge; - incl->stmt = NULL; - incl->file = file; - incl->map = map; - incl->modifier = extra_data; - incl->next_incl = NULL; - - if (nextop == '|') - merge = MERGE_AUGMENT; - else - merge = MERGE_OVERRIDE; - } - - if (first) - first->stmt = stmt; - else - free(stmt); - - return first; - -err: - log_err(ctx, "Illegal include statement \"%s\"; Ignored\n", stmt); - FreeInclude(first); - free(stmt); - return NULL; -} - -XkbFile * -XkbFileCreate(enum xkb_file_type type, char *name, ParseCommon *defs, - enum xkb_map_flags flags) -{ - XkbFile *file; - - file = calloc(1, sizeof(*file)); - if (!file) - return NULL; - - XkbEscapeMapName(name); - file->file_type = type; - file->topName = strdup_safe(name); - file->name = name; - file->defs = defs; - file->flags = flags; - - return file; -} - -XkbFile * -XkbFileFromComponents(struct xkb_context *ctx, - const struct xkb_component_names *kkctgs) -{ - char *const components[] = { - kkctgs->keycodes, kkctgs->types, - kkctgs->compat, kkctgs->symbols, - }; - enum xkb_file_type type; - IncludeStmt *include = NULL; - XkbFile *file = NULL; - ParseCommon *defs = NULL; - - for (type = FIRST_KEYMAP_FILE_TYPE; type <= LAST_KEYMAP_FILE_TYPE; type++) { - include = IncludeCreate(ctx, components[type], MERGE_DEFAULT); - if (!include) - goto err; - - file = XkbFileCreate(type, NULL, (ParseCommon *) include, 0); - if (!file) { - FreeInclude(include); - goto err; - } - - defs = AppendStmt(defs, &file->common); - } - - file = XkbFileCreate(FILE_TYPE_KEYMAP, NULL, defs, 0); - if (!file) - goto err; - - return file; - -err: - FreeXkbFile((XkbFile *) defs); - return NULL; -} - -static void -FreeExpr(ExprDef *expr) -{ - if (!expr) - return; - - switch (expr->expr.op) { - case EXPR_ACTION_LIST: - case EXPR_NEGATE: - case EXPR_UNARY_PLUS: - case EXPR_NOT: - case EXPR_INVERT: - FreeStmt((ParseCommon *) expr->unary.child); - break; - - case EXPR_DIVIDE: - case EXPR_ADD: - case EXPR_SUBTRACT: - case EXPR_MULTIPLY: - case EXPR_ASSIGN: - FreeStmt((ParseCommon *) expr->binary.left); - FreeStmt((ParseCommon *) expr->binary.right); - break; - - case EXPR_ACTION_DECL: - FreeStmt((ParseCommon *) expr->action.args); - break; - - case EXPR_ARRAY_REF: - FreeStmt((ParseCommon *) expr->array_ref.entry); - break; - - case EXPR_KEYSYM_LIST: - darray_free(expr->keysym_list.syms); - darray_free(expr->keysym_list.symsMapIndex); - darray_free(expr->keysym_list.symsNumEntries); - break; - - default: - break; - } -} - -static void -FreeInclude(IncludeStmt *incl) -{ - IncludeStmt *next; - - while (incl) - { - next = incl->next_incl; - - free(incl->file); - free(incl->map); - free(incl->modifier); - free(incl->stmt); - - free(incl); - incl = next; - } -} - -void -FreeStmt(ParseCommon *stmt) -{ - ParseCommon *next; - - while (stmt) - { - next = stmt->next; - - switch (stmt->type) { - case STMT_INCLUDE: - FreeInclude((IncludeStmt *) stmt); - /* stmt is already free'd here. */ - stmt = NULL; - break; - case STMT_EXPR: - FreeExpr((ExprDef *) stmt); - break; - case STMT_VAR: - FreeStmt((ParseCommon *) ((VarDef *) stmt)->name); - FreeStmt((ParseCommon *) ((VarDef *) stmt)->value); - break; - case STMT_TYPE: - FreeStmt((ParseCommon *) ((KeyTypeDef *) stmt)->body); - break; - case STMT_INTERP: - FreeStmt((ParseCommon *) ((InterpDef *) stmt)->match); - FreeStmt((ParseCommon *) ((InterpDef *) stmt)->def); - break; - case STMT_VMOD: - FreeStmt((ParseCommon *) ((VModDef *) stmt)->value); - break; - case STMT_SYMBOLS: - FreeStmt((ParseCommon *) ((SymbolsDef *) stmt)->symbols); - break; - case STMT_MODMAP: - FreeStmt((ParseCommon *) ((ModMapDef *) stmt)->keys); - break; - case STMT_GROUP_COMPAT: - FreeStmt((ParseCommon *) ((GroupCompatDef *) stmt)->def); - break; - case STMT_LED_MAP: - FreeStmt((ParseCommon *) ((LedMapDef *) stmt)->body); - break; - case STMT_LED_NAME: - FreeStmt((ParseCommon *) ((LedNameDef *) stmt)->name); - break; - default: - break; - } - - free(stmt); - stmt = next; - } -} - -void -FreeXkbFile(XkbFile *file) -{ - XkbFile *next; - - while (file) - { - next = (XkbFile *) file->common.next; - - switch (file->file_type) { - case FILE_TYPE_KEYMAP: - FreeXkbFile((XkbFile *) file->defs); - break; - - case FILE_TYPE_TYPES: - case FILE_TYPE_COMPAT: - case FILE_TYPE_SYMBOLS: - case FILE_TYPE_KEYCODES: - case FILE_TYPE_GEOMETRY: - FreeStmt(file->defs); - break; - - default: - break; - } - - free(file->name); - free(file->topName); - free(file); - file = next; - } -} - -static const char *xkb_file_type_strings[_FILE_TYPE_NUM_ENTRIES] = { - [FILE_TYPE_KEYCODES] = "xkb_keycodes", - [FILE_TYPE_TYPES] = "xkb_types", - [FILE_TYPE_COMPAT] = "xkb_compatibility", - [FILE_TYPE_SYMBOLS] = "xkb_symbols", - [FILE_TYPE_GEOMETRY] = "xkb_geometry", - [FILE_TYPE_KEYMAP] = "xkb_keymap", - [FILE_TYPE_RULES] = "rules", -}; - -const char * -xkb_file_type_to_string(enum xkb_file_type type) -{ - if (type > _FILE_TYPE_NUM_ENTRIES) - return "unknown"; - return xkb_file_type_strings[type]; -} - -static const char *stmt_type_strings[_STMT_NUM_VALUES] = { - [STMT_UNKNOWN] = "unknown statement", - [STMT_INCLUDE] = "include statement", - [STMT_KEYCODE] = "key name definition", - [STMT_ALIAS] = "key alias definition", - [STMT_EXPR] = "expression", - [STMT_VAR] = "variable definition", - [STMT_TYPE] = "key type definition", - [STMT_INTERP] = "symbol interpretation definition", - [STMT_VMOD] = "virtual modifiers definition", - [STMT_SYMBOLS] = "key symbols definition", - [STMT_MODMAP] = "modifier map declaration", - [STMT_GROUP_COMPAT] = "group declaration", - [STMT_LED_MAP] = "indicator map declaration", - [STMT_LED_NAME] = "indicator name declaration", -}; - -const char * -stmt_type_to_string(enum stmt_type type) -{ - if (type >= _STMT_NUM_VALUES) - return NULL; - return stmt_type_strings[type]; -} - -static const char *expr_op_type_strings[_EXPR_NUM_VALUES] = { - [EXPR_VALUE] = "literal", - [EXPR_IDENT] = "identifier", - [EXPR_ACTION_DECL] = "action declaration", - [EXPR_FIELD_REF] = "field reference", - [EXPR_ARRAY_REF] = "array reference", - [EXPR_KEYSYM_LIST] = "list of keysyms", - [EXPR_ACTION_LIST] = "list of actions", - [EXPR_ADD] = "addition", - [EXPR_SUBTRACT] = "subtraction", - [EXPR_MULTIPLY] = "multiplication", - [EXPR_DIVIDE] = "division", - [EXPR_ASSIGN] = "assignment", - [EXPR_NOT] = "logical negation", - [EXPR_NEGATE] = "arithmetic negation", - [EXPR_INVERT] = "bitwise inversion", - [EXPR_UNARY_PLUS] = "unary plus", -}; - -const char * -expr_op_type_to_string(enum expr_op_type type) -{ - if (type >= _EXPR_NUM_VALUES) - return NULL; - return expr_op_type_strings[type]; -} - -static const char *expr_value_type_strings[_EXPR_TYPE_NUM_VALUES] = { - [EXPR_TYPE_UNKNOWN] = "unknown", - [EXPR_TYPE_BOOLEAN] = "boolean", - [EXPR_TYPE_INT] = "int", - [EXPR_TYPE_STRING] = "string", - [EXPR_TYPE_ACTION] = "action", - [EXPR_TYPE_KEYNAME] = "keyname", - [EXPR_TYPE_SYMBOLS] = "symbols", -}; - -const char * -expr_value_type_to_string(enum expr_value_type type) -{ - if (type >= _EXPR_TYPE_NUM_VALUES) - return NULL; - return expr_value_type_strings[type]; -} |