GitHub/lua
1
0
Fork 0
mirror of https://github.com/lua/lua.git synced 2025-01-14 05:43:00 +08:00
Code Issues Projects Releases Wiki Activity

no more explicit support for wide-chars; too much troble...

Browse Source
This commit is contained in:
Roberto Ierusalimschy 2001-11-28 18:13:13 -02:00
parent dfaf8c5291
commit 72659a0605
39 changed files with 1161 additions and 1210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
lapi.c
View File

@ -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 <string.h>
#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; i<n; i++) {
setobj(L->top, &clvalue(func)->c.upvalue[i]);
L->top++;

45
lauxlib.c
View File

@ -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 */
}

36
lauxlib.h
View File

@ -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);

227
lbaselib.c
View File

@ -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 <stdlib.h>
#include <string.h>
#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<l) lua_error(L, l_s("invalid order function for sorting"));
if (j<l) lua_error(L, "invalid order function for sorting");
lua_pop(L, 1); /* remove a[j] */
}
if (j<i) {
@ -680,57 +679,57 @@ static int luaB_sort (lua_State *L) {
static const luaL_reg base_funcs[] = {
{l_s(LUA_ALERT), luaB__ALERT},
{l_s(LUA_ERRORMESSAGE), luaB__ERRORMESSAGE},
{l_s("call"), luaB_call},
{l_s("collectgarbage"), luaB_collectgarbage},
{l_s("dofile"), luaB_dofile},
{l_s("dostring"), luaB_dostring},
{l_s("error"), luaB_error},
{l_s("foreach"), luaB_foreach},
{l_s("foreachi"), luaB_foreachi},
{l_s("gcinfo"), luaB_gcinfo},
{l_s("getglobal"), luaB_getglobal},
{l_s("gettagmethod"), luaB_gettagmethod},
{l_s("globals"), luaB_globals},
{l_s("loadfile"), luaB_loadfile},
{l_s("loadstring"), luaB_loadstring},
{l_s("newtype"), luaB_newtype},
{l_s("newtag"), luaB_newtype}, /* for compatibility 4.0 */
{l_s("next"), luaB_next},
{l_s("print"), luaB_print},
{l_s("rawget"), luaB_rawget},
{l_s("rawset"), luaB_rawset},
{l_s("rawgettable"), luaB_rawget}, /* for compatibility 3.2 */
{l_s("rawsettable"), luaB_rawset}, /* for compatibility 3.2 */
{l_s("rawtype"), luaB_rawtype},
{l_s("setglobal"), luaB_setglobal},
{l_s("settag"), luaB_settype}, /* for compatibility 4.0 */
{l_s("settype"), luaB_settype},
{l_s("settagmethod"), luaB_settagmethod},
{l_s("tag"), luaB_tag},
{l_s("tonumber"), luaB_tonumber},
{l_s("tostring"), luaB_tostring},
{l_s("type"), luaB_type},
{l_s("assert"), luaB_assert},
{l_s("getn"), luaB_getn},
{l_s("sort"), luaB_sort},
{l_s("tinsert"), luaB_tinsert},
{l_s("tremove"), luaB_tremove},
{l_s("unpack"), luaB_unpack},
{l_s("weakmode"), luaB_weakmode}
{LUA_ALERT, luaB__ALERT},
{LUA_ERRORMESSAGE, luaB__ERRORMESSAGE},
{"call", luaB_call},
{"collectgarbage", luaB_collectgarbage},
{"dofile", luaB_dofile},
{"dostring", luaB_dostring},
{"error", luaB_error},
{"foreach", luaB_foreach},
{"foreachi", luaB_foreachi},
{"gcinfo", luaB_gcinfo},
{"getglobal", luaB_getglobal},
{"gettagmethod", luaB_gettagmethod},
{"globals", luaB_globals},
{"loadfile", luaB_loadfile},
{"loadstring", luaB_loadstring},
{"newtype", luaB_newtype},
{"newtag", luaB_newtype}, /* for compatibility 4.0 */
{"next", luaB_next},
{"print", luaB_print},
{"rawget", luaB_rawget},
{"rawset", luaB_rawset},
{"rawgettable", luaB_rawget}, /* for compatibility 3.2 */
{"rawsettable", luaB_rawset}, /* for compatibility 3.2 */
{"rawtype", luaB_rawtype},
{"setglobal", luaB_setglobal},
{"settag", luaB_settype}, /* for compatibility 4.0 */
{"settype", luaB_settype},
{"settagmethod", luaB_settagmethod},
{"tag", luaB_tag},
{"tonumber", luaB_tonumber},
{"tostring", luaB_tostring},
{"type", luaB_type},
{"assert", luaB_assert},
{"getn", luaB_getn},
{"sort", luaB_sort},
{"tinsert", luaB_tinsert},
{"tremove", luaB_tremove},
{"unpack", luaB_unpack},
{"weakmode", luaB_weakmode}
};
LUALIB_API int lua_baselibopen (lua_State *L) {
luaL_openl(L, base_funcs);
lua_pushliteral(L, l_s(LUA_VERSION));
lua_setglobal(L, l_s("_VERSION"));
lua_pushliteral(L, LUA_VERSION);
lua_setglobal(L, "_VERSION");
/* `require' needs an empty table as upvalue */
lua_newtable(L);
lua_pushcclosure(L, luaB_require, 1);
lua_setglobal(L, l_s("require"));
lua_setglobal(L, "require");
return 0;
}

17
lcode.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lcode.c,v 1.79 2001/08/27 15:16:28 roberto Exp roberto $
** $Id: lcode.c,v 1.82 2001/09/07 17:39:10 roberto Exp $
** Code generator for Lua
** See Copyright Notice in lua.h
*/
@ -7,7 +7,6 @@
#include <stdlib.h>
#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++;

4
lcode.h
View File

@ -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);

71
ldblib.c
View File

@ -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 <stdlib.h>
#include <string.h>
#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}
};

