libxkbcommon_la_SOURCES = \
src/xkbcomp/action.c \
src/xkbcomp/action.h \
+ src/xkbcomp/ast.h \
+ src/xkbcomp/ast-build.c \
+ src/xkbcomp/ast-build.h \
src/xkbcomp/compat.c \
src/xkbcomp/expr.c \
src/xkbcomp/expr.h \
+ src/xkbcomp/include.c \
+ src/xkbcomp/include.h \
src/xkbcomp/keycodes.c \
- src/xkbcomp/keytypes.c \
+ src/xkbcomp/keycodes.h \
src/xkbcomp/parser.y \
- src/xkbcomp/parseutils.c \
- src/xkbcomp/parseutils.h \
- src/xkbcomp/path.c \
- src/xkbcomp/path.h \
+ src/xkbcomp/parser-priv.h \
src/xkbcomp/rules.c \
src/xkbcomp/rules.h \
src/xkbcomp/scanner.l \
src/xkbcomp/symbols.c \
+ src/xkbcomp/types.c \
src/xkbcomp/vmod.c \
src/xkbcomp/vmod.h \
src/xkbcomp/xkbcomp.c \
- src/xkbcomp/xkbcomp.h \
src/xkbcomp/xkbcomp-priv.h \
src/atom.c \
src/atom.h \
#include "xkb-priv.h"
#include "text.h"
+struct xkb_keymap *
+xkb_map_new(struct xkb_context *ctx)
+{
+ struct xkb_keymap *keymap;
+
+ keymap = calloc(1, sizeof(*keymap));
+ if (!keymap)
+ return NULL;
+
+ keymap->refcnt = 1;
+ keymap->ctx = xkb_context_ref(ctx);
+
+ return keymap;
+}
+
+XKB_EXPORT struct xkb_keymap *
+xkb_map_ref(struct xkb_keymap *keymap)
+{
+ keymap->refcnt++;
+ return keymap;
+}
+
+XKB_EXPORT void
+xkb_map_unref(struct xkb_keymap *keymap)
+{
+ unsigned int i;
+ struct xkb_key *key;
+
+ if (!keymap || --keymap->refcnt > 0)
+ return;
+
+ for (i = 0; i < keymap->num_types; i++) {
+ free(keymap->types[i].map);
+ free(keymap->types[i].level_names);
+ }
+ free(keymap->types);
+ darray_foreach(key, keymap->keys) {
+ free(key->sym_index);
+ free(key->num_syms);
+ darray_free(key->syms);
+ free(key->actions);
+ }
+ darray_free(keymap->keys);
+ darray_free(keymap->sym_interpret);
+ darray_free(keymap->key_aliases);
+ free(keymap->keycodes_section_name);
+ free(keymap->symbols_section_name);
+ free(keymap->types_section_name);
+ free(keymap->compat_section_name);
+ xkb_context_unref(keymap->ctx);
+ free(keymap);
+}
+
/**
* Returns the total number of modifiers active in the keymap.
*/
return kc >= keymap->min_key_code && kc <= keymap->max_key_code;
}
+struct xkb_keymap *
+xkb_map_new(struct xkb_context *ctx);
+
xkb_atom_t
xkb_atom_intern(struct xkb_context *ctx, const char *string);
*
********************************************************/
+#include "xkbcomp-priv.h"
+#include "text.h"
+#include "expr.h"
#include "action.h"
+#include "keycodes.h"
static const ExprDef constTrue = {
.common = { .type = STMT_EXPR, .next = NULL },
*
********************************************************/
-#ifndef ACTION_H
-#define ACTION_H 1
-
-#include "xkbcomp-priv.h"
-#include "expr.h"
+#ifndef XKBCOMP_ACTION_H
+#define XKBCOMP_ACTION_H
#define F_ClearLocks 0
#define F_LatchToLock 1
struct _ActionInfo *next;
} ActionInfo;
-extern int
+int
HandleActionDef(ExprDef *def, struct xkb_keymap *keymap,
- union xkb_action *action,
- ActionInfo *info);
+ union xkb_action *action, ActionInfo *info);
-extern int
+int
SetActionField(struct xkb_keymap *keymap, const char *elem, const char *field,
- ExprDef *index, ExprDef *value,
- ActionInfo **info_rtrn);
+ ExprDef *index, ExprDef *value, ActionInfo **info_rtrn);
extern const LookupEntry ctrlNames[];
-#endif /* ACTION_H */
+#endif
*
********************************************************/
-#include "parseutils.h"
-#include "path.h"
+#include "xkbcomp-priv.h"
+#include "ast-build.h"
+#include "parser-priv.h"
+#include "include.h"
ATTR_MALLOC static void *
malloc_or_die(size_t size)
return list;
}
-bool
-LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
-{
- xkb_keysym_t sym;
-
- if (!str || istreq(str, "any") || istreq(str, "nosymbol")) {
- *sym_rtrn = XKB_KEY_NoSymbol;
- return 1;
- }
-
- if (istreq(str, "none") || istreq(str, "voidsymbol")) {
- *sym_rtrn = XKB_KEY_VoidSymbol;
- return 1;
- }
-
- sym = xkb_keysym_from_name(str);
- if (sym != XKB_KEY_NoSymbol) {
- *sym_rtrn = sym;
- return 1;
- }
-
- return 0;
-}
-
static void
FreeInclude(IncludeStmt *incl);
stmt = strdup_safe(str);
while (tmp && *tmp)
{
- if (!XkbParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
+ if (!ParseIncludeMap(&tmp, &file, &map, &nextop, &extra_data))
goto err;
if (first == NULL) {
return NULL;
}
-void
-CheckDefaultMap(struct xkb_context *ctx, XkbFile *maps, const char *fileName)
-{
- XkbFile *dflt = NULL, *tmp;
-
- for (tmp = maps; tmp; tmp = (XkbFile *) tmp->common.next) {
- if (!(tmp->flags & XkbLC_Default))
- continue;
- if (!dflt) {
- dflt = tmp;
- continue;
- }
-
- log_lvl(ctx, 3,
- "Multiple default components in %s; "
- "Using %s, ignoring %s\n",
- (fileName ? fileName : "(unknown)"),
- (dflt->name ? dflt->name : "(first)"),
- (tmp->name ? tmp->name : "(subsequent)"));
-
- tmp->flags &= (~XkbLC_Default);
- }
-}
-
/*
* All latin-1 alphanumerics, plus parens, slash, minus, underscore and
* wildcards.
}
XkbFile *
-CreateXKBFile(struct xkb_context *ctx, enum xkb_file_type type, char *name,
+XkbFileCreate(struct xkb_context *ctx, enum xkb_file_type type, char *name,
ParseCommon *defs, unsigned flags)
{
XkbFile *file;
return file;
}
+XkbFile *
+XkbFileFromComponents(struct xkb_context *ctx,
+ struct xkb_component_names *kkctgs)
+{
+ IncludeStmt *inc;
+ XkbFile *keycodes, *types, *compat, *symbols;
+
+ inc = IncludeCreate(ctx, kkctgs->keycodes, MERGE_DEFAULT);
+ keycodes = XkbFileCreate(ctx, FILE_TYPE_KEYCODES, NULL,
+ (ParseCommon *) inc, 0);
+
+ inc = IncludeCreate(ctx, kkctgs->types, MERGE_DEFAULT);
+ types = XkbFileCreate(ctx, FILE_TYPE_TYPES, NULL,
+ (ParseCommon *) inc, 0);
+ AppendStmt(&keycodes->common, &types->common);
+
+ inc = IncludeCreate(ctx, kkctgs->compat, MERGE_DEFAULT);
+ compat = XkbFileCreate(ctx, FILE_TYPE_COMPAT, NULL,
+ (ParseCommon *) inc, 0);
+ AppendStmt(&keycodes->common, &compat->common);
+
+ inc = IncludeCreate(ctx, kkctgs->symbols, MERGE_DEFAULT);
+ symbols = XkbFileCreate(ctx, FILE_TYPE_SYMBOLS, NULL,
+ (ParseCommon *) inc, 0);
+ AppendStmt(&keycodes->common, &symbols->common);
+
+ return XkbFileCreate(ctx, FILE_TYPE_KEYMAP, strdup(""),
+ &keycodes->common, 0);
+}
+
static void
FreeExpr(ExprDef *expr)
{
}
void
-FreeXKBFile(XkbFile *file)
+FreeXkbFile(XkbFile *file)
{
XkbFile *next;
switch (file->file_type) {
case FILE_TYPE_KEYMAP:
- FreeXKBFile((XkbFile *) file->defs);
+ FreeXkbFile((XkbFile *) file->defs);
break;
case FILE_TYPE_TYPES:
*
********************************************************/
-#ifndef PARSEUTILS_H
-#define PARSEUTILS_H
+#ifndef XKBCOMP_AST_BUILD_H
+#define XKBCOMP_AST_BUILD_H
-#include <stdio.h>
-
-#include "xkbcomp-priv.h"
-
-struct parser_param {
- struct xkb_context *ctx;
- void *scanner;
- XkbFile *rtrn;
-};
-
-#include "parser.h"
-
-struct scanner_extra {
- struct xkb_context *ctx;
- char *scanFile;
- char scanBuf[1024];
- char *s;
-};
-
-extern ParseCommon *
+ParseCommon *
AppendStmt(ParseCommon *to, ParseCommon *append);
-extern ExprDef *
+ExprDef *
ExprCreate(enum expr_op_type op, enum expr_value_type type);
-extern ExprDef *
+ExprDef *
ExprCreateUnary(enum expr_op_type op, enum expr_value_type type,
ExprDef *child);
-extern ExprDef *
+ExprDef *
ExprCreateBinary(enum expr_op_type op, ExprDef *left, ExprDef *right);
KeycodeDef *
KeycodeCreate(char keyName[XkbKeyNameLength], unsigned long value);
-extern KeyAliasDef *
+KeyAliasDef *
KeyAliasCreate(char keyName[XkbKeyNameLength], char real[XkbKeyNameLength]);
-extern VModDef *
+VModDef *
VModCreate(xkb_atom_t name, ExprDef *value);
-extern VarDef *
+VarDef *
VarCreate(ExprDef *name, ExprDef *value);
-extern VarDef *
+VarDef *
BoolVarCreate(xkb_atom_t nameToken, unsigned set);
-extern InterpDef *
+InterpDef *
InterpCreate(char *sym, ExprDef *match);
-extern KeyTypeDef *
+KeyTypeDef *
KeyTypeCreate(xkb_atom_t name, VarDef *body);
-extern SymbolsDef *
+SymbolsDef *
SymbolsCreate(char keyName[XkbKeyNameLength], ExprDef *symbols);
-extern GroupCompatDef *
+GroupCompatDef *
GroupCompatCreate(int group, ExprDef *def);
-extern ModMapDef *
+ModMapDef *
ModMapCreate(uint32_t modifier, ExprDef *keys);
-extern IndicatorMapDef *
+IndicatorMapDef *
IndicatorMapCreate(xkb_atom_t name, VarDef *body);
-extern IndicatorNameDef *
+IndicatorNameDef *
IndicatorNameCreate(int ndx, ExprDef *name, bool virtual);
-extern ExprDef *
+ExprDef *
ActionCreate(xkb_atom_t name, ExprDef *args);
-extern ExprDef *
+ExprDef *
CreateMultiKeysymList(ExprDef *list);
-extern ExprDef *
+ExprDef *
CreateKeysymList(char *sym);
-extern ExprDef *
+ExprDef *
AppendMultiKeysymList(ExprDef *list, ExprDef *append);
-extern ExprDef *
+ExprDef *
AppendKeysymList(ExprDef *list, char *sym);
-bool
-LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn);
-
-extern IncludeStmt *
+IncludeStmt *
IncludeCreate(struct xkb_context *ctx, char *str, enum merge_mode merge);
-extern void
-CheckDefaultMap(struct xkb_context *ctx, XkbFile *maps, const char *fileName);
-
-extern XkbFile *
-CreateXKBFile(struct xkb_context *ctx, enum xkb_file_type type, char *name,
- ParseCommon *defs,
- unsigned flags);
-
-extern bool
-XKBParseFile(struct xkb_context *ctx, FILE *file, const char *file_name,
- XkbFile **out);
-
-extern bool
-XKBParseString(struct xkb_context *context, const char *string,
- const char *file_name,
- XkbFile **out);
-
-extern void
-FreeXKBFile(XkbFile *file);
-
-extern void
-FreeStmt(ParseCommon *stmt);
+XkbFile *
+XkbFileCreate(struct xkb_context *ctx, enum xkb_file_type type, char *name,
+ ParseCommon *defs, unsigned flags);
void
-scanner_error(struct YYLTYPE *loc, void *scanner, const char *msg);
+FreeStmt(ParseCommon *stmt);
-#endif /* PARSEUTILS_H */
+#endif
*
********************************************************/
-#ifndef XKBCOMP_H
-#define XKBCOMP_H 1
-
-#include "xkb-priv.h"
+#ifndef XKBCOMP_AST_H
+#define XKBCOMP_AST_H
enum stmt_type {
STMT_UNKNOWN = 0,
unsigned flags;
} XkbFile;
-extern bool
-CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
- enum merge_mode merge);
-
-extern bool
-CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap,
- enum merge_mode merge);
-
-extern bool
-CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap,
- enum merge_mode merge);
-
-extern bool
-CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
- enum merge_mode merge);
-
-#endif /* XKBCOMP_H */
+#endif
********************************************************/
#include "xkbcomp-priv.h"
-#include "parseutils.h"
+#include "text.h"
+#include "expr.h"
#include "action.h"
#include "vmod.h"
+#include "include.h"
enum si_field {
SI_FIELD_VIRTUAL_MOD = (1 << 0),
next_incl.act = NULL;
ClearCompatInfo(&next_incl);
- FreeXKBFile(rtrn);
+ FreeXkbFile(rtrn);
}
MergeIncludedCompatMaps(info, &included, merge);
*
********************************************************/
+#include "xkbcomp-priv.h"
+#include "text.h"
#include "expr.h"
typedef bool (*IdentLookupFunc)(struct xkb_context *ctx, const void *priv,
*
********************************************************/
-#ifndef EXPR_H
-#define EXPR_H 1
-
-#include "xkbcomp-priv.h"
+#ifndef XKBCOMP_EXPR_H
+#define XKBCOMP_EXPR_H
typedef struct _LookupEntry {
const char *name;
unsigned int value;
} LookupEntry;
-extern const char *
+const char *
exprOpText(enum expr_op_type op);
bool
ExprResolveKeySym(struct xkb_context *ctx, const ExprDef *expr,
xkb_keysym_t *sym_rtrn);
-#endif /* EXPR_H */
+#endif
#include <errno.h>
#include <limits.h>
+#include <stdio.h>
-#include "path.h"
-#include "parseutils.h"
+#include "xkbcomp-priv.h"
+#include "text.h"
+#include "include.h"
/**
* Extract the first token from an include statement.
*
*/
bool
-XkbParseIncludeMap(char **str_inout, char **file_rtrn, char **map_rtrn,
- char *nextop_rtrn, char **extra_data)
+ParseIncludeMap(char **str_inout, char **file_rtrn, char **map_rtrn,
+ char *nextop_rtrn, char **extra_data)
{
char *tmp, *str, *next;
/**
* Return the xkb directory based on the type.
*/
-const char *
-XkbDirectoryForInclude(enum xkb_file_type type)
+static const char *
+DirectoryForInclude(enum xkb_file_type type)
{
switch (type) {
case FILE_TYPE_KEYMAP:
* pathRtrn is undefined.
*/
FILE *
-XkbFindFileInPath(struct xkb_context *ctx, const char *name,
+FindFileInXkbPath(struct xkb_context *ctx, const char *name,
enum xkb_file_type type, char **pathRtrn)
{
size_t i;
char buf[PATH_MAX];
const char *typeDir;
- typeDir = XkbDirectoryForInclude(type);
+ typeDir = DirectoryForInclude(type);
for (i = 0; i < xkb_context_num_include_paths(ctx); i++) {
ret = snprintf(buf, sizeof(buf), "%s/%s/%s",
xkb_context_include_path_get(ctx, i), typeDir, name);
FILE *file;
XkbFile *rtrn, *mapToUse, *next;
- file = XkbFindFileInPath(ctx, stmt->file, file_type, NULL);
+ file = FindFileInXkbPath(ctx, stmt->file, file_type, NULL);
if (file == NULL) {
log_err(ctx, "Can't find file \"%s\" for %s include\n", stmt->file,
- XkbDirectoryForInclude(file_type));
+ DirectoryForInclude(file_type));
return false;
}
- if (!XKBParseFile(ctx, file, stmt->file, &rtrn)) {
+ if (!XkbParseFile(ctx, file, stmt->file, &rtrn)) {
log_err(ctx, "Error interpreting include file \"%s\"\n", stmt->file);
fclose(file);
return false;
mapToUse->common.next = NULL;
if (streq(mapToUse->name, stmt->map) &&
mapToUse->file_type == file_type) {
- FreeXKBFile(next);
+ FreeXkbFile(next);
break;
}
else {
- FreeXKBFile(mapToUse);
+ FreeXkbFile(mapToUse);
}
mapToUse = next;
}
*
********************************************************/
-#ifndef XKBCOMP_PATH_H
-#define XKBCOMP_PATH_H
-
-#include <stdio.h>
-
-#include "xkbcomp-priv.h"
+#ifndef XKBCOMP_INCLUDE_H
+#define XKBCOMP_INCLUDE_H
bool
-XkbParseIncludeMap(char **str_inout, char **file_rtrn, char **map_rtrn,
- char *nextop_rtrn,
- char **extra_data);
-
-const char *
-XkbDirectoryForInclude(enum xkb_file_type type);
+ParseIncludeMap(char **str_inout, char **file_rtrn, char **map_rtrn,
+ char *nextop_rtrn, char **extra_data);
FILE *
-XkbFindFileInPath(struct xkb_context *ctx, const char *name,
+FindFileInXkbPath(struct xkb_context *ctx, const char *name,
enum xkb_file_type type, char **pathRtrn);
-#endif /* XKBCOMP_PATH_H */
+bool
+ProcessIncludeFile(struct xkb_context *ctx, IncludeStmt *stmt,
+ enum xkb_file_type file_type, XkbFile **file_rtrn,
+ enum merge_mode *merge_rtrn);
+
+#endif
********************************************************/
#include "xkbcomp-priv.h"
+#include "text.h"
#include "expr.h"
-#include "parseutils.h"
+#include "keycodes.h"
+#include "include.h"
/*
* The xkb_keycodes section
MergeIncludedKeycodes(&included, &next_incl, merge);
ClearKeyNamesInfo(&next_incl);
- FreeXKBFile(rtrn);
+ FreeXkbFile(rtrn);
}
MergeIncludedKeycodes(info, &included, merge);
--- /dev/null
+/************************************************************
+ * 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.
+ *
+ ********************************************************/
+
+#ifndef XKBCOMP_KEYCODES_H
+#define XKBCOMP_KEYCODES_H
+
+static inline unsigned long
+KeyNameToLong(const char name[XkbKeyNameLength])
+{
+ return
+ (((unsigned long)name[0]) << 24) |
+ (((unsigned long)name[1]) << 16) |
+ (((unsigned long)name[2]) << 8) |
+ (((unsigned long)name[3]) << 0);
+}
+
+static inline void
+LongToKeyName(unsigned long val, char name[XkbKeyNameLength])
+{
+ name[0] = ((val >> 24) & 0xff);
+ name[1] = ((val >> 16) & 0xff);
+ name[2] = ((val >> 8) & 0xff);
+ name[3] = ((val >> 0) & 0xff);
+}
+
+static inline const char *
+LongKeyNameText(unsigned long val)
+{
+ char buf[XkbKeyNameLength];
+ LongToKeyName(val, buf);
+ return KeyNameText(buf);
+}
+
+struct xkb_key *
+FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
+ bool use_aliases, xkb_keycode_t start_from);
+
+bool
+FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname,
+ unsigned long *real_name);
+
+#endif
--- /dev/null
+/************************************************************
+ * 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.
+ *
+ ********************************************************/
+
+#ifndef XKBCOMP_PARSER_PRIV_H
+#define XKBCOMP_PARSER_PRIV_H
+
+#pragma GCC diagnostic ignored "-Wredundant-decls"
+
+struct scanner_extra;
+
+struct parser_param {
+ struct xkb_context *ctx;
+ void *scanner;
+ XkbFile *rtrn;
+};
+
+#include "parser.h"
+
+void
+scanner_error(YYLTYPE *loc, void *scanner, const char *msg);
+
+int
+yylex(YYSTYPE *val, YYLTYPE *loc, void *scanner);
+
+#endif
%{
#include "xkbcomp-priv.h"
-#include "parseutils.h"
-
-#pragma GCC diagnostic ignored "-Wredundant-decls"
-
-extern int yylex(union YYSTYPE *val, struct YYLTYPE *loc, void *scanner);
+#include "ast-build.h"
+#include "parser-priv.h"
static void
yyerror(struct YYLTYPE *loc, struct parser_param *param, const char *msg)
XkbCompositeMap : OptFlags XkbCompositeType OptMapName OBRACE
XkbMapConfigList
CBRACE SEMI
- { $$ = CreateXKBFile(param->ctx, $2, $3, &$5->common, $1); }
+ { $$ = XkbFileCreate(param->ctx, $2, $3, &$5->common, $1); }
;
XkbCompositeType: XKB_KEYMAP { $$ = FILE_TYPE_KEYMAP; }
$$ = NULL;
}
else {
- $$ = CreateXKBFile(param->ctx, $2, $3, $5, $1);
+ $$ = XkbFileCreate(param->ctx, $2, $3, $5, $1);
}
}
;
$$ = NULL;
}
else {
- $$ = CreateXKBFile(param->ctx, $2, $3, $4, $1);
+ $$ = XkbFileCreate(param->ctx, $2, $3, $4, $1);
}
}
;
#include <sys/stat.h>
#include <sys/types.h>
+#include "xkbcomp-priv.h"
#include "rules.h"
-#include "path.h"
+#include "include.h"
static const char *
input_line_get(struct xkb_context *ctx, const char *buf, const char *end,
char *path;
char **include;
- file = XkbFindFileInPath(ctx, rmlvo->rules, FILE_TYPE_RULES, &path);
+ file = FindFileInXkbPath(ctx, rmlvo->rules, FILE_TYPE_RULES, &path);
if (!file) {
log_err(ctx, "Could not find \"%s\" rules in XKB path\n",
rmlvo->rules);
* authorization from the authors.
*/
-#ifndef RULES_H
-#define RULES_H
-
-#include "xkbcomp-priv.h"
+#ifndef XKBCOMP_RULES_H
+#define XKBCOMP_RULES_H
bool
xkb_components_from_rules(struct xkb_context *ctx,
const struct xkb_rule_names *rmlvo,
struct xkb_component_names *out);
-#endif /* RULES_H */
+#endif
********************************************************/
%{
-#include <stdio.h>
-
#include "xkbcomp-priv.h"
-#include "parseutils.h"
+#include "parser-priv.h"
-#pragma GCC diagnostic ignored "-Wredundant-decls"
#pragma GCC diagnostic ignored "-Wmissing-noreturn"
-extern int yyparse(struct parser_param *param);
+struct scanner_extra {
+ struct xkb_context *ctx;
+ char *scanFile;
+ char scanBuf[1024];
+ char *s;
+};
static void
scanner_error_extra(struct YYLTYPE *loc, struct scanner_extra *extra,
scanner_error_extra(loc, extra, msg);
}
+static void
+CheckDefaultMap(struct xkb_context *ctx, XkbFile *maps, const char *fileName)
+{
+ XkbFile *dflt = NULL, *tmp;
+
+ for (tmp = maps; tmp; tmp = (XkbFile *) tmp->common.next) {
+ if (!(tmp->flags & XkbLC_Default))
+ continue;
+
+ if (!dflt) {
+ dflt = tmp;
+ continue;
+ }
+
+ log_lvl(ctx, 3,
+ "Multiple default components in %s; "
+ "Using %s, ignoring %s\n",
+ (fileName ? fileName : "(unknown)"),
+ (dflt->name ? dflt->name : "(first)"),
+ (tmp->name ? tmp->name : "(subsequent)"));
+
+ tmp->flags &= (~XkbLC_Default);
+ }
+}
+
bool
-XKBParseString(struct xkb_context *ctx, const char *string,
+XkbParseString(struct xkb_context *ctx, const char *string,
const char *file_name, XkbFile **out)
{
int ret;
}
bool
-XKBParseFile(struct xkb_context *ctx, FILE *file,
+XkbParseFile(struct xkb_context *ctx, FILE *file,
const char *file_name, XkbFile **out)
{
int ret;
********************************************************/
#include "xkbcomp-priv.h"
-#include "parseutils.h"
+#include "text.h"
+#include "expr.h"
#include "action.h"
#include "vmod.h"
-
-/***====================================================================***/
+#include "keycodes.h"
+#include "include.h"
/* Needed to work with the typechecker. */
typedef darray(xkb_keysym_t) darray_xkb_keysym_t;
MergeIncludedSymbols(&included, &next_incl, merge);
FreeSymbolsInfo(&next_incl);
- FreeXKBFile(rtrn);
+ FreeXkbFile(rtrn);
}
MergeIncludedSymbols(info, &included, merge);
return true;
}
+bool
+LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn)
+{
+ xkb_keysym_t sym;
+
+ if (!str || istreq(str, "any") || istreq(str, "nosymbol")) {
+ *sym_rtrn = XKB_KEY_NoSymbol;
+ return 1;
+ }
+
+ if (istreq(str, "none") || istreq(str, "voidsymbol")) {
+ *sym_rtrn = XKB_KEY_VoidSymbol;
+ return 1;
+ }
+
+ sym = xkb_keysym_from_name(str);
+ if (sym != XKB_KEY_NoSymbol) {
+ *sym_rtrn = sym;
+ return 1;
+ }
+
+ return 0;
+}
+
static bool
AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
ExprDef *value)
********************************************************/
#include "xkbcomp-priv.h"
-#include "parseutils.h"
+#include "text.h"
#include "vmod.h"
+#include "expr.h"
+#include "include.h"
/*
* The xkb_types section
MergeIncludedKeyTypes(&included, &next_incl, merge);
FreeKeyTypesInfo(&next_incl);
- FreeXKBFile(rtrn);
+ FreeXkbFile(rtrn);
}
MergeIncludedKeyTypes(info, &included, merge);
*
********************************************************/
+#include "xkbcomp-priv.h"
+#include "text.h"
+#include "expr.h"
#include "vmod.h"
void
*
********************************************************/
-#ifndef VMOD_H
-#define VMOD_H 1
-
-#include "xkbcomp-priv.h"
-#include "expr.h"
+#ifndef XKBCOMP_VMOD_H
+#define XKBCOMP_VMOD_H
typedef struct _VModInfo {
xkb_mod_mask_t defined;
xkb_mod_mask_t available;
} VModInfo;
-extern void
+void
InitVModInfo(VModInfo *info, struct xkb_keymap *keymap);
-extern void
+void
ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap);
-extern bool
+bool
HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap,
enum merge_mode mergeMode, VModInfo *info);
ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
xkb_mod_index_t *ndx_rtrn, VModInfo *info);
-#endif /* VMOD_H */
+#endif
#ifndef XKBCOMP_PRIV_H
#define XKBCOMP_PRIV_H
-#include "xkbcomp.h"
-#include "text.h"
+#include "xkb-priv.h"
+#include "ast.h"
-extern bool
-ProcessIncludeFile(struct xkb_context *ctx, IncludeStmt *stmt,
- enum xkb_file_type file_type, XkbFile **file_rtrn,
- enum merge_mode *merge_rtrn);
+bool
+XkbParseFile(struct xkb_context *ctx, FILE *file, const char *file_name,
+ XkbFile **out);
-struct xkb_key *
-FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
- bool use_aliases, xkb_keycode_t start_from);
+bool
+XkbParseString(struct xkb_context *context, const char *string,
+ const char *file_name, XkbFile **out);
-extern bool
-FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname,
- unsigned long *real_name);
+void
+FreeXkbFile(XkbFile *file);
-extern bool
+XkbFile *
+XkbFileFromComponents(struct xkb_context *ctx,
+ struct xkb_component_names *kkctgs);
+
+bool
+CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap,
+ enum merge_mode merge);
+
+bool
+CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap,
+ enum merge_mode merge);
+
+bool
+CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap,
+ enum merge_mode merge);
+
+bool
+CompileSymbols(XkbFile *file, struct xkb_keymap *keymap,
+ enum merge_mode merge);
+
+bool
UpdateModifiersFromCompat(struct xkb_keymap *keymap);
+bool
+LookupKeysym(const char *str, xkb_keysym_t *sym_rtrn);
+
const char *
StmtTypeToString(enum stmt_type type);
-static inline unsigned long
-KeyNameToLong(const char name[XkbKeyNameLength])
-{
- return
- (((unsigned long)name[0]) << 24) |
- (((unsigned long)name[1]) << 16) |
- (((unsigned long)name[2]) << 8) |
- (((unsigned long)name[3]) << 0);
-}
-
-static inline void
-LongToKeyName(unsigned long val, char name[XkbKeyNameLength])
-{
- name[0] = ((val >> 24) & 0xff);
- name[1] = ((val >> 16) & 0xff);
- name[2] = ((val >> 8) & 0xff);
- name[3] = ((val >> 0) & 0xff);
-}
-
-static inline const char *
-LongKeyNameText(unsigned long val)
-{
- char buf[XkbKeyNameLength];
- LongToKeyName(val, buf);
- return KeyNameText(buf);
-}
+/***====================================================================***/
static inline bool
ReportNotArray(struct xkb_keymap *keymap, const char *type, const char *field,
return false;
}
-#endif /* XKBCOMP_PRIV_H */
+#endif
*/
#include "xkbcomp-priv.h"
+#include "text.h"
#include "rules.h"
-#include "parseutils.h"
-
-static XkbFile *
-keymap_file_from_names(struct xkb_context *ctx,
- const struct xkb_rule_names *rmlvo)
-{
- struct xkb_component_names kkctgs;
- XkbFile *keycodes, *types, *compat, *symbols;
- IncludeStmt *inc;
-
- if (!xkb_components_from_rules(ctx, rmlvo, &kkctgs)) {
- log_err(ctx,
- "Couldn't look up rules '%s', model '%s', layout '%s', "
- "variant '%s', options '%s'\n",
- rmlvo->rules, rmlvo->model, rmlvo->layout, rmlvo->variant,
- rmlvo->options);
- return NULL;
- }
-
- inc = IncludeCreate(ctx, kkctgs.keycodes, MERGE_DEFAULT);
- keycodes = CreateXKBFile(ctx, FILE_TYPE_KEYCODES, NULL,
- (ParseCommon *) inc, 0);
-
- inc = IncludeCreate(ctx, kkctgs.types, MERGE_DEFAULT);
- types = CreateXKBFile(ctx, FILE_TYPE_TYPES, NULL,
- (ParseCommon *) inc, 0);
- AppendStmt(&keycodes->common, &types->common);
-
- inc = IncludeCreate(ctx, kkctgs.compat, MERGE_DEFAULT);
- compat = CreateXKBFile(ctx, FILE_TYPE_COMPAT, NULL,
- (ParseCommon *) inc, 0);
- AppendStmt(&keycodes->common, &compat->common);
-
- inc = IncludeCreate(ctx, kkctgs.symbols, MERGE_DEFAULT);
- symbols = CreateXKBFile(ctx, FILE_TYPE_SYMBOLS, NULL,
- (ParseCommon *) inc, 0);
- AppendStmt(&keycodes->common, &symbols->common);
-
- free(kkctgs.keycodes);
- free(kkctgs.types);
- free(kkctgs.compat);
- free(kkctgs.symbols);
-
- return CreateXKBFile(ctx, FILE_TYPE_KEYMAP, strdup(""),
- &keycodes->common, 0);
-}
-
-static struct xkb_keymap *
-new_keymap(struct xkb_context *ctx)
-{
- struct xkb_keymap *keymap;
-
- keymap = calloc(1, sizeof(*keymap));
- if (!keymap)
- return NULL;
-
- keymap->refcnt = 1;
- keymap->ctx = xkb_context_ref(ctx);
-
- return keymap;
-}
/**
* Compile the given file and store the output in keymap.
XkbFile *compat = NULL;
XkbFile *symbols = NULL;
- keymap = new_keymap(ctx);
+ keymap = xkb_map_new(ctx);
if (!keymap)
goto err;
const struct xkb_rule_names *rmlvo_in,
enum xkb_map_compile_flags flags)
{
+ bool ok;
+ struct xkb_component_names kccgst;
struct xkb_rule_names rmlvo = *rmlvo_in;
XkbFile *file;
struct xkb_keymap *keymap;
if (isempty(rmlvo.layout))
rmlvo.layout = DEFAULT_XKB_LAYOUT;
- file = keymap_file_from_names(ctx, &rmlvo);
+ ok = xkb_components_from_rules(ctx, &rmlvo, &kccgst);
+ if (!ok) {
+ log_err(ctx,
+ "Couldn't look up rules '%s', model '%s', layout '%s', "
+ "variant '%s', options '%s'\n",
+ rmlvo.rules, rmlvo.model, rmlvo.layout, rmlvo.variant,
+ rmlvo.options);
+ return NULL;
+ }
+
+ file = XkbFileFromComponents(ctx, &kccgst);
+
+ free(kccgst.keycodes);
+ free(kccgst.types);
+ free(kccgst.compat);
+ free(kccgst.symbols);
+
if (!file) {
log_err(ctx,
"Failed to generate parsed XKB file from components\n");
}
keymap = compile_keymap(ctx, file);
- FreeXKBFile(file);
+ FreeXkbFile(file);
return keymap;
}
return NULL;
}
- ok = XKBParseString(ctx, string, "input", &file);
+ ok = XkbParseString(ctx, string, "input", &file);
if (!ok) {
log_err(ctx, "Failed to parse input xkb file\n");
return NULL;
}
keymap = compile_keymap(ctx, file);
- FreeXKBFile(file);
+ FreeXkbFile(file);
return keymap;
}
return NULL;
}
- ok = XKBParseFile(ctx, file, "(unknown file)", &xkb_file);
+ ok = XkbParseFile(ctx, file, "(unknown file)", &xkb_file);
if (!ok) {
log_err(ctx, "Failed to parse input xkb file\n");
return NULL;
}
keymap = compile_keymap(ctx, xkb_file);
- FreeXKBFile(xkb_file);
- return keymap;
-}
-
-XKB_EXPORT struct xkb_keymap *
-xkb_map_ref(struct xkb_keymap *keymap)
-{
- keymap->refcnt++;
+ FreeXkbFile(xkb_file);
return keymap;
}
-
-XKB_EXPORT void
-xkb_map_unref(struct xkb_keymap *keymap)
-{
- unsigned int i;
- struct xkb_key *key;
-
- if (!keymap || --keymap->refcnt > 0)
- return;
-
- for (i = 0; i < keymap->num_types; i++) {
- free(keymap->types[i].map);
- free(keymap->types[i].level_names);
- }
- free(keymap->types);
-
- darray_foreach(key, keymap->keys) {
- free(key->sym_index);
- free(key->num_syms);
- darray_free(key->syms);
- free(key->actions);
- }
- darray_free(keymap->keys);
-
- darray_free(keymap->sym_interpret);
-
- darray_free(keymap->key_aliases);
-
- free(keymap->keycodes_section_name);
- free(keymap->symbols_section_name);
- free(keymap->types_section_name);
- free(keymap->compat_section_name);
-
- xkb_context_unref(keymap->ctx);
-
- free(keymap);
-}
#include <stdio.h>
#include <string.h>
-#include "xkbcommon/xkbcommon.h"
-#include "rules.h"
#include "test.h"
+#include "xkb-priv.h"
+#include "rules.h"
struct test_data {
/* Rules file */
projects / platform / upstream / libxkbcommon.git / commitdiff