scanner: don't fail over unknown escape sequence
[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 "xkbcomp-priv.h"
25 #include "parser-priv.h"
26 #include "scanner-utils.h"
27
28 static void
29 scanner_log(enum xkb_log_level level, YYLTYPE *yylloc, struct scanner *s,
30             const char *msg)
31 {
32     xkb_log_cond_level(s->ctx, level, "%s:%d:%d: %s\n", s->file_name,
33                        yylloc->first_line, yylloc->first_column, msg);
34 }
35
36 int
37 scanner_error(YYLTYPE *yylloc, struct scanner *s, const char *msg)
38 {
39     scanner_log(XKB_LOG_LEVEL_ERROR, yylloc, s, msg);
40     return ERROR_TOK;
41 }
42
43 void
44 scanner_warn(YYLTYPE *yylloc, struct scanner *s, const char *msg)
45 {
46     scanner_log(XKB_LOG_LEVEL_WARNING, yylloc, s, msg);
47 }
48
49 static bool
50 number(struct scanner *s, int64_t *out, enum yytokentype *out_tok)
51 {
52     bool is_float = false, is_hex = false;
53     const char *start = s->s + s->pos;
54     char *end;
55
56     if (lit(s, "0x")) {
57         while (isxdigit(peek(s))) next(s);
58         is_hex = true;
59     }
60     else {
61         while (isdigit(peek(s))) next(s);
62         is_float = chr(s, '.');
63         while (isdigit(peek(s))) next(s);
64     }
65     if (s->s + s->pos == start)
66         return false;
67
68     errno = 0;
69     if (is_hex)
70         *out = strtoul(start, &end, 16);
71     else if (is_float)
72         *out = strtod(start, &end);
73     else
74         *out = strtoul(start, &end, 10);
75     if (errno != 0 || s->s + s->pos != end)
76         *out_tok = ERROR_TOK;
77     else
78         *out_tok = (is_float ? FLOAT : INTEGER);
79     return true;
80 }
81
82 int
83 _xkbcommon_lex(YYSTYPE *yylval, YYLTYPE *yylloc, struct scanner *s)
84 {
85     enum yytokentype tok;
86
87 skip_more_whitespace_and_comments:
88     /* Skip spaces. */
89     while (isspace(peek(s))) next(s);
90
91     /* Skip comments. */
92     if (lit(s, "//") || chr(s, '#')) {
93         while (!eof(s) && !eol(s)) next(s);
94         goto skip_more_whitespace_and_comments;
95     }
96
97     /* See if we're done. */
98     if (eof(s)) return END_OF_FILE;
99
100     /* New token. */
101     yylloc->first_line = yylloc->last_line = s->line;
102     yylloc->first_column = yylloc->last_column = s->column;
103     s->buf_pos = 0;
104
105     /* String literal. */
106     if (chr(s, '\"')) {
107         while (!eof(s) && !eol(s) && peek(s) != '\"') {
108             if (chr(s, '\\')) {
109                 uint8_t o;
110                 if      (chr(s, '\\')) buf_append(s, '\\');
111                 else if (chr(s, 'n'))  buf_append(s, '\n');
112                 else if (chr(s, 't'))  buf_append(s, '\t');
113                 else if (chr(s, 'r'))  buf_append(s, '\r');
114                 else if (chr(s, 'b'))  buf_append(s, '\b');
115                 else if (chr(s, 'f'))  buf_append(s, '\f');
116                 else if (chr(s, 'v'))  buf_append(s, '\v');
117                 else if (chr(s, 'e'))  buf_append(s, '\033');
118                 else if (oct(s, &o))   buf_append(s, (char) o);
119                 else {
120                     scanner_warn(yylloc, s,
121                                  "unknown escape sequence in string literal");
122                     /* Ignore. */
123                 }
124             } else {
125                 buf_append(s, next(s));
126             }
127         }
128         if (!buf_append(s, '\0') || !chr(s, '\"'))
129             return scanner_error(yylloc, s, "unterminated string literal");
130         yylval->str = strdup(s->buf);
131         if (!yylval->str)
132             return scanner_error(yylloc, s, "scanner out of memory");
133         return STRING;
134     }
135
136     /* Key name literal. */
137     if (chr(s, '<')) {
138         while (isgraph(peek(s)) && peek(s) != '>')
139             buf_append(s, next(s));
140         if (!buf_append(s, '\0') || !chr(s, '>'))
141             return scanner_error(yylloc, s, "unterminated key name literal");
142         /* Empty key name literals are allowed. */
143         yylval->sval = xkb_atom_intern(s->ctx, s->buf, s->buf_pos - 1);
144         return KEYNAME;
145     }
146
147     /* Operators and punctuation. */
148     if (chr(s, ';')) return SEMI;
149     if (chr(s, '{')) return OBRACE;
150     if (chr(s, '}')) return CBRACE;
151     if (chr(s, '=')) return EQUALS;
152     if (chr(s, '[')) return OBRACKET;
153     if (chr(s, ']')) return CBRACKET;
154     if (chr(s, '(')) return OPAREN;
155     if (chr(s, ')')) return CPAREN;
156     if (chr(s, '.')) return DOT;
157     if (chr(s, ',')) return COMMA;
158     if (chr(s, '+')) return PLUS;
159     if (chr(s, '-')) return MINUS;
160     if (chr(s, '*')) return TIMES;
161     if (chr(s, '!')) return EXCLAM;
162     if (chr(s, '~')) return INVERT;
163
164     /* Identifier. */
165     if (isalpha(peek(s)) || peek(s) == '_') {
166         s->buf_pos = 0;
167         while (isalnum(peek(s)) || peek(s) == '_')
168             buf_append(s, next(s));
169         if (!buf_append(s, '\0'))
170             return scanner_error(yylloc, s, "identifier too long");
171
172         /* Keyword. */
173         tok = keyword_to_token(s->buf);
174         if ((int) tok != -1) return tok;
175
176         yylval->str = strdup(s->buf);
177         if (!yylval->str)
178             return scanner_error(yylloc, s, "scanner out of memory");
179         return IDENT;
180     }
181
182     /* Number literal (hexadecimal / decimal / float). */
183     if (number(s, &yylval->num, &tok)) {
184         if (tok == ERROR_TOK)
185             return scanner_error(yylloc, s, "malformed number literal");
186         return tok;
187     }
188
189     return scanner_error(yylloc, s, "unrecognized token");
190 }
191
192 XkbFile *
193 XkbParseString(struct xkb_context *ctx, const char *string, size_t len,
194                const char *file_name, const char *map)
195 {
196     struct scanner scanner;
197     scanner_init(&scanner, ctx, string, len, file_name);
198     return parse(ctx, &scanner, map);
199 }
200
201 XkbFile *
202 XkbParseFile(struct xkb_context *ctx, FILE *file,
203              const char *file_name, const char *map)
204 {
205     bool ok;
206     XkbFile *xkb_file;
207     const char *string;
208     size_t size;
209
210     ok = map_file(file, &string, &size);
211     if (!ok) {
212         log_err(ctx, "Couldn't read XKB file %s: %s\n",
213                 file_name, strerror(errno));
214         return NULL;
215     }
216
217     xkb_file = XkbParseString(ctx, string, size, file_name, map);
218     unmap_file(string, size);
219     return xkb_file;
220 }