87
ldebug.c
View File

@ -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 <stdlib.h>
#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; e<TM_N; e++) {
@ -220,7 +219,7 @@ static const l_char *travtagmethods (global_State *G, const TObject *o) {
}
static const l_char *travglobals (lua_State *L, const TObject *o) {
static const char *travglobals (lua_State *L, const TObject *o) {
Table *g = hvalue(&L->gt);
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);
}

4
ldebug.h
View File

@ -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);

39
ldo.c
View File

@ -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 <stdlib.h>
#include <string.h>
#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);
}
}

4
ldo.h
View File

@ -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);

5
lfunc.c
View File

@ -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 <stdlib.h>
#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; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
if (pc < f->locvars[i].endpc) { /* is variable active? */

4
lfunc.h
View File

@ -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

5
lgc.c
View File

@ -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;
}
}

245
liolib.c
View File

@ -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 <string.h>
#include <time.h>
#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;
}

201
llex.c
View File

@ -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 <stdio.h>
#include <string.h>
#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("<eof>")
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", "",
"..", "...", "==", ">=", "<=", "~=",
"", "", "<eof>"
};
@ -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);

12
llex.h
View File

@ -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

59
lmathlib.c
View File

@ -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 <stdlib.h>
#include <math.h>
#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;
}

7
lmem.c
View File

@ -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 <stdlib.h>
#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) {

4
lmem.h
View File

@ -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)

41
lobject.c
View File

@ -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 <stdlib.h>
#include <string.h>
#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);
}
}
}

10
lobject.h
View File

@ -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

87
lopcodes.c
View File

@ -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

4
lopcodes.h
View File

@ -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

167
lparser.c
View File

