/************************************************************ 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. ********************************************************/ %{ #include "xkbcomp-priv.h" #include "parser-priv.h" #pragma GCC diagnostic ignored "-Wmissing-noreturn" #pragma GCC diagnostic ignored "-Wredundant-decls" #pragma GCC diagnostic push struct scanner_extra { struct xkb_context *ctx; const char *file_name; char scanBuf[1024]; char *s; }; static void scanner_error_extra(struct YYLTYPE *loc, struct scanner_extra *extra, const char *msg); #define YY_USER_ACTION { \ yylloc->first_line = yylineno; \ yylloc->last_line = yylineno; \ } #define APPEND_S(ch) do { \ if (yyextra->s - yyextra->scanBuf >= sizeof(yyextra->scanBuf) - 1) \ return ERROR_TOK; \ *yyextra->s++ = ch; \ } while (0) %} %option prefix="_xkbcommon_" %option reentrant %option extra-type="struct scanner_extra *" %option bison-bridge bison-locations %option yylineno %option nounistd noyywrap noinput nounput %option never-interactive %option case-insensitive %x S_STR %% "//"[^\n]* "#"[^\n]* \" yyextra->s = yyextra->scanBuf; BEGIN(S_STR); \" { BEGIN(INITIAL); *yyextra->s = '\0'; yylval->str = strdup(yyextra->scanBuf); return STRING; } \\[0-7]{1,3} { /* octal escape sequence */ unsigned int result; (void) sscanf( yytext + 1, "%o", &result ); if (result > 0xff) { scanner_error_extra(yylloc, yyextra, "Illegal octal escape"); return ERROR_TOK; } APPEND_S(result); } \\[0-9]+ { scanner_error_extra(yylloc, yyextra, "Illegal octal escape"); return ERROR_TOK; } \\n APPEND_S('\n'); \\t APPEND_S('\t'); \\r APPEND_S('\r'); \\b APPEND_S('\b'); \\f APPEND_S('\f'); \\v APPEND_S('\v'); \\e APPEND_S('\033'); . APPEND_S(yytext[0]); \<[a-zA-Z0-9_+-]+\> { /* We don't want the brackets. */ yytext[yyleng - 1] = '\0'; yytext++; yylval->sval = xkb_atom_intern(yyextra->ctx, yytext); return KEYNAME; } xkb_keymap return XKB_KEYMAP; xkb_keycodes return XKB_KEYCODES; xkb_types return XKB_TYPES; xkb_symbols return XKB_SYMBOLS; xkb_compat return XKB_COMPATMAP; xkb_compat_map return XKB_COMPATMAP; xkb_compatibility return XKB_COMPATMAP; xkb_compatibility_map return XKB_COMPATMAP; xkb_geometry return XKB_GEOMETRY; xkb_semantics return XKB_SEMANTICS; xkb_layout return XKB_LAYOUT; include return INCLUDE; override return OVERRIDE; augment return AUGMENT; replace return REPLACE; alternate return ALTERNATE; partial return PARTIAL; default return DEFAULT; hidden return HIDDEN; virtual_modifiers return VIRTUAL_MODS; type return TYPE; interpret return INTERPRET; action return ACTION_TOK; key return KEY; alias return ALIAS; group return GROUP; modmap return MODIFIER_MAP; mod_map return MODIFIER_MAP; modifier_map return MODIFIER_MAP; indicator return INDICATOR; shape return SHAPE; row return ROW; keys return KEYS; section return SECTION; overlay return OVERLAY; text return TEXT; outline return OUTLINE; solid return SOLID; logo return LOGO; virtual return VIRTUAL; alphanumeric_keys return ALPHANUMERIC_KEYS; modifier_keys return MODIFIER_KEYS; keypad_keys return KEYPAD_KEYS; function_keys return FUNCTION_KEYS; alternate_group return ALTERNATE_GROUP; [a-zA-Z_][a-zA-Z_0-9]* yylval->str = strdup(yytext); return IDENT; 0x[a-fA-F0-9]+ | [0-9]+ { char *end; yylval->num = strtoul(yytext, &end, 0); return INTEGER; } [0-9]+\.[0-9]+ { char *end; yylval->num = strtod(yytext, &end); return FLOAT; } "=" return EQUALS; "+" return PLUS; "-" return MINUS; "/" return DIVIDE; "*" return TIMES; "{" return OBRACE; "}" return CBRACE; "(" return OPAREN; ")" return CPAREN; "[" return OBRACKET; "]" return CBRACKET; "." return DOT; "," return COMMA; ";" return SEMI; "!" return EXCLAM; "~" return INVERT; [ \t\r\n\v]+ <> return END_OF_FILE; . return ERROR_TOK; %% #pragma GCC diagnostic pop static void scanner_error_extra(struct YYLTYPE *loc, struct scanner_extra *extra, const char *msg) { log_err(extra->ctx, "%s: line %d of %s\n", msg, loc->first_line, extra->file_name ? extra->file_name : "(unknown)"); } void scanner_error(struct YYLTYPE *loc, void *scanner, const char *msg) { struct scanner_extra *extra = yyget_extra(scanner); scanner_error_extra(loc, extra, msg); } static bool init_scanner(yyscan_t *scanner, struct scanner_extra *extra, struct xkb_context *ctx, const char *file_name) { memset(extra, 0, sizeof(*extra)); if (yylex_init_extra(extra, scanner) != 0) return false; extra->ctx = ctx; extra->file_name = file_name; return true; } static void clear_scanner(yyscan_t scanner) { yylex_destroy(scanner); } XkbFile * XkbParseString(struct xkb_context *ctx, const char *string, const char *file_name) { yyscan_t scanner; struct scanner_extra extra; YY_BUFFER_STATE state; XkbFile *xkb_file; if (!init_scanner(&scanner, &extra, ctx, file_name)) return NULL; state = yy_scan_string(string, scanner); xkb_file = parse(ctx, scanner, NULL); yy_delete_buffer(state, scanner); clear_scanner(scanner); return xkb_file; } /* * yy_scan_buffer() requires the last two bytes of \buf to be 0. These two bytes * are not scanned. Other zero bytes in the buffer are scanned normally, though. * Due to these terminating zeroes, \length must be greater than 2. * Furthermore, the buffer must be writable and you cannot make any assumptions * about it after the scanner finished. * All this must be guaranteed by the caller of this function! */ XkbFile * XkbParseBuffer(struct xkb_context *ctx, char *buf, size_t length, const char *file_name) { yyscan_t scanner; struct scanner_extra extra; YY_BUFFER_STATE state; XkbFile *xkb_file; if (!init_scanner(&scanner, &extra, ctx, file_name)) return NULL; xkb_file = NULL; state = yy_scan_buffer(buf, length, scanner); if (state) { xkb_file = parse(ctx, scanner, NULL); yy_delete_buffer(state, scanner); } clear_scanner(scanner); return xkb_file; } XkbFile * XkbParseFile(struct xkb_context *ctx, FILE *file, const char *file_name, const char *map) { yyscan_t scanner; struct scanner_extra extra; YY_BUFFER_STATE state; XkbFile *xkb_file; if (!init_scanner(&scanner, &extra, ctx, file_name)) return NULL; state = yy_create_buffer(file, YY_BUF_SIZE, scanner); yy_switch_to_buffer(state, scanner); xkb_file = parse(ctx, scanner, map); yy_delete_buffer(state, scanner); clear_scanner(scanner); return xkb_file; }