]>
git.zerfleddert.de Git - proxmark3-svn/blob - liblua/llex.c
2 ** $Id: llex.c,v 2.63 2013/03/16 21:10:18 roberto Exp $
4 ** See Copyright Notice in lua.h
28 #define next(ls) (ls->current = zgetc(ls->z))
32 #define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
36 static const char *const luaX_tokens
[] = {
37 "and", "break", "do", "else", "elseif",
38 "end", "false", "for", "function", "goto", "if",
39 "in", "local", "nil", "not", "or", "repeat",
40 "return", "then", "true", "until", "while",
41 "..", "...", "==", ">=", "<=", "~=", "::", "<eof>",
42 "<number>", "<name>", "<string>"
46 #define save_and_next(ls) (save(ls, ls->current), next(ls))
49 static l_noret
lexerror (LexState
*ls
, const char *msg
, int token
);
52 static void save (LexState
*ls
, int c
) {
53 Mbuffer
*b
= ls
->buff
;
54 if (luaZ_bufflen(b
) + 1 > luaZ_sizebuffer(b
)) {
56 if (luaZ_sizebuffer(b
) >= MAX_SIZET
/2)
57 lexerror(ls
, "lexical element too long", 0);
58 newsize
= luaZ_sizebuffer(b
) * 2;
59 luaZ_resizebuffer(ls
->L
, b
, newsize
);
61 b
->buffer
[luaZ_bufflen(b
)++] = cast(char, c
);
65 void luaX_init (lua_State
*L
) {
67 for (i
=0; i
<NUM_RESERVED
; i
++) {
68 TString
*ts
= luaS_new(L
, luaX_tokens
[i
]);
69 luaS_fix(ts
); /* reserved words are never collected */
70 ts
->tsv
.extra
= cast_byte(i
+1); /* reserved word */
75 const char *luaX_token2str (LexState
*ls
, int token
) {
76 if (token
< FIRST_RESERVED
) { /* single-byte symbols? */
77 lua_assert(token
== cast(unsigned char, token
));
78 return (lisprint(token
)) ? luaO_pushfstring(ls
->L
, LUA_QL("%c"), token
) :
79 luaO_pushfstring(ls
->L
, "char(%d)", token
);
82 const char *s
= luaX_tokens
[token
- FIRST_RESERVED
];
83 if (token
< TK_EOS
) /* fixed format (symbols and reserved words)? */
84 return luaO_pushfstring(ls
->L
, LUA_QS
, s
);
85 else /* names, strings, and numerals */
91 static const char *txtToken (LexState
*ls
, int token
) {
97 return luaO_pushfstring(ls
->L
, LUA_QS
, luaZ_buffer(ls
->buff
));
99 return luaX_token2str(ls
, token
);
104 static l_noret
lexerror (LexState
*ls
, const char *msg
, int token
) {
105 char buff
[LUA_IDSIZE
];
106 luaO_chunkid(buff
, getstr(ls
->source
), LUA_IDSIZE
);
107 msg
= luaO_pushfstring(ls
->L
, "%s:%d: %s", buff
, ls
->linenumber
, msg
);
109 luaO_pushfstring(ls
->L
, "%s near %s", msg
, txtToken(ls
, token
));
110 luaD_throw(ls
->L
, LUA_ERRSYNTAX
);
114 l_noret
luaX_syntaxerror (LexState
*ls
, const char *msg
) {
115 lexerror(ls
, msg
, ls
->t
.token
);
120 ** creates a new string and anchors it in function's table so that
121 ** it will not be collected until the end of the function's compilation
122 ** (by that time it should be anchored in function's prototype)
124 TString
*luaX_newstring (LexState
*ls
, const char *str
, size_t l
) {
125 lua_State
*L
= ls
->L
;
126 TValue
*o
; /* entry for `str' */
127 TString
*ts
= luaS_newlstr(L
, str
, l
); /* create new string */
128 setsvalue2s(L
, L
->top
++, ts
); /* temporarily anchor it in stack */
129 o
= luaH_set(L
, ls
->fs
->h
, L
->top
- 1);
130 if (ttisnil(o
)) { /* not in use yet? (see 'addK') */
131 /* boolean value does not need GC barrier;
132 table has no metatable, so it does not need to invalidate cache */
133 setbvalue(o
, 1); /* t[string] = true */
136 L
->top
--; /* remove string from stack */
142 ** increment line number and skips newline sequence (any of
143 ** \n, \r, \n\r, or \r\n)
145 static void inclinenumber (LexState
*ls
) {
146 int old
= ls
->current
;
147 lua_assert(currIsNewline(ls
));
148 next(ls
); /* skip `\n' or `\r' */
149 if (currIsNewline(ls
) && ls
->current
!= old
)
150 next(ls
); /* skip `\n\r' or `\r\n' */
151 if (++ls
->linenumber
>= MAX_INT
)
152 luaX_syntaxerror(ls
, "chunk has too many lines");
156 void luaX_setinput (lua_State
*L
, LexState
*ls
, ZIO
*z
, TString
*source
,
160 ls
->current
= firstchar
;
161 ls
->lookahead
.token
= TK_EOS
; /* no look-ahead token */
167 ls
->envn
= luaS_new(L
, LUA_ENV
); /* create env name */
168 luaS_fix(ls
->envn
); /* never collect this name */
169 luaZ_resizebuffer(ls
->L
, ls
->buff
, LUA_MINBUFFER
); /* initialize buffer */
175 ** =======================================================
177 ** =======================================================
182 static int check_next (LexState
*ls
, const char *set
) {
183 if (ls
->current
== '\0' || !strchr(set
, ls
->current
))
191 ** change all characters 'from' in buffer to 'to'
193 static void buffreplace (LexState
*ls
, char from
, char to
) {
194 size_t n
= luaZ_bufflen(ls
->buff
);
195 char *p
= luaZ_buffer(ls
->buff
);
197 if (p
[n
] == from
) p
[n
] = to
;
201 #if !defined(getlocaledecpoint)
202 #define getlocaledecpoint() (localeconv()->decimal_point[0])
206 #define buff2d(b,e) luaO_str2d(luaZ_buffer(b), luaZ_bufflen(b) - 1, e)
209 ** in case of format error, try to change decimal point separator to
210 ** the one defined in the current locale and check again
212 static void trydecpoint (LexState
*ls
, SemInfo
*seminfo
) {
213 char old
= ls
->decpoint
;
214 ls
->decpoint
= getlocaledecpoint();
215 buffreplace(ls
, old
, ls
->decpoint
); /* try new decimal separator */
216 if (!buff2d(ls
->buff
, &seminfo
->r
)) {
217 /* format error with correct decimal point: no more options */
218 buffreplace(ls
, ls
->decpoint
, '.'); /* undo change (for error message) */
219 lexerror(ls
, "malformed number", TK_NUMBER
);
226 ** this function is quite liberal in what it accepts, as 'luaO_str2d'
227 ** will reject ill-formed numerals.
229 static void read_numeral (LexState
*ls
, SemInfo
*seminfo
) {
230 const char *expo
= "Ee";
231 int first
= ls
->current
;
232 lua_assert(lisdigit(ls
->current
));
234 if (first
== '0' && check_next(ls
, "Xx")) /* hexadecimal? */
237 if (check_next(ls
, expo
)) /* exponent part? */
238 check_next(ls
, "+-"); /* optional exponent sign */
239 if (lisxdigit(ls
->current
) || ls
->current
== '.')
244 buffreplace(ls
, '.', ls
->decpoint
); /* follow locale for decimal point */
245 if (!buff2d(ls
->buff
, &seminfo
->r
)) /* format error? */
246 trydecpoint(ls
, seminfo
); /* try to update decimal point separator */
251 ** skip a sequence '[=*[' or ']=*]' and return its number of '='s or
252 ** -1 if sequence is malformed
254 static int skip_sep (LexState
*ls
) {
257 lua_assert(s
== '[' || s
== ']');
259 while (ls
->current
== '=') {
263 return (ls
->current
== s
) ? count
: (-count
) - 1;
267 static void read_long_string (LexState
*ls
, SemInfo
*seminfo
, int sep
) {
268 save_and_next(ls
); /* skip 2nd `[' */
269 if (currIsNewline(ls
)) /* string starts with a newline? */
270 inclinenumber(ls
); /* skip it */
272 switch (ls
->current
) {
274 lexerror(ls
, (seminfo
) ? "unfinished long string" :
275 "unfinished long comment", TK_EOS
);
276 break; /* to avoid warnings */
278 if (skip_sep(ls
) == sep
) {
279 save_and_next(ls
); /* skip 2nd `]' */
284 case '\n': case '\r': {
287 if (!seminfo
) luaZ_resetbuffer(ls
->buff
); /* avoid wasting space */
291 if (seminfo
) save_and_next(ls
);
297 seminfo
->ts
= luaX_newstring(ls
, luaZ_buffer(ls
->buff
) + (2 + sep
),
298 luaZ_bufflen(ls
->buff
) - 2*(2 + sep
));
302 static void escerror (LexState
*ls
, int *c
, int n
, const char *msg
) {
304 luaZ_resetbuffer(ls
->buff
); /* prepare error message */
306 for (i
= 0; i
< n
&& c
[i
] != EOZ
; i
++)
308 lexerror(ls
, msg
, TK_STRING
);
312 static int readhexaesc (LexState
*ls
) {
313 int c
[3], i
; /* keep input for error message */
314 int r
= 0; /* result accumulator */
315 c
[0] = 'x'; /* for error message */
316 for (i
= 1; i
< 3; i
++) { /* read two hexadecimal digits */
318 if (!lisxdigit(c
[i
]))
319 escerror(ls
, c
, i
+ 1, "hexadecimal digit expected");
320 r
= (r
<< 4) + luaO_hexavalue(c
[i
]);
326 static int readdecesc (LexState
*ls
) {
328 int r
= 0; /* result accumulator */
329 for (i
= 0; i
< 3 && lisdigit(ls
->current
); i
++) { /* read up to 3 digits */
331 r
= 10*r
+ c
[i
] - '0';
335 escerror(ls
, c
, i
, "decimal escape too large");
340 static void read_string (LexState
*ls
, int del
, SemInfo
*seminfo
) {
341 save_and_next(ls
); /* keep delimiter (for error messages) */
342 while (ls
->current
!= del
) {
343 switch (ls
->current
) {
345 lexerror(ls
, "unfinished string", TK_EOS
);
346 break; /* to avoid warnings */
349 lexerror(ls
, "unfinished string", TK_STRING
);
350 break; /* to avoid warnings */
351 case '\\': { /* escape sequences */
352 int c
; /* final character to be saved */
353 next(ls
); /* do not save the `\' */
354 switch (ls
->current
) {
355 case 'a': c
= '\a'; goto read_save
;
356 case 'b': c
= '\b'; goto read_save
;
357 case 'f': c
= '\f'; goto read_save
;
358 case 'n': c
= '\n'; goto read_save
;
359 case 'r': c
= '\r'; goto read_save
;
360 case 't': c
= '\t'; goto read_save
;
361 case 'v': c
= '\v'; goto read_save
;
362 case 'x': c
= readhexaesc(ls
); goto read_save
;
363 case '\n': case '\r':
364 inclinenumber(ls
); c
= '\n'; goto only_save
;
365 case '\\': case '\"': case '\'':
366 c
= ls
->current
; goto read_save
;
367 case EOZ
: goto no_save
; /* will raise an error next loop */
368 case 'z': { /* zap following span of spaces */
369 next(ls
); /* skip the 'z' */
370 while (lisspace(ls
->current
)) {
371 if (currIsNewline(ls
)) inclinenumber(ls
);
377 if (!lisdigit(ls
->current
))
378 escerror(ls
, &ls
->current
, 1, "invalid escape sequence");
379 /* digital escape \ddd */
384 read_save
: next(ls
); /* read next character */
385 only_save
: save(ls
, c
); /* save 'c' */
392 save_and_next(ls
); /* skip delimiter */
393 seminfo
->ts
= luaX_newstring(ls
, luaZ_buffer(ls
->buff
) + 1,
394 luaZ_bufflen(ls
->buff
) - 2);
398 static int llex (LexState
*ls
, SemInfo
*seminfo
) {
399 luaZ_resetbuffer(ls
->buff
);
401 switch (ls
->current
) {
402 case '\n': case '\r': { /* line breaks */
406 case ' ': case '\f': case '\t': case '\v': { /* spaces */
410 case '-': { /* '-' or '--' (comment) */
412 if (ls
->current
!= '-') return '-';
413 /* else is a comment */
415 if (ls
->current
== '[') { /* long comment? */
416 int sep
= skip_sep(ls
);
417 luaZ_resetbuffer(ls
->buff
); /* `skip_sep' may dirty the buffer */
419 read_long_string(ls
, NULL
, sep
); /* skip long comment */
420 luaZ_resetbuffer(ls
->buff
); /* previous call may dirty the buff. */
424 /* else short comment */
425 while (!currIsNewline(ls
) && ls
->current
!= EOZ
)
426 next(ls
); /* skip until end of line (or end of file) */
429 case '[': { /* long string or simply '[' */
430 int sep
= skip_sep(ls
);
432 read_long_string(ls
, seminfo
, sep
);
435 else if (sep
== -1) return '[';
436 else lexerror(ls
, "invalid long string delimiter", TK_STRING
);
440 if (ls
->current
!= '=') return '=';
441 else { next(ls
); return TK_EQ
; }
445 if (ls
->current
!= '=') return '<';
446 else { next(ls
); return TK_LE
; }
450 if (ls
->current
!= '=') return '>';
451 else { next(ls
); return TK_GE
; }
455 if (ls
->current
!= '=') return '~';
456 else { next(ls
); return TK_NE
; }
460 if (ls
->current
!= ':') return ':';
461 else { next(ls
); return TK_DBCOLON
; }
463 case '"': case '\'': { /* short literal strings */
464 read_string(ls
, ls
->current
, seminfo
);
467 case '.': { /* '.', '..', '...', or number */
469 if (check_next(ls
, ".")) {
470 if (check_next(ls
, "."))
471 return TK_DOTS
; /* '...' */
472 else return TK_CONCAT
; /* '..' */
474 else if (!lisdigit(ls
->current
)) return '.';
475 /* else go through */
477 case '0': case '1': case '2': case '3': case '4':
478 case '5': case '6': case '7': case '8': case '9': {
479 read_numeral(ls
, seminfo
);
486 if (lislalpha(ls
->current
)) { /* identifier or reserved word? */
490 } while (lislalnum(ls
->current
));
491 ts
= luaX_newstring(ls
, luaZ_buffer(ls
->buff
),
492 luaZ_bufflen(ls
->buff
));
494 if (isreserved(ts
)) /* reserved word? */
495 return ts
->tsv
.extra
- 1 + FIRST_RESERVED
;
500 else { /* single-char tokens (+ - / ...) */
511 void luaX_next (LexState
*ls
) {
512 ls
->lastline
= ls
->linenumber
;
513 if (ls
->lookahead
.token
!= TK_EOS
) { /* is there a look-ahead token? */
514 ls
->t
= ls
->lookahead
; /* use this one */
515 ls
->lookahead
.token
= TK_EOS
; /* and discharge it */
518 ls
->t
.token
= llex(ls
, &ls
->t
.seminfo
); /* read next token */
522 int luaX_lookahead (LexState
*ls
) {
523 lua_assert(ls
->lookahead
.token
== TK_EOS
);
524 ls
->lookahead
.token
= llex(ls
, &ls
->lookahead
.seminfo
);
525 return ls
->lookahead
.token
;