diff --git a/lapi.c b/lapi.c index ffeaf285..91cea50c 100644 --- a/lapi.c +++ b/lapi.c @@ -1,5 +1,5 @@ /* -** $Id: lapi.c,v 1.159 2001/10/31 19:58:11 roberto Exp $ +** $Id: lapi.c,v 1.160 2001/11/16 16:29:51 roberto Exp $ ** Lua API ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include -#define LUA_PRIVATE #include "lua.h" #include "lapi.h" @@ -23,10 +22,10 @@ #include "lvm.h" -const l_char lua_ident[] = - l_s("$Lua: ") l_s(LUA_VERSION) l_s(" ") l_s(LUA_COPYRIGHT) l_s(" $\n") - l_s("$Authors: ") l_s(LUA_AUTHORS) l_s(" $\n") - l_s("$URL: www.lua.org $\n"); +const char lua_ident[] = + "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n" + "$Authors: " LUA_AUTHORS " $\n" + "$URL: www.lua.org $\n"; @@ -156,12 +155,12 @@ LUA_API int lua_rawtag (lua_State *L, int index) { } -LUA_API const l_char *lua_type (lua_State *L, int index) { +LUA_API const char *lua_type (lua_State *L, int index) { StkId o; - const l_char *type; + const char *type; lua_lock(L); o = luaA_indexAcceptable(L, index); - type = (o == NULL) ? l_s("no value") : luaT_typename(G(L), o); + type = (o == NULL) ? "no value" : luaT_typename(G(L), o); lua_unlock(L); return type; } @@ -230,14 +229,14 @@ LUA_API lua_Number lua_tonumber (lua_State *L, int index) { } -LUA_API const l_char *lua_tostring (lua_State *L, int index) { +LUA_API const char *lua_tostring (lua_State *L, int index) { StkId o = luaA_indexAcceptable(L, index); if (o == NULL) return NULL; else if (ttype(o) == LUA_TSTRING) return svalue(o); else { - const l_char *s; + const char *s; lua_lock(L); /* `luaV_tostring' may create a new string */ s = (luaV_tostring(L, o) == 0) ? svalue(o) : NULL; lua_unlock(L); @@ -309,7 +308,7 @@ LUA_API void lua_pushnumber (lua_State *L, lua_Number n) { } -LUA_API void lua_pushlstring (lua_State *L, const l_char *s, size_t len) { +LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) { lua_lock(L); setsvalue(L->top, luaS_newlstr(L, s, len)); api_incr_top(L); @@ -317,7 +316,7 @@ LUA_API void lua_pushlstring (lua_State *L, const l_char *s, size_t len) { } -LUA_API void lua_pushstring (lua_State *L, const l_char *s) { +LUA_API void lua_pushstring (lua_State *L, const char *s) { if (s == NULL) lua_pushnil(L); else @@ -346,7 +345,7 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { */ -LUA_API void lua_getglobal (lua_State *L, const l_char *name) { +LUA_API void lua_getglobal (lua_State *L, const char *name) { lua_lock(L); luaV_getglobal(L, luaS_new(L, name), L->top); api_incr_top(L); @@ -398,7 +397,7 @@ LUA_API void lua_newtable (lua_State *L) { */ -LUA_API void lua_setglobal (lua_State *L, const l_char *name) { +LUA_API void lua_setglobal (lua_State *L, const char *name) { lua_lock(L); api_checknelems(L, 1); luaV_setglobal(L, luaS_new(L, name), L->top - 1); @@ -470,7 +469,7 @@ LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults) { } -LUA_API int lua_dofile (lua_State *L, const l_char *filename) { +LUA_API int lua_dofile (lua_State *L, const char *filename) { int status; status = lua_loadfile(L, filename); if (status == 0) /* parse OK? */ @@ -479,8 +478,8 @@ LUA_API int lua_dofile (lua_State *L, const l_char *filename) { } -LUA_API int lua_dobuffer (lua_State *L, const l_char *buff, size_t size, - const l_char *name) { +LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, + const char *name) { int status; status = lua_loadbuffer(L, buff, size, name); if (status == 0) /* parse OK? */ @@ -489,7 +488,7 @@ LUA_API int lua_dobuffer (lua_State *L, const l_char *buff, size_t size, } -LUA_API int lua_dostring (lua_State *L, const l_char *str) { +LUA_API int lua_dostring (lua_State *L, const char *str) { return lua_dobuffer(L, str, strlen(str), str); } @@ -534,22 +533,22 @@ LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) { ** miscellaneous functions */ -LUA_API int lua_newtype (lua_State *L, const l_char *name, int basictype) { +LUA_API int lua_newtype (lua_State *L, const char *name, int basictype) { int tag; lua_lock(L); if (basictype != LUA_TNONE && basictype != LUA_TTABLE && basictype != LUA_TUSERDATA) - luaO_verror(L, l_s("invalid basic type (%d) for new type"), basictype); + luaO_verror(L, "invalid basic type (%d) for new type", basictype); tag = luaT_newtag(L, name, basictype); if (tag == LUA_TNONE) - luaO_verror(L, l_s("type name '%.30s' already exists"), name); + luaO_verror(L, "type name '%.30s' already exists", name); lua_unlock(L); return tag; } -LUA_API int lua_name2tag (lua_State *L, const l_char *name) { +LUA_API int lua_name2tag (lua_State *L, const char *name) { int tag; const TObject *v; lua_lock(L); @@ -565,10 +564,10 @@ LUA_API int lua_name2tag (lua_State *L, const l_char *name) { } -LUA_API const l_char *lua_tag2name (lua_State *L, int tag) { - const l_char *s; +LUA_API const char *lua_tag2name (lua_State *L, int tag) { + const char *s; lua_lock(L); - s = (tag == LUA_TNONE) ? l_s("no value") : typenamebytag(G(L), tag); + s = (tag == LUA_TNONE) ? "no value" : typenamebytag(G(L), tag); lua_unlock(L); return s; } @@ -579,10 +578,10 @@ LUA_API void lua_settag (lua_State *L, int tag) { lua_lock(L); api_checknelems(L, 1); if (tag < 0 || tag >= G(L)->ntag) - luaO_verror(L, l_s("%d is not a valid tag"), tag); + luaO_verror(L, "%d is not a valid tag", tag); basictype = G(L)->TMtable[tag].basictype; if (basictype != LUA_TNONE && basictype != ttype(L->top-1)) - luaO_verror(L, l_s("tag %d can only be used for type '%.20s'"), tag, + luaO_verror(L, "tag %d can only be used for type '%.20s'", tag, typenamebytag(G(L), basictype)); switch (ttype(L->top-1)) { case LUA_TTABLE: @@ -592,14 +591,14 @@ LUA_API void lua_settag (lua_State *L, int tag) { uvalue(L->top-1)->uv.tag = tag; break; default: - luaO_verror(L, l_s("cannot change the tag of a %.20s"), + luaO_verror(L, "cannot change the tag of a %.20s", luaT_typename(G(L), L->top-1)); } lua_unlock(L); } -LUA_API void lua_error (lua_State *L, const l_char *s) { +LUA_API void lua_error (lua_State *L, const char *s) { lua_lock(L); luaD_error(L, s); lua_unlock(L); @@ -630,7 +629,7 @@ LUA_API int lua_getn (lua_State *L, int index) { lua_lock(L); t = luaA_index(L, index); api_check(L, ttype(t) == LUA_TTABLE); - value = luaH_getstr(hvalue(t), luaS_newliteral(L, l_s("n"))); /* = t.n */ + value = luaH_getstr(hvalue(t), luaS_newliteral(L, "n")); /* = t.n */ if (ttype(value) == LUA_TNUMBER) n = cast(int, nvalue(value)); else { @@ -734,7 +733,7 @@ LUA_API void lua_pushupvalues (lua_State *L) { api_check(L, iscfunction(func)); n = clvalue(func)->c.nupvalues; if (LUA_MINSTACK+n > lua_stackspace(L)) - luaD_error(L, l_s("stack overflow")); + luaD_error(L, "stack overflow"); for (i=0; itop, &clvalue(func)->c.upvalue[i]); L->top++; diff --git a/lauxlib.c b/lauxlib.c index 7fef8721..1189af50 100644 --- a/lauxlib.c +++ b/lauxlib.c @@ -1,5 +1,5 @@ /* -** $Id: lauxlib.c,v 1.52 2001/10/26 17:33:30 roberto Exp $ +** $Id: lauxlib.c,v 1.53 2001/10/31 19:40:14 roberto Exp $ ** Auxiliary functions for building Lua libraries ** See Copyright Notice in lua.h */ @@ -14,7 +14,6 @@ ** With care, these functions can be used by other libraries. */ -#define LUA_PRIVATE #include "lua.h" #include "lauxlib.h" @@ -23,7 +22,7 @@ -LUALIB_API int luaL_findstring (const l_char *name, const l_char *const list[]) { +LUALIB_API int luaL_findstring (const char *name, const char *const list[]) { int i; for (i=0; list[i]; i++) if (strcmp(list[i], name) == 0) @@ -31,20 +30,20 @@ LUALIB_API int luaL_findstring (const l_char *name, const l_char *const list[]) return -1; /* name not found */ } -LUALIB_API void luaL_argerror (lua_State *L, int narg, const l_char *extramsg) { +LUALIB_API void luaL_argerror (lua_State *L, int narg, const char *extramsg) { lua_Debug ar; lua_getstack(L, 0, &ar); - lua_getinfo(L, l_s("n"), &ar); + lua_getinfo(L, "n", &ar); if (ar.name == NULL) - ar.name = l_s("?"); - luaL_verror(L, l_s("bad argument #%d to `%.50s' (%.100s)"), + ar.name = "?"; + luaL_verror(L, "bad argument #%d to `%.50s' (%.100s)", narg, ar.name, extramsg); } -LUALIB_API void luaL_typerror (lua_State *L, int narg, const l_char *tname) { - l_char buff[80]; - sprintf(buff, l_s("%.25s expected, got %.25s"), tname, lua_type(L,narg)); +LUALIB_API void luaL_typerror (lua_State *L, int narg, const char *tname) { + char buff[80]; + sprintf(buff, "%.25s expected, got %.25s", tname, lua_type(L,narg)); luaL_argerror(L, narg, buff); } @@ -54,9 +53,9 @@ static void tag_error (lua_State *L, int narg, int tag) { } -LUALIB_API void luaL_check_stack (lua_State *L, int space, const l_char *mes) { +LUALIB_API void luaL_check_stack (lua_State *L, int space, const char *mes) { if (space > lua_stackspace(L)) - luaL_verror(L, l_s("stack overflow (%.30s)"), mes); + luaL_verror(L, "stack overflow (%.30s)", mes); } @@ -68,27 +67,27 @@ LUALIB_API void luaL_check_rawtype(lua_State *L, int narg, int t) { LUALIB_API void luaL_check_any (lua_State *L, int narg) { if (lua_rawtag(L, narg) == LUA_TNONE) - luaL_argerror(L, narg, l_s("value expected")); + luaL_argerror(L, narg, "value expected"); } LUALIB_API void *luaL_check_userdata (lua_State *L, int narg, - const l_char *name) { + const char *name) { if (strcmp(lua_type(L, narg), name) != 0) luaL_typerror(L, narg, name); return lua_touserdata(L, narg); } -LUALIB_API const l_char *luaL_check_lstr (lua_State *L, int narg, size_t *len) { - const l_char *s = lua_tostring(L, narg); +LUALIB_API const char *luaL_check_lstr (lua_State *L, int narg, size_t *len) { + const char *s = lua_tostring(L, narg); if (!s) tag_error(L, narg, LUA_TSTRING); if (len) *len = lua_strlen(L, narg); return s; } -LUALIB_API const l_char *luaL_opt_lstr (lua_State *L, int narg, const l_char *def, size_t *len) { +LUALIB_API const char *luaL_opt_lstr (lua_State *L, int narg, const char *def, size_t *len) { if (lua_isnull(L, narg)) { if (len) *len = (def ? strlen(def) : 0); @@ -119,8 +118,8 @@ LUALIB_API void luaL_openlib (lua_State *L, const luaL_reg *l, int n) { } -LUALIB_API void luaL_verror (lua_State *L, const l_char *fmt, ...) { - l_char buff[500]; +LUALIB_API void luaL_verror (lua_State *L, const char *fmt, ...) { + char buff[500]; va_list argp; va_start(argp, fmt); vsprintf(buff, fmt, argp); @@ -174,20 +173,20 @@ static void adjuststack (luaL_Buffer *B) { } -LUALIB_API l_char *luaL_prepbuffer (luaL_Buffer *B) { +LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) { if (emptybuffer(B)) adjuststack(B); return B->buffer; } -LUALIB_API void luaL_addlstring (luaL_Buffer *B, const l_char *s, size_t l) { +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { while (l--) luaL_putchar(B, *s++); } -LUALIB_API void luaL_addstring (luaL_Buffer *B, const l_char *s) { +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { luaL_addlstring(B, s, strlen(s)); } @@ -236,7 +235,7 @@ LUALIB_API int luaL_ref (lua_State *L, int t) { } else { /* no free elements */ ref = lua_getn(L, t) + 1; /* use next `n' */ - lua_pushliteral(L, l_s("n")); + lua_pushliteral(L, "n"); lua_pushnumber(L, ref); lua_settable(L, t); /* n = n+1 */ } diff --git a/lauxlib.h b/lauxlib.h index 9bc51695..43405bf2 100644 --- a/lauxlib.h +++ b/lauxlib.h @@ -1,5 +1,5 @@ /* -** $Id: lauxlib.h,v 1.37 2001/10/26 17:33:30 roberto Exp $ +** $Id: lauxlib.h,v 1.38 2001/10/31 19:40:14 roberto Exp $ ** Auxiliary functions for building Lua libraries ** See Copyright Notice in lua.h */ @@ -21,31 +21,31 @@ typedef struct luaL_reg { - const lua_char *name; + const char *name; lua_CFunction func; } luaL_reg; LUALIB_API void luaL_openlib (lua_State *L, const luaL_reg *l, int n); -LUALIB_API void luaL_typerror (lua_State *L, int narg, const lua_char *tname); +LUALIB_API void luaL_typerror (lua_State *L, int narg, const char *tname); LUALIB_API void luaL_argerror (lua_State *L, int numarg, - const lua_char *extramsg); -LUALIB_API const lua_char *luaL_check_lstr (lua_State *L, int numArg, + const char *extramsg); +LUALIB_API const char *luaL_check_lstr (lua_State *L, int numArg, size_t *len); -LUALIB_API const lua_char *luaL_opt_lstr (lua_State *L, int numArg, - const lua_char *def, size_t *len); +LUALIB_API const char *luaL_opt_lstr (lua_State *L, int numArg, + const char *def, size_t *len); LUALIB_API lua_Number luaL_check_number (lua_State *L, int numArg); LUALIB_API lua_Number luaL_opt_number (lua_State *L, int nArg, lua_Number def); -LUALIB_API void luaL_check_stack (lua_State *L, int space, const lua_char *msg); +LUALIB_API void luaL_check_stack (lua_State *L, int space, const char *msg); LUALIB_API void luaL_check_rawtype (lua_State *L, int narg, int t); LUALIB_API void luaL_check_any (lua_State *L, int narg); LUALIB_API void *luaL_check_userdata (lua_State *L, int narg, - const lua_char *name); + const char *name); -LUALIB_API void luaL_verror (lua_State *L, const lua_char *fmt, ...); -LUALIB_API int luaL_findstring (const lua_char *name, - const lua_char *const list[]); +LUALIB_API void luaL_verror (lua_State *L, const char *fmt, ...); +LUALIB_API int luaL_findstring (const char *name, + const char *const list[]); LUALIB_API int luaL_ref (lua_State *L, int t); LUALIB_API void luaL_unref (lua_State *L, int t, int ref); @@ -81,22 +81,22 @@ LUALIB_API void luaL_unref (lua_State *L, int t, int ref); typedef struct luaL_Buffer { - lua_char *p; /* current position in buffer */ + char *p; /* current position in buffer */ int level; lua_State *L; - lua_char buffer[LUAL_BUFFERSIZE]; + char buffer[LUAL_BUFFERSIZE]; } luaL_Buffer; #define luaL_putchar(B,c) \ ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \ - (*(B)->p++ = (lua_char)(c))) + (*(B)->p++ = (char)(c))) #define luaL_addsize(B,n) ((B)->p += (n)) LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B); -LUALIB_API lua_char *luaL_prepbuffer (luaL_Buffer *B); -LUALIB_API void luaL_addlstring (luaL_Buffer *B, const lua_char *s, size_t l); -LUALIB_API void luaL_addstring (luaL_Buffer *B, const lua_char *s); +LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B); +LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s); LUALIB_API void luaL_addvalue (luaL_Buffer *B); LUALIB_API void luaL_pushresult (luaL_Buffer *B); diff --git a/lbaselib.c b/lbaselib.c index 73e5c8e6..52343fe5 100644 --- a/lbaselib.c +++ b/lbaselib.c @@ -1,5 +1,5 @@ /* -** $Id: lbaselib.c,v 1.44 2001/10/17 21:12:57 roberto Exp $ +** $Id: lbaselib.c,v 1.45 2001/10/26 17:33:30 roberto Exp $ ** Basic library ** See Copyright Notice in lua.h */ @@ -11,7 +11,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lauxlib.h" @@ -21,7 +20,7 @@ static void aux_setn (lua_State *L, int t, int n) { - lua_pushliteral(L, l_s("n")); + lua_pushliteral(L, "n"); lua_pushnumber(L, n); lua_settable(L, t); } @@ -43,21 +42,21 @@ static int luaB__ALERT (lua_State *L) { */ static int luaB__ERRORMESSAGE (lua_State *L) { luaL_check_rawtype(L, 1, LUA_TSTRING); - lua_getglobal(L, l_s(LUA_ALERT)); + lua_getglobal(L, LUA_ALERT); if (lua_isfunction(L, -1)) { /* avoid error loop if _ALERT is not defined */ lua_Debug ar; - lua_pushliteral(L, l_s("error: ")); + lua_pushliteral(L, "error: "); lua_pushvalue(L, 1); if (lua_getstack(L, 1, &ar)) { - lua_getinfo(L, l_s("Sl"), &ar); + lua_getinfo(L, "Sl", &ar); if (ar.source && ar.currentline > 0) { - l_char buff[100]; - sprintf(buff, l_s("\n <%.70s: line %d>"), ar.short_src, ar.currentline); + char buff[100]; + sprintf(buff, "\n <%.70s: line %d>", ar.short_src, ar.currentline); lua_pushstring(L, buff); lua_concat(L, 2); } } - lua_pushliteral(L, l_s("\n")); + lua_pushliteral(L, "\n"); lua_concat(L, 3); lua_rawcall(L, 1, 0); } @@ -74,20 +73,20 @@ static int luaB__ERRORMESSAGE (lua_State *L) { static int luaB_print (lua_State *L) { int n = lua_gettop(L); /* number of arguments */ int i; - lua_getglobal(L, l_s("tostring")); + lua_getglobal(L, "tostring"); for (i=1; i<=n; i++) { - const l_char *s; + const char *s; lua_pushvalue(L, -1); /* function to be called */ lua_pushvalue(L, i); /* value to print */ lua_rawcall(L, 1, 1); s = lua_tostring(L, -1); /* get result */ if (s == NULL) - lua_error(L, l_s("`tostring' must return a string to `print'")); - if (i>1) fputs(l_s("\t"), stdout); + lua_error(L, "`tostring' must return a string to `print'"); + if (i>1) fputs("\t", stdout); fputs(s, stdout); lua_pop(L, 1); /* pop result */ } - fputs(l_s("\n"), stdout); + fputs("\n", stdout); return 0; } @@ -102,14 +101,14 @@ static int luaB_tonumber (lua_State *L) { } } else { - const l_char *s1 = luaL_check_string(L, 1); - l_char *s2; + const char *s1 = luaL_check_string(L, 1); + char *s2; unsigned long n; - luaL_arg_check(L, 2 <= base && base <= 36, 2, l_s("base out of range")); + luaL_arg_check(L, 2 <= base && base <= 36, 2, "base out of range"); n = strtoul(s1, &s2, base); if (s1 != s2) { /* at least one valid digit? */ - while (isspace(uchar(*s2))) s2++; /* skip trailing spaces */ - if (*s2 == l_c('\0')) { /* no invalid trailing characters? */ + while (isspace((unsigned char)(*s2))) s2++; /* skip trailing spaces */ + if (*s2 == '\0') { /* no invalid trailing characters? */ lua_pushnumber(L, n); return 1; } @@ -143,14 +142,14 @@ static int gettag (lua_State *L, int narg) { case LUA_TNUMBER: return (int)(lua_tonumber(L, narg)); case LUA_TSTRING: { - const l_char *name = lua_tostring(L, narg); + const char *name = lua_tostring(L, narg); int tag = lua_name2tag(L, name); if (tag == LUA_TNONE) - luaL_verror(L, l_s("'%.30s' is not a valid type name"), name); + luaL_verror(L, "'%.30s' is not a valid type name", name); return tag; } default: - luaL_argerror(L, narg, l_s("tag or type name expected")); + luaL_argerror(L, narg, "tag or type name expected"); return 0; /* to avoid warnings */ } } @@ -170,11 +169,11 @@ static int luaB_settype (lua_State *L) { } static int luaB_weakmode (lua_State *L) { - const l_char *mode = luaL_check_string(L, 2); + const char *mode = luaL_check_string(L, 2); luaL_check_rawtype(L, 1, LUA_TTABLE); - if (*mode == l_c('?')) { - l_char buff[3]; - l_char *s = buff; + if (*mode == '?') { + char buff[3]; + char *s = buff; int imode = lua_getweakmode(L, 1); if (imode & LUA_WEAK_KEY) *s++ = 'k'; if (imode & LUA_WEAK_VALUE) *s++ = 'v'; @@ -184,8 +183,8 @@ static int luaB_weakmode (lua_State *L) { } else { int imode = 0; - if (strchr(mode, l_c('k'))) imode |= LUA_WEAK_KEY; - if (strchr(mode, l_c('v'))) imode |= LUA_WEAK_VALUE; + if (strchr(mode, 'k')) imode |= LUA_WEAK_KEY; + if (strchr(mode, 'v')) imode |= LUA_WEAK_VALUE; lua_pushvalue(L, 1); /* push table */ lua_setweakmode(L, imode); return 1; /* return the table */ @@ -193,7 +192,7 @@ static int luaB_weakmode (lua_State *L) { } static int luaB_newtype (lua_State *L) { - const l_char *name = luaL_opt_string(L, 1, NULL); + const char *name = luaL_opt_string(L, 1, NULL); lua_pushnumber(L, lua_newtype(L, name, LUA_TTABLE)); return 1; } @@ -226,11 +225,11 @@ static int luaB_rawset (lua_State *L) { static int luaB_settagmethod (lua_State *L) { int tag = gettag(L, 1); - const l_char *event = luaL_check_string(L, 2); + const char *event = luaL_check_string(L, 2); luaL_arg_check(L, lua_isfunction(L, 3) || lua_isnil(L, 3), 3, - l_s("function or nil expected")); - if (strcmp(event, l_s("gc")) == 0) - lua_error(L, l_s("cannot set `gc' tag method from Lua")); + "function or nil expected"); + if (strcmp(event, "gc") == 0) + lua_error(L, "cannot set `gc' tag method from Lua"); lua_gettagmethod(L, tag, event); lua_pushvalue(L, 3); lua_settagmethod(L, tag, event); @@ -240,9 +239,9 @@ static int luaB_settagmethod (lua_State *L) { static int luaB_gettagmethod (lua_State *L) { int tag = gettag(L, 1); - const l_char *event = luaL_check_string(L, 2); - if (strcmp(event, l_s("gc")) == 0) - lua_error(L, l_s("cannot get `gc' tag method from Lua")); + const char *event = luaL_check_string(L, 2); + if (strcmp(event, "gc") == 0) + lua_error(L, "cannot get `gc' tag method from Lua"); lua_gettagmethod(L, tag, event); return 1; } @@ -288,9 +287,9 @@ static int luaB_next (lua_State *L) { static int passresults (lua_State *L, int status, int oldtop) { - static const l_char *const errornames[] = - {l_s("ok"), l_s("run-time error"), l_s("file error"), l_s("syntax error"), - l_s("memory error"), l_s("error in error handling")}; + static const char *const errornames[] = + {"ok", "run-time error", "file error", "syntax error", + "memory error", "error in error handling"}; if (status == 0) { int nresults = lua_gettop(L) - oldtop; if (nresults > 0) @@ -311,8 +310,8 @@ static int passresults (lua_State *L, int status, int oldtop) { static int luaB_dostring (lua_State *L) { int oldtop = lua_gettop(L); size_t l; - const l_char *s = luaL_check_lstr(L, 1, &l); - const l_char *chunkname = luaL_opt_string(L, 2, s); + const char *s = luaL_check_lstr(L, 1, &l); + const char *chunkname = luaL_opt_string(L, 2, s); return passresults(L, lua_dobuffer(L, s, l, chunkname), oldtop); } @@ -320,36 +319,36 @@ static int luaB_dostring (lua_State *L) { static int luaB_loadstring (lua_State *L) { int oldtop = lua_gettop(L); size_t l; - const l_char *s = luaL_check_lstr(L, 1, &l); - const l_char *chunkname = luaL_opt_string(L, 2, s); + const char *s = luaL_check_lstr(L, 1, &l); + const char *chunkname = luaL_opt_string(L, 2, s); return passresults(L, lua_loadbuffer(L, s, l, chunkname), oldtop); } static int luaB_dofile (lua_State *L) { int oldtop = lua_gettop(L); - const l_char *fname = luaL_opt_string(L, 1, NULL); + const char *fname = luaL_opt_string(L, 1, NULL); return passresults(L, lua_dofile(L, fname), oldtop); } static int luaB_loadfile (lua_State *L) { int oldtop = lua_gettop(L); - const l_char *fname = luaL_opt_string(L, 1, NULL); + const char *fname = luaL_opt_string(L, 1, NULL); return passresults(L, lua_loadfile(L, fname), oldtop); } -#define LUA_PATH l_s("LUA_PATH") +#define LUA_PATH "LUA_PATH" -#define LUA_PATH_SEP l_s(";") +#define LUA_PATH_SEP ";" #ifndef LUA_PATH_DEFAULT -#define LUA_PATH_DEFAULT l_s("./") +#define LUA_PATH_DEFAULT "./" #endif static int luaB_require (lua_State *L) { - const l_char *path; + const char *path; luaL_check_string(L, 1); lua_settop(L, 1); lua_getglobal(L, LUA_PATH); /* get path */ @@ -379,8 +378,8 @@ static int luaB_require (lua_State *L) { if (res == 0) break; /* ok; file done */ else if (res != LUA_ERRFILE) lua_error(L, NULL); /* error running package; propagate it */ - if (*(path+l) == l_c('\0')) /* no more directories? */ - luaL_verror(L, l_s("could not load package `%.20s' from path `%.200s'"), + if (*(path+l) == '\0') /* no more directories? */ + luaL_verror(L, "could not load package `%.20s' from path `%.200s'", lua_tostring(L, 1), lua_tostring(L, 2)); path += l+1; /* try next directory */ } @@ -396,7 +395,7 @@ static int aux_unpack (lua_State *L, int arg) { int n, i; luaL_check_rawtype(L, arg, LUA_TTABLE); n = lua_getn(L, arg); - luaL_check_stack(L, n, l_s("table too big to unpack")); + luaL_check_stack(L, n, "table too big to unpack"); for (i=1; i<=n; i++) /* push arg[1...n] */ lua_rawgeti(L, arg, i); return n; @@ -410,15 +409,15 @@ static int luaB_unpack (lua_State *L) { static int luaB_call (lua_State *L) { int oldtop; - const l_char *options = luaL_opt_string(L, 3, l_s("")); + const char *options = luaL_opt_string(L, 3, ""); int err = 0; /* index of old error method */ int status; int n; if (!lua_isnull(L, 4)) { /* set new error method */ - lua_getglobal(L, l_s(LUA_ERRORMESSAGE)); + lua_getglobal(L, LUA_ERRORMESSAGE); err = lua_gettop(L); /* get index */ lua_pushvalue(L, 4); - lua_setglobal(L, l_s(LUA_ERRORMESSAGE)); + lua_setglobal(L, LUA_ERRORMESSAGE); } oldtop = lua_gettop(L); /* top before function-call preparation */ /* push function */ @@ -427,23 +426,23 @@ static int luaB_call (lua_State *L) { status = lua_call(L, n, LUA_MULTRET); if (err != 0) { /* restore old error method */ lua_pushvalue(L, err); - lua_setglobal(L, l_s(LUA_ERRORMESSAGE)); + lua_setglobal(L, LUA_ERRORMESSAGE); } if (status != 0) { /* error in call? */ - if (strchr(options, l_c('x'))) + if (strchr(options, 'x')) lua_pushnil(L); /* return nil to signal the error */ else lua_error(L, NULL); /* propagate error without additional messages */ return 1; } - if (strchr(options, l_c('p'))) /* pack results? */ - lua_error(L, l_s("obsolete option `p' in `call'")); + if (strchr(options, 'p')) /* pack results? */ + lua_error(L, "obsolete option `p' in `call'"); return lua_gettop(L) - oldtop; /* results are already on the stack */ } static int luaB_tostring (lua_State *L) { - l_char buff[64]; + char buff[64]; switch (lua_rawtag(L, 1)) { case LUA_TNUMBER: lua_pushstring(L, lua_tostring(L, 1)); @@ -452,25 +451,25 @@ static int luaB_tostring (lua_State *L) { lua_pushvalue(L, 1); return 1; case LUA_TTABLE: - sprintf(buff, l_s("%.40s: %p"), lua_type(L, 1), lua_topointer(L, 1)); + sprintf(buff, "%.40s: %p", lua_type(L, 1), lua_topointer(L, 1)); break; case LUA_TFUNCTION: - sprintf(buff, l_s("function: %p"), lua_topointer(L, 1)); + sprintf(buff, "function: %p", lua_topointer(L, 1)); break; case LUA_TUSERDATA: { - const l_char *t = lua_type(L, 1); - if (strcmp(t, l_s("userdata")) == 0) - sprintf(buff, l_s("userdata(%d): %p"), lua_tag(L, 1), + const char *t = lua_type(L, 1); + if (strcmp(t, "userdata") == 0) + sprintf(buff, "userdata(%d): %p", lua_tag(L, 1), lua_touserdata(L, 1)); else - sprintf(buff, l_s("%.40s: %p"), t, lua_touserdata(L, 1)); + sprintf(buff, "%.40s: %p", t, lua_touserdata(L, 1)); break; } case LUA_TNIL: - lua_pushliteral(L, l_s("nil")); + lua_pushliteral(L, "nil"); return 1; default: - luaL_argerror(L, 1, l_s("value expected")); + luaL_argerror(L, 1, "value expected"); } lua_pushstring(L, buff); return 1; @@ -516,8 +515,8 @@ static int luaB_foreach (lua_State *L) { static int luaB_assert (lua_State *L) { luaL_check_any(L, 1); if (lua_isnil(L, 1)) - luaL_verror(L, l_s("assertion failed! %.90s"), - luaL_opt_string(L, 2, l_s(""))); + luaL_verror(L, "assertion failed! %.90s", + luaL_opt_string(L, 2, "")); lua_settop(L, 1); return 1; } @@ -635,12 +634,12 @@ static void auxsort (lua_State *L, int l, int u) { for (;;) { /* invariant: a[l..i] <= P <= a[j..u] */ /* repeat ++i until a[i] >= P */ while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) { - if (i>u) lua_error(L, l_s("invalid order function for sorting")); + if (i>u) lua_error(L, "invalid order function for sorting"); lua_pop(L, 1); /* remove a[i] */ } /* repeat --j until a[j] <= P */ while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) { - if (j -#define LUA_PRIVATE #include "lua.h" #include "lcode.h" @@ -27,7 +26,7 @@ -void luaK_error (LexState *ls, const l_char *msg) { +void luaK_error (LexState *ls, const char *msg) { luaX_error(ls, msg, ls->t.token); } @@ -83,7 +82,7 @@ static void luaK_fixjump (FuncState *fs, int pc, int dest) { else { /* jump is relative to position following jump instruction */ int offset = dest-(pc+1); if (abs(offset) > MAXARG_sBc) - luaK_error(fs->ls, l_s("control structure too long")); + luaK_error(fs->ls, "control structure too long"); SETARG_sBc(*jmp, offset); } } @@ -202,7 +201,7 @@ void luaK_reserveregs (FuncState *fs, int n) { fs->freereg += n; if (fs->freereg > fs->f->maxstacksize) { if (fs->freereg >= MAXSTACK) - luaK_error(fs->ls, l_s("function or expression too complex")); + luaK_error(fs->ls, "function or expression too complex"); fs->f->maxstacksize = cast(short, fs->freereg); } } @@ -232,7 +231,7 @@ static int addk (FuncState *fs, TObject *k) { TObject o; Proto *f = fs->f; luaM_growvector(fs->L, f->k, fs->nk, f->sizek, TObject, - MAXARG_Bc, l_s("constant table overflow")); + MAXARG_Bc, "constant table overflow"); setobj(&f->k[fs->nk], k); setnvalue(&o, fs->nk); luaH_set(fs->L, fs->h, k, &o); @@ -771,11 +770,11 @@ static void codelineinfo (FuncState *fs) { if (ls->lastline > fs->lastline) { if (ls->lastline > fs->lastline+1) { luaM_growvector(fs->L, f->lineinfo, fs->nlineinfo, f->sizelineinfo, int, - MAX_INT, l_s("line info overflow")); + MAX_INT, "line info overflow"); f->lineinfo[fs->nlineinfo++] = -(ls->lastline - (fs->lastline+1)); } luaM_growvector(fs->L, f->lineinfo, fs->nlineinfo, f->sizelineinfo, int, - MAX_INT, l_s("line info overflow")); + MAX_INT, "line info overflow"); f->lineinfo[fs->nlineinfo++] = fs->pc; fs->lastline = ls->lastline; } @@ -788,7 +787,7 @@ static int luaK_code (FuncState *fs, Instruction i) { f = fs->f; /* put new instruction in code array */ luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction, - MAX_INT, l_s("code size overflow")); + MAX_INT, "code size overflow"); f->code[fs->pc] = i; /*printf("free: %d ", fs->freereg); printopcode(f, fs->pc);*/ return fs->pc++; diff --git a/lcode.h b/lcode.h index c2b87bff..3413fe88 100644 --- a/lcode.h +++ b/lcode.h @@ -1,5 +1,5 @@ /* -** $Id: lcode.h,v 1.23 2001/06/12 14:36:48 roberto Exp roberto $ +** $Id: lcode.h,v 1.24 2001/07/24 17:19:07 roberto Exp $ ** Code generator for Lua ** See Copyright Notice in lua.h */ @@ -38,7 +38,7 @@ typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr; #define luaK_codeAsBc(fs,o,A,sBc) luaK_codeABc(fs,o,A,(sBc)+MAXARG_sBc) -void luaK_error (LexState *ls, const l_char *msg); +void luaK_error (LexState *ls, const char *msg); int luaK_codeABc (FuncState *fs, OpCode o, int A, unsigned int Bc); int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); void luaK_nil (FuncState *fs, int from, int n); diff --git a/ldblib.c b/ldblib.c index ea435b89..25dcb2f7 100644 --- a/ldblib.c +++ b/ldblib.c @@ -1,5 +1,5 @@ /* -** $Id: ldblib.c,v 1.39 2001/10/17 21:12:57 roberto Exp $ +** $Id: ldblib.c,v 1.40 2001/10/26 17:33:30 roberto Exp $ ** Interface from Lua to its debug API ** See Copyright Notice in lua.h */ @@ -9,7 +9,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lauxlib.h" @@ -18,14 +17,14 @@ -static void settabss (lua_State *L, const l_char *i, const l_char *v) { +static void settabss (lua_State *L, const char *i, const char *v) { lua_pushstring(L, i); lua_pushstring(L, v); lua_settable(L, -3); } -static void settabsi (lua_State *L, const l_char *i, int v) { +static void settabsi (lua_State *L, const char *i, int v) { lua_pushstring(L, i); lua_pushnumber(L, v); lua_settable(L, -3); @@ -34,8 +33,8 @@ static void settabsi (lua_State *L, const l_char *i, int v) { static int getinfo (lua_State *L) { lua_Debug ar; - const l_char *options = luaL_opt_string(L, 2, l_s("flnSu")); - l_char buff[20]; + const char *options = luaL_opt_string(L, 2, "flnSu"); + char buff[20]; if (lua_isnumber(L, 1)) { if (!lua_getstack(L, (int)(lua_tonumber(L, 1)), &ar)) { lua_pushnil(L); /* level out of range */ @@ -44,35 +43,35 @@ static int getinfo (lua_State *L) { } else if (lua_isfunction(L, 1)) { lua_pushvalue(L, 1); - sprintf(buff, l_s(">%.10s"), options); + sprintf(buff, ">%.10s", options); options = buff; } else - luaL_argerror(L, 1, l_s("function or level expected")); + luaL_argerror(L, 1, "function or level expected"); if (!lua_getinfo(L, options, &ar)) - luaL_argerror(L, 2, l_s("invalid option")); + luaL_argerror(L, 2, "invalid option"); lua_newtable(L); for (; *options; options++) { switch (*options) { - case l_c('S'): - settabss(L, l_s("source"), ar.source); + case 'S': + settabss(L, "source", ar.source); if (ar.source) - settabss(L, l_s("short_src"), ar.short_src); - settabsi(L, l_s("linedefined"), ar.linedefined); - settabss(L, l_s("what"), ar.what); + settabss(L, "short_src", ar.short_src); + settabsi(L, "linedefined", ar.linedefined); + settabss(L, "what", ar.what); break; - case l_c('l'): - settabsi(L, l_s("currentline"), ar.currentline); + case 'l': + settabsi(L, "currentline", ar.currentline); break; - case l_c('u'): - settabsi(L, l_s("nups"), ar.nups); + case 'u': + settabsi(L, "nups", ar.nups); break; - case l_c('n'): - settabss(L, l_s("name"), ar.name); - settabss(L, l_s("namewhat"), ar.namewhat); + case 'n': + settabss(L, "name", ar.name); + settabss(L, "namewhat", ar.namewhat); break; - case l_c('f'): - lua_pushliteral(L, l_s("func")); + case 'f': + lua_pushliteral(L, "func"); lua_pushvalue(L, -3); lua_settable(L, -3); break; @@ -84,9 +83,9 @@ static int getinfo (lua_State *L) { static int getlocal (lua_State *L) { lua_Debug ar; - const l_char *name; + const char *name; if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */ - luaL_argerror(L, 1, l_s("level out of range")); + luaL_argerror(L, 1, "level out of range"); name = lua_getlocal(L, &ar, luaL_check_int(L, 2)); if (name) { lua_pushstring(L, name); @@ -103,7 +102,7 @@ static int getlocal (lua_State *L) { static int setlocal (lua_State *L) { lua_Debug ar; if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */ - luaL_argerror(L, 1, l_s("level out of range")); + luaL_argerror(L, 1, "level out of range"); luaL_check_any(L, 3); lua_pushstring(L, lua_setlocal(L, &ar, luaL_check_int(L, 2))); return 1; @@ -111,11 +110,11 @@ static int setlocal (lua_State *L) { -#define KEY_CALLHOOK l_s("luadblibCallhook") -#define KEY_LINEHOOK l_s("luadblibLinehook") +#define KEY_CALLHOOK "luadblibCallhook" +#define KEY_LINEHOOK "luadblibLinehook" -static void hookf (lua_State *L, const l_char *key) { +static void hookf (lua_State *L, const char *key) { lua_pushstring(L, key); lua_gettable(L, LUA_REGISTRYINDEX); if (lua_isfunction(L, -1)) { @@ -139,7 +138,7 @@ static void linef (lua_State *L, lua_Debug *ar) { } -static void sethook (lua_State *L, const l_char *key, lua_Hook hook, +static void sethook (lua_State *L, const char *key, lua_Hook hook, lua_Hook (*sethookf)(lua_State * L, lua_Hook h)) { lua_settop(L, 1); if (lua_isnil(L, 1)) @@ -147,7 +146,7 @@ static void sethook (lua_State *L, const l_char *key, lua_Hook hook, else if (lua_isfunction(L, 1)) (*sethookf)(L, hook); else - luaL_argerror(L, 1, l_s("function expected")); + luaL_argerror(L, 1, "function expected"); lua_pushstring(L, key); lua_gettable(L, LUA_REGISTRYINDEX); /* get old value */ lua_pushstring(L, key); @@ -169,11 +168,11 @@ static int setlinehook (lua_State *L) { static const luaL_reg dblib[] = { - {l_s("getlocal"), getlocal}, - {l_s("getinfo"), getinfo}, - {l_s("setcallhook"), setcallhook}, - {l_s("setlinehook"), setlinehook}, - {l_s("setlocal"), setlocal} + {"getlocal", getlocal}, + {"getinfo", getinfo}, + {"setcallhook", setcallhook}, + {"setlinehook", setlinehook}, + {"setlocal", setlocal} }; diff --git a/ldebug.c b/ldebug.c index 7b568e60..5537fcd3 100644 --- a/ldebug.c +++ b/ldebug.c @@ -1,5 +1,5 @@ /* -** $Id: ldebug.c,v 1.91 2001/10/25 19:14:14 roberto Exp roberto $ +** $Id: ldebug.c,v 1.92 2001/10/31 19:58:11 roberto Exp $ ** Debug Interface ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include -#define LUA_PRIVATE #include "lua.h" #include "lapi.h" @@ -26,8 +25,8 @@ -static const l_char *getfuncname (lua_State *L, CallInfo *ci, - const l_char **name); +static const char *getfuncname (lua_State *L, CallInfo *ci, + const char **name); @@ -139,8 +138,8 @@ static Proto *getluaproto (CallInfo *ci) { } -LUA_API const l_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { - const l_char *name; +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; CallInfo *ci; Proto *fp; lua_lock(L); @@ -157,8 +156,8 @@ LUA_API const l_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) { } -LUA_API const l_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { - const l_char *name; +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { + const char *name; CallInfo *ci; Proto *fp; lua_lock(L); @@ -168,7 +167,7 @@ LUA_API const l_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { L->top--; /* pop new value */ if (fp) { /* is a Lua function? */ name = luaF_getlocalname(fp, n, currentpc(ci)); - if (!name || name[0] == l_c('(')) /* `(' starts private locals */ + if (!name || name[0] == '(') /* `(' starts private locals */ name = NULL; else setobj(ci->base+(n-1), L->top); @@ -181,7 +180,7 @@ LUA_API const l_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) { static void infoLproto (lua_Debug *ar, Proto *f) { ar->source = getstr(f->source); ar->linedefined = f->lineDefined; - ar->what = l_s("Lua"); + ar->what = "Lua"; } @@ -190,23 +189,23 @@ static void funcinfo (lua_State *L, lua_Debug *ar, StkId func) { if (ttype(func) == LUA_TFUNCTION) cl = clvalue(func); else { - luaD_error(L, l_s("value for `lua_getinfo' is not a function")); + luaD_error(L, "value for `lua_getinfo' is not a function"); cl = NULL; /* to avoid warnings */ } if (cl->c.isC) { - ar->source = l_s("=C"); + ar->source = "=C"; ar->linedefined = -1; - ar->what = l_s("C"); + ar->what = "C"; } else infoLproto(ar, cl->l.p); luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE); if (ar->linedefined == 0) - ar->what = l_s("main"); + ar->what = "main"; } -static const l_char *travtagmethods (global_State *G, const TObject *o) { +static const char *travtagmethods (global_State *G, const TObject *o) { if (ttype(o) == LUA_TFUNCTION) { int e; for (e=0; egt); int i = sizenode(g); while (i--) { @@ -235,20 +234,20 @@ static const l_char *travglobals (lua_State *L, const TObject *o) { static void getname (lua_State *L, const TObject *f, lua_Debug *ar) { /* try to find a name for given function */ if ((ar->name = travglobals(L, f)) != NULL) - ar->namewhat = l_s("global"); + ar->namewhat = "global"; /* not found: try tag methods */ else if ((ar->name = travtagmethods(G(L), f)) != NULL) - ar->namewhat = l_s("tag-method"); - else ar->namewhat = l_s(""); /* not found at all */ + ar->namewhat = "tag-method"; + else ar->namewhat = ""; /* not found at all */ } -LUA_API int lua_getinfo (lua_State *L, const l_char *what, lua_Debug *ar) { +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { StkId f; CallInfo *ci; int status = 1; lua_lock(L); - if (*what != l_c('>')) { /* function is active? */ + if (*what != '>') { /* function is active? */ ci = ar->_ci; f = ci->base - 1; } @@ -259,25 +258,25 @@ LUA_API int lua_getinfo (lua_State *L, const l_char *what, lua_Debug *ar) { } for (; *what; what++) { switch (*what) { - case l_c('S'): { + case 'S': { funcinfo(L, ar, f); break; } - case l_c('l'): { + case 'l': { ar->currentline = currentline(ci); break; } - case l_c('u'): { + case 'u': { ar->nups = (ttype(f) == LUA_TFUNCTION) ? clvalue(f)->c.nupvalues : 0; break; } - case l_c('n'): { + case 'n': { ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL; if (ar->namewhat == NULL) getname(L, f, ar); break; } - case l_c('f'): { + case 'f': { setobj(L->top, f); incr_top; /* push function */ break; @@ -470,7 +469,7 @@ int luaG_checkcode (const Proto *pt) { } -static const l_char *getobjname (lua_State *L, StkId obj, const l_char **name) { +static const char *getobjname (lua_State *L, StkId obj, const char **name) { CallInfo *ci = ci_stack(L, obj); if (isLmark(ci)) { /* an active Lua function? */ Proto *p = ci_func(ci)->l.p; @@ -479,14 +478,14 @@ static const l_char *getobjname (lua_State *L, StkId obj, const l_char **name) { Instruction i; *name = luaF_getlocalname(p, stackpos+1, pc); if (*name) /* is a local? */ - return l_s("local"); + return "local"; i = luaG_symbexec(p, pc, stackpos); /* try symbolic execution */ lua_assert(pc != -1); switch (GET_OPCODE(i)) { case OP_GETGLOBAL: { lua_assert(ttype(&p->k[GETARG_Bc(i)]) == LUA_TSTRING); *name = svalue(&p->k[GETARG_Bc(i)]); - return l_s("global"); + return "global"; } case OP_MOVE: { int a = GETARG_A(i); @@ -500,7 +499,7 @@ static const l_char *getobjname (lua_State *L, StkId obj, const l_char **name) { int c = GETARG_C(i) - MAXSTACK; if (c >= 0 && ttype(&p->k[c]) == LUA_TSTRING) { *name = svalue(&p->k[c]); - return l_s("field"); + return "field"; } break; } @@ -511,8 +510,8 @@ static const l_char *getobjname (lua_State *L, StkId obj, const l_char **name) { } -static const l_char *getfuncname (lua_State *L, CallInfo *ci, - const l_char **name) { +static const char *getfuncname (lua_State *L, CallInfo *ci, + const char **name) { ci = ci->prev; /* calling function */ if (ci == &L->basefunc || !isLmark(ci)) return NULL; /* not an active Lua function */ @@ -529,22 +528,22 @@ static const l_char *getfuncname (lua_State *L, CallInfo *ci, } -void luaG_typeerror (lua_State *L, StkId o, const l_char *op) { - const l_char *name; - const l_char *kind = getobjname(L, o, &name); - const l_char *t = luaT_typename(G(L), o); +void luaG_typeerror (lua_State *L, StkId o, const char *op) { + const char *name; + const char *kind = getobjname(L, o, &name); + const char *t = luaT_typename(G(L), o); if (kind) - luaO_verror(L, l_s("attempt to %.30s %.20s `%.40s' (a %.10s value)"), + luaO_verror(L, "attempt to %.30s %.20s `%.40s' (a %.10s value)", op, kind, name, t); else - luaO_verror(L, l_s("attempt to %.30s a %.10s value"), op, t); + luaO_verror(L, "attempt to %.30s a %.10s value", op, t); } void luaG_concaterror (lua_State *L, StkId p1, StkId p2) { if (ttype(p1) == LUA_TSTRING) p1 = p2; lua_assert(ttype(p1) != LUA_TSTRING); - luaG_typeerror(L, p1, l_s("concat")); + luaG_typeerror(L, p1, "concat"); } @@ -552,16 +551,16 @@ void luaG_aritherror (lua_State *L, StkId p1, TObject *p2) { TObject temp; if (luaV_tonumber(p1, &temp) != NULL) p1 = p2; /* first operand is OK; error is in the second */ - luaG_typeerror(L, p1, l_s("perform arithmetic on")); + luaG_typeerror(L, p1, "perform arithmetic on"); } void luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2) { - const l_char *t1 = luaT_typename(G(L), p1); - const l_char *t2 = luaT_typename(G(L), p2); + const char *t1 = luaT_typename(G(L), p1); + const char *t2 = luaT_typename(G(L), p2); if (t1[2] == t2[2]) - luaO_verror(L, l_s("attempt to compare two %.10s values"), t1); + luaO_verror(L, "attempt to compare two %.10s values", t1); else - luaO_verror(L, l_s("attempt to compare %.10s with %.10s"), t1, t2); + luaO_verror(L, "attempt to compare %.10s with %.10s", t1, t2); } diff --git a/ldebug.h b/ldebug.h index b1320301..30c2c3bc 100644 --- a/ldebug.h +++ b/ldebug.h @@ -1,5 +1,5 @@ /* -** $Id: ldebug.h,v 1.14 2001/06/11 14:56:42 roberto Exp roberto $ +** $Id: ldebug.h,v 1.15 2001/06/28 19:58:57 roberto Exp $ ** Auxiliary functions from Debug Interface module ** See Copyright Notice in lua.h */ @@ -12,7 +12,7 @@ #include "luadebug.h" -void luaG_typeerror (lua_State *L, StkId o, const l_char *op); +void luaG_typeerror (lua_State *L, StkId o, const char *op); void luaG_concaterror (lua_State *L, StkId p1, StkId p2); void luaG_aritherror (lua_State *L, StkId p1, TObject *p2); int luaG_getline (int *lineinfo, int pc, int refline, int *refi); diff --git a/ldo.c b/ldo.c index 29caf8bf..f28dca44 100644 --- a/ldo.c +++ b/ldo.c @@ -1,5 +1,5 @@ /* -** $Id: ldo.c,v 1.143 2001/10/17 21:12:57 roberto Exp $ +** $Id: ldo.c,v 1.144 2001/11/27 20:56:47 roberto Exp $ ** Stack and Call structure of Lua ** See Copyright Notice in lua.h */ @@ -10,7 +10,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "ldebug.h" @@ -58,7 +57,7 @@ void luaD_stackerror (lua_State *L) { else { L->stack_last += EXTRA_STACK; /* to be used by error message */ lua_assert(L->stack_last == L->stack+L->stacksize-1); - luaD_error(L, l_s("stack overflow")); + luaD_error(L, "stack overflow"); } } @@ -99,7 +98,7 @@ static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) { void luaD_lineHook (lua_State *L, int line, lua_Hook linehook) { if (L->allowhooks) { lua_Debug ar; - ar.event = l_s("line"); + ar.event = "line"; ar._ci = L->ci; ar.currentline = line; dohook(L, &ar, linehook); @@ -108,7 +107,7 @@ void luaD_lineHook (lua_State *L, int line, lua_Hook linehook) { static void luaD_callHook (lua_State *L, lua_Hook callhook, - const l_char *event) { + const char *event) { if (L->allowhooks) { lua_Debug ar; ar.event = event; @@ -146,7 +145,7 @@ void luaD_call (lua_State *L, StkId func) { /* `func' is not a function; check the `function' tag method */ Closure *tm = luaT_gettmbyObj(G(L), func, TM_FUNCTION); if (tm == NULL) - luaG_typeerror(L, func, l_s("call")); + luaG_typeerror(L, func, "call"); luaD_openstack(L, func); setclvalue(func, tm); /* tag method is the new function to be called */ } @@ -155,12 +154,12 @@ void luaD_call (lua_State *L, StkId func) { ci.base = func+1; callhook = L->callhook; if (callhook) - luaD_callHook(L, callhook, l_s("call")); + luaD_callHook(L, callhook, "call"); firstResult = (clvalue(func)->c.isC ? callCclosure(L, &clvalue(func)->c) : luaV_execute(L, &clvalue(func)->l, func+1)); if (callhook) /* same hook that was active at entry */ - luaD_callHook(L, callhook, l_s("return")); + luaD_callHook(L, callhook, "return"); L->ci = ci.prev; /* unchain callinfo */ /* move results to `func' (to erase parameters and function) */ while (firstResult < L->top) @@ -245,21 +244,21 @@ static int protectedparser (lua_State *L, ZIO *z, int bin) { } -LUA_API int lua_loadfile (lua_State *L, const l_char *filename) { +LUA_API int lua_loadfile (lua_State *L, const char *filename) { ZIO z; int status; int bin; /* flag for file mode */ int nlevel; /* level on the stack of filename */ - FILE *f = (filename == NULL) ? stdin : fopen(filename, l_s("r")); + FILE *f = (filename == NULL) ? stdin : fopen(filename, "r"); if (f == NULL) return LUA_ERRFILE; /* unable to open file */ bin = (ungetc(getc(f), f) == LUA_SIGNATURE[0]); if (bin && f != stdin) { fclose(f); - f = fopen(filename, l_s("rb")); /* reopen in binary mode */ + f = fopen(filename, "rb"); /* reopen in binary mode */ if (f == NULL) return LUA_ERRFILE; /* unable to reopen file */ } - lua_pushliteral(L, l_s("@")); - lua_pushstring(L, (filename == NULL) ? l_s("(stdin)") : filename); + lua_pushliteral(L, "@"); + lua_pushstring(L, (filename == NULL) ? "(stdin)" : filename); lua_concat(L, 2); nlevel = lua_gettop(L); filename = lua_tostring(L, -1); /* filename = `@'..filename */ @@ -272,11 +271,11 @@ LUA_API int lua_loadfile (lua_State *L, const l_char *filename) { } -LUA_API int lua_loadbuffer (lua_State *L, const l_char *buff, size_t size, - const l_char *name) { +LUA_API int lua_loadbuffer (lua_State *L, const char *buff, size_t size, + const char *name) { ZIO z; int status; - if (!name) name = l_s("?"); + if (!name) name = "?"; luaZ_mopen(&z, buff, size, name); status = protectedparser(L, &z, buff[0]==LUA_SIGNATURE[0]); return status; @@ -301,9 +300,9 @@ struct lua_longjmp { }; -static void message (lua_State *L, const l_char *s) { +static void message (lua_State *L, const char *s) { StkId top = L->top; - luaV_getglobal(L, luaS_newliteral(L, l_s(LUA_ERRORMESSAGE)), top); + luaV_getglobal(L, luaS_newliteral(L, LUA_ERRORMESSAGE), top); if (ttype(top) == LUA_TFUNCTION) { incr_top; setsvalue(top+1, luaS_new(L, s)); @@ -317,7 +316,7 @@ static void message (lua_State *L, const l_char *s) { /* ** Reports an error, and jumps up to the available recovery label */ -void luaD_error (lua_State *L, const l_char *s) { +void luaD_error (lua_State *L, const char *s) { if (s) message(L, s); luaD_breakrun(L, LUA_ERRRUN); } @@ -330,7 +329,7 @@ void luaD_breakrun (lua_State *L, int errcode) { } else { if (errcode != LUA_ERRMEM) - message(L, l_s("unable to recover; exiting\n")); + message(L, "unable to recover; exiting\n"); exit(EXIT_FAILURE); } } diff --git a/ldo.h b/ldo.h index 618e8bee..efb5db07 100644 --- a/ldo.h +++ b/ldo.h @@ -1,5 +1,5 @@ /* -** $Id: ldo.h,v 1.33 2001/06/05 19:41:24 roberto Exp roberto $ +** $Id: ldo.h,v 1.34 2001/06/08 19:00:57 roberto Exp $ ** Stack and Call structure of Lua ** See Copyright Notice in lua.h */ @@ -28,7 +28,7 @@ void luaD_lineHook (lua_State *L, int line, lua_Hook linehook); void luaD_call (lua_State *L, StkId func); void luaD_stackerror (lua_State *L); -void luaD_error (lua_State *L, const l_char *s); +void luaD_error (lua_State *L, const char *s); void luaD_breakrun (lua_State *L, int errcode); int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud); diff --git a/lfunc.c b/lfunc.c index 1e903a5b..8af857a8 100644 --- a/lfunc.c +++ b/lfunc.c @@ -1,5 +1,5 @@ /* -** $Id: lfunc.c,v 1.48 2001/10/02 16:45:03 roberto Exp $ +** $Id: lfunc.c,v 1.49 2001/11/06 21:41:53 roberto Exp $ ** Auxiliary functions to manipulate prototypes and closures ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include -#define LUA_PRIVATE #include "lua.h" #include "lfunc.h" @@ -157,7 +156,7 @@ void luaF_freeclosure (lua_State *L, Closure *c) { ** Look for n-th local variable at line `line' in function `func'. ** Returns NULL if not found. */ -const l_char *luaF_getlocalname (const Proto *f, int local_number, int pc) { +const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { int i; for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { if (pc < f->locvars[i].endpc) { /* is variable active? */ diff --git a/lfunc.h b/lfunc.h index d7506f84..111e554c 100644 --- a/lfunc.h +++ b/lfunc.h @@ -1,5 +1,5 @@ /* -** $Id: lfunc.h,v 1.16 2001/09/07 17:39:10 roberto Exp $ +** $Id: lfunc.h,v 1.17 2001/10/02 16:45:03 roberto Exp $ ** Auxiliary functions to manipulate prototypes and closures ** See Copyright Notice in lua.h */ @@ -19,7 +19,7 @@ void luaF_close (lua_State *L, StkId level); void luaF_freeproto (lua_State *L, Proto *f); void luaF_freeclosure (lua_State *L, Closure *c); -const l_char *luaF_getlocalname (const Proto *func, int local_number, int pc); +const char *luaF_getlocalname (const Proto *func, int local_number, int pc); #endif diff --git a/lgc.c b/lgc.c index d41b6d51..418ccd6c 100644 --- a/lgc.c +++ b/lgc.c @@ -1,10 +1,9 @@ /* -** $Id: lgc.c,v 1.115 2001/10/31 19:58:11 roberto Exp $ +** $Id: lgc.c,v 1.116 2001/11/06 21:41:53 roberto Exp $ ** Garbage Collector ** See Copyright Notice in lua.h */ -#define LUA_PRIVATE #include "lua.h" #include "ldebug.h" @@ -352,7 +351,7 @@ static void collectstrings (lua_State *L, int all) { static void checkMbuffer (lua_State *L) { if (G(L)->Mbuffsize > MINBUFFER*2) { /* is buffer too big? */ size_t newsize = G(L)->Mbuffsize/2; /* still larger than MINBUFFER */ - luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, newsize, l_char); + luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, newsize, char); G(L)->Mbuffsize = newsize; } } diff --git a/liolib.c b/liolib.c index 4114eae3..16adf983 100644 --- a/liolib.c +++ b/liolib.c @@ -1,5 +1,5 @@ /* -** $Id: liolib.c,v 1.123 2001/10/02 16:41:36 roberto Exp $ +** $Id: liolib.c,v 1.124 2001/10/26 17:33:30 roberto Exp $ ** Standard I/O (and system) library ** See Copyright Notice in lua.h */ @@ -10,7 +10,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lauxlib.h" @@ -40,12 +39,12 @@ int pclose(); */ #define OUTFILE 1 #define NOFILE 2 -#define FILEHANDLE l_s("FileHandle") -#define CLOSEDFILEHANDLE l_s("ClosedFileHandle") +#define FILEHANDLE "FileHandle" +#define CLOSEDFILEHANDLE "ClosedFileHandle" -static const l_char *const filenames[] = {l_s("_INPUT"), l_s("_OUTPUT")}; -static const l_char *const basicfiles[] = {l_s("_STDIN"), l_s("_STDOUT")}; +static const char *const filenames[] = {"_INPUT", "_OUTPUT"}; +static const char *const basicfiles[] = {"_STDIN", "_STDOUT"}; static int pushresult (lua_State *L, int i) { @@ -77,16 +76,16 @@ static FILE *getopthandle (lua_State *L, int inout) { if (p != NULL) { /* is it a userdata ? */ if (!checkfile(L, 1)) { /* not a valid file handle? */ if (strcmp(lua_type(L, 1), CLOSEDFILEHANDLE) == 0) - luaL_argerror(L, 1, l_s("file is closed")); + luaL_argerror(L, 1, "file is closed"); else - luaL_argerror(L, 1, l_s("(invalid value)")); + luaL_argerror(L, 1, "(invalid value)"); } lua_pushvalue(L, 1); lua_remove(L, 1); /* move it to stack top */ } else { /* try global value */ lua_getglobal(L, filenames[inout]); if (!checkfile(L,-1)) - luaL_verror(L, l_s("global variable `%.10s' is not a valid file handle"), + luaL_verror(L, "global variable `%.10s' is not a valid file handle", filenames[inout]); p = (FILE *)(lua_touserdata(L, -1)); } @@ -100,7 +99,7 @@ static void newfile (lua_State *L, FILE *f) { } -static void newfilewithname (lua_State *L, FILE *f, const l_char *name) { +static void newfilewithname (lua_State *L, FILE *f, const char *name) { newfile(L, f); lua_setglobal(L, name); } @@ -158,7 +157,7 @@ static int io_tmpfile (lua_State *L) { -static int io_fromto (lua_State *L, int inout, const l_char *mode) { +static int io_fromto (lua_State *L, int inout, const char *mode) { FILE *current; if (lua_isnull(L, 1)) { getopthandle(L, inout); @@ -166,25 +165,25 @@ static int io_fromto (lua_State *L, int inout, const l_char *mode) { return io_close(L); } else { - const l_char *s = luaL_check_string(L, 1); - current = (*s == l_c('|')) ? popen(s+1, mode) : fopen(s, mode); + const char *s = luaL_check_string(L, 1); + current = (*s == '|') ? popen(s+1, mode) : fopen(s, mode); return setnewfile(L, current, inout); } } static int io_readfrom (lua_State *L) { - return io_fromto(L, INFILE, l_s("r")); + return io_fromto(L, INFILE, "r"); } static int io_writeto (lua_State *L) { - return io_fromto(L, OUTFILE, l_s("w")); + return io_fromto(L, OUTFILE, "w"); } static int io_appendto (lua_State *L) { - FILE *current = fopen(luaL_check_string(L, 1), l_s("a")); + FILE *current = fopen(luaL_check_string(L, 1), "a"); return setnewfile(L, current, OUTFILE); } @@ -208,7 +207,7 @@ static int io_appendto (lua_State *L) { ** Addison-Wesley, 1993.) */ -static void prep_read_until (int next[], const l_char *p, int pl) { +static void prep_read_until (int next[], const char *p, int pl) { int i = 0; int j = -1; next[0] = -1; @@ -221,8 +220,8 @@ static void prep_read_until (int next[], const l_char *p, int pl) { } -static int read_until (lua_State *L, FILE *f, const l_char *p, int pl) { - l_charint c; +static int read_until (lua_State *L, FILE *f, const char *p, int pl) { + int c; int j; int next[LUA_MAXUNTIL+1]; luaL_Buffer b; @@ -255,7 +254,7 @@ static int read_until (lua_State *L, FILE *f, const l_char *p, int pl) { static int read_number (lua_State *L, FILE *f) { lua_Number d; - if (fscanf(f, l_s(LUA_NUMBER_SCAN), &d) == 1) { + if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) { lua_pushnumber(L, d); return 1; } @@ -264,7 +263,7 @@ static int read_number (lua_State *L, FILE *f) { static int test_eof (lua_State *L, FILE *f) { - l_charint c = getc(f); + int c = getc(f); ungetc(c, f); lua_pushlstring(L, NULL, 0); return (c != EOF); @@ -278,9 +277,9 @@ static int read_chars (lua_State *L, FILE *f, size_t n) { luaL_buffinit(L, &b); rlen = LUAL_BUFFERSIZE; /* try to read that much each time */ do { - l_char *p = luaL_prepbuffer(&b); + char *p = luaL_prepbuffer(&b); if (rlen > n) rlen = n; /* cannot read more than asked */ - nr = fread(p, sizeof(l_char), rlen, f); + nr = fread(p, sizeof(char), rlen, f); luaL_addsize(&b, nr); n -= nr; /* still have to read `n' chars */ } while (n > 0 && nr == rlen); /* until end of count or eof */ @@ -295,11 +294,11 @@ static int io_read (lua_State *L) { int success; int n; if (nargs == 0) { /* no arguments? */ - success = read_until(L, f, l_s("\n"), 1); /* read until \n (a line) */ + success = read_until(L, f, "\n", 1); /* read until \n (a line) */ n = 2; /* will return n-1 results */ } else { /* ensure stack space for all results and for auxlib's buffer */ - luaL_check_stack(L, nargs+LUA_MINSTACK, l_s("too many arguments")); + luaL_check_stack(L, nargs+LUA_MINSTACK, "too many arguments"); success = 1; for (n = 1; n<=nargs && success; n++) { if (lua_rawtag(L, n) == LUA_TNUMBER) { @@ -307,32 +306,32 @@ static int io_read (lua_State *L) { success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l); } else { - const l_char *p = lua_tostring(L, n); - if (!p || p[0] != l_c('*')) - lua_error(L, l_s("invalid `read' option")); + const char *p = lua_tostring(L, n); + if (!p || p[0] != '*') + lua_error(L, "invalid `read' option"); switch (p[1]) { - case l_c('n'): /* number */ + case 'n': /* number */ success = read_number(L, f); break; - case l_c('l'): /* line */ - success = read_until(L, f, l_s("\n"), 1); /* read until \n */ + case 'l': /* line */ + success = read_until(L, f, "\n", 1); /* read until \n */ break; - case l_c('a'): /* file */ + case 'a': /* file */ read_chars(L, f, ~((size_t)0)); /* read MAX_SIZE_T chars */ success = 1; /* always success */ break; - case l_c('w'): /* word */ - lua_error(L, l_s("obsolete option `*w'")); + case 'w': /* word */ + lua_error(L, "obsolete option `*w'"); break; - case l_c('u'): { /* read until */ + case 'u': { /* read until */ size_t pl = lua_strlen(L, n) - 2; luaL_arg_check(L, 0 < pl && pl <= LUA_MAXUNTIL, n, - l_s("invalid read-until length")); + "invalid read-until length"); success = read_until(L, f, p+2, (int)(pl)); break; } default: - luaL_argerror(L, n, l_s("invalid format")); + luaL_argerror(L, n, "invalid format"); success = 0; /* to avoid warnings */ } } @@ -357,12 +356,12 @@ static int io_write (lua_State *L) { if (lua_rawtag(L, arg) == LUA_TNUMBER) { /* optimization: could be done exactly as for strings */ status = status && - fprintf(f, l_s(LUA_NUMBER_FMT), lua_tonumber(L, arg)) > 0; + fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0; } else { size_t l; - const l_char *s = luaL_check_lstr(L, arg, &l); - status = status && (fwrite(s, sizeof(l_char), l, f) == l); + const char *s = luaL_check_lstr(L, arg, &l); + status = status && (fwrite(s, sizeof(char), l, f) == l); } } pushresult(L, status); @@ -372,11 +371,11 @@ static int io_write (lua_State *L) { static int io_seek (lua_State *L) { static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END}; - static const l_char *const modenames[] = {l_s("set"), l_s("cur"), l_s("end"), NULL}; + static const char *const modenames[] = {"set", "cur", "end", NULL}; FILE *f = (FILE *)(luaL_check_userdata(L, 1, FILEHANDLE)); - int op = luaL_findstring(luaL_opt_string(L, 2, l_s("cur")), modenames); + int op = luaL_findstring(luaL_opt_string(L, 2, "cur"), modenames); long offset = luaL_opt_long(L, 3, 0); - luaL_arg_check(L, op != -1, 2, l_s("invalid mode")); + luaL_arg_check(L, op != -1, 2, "invalid mode"); op = fseek(f, offset, mode[op]); if (op) return pushresult(L, 0); /* error */ @@ -420,9 +419,9 @@ static int io_rename (lua_State *L) { static int io_tmpname (lua_State *L) { - l_char buff[L_tmpnam]; + char buff[L_tmpnam]; if (tmpnam(buff) != buff) - lua_error(L, l_s("unable to generate a unique filename")); + lua_error(L, "unable to generate a unique filename"); lua_pushstring(L, buff); return 1; } @@ -449,14 +448,14 @@ static int io_clock (lua_State *L) { ** ======================================================= */ -static void setfield (lua_State *L, const l_char *key, int value) { +static void setfield (lua_State *L, const char *key, int value) { lua_pushstring(L, key); lua_pushnumber(L, value); lua_rawset(L, -3); } -static int getfield (lua_State *L, const l_char *key, int d) { +static int getfield (lua_State *L, const char *key, int d) { int res; lua_pushstring(L, key); lua_rawget(L, -2); @@ -464,7 +463,7 @@ static int getfield (lua_State *L, const l_char *key, int d) { res = (int)(lua_tonumber(L, -1)); else { if (d == -2) - luaL_verror(L, l_s("field `%.20s' missing in date table"), key); + luaL_verror(L, "field `%.20s' missing in date table", key); res = d; } lua_pop(L, 1); @@ -473,12 +472,12 @@ static int getfield (lua_State *L, const l_char *key, int d) { static int io_date (lua_State *L) { - const l_char *s = luaL_opt_string(L, 1, l_s("%c")); + const char *s = luaL_opt_string(L, 1, "%c"); time_t t = (time_t)(luaL_opt_number(L, 2, -1)); struct tm *stm; if (t == (time_t)(-1)) /* no time given? */ t = time(NULL); /* use current time */ - if (*s == l_c('!')) { /* UTC? */ + if (*s == '!') { /* UTC? */ stm = gmtime(&t); s++; /* skip `!' */ } @@ -486,24 +485,24 @@ static int io_date (lua_State *L) { stm = localtime(&t); if (stm == NULL) /* invalid date? */ lua_pushnil(L); - else if (strcmp(s, l_s("*t")) == 0) { + else if (strcmp(s, "*t") == 0) { lua_newtable(L); - setfield(L, l_s("sec"), stm->tm_sec); - setfield(L, l_s("min"), stm->tm_min); - setfield(L, l_s("hour"), stm->tm_hour); - setfield(L, l_s("day"), stm->tm_mday); - setfield(L, l_s("month"), stm->tm_mon+1); - setfield(L, l_s("year"), stm->tm_year+1900); - setfield(L, l_s("wday"), stm->tm_wday+1); - setfield(L, l_s("yday"), stm->tm_yday+1); - setfield(L, l_s("isdst"), stm->tm_isdst); + setfield(L, "sec", stm->tm_sec); + setfield(L, "min", stm->tm_min); + setfield(L, "hour", stm->tm_hour); + setfield(L, "day", stm->tm_mday); + setfield(L, "month", stm->tm_mon+1); + setfield(L, "year", stm->tm_year+1900); + setfield(L, "wday", stm->tm_wday+1); + setfield(L, "yday", stm->tm_yday+1); + setfield(L, "isdst", stm->tm_isdst); } else { - l_char b[256]; + char b[256]; if (strftime(b, sizeof(b), s, stm)) lua_pushstring(L, b); else - lua_error(L, l_s("invalid `date' format")); + lua_error(L, "invalid `date' format"); } return 1; } @@ -517,13 +516,13 @@ static int io_time (lua_State *L) { struct tm ts; luaL_check_rawtype(L, 1, LUA_TTABLE); lua_settop(L, 1); /* make sure table is at the top */ - ts.tm_sec = getfield(L, l_s("sec"), 0); - ts.tm_min = getfield(L, l_s("min"), 0); - ts.tm_hour = getfield(L, l_s("hour"), 12); - ts.tm_mday = getfield(L, l_s("day"), -2); - ts.tm_mon = getfield(L, l_s("month"), -2)-1; - ts.tm_year = getfield(L, l_s("year"), -2)-1900; - ts.tm_isdst = getfield(L, l_s("isdst"), -1); + ts.tm_sec = getfield(L, "sec", 0); + ts.tm_min = getfield(L, "min", 0); + ts.tm_hour = getfield(L, "hour", 12); + ts.tm_mday = getfield(L, "day", -2); + ts.tm_mon = getfield(L, "month", -2)-1; + ts.tm_year = getfield(L, "year", -2)-1900; + ts.tm_isdst = getfield(L, "isdst", -1); t = mktime(&ts); if (t == (time_t)(-1)) lua_pushnil(L); @@ -546,10 +545,10 @@ static int io_difftime (lua_State *L) { static int io_setloc (lua_State *L) { static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, LC_TIME}; - static const l_char *const catnames[] = {l_s("all"), l_s("collate"), l_s("ctype"), l_s("monetary"), - l_s("numeric"), l_s("time"), NULL}; - int op = luaL_findstring(luaL_opt_string(L, 2, l_s("all")), catnames); - luaL_arg_check(L, op != -1, 2, l_s("invalid option")); + static const char *const catnames[] = {"all", "collate", "ctype", "monetary", + "numeric", "time", NULL}; + int op = luaL_findstring(luaL_opt_string(L, 2, "all"), catnames); + luaL_arg_check(L, op != -1, 2, "invalid option"); lua_pushstring(L, setlocale(cat[op], luaL_check_string(L, 1))); return 1; } @@ -566,10 +565,10 @@ static int io_exit (lua_State *L) { static int io_debug (lua_State *L) { for (;;) { - l_char buffer[250]; - fprintf(stderr, l_s("lua_debug> ")); + char buffer[250]; + fprintf(stderr, "lua_debug> "); if (fgets(buffer, sizeof(buffer), stdin) == 0 || - strcmp(buffer, l_s("cont\n")) == 0) + strcmp(buffer, "cont\n") == 0) return 0; lua_dostring(L, buffer); lua_settop(L, 0); /* remove eventual returns */ @@ -586,61 +585,61 @@ static int errorfb (lua_State *L) { lua_Debug ar; luaL_Buffer b; luaL_buffinit(L, &b); - luaL_addstring(&b, l_s("error: ")); + luaL_addstring(&b, "error: "); luaL_addstring(&b, luaL_check_string(L, 1)); - luaL_addstring(&b, l_s("\n")); + luaL_addstring(&b, "\n"); while (lua_getstack(L, level++, &ar)) { - l_char buff[120]; /* enough to fit following `sprintf's */ + char buff[120]; /* enough to fit following `sprintf's */ if (level == 2) - luaL_addstring(&b, l_s("stack traceback:\n")); + luaL_addstring(&b, "stack traceback:\n"); else if (level > LEVELS1 && firstpart) { /* no more than `LEVELS2' more levels? */ if (!lua_getstack(L, level+LEVELS2, &ar)) level--; /* keep going */ else { - luaL_addstring(&b, l_s(" ...\n")); /* too many levels */ + luaL_addstring(&b, " ...\n"); /* too many levels */ while (lua_getstack(L, level+LEVELS2, &ar)) /* find last levels */ level++; } firstpart = 0; continue; } - sprintf(buff, l_s("%4d: "), level-1); + sprintf(buff, "%4d: ", level-1); luaL_addstring(&b, buff); - lua_getinfo(L, l_s("Snl"), &ar); + lua_getinfo(L, "Snl", &ar); switch (*ar.namewhat) { - case l_c('g'): case l_c('l'): /* global, local */ - sprintf(buff, l_s("function `%.50s'"), ar.name); + case 'g': case 'l': /* global, local */ + sprintf(buff, "function `%.50s'", ar.name); break; - case l_c('f'): /* field */ - sprintf(buff, l_s("method `%.50s'"), ar.name); + case 'f': /* field */ + sprintf(buff, "method `%.50s'", ar.name); break; - case l_c('t'): /* tag method */ - sprintf(buff, l_s("`%.50s' tag method"), ar.name); + case 't': /* tag method */ + sprintf(buff, "`%.50s' tag method", ar.name); break; default: { - if (*ar.what == l_c('m')) /* main? */ - sprintf(buff, l_s("main of %.70s"), ar.short_src); - else if (*ar.what == l_c('C')) /* C function? */ - sprintf(buff, l_s("%.70s"), ar.short_src); + if (*ar.what == 'm') /* main? */ + sprintf(buff, "main of %.70s", ar.short_src); + else if (*ar.what == 'C') /* C function? */ + sprintf(buff, "%.70s", ar.short_src); else - sprintf(buff, l_s("function <%d:%.70s>"), ar.linedefined, ar.short_src); + sprintf(buff, "function <%d:%.70s>", ar.linedefined, ar.short_src); ar.source = NULL; /* do not print source again */ } } luaL_addstring(&b, buff); if (ar.currentline > 0) { - sprintf(buff, l_s(" at line %d"), ar.currentline); + sprintf(buff, " at line %d", ar.currentline); luaL_addstring(&b, buff); } if (ar.source) { - sprintf(buff, l_s(" [%.70s]"), ar.short_src); + sprintf(buff, " [%.70s]", ar.short_src); luaL_addstring(&b, buff); } - luaL_addstring(&b, l_s("\n")); + luaL_addstring(&b, "\n"); } luaL_pushresult(&b); - lua_getglobal(L, l_s(LUA_ALERT)); + lua_getglobal(L, LUA_ALERT); if (lua_isfunction(L, -1)) { /* avoid loop if _ALERT is not defined */ lua_pushvalue(L, -2); /* error message */ lua_rawcall(L, 1, 0); @@ -651,29 +650,29 @@ static int errorfb (lua_State *L) { static const luaL_reg iolib[] = { - {l_s("appendto"), io_appendto}, - {l_s("clock"), io_clock}, - {l_s("closefile"), io_close}, - {l_s("date"), io_date}, - {l_s("debug"), io_debug}, - {l_s("difftime"), io_difftime}, - {l_s("execute"), io_execute}, - {l_s("exit"), io_exit}, - {l_s("flush"), io_flush}, - {l_s("getenv"), io_getenv}, - {l_s("openfile"), io_open}, - {l_s("read"), io_read}, - {l_s("readfrom"), io_readfrom}, - {l_s("remove"), io_remove}, - {l_s("rename"), io_rename}, - {l_s("seek"), io_seek}, - {l_s("setlocale"), io_setloc}, - {l_s("time"), io_time}, - {l_s("tmpfile"), io_tmpfile}, - {l_s("tmpname"), io_tmpname}, - {l_s("write"), io_write}, - {l_s("writeto"), io_writeto}, - {l_s(LUA_ERRORMESSAGE), errorfb} + {"appendto", io_appendto}, + {"clock", io_clock}, + {"closefile", io_close}, + {"date", io_date}, + {"debug", io_debug}, + {"difftime", io_difftime}, + {"execute", io_execute}, + {"exit", io_exit}, + {"flush", io_flush}, + {"getenv", io_getenv}, + {"openfile", io_open}, + {"read", io_read}, + {"readfrom", io_readfrom}, + {"remove", io_remove}, + {"rename", io_rename}, + {"seek", io_seek}, + {"setlocale", io_setloc}, + {"time", io_time}, + {"tmpfile", io_tmpfile}, + {"tmpname", io_tmpname}, + {"write", io_write}, + {"writeto", io_writeto}, + {LUA_ERRORMESSAGE, errorfb} }; @@ -684,12 +683,12 @@ LUALIB_API int lua_iolibopen (lua_State *L) { /* predefined file handles */ newfilewithname(L, stdin, basicfiles[INFILE]); newfilewithname(L, stdout, basicfiles[OUTFILE]); - newfilewithname(L, stderr, l_s("_STDERR")); + newfilewithname(L, stderr, "_STDERR"); resetfile(L, INFILE); resetfile(L, OUTFILE); /* close files when collected */ lua_pushcfunction(L, file_collect); - lua_settagmethod(L, iotag, l_s("gc")); + lua_settagmethod(L, iotag, "gc"); return 0; } diff --git a/llex.c b/llex.c index 670da132..6fb02f17 100644 --- a/llex.c +++ b/llex.c @@ -1,5 +1,5 @@ /* -** $Id: llex.c,v 1.91 2001/08/31 19:46:07 roberto Exp $ +** $Id: llex.c,v 1.92 2001/11/16 16:29:10 roberto Exp $ ** Lexical Analyzer ** See Copyright Notice in lua.h */ @@ -9,7 +9,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "llex.h" @@ -26,13 +25,13 @@ /* ORDER RESERVED */ -static const l_char *const token2string [] = { - l_s("and"), l_s("break"), l_s("do"), l_s("else"), l_s("elseif"), - l_s("end"), l_s("for"), l_s("function"), l_s("global"), l_s("if"), - l_s("in"), l_s("local"), l_s("nil"), l_s("not"), l_s("or"), l_s("repeat"), - l_s("return"), l_s("then"), l_s("until"), l_s("while"), l_s(""), - l_s(".."), l_s("..."), l_s("=="), l_s(">="), l_s("<="), l_s("~="), - l_s(""), l_s(""), l_s("") +static const char *const token2string [] = { + "and", "break", "do", "else", "elseif", + "end", "for", "function", "global", "if", + "in", "local", "nil", "not", "or", "repeat", + "return", "then", "until", "while", "", + "..", "...", "==", ">=", "<=", "~=", + "", "", "" }; @@ -49,62 +48,62 @@ void luaX_init (lua_State *L) { #define MAXSRC 80 -void luaX_checklimit (LexState *ls, int val, int limit, const l_char *msg) { +void luaX_checklimit (LexState *ls, int val, int limit, const char *msg) { if (val > limit) { - l_char buff[90]; - sprintf(buff, l_s("too many %.40s (limit=%d)"), msg, limit); + char buff[90]; + sprintf(buff, "too many %.40s (limit=%d)", msg, limit); luaX_error(ls, buff, ls->t.token); } } -static void luaX_syntaxerror (LexState *ls, const l_char *s, - const l_char *token) { - l_char buff[MAXSRC]; +static void luaX_syntaxerror (LexState *ls, const char *s, + const char *token) { + char buff[MAXSRC]; luaO_chunkid(buff, getstr(ls->source), MAXSRC); luaO_verror(ls->L, - l_s("%.99s;\n last token read: `%.30s' at line %d in %.80s"), + "%.99s;\n last token read: `%.30s' at line %d in %.80s", s, token, ls->linenumber, buff); } -void luaX_token2str (int token, l_char *s) { +void luaX_token2str (int token, char *s) { if (token < FIRST_RESERVED) { - lua_assert(token == (l_char)token); - s[0] = (l_char)token; - s[1] = l_c('\0'); + lua_assert(token == (char)token); + s[0] = (char)token; + s[1] = '\0'; } else strcpy(s, token2string[token-FIRST_RESERVED]); } -static l_char *token2str_all (LexState *ls, int token, l_char *s) { +static char *token2str_all (LexState *ls, int token, char *s) { luaX_token2str(token, s); - if (s[0] == l_c('\0')) - return cast(l_char *, G(ls->L)->Mbuffer); + if (s[0] == '\0') + return cast(char *, G(ls->L)->Mbuffer); else return s; } -void luaX_error (LexState *ls, const l_char *s, int token) { - l_char buff[TOKEN_LEN]; +void luaX_error (LexState *ls, const char *s, int token) { + char buff[TOKEN_LEN]; luaX_syntaxerror(ls, s, token2str_all(ls, token, buff)); } static void luaX_invalidchar (LexState *ls, int c) { - l_char buff[8]; - sprintf(buff, l_s("0x%02X"), uchar(c)); - luaX_syntaxerror(ls, l_s("invalid control char"), buff); + char buff[8]; + sprintf(buff, "0x%02X", (unsigned char)c); + luaX_syntaxerror(ls, "invalid control char", buff); } static void inclinenumber (LexState *LS) { next(LS); /* skip `\n' */ ++LS->linenumber; - luaX_checklimit(LS, LS->linenumber, MAX_INT, l_s("lines in a chunk")); + luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk"); } @@ -117,10 +116,10 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) { LS->lastline = 1; LS->source = source; next(LS); /* read first char */ - if (LS->current == l_c('#')) { + if (LS->current == '#') { do { /* skip first line */ next(LS); - } while (LS->current != l_c('\n') && LS->current != EOZ); + } while (LS->current != '\n' && LS->current != EOZ); } } @@ -137,10 +136,10 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) { #define EXTRABUFF 128 #define checkbuffer(L, n, len) \ - if (((len)+(n))*sizeof(l_char) > G(L)->Mbuffsize) \ - luaO_openspace(L, (len)+(n)+EXTRABUFF, l_char) + if (((len)+(n))*sizeof(char) > G(L)->Mbuffsize) \ + luaO_openspace(L, (len)+(n)+EXTRABUFF, char) -#define save(L, c, l) (cast(l_char *, G(L)->Mbuffer)[l++] = (l_char)c) +#define save(L, c, l) (cast(char *, G(L)->Mbuffer)[l++] = (char)c) #define save_and_next(L, LS, l) (save(L, LS->current, l), next(LS)) @@ -151,8 +150,8 @@ static size_t readname (LexState *LS) { do { checkbuffer(L, 10, l); save_and_next(L, LS, l); - } while (isalnum(LS->current) || LS->current == l_c('_')); - save(L, l_c('\0'), l); + } while (isalnum(LS->current) || LS->current == '_'); + save(L, '\0', l); return l-1; } @@ -162,18 +161,18 @@ static void read_number (LexState *LS, int comma, SemInfo *seminfo) { lua_State *L = LS->L; size_t l = 0; checkbuffer(L, 10, l); - if (comma) save(L, l_c('.'), l); + if (comma) save(L, '.', l); while (isdigit(LS->current)) { checkbuffer(L, 10, l); save_and_next(L, LS, l); } - if (LS->current == l_c('.')) { + if (LS->current == '.') { save_and_next(L, LS, l); - if (LS->current == l_c('.')) { + if (LS->current == '.') { save_and_next(L, LS, l); - save(L, l_c('\0'), l); + save(L, '\0', l); luaX_error(LS, - l_s("ambiguous syntax (decimal point x string concatenation)"), + "ambiguous syntax (decimal point x string concatenation)", TK_NUMBER); } } @@ -181,18 +180,18 @@ static void read_number (LexState *LS, int comma, SemInfo *seminfo) { checkbuffer(L, 10, l); save_and_next(L, LS, l); } - if (LS->current == l_c('e') || LS->current == l_c('E')) { + if (LS->current == 'e' || LS->current == 'E') { save_and_next(L, LS, l); /* read `E' */ - if (LS->current == l_c('+') || LS->current == l_c('-')) + if (LS->current == '+' || LS->current == '-') save_and_next(L, LS, l); /* optional exponent sign */ while (isdigit(LS->current)) { checkbuffer(L, 10, l); save_and_next(L, LS, l); } } - save(L, l_c('\0'), l); - if (!luaO_str2d(cast(l_char *, G(L)->Mbuffer), &seminfo->r)) - luaX_error(LS, l_s("malformed number"), TK_NUMBER); + save(L, '\0', l); + if (!luaO_str2d(cast(char *, G(L)->Mbuffer), &seminfo->r)) + luaX_error(LS, "malformed number", TK_NUMBER); } @@ -201,34 +200,34 @@ static void read_long_string (LexState *LS, SemInfo *seminfo) { int cont = 0; size_t l = 0; checkbuffer(L, 10, l); - save(L, l_c('['), l); /* save first `[' */ + save(L, '[', l); /* save first `[' */ save_and_next(L, LS, l); /* pass the second `[' */ - if (LS->current == l_c('\n')) /* string starts with a newline? */ + if (LS->current == '\n') /* string starts with a newline? */ inclinenumber(LS); /* skip it */ for (;;) { checkbuffer(L, 10, l); switch (LS->current) { case EOZ: - save(L, l_c('\0'), l); - luaX_error(LS, l_s("unfinished long string"), TK_STRING); + save(L, '\0', l); + luaX_error(LS, "unfinished long string", TK_STRING); break; /* to avoid warnings */ - case l_c('['): + case '[': save_and_next(L, LS, l); - if (LS->current == l_c('[')) { + if (LS->current == '[') { cont++; save_and_next(L, LS, l); } continue; - case l_c(']'): + case ']': save_and_next(L, LS, l); - if (LS->current == l_c(']')) { + if (LS->current == ']') { if (cont == 0) goto endloop; cont--; save_and_next(L, LS, l); } continue; - case l_c('\n'): - save(L, l_c('\n'), l); + case '\n': + save(L, '\n', l); inclinenumber(LS); continue; default: @@ -236,8 +235,8 @@ static void read_long_string (LexState *LS, SemInfo *seminfo) { } } endloop: save_and_next(L, LS, l); /* skip the second `]' */ - save(L, l_c('\0'), l); - seminfo->ts = luaS_newlstr(L, cast(l_char *, G(L)->Mbuffer)+2, l-5); + save(L, '\0', l); + seminfo->ts = luaS_newlstr(L, cast(char *, G(L)->Mbuffer)+2, l-5); } @@ -249,21 +248,21 @@ static void read_string (LexState *LS, int del, SemInfo *seminfo) { while (LS->current != del) { checkbuffer(L, 10, l); switch (LS->current) { - case EOZ: case l_c('\n'): - save(L, l_c('\0'), l); - luaX_error(LS, l_s("unfinished string"), TK_STRING); + case EOZ: case '\n': + save(L, '\0', l); + luaX_error(LS, "unfinished string", TK_STRING); break; /* to avoid warnings */ - case l_c('\\'): + case '\\': next(LS); /* do not save the `\' */ switch (LS->current) { - case l_c('a'): save(L, l_c('\a'), l); next(LS); break; - case l_c('b'): save(L, l_c('\b'), l); next(LS); break; - case l_c('f'): save(L, l_c('\f'), l); next(LS); break; - case l_c('n'): save(L, l_c('\n'), l); next(LS); break; - case l_c('r'): save(L, l_c('\r'), l); next(LS); break; - case l_c('t'): save(L, l_c('\t'), l); next(LS); break; - case l_c('v'): save(L, l_c('\v'), l); next(LS); break; - case l_c('\n'): save(L, l_c('\n'), l); inclinenumber(LS); break; + case 'a': save(L, '\a', l); next(LS); break; + case 'b': save(L, '\b', l); next(LS); break; + case 'f': save(L, '\f', l); next(LS); break; + case 'n': save(L, '\n', l); next(LS); break; + case 'r': save(L, '\r', l); next(LS); break; + case 't': save(L, '\t', l); next(LS); break; + case 'v': save(L, '\v', l); next(LS); break; + case '\n': save(L, '\n', l); inclinenumber(LS); break; default: { if (!isdigit(LS->current)) save_and_next(L, LS, l); /* handles \\, \", \', and \? */ @@ -271,12 +270,12 @@ static void read_string (LexState *LS, int del, SemInfo *seminfo) { int c = 0; int i = 0; do { - c = 10*c + (LS->current-l_c('0')); + c = 10*c + (LS->current-'0'); next(LS); } while (++i<3 && isdigit(LS->current)); if (c > UCHAR_MAX) { - save(L, l_c('\0'), l); - luaX_error(LS, l_s("escape sequence too large"), TK_STRING); + save(L, '\0', l); + luaX_error(LS, "escape sequence too large", TK_STRING); } save(L, c, l); } @@ -288,8 +287,8 @@ static void read_string (LexState *LS, int del, SemInfo *seminfo) { } } save_and_next(L, LS, l); /* skip delimiter */ - save(L, l_c('\0'), l); - seminfo->ts = luaS_newlstr(L, cast(l_char *, G(L)->Mbuffer)+1, l-3); + save(L, '\0', l); + seminfo->ts = luaS_newlstr(L, cast(char *, G(L)->Mbuffer)+1, l-3); } @@ -297,70 +296,70 @@ int luaX_lex (LexState *LS, SemInfo *seminfo) { for (;;) { switch (LS->current) { - case l_c(' '): case l_c('\t'): case l_c('\r'): /* `\r' to avoid problems with DOS */ + case ' ': case '\t': case '\r': /* `\r' to avoid problems with DOS */ next(LS); continue; - case l_c('\n'): + case '\n': inclinenumber(LS); continue; - case l_c('$'): + case '$': luaX_error(LS, - l_s("unexpected `$' (pragmas are no longer supported)"), + "unexpected `$' (pragmas are no longer supported)", LS->current); break; - case l_c('-'): + case '-': next(LS); - if (LS->current != l_c('-')) return l_c('-'); - do { next(LS); } while (LS->current != l_c('\n') && LS->current != EOZ); + if (LS->current != '-') return '-'; + do { next(LS); } while (LS->current != '\n' && LS->current != EOZ); continue; - case l_c('['): + case '[': next(LS); - if (LS->current != l_c('[')) return l_c('['); + if (LS->current != '[') return '['; else { read_long_string(LS, seminfo); return TK_STRING; } - case l_c('='): + case '=': next(LS); - if (LS->current != l_c('=')) return l_c('='); + if (LS->current != '=') return '='; else { next(LS); return TK_EQ; } - case l_c('<'): + case '<': next(LS); - if (LS->current != l_c('=')) return l_c('<'); + if (LS->current != '=') return '<'; else { next(LS); return TK_LE; } - case l_c('>'): + case '>': next(LS); - if (LS->current != l_c('=')) return l_c('>'); + if (LS->current != '=') return '>'; else { next(LS); return TK_GE; } - case l_c('~'): + case '~': next(LS); - if (LS->current != l_c('=')) return l_c('~'); + if (LS->current != '=') return '~'; else { next(LS); return TK_NE; } - case l_c('"'): - case l_c('\''): + case '"': + case '\'': read_string(LS, LS->current, seminfo); return TK_STRING; - case l_c('.'): + case '.': next(LS); - if (LS->current == l_c('.')) { + if (LS->current == '.') { next(LS); - if (LS->current == l_c('.')) { + if (LS->current == '.') { next(LS); return TK_DOTS; /* ... */ } else return TK_CONCAT; /* .. */ } - else if (!isdigit(LS->current)) return l_c('.'); + else if (!isdigit(LS->current)) return '.'; else { read_number(LS, 1, seminfo); return TK_NUMBER; @@ -374,17 +373,17 @@ int luaX_lex (LexState *LS, SemInfo *seminfo) { read_number(LS, 0, seminfo); return TK_NUMBER; } - else if (isalpha(LS->current) || LS->current == l_c('_')) { + else if (isalpha(LS->current) || LS->current == '_') { /* identifier or reserved word */ size_t l = readname(LS); - TString *ts = luaS_newlstr(LS->L, cast(l_char *, G(LS->L)->Mbuffer), l); + TString *ts = luaS_newlstr(LS->L, cast(char *, G(LS->L)->Mbuffer), l); if (ts->tsv.marked >= RESERVEDMARK) /* reserved word? */ return ts->tsv.marked-RESERVEDMARK+FIRST_RESERVED; seminfo->ts = ts; return TK_NAME; } else { - l_charint c = LS->current; + int c = LS->current; if (iscntrl(c)) luaX_invalidchar(LS, c); next(LS); diff --git a/llex.h b/llex.h index 69242cee..d90ff2d7 100644 --- a/llex.h +++ b/llex.h @@ -1,5 +1,5 @@ /* -** $Id: llex.h,v 1.38 2001/08/31 19:46:07 roberto Exp $ +** $Id: llex.h,v 1.39 2001/11/16 16:29:10 roberto Exp $ ** Lexical Analyzer ** See Copyright Notice in lua.h */ @@ -14,7 +14,7 @@ #define FIRST_RESERVED 257 /* maximum length of a reserved word */ -#define TOKEN_LEN (sizeof(l_s("function"))/sizeof(l_char)) +#define TOKEN_LEN (sizeof("function")/sizeof(char)) /* @@ -49,7 +49,7 @@ typedef struct Token { typedef struct LexState { - l_charint current; /* current character */ + int current; /* current character (charint) */ Token t; /* current token */ Token lookahead; /* look ahead token */ struct FuncState *fs; /* `FuncState' is private to the parser */ @@ -64,9 +64,9 @@ typedef struct LexState { void luaX_init (lua_State *L); void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source); int luaX_lex (LexState *LS, SemInfo *seminfo); -void luaX_checklimit (LexState *ls, int val, int limit, const l_char *msg); -void luaX_error (LexState *ls, const l_char *s, int token); -void luaX_token2str (int token, l_char *s); +void luaX_checklimit (LexState *ls, int val, int limit, const char *msg); +void luaX_error (LexState *ls, const char *s, int token); +void luaX_token2str (int token, char *s); #endif diff --git a/lmathlib.c b/lmathlib.c index 4135d030..eb05fef2 100644 --- a/lmathlib.c +++ b/lmathlib.c @@ -1,5 +1,5 @@ /* -** $Id: lmathlib.c,v 1.37 2001/03/06 20:09:38 roberto Exp roberto $ +** $Id: lmathlib.c,v 1.38 2001/03/26 14:31:49 roberto Exp $ ** Standard mathematical library ** See Copyright Notice in lua.h */ @@ -8,7 +8,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lauxlib.h" @@ -177,18 +176,18 @@ static int math_random (lua_State *L) { } case 1: { /* only upper limit */ int u = luaL_check_int(L, 1); - luaL_arg_check(L, 1<=u, 1, l_s("interval is empty")); + luaL_arg_check(L, 1<=u, 1, "interval is empty"); lua_pushnumber(L, (int)(r*u)+1); /* integer between 1 and `u' */ break; } case 2: { /* lower and upper limits */ int l = luaL_check_int(L, 1); int u = luaL_check_int(L, 2); - luaL_arg_check(L, l<=u, 2, l_s("interval is empty")); + luaL_arg_check(L, l<=u, 2, "interval is empty"); lua_pushnumber(L, (int)(r*(u-l+1))+l); /* integer between `l' and `u' */ break; } - default: lua_error(L, l_s("wrong number of arguments")); + default: lua_error(L, "wrong number of arguments"); } return 1; } @@ -201,29 +200,29 @@ static int math_randomseed (lua_State *L) { static const luaL_reg mathlib[] = { -{l_s("abs"), math_abs}, -{l_s("sin"), math_sin}, -{l_s("cos"), math_cos}, -{l_s("tan"), math_tan}, -{l_s("asin"), math_asin}, -{l_s("acos"), math_acos}, -{l_s("atan"), math_atan}, -{l_s("atan2"), math_atan2}, -{l_s("ceil"), math_ceil}, -{l_s("floor"), math_floor}, -{l_s("mod"), math_mod}, -{l_s("frexp"), math_frexp}, -{l_s("ldexp"), math_ldexp}, -{l_s("sqrt"), math_sqrt}, -{l_s("min"), math_min}, -{l_s("max"), math_max}, -{l_s("log"), math_log}, -{l_s("log10"), math_log10}, -{l_s("exp"), math_exp}, -{l_s("deg"), math_deg}, -{l_s("rad"), math_rad}, -{l_s("random"), math_random}, -{l_s("randomseed"), math_randomseed} +{"abs", math_abs}, +{"sin", math_sin}, +{"cos", math_cos}, +{"tan", math_tan}, +{"asin", math_asin}, +{"acos", math_acos}, +{"atan", math_atan}, +{"atan2", math_atan2}, +{"ceil", math_ceil}, +{"floor", math_floor}, +{"mod", math_mod}, +{"frexp", math_frexp}, +{"ldexp", math_ldexp}, +{"sqrt", math_sqrt}, +{"min", math_min}, +{"max", math_max}, +{"log", math_log}, +{"log10", math_log10}, +{"exp", math_exp}, +{"deg", math_deg}, +{"rad", math_rad}, +{"random", math_random}, +{"randomseed", math_randomseed} }; /* @@ -232,9 +231,9 @@ static const luaL_reg mathlib[] = { LUALIB_API int lua_mathlibopen (lua_State *L) { luaL_openl(L, mathlib); lua_pushcfunction(L, math_pow); - lua_settagmethod(L, LUA_TNUMBER, l_s("pow")); + lua_settagmethod(L, LUA_TNUMBER, "pow"); lua_pushnumber(L, PI); - lua_setglobal(L, l_s("PI")); + lua_setglobal(L, "PI"); return 0; } diff --git a/lmem.c b/lmem.c index 32318815..33181016 100644 --- a/lmem.c +++ b/lmem.c @@ -1,5 +1,5 @@ /* -** $Id: lmem.c,v 1.50 2001/08/31 19:46:07 roberto Exp $ +** $Id: lmem.c,v 1.51 2001/10/25 19:13:33 roberto Exp $ ** Interface to Memory Manager ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include -#define LUA_PRIVATE #include "lua.h" #include "ldo.h" @@ -27,7 +26,7 @@ void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems, - int limit, const l_char *errormsg) { + int limit, const char *errormsg) { void *newblock; int newsize = (*size)*2; if (newsize < MINSIZEARRAY) @@ -54,7 +53,7 @@ void *luaM_realloc (lua_State *L, void *block, lu_mem oldsize, lu_mem size) { block = NULL; } else if (size >= MAX_SIZET) - luaD_error(L, l_s("memory allocation error: block too big")); + luaD_error(L, "memory allocation error: block too big"); else { block = l_realloc(block, oldsize, size); if (block == NULL) { diff --git a/lmem.h b/lmem.h index 1164e359..bb0ba5a9 100644 --- a/lmem.h +++ b/lmem.h @@ -1,5 +1,5 @@ /* -** $Id: lmem.h,v 1.22 2001/02/23 17:17:25 roberto Exp $ +** $Id: lmem.h,v 1.24 2001/09/07 17:30:16 roberto Exp $ ** Interface to Memory Manager ** See Copyright Notice in lua.h */ @@ -16,7 +16,7 @@ void *luaM_realloc (lua_State *L, void *oldblock, lu_mem oldsize, lu_mem size); void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem, - int limit, const l_char *errormsg); + int limit, const char *errormsg); #define luaM_free(L, b, s) luaM_realloc(L, (b), (s), 0) #define luaM_freelem(L, b) luaM_realloc(L, (b), sizeof(*(b)), 0) diff --git a/lobject.c b/lobject.c index 3dfafde4..67ba2b62 100644 --- a/lobject.c +++ b/lobject.c @@ -1,5 +1,5 @@ /* -** $Id: lobject.c,v 1.70 2001/03/26 14:31:49 roberto Exp $ +** $Id: lobject.c,v 1.71 2001/10/25 19:14:14 roberto Exp $ ** Some generic functions over Lua objects ** See Copyright Notice in lua.h */ @@ -10,7 +10,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "ldo.h" @@ -73,12 +72,12 @@ void *luaO_openspaceaux (lua_State *L, size_t n) { } -int luaO_str2d (const l_char *s, lua_Number *result) { - l_char *endptr; +int luaO_str2d (const char *s, lua_Number *result) { + char *endptr; lua_Number res = lua_str2number(s, &endptr); if (endptr == s) return 0; /* no conversion */ - while (isspace(uchar(*endptr))) endptr++; - if (*endptr != l_c('\0')) return 0; /* invalid trailing characters? */ + while (isspace((unsigned char)(*endptr))) endptr++; + if (*endptr != '\0') return 0; /* invalid trailing characters? */ *result = res; return 1; } @@ -88,9 +87,9 @@ int luaO_str2d (const l_char *s, lua_Number *result) { #define MAX_VERROR 280 /* this function needs to handle only '%d' and '%.XXs' formats */ -void luaO_verror (lua_State *L, const l_char *fmt, ...) { +void luaO_verror (lua_State *L, const char *fmt, ...) { va_list argp; - l_char buff[MAX_VERROR]; /* to hold formatted message */ + char buff[MAX_VERROR]; /* to hold formatted message */ va_start(argp, fmt); vsprintf(buff, fmt, argp); va_end(argp); @@ -98,36 +97,36 @@ void luaO_verror (lua_State *L, const l_char *fmt, ...) { } -void luaO_chunkid (l_char *out, const l_char *source, int bufflen) { - if (*source == l_c('=')) { +void luaO_chunkid (char *out, const char *source, int bufflen) { + if (*source == '=') { strncpy(out, source+1, bufflen); /* remove first char */ - out[bufflen-1] = l_c('\0'); /* ensures null termination */ + out[bufflen-1] = '\0'; /* ensures null termination */ } else { - if (*source == l_c('@')) { + if (*source == '@') { int l; source++; /* skip the `@' */ - bufflen -= sizeof(l_s("file `...%s'")); + bufflen -= sizeof("file `...%s'"); l = strlen(source); if (l>bufflen) { source += (l-bufflen); /* get last part of file name */ - sprintf(out, l_s("file `...%.99s'"), source); + sprintf(out, "file `...%.99s'", source); } else - sprintf(out, l_s("file `%.99s'"), source); + sprintf(out, "file `%.99s'", source); } else { - int len = strcspn(source, l_s("\n")); /* stop at first newline */ - bufflen -= sizeof(l_s("string \"%.*s...\"")); + int len = strcspn(source, "\n"); /* stop at first newline */ + bufflen -= sizeof("string \"%.*s...\""); if (len > bufflen) len = bufflen; - if (source[len] != l_c('\0')) { /* must truncate? */ - strcpy(out, l_s("string \"")); + if (source[len] != '\0') { /* must truncate? */ + strcpy(out, "string \""); out += strlen(out); strncpy(out, source, len); - strcpy(out+len, l_s("...\"")); + strcpy(out+len, "...\""); } else - sprintf(out, l_s("string \"%.99s\""), source); + sprintf(out, "string \"%.99s\"", source); } } } diff --git a/lobject.h b/lobject.h index d8e6057f..3e1e8b36 100644 --- a/lobject.h +++ b/lobject.h @@ -1,5 +1,5 @@ /* -** $Id: lobject.h,v 1.115 2001/10/25 19:14:14 roberto Exp $ +** $Id: lobject.h,v 1.116 2001/11/06 21:41:53 roberto Exp $ ** Type definitions for Lua objects ** See Copyright Notice in lua.h */ @@ -114,7 +114,7 @@ typedef union TString { } TString; -#define getstr(ts) cast(l_char *, (ts) + 1) +#define getstr(ts) cast(char *, (ts) + 1) #define svalue(o) getstr(tsvalue(o)) @@ -277,10 +277,10 @@ int luaO_log2 (unsigned int x); void *luaO_openspaceaux (lua_State *L, size_t n); int luaO_equalObj (const TObject *t1, const TObject *t2); -int luaO_str2d (const l_char *s, lua_Number *result); +int luaO_str2d (const char *s, lua_Number *result); -void luaO_verror (lua_State *L, const l_char *fmt, ...); -void luaO_chunkid (l_char *out, const l_char *source, int len); +void luaO_verror (lua_State *L, const char *fmt, ...); +void luaO_chunkid (char *out, const char *source, int len); #endif diff --git a/lopcodes.c b/lopcodes.c index ae5f37e3..c0974d96 100644 --- a/lopcodes.c +++ b/lopcodes.c @@ -1,12 +1,11 @@ /* -** $Id: lopcodes.c,v 1.5 2001/09/07 17:39:10 roberto Exp $ +** $Id: lopcodes.c,v 1.6 2001/10/25 19:14:14 roberto Exp $ ** extracted automatically from lopcodes.h by mkprint.lua ** DO NOT EDIT ** See Copyright Notice in lua.h */ -#define LUA_PRIVATE #include "lua.h" #include "lobject.h" @@ -15,48 +14,48 @@ #ifdef LUA_OPNAMES -const l_char *const luaP_opnames[] = { - l_s("MOVE"), - l_s("LOADK"), - l_s("LOADINT"), - l_s("LOADNIL"), - l_s("GETUPVAL"), - l_s("GETGLOBAL"), - l_s("GETTABLE"), - l_s("SETGLOBAL"), - l_s("SETUPVAL"), - l_s("SETTABLE"), - l_s("NEWTABLE"), - l_s("SELF"), - l_s("ADD"), - l_s("SUB"), - l_s("MUL"), - l_s("DIV"), - l_s("POW"), - l_s("UNM"), - l_s("NOT"), - l_s("CONCAT"), - l_s("JMP"), - l_s("CJMP"), - l_s("TESTEQ"), - l_s("TESTNE"), - l_s("TESTLT"), - l_s("TESTLE"), - l_s("TESTGT"), - l_s("TESTGE"), - l_s("TESTT"), - l_s("TESTF"), - l_s("NILJMP"), - l_s("CALL"), - l_s("RETURN"), - l_s("FORPREP"), - l_s("FORLOOP"), - l_s("TFORPREP"), - l_s("TFORLOOP"), - l_s("SETLIST"), - l_s("SETLISTO"), - l_s("CLOSE"), - l_s("CLOSURE") +const char *const luaP_opnames[] = { + "MOVE", + "LOADK", + "LOADINT", + "LOADNIL", + "GETUPVAL", + "GETGLOBAL", + "GETTABLE", + "SETGLOBAL", + "SETUPVAL", + "SETTABLE", + "NEWTABLE", + "SELF", + "ADD", + "SUB", + "MUL", + "DIV", + "POW", + "UNM", + "NOT", + "CONCAT", + "JMP", + "CJMP", + "TESTEQ", + "TESTNE", + "TESTLT", + "TESTLE", + "TESTGT", + "TESTGE", + "TESTT", + "TESTF", + "NILJMP", + "CALL", + "RETURN", + "FORPREP", + "FORLOOP", + "TFORPREP", + "TFORLOOP", + "SETLIST", + "SETLISTO", + "CLOSE", + "CLOSURE" }; #endif diff --git a/lopcodes.h b/lopcodes.h index 8afd2d4e..ce09a7a4 100644 --- a/lopcodes.h +++ b/lopcodes.h @@ -1,5 +1,5 @@ /* -** $Id: lopcodes.h,v 1.81 2001/09/07 17:39:10 roberto Exp $ +** $Id: lopcodes.h,v 1.82 2001/10/25 19:14:14 roberto Exp $ ** Opcodes for Lua virtual machine ** See Copyright Notice in lua.h */ @@ -224,7 +224,7 @@ extern const lu_byte luaP_opmodes[NUM_OPCODES]; /* ** opcode names (only included when compiled with LUA_OPNAMES) */ -extern const l_char *const luaP_opnames[]; +extern const char *const luaP_opnames[]; #endif diff --git a/lparser.c b/lparser.c index 744c9ce6..f5d722c4 100644 --- a/lparser.c +++ b/lparser.c @@ -1,5 +1,5 @@ /* -** $Id: lparser.c,v 1.159 2001/10/02 16:41:36 roberto Exp $ +** $Id: lparser.c,v 1.160 2001/10/25 19:14:14 roberto Exp $ ** Lua Parser ** See Copyright Notice in lua.h */ @@ -8,7 +8,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lcode.h" @@ -76,9 +75,9 @@ static void lookahead (LexState *ls) { static void error_expected (LexState *ls, int token) { - l_char buff[30], t[TOKEN_LEN]; + char buff[30], t[TOKEN_LEN]; luaX_token2str(token, t); - sprintf(buff, l_s("`%.10s' expected"), t); + sprintf(buff, "`%.10s' expected", t); luaK_error(ls, buff); } @@ -90,7 +89,7 @@ static void check (LexState *ls, int c) { } -static void check_condition (LexState *ls, int c, const l_char *msg) { +static void check_condition (LexState *ls, int c, const char *msg) { if (!c) luaK_error(ls, msg); } @@ -109,11 +108,11 @@ static void check_match (LexState *ls, int what, int who, int where) { if (where == ls->linenumber) error_expected(ls, what); else { - l_char buff[70]; - l_char t_what[TOKEN_LEN], t_who[TOKEN_LEN]; + char buff[70]; + char t_what[TOKEN_LEN], t_who[TOKEN_LEN]; luaX_token2str(what, t_what); luaX_token2str(who, t_who); - sprintf(buff, l_s("`%.10s' expected (to close `%.10s' at line %d)"), + sprintf(buff, "`%.10s' expected (to close `%.10s' at line %d)", t_what, t_who, where); luaK_error(ls, buff); } @@ -123,7 +122,7 @@ static void check_match (LexState *ls, int what, int who, int where) { static TString *str_checkname (LexState *ls) { - check_condition(ls, (ls->t.token == TK_NAME), l_s(" expected")); + check_condition(ls, (ls->t.token == TK_NAME), " expected"); return ls->t.seminfo.ts; } @@ -150,7 +149,7 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) { FuncState *fs = ls->fs; Proto *f = fs->f; luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, - LocVar, MAX_INT, l_s("")); + LocVar, MAX_INT, ""); f->locvars[fs->nlocvars].varname = varname; return fs->nlocvars++; } @@ -158,7 +157,7 @@ static int luaI_registerlocalvar (LexState *ls, TString *varname) { static void new_localvar (LexState *ls, TString *name, int n) { FuncState *fs = ls->fs; - luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, l_s("local variables")); + luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, "local variables"); fs->actloc[fs->nactloc+n] = luaI_registerlocalvar(ls, name); } @@ -194,7 +193,7 @@ static void removelocalvars (LexState *ls, int nvars, int toclose) { } -static void new_localvarstr (LexState *ls, const l_char *name, int n) { +static void new_localvarstr (LexState *ls, const char *name, int n) { new_localvar(ls, luaS_new(ls->L, name), n); } @@ -206,7 +205,7 @@ static int indexupvalue (FuncState *fs, expdesc *v) { return i; } /* new one */ - luaX_checklimit(fs->ls, fs->f->nupvalues+1, MAXUPVALUES, l_s("upvalues")); + luaX_checklimit(fs->ls, fs->f->nupvalues+1, MAXUPVALUES, "upvalues"); fs->upvalues[fs->f->nupvalues] = *v; return fs->f->nupvalues++; } @@ -263,11 +262,11 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { static void code_params (LexState *ls, int nparams, short dots) { FuncState *fs = ls->fs; adjustlocalvars(ls, nparams); - luaX_checklimit(ls, fs->nactloc, MAXPARAMS, l_s("parameters")); + luaX_checklimit(ls, fs->nactloc, MAXPARAMS, "parameters"); fs->f->numparams = cast(short, fs->nactloc); /* `self' could be there already */ fs->f->is_vararg = dots; if (dots) { - new_localvarstr(ls, l_s("arg"), 0); + new_localvarstr(ls, "arg", 0); adjustlocalvars(ls, 1); } luaK_reserveregs(fs, fs->nactloc); /* reserve register for parameters */ @@ -294,7 +293,7 @@ static void pushclosure (LexState *ls, FuncState *func, expdesc *v) { Proto *f = fs->f; int i; luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *, - MAXARG_Bc, l_s("constant table overflow")); + MAXARG_Bc, "constant table overflow"); f->p[fs->np++] = func->f; init_exp(v, VRELOCABLE, luaK_codeABc(fs, OP_CLOSURE, 0, fs->np-1)); for (i=0; if->nupvalues; i++) { @@ -366,7 +365,7 @@ Proto *luaY_parser (lua_State *L, ZIO *z) { next(&lexstate); /* read first token */ chunk(&lexstate); check_condition(&lexstate, (lexstate.t.token == TK_EOS), - l_s(" expected")); + " expected"); close_func(&lexstate); lua_assert(funcstate.prev == NULL); lua_assert(funcstate.f->nupvalues == 0); @@ -396,7 +395,7 @@ static void luaY_index (LexState *ls, expdesc *v) { next(ls); /* skip the '[' */ expr(ls, v); luaK_exp2val(ls->fs, v); - check(ls, l_c(']')); + check(ls, ']'); } @@ -404,7 +403,7 @@ static int explist1 (LexState *ls, expdesc *v) { /* explist1 -> expr { `,' expr } */ int n = 1; /* at least one expression */ expr(ls, v); - while (ls->t.token == l_c(',')) { + while (ls->t.token == ',') { next(ls); /* skip comma */ luaK_exp2nextreg(ls->fs, v); expr(ls, v); @@ -419,21 +418,21 @@ static void funcargs (LexState *ls, expdesc *f) { expdesc args; int base, nparams; switch (ls->t.token) { - case l_c('('): { /* funcargs -> `(' [ explist1 ] `)' */ + case '(': { /* funcargs -> `(' [ explist1 ] `)' */ int line = ls->linenumber; if (line != ls->lastline) - luaK_error(ls, l_s("ambiguous syntax (function call x new statement)")); + luaK_error(ls, "ambiguous syntax (function call x new statement)"); next(ls); - if (ls->t.token == l_c(')')) /* arg list is empty? */ + if (ls->t.token == ')') /* arg list is empty? */ args.k = VVOID; else { explist1(ls, &args); luaK_setcallreturns(fs, &args, LUA_MULTRET); } - check_match(ls, l_c(')'), l_c('('), line); + check_match(ls, ')', '(', line); break; } - case l_c('{'): { /* funcargs -> constructor */ + case '{': { /* funcargs -> constructor */ constructor(ls, &args); break; } @@ -443,7 +442,7 @@ static void funcargs (LexState *ls, expdesc *f) { break; } default: { - luaK_error(ls, l_s("function arguments expected")); + luaK_error(ls, "function arguments expected"); break; } } @@ -480,13 +479,13 @@ static void recfield (LexState *ls, expdesc *t) { checkname(ls, &key); break; } - case l_c('['): { + case '[': { luaY_index(ls, &key); break; } - default: luaK_error(ls, l_s(" or `[' expected")); + default: luaK_error(ls, " or `[' expected"); } - check(ls, l_c('=')); + check(ls, '='); luaK_exp2RK(fs, &key); expr(ls, &val); luaK_exp2anyreg(fs, &val); @@ -497,9 +496,9 @@ static void recfield (LexState *ls, expdesc *t) { static int anotherfield (LexState *ls) { - if (ls->t.token != l_c(',')) return 0; + if (ls->t.token != ',') return 0; next(ls); /* skip the comma */ - return (ls->t.token != l_c(';') && ls->t.token != l_c('}')); + return (ls->t.token != ';' && ls->t.token != '}'); } @@ -508,7 +507,7 @@ static int recfields (LexState *ls, expdesc *t) { int n = 0; do { /* at least one element */ recfield(ls, t); - luaX_checklimit(ls, n, MAX_INT, l_s("items in a constructor")); + luaX_checklimit(ls, n, MAX_INT, "items in a constructor"); n++; } while (anotherfield(ls)); return n; @@ -525,7 +524,7 @@ static int listfields (LexState *ls, expdesc *t) { expr(ls, &v); while (anotherfield(ls)) { luaK_exp2nextreg(fs, &v); - luaX_checklimit(ls, n, MAXARG_Bc, l_s("items in a constructor")); + luaX_checklimit(ls, n, MAXARG_Bc, "items in a constructor"); if (n%LFIELDS_PER_FLUSH == 0) { luaK_codeABc(fs, OP_SETLIST, t->u.i.info, n-1); /* flush */ fs->freereg = reg; /* free registers */ @@ -548,18 +547,18 @@ static int listfields (LexState *ls, expdesc *t) { static void constructor_part (LexState *ls, expdesc *t, Constdesc *cd) { switch (ls->t.token) { - case l_c(';'): case l_c('}'): { /* constructor_part -> empty */ + case ';': case '}': { /* constructor_part -> empty */ cd->narray = cd->nhash = 0; cd->k = ls->t.token; break; } case TK_NAME: { /* may be listfields or recfields */ lookahead(ls); - if (ls->lookahead.token != l_c('=')) /* expression? */ + if (ls->lookahead.token != '=') /* expression? */ goto case_default; /* else go through to recfields */ } - case l_c('['): { /* constructor_part -> recfields */ + case '[': { /* constructor_part -> recfields */ cd->nhash = recfields(ls, t); cd->narray = 0; cd->k = 1; /* record */ @@ -586,18 +585,18 @@ static void constructor (LexState *ls, expdesc *t) { pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); init_exp(t, VRELOCABLE, pc); luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */ - check(ls, l_c('{')); + check(ls, '{'); constructor_part(ls, t, &cd); na = cd.narray; nh = cd.nhash; - if (optional(ls, l_c(';'))) { + if (optional(ls, ';')) { Constdesc other_cd; constructor_part(ls, t, &other_cd); - check_condition(ls,(cd.k != other_cd.k), l_s("invalid constructor syntax")); + check_condition(ls,(cd.k != other_cd.k), "invalid constructor syntax"); na += other_cd.narray; nh += other_cd.nhash; } - check_match(ls, l_c('}'), l_c('{'), line); + check_match(ls, '}', '{', line); if (na > 0) SETARG_B(fs->f->code[pc], luaO_log2(na-1)+2); /* set initial table size */ SETARG_C(fs->f->code[pc], luaO_log2(nh)+1); /* set initial table size */ @@ -618,10 +617,10 @@ static void constructor (LexState *ls, expdesc *t) { static void prefixexp (LexState *ls, expdesc *v) { /* prefixexp -> NAME | '(' expr ')' */ switch (ls->t.token) { - case l_c('('): { + case '(': { next(ls); expr(ls, v); - check(ls, l_c(')')); + check(ls, ')'); luaK_dischargevars(ls->fs, v); return; } @@ -630,15 +629,15 @@ static void prefixexp (LexState *ls, expdesc *v) { next(ls); return; } - case l_c('%'): { /* for compatibility only */ + case '%': { /* for compatibility only */ next(ls); /* skip `%' */ singlevar(ls->fs, str_checkname(ls), v, 1); - check_condition(ls, v->k == VUPVAL, l_s("global upvalues are obsolete")); + check_condition(ls, v->k == VUPVAL, "global upvalues are obsolete"); next(ls); return; } default: { - luaK_error(ls, l_s("unexpected symbol")); + luaK_error(ls, "unexpected symbol"); return; } } @@ -652,18 +651,18 @@ static void primaryexp (LexState *ls, expdesc *v) { prefixexp(ls, v); for (;;) { switch (ls->t.token) { - case l_c('.'): { /* field */ + case '.': { /* field */ luaY_field(ls, v); break; } - case l_c('['): { /* `[' exp1 `]' */ + case '[': { /* `[' exp1 `]' */ expdesc key; luaK_exp2anyreg(fs, v); luaY_index(ls, &key); luaK_indexed(fs, v, &key); break; } - case l_c(':'): { /* `:' NAME funcargs */ + case ':': { /* `:' NAME funcargs */ expdesc key; next(ls); checkname(ls, &key); @@ -671,7 +670,7 @@ static void primaryexp (LexState *ls, expdesc *v) { funcargs(ls, v); break; } - case l_c('('): case TK_STRING: case l_c('{'): { /* funcargs */ + case '(': case TK_STRING: case '{': { /* funcargs */ luaK_exp2nextreg(fs, v); funcargs(ls, v); break; @@ -702,7 +701,7 @@ static void simpleexp (LexState *ls, expdesc *v) { next(ls); break; } - case l_c('{'): { /* constructor */ + case '{': { /* constructor */ constructor(ls, v); break; } @@ -724,7 +723,7 @@ static void simpleexp (LexState *ls, expdesc *v) { static UnOpr getunopr (int op) { switch (op) { case TK_NOT: return OPR_NOT; - case l_c('-'): return OPR_MINUS; + case '-': return OPR_MINUS; default: return OPR_NOUNOPR; } } @@ -732,17 +731,17 @@ static UnOpr getunopr (int op) { static BinOpr getbinopr (int op) { switch (op) { - case l_c('+'): return OPR_ADD; - case l_c('-'): return OPR_SUB; - case l_c('*'): return OPR_MULT; - case l_c('/'): return OPR_DIV; - case l_c('^'): return OPR_POW; + case '+': return OPR_ADD; + case '-': return OPR_SUB; + case '*': return OPR_MULT; + case '/': return OPR_DIV; + case '^': return OPR_POW; case TK_CONCAT: return OPR_CONCAT; case TK_NE: return OPR_NE; case TK_EQ: return OPR_EQ; - case l_c('<'): return OPR_LT; + case '<': return OPR_LT; case TK_LE: return OPR_LE; - case l_c('>'): return OPR_GT; + case '>': return OPR_GT; case TK_GE: return OPR_GE; case TK_AND: return OPR_AND; case TK_OR: return OPR_OR; @@ -870,8 +869,8 @@ static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { expdesc e; check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED, - l_s("syntax error!")); - if (ls->t.token == l_c(',')) { /* assignment -> `,' primaryexp assignment */ + "syntax error!"); + if (ls->t.token == ',') { /* assignment -> `,' primaryexp assignment */ struct LHS_assign nv; nv.prev = lh; next(ls); @@ -882,7 +881,7 @@ static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { } else { /* assignment -> `=' explist1 */ int nexps; - check(ls, l_c('=')); + check(ls, '='); nexps = explist1(ls, &e); if (nexps != nvars) { adjust_assign(ls, nvars, nexps, &e); @@ -965,19 +964,19 @@ static void forbody (LexState *ls, int nvar, OpCode prepfor, OpCode loopfor) { static void fornum (LexState *ls, TString *varname) { /* fornum -> NAME = exp1,exp1[,exp1] forbody */ FuncState *fs = ls->fs; - check(ls, l_c('=')); + check(ls, '='); exp1(ls); /* initial value */ - check(ls, l_c(',')); + check(ls, ','); exp1(ls); /* limit */ - if (optional(ls, l_c(','))) + if (optional(ls, ',')) exp1(ls); /* optional step */ else { luaK_codeAsBc(fs, OP_LOADINT, fs->freereg, 1); /* default step */ luaK_reserveregs(fs, 1); } new_localvar(ls, varname, 0); - new_localvarstr(ls, l_s("(limit)"), 1); - new_localvarstr(ls, l_s("(step)"), 2); + new_localvarstr(ls, "(limit)", 1); + new_localvarstr(ls, "(step)", 2); forbody(ls, 3, OP_FORPREP, OP_FORLOOP); } @@ -985,13 +984,13 @@ static void fornum (LexState *ls, TString *varname) { static void forlist (LexState *ls, TString *indexname) { /* forlist -> NAME,NAME IN exp1 forbody */ TString *valname; - check(ls, l_c(',')); + check(ls, ','); valname = str_checkname(ls); next(ls); /* skip var name */ check(ls, TK_IN); exp1(ls); /* table */ - new_localvarstr(ls, l_s("(table)"), 0); - new_localvarstr(ls, l_s("(index)"), 1); + new_localvarstr(ls, "(table)", 0); + new_localvarstr(ls, "(index)", 1); new_localvar(ls, indexname, 2); new_localvar(ls, valname, 3); luaK_reserveregs(ls->fs, 3); /* registers for control, index and val */ @@ -1009,9 +1008,9 @@ static void forstat (LexState *ls, int line) { varname = str_checkname(ls); /* first variable name */ next(ls); /* skip var name */ switch (ls->t.token) { - case l_c('='): fornum(ls, varname); break; - case l_c(','): forlist(ls, varname); break; - default: luaK_error(ls, l_s("`=' or `,' expected")); + case '=': fornum(ls, varname); break; + case ',': forlist(ls, varname); break; + default: luaK_error(ls, "`=' or `,' expected"); } check_match(ls, TK_END, TK_FOR, line); leavebreak(fs, &bl); @@ -1060,8 +1059,8 @@ static void localstat (LexState *ls) { next(ls); /* skip LOCAL or `,' */ new_localvar(ls, str_checkname(ls), nvars++); next(ls); /* skip var name */ - } while (ls->t.token == l_c(',')); - if (optional(ls, l_c('='))) + } while (ls->t.token == ','); + if (optional(ls, '=')) nexps = explist1(ls, &e); else { e.k = VVOID; @@ -1077,10 +1076,10 @@ static int funcname (LexState *ls, expdesc *v) { int needself = 0; singlevar(ls->fs, str_checkname(ls), v, 1); next(ls); /* skip var name */ - while (ls->t.token == l_c('.')) { + while (ls->t.token == '.') { luaY_field(ls, v); } - if (ls->t.token == l_c(':')) { + if (ls->t.token == ':') { needself = 1; luaY_field(ls, v); } @@ -1120,7 +1119,7 @@ static void retstat (LexState *ls) { expdesc e; int first, nret; /* registers with returned values */ next(ls); /* skip RETURN */ - if (block_follow(ls->t.token) || ls->t.token == l_c(';')) + if (block_follow(ls->t.token) || ls->t.token == ';') first = nret = 0; /* return no values */ else { explist1(ls, &e); /* optional return values */ @@ -1145,7 +1144,7 @@ static void breakstat (LexState *ls) { FuncState *fs = ls->fs; Breaklabel *bl = fs->bl; if (!bl) - luaK_error(ls, l_s("no loop to break")); + luaK_error(ls, "no loop to break"); next(ls); /* skip BREAK */ closelevel(ls, bl->nactloc); luaK_concat(fs, &bl->breaklist, luaK_jump(fs)); @@ -1205,15 +1204,15 @@ static void parlist (LexState *ls) { /* parlist -> [ param { `,' param } ] */ int nparams = 0; short dots = 0; - if (ls->t.token != l_c(')')) { /* is `parlist' not empty? */ + if (ls->t.token != ')') { /* is `parlist' not empty? */ do { switch (ls->t.token) { case TK_DOTS: dots = 1; break; case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break; - default: luaK_error(ls, l_s(" or `...' expected")); + default: luaK_error(ls, " or `...' expected"); } next(ls); - } while (!dots && optional(ls, l_c(','))); + } while (!dots && optional(ls, ',')); } code_params(ls, nparams, dots); } @@ -1224,13 +1223,13 @@ static void body (LexState *ls, expdesc *e, int needself, int line) { FuncState new_fs; open_func(ls, &new_fs); new_fs.f->lineDefined = line; - check(ls, l_c('(')); + check(ls, '('); if (needself) { - new_localvarstr(ls, l_s("self"), 0); + new_localvarstr(ls, "self", 0); adjustlocalvars(ls, 1); } parlist(ls); - check(ls, l_c(')')); + check(ls, ')'); chunk(ls); check_match(ls, TK_END, TK_FUNCTION, line); close_func(ls); @@ -1246,7 +1245,7 @@ static void chunk (LexState *ls) { int islast = 0; while (!islast && !block_follow(ls->t.token)) { islast = statement(ls); - optional(ls, l_c(';')); + optional(ls, ';'); lua_assert(ls->fs->freereg >= ls->fs->nactloc); ls->fs->freereg = ls->fs->nactloc; /* free registers */ } diff --git a/lstate.c b/lstate.c index 40b3dc27..a9130455 100644 --- a/lstate.c +++ b/lstate.c @@ -1,5 +1,5 @@ /* -** $Id: lstate.c,v 1.71 2001/10/31 19:58:11 roberto Exp $ +** $Id: lstate.c,v 1.72 2001/11/06 21:40:51 roberto Exp $ ** Global State ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include -#define LUA_PRIVATE #include "lua.h" #include "ldo.h" @@ -120,7 +119,7 @@ static void close_state (lua_State *L, lua_State *OL) { lua_assert(G(L)->roottable == NULL); luaS_freeall(L); luaM_freearray(L, G(L)->TMtable, G(L)->sizeTM, struct TM); - luaM_freearray(L, G(L)->Mbuffer, G(L)->Mbuffsize, l_char); + luaM_freearray(L, G(L)->Mbuffer, G(L)->Mbuffsize, char); luaM_freelem(NULL, L->_G); } luaM_freearray(OL, L->stack, L->stacksize, TObject); diff --git a/lstring.c b/lstring.c index a5e0205d..5f69aafc 100644 --- a/lstring.c +++ b/lstring.c @@ -1,5 +1,5 @@ /* -** $Id: lstring.c,v 1.66 2001/08/27 15:16:28 roberto Exp $ +** $Id: lstring.c,v 1.67 2001/08/31 19:46:07 roberto Exp $ ** String table (keeps all strings handled by Lua) ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include -#define LUA_PRIVATE #include "lua.h" #include "lmem.h" @@ -47,15 +46,15 @@ void luaS_resize (lua_State *L, int newsize) { } -static TString *newlstr (lua_State *L, const l_char *str, size_t l, lu_hash h) { +static TString *newlstr (lua_State *L, const char *str, size_t l, lu_hash h) { TString *ts = cast(TString *, luaM_malloc(L, sizestring(l))); stringtable *tb; ts->tsv.nexthash = NULL; ts->tsv.len = l; ts->tsv.hash = h; ts->tsv.marked = 0; - memcpy(getstr(ts), str, l*sizeof(l_char)); - getstr(ts)[l] = l_c('\0'); /* ending 0 */ + memcpy(getstr(ts), str, l*sizeof(char)); + getstr(ts)[l] = '\0'; /* ending 0 */ tb = &G(L)->strt; h = lmod(h, tb->size); ts->tsv.nexthash = tb->hash[h]; /* chain new entry */ @@ -67,13 +66,13 @@ static TString *newlstr (lua_State *L, const l_char *str, size_t l, lu_hash h) { } -TString *luaS_newlstr (lua_State *L, const l_char *str, size_t l) { +TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { TString *ts; lu_hash h = l; /* seed */ size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */ size_t l1; for (l1=l; l1>=step; l1-=step) /* compute hash */ - h = h ^ ((h<<5)+(h>>2)+uchar(str[l1-1])); + h = h ^ ((h<<5)+(h>>2)+(unsigned char)(str[l1-1])); for (ts = G(L)->strt.hash[lmod(h, G(L)->strt.size)]; ts != NULL; ts = ts->tsv.nexthash) { diff --git a/lstring.h b/lstring.h index f8fb0b60..2fbf1daf 100644 --- a/lstring.h +++ b/lstring.h @@ -1,5 +1,5 @@ /* -** $Id: lstring.h,v 1.33 2001/06/15 20:36:57 roberto Exp $ +** $Id: lstring.h,v 1.34 2001/08/31 19:46:07 roberto Exp $ ** String table (keep all strings handled by Lua) ** See Copyright Notice in lua.h */ @@ -22,18 +22,18 @@ #define sizestring(l) (cast(lu_mem, sizeof(union TString))+ \ - (cast(lu_mem, l)+1)*sizeof(l_char)) + (cast(lu_mem, l)+1)*sizeof(char)) #define sizeudata(l) (cast(lu_mem, sizeof(union Udata))+(l)) #define luaS_new(L, s) (luaS_newlstr(L, s, strlen(s))) -#define luaS_newliteral(L, s) (luaS_newlstr(L, l_s("") s, \ - (sizeof(s)/sizeof(l_char))-1)) +#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ + (sizeof(s)/sizeof(char))-1)) void luaS_resize (lua_State *L, int newsize); Udata *luaS_newudata (lua_State *L, size_t s); void luaS_freeall (lua_State *L); -TString *luaS_newlstr (lua_State *L, const l_char *str, size_t l); +TString *luaS_newlstr (lua_State *L, const char *str, size_t l); #endif diff --git a/lstrlib.c b/lstrlib.c index 9a6f04d1..8ce5e9ba 100644 --- a/lstrlib.c +++ b/lstrlib.c @@ -1,5 +1,5 @@ /* -** $Id: lstrlib.c,v 1.72 2001/10/16 17:41:43 roberto Exp $ +** $Id: lstrlib.c,v 1.73 2001/10/26 17:33:30 roberto Exp $ ** Standard library for string operations and pattern-matching ** See Copyright Notice in lua.h */ @@ -11,13 +11,18 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lauxlib.h" #include "lualib.h" +/* macro to `unsign' a character */ +#ifndef uchar +#define uchar(c) ((unsigned char)(c)) +#endif + + typedef long sint32; /* a signed version for size_t */ @@ -37,14 +42,14 @@ static sint32 posrelat (sint32 pos, size_t len) { static int str_sub (lua_State *L) { size_t l; - const l_char *s = luaL_check_lstr(L, 1, &l); + const char *s = luaL_check_lstr(L, 1, &l); sint32 start = posrelat(luaL_check_long(L, 2), l); sint32 end = posrelat(luaL_opt_long(L, 3, -1), l); if (start < 1) start = 1; if (end > (sint32)l) end = l; if (start <= end) lua_pushlstring(L, s+start-1, end-start+1); - else lua_pushliteral(L, l_s("")); + else lua_pushliteral(L, ""); return 1; } @@ -53,7 +58,7 @@ static int str_lower (lua_State *L) { size_t l; size_t i; luaL_Buffer b; - const l_char *s = luaL_check_lstr(L, 1, &l); + const char *s = luaL_check_lstr(L, 1, &l); luaL_buffinit(L, &b); for (i=0; i 0) @@ -108,9 +113,9 @@ static int str_concat (lua_State *L) { static int str_byte (lua_State *L) { size_t l; - const l_char *s = luaL_check_lstr(L, 1, &l); + const char *s = luaL_check_lstr(L, 1, &l); sint32 pos = posrelat(luaL_opt_long(L, 2, 1), l); - luaL_arg_check(L, 0 < pos && (size_t)(pos) <= l, 2, l_s("out of range")); + luaL_arg_check(L, 0 < pos && (size_t)(pos) <= l, 2, "out of range"); lua_pushnumber(L, uchar(s[pos-1])); return 1; } @@ -123,7 +128,7 @@ static int str_char (lua_State *L) { luaL_buffinit(L, &b); for (i=1; i<=n; i++) { int c = luaL_check_int(L, i); - luaL_arg_check(L, uchar(c) == c, i, l_s("invalid value")); + luaL_arg_check(L, uchar(c) == c, i, "invalid value"); luaL_putchar(&b, uchar(c)); } luaL_pushresult(&b); @@ -147,25 +152,25 @@ static int str_char (lua_State *L) { #define CAP_POSITION (-2) typedef struct MatchState { - const l_char *src_init; /* init of source string */ - const l_char *src_end; /* end (`\0') of source string */ + const char *src_init; /* init of source string */ + const char *src_end; /* end (`\0') of source string */ int level; /* total number of captures (finished or unfinished) */ struct { - const l_char *init; + const char *init; sint32 len; } capture[MAX_CAPTURES]; lua_State *L; } MatchState; -#define ESC l_c('%') -#define SPECIALS l_s("^$*+?.([%-") +#define ESC '%' +#define SPECIALS "^$*+?.([%-" static int check_capture (MatchState *ms, int l) { - l -= l_c('1'); + l -= '1'; if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED) - lua_error(ms->L, l_s("invalid capture index")); + lua_error(ms->L, "invalid capture index"); return l; } @@ -174,25 +179,25 @@ static int capture_to_close (MatchState *ms) { int level = ms->level; for (level--; level>=0; level--) if (ms->capture[level].len == CAP_UNFINISHED) return level; - lua_error(ms->L, l_s("invalid pattern capture")); + lua_error(ms->L, "invalid pattern capture"); return 0; /* to avoid warnings */ } -static const l_char *luaI_classend (MatchState *ms, const l_char *p) { +static const char *luaI_classend (MatchState *ms, const char *p) { switch (*p++) { case ESC: - if (*p == l_c('\0')) - lua_error(ms->L, l_s("malformed pattern (ends with `%')")); + if (*p == '\0') + lua_error(ms->L, "malformed pattern (ends with `%')"); return p+1; - case l_c('['): - if (*p == l_c('^')) p++; + case '[': + if (*p == '^') p++; do { /* look for a `]' */ - if (*p == l_c('\0')) - lua_error(ms->L, l_s("malformed pattern (missing `]')")); - if (*(p++) == ESC && *p != l_c('\0')) + if (*p == '\0') + lua_error(ms->L, "malformed pattern (missing `]')"); + if (*(p++) == ESC && *p != '\0') p++; /* skip escapes (e.g. `%]') */ - } while (*p != l_c(']')); + } while (*p != ']'); return p+1; default: return p; @@ -200,28 +205,28 @@ static const l_char *luaI_classend (MatchState *ms, const l_char *p) { } -static int match_class (l_charint c, l_charint cl) { +static int match_class (int c, int cl) { int res; switch (tolower(cl)) { - case l_c('a') : res = isalpha(c); break; - case l_c('c') : res = iscntrl(c); break; - case l_c('d') : res = isdigit(c); break; - case l_c('l') : res = islower(c); break; - case l_c('p') : res = ispunct(c); break; - case l_c('s') : res = isspace(c); break; - case l_c('u') : res = isupper(c); break; - case l_c('w') : res = isalnum(c); break; - case l_c('x') : res = isxdigit(c); break; - case l_c('z') : res = (c == 0); break; + case 'a' : res = isalpha(c); break; + case 'c' : res = iscntrl(c); break; + case 'd' : res = isdigit(c); break; + case 'l' : res = islower(c); break; + case 'p' : res = ispunct(c); break; + case 's' : res = isspace(c); break; + case 'u' : res = isupper(c); break; + case 'w' : res = isalnum(c); break; + case 'x' : res = isxdigit(c); break; + case 'z' : res = (c == 0); break; default: return (cl == c); } return (islower(cl) ? res : !res); } -static int matchbracketclass (l_charint c, const l_char *p, const l_char *ec) { +static int matchbracketclass (int c, const char *p, const char *ec) { int sig = 1; - if (*(p+1) == l_c('^')) { + if (*(p+1) == '^') { sig = 0; p++; /* skip the `^' */ } @@ -231,7 +236,7 @@ static int matchbracketclass (l_charint c, const l_char *p, const l_char *ec) { if (match_class(c, *p)) return sig; } - else if ((*(p+1) == l_c('-')) && (p+2 < ec)) { + else if ((*(p+1) == '-') && (p+2 < ec)) { p+=2; if (uchar(*(p-2)) <= c && c <= uchar(*p)) return sig; @@ -242,13 +247,13 @@ static int matchbracketclass (l_charint c, const l_char *p, const l_char *ec) { } -static int luaI_singlematch (l_charint c, const l_char *p, const l_char *ep) { +static int luaI_singlematch (int c, const char *p, const char *ep) { switch (*p) { - case l_c('.'): /* matches any char */ + case '.': /* matches any char */ return 1; case ESC: return match_class(c, *(p+1)); - case l_c('['): + case '[': return matchbracketclass(c, p, ep-1); default: return (uchar(*p) == c); @@ -256,13 +261,13 @@ static int luaI_singlematch (l_charint c, const l_char *p, const l_char *ep) { } -static const l_char *match (MatchState *ms, const l_char *s, const l_char *p); +static const char *match (MatchState *ms, const char *s, const char *p); -static const l_char *matchbalance (MatchState *ms, const l_char *s, - const l_char *p) { +static const char *matchbalance (MatchState *ms, const char *s, + const char *p) { if (*p == 0 || *(p+1) == 0) - lua_error(ms->L, l_s("unbalanced pattern")); + lua_error(ms->L, "unbalanced pattern"); if (*s != *p) return NULL; else { int b = *p; @@ -279,14 +284,14 @@ static const l_char *matchbalance (MatchState *ms, const l_char *s, } -static const l_char *max_expand (MatchState *ms, const l_char *s, - const l_char *p, const l_char *ep) { +static const char *max_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { sint32 i = 0; /* counts maximum expand for item */ while ((s+i)src_end && luaI_singlematch(uchar(*(s+i)), p, ep)) i++; /* keeps trying to match with the maximum repetitions */ while (i>=0) { - const l_char *res = match(ms, (s+i), ep+1); + const char *res = match(ms, (s+i), ep+1); if (res) return res; i--; /* else didn't match; reduce 1 repetition to try again */ } @@ -294,10 +299,10 @@ static const l_char *max_expand (MatchState *ms, const l_char *s, } -static const l_char *min_expand (MatchState *ms, const l_char *s, - const l_char *p, const l_char *ep) { +static const char *min_expand (MatchState *ms, const char *s, + const char *p, const char *ep) { for (;;) { - const l_char *res = match(ms, s, ep+1); + const char *res = match(ms, s, ep+1); if (res != NULL) return res; else if (ssrc_end && luaI_singlematch(uchar(*s), p, ep)) @@ -307,11 +312,11 @@ static const l_char *min_expand (MatchState *ms, const l_char *s, } -static const l_char *start_capture (MatchState *ms, const l_char *s, - const l_char *p, int what) { - const l_char *res; +static const char *start_capture (MatchState *ms, const char *s, + const char *p, int what) { + const char *res; int level = ms->level; - if (level >= MAX_CAPTURES) lua_error(ms->L, l_s("too many captures")); + if (level >= MAX_CAPTURES) lua_error(ms->L, "too many captures"); ms->capture[level].init = s; ms->capture[level].len = what; ms->level = level+1; @@ -321,10 +326,10 @@ static const l_char *start_capture (MatchState *ms, const l_char *s, } -static const l_char *end_capture (MatchState *ms, const l_char *s, - const l_char *p) { +static const char *end_capture (MatchState *ms, const char *s, + const char *p) { int l = capture_to_close(ms); - const l_char *res; + const char *res; ms->capture[l].len = s - ms->capture[l].init; /* close capture */ if ((res = match(ms, s, p)) == NULL) /* match failed? */ ms->capture[l].len = CAP_UNFINISHED; /* undo capture */ @@ -332,7 +337,7 @@ static const l_char *end_capture (MatchState *ms, const l_char *s, } -static const l_char *match_capture (MatchState *ms, const l_char *s, int l) { +static const char *match_capture (MatchState *ms, const char *s, int l) { size_t len; l = check_capture(ms, l); len = ms->capture[l].len; @@ -343,15 +348,15 @@ static const l_char *match_capture (MatchState *ms, const l_char *s, int l) { } -static const l_char *match (MatchState *ms, const l_char *s, const l_char *p) { +static const char *match (MatchState *ms, const char *s, const char *p) { init: /* using goto's to optimize tail recursion */ switch (*p) { - case l_c('('): /* start capture */ - if (*(p+1) == l_c(')')) /* position capture? */ + case '(': /* start capture */ + if (*(p+1) == ')') /* position capture? */ return start_capture(ms, s, p+2, CAP_POSITION); else return start_capture(ms, s, p+1, CAP_UNFINISHED); - case l_c(')'): /* end capture */ + case ')': /* end capture */ return end_capture(ms, s, p+1); case ESC: /* may be %[0-9] or %b */ if (isdigit(uchar(*(p+1)))) { /* capture? */ @@ -359,33 +364,33 @@ static const l_char *match (MatchState *ms, const l_char *s, const l_char *p) { if (s == NULL) return NULL; p+=2; goto init; /* else return match(ms, s, p+2) */ } - else if (*(p+1) == l_c('b')) { /* balanced string? */ + else if (*(p+1) == 'b') { /* balanced string? */ s = matchbalance(ms, s, p+2); if (s == NULL) return NULL; p+=4; goto init; /* else return match(ms, s, p+4); */ } else goto dflt; /* case default */ - case l_c('\0'): /* end of pattern */ + case '\0': /* end of pattern */ return s; /* match succeeded */ - case l_c('$'): - if (*(p+1) == l_c('\0')) /* is the `$' the last char in pattern? */ + case '$': + if (*(p+1) == '\0') /* is the `$' the last char in pattern? */ return (s == ms->src_end) ? s : NULL; /* check end of string */ else goto dflt; default: dflt: { /* it is a pattern item */ - const l_char *ep = luaI_classend(ms, p); /* points to what is next */ + const char *ep = luaI_classend(ms, p); /* points to what is next */ int m = ssrc_end && luaI_singlematch(uchar(*s), p, ep); switch (*ep) { - case l_c('?'): { /* optional */ - const l_char *res; + case '?': { /* optional */ + const char *res; if (m && ((res=match(ms, s+1, ep+1)) != NULL)) return res; p=ep+1; goto init; /* else return match(ms, s, ep+1); */ } - case l_c('*'): /* 0 or more repetitions */ + case '*': /* 0 or more repetitions */ return max_expand(ms, s, p, ep); - case l_c('+'): /* 1 or more repetitions */ + case '+': /* 1 or more repetitions */ return (m ? max_expand(ms, s+1, p, ep) : NULL); - case l_c('-'): /* 0 or more repetitions (minimum) */ + case '-': /* 0 or more repetitions (minimum) */ return min_expand(ms, s, p, ep); default: if (!m) return NULL; @@ -397,15 +402,15 @@ static const l_char *match (MatchState *ms, const l_char *s, const l_char *p) { -static const l_char *lmemfind (const l_char *s1, size_t l1, - const l_char *s2, size_t l2) { +static const char *lmemfind (const char *s1, size_t l1, + const char *s2, size_t l2) { if (l2 == 0) return s1; /* empty strings are everywhere */ else if (l2 > l1) return NULL; /* avoids a negative `l1' */ else { - const l_char *init; /* to search for a `*s2' inside `s1' */ + const char *init; /* to search for a `*s2' inside `s1' */ l2--; /* 1st char will be checked by `memchr' */ l1 = l1-l2; /* `s2' cannot be found after that */ - while (l1 > 0 && (init = (const l_char *)memchr(s1, *s2, l1)) != NULL) { + while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) { init++; /* 1st char is already checked */ if (memcmp(init, s2+1, l2) == 0) return init-1; @@ -421,7 +426,7 @@ static const l_char *lmemfind (const l_char *s1, size_t l1, static void push_onecapture (MatchState *ms, int i) { int l = ms->capture[i].len; - if (l == CAP_UNFINISHED) lua_error(ms->L, l_s("unfinished capture")); + if (l == CAP_UNFINISHED) lua_error(ms->L, "unfinished capture"); if (l == CAP_POSITION) lua_pushnumber(ms->L, ms->capture[i].init - ms->src_init + 1); else @@ -431,7 +436,7 @@ static void push_onecapture (MatchState *ms, int i) { static int push_captures (MatchState *ms) { int i; - luaL_check_stack(ms->L, ms->level, l_s("too many captures")); + luaL_check_stack(ms->L, ms->level, "too many captures"); for (i=0; ilevel; i++) push_onecapture(ms, i); return ms->level; /* number of strings pushed */ @@ -440,13 +445,13 @@ static int push_captures (MatchState *ms) { static int str_find (lua_State *L) { size_t l1, l2; - const l_char *s = luaL_check_lstr(L, 1, &l1); - const l_char *p = luaL_check_lstr(L, 2, &l2); + const char *s = luaL_check_lstr(L, 1, &l1); + const char *p = luaL_check_lstr(L, 2, &l2); sint32 init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1; - luaL_arg_check(L, 0 <= init && (size_t)(init) <= l1, 3, l_s("out of range")); + luaL_arg_check(L, 0 <= init && (size_t)(init) <= l1, 3, "out of range"); if (lua_gettop(L) > 3 || /* extra argument? */ strpbrk(p, SPECIALS) == NULL) { /* or no special characters? */ - const l_char *s2 = lmemfind(s+init, l1-init, p, l2); + const char *s2 = lmemfind(s+init, l1-init, p, l2); if (s2) { lua_pushnumber(L, s2-s+1); lua_pushnumber(L, s2-s+l2); @@ -455,13 +460,13 @@ static int str_find (lua_State *L) { } else { MatchState ms; - int anchor = (*p == l_c('^')) ? (p++, 1) : 0; - const l_char *s1=s+init; + int anchor = (*p == '^') ? (p++, 1) : 0; + const char *s1=s+init; ms.L = L; ms.src_init = s; ms.src_end = s+l1; do { - const l_char *res; + const char *res; ms.level = 0; if ((res=match(&ms, s1, p)) != NULL) { lua_pushnumber(L, s1-s+1); /* start */ @@ -478,7 +483,7 @@ static int str_find (lua_State *L) { static void add_s (MatchState *ms, luaL_Buffer *b) { lua_State *L = ms->L; if (lua_isstring(L, 3)) { - const l_char *news = lua_tostring(L, 3); + const char *news = lua_tostring(L, 3); size_t l = lua_strlen(L, 3); size_t i; for (i=0; i= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)), - 3, l_s("string or function expected")); + 3, "string or function expected"); luaL_buffinit(L, &b); ms.L = L; ms.src_init = src; ms.src_end = src+srcl; while (n < max_s) { - const l_char *e; + const char *e; ms.level = 0; e = match(&ms, src, p); if (e) { @@ -557,40 +562,40 @@ static int str_gsub (lua_State *L) { static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) { size_t l; - const l_char *s = luaL_check_lstr(L, arg, &l); - luaL_putchar(b, l_c('"')); + const char *s = luaL_check_lstr(L, arg, &l); + luaL_putchar(b, '"'); while (l--) { switch (*s) { - case l_c('"'): case l_c('\\'): case l_c('\n'): - luaL_putchar(b, l_c('\\')); + case '"': case '\\': case '\n': + luaL_putchar(b, '\\'); luaL_putchar(b, *s); break; - case l_c('\0'): luaL_addlstring(b, l_s("\\000"), 4); break; + case '\0': luaL_addlstring(b, "\\000", 4); break; default: luaL_putchar(b, *s); } s++; } - luaL_putchar(b, l_c('"')); + luaL_putchar(b, '"'); } -static const l_char *scanformat (lua_State *L, const l_char *strfrmt, - l_char *form, int *hasprecision) { - const l_char *p = strfrmt; - while (strchr(l_s("-+ #0"), *p)) p++; /* skip flags */ +static const char *scanformat (lua_State *L, const char *strfrmt, + char *form, int *hasprecision) { + const char *p = strfrmt; + while (strchr("-+ #0", *p)) p++; /* skip flags */ if (isdigit(uchar(*p))) p++; /* skip width */ if (isdigit(uchar(*p))) p++; /* (2 digits at most) */ - if (*p == l_c('.')) { + if (*p == '.') { p++; *hasprecision = 1; if (isdigit(uchar(*p))) p++; /* skip precision */ if (isdigit(uchar(*p))) p++; /* (2 digits at most) */ } if (isdigit(uchar(*p))) - lua_error(L, l_s("invalid format (width or precision too long)")); + lua_error(L, "invalid format (width or precision too long)"); if (p-strfrmt+2 > MAX_FORMAT) /* +2 to include `%' and the specifier */ - lua_error(L, l_s("invalid format (too long)")); - form[0] = l_c('%'); + lua_error(L, "invalid format (too long)"); + form[0] = '%'; strncpy(form+1, strfrmt, p-strfrmt+1); form[p-strfrmt+2] = 0; return p; @@ -600,40 +605,40 @@ static const l_char *scanformat (lua_State *L, const l_char *strfrmt, static int str_format (lua_State *L) { int arg = 1; size_t sfl; - const l_char *strfrmt = luaL_check_lstr(L, arg, &sfl); - const l_char *strfrmt_end = strfrmt+sfl; + const char *strfrmt = luaL_check_lstr(L, arg, &sfl); + const char *strfrmt_end = strfrmt+sfl; luaL_Buffer b; luaL_buffinit(L, &b); while (strfrmt < strfrmt_end) { - if (*strfrmt != l_c('%')) + if (*strfrmt != '%') luaL_putchar(&b, *strfrmt++); - else if (*++strfrmt == l_c('%')) + else if (*++strfrmt == '%') luaL_putchar(&b, *strfrmt++); /* %% */ else { /* format item */ - l_char form[MAX_FORMAT]; /* to store the format (`%...') */ - l_char buff[MAX_ITEM]; /* to store the formatted item */ + char form[MAX_FORMAT]; /* to store the format (`%...') */ + char buff[MAX_ITEM]; /* to store the formatted item */ int hasprecision = 0; - if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == l_c('$')) - lua_error(L, l_s("obsolete `format' option (d$)")); + if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == '$') + lua_error(L, "obsolete `format' option (d$)"); arg++; strfrmt = scanformat(L, strfrmt, form, &hasprecision); switch (*strfrmt++) { - case l_c('c'): case l_c('d'): case l_c('i'): + case 'c': case 'd': case 'i': sprintf(buff, form, luaL_check_int(L, arg)); break; - case l_c('o'): case l_c('u'): case l_c('x'): case l_c('X'): + case 'o': case 'u': case 'x': case 'X': sprintf(buff, form, (unsigned int)(luaL_check_number(L, arg))); break; - case l_c('e'): case l_c('E'): case l_c('f'): - case l_c('g'): case l_c('G'): + case 'e': case 'E': case 'f': + case 'g': case 'G': sprintf(buff, form, luaL_check_number(L, arg)); break; - case l_c('q'): + case 'q': luaI_addquoted(L, &b, arg); continue; /* skip the `addsize' at the end */ - case l_c('s'): { + case 's': { size_t l; - const l_char *s = luaL_check_lstr(L, arg, &l); + const char *s = luaL_check_lstr(L, arg, &l); if (!hasprecision && l >= 100) { /* no precision and string is too long to be formatted; keep original string */ @@ -647,7 +652,7 @@ static int str_format (lua_State *L) { } } default: /* also treat cases `pnLlh' */ - lua_error(L, l_s("invalid option in `format'")); + lua_error(L, "invalid option in `format'"); } luaL_addlstring(&b, buff, strlen(buff)); } @@ -658,17 +663,17 @@ static int str_format (lua_State *L) { static const luaL_reg strlib[] = { -{l_s("strlen"), str_len}, -{l_s("strsub"), str_sub}, -{l_s("strlower"), str_lower}, -{l_s("strupper"), str_upper}, -{l_s("strchar"), str_char}, -{l_s("strrep"), str_rep}, -{l_s("strbyte"), str_byte}, -{l_s("concat"), str_concat}, -{l_s("format"), str_format}, -{l_s("strfind"), str_find}, -{l_s("gsub"), str_gsub} +{"strlen", str_len}, +{"strsub", str_sub}, +{"strlower", str_lower}, +{"strupper", str_upper}, +{"strchar", str_char}, +{"strrep", str_rep}, +{"strbyte", str_byte}, +{"concat", str_concat}, +{"format", str_format}, +{"strfind", str_find}, +{"gsub", str_gsub} }; diff --git a/ltable.c b/ltable.c index 486b09a8..b9e42c18 100644 --- a/ltable.c +++ b/ltable.c @@ -1,5 +1,5 @@ /* -** $Id: ltable.c,v 1.87 2001/10/25 19:14:14 roberto Exp $ +** $Id: ltable.c,v 1.88 2001/11/16 16:29:51 roberto Exp $ ** Lua tables (hash) ** See Copyright Notice in lua.h */ @@ -23,7 +23,6 @@ -#define LUA_PRIVATE #include "lua.h" #include "ldo.h" @@ -101,7 +100,7 @@ int luaH_index (lua_State *L, Table *t, const TObject *key) { else { const TObject *v = luaH_get(t, key); if (v == &luaO_nilobject) - luaD_error(L, l_s("invalid key for `next'")); + luaD_error(L, "invalid key for `next'"); i = cast(int, (cast(const lu_byte *, v) - cast(const lu_byte *, val(node(t, 0)))) / sizeof(Node)); return i + t->sizearray; /* hash elements are numbered after array ones */ @@ -193,7 +192,7 @@ static void numuse (const Table *t, int *narray, int *nhash) { static void setarrayvector (lua_State *L, Table *t, int size) { int i; if (size > twoto(MAXBITS)) - luaD_error(L, l_s("table overflow")); + luaD_error(L, "table overflow"); luaM_reallocvector(L, t->array, t->sizearray, size, TObject); for (i=t->sizearray; iarray[i]); @@ -206,7 +205,7 @@ static void setnodevector (lua_State *L, Table *t, int lsize) { int size; if (lsize < MINHASHSIZE) lsize = MINHASHSIZE; else if (lsize > MAXBITS) - luaD_error(L, l_s("table overflow")); + luaD_error(L, "table overflow"); size = twoto(lsize); t->node = luaM_newvector(L, size, Node); for (i=0; i -#define LUA_PRIVATE #include "lua.h" #include "lapi.h" @@ -43,7 +42,7 @@ int islocked = 0; -static void setnameval (lua_State *L, const l_char *name, int val) { +static void setnameval (lua_State *L, const char *name, int val) { lua_pushstring(L, name); lua_pushnumber(L, val); lua_settable(L, -3); @@ -139,21 +138,21 @@ void *debug_realloc (void *block, size_t oldsize, size_t size) { */ -static l_char *buildop (Proto *p, int pc, l_char *buff) { +static char *buildop (Proto *p, int pc, char *buff) { Instruction i = p->code[pc]; OpCode o = GET_OPCODE(i); - const l_char *name = luaP_opnames[o]; - sprintf(buff, l_s("%4d - "), pc); + const char *name = luaP_opnames[o]; + sprintf(buff, "%4d - ", pc); switch (getOpMode(o)) { case iABC: - sprintf(buff+strlen(buff), l_s("%-12s%4d %4d %4d"), name, + sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name, GETARG_A(i), GETARG_B(i), GETARG_C(i)); break; case iABc: - sprintf(buff+strlen(buff), l_s("%-12s%4d %4d"), name, GETARG_A(i), GETARG_Bc(i)); + sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bc(i)); break; case iAsBc: - sprintf(buff+strlen(buff), l_s("%-12s%4d %4d"), name, GETARG_A(i), GETARG_sBc(i)); + sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBc(i)); break; } return buff; @@ -164,13 +163,13 @@ static int listcode (lua_State *L) { int pc; Proto *p; luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), - 1, l_s("Lua function expected")); + 1, "Lua function expected"); p = clvalue(luaA_index(L, 1))->l.p; lua_newtable(L); - setnameval(L, l_s("maxstack"), p->maxstacksize); - setnameval(L, l_s("numparams"), p->numparams); + setnameval(L, "maxstack", p->maxstacksize); + setnameval(L, "numparams", p->numparams); for (pc=0; pcsizecode; pc++) { - l_char buff[100]; + char buff[100]; lua_pushnumber(L, pc+1); lua_pushstring(L, buildop(p, pc, buff)); lua_settable(L, -3); @@ -183,7 +182,7 @@ static int listk (lua_State *L) { Proto *p; int i; luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), - 1, l_s("Lua function expected")); + 1, "Lua function expected"); p = clvalue(luaA_index(L, 1))->l.p; lua_newtable(L); for (i=0; isizek; i++) { @@ -199,9 +198,9 @@ static int listlocals (lua_State *L) { Proto *p; int pc = luaL_check_int(L, 2) - 1; int i = 0; - const l_char *name; + const char *name; luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), - 1, l_s("Lua function expected")); + 1, "Lua function expected"); p = clvalue(luaA_index(L, 1))->l.p; while ((name = luaF_getlocalname(p, ++i, pc)) != NULL) lua_pushstring(L, name); @@ -215,12 +214,12 @@ static int listlocals (lua_State *L) { static int get_limits (lua_State *L) { lua_newtable(L); - setnameval(L, l_s("BITS_INT"), BITS_INT); - setnameval(L, l_s("LFPF"), LFIELDS_PER_FLUSH); - setnameval(L, l_s("MAXLOCALS"), MAXLOCALS); - setnameval(L, l_s("MAXPARAMS"), MAXPARAMS); - setnameval(L, l_s("MAXSTACK"), MAXSTACK); - setnameval(L, l_s("MAXUPVALUES"), MAXUPVALUES); + setnameval(L, "BITS_INT", BITS_INT); + setnameval(L, "LFPF", LFIELDS_PER_FLUSH); + setnameval(L, "MAXLOCALS", MAXLOCALS); + setnameval(L, "MAXPARAMS", MAXPARAMS); + setnameval(L, "MAXSTACK", MAXSTACK); + setnameval(L, "MAXUPVALUES", MAXUPVALUES); return 1; } @@ -241,7 +240,7 @@ static int mem_query (lua_State *L) { static int hash_query (lua_State *L) { if (lua_isnull(L, 2)) { - luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, l_s("string expected")); + luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, "string expected"); lua_pushnumber(L, tsvalue(luaA_index(L, 1))->tsv.hash); } else { @@ -336,8 +335,8 @@ static int unref (lua_State *L) { static int newuserdata (lua_State *L) { size_t size = luaL_check_int(L, 1); - l_char *p = cast(l_char *, lua_newuserdata(L, size)); - while (size--) *p++ = l_c('\0'); + char *p = cast(char *, lua_newuserdata(L, size)); + while (size--) *p++ = '\0'; return 1; } @@ -383,7 +382,7 @@ static int s2d (lua_State *L) { static int d2s (lua_State *L) { double d = luaL_check_number(L, 1); - lua_pushlstring(L, cast(l_char *, &d), sizeof(d)); + lua_pushlstring(L, cast(char *, &d), sizeof(d)); return 1; } @@ -418,7 +417,7 @@ static int closestate (lua_State *L) { static int doremote (lua_State *L) { lua_State *L1; - const l_char *code = luaL_check_string(L, 2); + const char *code = luaL_check_string(L, 2); int status; L1 = cast(lua_State *, cast(unsigned long, luaL_check_number(L, 1))); status = lua_dostring(L1, code); @@ -438,7 +437,7 @@ static int doremote (lua_State *L) { static int settagmethod (lua_State *L) { int tag = luaL_check_int(L, 1); - const l_char *event = luaL_check_string(L, 2); + const char *event = luaL_check_string(L, 2); luaL_check_any(L, 3); lua_gettagmethod(L, tag, event); lua_pushvalue(L, 3); @@ -460,36 +459,36 @@ static int log2_aux (lua_State *L) { ** ======================================================= */ -static const l_char *const delimits = l_s(" \t\n,;"); +static const char *const delimits = " \t\n,;"; -static void skip (const l_char **pc) { - while (**pc != l_c('\0') && strchr(delimits, **pc)) (*pc)++; +static void skip (const char **pc) { + while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++; } -static int getnum_aux (lua_State *L, const l_char **pc) { +static int getnum_aux (lua_State *L, const char **pc) { int res = 0; int sig = 1; skip(pc); - if (**pc == l_c('.')) { + if (**pc == '.') { res = cast(int, lua_tonumber(L, -1)); lua_pop(L, 1); (*pc)++; return res; } - else if (**pc == l_c('-')) { + else if (**pc == '-') { sig = -1; (*pc)++; } - while (isdigit(cast(int, **pc))) res = res*10 + (*(*pc)++) - l_c('0'); + while (isdigit(cast(int, **pc))) res = res*10 + (*(*pc)++) - '0'; return sig*res; } -static const l_char *getname_aux (l_char *buff, const l_char **pc) { +static const char *getname_aux (char *buff, const char **pc) { int i = 0; skip(pc); - while (**pc != l_c('\0') && !strchr(delimits, **pc)) + while (**pc != '\0' && !strchr(delimits, **pc)) buff[i++] = *(*pc)++; - buff[i] = l_c('\0'); + buff[i] = '\0'; return buff; } @@ -501,134 +500,134 @@ static const l_char *getname_aux (l_char *buff, const l_char **pc) { static int testC (lua_State *L) { - l_char buff[30]; - const l_char *pc = luaL_check_string(L, 1); + char buff[30]; + const char *pc = luaL_check_string(L, 1); for (;;) { - const l_char *inst = getname; - if EQ(l_s("")) return 0; - else if EQ(l_s("isnumber")) { + const char *inst = getname; + if EQ("") return 0; + else if EQ("isnumber") { lua_pushnumber(L, lua_isnumber(L, getnum)); } - else if EQ(l_s("isstring")) { + else if EQ("isstring") { lua_pushnumber(L, lua_isstring(L, getnum)); } - else if EQ(l_s("istable")) { + else if EQ("istable") { lua_pushnumber(L, lua_istable(L, getnum)); } - else if EQ(l_s("iscfunction")) { + else if EQ("iscfunction") { lua_pushnumber(L, lua_iscfunction(L, getnum)); } - else if EQ(l_s("isfunction")) { + else if EQ("isfunction") { lua_pushnumber(L, lua_isfunction(L, getnum)); } - else if EQ(l_s("isuserdata")) { + else if EQ("isuserdata") { lua_pushnumber(L, lua_isuserdata(L, getnum)); } - else if EQ(l_s("isnil")) { + else if EQ("isnil") { lua_pushnumber(L, lua_isnil(L, getnum)); } - else if EQ(l_s("isnull")) { + else if EQ("isnull") { lua_pushnumber(L, lua_isnull(L, getnum)); } - else if EQ(l_s("tonumber")) { + else if EQ("tonumber") { lua_pushnumber(L, lua_tonumber(L, getnum)); } - else if EQ(l_s("tostring")) { - const l_char *s = lua_tostring(L, getnum); + else if EQ("tostring") { + const char *s = lua_tostring(L, getnum); lua_pushstring(L, s); } - else if EQ(l_s("tonumber")) { + else if EQ("tonumber") { lua_pushnumber(L, lua_tonumber(L, getnum)); } - else if EQ(l_s("strlen")) { + else if EQ("strlen") { lua_pushnumber(L, lua_strlen(L, getnum)); } - else if EQ(l_s("tocfunction")) { + else if EQ("tocfunction") { lua_pushcfunction(L, lua_tocfunction(L, getnum)); } - else if EQ(l_s("return")) { + else if EQ("return") { return getnum; } - else if EQ(l_s("gettop")) { + else if EQ("gettop") { lua_pushnumber(L, lua_gettop(L)); } - else if EQ(l_s("settop")) { + else if EQ("settop") { lua_settop(L, getnum); } - else if EQ(l_s("pop")) { + else if EQ("pop") { lua_pop(L, getnum); } - else if EQ(l_s("pushnum")) { + else if EQ("pushnum") { lua_pushnumber(L, getnum); } - else if EQ(l_s("pushvalue")) { + else if EQ("pushvalue") { lua_pushvalue(L, getnum); } - else if EQ(l_s("pushcclosure")) { + else if EQ("pushcclosure") { lua_pushcclosure(L, testC, getnum); } - else if EQ(l_s("pushupvalues")) { + else if EQ("pushupvalues") { lua_pushupvalues(L); } - else if EQ(l_s("remove")) { + else if EQ("remove") { lua_remove(L, getnum); } - else if EQ(l_s("insert")) { + else if EQ("insert") { lua_insert(L, getnum); } - else if EQ(l_s("gettable")) { + else if EQ("gettable") { lua_gettable(L, getnum); } - else if EQ(l_s("settable")) { + else if EQ("settable") { lua_settable(L, getnum); } - else if EQ(l_s("next")) { + else if EQ("next") { lua_next(L, -2); } - else if EQ(l_s("concat")) { + else if EQ("concat") { lua_concat(L, getnum); } - else if EQ(l_s("lessthan")) { + else if EQ("lessthan") { int a = getnum; if (lua_lessthan(L, a, getnum)) lua_pushnumber(L, 1); else lua_pushnil(L); } - else if EQ(l_s("equal")) { + else if EQ("equal") { int a = getnum; if (lua_equal(L, a, getnum)) lua_pushnumber(L, 1); else lua_pushnil(L); } - else if EQ(l_s("rawcall")) { + else if EQ("rawcall") { int narg = getnum; int nres = getnum; lua_rawcall(L, narg, nres); } - else if EQ(l_s("call")) { + else if EQ("call") { int narg = getnum; int nres = getnum; lua_call(L, narg, nres); } - else if EQ(l_s("dostring")) { + else if EQ("dostring") { lua_dostring(L, luaL_check_string(L, getnum)); } - else if EQ(l_s("settagmethod")) { + else if EQ("settagmethod") { int tag = getnum; - const l_char *event = getname; + const char *event = getname; lua_settagmethod(L, tag, event); } - else if EQ(l_s("gettagmethod")) { + else if EQ("gettagmethod") { int tag = getnum; - const l_char *event = getname; + const char *event = getname; lua_gettagmethod(L, tag, event); } - else if EQ(l_s("type")) { + else if EQ("type") { lua_pushstring(L, lua_type(L, getnum)); } - else luaL_verror(L, l_s("unknown instruction %.30s"), buff); + else luaL_verror(L, "unknown instruction %.30s", buff); } return 0; } @@ -638,32 +637,32 @@ static int testC (lua_State *L) { static const struct luaL_reg tests_funcs[] = { - {l_s("hash"), hash_query}, - {l_s("limits"), get_limits}, - {l_s("listcode"), listcode}, - {l_s("listk"), listk}, - {l_s("listlocals"), listlocals}, - {l_s("loadlib"), loadlib}, - {l_s("querystr"), string_query}, - {l_s("querytab"), table_query}, - {l_s("testC"), testC}, - {l_s("ref"), tref}, - {l_s("getref"), getref}, - {l_s("unref"), unref}, - {l_s("d2s"), d2s}, - {l_s("s2d"), s2d}, - {l_s("newuserdata"), newuserdata}, - {l_s("newuserdatabox"), newuserdatabox}, - {l_s("settag"), settag}, - {l_s("udataval"), udataval}, - {l_s("newtag"), newtag}, - {l_s("doonnewstack"), doonnewstack}, - {l_s("newstate"), newstate}, - {l_s("closestate"), closestate}, - {l_s("doremote"), doremote}, - {l_s("settagmethod"), settagmethod}, - {l_s("log2"), log2_aux}, - {l_s("totalmem"), mem_query} + {"hash", hash_query}, + {"limits", get_limits}, + {"listcode", listcode}, + {"listk", listk}, + {"listlocals", listlocals}, + {"loadlib", loadlib}, + {"querystr", string_query}, + {"querytab", table_query}, + {"testC", testC}, + {"ref", tref}, + {"getref", getref}, + {"unref", unref}, + {"d2s", d2s}, + {"s2d", s2d}, + {"newuserdata", newuserdata}, + {"newuserdatabox", newuserdatabox}, + {"settag", settag}, + {"udataval", udataval}, + {"newtag", newtag}, + {"doonnewstack", doonnewstack}, + {"newstate", newstate}, + {"closestate", closestate}, + {"doremote", doremote}, + {"settagmethod", settagmethod}, + {"log2", log2_aux}, + {"totalmem", mem_query} }; @@ -677,7 +676,7 @@ void luaB_opentests (lua_State *L) { lua_setglobals(L); luaL_openl(L, tests_funcs); /* open functions inside new table */ lua_setglobals(L); /* restore old table of globals */ - lua_setglobal(L, l_s("T")); /* set new table as global T */ + lua_setglobal(L, "T"); /* set new table as global T */ } #endif diff --git a/ltm.c b/ltm.c index a58934fa..ef0f89e1 100644 --- a/ltm.c +++ b/ltm.c @@ -1,5 +1,5 @@ /* -** $Id: ltm.c,v 1.78 2001/08/31 19:46:07 roberto Exp $ +** $Id: ltm.c,v 1.80 2001/10/11 21:41:21 roberto Exp $ ** Tag methods ** See Copyright Notice in lua.h */ @@ -8,7 +8,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "ldo.h" @@ -20,16 +19,16 @@ #include "ltm.h" -const l_char *const luaT_eventname[] = { /* ORDER TM */ - l_s("gettable"), l_s("settable"), l_s("index"), l_s("getglobal"), - l_s("setglobal"), l_s("add"), l_s("sub"), l_s("mul"), l_s("div"), - l_s("pow"), l_s("unm"), l_s("lt"), l_s("concat"), l_s("gc"), - l_s("function"), +const char *const luaT_eventname[] = { /* ORDER TM */ + "gettable", "settable", "index", "getglobal", + "setglobal", "add", "sub", "mul", "div", + "pow", "unm", "lt", "concat", "gc", + "function", NULL }; -static int findevent (const l_char *name) { +static int findevent (const char *name) { int i; for (i=0; luaT_eventname[i]; i++) if (strcmp(luaT_eventname[i], name) == 0) @@ -38,10 +37,10 @@ static int findevent (const l_char *name) { } -static int luaI_checkevent (lua_State *L, const l_char *name) { +static int luaI_checkevent (lua_State *L, const char *name) { int e = findevent(name); if (e < 0) - luaO_verror(L, l_s("`%.50s' is not a valid event name"), name); + luaO_verror(L, "`%.50s' is not a valid event name", name); return e; } @@ -66,9 +65,9 @@ static int luaT_validevent (int t, int e) { /* ORDER LUA_T */ void luaT_init (lua_State *L) { - static const l_char *const typenames[NUM_TAGS] = { - l_s("userdata"), l_s("nil"), l_s("number"), l_s("string"), - l_s("table"), l_s("function") + static const char *const typenames[NUM_TAGS] = { + "userdata", "nil", "number", "string", + "table", "function" }; int i; for (i=0; iTMtable, G(L)->ntag, G(L)->sizeTM, struct TM, - MAX_INT, l_s("tag table overflow")); + MAX_INT, "tag table overflow"); tag = G(L)->ntag; if (name) { const TObject *v; @@ -104,7 +103,7 @@ int luaT_newtag (lua_State *L, const l_char *name, int basictype) { static void checktag (lua_State *L, int tag) { if (!(0 <= tag && tag < G(L)->ntag)) - luaO_verror(L, l_s("%d is not a valid tag"), tag); + luaO_verror(L, "%d is not a valid tag", tag); } @@ -118,7 +117,7 @@ int luaT_tag (const TObject *o) { } -const l_char *luaT_typename (global_State *G, const TObject *o) { +const char *luaT_typename (global_State *G, const TObject *o) { int t = ttype(o); int tag; TString *ts; @@ -139,7 +138,7 @@ const l_char *luaT_typename (global_State *G, const TObject *o) { } -LUA_API void lua_gettagmethod (lua_State *L, int t, const l_char *event) { +LUA_API void lua_gettagmethod (lua_State *L, int t, const char *event) { int e; lua_lock(L); e = luaI_checkevent(L, event); @@ -154,16 +153,16 @@ LUA_API void lua_gettagmethod (lua_State *L, int t, const l_char *event) { } -LUA_API void lua_settagmethod (lua_State *L, int t, const l_char *event) { +LUA_API void lua_settagmethod (lua_State *L, int t, const char *event) { int e; lua_lock(L); e = luaI_checkevent(L, event); checktag(L, t); if (!luaT_validevent(t, e)) - luaO_verror(L, l_s("cannot change `%.20s' tag method for type `%.20s'%.20s"), + luaO_verror(L, "cannot change `%.20s' tag method for type `%.20s'%.20s", luaT_eventname[e], typenamebytag(G(L), t), (t == LUA_TTABLE || t == LUA_TUSERDATA) ? - l_s(" with default tag") : l_s("")); + " with default tag" : ""); switch (ttype(L->top - 1)) { case LUA_TNIL: luaT_gettm(G(L), t, e) = NULL; @@ -172,7 +171,7 @@ LUA_API void lua_settagmethod (lua_State *L, int t, const l_char *event) { luaT_gettm(G(L), t, e) = clvalue(L->top - 1); break; default: - luaD_error(L, l_s("tag method must be a function (or nil)")); + luaD_error(L, "tag method must be a function (or nil)"); } L->top--; lua_unlock(L); diff --git a/ltm.h b/ltm.h index 36f5fbc1..797dd9a6 100644 --- a/ltm.h +++ b/ltm.h @@ -1,5 +1,5 @@ /* -** $Id: ltm.h,v 1.27 2001/08/27 15:13:59 roberto Exp $ +** $Id: ltm.h,v 1.28 2001/10/02 16:43:54 roberto Exp $ ** Tag methods ** See Copyright Notice in lua.h */ @@ -67,12 +67,12 @@ struct TM { #define validtag(G,t) (NUM_TAGS <= (t) && (t) < G->ntag) -extern const l_char *const luaT_eventname[]; +extern const char *const luaT_eventname[]; void luaT_init (lua_State *L); -int luaT_newtag (lua_State *L, const l_char *name, int basictype); -const l_char *luaT_typename (global_State *G, const TObject *o); +int luaT_newtag (lua_State *L, const char *name, int basictype); +const char *luaT_typename (global_State *G, const TObject *o); int luaT_tag (const TObject *o); diff --git a/lua.c b/lua.c index f90da9a5..933fb8ca 100644 --- a/lua.c +++ b/lua.c @@ -1,5 +1,5 @@ /* -** $Id: lua.c,v 1.71 2001/10/17 21:12:57 roberto Exp $ +** $Id: lua.c,v 1.72 2001/11/27 20:56:47 roberto Exp $ ** Lua stand-alone interpreter ** See Copyright Notice in lua.h */ @@ -10,7 +10,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "luadebug.h" @@ -25,12 +24,12 @@ static int isatty (int x) { return x==0; } /* assume stdin is a tty */ #ifndef LUA_PROGNAME -#define LUA_PROGNAME l_s("lua: ") +#define LUA_PROGNAME "lua: " #endif #ifndef PROMPT -#define PROMPT l_s("> ") +#define PROMPT "> " #endif @@ -62,7 +61,7 @@ static void lstop (void) { lua_setlinehook(L, old_linehook); lua_setcallhook(L, old_callhook); lreset(); - lua_error(L, l_s("interrupted!")); + lua_error(L, "interrupted!"); } @@ -75,7 +74,7 @@ static void laction (int i) { } -static int ldo (int (*f)(lua_State *l, const l_char *), const l_char *name, +static int ldo (int (*f)(lua_State *l, const char *), const char *name, int clear) { int res; handler h = lreset(); @@ -86,45 +85,45 @@ static int ldo (int (*f)(lua_State *l, const l_char *), const l_char *name, lua_settop(L, top); /* remove eventual results */ /* Lua gives no message in such cases, so lua.c provides one */ if (res == LUA_ERRMEM) { - fprintf(stderr, LUA_PROGNAME l_s("memory allocation error\n")); + fprintf(stderr, LUA_PROGNAME "memory allocation error\n"); } else if (res == LUA_ERRERR) - fprintf(stderr, LUA_PROGNAME l_s("error in error message\n")); + fprintf(stderr, LUA_PROGNAME "error in error message\n"); return res; } static void print_message (void) { fprintf(stderr, - l_s("usage: lua [options]. Available options are:\n") - l_s(" - execute stdin as a file\n") - l_s(" -c close Lua when exiting\n") - l_s(" -e stat execute string `stat'\n") - l_s(" -f name execute file `name' with remaining arguments in table `arg'\n") - l_s(" -i enter interactive mode with prompt\n") - l_s(" -q enter interactive mode without prompt\n") - l_s(" -sNUM set stack size to NUM (must be the first option)\n") - l_s(" -v print version information\n") - l_s(" a=b set global `a' to string `b'\n") - l_s(" name execute file `name'\n") + "usage: lua [options]. Available options are:\n" + " - execute stdin as a file\n" + " -c close Lua when exiting\n" + " -e stat execute string `stat'\n" + " -f name execute file `name' with remaining arguments in table `arg'\n" + " -i enter interactive mode with prompt\n" + " -q enter interactive mode without prompt\n" + " -sNUM set stack size to NUM (must be the first option)\n" + " -v print version information\n" + " a=b set global `a' to string `b'\n" + " name execute file `name'\n" ); } static void print_version (void) { - printf(l_s("%.80s %.80s\n"), l_s(LUA_VERSION), l_s(LUA_COPYRIGHT)); + printf("%.80s %.80s\n", LUA_VERSION, LUA_COPYRIGHT); } -static void assign (l_char *arg) { - l_char *eq = strchr(arg, l_c('=')); - *eq = l_c('\0'); /* spilt `arg' in two strings (name & value) */ +static void assign (char *arg) { + char *eq = strchr(arg, '='); + *eq = '\0'; /* spilt `arg' in two strings (name & value) */ lua_pushstring(L, eq+1); lua_setglobal(L, arg); } -static void getargs (l_char *argv[]) { +static void getargs (char *argv[]) { int i; lua_newtable(L); for (i=0; argv[i]; i++) { @@ -134,24 +133,24 @@ static void getargs (l_char *argv[]) { lua_settable(L, -3); } /* arg.n = maximum index in table `arg' */ - lua_pushliteral(L, l_s("n")); + lua_pushliteral(L, "n"); lua_pushnumber(L, i-1); lua_settable(L, -3); } static int l_getargs (lua_State *l) { - l_char **argv = (l_char **)lua_touserdata(l, lua_upvalueindex(1)); + char **argv = (char **)lua_touserdata(l, lua_upvalueindex(1)); getargs(argv); return 1; } -static int file_input (const l_char *argv) { +static int file_input (const char *argv) { int result = ldo(lua_dofile, argv, 1); if (result) { if (result == LUA_ERRFILE) { - fprintf(stderr, LUA_PROGNAME l_s("cannot execute file ")); + fprintf(stderr, LUA_PROGNAME "cannot execute file "); perror(argv); } return EXIT_FAILURE; @@ -167,12 +166,12 @@ static int file_input (const l_char *argv) { #endif -static const l_char *get_prompt (int prompt) { +static const char *get_prompt (int prompt) { if (!prompt) - return l_s(""); + return ""; else { - const l_char *s; - lua_getglobal(L, l_s("_PROMPT")); + const char *s; + lua_getglobal(L, "_PROMPT"); s = lua_tostring(L, -1); if (!s) s = PROMPT; lua_pop(L, 1); /* remove global */ @@ -188,20 +187,20 @@ static void manual_input (int version, int prompt) { int toprint = 0; fputs(get_prompt(prompt), stdout); /* show prompt */ for(;;) { - l_char buffer[MAXINPUT]; + char buffer[MAXINPUT]; size_t l; if (fgets(buffer, sizeof(buffer), stdin) == NULL) { - printf(l_s("\n")); + printf("\n"); return; } - if (firstline && buffer[0] == l_c('=')) { - buffer[0] = l_c(' '); - lua_pushstring(L, l_s("return")); + if (firstline && buffer[0] == '=') { + buffer[0] = ' '; + lua_pushstring(L, "return"); toprint = 1; } l = strlen(buffer); - if (buffer[l-1] == l_c('\n') && buffer[l-2] == l_c('\\')) { - buffer[l-2] = l_c('\n'); + if (buffer[l-1] == '\n' && buffer[l-2] == '\\') { + buffer[l-2] = '\n'; lua_pushlstring(L, buffer, l-1); } else { @@ -214,7 +213,7 @@ static void manual_input (int version, int prompt) { ldo(lua_dostring, lua_tostring(L, 1), 0); lua_remove(L, 1); /* remove ran string */ if (toprint && lua_gettop(L) > 0) { /* any result to print? */ - lua_getglobal(L, l_s("print")); + lua_getglobal(L, "print"); lua_insert(L, 1); lua_call(L, lua_gettop(L)-1, 0); } @@ -224,7 +223,7 @@ static void manual_input (int version, int prompt) { } -static int handle_argv (l_char *argv[], int *toclose) { +static int handle_argv (char *argv[], int *toclose) { if (*argv == NULL) { /* no more arguments? */ if (isatty(0)) { manual_input(1, 1); @@ -235,8 +234,8 @@ static int handle_argv (l_char *argv[], int *toclose) { else { /* other arguments; loop over them */ int i; for (i = 0; argv[i] != NULL; i++) { - if (argv[i][0] != l_c('-')) { /* not an option? */ - if (strchr(argv[i], l_c('='))) + if (argv[i][0] != '-') { /* not an option? */ + if (strchr(argv[i], '=')) assign(argv[i]); else if (file_input(argv[i]) != EXIT_SUCCESS) @@ -247,49 +246,49 @@ static int handle_argv (l_char *argv[], int *toclose) { ldo(lua_dofile, NULL, 1); /* executes stdin as a file */ break; } - case l_c('i'): { + case 'i': { manual_input(0, 1); break; } - case l_c('q'): { + case 'q': { manual_input(0, 0); break; } - case l_c('c'): { + case 'c': { *toclose = 1; break; } - case l_c('v'): { + case 'v': { print_version(); break; } - case l_c('e'): { + case 'e': { i++; if (argv[i] == NULL) { print_message(); return EXIT_FAILURE; } if (ldo(lua_dostring, argv[i], 1) != 0) { - fprintf(stderr, LUA_PROGNAME l_s("error running argument `%.99s'\n"), + fprintf(stderr, LUA_PROGNAME "error running argument `%.99s'\n", argv[i]); return EXIT_FAILURE; } break; } - case l_c('f'): { + case 'f': { i++; if (argv[i] == NULL) { print_message(); return EXIT_FAILURE; } getargs(argv+i); /* collect remaining arguments */ - lua_setglobal(L, l_s("arg")); + lua_setglobal(L, "arg"); return file_input(argv[i]); /* stop scanning arguments */ } - case l_c('s'): { + case 's': { if (i == 0) break; /* option already handled */ fprintf(stderr, - LUA_PROGNAME l_s("stack size (`-s') must be the first option\n")); + LUA_PROGNAME "stack size (`-s') must be the first option\n"); return EXIT_FAILURE; } default: { @@ -303,12 +302,12 @@ static int handle_argv (l_char *argv[], int *toclose) { } -static int getstacksize (int argc, l_char *argv[]) { +static int getstacksize (int argc, char *argv[]) { int stacksize = 0; - if (argc >= 2 && argv[1][0] == l_c('-') && argv[1][1] == l_c('s')) { + if (argc >= 2 && argv[1][0] == '-' && argv[1][1] == 's') { stacksize = strtol(&argv[1][2], NULL, 10); if (stacksize <= 0) { - fprintf(stderr, LUA_PROGNAME l_s("invalid stack size ('%.20s')\n"), + fprintf(stderr, LUA_PROGNAME "invalid stack size ('%.20s')\n", &argv[1][2]); exit(EXIT_FAILURE); } @@ -317,10 +316,10 @@ static int getstacksize (int argc, l_char *argv[]) { } -static void register_getargs (l_char *argv[]) { +static void register_getargs (char *argv[]) { lua_newuserdatabox(L, argv); lua_pushcclosure(L, l_getargs, 1); - lua_setglobal(L, l_s("getargs")); + lua_setglobal(L, "getargs"); } @@ -333,7 +332,7 @@ static void openstdlibs (lua_State *l) { } -int main (int argc, l_char *argv[]) { +int main (int argc, char *argv[]) { int status; int toclose = 0; L = lua_open(getstacksize(argc, argv)); /* create state */ diff --git a/lua.h b/lua.h index 9cc3f081..52179b84 100644 --- a/lua.h +++ b/lua.h @@ -1,5 +1,5 @@ /* -** $Id: lua.h,v 1.106 2001/10/31 19:40:14 roberto Exp roberto $ +** $Id: lua.h,v 1.107 2001/10/31 19:58:11 roberto Exp $ ** Lua - An Extensible Extension Language ** TeCGraf: Grupo de Tecnologia em Computacao Grafica, PUC-Rio, Brazil ** e-mail: info@lua.org @@ -91,12 +91,6 @@ typedef int (*lua_CFunction) (lua_State *L); #endif typedef LUA_NUMBER lua_Number; -/* Lua character type */ -#ifndef L_CHAR -#define L_CHAR char -#endif -typedef L_CHAR lua_char; - /* mark for all API functions */ #ifndef LUA_API @@ -126,7 +120,7 @@ LUA_API int lua_stackspace (lua_State *L); ** access functions (stack -> C) */ -LUA_API const lua_char *lua_type (lua_State *L, int index); +LUA_API const char *lua_type (lua_State *L, int index); LUA_API int lua_isnumber (lua_State *L, int index); LUA_API int lua_isstring (lua_State *L, int index); LUA_API int lua_iscfunction (lua_State *L, int index); @@ -137,7 +131,7 @@ LUA_API int lua_equal (lua_State *L, int index1, int index2); LUA_API int lua_lessthan (lua_State *L, int index1, int index2); LUA_API lua_Number lua_tonumber (lua_State *L, int index); -LUA_API const lua_char *lua_tostring (lua_State *L, int index); +LUA_API const char *lua_tostring (lua_State *L, int index); LUA_API size_t lua_strlen (lua_State *L, int index); LUA_API lua_CFunction lua_tocfunction (lua_State *L, int index); LUA_API void *lua_touserdata (lua_State *L, int index); @@ -149,19 +143,19 @@ LUA_API const void *lua_topointer (lua_State *L, int index); */ LUA_API void lua_pushnil (lua_State *L); LUA_API void lua_pushnumber (lua_State *L, lua_Number n); -LUA_API void lua_pushlstring (lua_State *L, const lua_char *s, size_t len); -LUA_API void lua_pushstring (lua_State *L, const lua_char *s); +LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len); +LUA_API void lua_pushstring (lua_State *L, const char *s); LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n); /* ** get functions (Lua -> stack) */ -LUA_API void lua_getglobal (lua_State *L, const lua_char *name); +LUA_API void lua_getglobal (lua_State *L, const char *name); LUA_API void lua_gettable (lua_State *L, int index); LUA_API void lua_rawget (lua_State *L, int index); LUA_API void lua_rawgeti (lua_State *L, int index, int n); -LUA_API void lua_gettagmethod (lua_State *L, int tag, const lua_char *event); +LUA_API void lua_gettagmethod (lua_State *L, int tag, const char *event); LUA_API void lua_newtable (lua_State *L); LUA_API void lua_getweakregistry (lua_State *L); @@ -169,12 +163,12 @@ LUA_API void lua_getweakregistry (lua_State *L); /* ** set functions (stack -> Lua) */ -LUA_API void lua_setglobal (lua_State *L, const lua_char *name); +LUA_API void lua_setglobal (lua_State *L, const char *name); LUA_API void lua_settable (lua_State *L, int index); LUA_API void lua_rawset (lua_State *L, int index); LUA_API void lua_rawseti (lua_State *L, int index, int n); LUA_API void lua_setglobals (lua_State *L); -LUA_API void lua_settagmethod (lua_State *L, int tag, const lua_char *event); +LUA_API void lua_settagmethod (lua_State *L, int tag, const char *event); /* @@ -182,13 +176,13 @@ LUA_API void lua_settagmethod (lua_State *L, int tag, const lua_char *event); */ LUA_API int lua_call (lua_State *L, int nargs, int nresults); LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults); -LUA_API int lua_loadfile (lua_State *L, const lua_char *filename); -LUA_API int lua_dofile (lua_State *L, const lua_char *filename); -LUA_API int lua_dostring (lua_State *L, const lua_char *str); -LUA_API int lua_loadbuffer (lua_State *L, const lua_char *buff, size_t size, - const lua_char *name); -LUA_API int lua_dobuffer (lua_State *L, const lua_char *buff, size_t size, - const lua_char *name); +LUA_API int lua_loadfile (lua_State *L, const char *filename); +LUA_API int lua_dofile (lua_State *L, const char *filename); +LUA_API int lua_dostring (lua_State *L, const char *str); +LUA_API int lua_loadbuffer (lua_State *L, const char *buff, size_t size, + const char *name); +LUA_API int lua_dobuffer (lua_State *L, const char *buff, size_t size, + const char *name); /* ** Garbage-collection functions @@ -200,13 +194,13 @@ LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold); /* ** miscellaneous functions */ -LUA_API int lua_newtype (lua_State *L, const lua_char *name, int basictype); +LUA_API int lua_newtype (lua_State *L, const char *name, int basictype); LUA_API void lua_settag (lua_State *L, int tag); -LUA_API int lua_name2tag (lua_State *L, const lua_char *name); -LUA_API const lua_char *lua_tag2name (lua_State *L, int tag); +LUA_API int lua_name2tag (lua_State *L, const char *name); +LUA_API const char *lua_tag2name (lua_State *L, int tag); -LUA_API void lua_error (lua_State *L, const lua_char *s); +LUA_API void lua_error (lua_State *L, const char *s); LUA_API int lua_next (lua_State *L, int index); LUA_API int lua_getn (lua_State *L, int index); @@ -240,8 +234,8 @@ LUA_API int lua_getweakmode (lua_State *L, int index); #define lua_isnil(L,n) (lua_rawtag(L,n) == LUA_TNIL) #define lua_isnull(L,n) (lua_rawtag(L,n) == LUA_TNONE) -#define lua_pushliteral(L, s) lua_pushlstring(L, s, \ - (sizeof(s)/sizeof(lua_char))-1) +#define lua_pushliteral(L, s) lua_pushlstring(L, "" s, \ + (sizeof(s)/sizeof(char))-1) #define lua_getregistry(L) lua_pushvalue(L, LUA_REGISTRYINDEX); #define lua_getglobals(L) lua_pushvalue(L, LUA_GLOBALSINDEX); @@ -264,7 +258,7 @@ LUA_API void lua_pushupvalues (lua_State *L); #define LUA_REFNIL (-1) #define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \ - (lua_error(L, l_s("unlocked references are obsolete")), 0)) + (lua_error(L, "unlocked references are obsolete"), 0)) #define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref)) @@ -277,43 +271,21 @@ LUA_API void lua_pushupvalues (lua_State *L); /* ** {====================================================================== ** useful definitions for Lua kernel and libraries +** ======================================================================= */ -#ifdef LUA_PRIVATE - -#define l_char lua_char - -/* macro to control type of literal strings */ -#ifndef l_s -#define l_s(x) x -#endif - -/* macro to control type of literal chars */ -#ifndef l_c -#define l_c(x) x -#endif - -/* macro to `unsign' a character */ -#ifndef uchar -#define uchar(c) ((unsigned char)(c)) -#endif - -/* integer type to hold the result of fgetc */ -#ifndef l_charint -#define l_charint int -#endif -/* -** formats for Lua numbers -*/ +/* formats for Lua numbers */ #ifndef LUA_NUMBER_SCAN #define LUA_NUMBER_SCAN "%lf" #endif + #ifndef LUA_NUMBER_FMT #define LUA_NUMBER_FMT "%.16g" #endif + /* function to convert a lua_Number to a string */ #ifndef lua_number2str -#define lua_number2str(s,n) sprintf((s), l_s(LUA_NUMBER_FMT), (n)) +#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) #endif /* function to convert a string to a lua_Number */ @@ -321,7 +293,6 @@ LUA_API void lua_pushupvalues (lua_State *L); #define lua_str2number(s,p) strtod((s), (p)) #endif -#endif /* }====================================================================== */ diff --git a/luadebug.h b/luadebug.h index 9c2bc13e..b6d7c4b5 100644 --- a/luadebug.h +++ b/luadebug.h @@ -1,5 +1,5 @@ /* -** $Id: luadebug.h,v 1.19 2001/03/07 18:09:25 roberto Exp roberto $ +** $Id: luadebug.h,v 1.20 2001/04/06 21:17:37 roberto Exp $ ** Debugging API ** See Copyright Notice in lua.h */ @@ -18,9 +18,9 @@ typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar); -LUA_API int lua_getinfo (lua_State *L, const lua_char *what, lua_Debug *ar); -LUA_API const lua_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n); -LUA_API const lua_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n); +LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n); LUA_API lua_Hook lua_setcallhook (lua_State *L, lua_Hook func); LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func); @@ -29,15 +29,15 @@ LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func); #define LUA_IDSIZE 60 struct lua_Debug { - const lua_char *event; /* `call', `return' */ + const char *event; /* `call', `return' */ int currentline; /* (l) */ - const lua_char *name; /* (n) */ - const lua_char *namewhat; /* (n) `global', `tag method', `local', `field' */ + const char *name; /* (n) */ + const char *namewhat; /* (n) `global', `tag method', `local', `field' */ int nups; /* (u) number of upvalues */ int linedefined; /* (S) */ - const lua_char *what; /* (S) `Lua' function, `C' function, Lua `main' */ - const lua_char *source; /* (S) */ - lua_char short_src[LUA_IDSIZE]; /* (S) */ + const char *what; /* (S) `Lua' function, `C' function, Lua `main' */ + const char *source; /* (S) */ + char short_src[LUA_IDSIZE]; /* (S) */ /* private part */ struct CallInfo *_ci; /* active function */ }; diff --git a/lundump.c b/lundump.c index f608730b..4906a8db 100644 --- a/lundump.c +++ b/lundump.c @@ -1,5 +1,5 @@ /* -** $Id: lundump.c,v 1.36 2001/07/19 14:34:06 lhf Exp lhf $ +** $Id: lundump.c,v 1.43 2001/07/24 21:57:19 roberto Exp $ ** load pre-compiled Lua chunks ** See Copyright Notice in lua.h */ @@ -7,7 +7,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "ldebug.h" @@ -20,15 +19,15 @@ #define LoadByte ezgetc #define LoadShort (short) LoadInt -static const l_char* ZNAME (ZIO* Z) +static const char* ZNAME (ZIO* Z) { - const l_char* s=zname(Z); - return (*s==l_c('@')) ? s+1 : s; + const char* s=zname(Z); + return (*s=='@') ? s+1 : s; } static void unexpectedEOZ (lua_State* L, ZIO* Z) { - luaO_verror(L,l_s("unexpected end of file in `%.99s'"),ZNAME(Z)); + luaO_verror(L,"unexpected end of file in `%.99s'",ZNAME(Z)); } static int ezgetc (lua_State* L, ZIO* Z) @@ -48,9 +47,9 @@ static void LoadBlock (lua_State* L, void* b, size_t size, ZIO* Z, int swap) { if (swap) { - l_char *p=(l_char*) b+size-1; + char *p=(char*) b+size-1; int n=size; - while (n--) *p--=(l_char)ezgetc(L,Z); + while (n--) *p--=(char)ezgetc(L,Z); } else ezread(L,Z,b,size); @@ -60,12 +59,12 @@ static void LoadVector (lua_State* L, void* b, int m, size_t size, ZIO* Z, int s { if (swap) { - l_char *q=(l_char*) b; + char *q=(char*) b; while (m--) { - l_char *p=q+size-1; + char *p=q+size-1; int n=size; - while (n--) *p--=(l_char)ezgetc(L,Z); + while (n--) *p--=(char)ezgetc(L,Z); q+=size; } } @@ -101,7 +100,7 @@ static TString* LoadString (lua_State* L, ZIO* Z, int swap) return NULL; else { - l_char* s=luaO_openspace(L,size,l_char); + char* s=luaO_openspace(L,size,char); LoadBlock(L,s,size,Z,0); return luaS_newlstr(L,s,size-1); /* remove trailing '\0' */ } @@ -159,7 +158,7 @@ static void LoadConstants (lua_State* L, Proto* f, ZIO* Z, int swap) tsvalue(o)=LoadString(L,Z,swap); break; default: - luaO_verror(L,l_s("bad constant type (%d) in `%.99s'"),ttype(o),ZNAME(Z)); + luaO_verror(L,"bad constant type (%d) in `%.99s'",ttype(o),ZNAME(Z)); break; } } @@ -183,25 +182,25 @@ static Proto* LoadFunction (lua_State* L, TString* p, ZIO* Z, int swap) LoadConstants(L,f,Z,swap); LoadCode(L,f,Z,swap); #ifndef TRUST_BINARIES - if (!luaG_checkcode(f)) luaO_verror(L,l_s("bad code in `%.99s'"),ZNAME(Z)); + if (!luaG_checkcode(f)) luaO_verror(L,"bad code in `%.99s'",ZNAME(Z)); #endif return f; } static void LoadSignature (lua_State* L, ZIO* Z) { - const l_char* s=l_s(LUA_SIGNATURE); + const char* s=LUA_SIGNATURE; while (*s!=0 && ezgetc(L,Z)==*s) ++s; - if (*s!=0) luaO_verror(L,l_s("bad signature in `%.99s'"),ZNAME(Z)); + if (*s!=0) luaO_verror(L,"bad signature in `%.99s'",ZNAME(Z)); } -static void TestSize (lua_State* L, int s, const l_char* what, ZIO* Z) +static void TestSize (lua_State* L, int s, const char* what, ZIO* Z) { int r=LoadByte(L,Z); if (r!=s) - luaO_verror(L,l_s("virtual machine mismatch in `%.99s':\n") - l_s(" size of %.20s is %d but read %d"),ZNAME(Z),what,s,r); + luaO_verror(L,"virtual machine mismatch in `%.99s':\n" + " size of %.20s is %d but read %d",ZNAME(Z),what,s,r); } #define TESTSIZE(s,w) TestSize(L,s,w,Z) @@ -214,26 +213,26 @@ static int LoadHeader (lua_State* L, ZIO* Z) LoadSignature(L,Z); version=LoadByte(L,Z); if (version>VERSION) - luaO_verror(L,l_s("`%.99s' too new:\n") - l_s(" read version %d.%d; expected at most %d.%d"), + luaO_verror(L,"`%.99s' too new:\n" + " read version %d.%d; expected at most %d.%d", ZNAME(Z),V(version),V(VERSION)); if (version #include -#define LUA_PRIVATE #include "lua.h" #include "lapi.h" @@ -54,7 +53,7 @@ int luaV_tostring (lua_State *L, TObject *obj) { if (ttype(obj) != LUA_TNUMBER) return 1; else { - l_char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */ + char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */ lua_number2str(s, nvalue(obj)); /* convert `s' to number */ setsvalue(obj, luaS_new(L, s)); return 0; @@ -86,7 +85,7 @@ static void traceexec (lua_State *L, lua_Hook linehook) { /* maximum stack used by a call to a tag method (func + args) */ #define MAXSTACK_TM 4 -static StkId callTM (lua_State *L, Closure *f, const l_char *fmt, ...) { +static StkId callTM (lua_State *L, Closure *f, const char *fmt, ...) { va_list argp; StkId base = L->top; lua_assert(strlen(fmt)+1 <= MAXSTACK_TM); @@ -95,11 +94,11 @@ static StkId callTM (lua_State *L, Closure *f, const l_char *fmt, ...) { setclvalue(L->top, f); /* push function */ L->top++; while (*fmt) { - if (*fmt++ == l_c('o')) { + if (*fmt++ == 'o') { setobj(L->top, va_arg(argp, TObject *)); } else { - lua_assert(*(fmt-1) == l_c('s')); + lua_assert(*(fmt-1) == 's'); setsvalue(L->top, va_arg(argp, TString *)); } L->top++; @@ -146,9 +145,9 @@ void luaV_gettable (lua_State *L, StkId t, TObject *key, StkId res) { } else { /* not a table; try a `gettable' tag method */ tm = luaT_gettmbyObj(G(L), t, TM_GETTABLE); if (tm == NULL) /* no tag method? */ - luaG_typeerror(L, t, l_s("index")); + luaG_typeerror(L, t, "index"); } - setTMresult(L, res, callTM(L, tm, l_s("oo"), t, key)); + setTMresult(L, res, callTM(L, tm, "oo", t, key)); } @@ -169,9 +168,9 @@ void luaV_settable (lua_State *L, StkId t, TObject *key, StkId val) { } else { /* not a table; try a `settable' tag method */ tm = luaT_gettmbyObj(G(L), t, TM_SETTABLE); if (tm == NULL) /* no tag method? */ - luaG_typeerror(L, t, l_s("index")); + luaG_typeerror(L, t, "index"); } - setTM(L, callTM(L, tm, l_s("ooo"), t, key, val)); + setTM(L, callTM(L, tm, "ooo", t, key, val)); } @@ -183,7 +182,7 @@ void luaV_getglobal (lua_State *L, TString *name, StkId res) { setobj(res, value); /* default behavior */ } else - setTMresult(L, res, callTM(L, tm, l_s("so"), name, value)); + setTMresult(L, res, callTM(L, tm, "so", name, value)); } @@ -198,7 +197,7 @@ void luaV_setglobal (lua_State *L, TString *name, StkId val) { settableval(oldvalue, val); /* warning: tricky optimization! */ } else - setTM(L, callTM(L, tm, l_s("soo"), name, oldvalue, val)); + setTM(L, callTM(L, tm, "soo", name, oldvalue, val)); } @@ -213,7 +212,7 @@ static int call_binTM (lua_State *L, const TObject *p1, const TObject *p2, return 0; /* no tag method */ } } - setTMresult(L, res, callTM(L, tm, l_s("oo"), p1, p2)); + setTMresult(L, res, callTM(L, tm, "oo", p1, p2)); return 1; } @@ -226,9 +225,9 @@ static void call_arith (lua_State *L, StkId p1, TObject *p2, static int luaV_strlessthan (const TString *ls, const TString *rs) { - const l_char *l = getstr(ls); + const char *l = getstr(ls); size_t ll = ls->tsv.len; - const l_char *r = getstr(rs); + const char *r = getstr(rs); size_t lr = rs->tsv.len; for (;;) { int temp = strcoll(l, r); @@ -271,14 +270,14 @@ void luaV_strconc (lua_State *L, int total, StkId top) { /* at least two string values; get as many as possible */ lu_mem tl = cast(lu_mem, tsvalue(top-1)->tsv.len) + cast(lu_mem, tsvalue(top-2)->tsv.len); - l_char *buffer; + char *buffer; int i; while (n < total && !tostring(L, top-n-1)) { /* collect total length */ tl += tsvalue(top-n-1)->tsv.len; n++; } - if (tl > MAX_SIZET) luaD_error(L, l_s("string size overflow")); - buffer = luaO_openspace(L, tl, l_char); + if (tl > MAX_SIZET) luaD_error(L, "string size overflow"); + buffer = luaO_openspace(L, tl, char); tl = 0; for (i=n; i>0; i--) { /* concat all strings */ size_t l = tsvalue(top-i)->tsv.len; @@ -301,7 +300,7 @@ static void luaV_pack (lua_State *L, StkId firstelem) { luaH_setnum(L, htab, i+1, firstelem+i); /* store counter in field `n' */ setnvalue(&n, i); - luaH_setstr(L, htab, luaS_newliteral(L, l_s("n")), &n); + luaH_setstr(L, htab, luaS_newliteral(L, "n"), &n); L->top = firstelem; /* remove elements from the stack */ sethvalue(L->top, htab); incr_top; @@ -567,11 +566,11 @@ StkId luaV_execute (lua_State *L, const LClosure *cl, StkId base) { } case OP_FORPREP: { if (luaV_tonumber(ra, ra) == NULL) - luaD_error(L, l_s("`for' initial value must be a number")); + luaD_error(L, "`for' initial value must be a number"); if (luaV_tonumber(ra+1, ra+1) == NULL) - luaD_error(L, l_s("`for' limit must be a number")); + luaD_error(L, "`for' limit must be a number"); if (luaV_tonumber(ra+2, ra+2) == NULL) - luaD_error(L, l_s("`for' step must be a number")); + luaD_error(L, "`for' step must be a number"); /* decrement index (to be incremented) */ chgnvalue(ra, nvalue(ra) - nvalue(ra+2)); pc += -GETARG_sBc(i); /* `jump' to loop end (delta is negated here) */ @@ -583,7 +582,7 @@ StkId luaV_execute (lua_State *L, const LClosure *cl, StkId base) { runtime_check(L, ttype(ra+1) == LUA_TNUMBER && ttype(ra+2) == LUA_TNUMBER); if (ttype(ra) != LUA_TNUMBER) - luaD_error(L, l_s("`for' index must be a number")); + luaD_error(L, "`for' index must be a number"); chgnvalue(ra+1, nvalue(ra+1) - 1); /* decrement counter */ if (nvalue(ra+1) >= 0) { chgnvalue(ra, nvalue(ra) + nvalue(ra+2)); /* increment index */ @@ -593,7 +592,7 @@ StkId luaV_execute (lua_State *L, const LClosure *cl, StkId base) { } case OP_TFORPREP: { if (ttype(ra) != LUA_TTABLE) - luaD_error(L, l_s("`for' table must be a table")); + luaD_error(L, "`for' table must be a table"); setnvalue(ra+1, -1); /* initial index */ setnilvalue(ra+2); setnilvalue(ra+3); diff --git a/lzio.c b/lzio.c index b5892ce0..208bdb8b 100644 --- a/lzio.c +++ b/lzio.c @@ -1,5 +1,5 @@ /* -** $Id: lzio.c,v 1.13 2000/06/12 13:52:05 roberto Exp roberto $ +** $Id: lzio.c,v 1.14 2001/03/26 14:31:49 roberto Exp $ ** a generic input stream interface ** See Copyright Notice in lua.h */ @@ -9,7 +9,6 @@ #include #include -#define LUA_PRIVATE #include "lua.h" #include "lzio.h"