lua/llex.c

454 lines
12 KiB
C
Raw Normal View History

1997-09-17 03:25:59 +08:00
/*
** $Id: llex.c,v 2.30 2009/02/11 18:25:20 roberto Exp roberto $
1999-02-26 05:07:26 +08:00
** Lexical Analyzer
1997-09-17 03:25:59 +08:00
** See Copyright Notice in lua.h
*/
1993-12-23 05:15:16 +08:00
#include <locale.h>
#include <string.h>
1993-12-23 05:15:16 +08:00
2002-12-05 01:38:31 +08:00
#define llex_c
#define LUA_CORE
2002-12-05 01:38:31 +08:00
#include "lua.h"
#include "lctype.h"
#include "ldo.h"
1997-09-17 03:25:59 +08:00
#include "llex.h"
#include "lobject.h"
#include "lparser.h"
#include "lstate.h"
1997-09-17 03:25:59 +08:00
#include "lstring.h"
#include "ltable.h"
1997-09-17 03:25:59 +08:00
#include "lzio.h"
1993-12-23 05:15:16 +08:00
#define next(ls) (ls->current = zgetc(ls->z))
1997-09-17 03:25:59 +08:00
1997-09-17 03:25:59 +08:00
#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
1998-05-27 21:08:34 +08:00
1999-07-23 03:29:42 +08:00
/* ORDER RESERVED */
static const char *const luaX_tokens [] = {
"and", "break", "do", "else", "elseif",
2002-09-03 19:57:38 +08:00
"end", "false", "for", "function", "if",
"in", "local", "nil", "not", "or", "repeat",
2004-12-04 04:54:12 +08:00
"return", "then", "true", "until", "while",
"..", "...", "==", ">=", "<=", "~=", "<eof>",
"<number>", "<name>", "<string>"
2001-02-24 01:17:25 +08:00
};
1998-05-27 21:08:34 +08:00
1997-09-17 03:25:59 +08:00
#define save_and_next(ls) (save(ls, ls->current), next(ls))
2007-10-26 00:45:47 +08:00
static void lexerror (LexState *ls, const char *msg, int token);
static void save (LexState *ls, int c) {
Mbuffer *b = ls->buff;
if (b->n + 1 > b->buffsize) {
size_t newsize;
if (b->buffsize >= MAX_SIZET/2)
2007-10-26 00:45:47 +08:00
lexerror(ls, "lexical element too long", 0);
newsize = b->buffsize * 2;
luaZ_resizebuffer(ls->L, b, newsize);
}
b->buffer[b->n++] = cast(char, c);
}
void luaX_init (lua_State *L) {
2000-03-03 22:58:26 +08:00
int i;
2000-02-09 00:39:42 +08:00
for (i=0; i<NUM_RESERVED; i++) {
2004-12-02 20:59:10 +08:00
TString *ts = luaS_new(L, luaX_tokens[i]);
luaS_fix(ts); /* reserved words are never collected */
2004-12-02 20:59:10 +08:00
lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);
2005-12-23 00:19:56 +08:00
ts->tsv.reserved = cast_byte(i+1); /* reserved word */
1998-05-27 21:08:34 +08:00
}
}
2003-09-05 04:00:28 +08:00
const char *luaX_token2str (LexState *ls, int token) {
if (token < FIRST_RESERVED) {
2004-11-25 03:16:03 +08:00
lua_assert(token == cast(unsigned char, token));
return (lisprint(token)) ? luaO_pushfstring(ls->L, LUA_QL("%c"), token) :
2007-08-10 04:29:15 +08:00
luaO_pushfstring(ls->L, "char(%d)", token);
}
else {
const char *s = luaX_tokens[token - FIRST_RESERVED];
if (token < TK_EOS)
return luaO_pushfstring(ls->L, LUA_QS, s);
else
return s;
2003-09-05 04:00:28 +08:00
}
}
static const char *txtToken (LexState *ls, int token) {
switch (token) {
case TK_NAME:
case TK_STRING:
case TK_NUMBER:
save(ls, '\0');
return luaO_pushfstring(ls->L, LUA_QS, luaZ_buffer(ls->buff));
default:
2003-09-05 04:00:28 +08:00
return luaX_token2str(ls, token);
1997-09-17 03:25:59 +08:00
}
1998-05-27 21:08:34 +08:00
}
2007-10-26 00:45:47 +08:00
static void lexerror (LexState *ls, const char *msg, int token) {
2008-12-26 19:55:57 +08:00
char buff[LUA_IDSIZE];
luaO_chunkid(buff, getstr(ls->source), LUA_IDSIZE);
2004-03-13 03:53:56 +08:00
msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
if (token)
luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
luaD_throw(ls->L, LUA_ERRSYNTAX);
}
2003-09-05 04:00:28 +08:00
void luaX_syntaxerror (LexState *ls, const char *msg) {
2007-10-26 00:45:47 +08:00
lexerror(ls, msg, ls->t.token);
1997-09-17 03:25:59 +08:00
}
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
lua_State *L = ls->L;
TValue *o; /* entry for `str' */
2003-08-28 05:01:44 +08:00
TString *ts = luaS_newlstr(L, str, l);
setsvalue2s(L, L->top++, ts); /* anchor string */
o = luaH_setstr(L, ls->fs->h, ts);
2003-08-28 05:01:44 +08:00
if (ttisnil(o))
setbvalue(o, 1); /* make sure `str' will not be collected */
L->top--;
2003-08-28 05:01:44 +08:00
return ts;
}
static void inclinenumber (LexState *ls) {
int old = ls->current;
lua_assert(currIsNewline(ls));
next(ls); /* skip `\n' or `\r' */
if (currIsNewline(ls) && ls->current != old)
next(ls); /* skip `\n\r' or `\r\n' */
2004-03-13 03:53:56 +08:00
if (++ls->linenumber >= MAX_INT)
luaX_syntaxerror(ls, "chunk has too many lines");
2000-05-26 22:04:04 +08:00
}
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
ls->decpoint = '.';
ls->L = L;
ls->lookahead.token = TK_EOS; /* no look-ahead token */
ls->z = z;
ls->fs = NULL;
ls->linenumber = 1;
ls->lastline = 1;
ls->source = source;
luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
next(ls); /* read first char */
2000-05-26 22:04:04 +08:00
}
1997-09-17 03:25:59 +08:00
/*
** =======================================================
1999-12-15 02:33:29 +08:00
** LEXICAL ANALYZER
1997-09-17 03:25:59 +08:00
** =======================================================
*/
2000-09-12 01:38:42 +08:00
static int check_next (LexState *ls, const char *set) {
if (ls->current == '\0' || !strchr(set, ls->current))
return 0;
save_and_next(ls);
return 1;
}
static void buffreplace (LexState *ls, char from, char to) {
2006-02-07 02:28:16 +08:00
size_t n = luaZ_bufflen(ls->buff);
char *p = luaZ_buffer(ls->buff);
while (n--)
if (p[n] == from) p[n] = to;
}
#if !defined(getlocaledecpoint)
#define getlocaledecpoint() (localeconv()->decimal_point[0])
#endif
static void trydecpoint (LexState *ls, SemInfo *seminfo) {
/* format error: try to update decimal point separator */
char old = ls->decpoint;
ls->decpoint = getlocaledecpoint();
buffreplace(ls, old, ls->decpoint); /* try updated decimal separator */
if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {
/* format error with correct decimal point: no more options */
buffreplace(ls, ls->decpoint, '.'); /* undo change (for error message) */
2007-10-26 00:45:47 +08:00
lexerror(ls, "malformed number", TK_NUMBER);
}
}
2000-09-12 01:38:42 +08:00
/* LUA_NUMBER */
static void read_numeral (LexState *ls, SemInfo *seminfo) {
lua_assert(lisdigit(ls->current));
do {
save_and_next(ls);
} while (lisdigit(ls->current) || ls->current == '.');
2006-01-24 04:06:19 +08:00
if (check_next(ls, "Ee")) /* `E'? */
check_next(ls, "+-"); /* optional exponent sign */
while (lisalnum(ls->current) || ls->current == '_')
2006-01-24 04:06:19 +08:00
save_and_next(ls);
save(ls, '\0');
buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */
if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) /* format error? */
trydecpoint(ls, seminfo); /* try to update decimal point separator */
2000-09-12 01:38:42 +08:00
}
static int skip_sep (LexState *ls) {
int count = 0;
int s = ls->current;
lua_assert(s == '[' || s == ']');
save_and_next(ls);
while (ls->current == '=') {
save_and_next(ls);
count++;
}
return (ls->current == s) ? count : (-count) - 1;
}
static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
save_and_next(ls); /* skip 2nd `[' */
if (currIsNewline(ls)) /* string starts with a newline? */
inclinenumber(ls); /* skip it */
1998-12-03 23:45:15 +08:00
for (;;) {
switch (ls->current) {
1997-06-17 00:50:22 +08:00
case EOZ:
2007-10-26 00:45:47 +08:00
lexerror(ls, (seminfo) ? "unfinished long string" :
"unfinished long comment", TK_EOS);
2000-01-26 02:44:21 +08:00
break; /* to avoid warnings */
case ']': {
if (skip_sep(ls) == sep) {
save_and_next(ls); /* skip 2nd `]' */
goto endloop;
}
break;
}
case '\n':
case '\r': {
save(ls, '\n');
inclinenumber(ls);
if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
break;
}
default: {
if (seminfo) save_and_next(ls);
else next(ls);
}
}
} endloop:
2002-03-09 03:07:01 +08:00
if (seminfo)
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
luaZ_bufflen(ls->buff) - 2*(2 + sep));
2000-01-26 02:44:21 +08:00
}
static void read_string (LexState *ls, int del, SemInfo *seminfo) {
save_and_next(ls);
while (ls->current != del) {
switch (ls->current) {
case EOZ:
2007-10-26 00:45:47 +08:00
lexerror(ls, "unfinished string", TK_EOS);
continue; /* to avoid warnings */
case '\n':
case '\r':
2007-10-26 00:45:47 +08:00
lexerror(ls, "unfinished string", TK_STRING);
continue; /* to avoid warnings */
case '\\': {
int c;
next(ls); /* do not save the `\' */
switch (ls->current) {
case 'a': c = '\a'; break;
case 'b': c = '\b'; break;
case 'f': c = '\f'; break;
case 'n': c = '\n'; break;
case 'r': c = '\r'; break;
case 't': c = '\t'; break;
case 'v': c = '\v'; break;
case '\n':
case '\r': save(ls, '\n'); inclinenumber(ls); continue;
case EOZ: continue; /* will raise an error next loop */
2001-02-24 01:17:25 +08:00
default: {
if (!lisdigit(ls->current))
save_and_next(ls); /* handles \\, \", \', and \? */
2001-02-24 01:17:25 +08:00
else { /* \xxx */
int i = 0;
c = 0;
2001-02-24 01:17:25 +08:00
do {
c = 10*c + (ls->current-'0');
next(ls);
} while (++i<3 && lisdigit(ls->current));
if (c > UCHAR_MAX)
2007-10-26 00:45:47 +08:00
lexerror(ls, "escape sequence too large", TK_STRING);
save(ls, c);
2000-09-12 01:38:42 +08:00
}
continue;
2000-01-26 02:44:21 +08:00
}
}
save(ls, c);
next(ls);
continue;
}
2000-01-26 02:44:21 +08:00
default:
save_and_next(ls);
2000-01-26 02:44:21 +08:00
}
}
save_and_next(ls); /* skip delimiter */
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
luaZ_bufflen(ls->buff) - 2);
}
1997-09-17 03:25:59 +08:00
2005-12-07 23:43:05 +08:00
static int llex (LexState *ls, SemInfo *seminfo) {
luaZ_resetbuffer(ls->buff);
1998-12-03 23:45:15 +08:00
for (;;) {
switch (ls->current) {
case '\n':
case '\r': {
inclinenumber(ls);
1998-01-09 22:44:55 +08:00
continue;
}
case '-': {
next(ls);
if (ls->current != '-') return '-';
2002-03-09 03:07:01 +08:00
/* else is a comment */
next(ls);
if (ls->current == '[') {
int sep = skip_sep(ls);
luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */
if (sep >= 0) {
read_long_string(ls, NULL, sep); /* long comment */
luaZ_resetbuffer(ls->buff);
continue;
}
}
/* else short comment */
while (!currIsNewline(ls) && ls->current != EOZ)
next(ls);
1993-12-23 05:15:16 +08:00
continue;
}
case '[': {
int sep = skip_sep(ls);
if (sep >= 0) {
read_long_string(ls, seminfo, sep);
2000-03-11 02:37:44 +08:00
return TK_STRING;
}
else if (sep == -1) return '[';
2007-10-26 00:45:47 +08:00
else lexerror(ls, "invalid long string delimiter", TK_STRING);
}
case '=': {
next(ls);
if (ls->current != '=') return '=';
else { next(ls); return TK_EQ; }
}
case '<': {
next(ls);
if (ls->current != '=') return '<';
else { next(ls); return TK_LE; }
}
case '>': {
next(ls);
if (ls->current != '=') return '>';
else { next(ls); return TK_GE; }
}
case '~': {
next(ls);
if (ls->current != '=') return '~';
else { next(ls); return TK_NE; }
}
case '"':
case '\'': {
read_string(ls, ls->current, seminfo);
2000-03-11 02:37:44 +08:00
return TK_STRING;
}
case '.': {
save_and_next(ls);
if (check_next(ls, ".")) {
if (check_next(ls, "."))
2000-03-11 02:37:44 +08:00
return TK_DOTS; /* ... */
2000-04-07 21:11:49 +08:00
else return TK_CONCAT; /* .. */
1993-12-23 05:15:16 +08:00
}
else if (!lisdigit(ls->current)) return '.';
2000-09-12 01:38:42 +08:00
else {
read_numeral(ls, seminfo);
2000-09-12 01:38:42 +08:00
return TK_NUMBER;
}
}
case EOZ: {
2000-03-11 02:37:44 +08:00
return TK_EOS;
}
2001-02-24 01:17:25 +08:00
default: {
if (lisspace(ls->current)) {
lua_assert(!currIsNewline(ls));
next(ls);
continue;
}
else if (lisdigit(ls->current)) {
read_numeral(ls, seminfo);
2001-02-24 01:17:25 +08:00
return TK_NUMBER;
1997-07-02 03:32:41 +08:00
}
else if (lisalpha(ls->current) || ls->current == '_') {
2001-02-24 01:17:25 +08:00
/* identifier or reserved word */
TString *ts;
do {
save_and_next(ls);
} while (lisalnum(ls->current) || ls->current == '_');
ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
luaZ_bufflen(ls->buff));
if (ts->tsv.reserved > 0) /* reserved word? */
return ts->tsv.reserved - 1 + FIRST_RESERVED;
2003-09-05 04:00:28 +08:00
else {
seminfo->ts = ts;
return TK_NAME;
}
1997-07-02 03:32:41 +08:00
}
2001-02-24 01:17:25 +08:00
else {
int c = ls->current;
next(ls);
2001-02-24 01:17:25 +08:00
return c; /* single-char tokens (+ - / ...) */
}
}
1993-12-23 05:15:16 +08:00
}
}
}
2005-12-07 23:43:05 +08:00
void luaX_next (LexState *ls) {
ls->lastline = ls->linenumber;
if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */
ls->t = ls->lookahead; /* use this one */
ls->lookahead.token = TK_EOS; /* and discharge it */
}
else
ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */
}
2007-05-12 01:28:56 +08:00
int luaX_lookahead (LexState *ls) {
2005-12-07 23:43:05 +08:00
lua_assert(ls->lookahead.token == TK_EOS);
ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
2007-05-12 01:28:56 +08:00
return ls->lookahead.token;
2005-12-07 23:43:05 +08:00
}