e502216e4840f4a585583861c4a3b1ed2407a3d9
[platform/upstream/libxkbcommon.git] / src / xkbcomp / scanner.c
1 /*
2  * Copyright © 2012 Ran Benita <ran234@gmail.com>
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining a
5  * copy of this software and associated documentation files (the "Software"),
6  * to deal in the Software without restriction, including without limitation
7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8  * and/or sell copies of the Software, and to permit persons to whom the
9  * Software is furnished to do so, subject to the following conditions:
10  *
11  * The above copyright notice and this permission notice (including the next
12  * paragraph) shall be included in all copies or substantial portions of the
13  * Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  */
23
24 #include "config.h"
25
26 #include "xkbcomp-priv.h"
27 #include "parser-priv.h"
28 #include "scanner-utils.h"
29
30 static bool
31 number(struct scanner *s, int64_t *out, int *out_tok)
32 {
33     bool is_float = false, is_hex = false;
34     const char *start = s->s + s->pos;
35     char *end;
36
37     if (scanner_lit(s, "0x")) {
38         while (is_xdigit(scanner_peek(s))) scanner_next(s);
39         is_hex = true;
40     }
41     else {
42         while (is_digit(scanner_peek(s))) scanner_next(s);
43         is_float = scanner_chr(s, '.');
44         while (is_digit(scanner_peek(s))) scanner_next(s);
45     }
46     if (s->s + s->pos == start)
47         return false;
48
49     errno = 0;
50     if (is_hex)
51         *out = strtoul(start, &end, 16);
52     else if (is_float)
53         /* The parser currently just ignores floats, so the cast is
54          * fine - the value doesn't matter. */
55         *out = strtod(start, &end);
56     else
57         *out = strtoul(start, &end, 10);
58     if (errno != 0 || s->s + s->pos != end)
59         *out_tok = ERROR_TOK;
60     else
61         *out_tok = (is_float ? FLOAT : INTEGER);
62     return true;
63 }
64
65 int
66 _xkbcommon_lex(YYSTYPE *yylval, struct scanner *s)
67 {
68     int tok;
69
70 skip_more_whitespace_and_comments:
71     /* Skip spaces. */
72     while (is_space(scanner_peek(s))) scanner_next(s);
73
74     /* Skip comments. */
75     if (scanner_lit(s, "//") || scanner_chr(s, '#')) {
76         scanner_skip_to_eol(s);
77         goto skip_more_whitespace_and_comments;
78     }
79
80     /* See if we're done. */
81     if (scanner_eof(s)) return END_OF_FILE;
82
83     /* New token. */
84     s->token_line = s->line;
85     s->token_column = s->column;
86     s->buf_pos = 0;
87
88     /* String literal. */
89     if (scanner_chr(s, '\"')) {
90         while (!scanner_eof(s) && !scanner_eol(s) && scanner_peek(s) != '\"') {
91             if (scanner_chr(s, '\\')) {
92                 uint8_t o;
93                 if      (scanner_chr(s, '\\')) scanner_buf_append(s, '\\');
94                 else if (scanner_chr(s, 'n'))  scanner_buf_append(s, '\n');
95                 else if (scanner_chr(s, 't'))  scanner_buf_append(s, '\t');
96                 else if (scanner_chr(s, 'r'))  scanner_buf_append(s, '\r');
97                 else if (scanner_chr(s, 'b'))  scanner_buf_append(s, '\b');
98                 else if (scanner_chr(s, 'f'))  scanner_buf_append(s, '\f');
99                 else if (scanner_chr(s, 'v'))  scanner_buf_append(s, '\v');
100                 else if (scanner_chr(s, 'e'))  scanner_buf_append(s, '\033');
101                 else if (scanner_oct(s, &o))   scanner_buf_append(s, (char) o);
102                 else {
103                     scanner_warn(s, "unknown escape sequence in string literal");
104                     /* Ignore. */
105                 }
106             } else {
107                 scanner_buf_append(s, scanner_next(s));
108             }
109         }
110         if (!scanner_buf_append(s, '\0') || !scanner_chr(s, '\"')) {
111             scanner_err(s, "unterminated string literal");
112             return ERROR_TOK;
113         }
114         yylval->str = strdup(s->buf);
115         if (!yylval->str)
116             return ERROR_TOK;
117         return STRING;
118     }
119
120     /* Key name literal. */
121     if (scanner_chr(s, '<')) {
122         while (is_graph(scanner_peek(s)) && scanner_peek(s) != '>')
123             scanner_buf_append(s, scanner_next(s));
124         if (!scanner_buf_append(s, '\0') || !scanner_chr(s, '>')) {
125             scanner_err(s, "unterminated key name literal");
126             return ERROR_TOK;
127         }
128         /* Empty key name literals are allowed. */
129         yylval->atom = xkb_atom_intern(s->ctx, s->buf, s->buf_pos - 1);
130         return KEYNAME;
131     }
132
133     /* Operators and punctuation. */
134     if (scanner_chr(s, ';')) return SEMI;
135     if (scanner_chr(s, '{')) return OBRACE;
136     if (scanner_chr(s, '}')) return CBRACE;
137     if (scanner_chr(s, '=')) return EQUALS;
138     if (scanner_chr(s, '[')) return OBRACKET;
139     if (scanner_chr(s, ']')) return CBRACKET;
140     if (scanner_chr(s, '(')) return OPAREN;
141     if (scanner_chr(s, ')')) return CPAREN;
142     if (scanner_chr(s, '.')) return DOT;
143     if (scanner_chr(s, ',')) return COMMA;
144     if (scanner_chr(s, '+')) return PLUS;
145     if (scanner_chr(s, '-')) return MINUS;
146     if (scanner_chr(s, '*')) return TIMES;
147     if (scanner_chr(s, '/')) return DIVIDE;
148     if (scanner_chr(s, '!')) return EXCLAM;
149     if (scanner_chr(s, '~')) return INVERT;
150
151     /* Identifier. */
152     if (is_alpha(scanner_peek(s)) || scanner_peek(s) == '_') {
153         s->buf_pos = 0;
154         while (is_alnum(scanner_peek(s)) || scanner_peek(s) == '_')
155             scanner_buf_append(s, scanner_next(s));
156         if (!scanner_buf_append(s, '\0')) {
157             scanner_err(s, "identifier too long");
158             return ERROR_TOK;
159         }
160
161         /* Keyword. */
162         tok = keyword_to_token(s->buf, s->buf_pos - 1);
163         if (tok != -1) return tok;
164
165         yylval->str = strdup(s->buf);
166         if (!yylval->str)
167             return ERROR_TOK;
168         return IDENT;
169     }
170
171     /* Number literal (hexadecimal / decimal / float). */
172     if (number(s, &yylval->num, &tok)) {
173         if (tok == ERROR_TOK) {
174             scanner_err(s, "malformed number literal");
175             return ERROR_TOK;
176         }
177         return tok;
178     }
179
180     scanner_err(s, "unrecognized token");
181     return ERROR_TOK;
182 }
183
184 XkbFile *
185 XkbParseString(struct xkb_context *ctx, const char *string, size_t len,
186                const char *file_name, const char *map)
187 {
188     struct scanner scanner;
189     scanner_init(&scanner, ctx, string, len, file_name, NULL);
190     return parse(ctx, &scanner, map);
191 }
192
193 XkbFile *
194 XkbParseFile(struct xkb_context *ctx, FILE *file,
195              const char *file_name, const char *map)
196 {
197     bool ok;
198     XkbFile *xkb_file;
199     char *string;
200     size_t size;
201
202     ok = map_file(file, &string, &size);
203     if (!ok) {
204         log_err(ctx, "Couldn't read XKB file %s: %s\n",
205                 file_name, strerror(errno));
206         return NULL;
207     }
208
209     xkb_file = XkbParseString(ctx, string, size, file_name, map);
210     unmap_file(string, size);
211     return xkb_file;
212 }