@ -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 <stdio.h>
#include <string.h>
#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("<name> expected"));
check_condition(ls, (ls->t.token == TK_NAME), "<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; i<func->f->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("<eof> expected"));
"<eof> 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("<name> or `[' expected"));
default: luaK_error(ls, "<name> 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("<name> or `...' expected"));
default: luaK_error(ls, "<name> 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 */
}

5
lstate.c
View File

@ -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 <stdio.h>
#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);

13
lstring.c
View File

@ -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 <string.h>
#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) {

10
lstring.h
View File

@ -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

277
lstrlib.c
View File

@ -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 <stdlib.h>
#include <string.h>
#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<l; i++)
luaL_putchar(&b, tolower(uchar(s[i])));
@ -66,7 +71,7 @@ static int str_upper (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<l; i++)
luaL_putchar(&b, toupper(uchar(s[i])));
@ -77,7 +82,7 @@ static int str_upper (lua_State *L) {
static int str_rep (lua_State *L) {
size_t l;
luaL_Buffer b;
const l_char *s = luaL_check_lstr(L, 1, &l);
const char *s = luaL_check_lstr(L, 1, &l);
int n = luaL_check_int(L, 2);
luaL_buffinit(L, &b);
while (n-- > 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)<ms->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 (s<ms->src_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 = s<ms->src_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; i<ms->level; 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<l; i++) {
@ -511,22 +516,22 @@ static void add_s (MatchState *ms, luaL_Buffer *b) {
static int str_gsub (lua_State *L) {
size_t srcl;
const l_char *src = luaL_check_lstr(L, 1, &srcl);
const l_char *p = luaL_check_string(L, 2);
const char *src = luaL_check_lstr(L, 1, &srcl);
const char *p = luaL_check_string(L, 2);
int max_s = luaL_opt_int(L, 4, srcl+1);
int anchor = (*p == l_c('^')) ? (p++, 1) : 0;
int anchor = (*p == '^') ? (p++, 1) : 0;
int n = 0;
MatchState ms;
luaL_Buffer b;
luaL_arg_check(L,
lua_gettop(L) >= 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}
};

11
ltable.c
View File

@ -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; i<size; i++)
setnilvalue(&t->array[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<size; i++) {
@ -417,7 +416,7 @@ void luaH_set (lua_State *L, Table *t, const TObject *key, const TObject *val) {
settableval(p, val);
}
else {
if (ttype(key) == LUA_TNIL) luaD_error(L, l_s("table index is nil"));
if (ttype(key) == LUA_TNIL) luaD_error(L, "table index is nil");
newkey(L, t, key, val);
}
}

215
ltests.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ltests.c,v 1.95 2001/10/26 17:33:30 roberto Exp $
** $Id: ltests.c,v 1.96 2001/11/06 21:41:43 roberto Exp $
** Internal Module for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/
@ -12,7 +12,6 @@
#include <string.h>
#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; pc<p->sizecode; 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; i<p->sizek; 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

43
ltm.c
View File

@ -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 <stdio.h>
#include <string.h>
#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; i<NUM_TAGS; i++)
@ -76,12 +75,12 @@ void luaT_init (lua_State *L) {
}
int luaT_newtag (lua_State *L, const l_char *name, int basictype) {
int luaT_newtag (lua_State *L, const char *name, int basictype) {
int tag;
int i;
TString *ts = NULL;
luaM_growvector(L, G(L)->TMtable, 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);

8
ltm.h
View File

@ -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);

117
lua.c
View File

@ -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 <stdlib.h>
#include <string.h>
#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 */

85
lua.h
View File

@ -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
/* }====================================================================== */

20
luadebug.h
View File

@ -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 */
};

69
lundump.c
View File

@ -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 <stdio.h>
#include <string.h>
#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<VERSION0) /* check last major change */
luaO_verror(L,l_s("`%.99s' too old:\n")
l_s(" read version %d.%d; expected at least %d.%d"),
luaO_verror(L,"`%.99s' too old:\n"
" read version %d.%d; expected at least %d.%d",
ZNAME(Z),V(version),V(VERSION));
swap=(luaU_endianness()!=LoadByte(L,Z)); /* need to swap bytes? */
TESTSIZE(sizeof(int),l_s("int"));
TESTSIZE(sizeof(size_t), l_s("size_t"));
TESTSIZE(sizeof(Instruction), l_s("size_t"));
TESTSIZE(SIZE_OP, l_s("OP"));
TESTSIZE(SIZE_A, l_s("A"));
TESTSIZE(SIZE_B, l_s("B"));
TESTSIZE(SIZE_C, l_s("C"));
TESTSIZE(sizeof(lua_Number), l_s("number"));
TESTSIZE(sizeof(int),"int");
TESTSIZE(sizeof(size_t), "size_t");
TESTSIZE(sizeof(Instruction), "size_t");
TESTSIZE(SIZE_OP, "OP");
TESTSIZE(SIZE_A, "A");
TESTSIZE(SIZE_B, "B");
TESTSIZE(SIZE_C, "C");
TESTSIZE(sizeof(lua_Number), "number");
x=LoadNumber(L,Z,swap);
if ((long)x!=(long)tx) /* disregard errors in last bits of fraction */
luaO_verror(L,l_s("unknown number format in `%.99s':\n")
l_s(" read ") l_s(LUA_NUMBER_FMT) l_s("; expected ") l_s(LUA_NUMBER_FMT),
luaO_verror(L,"unknown number format in `%.99s':\n"
" read " LUA_NUMBER_FMT "; expected " LUA_NUMBER_FMT,
ZNAME(Z),x,tx);
return swap;
}
@ -250,7 +249,7 @@ Proto* luaU_undump (lua_State* L, ZIO* Z)
{
Proto* f=LoadChunk(L,Z);
if (zgetc(Z)!=EOZ)
luaO_verror(L,l_s("`%.99s' apparently contains more than one chunk"),ZNAME(Z));
luaO_verror(L,"`%.99s' apparently contains more than one chunk",ZNAME(Z));
return f;
}
@ -260,5 +259,5 @@ Proto* luaU_undump (lua_State* L, ZIO* Z)
int luaU_endianness (void)
{
int x=1;
return *(l_char*)&x;
return *(char*)&x;
}

47
lvm.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lvm.c,v 1.197 2001/10/31 19:58:11 roberto Exp $
** $Id: lvm.c,v 1.198 2001/11/06 21:41:53 roberto Exp $
** Lua virtual machine
** See Copyright Notice in lua.h
*/
@ -10,7 +10,6 @@
#include <stdlib.h>
#include <string.h>
#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);

3
lzio.c
View File

@ -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 <stdio.h>
#include <string.h>
#define LUA_PRIVATE
#include "lua.h"
#include "lzio.h"