/src/testdir/build/lua-master/source/llex.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | ** $Id: llex.c $ |
3 | | ** Lexical Analyzer |
4 | | ** See Copyright Notice in lua.h |
5 | | */ |
6 | | |
7 | | #define llex_c |
8 | | #define LUA_CORE |
9 | | |
10 | | #include "lprefix.h" |
11 | | |
12 | | |
13 | | #include <locale.h> |
14 | | #include <string.h> |
15 | | |
16 | | #include "lua.h" |
17 | | |
18 | | #include "lctype.h" |
19 | | #include "ldebug.h" |
20 | | #include "ldo.h" |
21 | | #include "lgc.h" |
22 | | #include "llex.h" |
23 | | #include "lobject.h" |
24 | | #include "lparser.h" |
25 | | #include "lstate.h" |
26 | | #include "lstring.h" |
27 | | #include "ltable.h" |
28 | | #include "lzio.h" |
29 | | |
30 | | |
31 | | |
32 | 0 | #define next(ls) (ls->current = zgetc(ls->z)) |
33 | | |
34 | | |
35 | | |
36 | 0 | #define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') |
37 | | |
38 | | |
39 | | /* ORDER RESERVED */ |
40 | | static const char *const luaX_tokens [] = { |
41 | | "and", "break", "do", "else", "elseif", |
42 | | "end", "false", "for", "function", "goto", "if", |
43 | | "in", "local", "nil", "not", "or", "repeat", |
44 | | "return", "then", "true", "until", "while", |
45 | | "//", "..", "...", "==", ">=", "<=", "~=", |
46 | | "<<", ">>", "::", "<eof>", |
47 | | "<number>", "<integer>", "<name>", "<string>" |
48 | | }; |
49 | | |
50 | | |
51 | 0 | #define save_and_next(ls) (save(ls, ls->current), next(ls)) |
52 | | |
53 | | |
54 | | static l_noret lexerror (LexState *ls, const char *msg, int token); |
55 | | |
56 | | |
57 | 0 | static void save (LexState *ls, int c) { |
58 | 0 | Mbuffer *b = ls->buff; |
59 | 0 | if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { |
60 | 0 | size_t newsize; |
61 | 0 | if (luaZ_sizebuffer(b) >= MAX_SIZE/2) |
62 | 0 | lexerror(ls, "lexical element too long", 0); |
63 | 0 | newsize = luaZ_sizebuffer(b) * 2; |
64 | 0 | luaZ_resizebuffer(ls->L, b, newsize); |
65 | 0 | } |
66 | 0 | b->buffer[luaZ_bufflen(b)++] = cast_char(c); |
67 | 0 | } |
68 | | |
69 | | |
70 | 64 | void luaX_init (lua_State *L) { |
71 | 64 | int i; |
72 | 64 | TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ |
73 | 64 | luaC_fix(L, obj2gco(e)); /* never collect this name */ |
74 | 1.47k | for (i=0; i<NUM_RESERVED; i++) { |
75 | 1.40k | TString *ts = luaS_new(L, luaX_tokens[i]); |
76 | 1.40k | luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */ |
77 | 1.40k | ts->extra = cast_byte(i+1); /* reserved word */ |
78 | 1.40k | } |
79 | 64 | } |
80 | | |
81 | | |
82 | 0 | const char *luaX_token2str (LexState *ls, int token) { |
83 | 0 | if (token < FIRST_RESERVED) { /* single-byte symbols? */ |
84 | 0 | if (lisprint(token)) |
85 | 0 | return luaO_pushfstring(ls->L, "'%c'", token); |
86 | 0 | else /* control character */ |
87 | 0 | return luaO_pushfstring(ls->L, "'<\\%d>'", token); |
88 | 0 | } |
89 | 0 | else { |
90 | 0 | const char *s = luaX_tokens[token - FIRST_RESERVED]; |
91 | 0 | if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ |
92 | 0 | return luaO_pushfstring(ls->L, "'%s'", s); |
93 | 0 | else /* names, strings, and numerals */ |
94 | 0 | return s; |
95 | 0 | } |
96 | 0 | } |
97 | | |
98 | | |
99 | 0 | static const char *txtToken (LexState *ls, int token) { |
100 | 0 | switch (token) { |
101 | 0 | case TK_NAME: case TK_STRING: |
102 | 0 | case TK_FLT: case TK_INT: |
103 | 0 | save(ls, '\0'); |
104 | 0 | return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); |
105 | 0 | default: |
106 | 0 | return luaX_token2str(ls, token); |
107 | 0 | } |
108 | 0 | } |
109 | | |
110 | | |
111 | 0 | static l_noret lexerror (LexState *ls, const char *msg, int token) { |
112 | 0 | msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); |
113 | 0 | if (token) |
114 | 0 | luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); |
115 | 0 | luaD_throw(ls->L, LUA_ERRSYNTAX); |
116 | 0 | } |
117 | | |
118 | | |
119 | 0 | l_noret luaX_syntaxerror (LexState *ls, const char *msg) { |
120 | 0 | lexerror(ls, msg, ls->t.token); |
121 | 0 | } |
122 | | |
123 | | |
124 | | /* |
125 | | ** Creates a new string and anchors it in scanner's table so that it |
126 | | ** will not be collected until the end of the compilation; by that time |
127 | | ** it should be anchored somewhere. It also internalizes long strings, |
128 | | ** ensuring there is only one copy of each unique string. The table |
129 | | ** here is used as a set: the string enters as the key, while its value |
130 | | ** is irrelevant. We use the string itself as the value only because it |
131 | | ** is a TValue readily available. Later, the code generation can change |
132 | | ** this value. |
133 | | */ |
134 | 0 | TString *luaX_newstring (LexState *ls, const char *str, size_t l) { |
135 | 0 | lua_State *L = ls->L; |
136 | 0 | TString *ts = luaS_newlstr(L, str, l); /* create new string */ |
137 | 0 | const TValue *o = luaH_getstr(ls->h, ts); |
138 | 0 | if (!ttisnil(o)) /* string already present? */ |
139 | 0 | ts = keystrval(nodefromval(o)); /* get saved copy */ |
140 | 0 | else { /* not in use yet */ |
141 | 0 | TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ |
142 | 0 | setsvalue(L, stv, ts); /* temporarily anchor the string */ |
143 | 0 | luaH_finishset(L, ls->h, stv, o, stv); /* t[string] = string */ |
144 | | /* table is not a metatable, so it does not need to invalidate cache */ |
145 | 0 | luaC_checkGC(L); |
146 | 0 | L->top.p--; /* remove string from stack */ |
147 | 0 | } |
148 | 0 | return ts; |
149 | 0 | } |
150 | | |
151 | | |
152 | | /* |
153 | | ** increment line number and skips newline sequence (any of |
154 | | ** \n, \r, \n\r, or \r\n) |
155 | | */ |
156 | 0 | static void inclinenumber (LexState *ls) { |
157 | 0 | int old = ls->current; |
158 | 0 | lua_assert(currIsNewline(ls)); |
159 | 0 | next(ls); /* skip '\n' or '\r' */ |
160 | 0 | if (currIsNewline(ls) && ls->current != old) |
161 | 0 | next(ls); /* skip '\n\r' or '\r\n' */ |
162 | 0 | if (++ls->linenumber >= MAX_INT) |
163 | 0 | lexerror(ls, "chunk has too many lines", 0); |
164 | 0 | } |
165 | | |
166 | | |
167 | | void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source, |
168 | 0 | int firstchar) { |
169 | 0 | ls->t.token = 0; |
170 | 0 | ls->L = L; |
171 | 0 | ls->current = firstchar; |
172 | 0 | ls->lookahead.token = TK_EOS; /* no look-ahead token */ |
173 | 0 | ls->z = z; |
174 | 0 | ls->fs = NULL; |
175 | 0 | ls->linenumber = 1; |
176 | 0 | ls->lastline = 1; |
177 | 0 | ls->source = source; |
178 | 0 | ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ |
179 | 0 | luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ |
180 | 0 | } |
181 | | |
182 | | |
183 | | |
184 | | /* |
185 | | ** ======================================================= |
186 | | ** LEXICAL ANALYZER |
187 | | ** ======================================================= |
188 | | */ |
189 | | |
190 | | |
191 | 0 | static int check_next1 (LexState *ls, int c) { |
192 | 0 | if (ls->current == c) { |
193 | 0 | next(ls); |
194 | 0 | return 1; |
195 | 0 | } |
196 | 0 | else return 0; |
197 | 0 | } |
198 | | |
199 | | |
200 | | /* |
201 | | ** Check whether current char is in set 'set' (with two chars) and |
202 | | ** saves it |
203 | | */ |
204 | 0 | static int check_next2 (LexState *ls, const char *set) { |
205 | 0 | lua_assert(set[2] == '\0'); |
206 | 0 | if (ls->current == set[0] || ls->current == set[1]) { |
207 | 0 | save_and_next(ls); |
208 | 0 | return 1; |
209 | 0 | } |
210 | 0 | else return 0; |
211 | 0 | } |
212 | | |
213 | | |
214 | | /* LUA_NUMBER */ |
215 | | /* |
216 | | ** This function is quite liberal in what it accepts, as 'luaO_str2num' |
217 | | ** will reject ill-formed numerals. Roughly, it accepts the following |
218 | | ** pattern: |
219 | | ** |
220 | | ** %d(%x|%.|([Ee][+-]?))* | 0[Xx](%x|%.|([Pp][+-]?))* |
221 | | ** |
222 | | ** The only tricky part is to accept [+-] only after a valid exponent |
223 | | ** mark, to avoid reading '3-4' or '0xe+1' as a single number. |
224 | | ** |
225 | | ** The caller might have already read an initial dot. |
226 | | */ |
227 | 0 | static int read_numeral (LexState *ls, SemInfo *seminfo) { |
228 | 0 | TValue obj; |
229 | 0 | const char *expo = "Ee"; |
230 | 0 | int first = ls->current; |
231 | 0 | lua_assert(lisdigit(ls->current)); |
232 | 0 | save_and_next(ls); |
233 | 0 | if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ |
234 | 0 | expo = "Pp"; |
235 | 0 | for (;;) { |
236 | 0 | if (check_next2(ls, expo)) /* exponent mark? */ |
237 | 0 | check_next2(ls, "-+"); /* optional exponent sign */ |
238 | 0 | else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ |
239 | 0 | save_and_next(ls); |
240 | 0 | else break; |
241 | 0 | } |
242 | 0 | if (lislalpha(ls->current)) /* is numeral touching a letter? */ |
243 | 0 | save_and_next(ls); /* force an error */ |
244 | 0 | save(ls, '\0'); |
245 | 0 | if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ |
246 | 0 | lexerror(ls, "malformed number", TK_FLT); |
247 | 0 | if (ttisinteger(&obj)) { |
248 | 0 | seminfo->i = ivalue(&obj); |
249 | 0 | return TK_INT; |
250 | 0 | } |
251 | 0 | else { |
252 | 0 | lua_assert(ttisfloat(&obj)); |
253 | 0 | seminfo->r = fltvalue(&obj); |
254 | 0 | return TK_FLT; |
255 | 0 | } |
256 | 0 | } |
257 | | |
258 | | |
259 | | /* |
260 | | ** read a sequence '[=*[' or ']=*]', leaving the last bracket. If |
261 | | ** sequence is well formed, return its number of '='s + 2; otherwise, |
262 | | ** return 1 if it is a single bracket (no '='s and no 2nd bracket); |
263 | | ** otherwise (an unfinished '[==...') return 0. |
264 | | */ |
265 | 0 | static size_t skip_sep (LexState *ls) { |
266 | 0 | size_t count = 0; |
267 | 0 | int s = ls->current; |
268 | 0 | lua_assert(s == '[' || s == ']'); |
269 | 0 | save_and_next(ls); |
270 | 0 | while (ls->current == '=') { |
271 | 0 | save_and_next(ls); |
272 | 0 | count++; |
273 | 0 | } |
274 | 0 | return (ls->current == s) ? count + 2 |
275 | 0 | : (count == 0) ? 1 |
276 | 0 | : 0; |
277 | 0 | } |
278 | | |
279 | | |
280 | 0 | static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { |
281 | 0 | int line = ls->linenumber; /* initial line (for error message) */ |
282 | 0 | save_and_next(ls); /* skip 2nd '[' */ |
283 | 0 | if (currIsNewline(ls)) /* string starts with a newline? */ |
284 | 0 | inclinenumber(ls); /* skip it */ |
285 | 0 | for (;;) { |
286 | 0 | switch (ls->current) { |
287 | 0 | case EOZ: { /* error */ |
288 | 0 | const char *what = (seminfo ? "string" : "comment"); |
289 | 0 | const char *msg = luaO_pushfstring(ls->L, |
290 | 0 | "unfinished long %s (starting at line %d)", what, line); |
291 | 0 | lexerror(ls, msg, TK_EOS); |
292 | 0 | break; /* to avoid warnings */ |
293 | 0 | } |
294 | 0 | case ']': { |
295 | 0 | if (skip_sep(ls) == sep) { |
296 | 0 | save_and_next(ls); /* skip 2nd ']' */ |
297 | 0 | goto endloop; |
298 | 0 | } |
299 | 0 | break; |
300 | 0 | } |
301 | 0 | case '\n': case '\r': { |
302 | 0 | save(ls, '\n'); |
303 | 0 | inclinenumber(ls); |
304 | 0 | if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ |
305 | 0 | break; |
306 | 0 | } |
307 | 0 | default: { |
308 | 0 | if (seminfo) save_and_next(ls); |
309 | 0 | else next(ls); |
310 | 0 | } |
311 | 0 | } |
312 | 0 | } endloop: |
313 | 0 | if (seminfo) |
314 | 0 | seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, |
315 | 0 | luaZ_bufflen(ls->buff) - 2 * sep); |
316 | 0 | } |
317 | | |
318 | | |
319 | 0 | static void esccheck (LexState *ls, int c, const char *msg) { |
320 | 0 | if (!c) { |
321 | 0 | if (ls->current != EOZ) |
322 | 0 | save_and_next(ls); /* add current to buffer for error message */ |
323 | 0 | lexerror(ls, msg, TK_STRING); |
324 | 0 | } |
325 | 0 | } |
326 | | |
327 | | |
328 | 0 | static int gethexa (LexState *ls) { |
329 | 0 | save_and_next(ls); |
330 | 0 | esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); |
331 | 0 | return luaO_hexavalue(ls->current); |
332 | 0 | } |
333 | | |
334 | | |
335 | 0 | static int readhexaesc (LexState *ls) { |
336 | 0 | int r = gethexa(ls); |
337 | 0 | r = (r << 4) + gethexa(ls); |
338 | 0 | luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ |
339 | 0 | return r; |
340 | 0 | } |
341 | | |
342 | | |
343 | 0 | static unsigned long readutf8esc (LexState *ls) { |
344 | 0 | unsigned long r; |
345 | 0 | int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */ |
346 | 0 | save_and_next(ls); /* skip 'u' */ |
347 | 0 | esccheck(ls, ls->current == '{', "missing '{'"); |
348 | 0 | r = gethexa(ls); /* must have at least one digit */ |
349 | 0 | while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { |
350 | 0 | i++; |
351 | 0 | esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large"); |
352 | 0 | r = (r << 4) + luaO_hexavalue(ls->current); |
353 | 0 | } |
354 | 0 | esccheck(ls, ls->current == '}', "missing '}'"); |
355 | 0 | next(ls); /* skip '}' */ |
356 | 0 | luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ |
357 | 0 | return r; |
358 | 0 | } |
359 | | |
360 | | |
361 | 0 | static void utf8esc (LexState *ls) { |
362 | 0 | char buff[UTF8BUFFSZ]; |
363 | 0 | int n = luaO_utf8esc(buff, readutf8esc(ls)); |
364 | 0 | for (; n > 0; n--) /* add 'buff' to string */ |
365 | 0 | save(ls, buff[UTF8BUFFSZ - n]); |
366 | 0 | } |
367 | | |
368 | | |
369 | 0 | static int readdecesc (LexState *ls) { |
370 | 0 | int i; |
371 | 0 | int r = 0; /* result accumulator */ |
372 | 0 | for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ |
373 | 0 | r = 10*r + ls->current - '0'; |
374 | 0 | save_and_next(ls); |
375 | 0 | } |
376 | 0 | esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); |
377 | 0 | luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ |
378 | 0 | return r; |
379 | 0 | } |
380 | | |
381 | | |
382 | 0 | static void read_string (LexState *ls, int del, SemInfo *seminfo) { |
383 | 0 | save_and_next(ls); /* keep delimiter (for error messages) */ |
384 | 0 | while (ls->current != del) { |
385 | 0 | switch (ls->current) { |
386 | 0 | case EOZ: |
387 | 0 | lexerror(ls, "unfinished string", TK_EOS); |
388 | 0 | break; /* to avoid warnings */ |
389 | 0 | case '\n': |
390 | 0 | case '\r': |
391 | 0 | lexerror(ls, "unfinished string", TK_STRING); |
392 | 0 | break; /* to avoid warnings */ |
393 | 0 | case '\\': { /* escape sequences */ |
394 | 0 | int c; /* final character to be saved */ |
395 | 0 | save_and_next(ls); /* keep '\\' for error messages */ |
396 | 0 | switch (ls->current) { |
397 | 0 | case 'a': c = '\a'; goto read_save; |
398 | 0 | case 'b': c = '\b'; goto read_save; |
399 | 0 | case 'f': c = '\f'; goto read_save; |
400 | 0 | case 'n': c = '\n'; goto read_save; |
401 | 0 | case 'r': c = '\r'; goto read_save; |
402 | 0 | case 't': c = '\t'; goto read_save; |
403 | 0 | case 'v': c = '\v'; goto read_save; |
404 | 0 | case 'x': c = readhexaesc(ls); goto read_save; |
405 | 0 | case 'u': utf8esc(ls); goto no_save; |
406 | 0 | case '\n': case '\r': |
407 | 0 | inclinenumber(ls); c = '\n'; goto only_save; |
408 | 0 | case '\\': case '\"': case '\'': |
409 | 0 | c = ls->current; goto read_save; |
410 | 0 | case EOZ: goto no_save; /* will raise an error next loop */ |
411 | 0 | case 'z': { /* zap following span of spaces */ |
412 | 0 | luaZ_buffremove(ls->buff, 1); /* remove '\\' */ |
413 | 0 | next(ls); /* skip the 'z' */ |
414 | 0 | while (lisspace(ls->current)) { |
415 | 0 | if (currIsNewline(ls)) inclinenumber(ls); |
416 | 0 | else next(ls); |
417 | 0 | } |
418 | 0 | goto no_save; |
419 | 0 | } |
420 | 0 | default: { |
421 | 0 | esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); |
422 | 0 | c = readdecesc(ls); /* digital escape '\ddd' */ |
423 | 0 | goto only_save; |
424 | 0 | } |
425 | 0 | } |
426 | 0 | read_save: |
427 | 0 | next(ls); |
428 | | /* go through */ |
429 | 0 | only_save: |
430 | 0 | luaZ_buffremove(ls->buff, 1); /* remove '\\' */ |
431 | 0 | save(ls, c); |
432 | | /* go through */ |
433 | 0 | no_save: break; |
434 | 0 | } |
435 | 0 | default: |
436 | 0 | save_and_next(ls); |
437 | 0 | } |
438 | 0 | } |
439 | 0 | save_and_next(ls); /* skip delimiter */ |
440 | 0 | seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, |
441 | 0 | luaZ_bufflen(ls->buff) - 2); |
442 | 0 | } |
443 | | |
444 | | |
445 | 0 | static int llex (LexState *ls, SemInfo *seminfo) { |
446 | 0 | luaZ_resetbuffer(ls->buff); |
447 | 0 | for (;;) { |
448 | 0 | switch (ls->current) { |
449 | 0 | case '\n': case '\r': { /* line breaks */ |
450 | 0 | inclinenumber(ls); |
451 | 0 | break; |
452 | 0 | } |
453 | 0 | case ' ': case '\f': case '\t': case '\v': { /* spaces */ |
454 | 0 | next(ls); |
455 | 0 | break; |
456 | 0 | } |
457 | 0 | case '-': { /* '-' or '--' (comment) */ |
458 | 0 | next(ls); |
459 | 0 | if (ls->current != '-') return '-'; |
460 | | /* else is a comment */ |
461 | 0 | next(ls); |
462 | 0 | if (ls->current == '[') { /* long comment? */ |
463 | 0 | size_t sep = skip_sep(ls); |
464 | 0 | luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ |
465 | 0 | if (sep >= 2) { |
466 | 0 | read_long_string(ls, NULL, sep); /* skip long comment */ |
467 | 0 | luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ |
468 | 0 | break; |
469 | 0 | } |
470 | 0 | } |
471 | | /* else short comment */ |
472 | 0 | while (!currIsNewline(ls) && ls->current != EOZ) |
473 | 0 | next(ls); /* skip until end of line (or end of file) */ |
474 | 0 | break; |
475 | 0 | } |
476 | 0 | case '[': { /* long string or simply '[' */ |
477 | 0 | size_t sep = skip_sep(ls); |
478 | 0 | if (sep >= 2) { |
479 | 0 | read_long_string(ls, seminfo, sep); |
480 | 0 | return TK_STRING; |
481 | 0 | } |
482 | 0 | else if (sep == 0) /* '[=...' missing second bracket? */ |
483 | 0 | lexerror(ls, "invalid long string delimiter", TK_STRING); |
484 | 0 | return '['; |
485 | 0 | } |
486 | 0 | case '=': { |
487 | 0 | next(ls); |
488 | 0 | if (check_next1(ls, '=')) return TK_EQ; /* '==' */ |
489 | 0 | else return '='; |
490 | 0 | } |
491 | 0 | case '<': { |
492 | 0 | next(ls); |
493 | 0 | if (check_next1(ls, '=')) return TK_LE; /* '<=' */ |
494 | 0 | else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ |
495 | 0 | else return '<'; |
496 | 0 | } |
497 | 0 | case '>': { |
498 | 0 | next(ls); |
499 | 0 | if (check_next1(ls, '=')) return TK_GE; /* '>=' */ |
500 | 0 | else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ |
501 | 0 | else return '>'; |
502 | 0 | } |
503 | 0 | case '/': { |
504 | 0 | next(ls); |
505 | 0 | if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ |
506 | 0 | else return '/'; |
507 | 0 | } |
508 | 0 | case '~': { |
509 | 0 | next(ls); |
510 | 0 | if (check_next1(ls, '=')) return TK_NE; /* '~=' */ |
511 | 0 | else return '~'; |
512 | 0 | } |
513 | 0 | case ':': { |
514 | 0 | next(ls); |
515 | 0 | if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ |
516 | 0 | else return ':'; |
517 | 0 | } |
518 | 0 | case '"': case '\'': { /* short literal strings */ |
519 | 0 | read_string(ls, ls->current, seminfo); |
520 | 0 | return TK_STRING; |
521 | 0 | } |
522 | 0 | case '.': { /* '.', '..', '...', or number */ |
523 | 0 | save_and_next(ls); |
524 | 0 | if (check_next1(ls, '.')) { |
525 | 0 | if (check_next1(ls, '.')) |
526 | 0 | return TK_DOTS; /* '...' */ |
527 | 0 | else return TK_CONCAT; /* '..' */ |
528 | 0 | } |
529 | 0 | else if (!lisdigit(ls->current)) return '.'; |
530 | 0 | else return read_numeral(ls, seminfo); |
531 | 0 | } |
532 | 0 | case '0': case '1': case '2': case '3': case '4': |
533 | 0 | case '5': case '6': case '7': case '8': case '9': { |
534 | 0 | return read_numeral(ls, seminfo); |
535 | 0 | } |
536 | 0 | case EOZ: { |
537 | 0 | return TK_EOS; |
538 | 0 | } |
539 | 0 | default: { |
540 | 0 | if (lislalpha(ls->current)) { /* identifier or reserved word? */ |
541 | 0 | TString *ts; |
542 | 0 | do { |
543 | 0 | save_and_next(ls); |
544 | 0 | } while (lislalnum(ls->current)); |
545 | 0 | ts = luaX_newstring(ls, luaZ_buffer(ls->buff), |
546 | 0 | luaZ_bufflen(ls->buff)); |
547 | 0 | seminfo->ts = ts; |
548 | 0 | if (isreserved(ts)) /* reserved word? */ |
549 | 0 | return ts->extra - 1 + FIRST_RESERVED; |
550 | 0 | else { |
551 | 0 | return TK_NAME; |
552 | 0 | } |
553 | 0 | } |
554 | 0 | else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ |
555 | 0 | int c = ls->current; |
556 | 0 | next(ls); |
557 | 0 | return c; |
558 | 0 | } |
559 | 0 | } |
560 | 0 | } |
561 | 0 | } |
562 | 0 | } |
563 | | |
564 | | |
565 | 0 | void luaX_next (LexState *ls) { |
566 | 0 | ls->lastline = ls->linenumber; |
567 | 0 | if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ |
568 | 0 | ls->t = ls->lookahead; /* use this one */ |
569 | 0 | ls->lookahead.token = TK_EOS; /* and discharge it */ |
570 | 0 | } |
571 | 0 | else |
572 | 0 | ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ |
573 | 0 | } |
574 | | |
575 | | |
576 | 0 | int luaX_lookahead (LexState *ls) { |
577 | 0 | lua_assert(ls->lookahead.token == TK_EOS); |
578 | 0 | ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); |
579 | 0 | return ls->lookahead.token; |
580 | 0 | } |
581 | | |