#ifndef XKBCOMP_PARSER_PRIV_H
#define XKBCOMP_PARSER_PRIV_H
-struct scanner;
struct parser_param;
+#include "scanner-utils.h"
#include "parser.h"
int
-scanner_error(struct scanner *scanner, const char *msg);
-
-void
-scanner_warn(struct scanner *s, const char *msg);
-
-int
_xkbcommon_lex(YYSTYPE *yylval, struct scanner *scanner);
XkbFile *
-parse(struct xkb_context *ctx, void *scanner, const char *map);
+parse(struct xkb_context *ctx, struct scanner *scanner, const char *map);
int
keyword_to_token(const char *string, unsigned int len);
struct parser_param {
struct xkb_context *ctx;
- void *scanner;
+ struct scanner *scanner;
XkbFile *rtrn;
bool more_maps;
};
-static void
-parser_error(struct parser_param *param, const char *msg)
-{
- scanner_error(param->scanner, msg);
-}
+#define parser_err(param, fmt, ...) \
+ scanner_err((param)->scanner, fmt, ##__VA_ARGS__)
-static void
-parser_warn(struct parser_param *param, const char *msg)
-{
- scanner_warn(param->scanner, msg);
-}
+#define parser_warn(param, fmt, ...) \
+ scanner_warn((param)->scanner, fmt, ##__VA_ARGS__)
static void
_xkbcommon_error(struct parser_param *param, const char *msg)
{
- parser_error(param, msg);
+ parser_err(param, "%s", msg);
}
static bool
return false;
}
-#define scanner param->scanner
+#define param_scanner param->scanner
%}
%pure-parser
-%lex-param { struct scanner *scanner }
+%lex-param { struct scanner *param_scanner }
%parse-param { struct parser_param *param }
%token
%%
-#undef scanner
-
XkbFile *
-parse(struct xkb_context *ctx, void *scanner, const char *map)
+parse(struct xkb_context *ctx, struct scanner *scanner, const char *map)
{
int ret;
XkbFile *first = NULL;
return first;
}
-
-#define scanner param->scanner
TOK_ERROR
};
-/* C99 is stupid. Just use the 1 variant when there are no args. */
-#define scanner_error1(scanner, msg) \
- log_warn((scanner)->ctx, "%s:%u:%u: %s\n", \
- (scanner)->file_name, \
- (scanner)->token_line, (scanner)->token_column, msg)
-#define scanner_error(scanner, fmt, ...) \
- log_err((scanner)->ctx, "%s:%u:%u: " fmt "\n", \
- (scanner)->file_name, \
- (scanner)->token_line, (scanner)->token_column, __VA_ARGS__)
-
static inline bool
is_ident(char ch)
{
/* Escaped line continuation. */
if (chr(s, '\\')) {
if (!eol(s)) {
- scanner_error1(s, "illegal new line escape; must appear at end of line");
+ scanner_err(s, "illegal new line escape; must appear at end of line");
return TOK_ERROR;
}
next(s);
val->string.len++;
}
if (val->string.len == 0) {
- scanner_error1(s, "unexpected character after \'$\'; expected name");
+ scanner_err(s, "unexpected character after \'$\'; expected name");
return TOK_ERROR;
}
return TOK_GROUP_NAME;
return TOK_IDENTIFIER;
}
- scanner_error1(s, "unrecognized token");
+ scanner_err(s, "unrecognized token");
return TOK_ERROR;
}
free(m);
}
-#define matcher_error1(matcher, msg) \
- scanner_error1(&(matcher)->scanner, msg)
-#define matcher_error(matcher, fmt, ...) \
- scanner_error(&(matcher)->scanner, fmt, __VA_ARGS__)
+#define matcher_err(matcher, fmt, ...) \
+ scanner_err(&(matcher)->scanner, fmt, ## __VA_ARGS__)
static void
matcher_group_start_new(struct matcher *m, struct sval name)
/* Not found. */
if (mlvo >= _MLVO_NUM_ENTRIES) {
- matcher_error(m,
- "invalid mapping: %.*s is not a valid value here; "
- "ignoring rule set",
- ident.len, ident.start);
+ matcher_err(m, "invalid mapping: %.*s is not a valid value here; ignoring rule set",
+ ident.len, ident.start);
m->mapping.skip = true;
return;
}
if (m->mapping.defined_mlvo_mask & (1u << mlvo)) {
- matcher_error(m,
- "invalid mapping: %.*s appears twice on the same line; "
- "ignoring rule set",
- mlvo_sval.len, mlvo_sval.start);
+ matcher_err(m, "invalid mapping: %.*s appears twice on the same line; ignoring rule set",
+ mlvo_sval.len, mlvo_sval.start);
m->mapping.skip = true;
return;
}
int consumed = extract_layout_index(ident.start + mlvo_sval.len,
ident.len - mlvo_sval.len, &idx);
if ((int) (ident.len - mlvo_sval.len) != consumed) {
- matcher_error(m,
- "invalid mapping:\" %.*s\" may only be followed by a valid group index; "
- "ignoring rule set",
- mlvo_sval.len, mlvo_sval.start);
+ matcher_err(m, "invalid mapping: \"%.*s\" may only be followed by a valid group index; ignoring rule set",
+ mlvo_sval.len, mlvo_sval.start);
m->mapping.skip = true;
return;
}
m->mapping.variant_idx = idx;
}
else {
- matcher_error(m,
- "invalid mapping: \"%.*s\" cannot be followed by a group index; "
- "ignoring rule set",
- mlvo_sval.len, mlvo_sval.start);
+ matcher_err(m, "invalid mapping: \"%.*s\" cannot be followed by a group index; ignoring rule set",
+ mlvo_sval.len, mlvo_sval.start);
m->mapping.skip = true;
return;
}
/* Not found. */
if (kccgst >= _KCCGST_NUM_ENTRIES) {
- matcher_error(m,
- "invalid mapping: %.*s is not a valid value here; "
- "ignoring rule set",
- ident.len, ident.start);
+ matcher_err(m, "invalid mapping: %.*s is not a valid value here; ignoring rule set",
+ ident.len, ident.start);
m->mapping.skip = true;
return;
}
if (m->mapping.defined_kccgst_mask & (1u << kccgst)) {
- matcher_error(m,
- "invalid mapping: %.*s appears twice on the same line; "
- "ignoring rule set",
- kccgst_sval.len, kccgst_sval.start);
+ matcher_err(m, "invalid mapping: %.*s appears twice on the same line; ignoring rule set",
+ kccgst_sval.len, kccgst_sval.start);
m->mapping.skip = true;
return;
}
matcher_mapping_verify(struct matcher *m)
{
if (m->mapping.num_mlvo == 0) {
- matcher_error1(m,
- "invalid mapping: must have at least one value on the left hand side; "
- "ignoring rule set");
+ matcher_err(m, "invalid mapping: must have at least one value on the left hand side; ignoring rule set");
goto skip;
}
if (m->mapping.num_kccgst == 0) {
- matcher_error1(m,
- "invalid mapping: must have at least one value on the right hand side; "
- "ignoring rule set");
+ matcher_err(m, "invalid mapping: must have at least one value on the right hand side; ignoring rule set");
goto skip;
}
enum mlvo_match_type match_type)
{
if (m->rule.num_mlvo_values + 1 > m->mapping.num_mlvo) {
- matcher_error1(m,
- "invalid rule: has more values than the mapping line; "
- "ignoring rule");
+ matcher_err(m, "invalid rule: has more values than the mapping line; ignoring rule");
m->rule.skip = true;
return;
}
matcher_rule_set_kccgst(struct matcher *m, struct sval ident)
{
if (m->rule.num_kccgst_values + 1 > m->mapping.num_kccgst) {
- matcher_error1(m,
- "invalid rule: has more values than the mapping line; "
- "ignoring rule");
+ matcher_err(m, "invalid rule: has more values than the mapping line; ignoring rule");
m->rule.skip = true;
return;
}
int consumed;
if (mlv != MLVO_LAYOUT && mlv != MLVO_VARIANT) {
- matcher_error1(m,
- "invalid index in %%-expansion; "
- "may only index layout or variant");
+ matcher_err(m, "invalid index in %%-expansion; may only index layout or variant");
goto error;
}
error:
darray_free(expanded);
- matcher_error1(m, "invalid %%-expansion in value; not used");
+ matcher_err(m, "invalid %%-expansion in value; not used");
return false;
}
{
if (m->rule.num_mlvo_values != m->mapping.num_mlvo ||
m->rule.num_kccgst_values != m->mapping.num_kccgst) {
- matcher_error1(m,
- "invalid rule: must have same number of values as mapping line;"
- "ignoring rule");
+ matcher_err(m, "invalid rule: must have same number of values as mapping line; ignoring rule");
m->rule.skip = true;
}
}
return true;
state_error:
- matcher_error1(m, "unexpected token");
+ matcher_err(m, "unexpected token");
error:
return false;
}
struct xkb_context *ctx;
};
+#define scanner_log(scanner, level, fmt, ...) \
+ xkb_log((scanner)->ctx, (level), 0, \
+ "%s:%u:%u: " fmt "\n", \
+ (scanner)->file_name, \
+ (scanner)->token_line, (scanner)->token_column, ##__VA_ARGS__)
+
+#define scanner_err(scanner, fmt, ...) \
+ scanner_log(scanner, XKB_LOG_LEVEL_ERROR, fmt, ##__VA_ARGS__)
+
+#define scanner_warn(scanner, fmt, ...) \
+ scanner_log(scanner, XKB_LOG_LEVEL_WARNING, fmt, ##__VA_ARGS__)
+
static inline void
scanner_init(struct scanner *s, struct xkb_context *ctx,
const char *string, size_t len, const char *file_name)
#include "xkbcomp-priv.h"
#include "parser-priv.h"
-#include "scanner-utils.h"
-
-static void
-scanner_log(enum xkb_log_level level, struct scanner *s, const char *msg)
-{
- xkb_log(s->ctx, level, 0, "%s:%u:%u: %s\n", s->file_name,
- s->token_line, s->token_column, msg);
-}
-
-int
-scanner_error(struct scanner *s, const char *msg)
-{
- scanner_log(XKB_LOG_LEVEL_ERROR, s, msg);
- return ERROR_TOK;
-}
-
-void
-scanner_warn(struct scanner *s, const char *msg)
-{
- scanner_log(XKB_LOG_LEVEL_WARNING, s, msg);
-}
static bool
number(struct scanner *s, int64_t *out, int *out_tok)
buf_append(s, next(s));
}
}
- if (!buf_append(s, '\0') || !chr(s, '\"'))
- return scanner_error(s, "unterminated string literal");
+ if (!buf_append(s, '\0') || !chr(s, '\"')) {
+ scanner_err(s, "unterminated string literal");
+ return ERROR_TOK;
+ }
yylval->str = strdup(s->buf);
if (!yylval->str)
- return scanner_error(s, "scanner out of memory");
+ return ERROR_TOK;
return STRING;
}
if (chr(s, '<')) {
while (is_graph(peek(s)) && peek(s) != '>')
buf_append(s, next(s));
- if (!buf_append(s, '\0') || !chr(s, '>'))
- return scanner_error(s, "unterminated key name literal");
+ if (!buf_append(s, '\0') || !chr(s, '>')) {
+ scanner_err(s, "unterminated key name literal");
+ return ERROR_TOK;
+ }
/* Empty key name literals are allowed. */
yylval->sval = xkb_atom_intern(s->ctx, s->buf, s->buf_pos - 1);
return KEYNAME;
s->buf_pos = 0;
while (is_alnum(peek(s)) || peek(s) == '_')
buf_append(s, next(s));
- if (!buf_append(s, '\0'))
- return scanner_error(s, "identifier too long");
+ if (!buf_append(s, '\0')) {
+ scanner_err(s, "identifier too long");
+ return ERROR_TOK;
+ }
/* Keyword. */
tok = keyword_to_token(s->buf, s->buf_pos - 1);
yylval->str = strdup(s->buf);
if (!yylval->str)
- return scanner_error(s, "scanner out of memory");
+ return ERROR_TOK;
return IDENT;
}
/* Number literal (hexadecimal / decimal / float). */
if (number(s, &yylval->num, &tok)) {
- if (tok == ERROR_TOK)
- return scanner_error(s, "malformed number literal");
+ if (tok == ERROR_TOK) {
+ scanner_err(s, "malformed number literal");
+ return ERROR_TOK;
+ }
return tok;
}
- return scanner_error(s, "unrecognized token");
+ scanner_err(s, "unrecognized token");
+ return ERROR_TOK;
}
XkbFile *