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