commit 9fdf73bc9a6b4c6afbfff1d8181fface6b1c6761
parent f1fd9b5c2c21f24d25d7813f431a3495702ebea6
Author: Roberto Ierusalimschy <roberto@inf.puc-rio.br>
Date: Mon, 28 Aug 2000 14:56:42 -0300
first version for new API
Diffstat:
M | lapi.c | | | 432 | +++++++++++++++++++++++++++++++++++++++---------------------------------------- |
M | lapi.h | | | 5 | ++--- |
M | lauxlib.c | | | 68 | +++++++++++++++++++++++++++++--------------------------------------- |
M | lauxlib.h | | | 12 | +++++------- |
M | lbuiltin.c | | | 337 | ++++++++++++++++++++++++++++++++++++++++++++----------------------------------- |
M | lbuiltin.h | | | 58 | +++++++++++++++++++++++++++++----------------------------- |
M | ldblib.c | | | 104 | +++++++++++++++++++++++++++++++++++++------------------------------------------ |
M | ldebug.c | | | 40 | +++++++++++++++++++++------------------- |
M | ldo.c | | | 87 | ++++++++++++++++++++++++++++++++----------------------------------------------- |
M | ldo.h | | | 3 | +-- |
M | lgc.c | | | 42 | +++++++++++++++++++++++++++++++++++++++--- |
M | liolib.c | | | 196 | ++++++++++++++++++++++++++++++++++++++++++++----------------------------------- |
M | llimits.h | | | 8 | +------- |
M | lmathlib.c | | | 122 | ++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------- |
D | lref.c | | | 118 | ------------------------------------------------------------------------------- |
D | lref.h | | | 27 | --------------------------- |
M | lstate.c | | | 8 | +------- |
M | lstate.h | | | 35 | +++++++++++++++++------------------ |
M | lstrlib.c | | | 104 | +++++++++++++++++++++++++++++++++++++++++++------------------------------------ |
M | ltests.c | | | 413 | +++++++++++++++++++++++++++++++++++++++++-------------------------------------- |
M | lua.c | | | 74 | ++++++++++++++++++++++++++++++++++++++------------------------------------ |
M | lua.h | | | 251 | +++++++++++++++++++++++++------------------------------------------------------ |
M | luadebug.h | | | 16 | ++++------------ |
M | lundump.c | | | 4 | ++-- |
24 files changed, 1205 insertions(+), 1359 deletions(-)
diff --git a/lapi.c b/lapi.c
@@ -1,5 +1,5 @@
/*
-** $Id: lapi.c,v 1.86 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: lapi.c,v 1.87 2000/08/14 19:10:14 roberto Exp roberto $
** Lua API
** See Copyright Notice in lua.h
*/
@@ -16,7 +16,6 @@
#include "lgc.h"
#include "lmem.h"
#include "lobject.h"
-#include "lref.h"
#include "lstate.h"
#include "lstring.h"
#include "ltable.h"
@@ -29,246 +28,148 @@ const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
-void luaA_checkCargs (lua_State *L, int nargs) {
- if (nargs > L->top-L->Cstack.base)
- luaL_verror(L, "Lua API error - "
- "expected at least %d arguments in C2lua stack", nargs);
-}
-
+#define Index(L,i) ((i) >= 0 ? (L->Cbase+((i)-1)) : (L->top+(i)))
-lua_Object luaA_putluaObject (lua_State *L, const TObject *o) {
- luaD_openstack(L, L->Cstack.base);
- *L->Cstack.base++ = *o;
- return L->Cstack.base-1;
-}
+#define api_incr_top(L) (++L->top)
-static void top2LC (lua_State *L, int n) {
- /* Put the `n' elements on the top as the Lua2C contents */
- L->Cstack.base = L->top; /* new base */
- L->Cstack.lua2C = L->Cstack.base-n; /* position of the new results */
- L->Cstack.num = n; /* number of results */
-}
-lua_Object lua_pop (lua_State *L) {
- luaA_checkCargs(L, 1);
- if (L->Cstack.base != L->top-1) {
- luaD_openstack(L, L->Cstack.base);
- *L->Cstack.base = *(--L->top);
- }
- return L->Cstack.base++;
+TObject *luaA_index (lua_State *L, int index) {
+ return Index(L, index);
}
-void lua_pushglobals (lua_State *L) {
- hvalue(L->top) = L->gt;
- ttype(L->top) = TAG_TABLE;
+void luaA_pushobject (lua_State *L, const TObject *o) {
+ *L->top = *o;
incr_top;
}
-void lua_setglobals (lua_State *L, lua_Object newtable) {
- if (lua_type(L, newtable)[0] != 't') /* type == "table"? */
- lua_error(L, "Lua API error - invalid value for global table");
- L->gt = hvalue(newtable);
-}
-
/*
-** Get a parameter, returning the object handle or LUA_NOOBJECT on error.
-** `number' must be 1 to get the first parameter.
+** basic stack manipulation
*/
-lua_Object lua_lua2C (lua_State *L, int number) {
- if (number <= 0 || number > L->Cstack.num) return LUA_NOOBJECT;
- return L->Cstack.lua2C+number-1;
-}
-int lua_callfunction (lua_State *L, lua_Object function) {
- if (function == LUA_NOOBJECT)
- return 1;
- else {
- luaD_openstack(L, L->Cstack.base);
- *L->Cstack.base = *function;
- return luaD_protectedrun(L);
- }
+int lua_gettop (lua_State *L) {
+ return (L->top - L->Cbase);
}
-lua_Object lua_gettagmethod (lua_State *L, int tag, const char *event) {
- return luaA_putluaObject(L, luaT_gettagmethod(L, tag, event));
+void lua_settop (lua_State *L, int index) {
+ if (index >= 0)
+ luaD_adjusttop(L, L->Cbase, index);
+ else
+ L->top += index; /* index is negative */
}
-lua_Object lua_settagmethod (lua_State *L, int tag, const char *event) {
- TObject *method;
- luaA_checkCargs(L, 1);
- method = L->top-1;
- if ((ttype(method) != TAG_NIL) && (*lua_type(L, method) != 'f'))
- lua_error(L, "Lua API error - tag method must be a function or nil");
- luaT_settagmethod(L, tag, event, method);
- return lua_pop(L);
+void lua_pushobject (lua_State *L, int index) {
+ *L->top = *Index(L, index);
+ api_incr_top(L);
}
-lua_Object lua_gettable (lua_State *L) {
- luaA_checkCargs(L, 2);
- luaV_gettable(L, L->top--);
- return lua_pop(L);
-}
-
-lua_Object lua_rawget (lua_State *L) {
- lua_Object res;
- luaA_checkCargs(L, 2);
- if (ttype(L->top-2) != TAG_TABLE)
- lua_error(L, "indexed expression not a table");
- res = luaA_putluaObject(L, luaH_get(L, hvalue(L->top-2), L->top-1));
- L->top -= 2;
- return res;
-}
+/*
+** access functions (stack -> C)
+*/
-void lua_settable (lua_State *L) {
- StkId top;
- luaA_checkCargs(L, 3);
- top = L->top;
- luaV_settable(L, top-3, top);
- L->top = top-3; /* pop table, index, and value */
-}
+#define btest(L,i,value,default) { \
+ StkId o; \
+ if ((i) >= 0) { \
+ o = L->Cbase+((i)-1); \
+ if (o >= L->top) return (default); \
+ } \
+ else o = L->top+(i); \
+ return (value); }
-void lua_rawset (lua_State *L) {
- luaA_checkCargs(L, 3);
- if (ttype(L->top-3) != TAG_TABLE)
- lua_error(L, "indexed expression not a table");
- *luaH_set(L, hvalue(L->top-3), L->top-2) = *(L->top-1);
- L->top -= 3;
-}
+#define access(L,i,test,default,value) { \
+ StkId o; \
+ if ((i) >= 0) { \
+ o = L->Cbase+((i)-1); \
+ if (o >= L->top) return (default); \
+ } \
+ else o = L->top+(i); \
+ return ((test) ? (value) : (default)); }
-lua_Object lua_createtable (lua_State *L) {
- TObject o;
- luaC_checkGC(L);
- hvalue(&o) = luaH_new(L, 0);
- ttype(&o) = TAG_TABLE;
- return luaA_putluaObject(L, &o);
+const char *lua_type (lua_State *L, int index) {
+ btest(L, index, luaO_typename(o), "NO VALUE");
}
-
-lua_Object lua_getglobal (lua_State *L, const char *name) {
- luaV_getglobal(L, luaS_new(L, name), L->top++);
- return lua_pop(L);
+int lua_iscfunction (lua_State *L, int index) {
+ btest(L, index, (ttype(o) == TAG_CCLOSURE), 0);
}
-
-void lua_setglobal (lua_State *L, const char *name) {
- luaA_checkCargs(L, 1);
- luaV_setglobal(L, luaS_new(L, name), L->top--);
+int lua_isnumber (lua_State *L, int index) {
+ btest(L, index, (tonumber(Index(L, index)) == 0), 0);
}
-
-const char *lua_type (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o == LUA_NOOBJECT) ? "NOOBJECT" : luaO_typename(o);
+int lua_tag (lua_State *L, int index) {
+ btest(L, index,
+ ((ttype(o) == TAG_USERDATA) ? tsvalue(o)->u.d.tag : luaT_effectivetag(L, o)),
+ -1);
}
-int lua_isnil (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o != LUA_NOOBJECT) && (ttype(o) == TAG_NIL);
+int lua_equal(lua_State *L, int index1, int index2) {
+ return luaO_equalObj(Index(L, index1), Index(L, index2));
}
-int lua_istable (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o != LUA_NOOBJECT) && (ttype(o) == TAG_TABLE);
-}
-int lua_isuserdata (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o != LUA_NOOBJECT) && (ttype(o) == TAG_USERDATA);
-}
-int lua_iscfunction (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o != LUA_NOOBJECT) && (ttype(o) == TAG_CCLOSURE);
+double lua_tonumber (lua_State *L, int index) {
+ access(L, index, (tonumber(o) == 0), 0.0, nvalue(o));
}
-int lua_isnumber (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o != LUA_NOOBJECT) && (tonumber(o) == 0);
+const char *lua_tostring (lua_State *L, int index) {
+ luaC_checkGC(L); /* `tostring' may create a new string */
+ access(L, index, (tostring(L, o) == 0), NULL, svalue(o));
}
-int lua_isstring (lua_State *L, lua_Object o) {
- UNUSED(L);
- return (o != LUA_NOOBJECT && (ttype(o) == TAG_STRING ||
- ttype(o) == TAG_NUMBER));
+size_t lua_strlen (lua_State *L, int index) {
+ access(L, index, (tostring(L, o) == 0), 0, tsvalue(o)->u.s.len);
}
-int lua_isfunction (lua_State *L, lua_Object o) {
- return *lua_type(L, o) == 'f';
+lua_CFunction lua_tocfunction (lua_State *L, int index) {
+ access(L, index, (ttype(o) == TAG_CCLOSURE), NULL, clvalue(o)->f.c);
}
-int lua_equal(lua_State *L, lua_Object o1, lua_Object o2) {
- UNUSED(L);
- if (o1 == LUA_NOOBJECT || o2 == LUA_NOOBJECT)
- return (o1 == o2);
- else return luaO_equalObj(o1, o2);
+void *lua_touserdata (lua_State *L, int index) {
+ access(L, index, (ttype(o) == TAG_USERDATA), NULL, tsvalue(o)->u.d.value);
}
-double lua_getnumber (lua_State *L, lua_Object obj) {
- UNUSED(L);
- if (obj == LUA_NOOBJECT || tonumber(obj))
- return 0.0;
- else return (nvalue(obj));
-}
-const char *lua_getstring (lua_State *L, lua_Object obj) {
- luaC_checkGC(L); /* `tostring' may create a new string */
- if (obj == LUA_NOOBJECT || tostring(L, obj))
- return NULL;
- else return (svalue(obj));
-}
-
-size_t lua_strlen (lua_State *L, lua_Object obj) {
- if (obj == LUA_NOOBJECT || tostring(L, obj))
- return 0L;
- else return (tsvalue(obj)->u.s.len);
-}
-
-void *lua_getuserdata (lua_State *L, lua_Object obj) {
- UNUSED(L);
- if (obj == LUA_NOOBJECT || ttype(obj) != TAG_USERDATA)
- return NULL;
- else return tsvalue(obj)->u.d.value;
-}
-
-lua_CFunction lua_getcfunction (lua_State *L, lua_Object obj) {
- if (!lua_iscfunction(L, obj))
- return NULL;
- else return clvalue(obj)->f.c;
-}
+/*
+** push functions (C -> stack)
+*/
void lua_pushnil (lua_State *L) {
ttype(L->top) = TAG_NIL;
- incr_top;
+ api_incr_top(L);
}
+
void lua_pushnumber (lua_State *L, double n) {
ttype(L->top) = TAG_NUMBER;
nvalue(L->top) = n;
- incr_top;
+ api_incr_top(L);
}
+
void lua_pushlstring (lua_State *L, const char *s, size_t len) {
+ luaC_checkGC(L);
tsvalue(L->top) = luaS_newlstr(L, s, len);
ttype(L->top) = TAG_STRING;
- incr_top;
- luaC_checkGC(L);
+ api_incr_top(L);
}
+
void lua_pushstring (lua_State *L, const char *s) {
if (s == NULL)
lua_pushnil(L);
@@ -276,48 +177,154 @@ void lua_pushstring (lua_State *L, const char *s) {
lua_pushlstring(L, s, strlen(s));
}
+
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
- if (fn == NULL)
- lua_error(L, "Lua API error - attempt to push a NULL Cfunction");
- luaA_checkCargs(L, n);
- luaV_Cclosure(L, fn, n);
luaC_checkGC(L);
+ luaV_Cclosure(L, fn, n);
}
+
void lua_pushusertag (lua_State *L, void *u, int tag) { /* ORDER LUA_T */
+ luaC_checkGC(L);
if (tag != LUA_ANYTAG && tag != TAG_USERDATA && tag < NUM_TAGS)
luaL_verror(L, "invalid tag for a userdata (%d)", tag);
tsvalue(L->top) = luaS_createudata(L, u, tag);
ttype(L->top) = TAG_USERDATA;
- incr_top;
- luaC_checkGC(L);
+ api_incr_top(L);
}
-void luaA_pushobject (lua_State *L, const TObject *o) {
- *L->top = *o;
- incr_top;
+
+
+/*
+** get functions (Lua -> stack)
+*/
+
+
+void lua_getglobal (lua_State *L, const char *name) {
+ luaV_getglobal(L, luaS_new(L, name), L->top++);
}
-void lua_pushobject (lua_State *L, lua_Object o) {
- if (o == LUA_NOOBJECT)
- lua_error(L, "Lua API error - attempt to push a NOOBJECT");
- *L->top = *o;
- incr_top;
+
+void lua_gettable (lua_State *L) {
+ luaV_gettable(L, L->top--);
}
-int lua_tag (lua_State *L, lua_Object o) {
- if (o == LUA_NOOBJECT)
- return TAG_NIL;
- else if (ttype(o) == TAG_USERDATA) /* to allow `old' tags (deprecated) */
- return tsvalue(o)->u.d.tag;
+void lua_rawget (lua_State *L) {
+ if (ttype(L->top - 2) != TAG_TABLE)
+ lua_error(L, "indexed expression not a table");
+ *(L->top - 2) = *luaH_get(L, hvalue(L->top - 2), L->top - 1);
+ L->top--;
+}
+
+
+void lua_getglobals (lua_State *L) {
+ hvalue(L->top) = L->gt;
+ ttype(L->top) = TAG_TABLE;
+ api_incr_top(L);
+}
+
+
+void lua_gettagmethod (lua_State *L, int tag, const char *event) {
+ *L->top = *luaT_gettagmethod(L, tag, event);
+ api_incr_top(L);
+}
+
+
+int lua_getref (lua_State *L, int ref) {
+ if (ref == LUA_REFNIL)
+ ttype(L->top) = TAG_NIL;
+ else if (0 <= ref && ref < L->refSize &&
+ (L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD))
+ *L->top = L->refArray[ref].o;
else
- return luaT_effectivetag(L, o);
+ return 0;
+ api_incr_top(L);
+ return 1;
+}
+
+
+void lua_newtable (lua_State *L) {
+ luaC_checkGC(L);
+ hvalue(L->top) = luaH_new(L, 0);
+ ttype(L->top) = TAG_TABLE;
+ api_incr_top(L);
}
+
+/*
+** set functions (stack -> Lua)
+*/
+
+
+void lua_setglobal (lua_State *L, const char *name) {
+ luaV_setglobal(L, luaS_new(L, name), L->top--);
+}
+
+
+void lua_settable (lua_State *L) {
+ StkId top = L->top;
+ luaV_settable(L, top-3, top);
+ L->top = top-3; /* pop table, index, and value */
+}
+
+
+void lua_rawset (lua_State *L) {
+ if (ttype(L->top-3) != TAG_TABLE)
+ lua_error(L, "indexed expression not a table");
+ *luaH_set(L, hvalue(L->top-3), L->top-2) = *(L->top-1);
+ L->top -= 3;
+}
+
+
+void lua_setglobals (lua_State *L) {
+ TObject *newtable = --L->top;
+ if (ttype(newtable) != TAG_TABLE)
+ lua_error(L, "Lua API error - invalid value for global table");
+ L->gt = hvalue(newtable);
+}
+
+
+void lua_settagmethod (lua_State *L, int tag, const char *event) {
+ TObject *method = L->top - 1;
+ if (ttype(method) != TAG_NIL &&
+ ttype(method) != TAG_CCLOSURE &&
+ ttype(method) != TAG_LCLOSURE)
+ lua_error(L, "Lua API error - tag method must be a function or nil");
+ luaT_settagmethod(L, tag, event, method);
+}
+
+
+int lua_ref (lua_State *L, int lock) {
+ int ref;
+ if (ttype(L->top-1) == TAG_NIL)
+ ref = LUA_REFNIL;
+ else {
+ if (L->refFree != NONEXT) { /* is there a free place? */
+ ref = L->refFree;
+ L->refFree = L->refArray[ref].st;
+ }
+ else { /* no more free places */
+ luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref,
+ "reference table overflow", MAX_INT);
+ ref = L->refSize++;
+ }
+ L->refArray[ref].o = *(L->top-1);
+ L->refArray[ref].st = lock ? LOCK : HOLD;
+ }
+ L->top--;
+ return ref;
+}
+
+
+
+/*
+** miscelaneous functions
+*/
+
+
void lua_settag (lua_State *L, int tag) {
- luaA_checkCargs(L, 1);
luaT_realtag(L, tag);
switch (ttype(L->top-1)) {
case TAG_TABLE:
@@ -334,6 +341,17 @@ void lua_settag (lua_State *L, int tag) {
}
+void lua_unref (lua_State *L, int ref) {
+ if (ref >= 0) {
+ if (ref >= L->refSize || L->refArray[ref].st >= 0)
+ lua_error(L, "Lua API error - "
+ "invalid argument for function `lua_unref'");
+ L->refArray[ref].st = L->refFree;
+ L->refFree = ref;
+ }
+}
+
+
int luaA_next (lua_State *L, const Hash *t, int i) {
int tsize = t->size;
for (; i<tsize; i++) {
@@ -348,38 +366,10 @@ int luaA_next (lua_State *L, const Hash *t, int i) {
}
-int lua_next (lua_State *L, lua_Object t, int i) {
+int lua_next (lua_State *L, int index, int i) {
+ const TObject *t = Index(L, index);
if (ttype(t) != TAG_TABLE)
lua_error(L, "Lua API error - object is not a table in `lua_next'");
- i = luaA_next(L, hvalue(t), i);
- top2LC(L, (i==0) ? 0 : 2);
- return i;
-}
-
-
-
-#if LUA_DEPRECATETFUNCS
-
-/*
-** obsolete functions
-*/
-
-lua_Object lua_rawgetglobal (lua_State *L, const char *name) {
- lua_pushglobals(L);
- lua_pushstring(L, name);
- return lua_rawget(L);
-}
-
-
-void lua_rawsetglobal (lua_State *L, const char *name) {
- lua_Object value;
- lua_beginblock(L);
- value = lua_pop(L);
- lua_pushglobals(L);
- lua_pushstring(L, name);
- lua_pushobject(L, value);
- lua_rawset(L);
- lua_endblock(L);
+ return luaA_next(L, hvalue(t), i);
}
-#endif
diff --git a/lapi.h b/lapi.h
@@ -1,5 +1,5 @@
/*
-** $Id: lapi.h,v 1.17 2000/05/08 19:32:53 roberto Exp roberto $
+** $Id: lapi.h,v 1.18 2000/05/08 20:49:05 roberto Exp roberto $
** Auxiliary functions from Lua API
** See Copyright Notice in lua.h
*/
@@ -11,9 +11,8 @@
#include "lobject.h"
-void luaA_checkCargs (lua_State *L, int nargs);
+TObject *luaA_index (lua_State *L, int index);
void luaA_pushobject (lua_State *L, const TObject *o);
int luaA_next (lua_State *L, const Hash *t, int i);
-lua_Object luaA_putluaObject (lua_State *L, const TObject *o);
#endif
diff --git a/lauxlib.c b/lauxlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lauxlib.c,v 1.29 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: lauxlib.c,v 1.30 2000/08/09 19:16:57 roberto Exp roberto $
** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h
*/
@@ -41,72 +41,61 @@ void luaL_argerror (lua_State *L, int narg, const char *extramsg) {
}
-static void type_error (lua_State *L, int narg, const char *type_name,
- lua_Object o) {
+static void type_error (lua_State *L, int narg, const char *type_name) {
char buff[100];
- const char *otype = (o == LUA_NOOBJECT) ? "no value" : lua_type(L, o);
- sprintf(buff, "%.10s expected, got %.10s", type_name, otype);
+ const char *rt = lua_type(L, narg);
+ if (*rt == 'N') rt = "no value";
+ sprintf(buff, "%.10s expected, got %.10s", type_name, rt);
luaL_argerror(L, narg, buff);
}
-static const char *checkstr (lua_State *L, lua_Object o, int narg,
- size_t *len) {
- const char *s = lua_getstring(L, o);
- if (!s) type_error(L, narg, "string", o);
- if (len) *len = lua_strlen(L, o);
+/*
+** use the 3rd letter of type names for testing:
+** nuMber, niL, stRing, fuNction, usErdata, taBle, anY
+*/
+void luaL_checktype(lua_State *L, int narg, const char *tname) {
+ const char *rt = lua_type(L, narg);
+ if (!(*rt != 'N' && (tname[2] == 'y' || tname[2] == rt[2])))
+ type_error(L, narg, tname);
+}
+
+
+static const char *checkstr (lua_State *L, int narg, size_t *len) {
+ const char *s = lua_tostring(L, narg);
+ if (!s) type_error(L, narg, "string");
+ if (len) *len = lua_strlen(L, narg);
return s;
}
const char *luaL_check_lstr (lua_State *L, int narg, size_t *len) {
- return checkstr(L, lua_getparam(L, narg), narg, len);
+ return checkstr(L, narg, len);
}
const char *luaL_opt_lstr (lua_State *L, int narg, const char *def,
size_t *len) {
- lua_Object o = lua_getparam(L, narg);
- if (o == LUA_NOOBJECT) {
+ if (lua_isnull(L, narg)) {
if (len) *len = def ? strlen(def) : 0;
return def;
}
- else return checkstr(L, o, narg, len);
+ else return checkstr(L, narg, len);
}
double luaL_check_number (lua_State *L, int narg) {
- lua_Object o = lua_getparam(L, narg);
- if (!lua_isnumber(L, o)) type_error(L, narg, "number", o);
- return lua_getnumber(L, o);
+ if (!lua_isnumber(L, narg)) type_error(L, narg, "number");
+ return lua_tonumber(L, narg);
}
double luaL_opt_number (lua_State *L, int narg, double def) {
- lua_Object o = lua_getparam(L, narg);
- if (o == LUA_NOOBJECT) return def;
+ if (lua_isnull(L, narg)) return def;
else {
- if (!lua_isnumber(L, o)) type_error(L, narg, "number", o);
- return lua_getnumber(L, o);
+ if (!lua_isnumber(L, narg)) type_error(L, narg, "number");
+ return lua_tonumber(L, narg);
}
}
-lua_Object luaL_tablearg (lua_State *L, int narg) {
- lua_Object o = lua_getparam(L, narg);
- if (!lua_istable(L, o)) type_error(L, narg, "table", o);
- return o;
-}
-
-lua_Object luaL_functionarg (lua_State *L, int narg) {
- lua_Object o = lua_getparam(L, narg);
- if (!lua_isfunction(L, o)) type_error(L, narg, "function", o);
- return o;
-}
-
-lua_Object luaL_nonnullarg (lua_State *L, int narg) {
- lua_Object o = lua_getparam(L, narg);
- luaL_arg_check(L, o != LUA_NOOBJECT, narg, "value expected");
- return o;
-}
-
void luaL_openlib (lua_State *L, const struct luaL_reg *l, int n) {
int i;
for (i=0; i<n; i++)
@@ -150,3 +139,4 @@ void luaL_filesource (char *out, const char *filename, int len) {
if (filename == NULL) filename = "(stdin)";
sprintf(out, "@%.*s", len-2, filename); /* -2 for '@' and '\0' */
}
+
diff --git a/lauxlib.h b/lauxlib.h
@@ -1,5 +1,5 @@
/*
-** $Id: lauxlib.h,v 1.18 2000/05/24 13:54:49 roberto Exp roberto $
+** $Id: lauxlib.h,v 1.19 2000/08/09 19:16:57 roberto Exp roberto $
** Auxiliary functions for building Lua libraries
** See Copyright Notice in lua.h
*/
@@ -27,14 +27,15 @@ const char *luaL_opt_lstr (lua_State *L, int numArg, const char *def,
size_t *len);
double luaL_check_number (lua_State *L, int numArg);
double luaL_opt_number (lua_State *L, int numArg, double def);
-lua_Object luaL_functionarg (lua_State *L, int arg);
-lua_Object luaL_tablearg (lua_State *L, int arg);
-lua_Object luaL_nonnullarg (lua_State *L, int numArg);
+
+void luaL_checktype(lua_State *L, int narg, const char *tname);
+
void luaL_verror (lua_State *L, const char *fmt, ...);
int luaL_findstring (const char *name, const char *const list[]);
void luaL_chunkid (char *out, const char *source, int len);
void luaL_filesource (char *out, const char *filename, int len);
+
char *luaL_openspace (lua_State *L, size_t size);
void luaL_resetbuffer (lua_State *L);
void luaL_addchar (lua_State *L, int c);
@@ -91,9 +92,6 @@ char *luaL_buffer (lua_State *L);
(luaL_opt_lstr)(lua_state,numArg,def,len)
#define luaL_check_number(numArg) (luaL_check_number)(lua_state,numArg)
#define luaL_opt_number(numArg,def) (luaL_opt_number)(lua_state,numArg,def)
-#define luaL_functionarg(arg) (luaL_functionarg)(lua_state,arg)
-#define luaL_tablearg(arg) (luaL_tablearg)(lua_state,arg)
-#define luaL_nonnullarg(numArg) (luaL_nonnullarg)(lua_state,numArg)
#define luaL_openspace(size) (luaL_openspace)(lua_state,size)
#define luaL_resetbuffer() (luaL_resetbuffer)(lua_state)
#define luaL_addchar(c) (luaL_addchar)(lua_state,c)
diff --git a/lbuiltin.c b/lbuiltin.c
@@ -1,5 +1,5 @@
/*
-** $Id: lbuiltin.c,v 1.120 2000/08/14 19:10:14 roberto Exp roberto $
+** $Id: lbuiltin.c,v 1.121 2000/08/15 18:28:48 roberto Exp roberto $
** Built-in functions
** See Copyright Notice in lua.h
*/
@@ -50,7 +50,6 @@ void luaB_opentests (lua_State *L);
** =======================================================
*/
-
static Number getsize (const Hash *h) {
Number max = 0;
int i = h->size;
@@ -73,7 +72,8 @@ static Number getnarg (lua_State *L, const Hash *a) {
static Hash *gettable (lua_State *L, int arg) {
- return hvalue(luaL_tablearg(L, arg));
+ luaL_checktype(L, arg, "table");
+ return hvalue(luaA_index(L, arg));
}
/* }====================================================== */
@@ -90,8 +90,9 @@ static Hash *gettable (lua_State *L, int arg) {
** If your system does not support `stderr', redefine this function, or
** redefine _ERRORMESSAGE so that it won't need _ALERT.
*/
-void luaB__ALERT (lua_State *L) {
+int luaB__ALERT (lua_State *L) {
fputs(luaL_check_string(L, 1), stderr);
+ return 0;
}
@@ -99,18 +100,19 @@ void luaB__ALERT (lua_State *L) {
** Standard implementation of _ERRORMESSAGE.
** The library `liolib' redefines _ERRORMESSAGE for better error information.
*/
-void luaB__ERRORMESSAGE (lua_State *L) {
- lua_Object al;
- lua_pushglobals(L);
+int luaB__ERRORMESSAGE (lua_State *L) {
+ lua_getglobals(L);
lua_pushstring(L, LUA_ALERT);
- al = lua_rawget(L);
- if (lua_isfunction(L, al)) { /* avoid error loop if _ALERT is not defined */
+ lua_rawget(L);
+ if (lua_isfunction(L, -1)) { /* avoid error loop if _ALERT is not defined */
const char *s = luaL_check_string(L, 1);
char *buff = luaL_openspace(L, strlen(s)+sizeof("error: \n"));
strcpy(buff, "error: "); strcat(buff, s); strcat(buff, "\n");
+ lua_pushobject(L, -1); /* function to be called */
lua_pushstring(L, buff);
- lua_callfunction(L, al);
+ lua_call(L, 1, 0);
}
+ return 0;
}
@@ -120,36 +122,35 @@ void luaB__ERRORMESSAGE (lua_State *L) {
** model but changing `fputs' to put the strings at a proper place
** (a console window or a log file, for instance).
*/
-void luaB_print (lua_State *L) {
- lua_Object args[MAXPRINT];
- lua_Object obj;
- int n = 0;
+int luaB_print (lua_State *L) {
+ int n = lua_gettop(L); /* number of arguments */
int i;
- while ((obj = lua_getparam(L, n+1)) != LUA_NOOBJECT) {
- luaL_arg_check(L, n < MAXPRINT, n+1, "too many arguments");
- args[n++] = obj;
- }
- for (i=0; i<n; i++) {
- lua_pushobject(L, args[i]);
- if (lua_call(L, "tostring"))
+ lua_getglobal(L, "tostring");
+ for (i=1; i<=n; i++) {
+ const char *s;
+ lua_pushobject(L, -1); /* function to be called */
+ lua_pushobject(L, i);
+ if (lua_call(L, 1, 1) != 0)
lua_error(L, "error in `tostring' called by `print'");
- obj = lua_getresult(L, 1);
- if (!lua_isstring(L, obj))
+ s = lua_tostring(L, -1); /* get result */
+ if (s == NULL)
lua_error(L, "`tostring' must return a string to `print'");
- if (i>0) fputs("\t", stdout);
- fputs(lua_getstring(L, obj), stdout);
+ if (i>1) fputs("\t", stdout);
+ fputs(s, stdout);
+ lua_settop(L, -1); /* pop result */
}
fputs("\n", stdout);
+ return 0;
}
-void luaB_tonumber (lua_State *L) {
+int luaB_tonumber (lua_State *L) {
int base = luaL_opt_int(L, 2, 10);
if (base == 10) { /* standard conversion */
- lua_Object o = luaL_nonnullarg(L, 1);
- if (lua_isnumber(L, o)) {
- lua_pushnumber(L, lua_getnumber(L, o));
- return;
+ luaL_checktype(L, 1, "any");
+ if (lua_isnumber(L, 1)) {
+ lua_pushnumber(L, lua_tonumber(L, 1));
+ return 1;
}
}
else {
@@ -162,94 +163,108 @@ void luaB_tonumber (lua_State *L) {
while (isspace((unsigned char)*s2)) s2++; /* skip trailing spaces */
if (*s2 == '\0') { /* no invalid trailing characters? */
lua_pushnumber(L, n);
- return;
+ return 1;
}
}
}
lua_pushnil(L); /* else not a number */
+ return 1;
}
-void luaB_error (lua_State *L) {
+int luaB_error (lua_State *L) {
lua_error(L, luaL_opt_string(L, 1, NULL));
+ return 0; /* to avoid errors */
}
-void luaB_setglobal (lua_State *L) {
- const char *name = luaL_check_string(L, 1);
- lua_Object value = luaL_nonnullarg(L, 2);
- lua_pushobject(L, value);
- lua_setglobal(L, name);
+int luaB_setglobal (lua_State *L) {
+ luaL_checktype(L, 2, "any");
+ lua_setglobal(L, luaL_check_string(L, 1));
+ return 0;
}
-void luaB_getglobal (lua_State *L) {
- lua_pushobject(L, lua_getglobal(L, luaL_check_string(L, 1)));
+int luaB_getglobal (lua_State *L) {
+ lua_getglobal(L, luaL_check_string(L, 1));
+ return 1;
}
-void luaB_tag (lua_State *L) {
- lua_pushnumber(L, lua_tag(L, luaL_nonnullarg(L, 1)));
+int luaB_tag (lua_State *L) {
+ luaL_checktype(L, 1, "any");
+ lua_pushnumber(L, lua_tag(L, 1));
+ return 1;
}
-void luaB_settag (lua_State *L) {
- lua_Object o = luaL_tablearg(L, 1);
- lua_pushobject(L, o);
+int luaB_settag (lua_State *L) {
+ luaL_checktype(L, 1, "table");
+ lua_pushobject(L, 1); /* push table */
lua_settag(L, luaL_check_int(L, 2));
- lua_pushobject(L, o); /* return first argument */
+ lua_pushobject(L, 1); /* return first argument */
+ return 1;
}
-void luaB_newtag (lua_State *L) {
+int luaB_newtag (lua_State *L) {
lua_pushnumber(L, lua_newtag(L));
+ return 1;
}
-void luaB_copytagmethods (lua_State *L) {
+int luaB_copytagmethods (lua_State *L) {
lua_pushnumber(L, lua_copytagmethods(L, luaL_check_int(L, 1),
luaL_check_int(L, 2)));
+ return 1;
}
-void luaB_globals (lua_State *L) {
- lua_pushglobals(L);
- if (lua_getparam(L, 1) != LUA_NOOBJECT)
- lua_setglobals(L, luaL_tablearg(L, 1));
+int luaB_globals (lua_State *L) {
+ lua_getglobals(L); /* value to be returned */
+ if (!lua_isnull(L, 1)) {
+ luaL_checktype(L, 1, "table");
+ lua_pushobject(L, 1); /* new table of globals */
+ lua_setglobals(L);
+ }
+ return 1;
}
-void luaB_rawget (lua_State *L) {
- lua_pushobject(L, luaL_nonnullarg(L, 1));
- lua_pushobject(L, luaL_nonnullarg(L, 2));
- lua_pushobject(L, lua_rawget(L));
+int luaB_rawget (lua_State *L) {
+ luaL_checktype(L, 1, "table");
+ luaL_checktype(L, 2, "any");
+ lua_rawget(L);
+ return 1;
}
-void luaB_rawset (lua_State *L) {
- lua_pushobject(L, luaL_nonnullarg(L, 1));
- lua_pushobject(L, luaL_nonnullarg(L, 2));
- lua_pushobject(L, luaL_nonnullarg(L, 3));
+int luaB_rawset (lua_State *L) {
+ luaL_checktype(L, 1, "table");
+ luaL_checktype(L, 2, "any");
+ luaL_checktype(L, 3, "any");
lua_rawset(L);
+ return 1;
}
-void luaB_settagmethod (lua_State *L) {
- int tag = luaL_check_int(L, 1);
+int luaB_settagmethod (lua_State *L) {
+ int tag = (int)luaL_check_int(L, 1);
const char *event = luaL_check_string(L, 2);
- lua_Object nf = luaL_nonnullarg(L, 3);
- luaL_arg_check(L, lua_isnil(L, nf) || lua_isfunction(L, nf), 3,
+ luaL_arg_check(L, lua_isfunction(L, 3) || lua_isnil(L, 3), 3,
"function or nil expected");
if (strcmp(event, "gc") == 0 && tag != TAG_NIL)
lua_error(L, "deprecated use: cannot set the `gc' tag method from Lua");
- lua_pushobject(L, nf);
- lua_pushobject(L, lua_settagmethod(L, tag, event));
+ lua_settagmethod(L, tag, event);
+ return 1;
}
-void luaB_gettagmethod (lua_State *L) {
- lua_pushobject(L, lua_gettagmethod(L, luaL_check_int(L, 1),
- luaL_check_string(L, 2)));
+int luaB_gettagmethod (lua_State *L) {
+ lua_gettagmethod(L, luaL_check_int(L, 1), luaL_check_string(L, 2));
+ return 1;
}
-void luaB_collectgarbage (lua_State *L) {
+int luaB_collectgarbage (lua_State *L) {
lua_pushnumber(L, lua_collectgarbage(L, luaL_opt_int(L, 1, 0)));
+ return 1;
}
-void luaB_type (lua_State *L) {
- lua_Object o = luaL_nonnullarg(L, 1);
- lua_pushstring(L, lua_type(L, o));
+int luaB_type (lua_State *L) {
+ luaL_checktype(L, 1, "any");
+ lua_pushstring(L, lua_type(L, 1));
+ return 1;
}
/* }====================================================== */
@@ -263,99 +278,115 @@ void luaB_type (lua_State *L) {
*/
-static void passresults (lua_State *L) {
- L->Cstack.base = L->Cstack.lua2C; /* position of first result */
- if (L->Cstack.num == 0)
- lua_pushuserdata(L, NULL); /* at least one result to signal no errors */
+static int passresults (lua_State *L, int status, int oldtop) {
+ if (status == 0) {
+ int nresults = lua_gettop(L) - oldtop;
+ if (nresults > 0)
+ return nresults; /* results are already on the stack */
+ else {
+ lua_pushuserdata(L, NULL); /* at least one result to signal no errors */
+ return 1;
+ }
+ }
+ else { /* error */
+ lua_pushnil(L);
+ lua_pushnumber(L, status); /* error code */
+ return 2;
+ }
}
-void luaB_dostring (lua_State *L) {
+int luaB_dostring (lua_State *L) {
+ int oldtop = lua_gettop(L);
size_t l;
const char *s = luaL_check_lstr(L, 1, &l);
if (*s == ID_CHUNK)
lua_error(L, "`dostring' cannot run pre-compiled code");
- if (lua_dobuffer(L, s, l, luaL_opt_string(L, 2, s)) == 0)
- passresults(L);
- else
- lua_pushnil(L);
+ return passresults(L, lua_dobuffer(L, s, l, luaL_opt_string(L, 2, s)), oldtop);
}
-void luaB_dofile (lua_State *L) {
+int luaB_dofile (lua_State *L) {
+ int oldtop = lua_gettop(L);
const char *fname = luaL_opt_string(L, 1, NULL);
- if (lua_dofile(L, fname) == 0)
- passresults(L);
- else
- lua_pushnil(L);
+ return passresults(L, lua_dofile(L, fname), oldtop);
}
-void luaB_call (lua_State *L) {
- lua_Object f = luaL_nonnullarg(L, 1);
+int luaB_call (lua_State *L) {
+ int oldtop;
const Hash *arg = gettable(L, 2);
const char *options = luaL_opt_string(L, 3, "");
- lua_Object err = lua_getparam(L, 4);
- int narg = (int)getnarg(L, arg);
+ int err = 0; /* index of old error method */
+ int n = (int)getnarg(L, arg);
int i, status;
- if (err != LUA_NOOBJECT) { /* set new error method */
- lua_Object oldem = lua_getglobal(L, LUA_ERRORMESSAGE);
- lua_pushobject(L, err);
+ if (!lua_isnull(L, 4)) { /* set new error method */
+ lua_getglobal(L, LUA_ERRORMESSAGE);
+ err = lua_gettop(L); /* get index */
+ lua_pushobject(L, 4);
lua_setglobal(L, LUA_ERRORMESSAGE);
- err = oldem;
}
+ oldtop = lua_gettop(L); /* top before function-call preparation */
+ /* push function */
+ lua_pushobject(L, 1);
/* push arg[1...n] */
- luaD_checkstack(L, narg);
- for (i=0; i<narg; i++)
+ luaD_checkstack(L, n);
+ for (i=0; i<n; i++)
*(L->top++) = *luaH_getnum(arg, i+1);
- status = lua_callfunction(L, f);
- if (err != LUA_NOOBJECT) { /* restore old error method */
+ status = lua_call(L, n, LUA_MULTRET);
+ n = lua_gettop(L) - oldtop; /* number of results */
+ if (err != 0) { /* restore old error method */
lua_pushobject(L, err);
lua_setglobal(L, LUA_ERRORMESSAGE);
}
if (status != 0) { /* error in call? */
- if (strchr(options, 'x')) {
- lua_pushnil(L);
- return; /* return nil to signal the error */
- }
+ 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;
}
else { /* no errors */
if (strchr(options, 'p')) { /* pack results? */
- luaV_pack(L, L->Cstack.lua2C, L->Cstack.num, L->top);
+ luaV_pack(L, luaA_index(L, oldtop+1), n, L->top);
incr_top;
+ return 1; /* only table is returned */
}
else
- L->Cstack.base = L->Cstack.lua2C; /* position of first result */
+ return n; /* results are already on the stack */
}
}
-void luaB_next (lua_State *L) {
+int luaB_next (lua_State *L) {
const Hash *a = gettable(L, 1);
- lua_Object k = lua_getparam(L, 2);
int i; /* `luaA_next' gets first element after `i' */
- if (k == LUA_NOOBJECT || ttype(k) == TAG_NIL)
+ if (lua_isnull(L, 2) || lua_isnil(L, 2)) /* no index or nil index? */
i = 0; /* get first */
else {
- i = luaH_pos(L, a, k)+1;
+ i = luaH_pos(L, a, luaA_index(L, 2))+1;
luaL_arg_check(L, i != 0, 2, "key not found");
}
- if (luaA_next(L, a, i) == 0)
+ if (luaA_next(L, a, i) != 0)
+ return 2; /* `luaA_next' left them on the stack */
+ else {
lua_pushnil(L);
+ return 1;
+ }
}
-void luaB_tostring (lua_State *L) {
- lua_Object o = luaL_nonnullarg(L, 1);
+int luaB_tostring (lua_State *L) {
char buff[64];
+ const TObject *o;
+ luaL_checktype(L, 1, "any");
+ o = luaA_index(L, 1);
switch (ttype(o)) {
case TAG_NUMBER:
- lua_pushstring(L, lua_getstring(L, o));
- return;
+ lua_pushstring(L, lua_tostring(L, 1));
+ return 1;
case TAG_STRING:
- lua_pushobject(L, o);
- return;
+ lua_pushobject(L, 1);
+ return 1;
case TAG_TABLE:
sprintf(buff, "table: %p", hvalue(o));
break;
@@ -368,11 +399,12 @@ void luaB_tostring (lua_State *L) {
break;
case TAG_NIL:
lua_pushstring(L, "nil");
- return;
+ return 1;
default:
LUA_INTERNALERROR("invalid type");
}
lua_pushstring(L, buff);
+ return 1;
}
/* }====================================================== */
@@ -389,15 +421,17 @@ void luaB_tostring (lua_State *L) {
** =======================================================
*/
-void luaB_assert (lua_State *L) {
- lua_Object p = luaL_nonnullarg(L, 1);
- if (lua_isnil(L, p))
+int luaB_assert (lua_State *L) {
+ luaL_checktype(L, 1, "any");
+ if (lua_isnil(L, 1))
luaL_verror(L, "assertion failed! %.90s", luaL_opt_string(L, 2, ""));
+ return 0;
}
-void luaB_getn (lua_State *L) {
+int luaB_getn (lua_State *L) {
lua_pushnumber(L, getnarg(L, gettable(L, 1)));
+ return 1;
}
@@ -408,72 +442,72 @@ static void t_move (lua_State *L, Hash *t, int from, int to) {
}
-void luaB_tinsert (lua_State *L) {
+int luaB_tinsert (lua_State *L) {
Hash *a = gettable(L, 1);
- lua_Object v = lua_getparam(L, 3);
int n = (int)getnarg(L, a);
+ int v = lua_gettop(L); /* last argument: to be inserted */
int pos;
- if (v != LUA_NOOBJECT)
- pos = luaL_check_int(L, 2);
- else { /* called with only 2 arguments */
- v = luaL_nonnullarg(L, 2);
+ if (v == 2) /* called with only 2 arguments */
pos = n+1;
- }
+ else
+ pos = luaL_check_int(L, 2); /* 2nd argument is the position */
luaH_setstrnum(L, a, luaS_new(L, "n"), n+1); /* a.n = n+1 */
for (; n>=pos; n--)
t_move(L, a, n, n+1); /* a[n+1] = a[n] */
- *luaH_setint(L, a, pos) = *v; /* a[pos] = v */
+ *luaH_setint(L, a, pos) = *luaA_index(L, v); /* a[pos] = v */
+ return 0;
}
-void luaB_tremove (lua_State *L) {
+int luaB_tremove (lua_State *L) {
Hash *a = gettable(L, 1);
int n = (int)getnarg(L, a);
int pos = luaL_opt_int(L, 2, n);
- if (n <= 0) return; /* table is "empty" */
+ if (n <= 0) return 0; /* table is "empty" */
luaA_pushobject(L, luaH_getnum(a, pos)); /* result = a[pos] */
for ( ;pos<n; pos++)
t_move(L, a, pos+1, pos); /* a[pos] = a[pos+1] */
luaH_setstrnum(L, a, luaS_new(L, "n"), n-1); /* a.n = n-1 */
ttype(luaH_setint(L, a, n)) = TAG_NIL; /* a[n] = nil */
+ return 1;
}
-static void luaB_foreachi (lua_State *L) {
+static int luaB_foreachi (lua_State *L) {
const Hash *t = gettable(L, 1);
int n = (int)getnarg(L, t);
int i;
- lua_Object f = luaL_functionarg(L, 2);
- luaD_checkstack(L, 3); /* for f, key, and val */
+ luaL_checktype(L, 2, "function");
for (i=1; i<=n; i++) {
- *(L->top++) = *f;
+ lua_pushobject(L, 2);
ttype(L->top) = TAG_NUMBER; nvalue(L->top++) = i;
*(L->top++) = *luaH_getnum(t, i);
luaD_call(L, L->top-3, 1);
if (ttype(L->top-1) != TAG_NIL)
- return;
+ return 1;
L->top--; /* remove nil result */
}
+ return 0;
}
-static void luaB_foreach (lua_State *L) {
+static int luaB_foreach (lua_State *L) {
const Hash *a = gettable(L, 1);
- lua_Object f = luaL_functionarg(L, 2);
int i;
- luaD_checkstack(L, 3); /* for f, key, and val */
+ luaL_checktype(L, 2, "function");
for (i=0; i<a->size; i++) {
const Node *nd = &(a->node[i]);
if (ttype(val(nd)) != TAG_NIL) {
- *(L->top++) = *f;
+ lua_pushobject(L, 2);
*(L->top++) = *key(nd);
*(L->top++) = *val(nd);
luaD_call(L, L->top-3, 1);
if (ttype(L->top-1) != TAG_NIL)
- return;
+ return 1;
L->top--; /* remove result */
}
}
+ return 0;
}
@@ -492,10 +526,10 @@ static void swap (lua_State *L, Hash *a, int i, int j) {
*luaH_setint(L, a, j) = temp;
}
-static int sort_comp (lua_State *L, lua_Object f, const TObject *a,
- const TObject *b) {
+static int sort_comp (lua_State *L, const TObject *f, const TObject *a,
+ const TObject *b) {
/* WARNING: the caller (auxsort) must ensure stack space */
- if (f != LUA_NOOBJECT) {
+ if (f != NULL) {
*(L->top) = *f;
*(L->top+1) = *a;
*(L->top+2) = *b;
@@ -508,7 +542,7 @@ static int sort_comp (lua_State *L, lua_Object f, const TObject *a,
return luaV_lessthan(L, a, b, L->top);
}
-static void auxsort (lua_State *L, Hash *a, int l, int u, lua_Object f) {
+static void auxsort (lua_State *L, Hash *a, int l, int u, const TObject *f) {
StkId P = L->top++; /* temporary place for pivot */
ttype(P) = TAG_NIL;
while (l < u) { /* for tail recursion */
@@ -552,14 +586,16 @@ static void auxsort (lua_State *L, Hash *a, int l, int u, lua_Object f) {
L->top--; /* remove pivot from stack */
}
-void luaB_sort (lua_State *L) {
+int luaB_sort (lua_State *L) {
Hash *a = gettable(L, 1);
int n = (int)getnarg(L, a);
- lua_Object func = lua_getparam(L, 2);
- luaL_arg_check(L, func == LUA_NOOBJECT || lua_isfunction(L, func), 2,
- "function expected");
- luaD_checkstack(L, 4); /* for pivot, f, a, b (sort_comp) */
+ const TObject *func = NULL;
+ if (!lua_isnull(L, 2)) { /* is there a 2nd argument? */
+ luaL_checktype(L, 2, "function");
+ func = luaA_index(L, 2);
+ }
auxsort(L, a, 1, n, func);
+ return 0;
}
/* }====================================================== */
@@ -615,8 +651,9 @@ static void deprecated_funcs (lua_State *L) {
/*
** gives an explicit error in any attempt to call a deprecated function
*/
-static void deprecated_func (lua_State *L) {
+static int deprecated_func (lua_State *L) {
luaL_verror(L, "function `%.20s' is deprecated", luaL_check_string(L, 1));
+ return 0; /* to avoid warnings */
}
diff --git a/lbuiltin.h b/lbuiltin.h
@@ -1,5 +1,5 @@
/*
-** $Id: lbuiltin.h,v 1.8 2000/05/08 19:32:53 roberto Exp roberto $
+** $Id: lbuiltin.h,v 1.9 2000/05/26 19:17:57 roberto Exp roberto $
** Built-in functions
** See Copyright Notice in lua.h
*/
@@ -9,34 +9,34 @@
#include "lua.h"
-void luaB__ALERT (lua_State *L);
-void luaB__ERRORMESSAGE (lua_State *L);
-void luaB_assert (lua_State *L);
-void luaB_call (lua_State *L);
-void luaB_collectgarbage (lua_State *L);
-void luaB_copytagmethods (lua_State *L);
-void luaB_dofile (lua_State *L);
-void luaB_dostring (lua_State *L);
-void luaB_error (lua_State *L);
-void luaB_getglobal (lua_State *L);
-void luaB_getn (lua_State *L);
-void luaB_gettagmethod (lua_State *L);
-void luaB_globals (lua_State *L);
-void luaB_newtag (lua_State *L);
-void luaB_next (lua_State *L);
-void luaB_print (lua_State *L);
-void luaB_rawget (lua_State *L);
-void luaB_rawset (lua_State *L);
-void luaB_setglobal (lua_State *L);
-void luaB_settag (lua_State *L);
-void luaB_settagmethod (lua_State *L);
-void luaB_sort (lua_State *L);
-void luaB_tag (lua_State *L);
-void luaB_tinsert (lua_State *L);
-void luaB_tonumber (lua_State *L);
-void luaB_tostring (lua_State *L);
-void luaB_tremove (lua_State *L);
-void luaB_type (lua_State *L);
+int luaB__ALERT (lua_State *L);
+int luaB__ERRORMESSAGE (lua_State *L);
+int luaB_assert (lua_State *L);
+int luaB_call (lua_State *L);
+int luaB_collectgarbage (lua_State *L);
+int luaB_copytagmethods (lua_State *L);
+int luaB_dofile (lua_State *L);
+int luaB_dostring (lua_State *L);
+int luaB_error (lua_State *L);
+int luaB_getglobal (lua_State *L);
+int luaB_getn (lua_State *L);
+int luaB_gettagmethod (lua_State *L);
+int luaB_globals (lua_State *L);
+int luaB_newtag (lua_State *L);
+int luaB_next (lua_State *L);
+int luaB_print (lua_State *L);
+int luaB_rawget (lua_State *L);
+int luaB_rawset (lua_State *L);
+int luaB_setglobal (lua_State *L);
+int luaB_settag (lua_State *L);
+int luaB_settagmethod (lua_State *L);
+int luaB_sort (lua_State *L);
+int luaB_tag (lua_State *L);
+int luaB_tinsert (lua_State *L);
+int luaB_tonumber (lua_State *L);
+int luaB_tostring (lua_State *L);
+int luaB_tremove (lua_State *L);
+int luaB_type (lua_State *L);
void luaB_predefine (lua_State *L);
diff --git a/ldblib.c b/ldblib.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldblib.c,v 1.17 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: ldblib.c,v 1.18 2000/08/09 19:16:57 roberto Exp roberto $
** Interface from Lua to its debug API
** See Copyright Notice in lua.h
*/
@@ -17,102 +17,96 @@
-static void settabss (lua_State *L, lua_Object t, const char *i, const char *v) {
- lua_pushobject(L, t);
+static void settabss (lua_State *L, const char *i, const char *v) {
+ lua_pushobject(L, -1);
lua_pushstring(L, i);
lua_pushstring(L, v);
lua_settable(L);
}
-static void settabsi (lua_State *L, lua_Object t, const char *i, int v) {
- lua_pushobject(L, t);
+static void settabsi (lua_State *L, const char *i, int v) {
+ lua_pushobject(L, -1);
lua_pushstring(L, i);
lua_pushnumber(L, v);
lua_settable(L);
}
-static void settabso (lua_State *L, lua_Object t, const char *i, lua_Object v) {
- lua_pushobject(L, t);
- lua_pushstring(L, i);
- lua_pushobject(L, v);
- lua_settable(L);
-}
-
-
-static void getinfo (lua_State *L) {
+static int getinfo (lua_State *L) {
lua_Debug ar;
- lua_Object res;
- lua_Object func = lua_getparam(L, 1);
const char *options = luaL_opt_string(L, 2, "flnSu");
char buff[20];
- if (lua_isnumber(L, func)) {
- if (!lua_getstack(L, (int)lua_getnumber(L, func), &ar)) {
+ if (lua_isnumber(L, 1)) {
+ if (!lua_getstack(L, (int)lua_tonumber(L, 1), &ar)) {
lua_pushnil(L); /* level out of range */
- return;
+ return 1;
}
}
- else if (lua_isfunction(L, func)) {
- ar.func = func;
+ else if (lua_isfunction(L, 1)) {
+ lua_pushobject(L, 1);
sprintf(buff, ">%.10s", options);
options = buff;
}
else
luaL_argerror(L, 1, "function or level expected");
- res = lua_createtable(L);
if (!lua_getinfo(L, options, &ar))
luaL_argerror(L, 2, "invalid option");
+ lua_newtable(L);
for (; *options; options++) {
switch (*options) {
case 'S':
- settabss(L, res, "source", ar.source);
- settabsi(L, res, "linedefined", ar.linedefined);
- settabss(L, res, "what", ar.what);
+ settabss(L, "source", ar.source);
+ settabsi(L, "linedefined", ar.linedefined);
+ settabss(L, "what", ar.what);
break;
case 'l':
- settabsi(L, res, "currentline", ar.currentline);
+ settabsi(L, "currentline", ar.currentline);
break;
case 'u':
- settabsi(L, res, "nups", ar.nups);
+ settabsi(L, "nups", ar.nups);
break;
case 'n':
- settabss(L, res, "name", ar.name);
- settabss(L, res, "namewhat", ar.namewhat);
+ settabss(L, "name", ar.name);
+ settabss(L, "namewhat", ar.namewhat);
break;
case 'f':
- settabso(L, res, "func", ar.func);
+ lua_pushobject(L, -1);
+ lua_pushstring(L, "func");
+ lua_pushobject(L, -4);
+ lua_settable(L);
break;
}
}
- lua_pushobject(L, res);
+ return 1; /* return table */
}
-static void getlocal (lua_State *L) {
+static int getlocal (lua_State *L) {
lua_Debug ar;
- lua_Localvar lvar;
+ const char *name;
if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */
luaL_argerror(L, 1, "level out of range");
- lvar.index = luaL_check_int(L, 2);
- if (lua_getlocal(L, &ar, &lvar)) {
- lua_pushstring(L, lvar.name);
- lua_pushobject(L, lvar.value);
+ name = lua_getlocal(L, &ar, luaL_check_int(L, 2));
+ if (name) {
+ lua_pushstring(L, name);
+ lua_pushobject(L, -2);
+ return 2;
+ }
+ else {
+ lua_pushnil(L);
+ return 1;
}
- else lua_pushnil(L);
}
-static void setlocal (lua_State *L) {
+static int setlocal (lua_State *L) {
lua_Debug ar;
- lua_Localvar lvar;
if (!lua_getstack(L, luaL_check_int(L, 1), &ar)) /* level out of range? */
luaL_argerror(L, 1, "level out of range");
- lvar.index = luaL_check_int(L, 2);
- lvar.value = luaL_nonnullarg(L, 3);
- if (lua_setlocal(L, &ar, &lvar))
- lua_pushstring(L, lvar.name);
- else lua_pushnil(L);
+ luaL_checktype(L, 3, "any");
+ lua_pushstring(L, lua_setlocal(L, &ar, luaL_check_int(L, 2)));
+ return 1;
}
@@ -128,47 +122,47 @@ static int callhook = LUA_NOREF; /* Lua reference to call hook function */
static void linef (lua_State *L, lua_Debug *ar) {
if (linehook != LUA_NOREF) {
+ lua_getref(L, linehook);
lua_pushnumber(L, ar->currentline);
- lua_callfunction(L, lua_getref(L, linehook));
+ lua_call(L, 1, 0);
}
}
static void callf (lua_State *L, lua_Debug *ar) {
if (callhook != LUA_NOREF) {
+ lua_getref(L, callhook);
lua_pushstring(L, ar->event);
- lua_callfunction(L, lua_getref(L, callhook));
+ lua_call(L, 1, 0);
}
}
-static void setcallhook (lua_State *L) {
- lua_Object f = lua_getparam(L, 1);
+static int setcallhook (lua_State *L) {
lua_unref(L, callhook);
- if (f == LUA_NOOBJECT) {
+ if (lua_isnull(L, 1)) {
callhook = LUA_NOREF;
lua_setcallhook(L, NULL);
}
else {
- lua_pushobject(L, f);
callhook = lua_ref(L, 1);
lua_setcallhook(L, callf);
}
+ return 0;
}
-static void setlinehook (lua_State *L) {
- lua_Object f = lua_getparam(L, 1);
+static int setlinehook (lua_State *L) {
lua_unref(L, linehook);
- if (f == LUA_NOOBJECT) {
+ if (lua_isnull(L, 1)) {
linehook = LUA_NOREF;
lua_setlinehook(L, NULL);
}
else {
- lua_pushobject(L, f);
linehook = lua_ref(L, 1);
lua_setlinehook(L, linef);
}
+ return 0;
}
diff --git a/ldebug.c b/ldebug.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldebug.c,v 1.35 2000/08/14 17:59:20 roberto Exp roberto $
+** $Id: ldebug.c,v 1.36 2000/08/15 18:28:48 roberto Exp roberto $
** Debug Interface
** See Copyright Notice in lua.h
*/
@@ -144,26 +144,28 @@ static Proto *getluaproto (StkId f) {
}
-int lua_getlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v) {
+const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int localnum) {
+ const char *name;
StkId f = ar->_func;
Proto *fp = getluaproto(f);
- if (!fp) return 0; /* `f' is not a Lua function? */
- v->name = luaF_getlocalname(fp, v->index, lua_currentpc(f));
- if (!v->name) return 0;
- v->value = luaA_putluaObject(L, (f+1)+(v->index-1));
- return 1;
+ if (!fp) return NULL; /* `f' is not a Lua function? */
+ name = luaF_getlocalname(fp, localnum, lua_currentpc(f));
+ if (!name) return NULL;
+ luaA_pushobject(L, (f+1)+(localnum-1)); /* push value */
+ return name;
}
-int lua_setlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v) {
+const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int localnum) {
+ const char *name;
StkId f = ar->_func;
Proto *fp = getluaproto(f);
UNUSED(L);
- if (!fp) return 0; /* `f' is not a Lua function? */
- v->name = luaF_getlocalname(fp, v->index, lua_currentpc(f));
- if (!v->name || v->name[0] == '*') return 0; /* `*' starts private locals */
- *((f+1)+(v->index-1)) = *v->value;
- return 1;
+ if (!fp) return NULL; /* `f' is not a Lua function? */
+ name = luaF_getlocalname(fp, localnum, lua_currentpc(f));
+ if (!name || name[0] == '*') return NULL; /* `*' starts private locals */
+ *((f+1)+(localnum-1)) = *(--L->top);
+ return name;
}
@@ -236,7 +238,7 @@ int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
func = ar->_func;
else {
what++; /* skip the '>' */
- func = ar->func;
+ func = L->top - 1;
}
for (; *what; what++) {
switch (*what) {
@@ -260,13 +262,13 @@ int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
}
case 'f': {
setnormalized(L->top, func);
- incr_top;
- ar->func = lua_pop(L);
+ incr_top; /* push function */
break;
}
default: return 0; /* invalid option */
}
}
+ if (!isactive) L->top--; /* pop function */
return 1;
}
@@ -420,7 +422,7 @@ static const char *getfuncname (lua_State *L, StkId f, const char **name) {
void luaG_typeerror (lua_State *L, StkId o, const char *op) {
const char *name;
const char *kind = getobjname(L, o, &name);
- const char *t = lua_type(L, o);
+ const char *t = luaO_typename(o);
if (kind)
luaL_verror(L, "attempt to %.30s %.20s `%.40s' (a %.10s value)",
op, kind, name, t);
@@ -437,8 +439,8 @@ void luaG_binerror (lua_State *L, StkId p1, lua_Type t, const char *op) {
void luaG_ordererror (lua_State *L, StkId top) {
- const char *t1 = lua_type(L, top-2);
- const char *t2 = lua_type(L, top-1);
+ const char *t1 = luaO_typename(top-2);
+ const char *t2 = luaO_typename(top-1);
if (t1[2] == t2[2])
luaL_verror(L, "attempt to compare two %.10s values", t1);
else
diff --git a/ldo.c b/ldo.c
@@ -1,5 +1,5 @@
/*
-** $Id: ldo.c,v 1.84 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: ldo.c,v 1.85 2000/08/10 19:50:47 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@@ -41,8 +41,7 @@ void luaD_init (lua_State *L, int stacksize) {
L->stack = luaM_newvector(L, stacksize+EXTRA_STACK, TObject);
L->stack_last = L->stack+(stacksize-1);
L->stacksize = stacksize;
- L->Cstack.base = L->Cstack.lua2C = L->top = L->stack;
- L->Cstack.num = 0;
+ L->Cbase = L->top = L->stack;
}
@@ -68,8 +67,8 @@ void luaD_checkstack (lua_State *L, int n) {
static void restore_stack_limit (lua_State *L) {
- if (L->top-L->stack < L->stacksize-1)
- L->stack_last = L->stack+(L->stacksize-1);
+ if (L->top - L->stack < L->stacksize - 1)
+ L->stack_last = L->stack + (L->stacksize-1);
}
@@ -103,9 +102,8 @@ void luaD_openstack (lua_State *L, StkId pos) {
void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook) {
if (L->allowhooks) {
lua_Debug ar;
- struct C_Lua_Stack oldCLS = L->Cstack;
- StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->top;
- L->Cstack.num = 0;
+ StkId old_Cbase = L->Cbase;
+ StkId old_top = L->Cbase = L->top;
ar._func = func;
ar.event = "line";
ar.currentline = line;
@@ -113,7 +111,7 @@ void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook) {
(*linehook)(L, &ar);
L->allowhooks = 1;
L->top = old_top;
- L->Cstack = oldCLS;
+ L->Cbase = old_Cbase;
}
}
@@ -122,42 +120,36 @@ static void luaD_callHook (lua_State *L, StkId func, lua_Hook callhook,
const char *event) {
if (L->allowhooks) {
lua_Debug ar;
- struct C_Lua_Stack oldCLS = L->Cstack;
- StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->top;
- L->Cstack.num = 0;
+ StkId old_Cbase = L->Cbase;
+ StkId old_top = L->Cbase = L->top;
ar._func = func;
ar.event = event;
L->allowhooks = 0; /* cannot call hooks inside a hook */
callhook(L, &ar);
L->allowhooks = 1;
L->top = old_top;
- L->Cstack = oldCLS;
+ L->Cbase = old_Cbase;
}
}
static StkId callCclosure (lua_State *L, const struct Closure *cl, StkId base) {
int nup = cl->nupvalues; /* number of upvalues */
- int numarg = L->top-base;
- struct C_Lua_Stack oldCLS = L->Cstack;
- StkId firstResult;
+ StkId old_Cbase = L->Cbase;
+ int nres; /* number of results */
if (nup > 0) {
- int n = numarg;
+ int n = L->top - base; /* number of arguments */
luaD_checkstack(L, nup);
/* open space for upvalues as extra arguments */
while (n--) *(base+nup+n) = *(base+n);
L->top += nup;
- numarg += nup;
/* copy upvalues into stack */
while (nup--) *(base+nup) = cl->upvalue[nup];
}
- L->Cstack.num = numarg;
- L->Cstack.lua2C = base;
- L->Cstack.base = L->top;
- (*cl->f.c)(L); /* do the actual call */
- firstResult = L->Cstack.base;
- L->Cstack = oldCLS;
- return firstResult;
+ L->Cbase = base; /* new base for C function */
+ nres = (*cl->f.c)(L); /* do the actual call */
+ L->Cbase = old_Cbase; /* restore old C base */
+ return L->top - nres; /* return index of first result */
}
@@ -257,42 +249,36 @@ void lua_error (lua_State *L, const char *s) {
static void chain_longjmp (lua_State *L, struct lua_longjmp *lj) {
- lj->base = L->Cstack.base;
- lj->numCblocks = L->numCblocks;
+ lj->status = 0;
+ lj->base = L->Cbase;
lj->previous = L->errorJmp;
L->errorJmp = lj;
}
-static void restore_longjmp (lua_State *L, struct lua_longjmp *lj) {
- L->Cstack.num = 0; /* no results */
- L->top = L->Cstack.base = L->Cstack.lua2C = lj->base;
- L->numCblocks = lj->numCblocks;
+static int restore_longjmp (lua_State *L, struct lua_longjmp *lj) {
+ L->Cbase = lj->base;
L->errorJmp = lj->previous;
+ return lj->status;
}
/*
-** Execute a protected call. Assumes that function is at Cstack.base and
-** parameters are on top of it.
+** Execute a protected call.
*/
-int luaD_protectedrun (lua_State *L) {
+int lua_call (lua_State *L, int nargs, int nresults) {
+ StkId func = L->top - (nargs+1); /* function to be called */
struct lua_longjmp myErrorJmp;
chain_longjmp(L, &myErrorJmp);
+ if (nresults == LUA_MULTRET) nresults = MULT_RET; /* internal code */
if (setjmp(myErrorJmp.b) == 0) {
- StkId base = L->Cstack.base;
- luaD_call(L, base, MULT_RET);
- L->Cstack.lua2C = base; /* position of the new results */
- L->Cstack.num = L->top - base;
- L->Cstack.base = base + L->Cstack.num; /* incorporate results on stack */
- L->errorJmp = myErrorJmp.previous;
- return 0;
+ luaD_call(L, func, nresults);
}
- else { /* an error occurred: restore the stack */
- restore_longjmp(L, &myErrorJmp);
+ else { /* an error occurred: restore the state */
+ L->top = func; /* remove garbage from the stack */
restore_stack_limit(L);
- return myErrorJmp.status;
}
+ return restore_longjmp(L, &myErrorJmp);
}
@@ -302,20 +288,17 @@ int luaD_protectedrun (lua_State *L) {
static int protectedparser (lua_State *L, ZIO *z, int bin) {
struct lua_longjmp myErrorJmp;
chain_longjmp(L, &myErrorJmp);
- L->top = L->Cstack.base; /* clear C2Lua */
if (setjmp(myErrorJmp.b) == 0) {
Proto *tf = bin ? luaU_undump1(L, z) : luaY_parser(L, z);
- L->errorJmp = myErrorJmp.previous;
- if (tf == NULL) return -1; /* `natural' end */
+ if (tf == NULL)
+ myErrorJmp.status = -1; /* `natural' end */
luaV_Lclosure(L, tf, 0);
- return 0;
}
- else { /* an error occurred */
- restore_longjmp(L, &myErrorJmp);
+ else { /* an error occurred: correct error code */
if (myErrorJmp.status == LUA_ERRRUN)
myErrorJmp.status = LUA_ERRSYNTAX;
- return myErrorJmp.status; /* error code */
}
+ return restore_longjmp(L, &myErrorJmp); /* error code */
}
@@ -331,7 +314,7 @@ static int do_main (lua_State *L, ZIO *z, int bin) {
else {
unsigned long newelems2 = 2*(L->nblocks-old_blocks);
L->GCthreshold += newelems2;
- status = luaD_protectedrun(L);
+ status = lua_call(L, 0, LUA_MULTRET);
L->GCthreshold -= newelems2;
}
} while (bin && status == 0);
diff --git a/ldo.h b/ldo.h
@@ -1,5 +1,5 @@
/*
-** $Id: ldo.h,v 1.21 2000/06/28 20:21:06 roberto Exp roberto $
+** $Id: ldo.h,v 1.22 2000/08/07 18:39:16 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@@ -26,7 +26,6 @@ void luaD_lineHook (lua_State *L, StkId func, int line, lua_Hook linehook);
void luaD_call (lua_State *L, StkId func, int nResults);
void luaD_callTM (lua_State *L, const TObject *f, int nParams, int nResults);
void luaD_breakrun (lua_State *L, int errcode);
-int luaD_protectedrun (lua_State *L);
void luaD_checkstack (lua_State *L, int n);
diff --git a/lgc.c b/lgc.c
@@ -1,5 +1,5 @@
/*
-** $Id: lgc.c,v 1.62 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: lgc.c,v 1.63 2000/08/22 17:44:17 roberto Exp roberto $
** Garbage Collector
** See Copyright Notice in lua.h
*/
@@ -11,7 +11,6 @@
#include "lgc.h"
#include "lmem.h"
#include "lobject.h"
-#include "lref.h"
#include "lstate.h"
#include "lstring.h"
#include "ltable.h"
@@ -145,6 +144,43 @@ static void markall (lua_State *L) {
}
+static int hasmark (const TObject *o) {
+ /* valid only for locked objects */
+ switch (o->ttype) {
+ case TAG_STRING: case TAG_USERDATA:
+ return tsvalue(o)->marked;
+ case TAG_TABLE:
+ return ismarked(hvalue(o));
+ case TAG_LCLOSURE: case TAG_CCLOSURE:
+ return ismarked(clvalue(o)->mark);
+ default: /* number */
+ return 1;
+ }
+}
+
+
+/* macro for internal debugging; check if a link of free refs is valid */
+#define VALIDLINK(L, st,n) (NONEXT <= (st) && (st) < (n))
+
+static void invalidaterefs (lua_State *L) {
+ int n = L->refSize;
+ int i;
+ for (i=0; i<n; i++) {
+ struct Ref *r = &L->refArray[i];
+ if (r->st == HOLD && !hasmark(&r->o))
+ r->st = COLLECTED;
+ LUA_ASSERT((r->st == LOCK && hasmark(&r->o)) ||
+ (r->st == HOLD && hasmark(&r->o)) ||
+ r->st == COLLECTED ||
+ r->st == NONEXT ||
+ (r->st < n && VALIDLINK(L, L->refArray[r->st].st, n)),
+ "inconsistent ref table");
+ }
+ LUA_ASSERT(VALIDLINK(L, L->refFree, n), "inconsistent ref table");
+}
+
+
+
static void collectproto (lua_State *L) {
Proto **p = &L->rootproto;
Proto *next;
@@ -300,7 +336,7 @@ void luaC_collect (lua_State *L, int all) {
long lua_collectgarbage (lua_State *L, long limit) {
unsigned long recovered = L->nblocks; /* to subtract `nblocks' after gc */
markall(L);
- luaR_invalidaterefs(L);
+ invalidaterefs(L);
luaC_collect(L, 0);
recovered = recovered - L->nblocks;
L->GCthreshold = (limit == 0) ? 2*L->nblocks : L->nblocks+limit;
diff --git a/liolib.c b/liolib.c
@@ -1,5 +1,5 @@
/*
-** $Id: liolib.c,v 1.70 2000/08/14 19:10:14 roberto Exp roberto $
+** $Id: liolib.c,v 1.71 2000/08/22 17:47:17 roberto Exp roberto $
** Standard I/O (and system) library
** See Copyright Notice in lua.h
*/
@@ -61,13 +61,16 @@ typedef struct IOCtrl {
static const char *const filenames[] = {"_INPUT", "_OUTPUT"};
-static void pushresult (lua_State *L, int i) {
- if (i)
+static int pushresult (lua_State *L, int i) {
+ if (i) {
lua_pushuserdata(L, NULL);
+ return 1;
+ }
else {
lua_pushnil(L);
lua_pushstring(L, strerror(errno));
lua_pushnumber(L, errno);
+ return 3;;
}
}
@@ -79,8 +82,8 @@ static void pushresult (lua_State *L, int i) {
*/
-static FILE *gethandle (lua_State *L, IOCtrl *ctrl, lua_Object f) {
- void *p = lua_getuserdata(L, f);
+static FILE *gethandle (lua_State *L, IOCtrl *ctrl, int f) {
+ void *p = lua_touserdata(L, f);
if (p != NULL) { /* is `f' a userdata ? */
int ftag = lua_tag(L, f);
if (ftag == ctrl->iotag) /* does it have the correct tag? */
@@ -94,7 +97,7 @@ static FILE *gethandle (lua_State *L, IOCtrl *ctrl, lua_Object f) {
static FILE *getnonullfile (lua_State *L, IOCtrl *ctrl, int arg) {
- FILE *f = gethandle(L, ctrl, lua_getparam(L, arg));
+ FILE *f = gethandle(L, ctrl, arg);
luaL_arg_check(L, f, arg, "invalid file handle");
return f;
}
@@ -102,9 +105,11 @@ static FILE *getnonullfile (lua_State *L, IOCtrl *ctrl, int arg) {
static FILE *getfilebyref (lua_State *L, IOCtrl *ctrl, int inout) {
FILE *f;
- lua_pushglobals(L);
- lua_pushref(L, ctrl->ref[inout]);
- f = gethandle(L, ctrl, lua_rawget(L));
+ lua_getglobals(L);
+ lua_getref(L, ctrl->ref[inout]);
+ lua_rawget(L);
+ f = gethandle(L, ctrl, -1);
+ lua_settop(L, -1); /* remove global */
if (f == NULL)
luaL_verror(L, "global variable `%.10s' is not a file handle",
filenames[inout]);
@@ -122,12 +127,13 @@ static void setfilebyname (lua_State *L, IOCtrl *ctrl, FILE *f,
#define setfile(L,ctrl,f,inout) (setfilebyname(L,ctrl,f,filenames[inout]))
-static void setreturn (lua_State *L, IOCtrl *ctrl, FILE *f, int inout) {
+static int setreturn (lua_State *L, IOCtrl *ctrl, FILE *f, int inout) {
if (f == NULL)
- pushresult(L, 0);
+ return pushresult(L, 0);
else {
setfile(L, ctrl, f, inout);
lua_pushusertag(L, f, ctrl->iotag);
+ return 1;
}
}
@@ -143,15 +149,15 @@ static int closefile (lua_State *L, IOCtrl *ctrl, FILE *f) {
}
-static void io_close (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
- pushresult(L, closefile(L, ctrl, getnonullfile(L, ctrl, 2)));
+static int io_close (lua_State *L) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
+ return pushresult(L, closefile(L, ctrl, getnonullfile(L, ctrl, 2)));
}
-static void file_collect (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
- if (ctrl == (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 2))) {
+static int file_collect (lua_State *L) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
+ if (ctrl == (IOCtrl *)lua_touserdata(L, 2)) {
/* collectig `ctrl' itself */
lua_unref(L, ctrl->ref[INFILE]);
lua_unref(L, ctrl->ref[OUTFILE]);
@@ -162,50 +168,54 @@ static void file_collect (lua_State *L) {
if (f != stdin && f != stdout && f != stderr)
CLOSEFILE(L, f);
}
+ return 0;
}
-static void io_open (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
+static int io_open (lua_State *L) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
FILE *f = fopen(luaL_check_string(L, 2), luaL_check_string(L, 3));
- if (f) lua_pushusertag(L, f, ctrl->iotag);
- else pushresult(L, 0);
+ if (f) {
+ lua_pushusertag(L, f, ctrl->iotag);
+ return 1;
+ }
+ else
+ return pushresult(L, 0);
}
-static void io_fromto (lua_State *L, int inout, const char *mode) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
- lua_Object f = lua_getparam(L, 2);
+static int io_fromto (lua_State *L, int inout, const char *mode) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
FILE *current;
- if (f == LUA_NOOBJECT) {
+ if (lua_isnull(L, 2)) {
closefile(L, ctrl, getfilebyref(L, ctrl, inout));
current = (inout == 0) ? stdin : stdout;
}
- else if (lua_tag(L, f) == ctrl->iotag) /* deprecated option */
- current = (FILE *)lua_getuserdata(L, f);
+ else if (lua_tag(L, 2) == ctrl->iotag) /* deprecated option */
+ current = (FILE *)lua_touserdata(L, 2);
else {
const char *s = luaL_check_string(L, 2);
current = (*s == '|') ? popen(s+1, mode) : fopen(s, mode);
}
- setreturn(L, ctrl, current, inout);
+ return setreturn(L, ctrl, current, inout);
}
-static void io_readfrom (lua_State *L) {
- io_fromto(L, INFILE, "r");
+static int io_readfrom (lua_State *L) {
+ return io_fromto(L, INFILE, "r");
}
-static void io_writeto (lua_State *L) {
- io_fromto(L, OUTFILE, "w");
+static int io_writeto (lua_State *L) {
+ return io_fromto(L, OUTFILE, "w");
}
-static void io_appendto (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
+static int io_appendto (lua_State *L) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
FILE *current = fopen(luaL_check_string(L, 2), "a");
- setreturn(L, ctrl, current, OUTFILE);
+ return setreturn(L, ctrl, current, OUTFILE);
}
@@ -342,28 +352,29 @@ static int read_chars (lua_State *L, FILE *f, size_t n) {
}
-static void io_read (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
- int arg = 2;
- lua_Object op;
- FILE *f = gethandle(L, ctrl, lua_getparam(L, arg));
- if (f) arg++;
+static int io_read (lua_State *L) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
+ int lastarg = lua_gettop(L);
+ int firstarg = 2;
+ FILE *f = gethandle(L, ctrl, firstarg);
+ int n = 0;
+ if (f) firstarg++;
else f = getfilebyref(L, ctrl, INFILE); /* get _INPUT */
- op = lua_getparam(L, arg);
do { /* repeat for each part */
size_t l;
int success;
luaL_resetbuffer(L);
- if (lua_isnumber(L, op))
- success = read_chars(L, f, (size_t)lua_getnumber(L, op));
+ if (lua_isnumber(L, firstarg+n))
+ success = read_chars(L, f, (size_t)lua_tonumber(L, firstarg+n));
else {
- const char *p = luaL_opt_string(L, arg, "*l");
+ const char *p = luaL_opt_string(L, firstarg+n, "*l");
if (p[0] != '*')
success = read_pattern(L, f, p); /* deprecated! */
else {
switch (p[1]) {
case 'n': /* number */
- if (!read_number(L, f)) return; /* read fails */
+ if (!read_number(L, f)) return n; /* read fails */
+ n++;
continue; /* number is already pushed; avoid the "pushstring" */
case 'l': /* line */
success = read_line(L, f);
@@ -377,66 +388,69 @@ static void io_read (lua_State *L) {
success = 0; /* must read something to succeed */
break;
default:
- luaL_argerror(L, arg, "invalid format");
+ luaL_argerror(L, firstarg+n, "invalid format");
success = 0; /* to avoid warnings */
}
}
}
l = luaL_getsize(L);
- if (!success && l==0) return; /* read fails */
+ if (!success && l==0) return n; /* read fails */
lua_pushlstring(L, luaL_buffer(L), l);
- } while ((op = lua_getparam(L, ++arg)) != LUA_NOOBJECT);
+ n++;
+ } while (firstarg+n <= lastarg);
+ return n;
}
/* }====================================================== */
-static void io_write (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
+static int io_write (lua_State *L) {
+ int lastarg = lua_gettop(L);
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
int arg = 2;
int status = 1;
- lua_Object o;
- FILE *f = gethandle(L, ctrl, lua_getparam(L, arg));
+ FILE *f = gethandle(L, ctrl, arg);
if (f) arg++;
else f = getfilebyref(L, ctrl, OUTFILE); /* get _OUTPUT */
- while ((o = lua_getparam(L, arg)) != LUA_NOOBJECT) {
- if (lua_type(L, o)[2] == 'm') { /* nuMber? */ /* LUA_NUMBER */
+ for (; arg <= lastarg; arg++) {
+ if (lua_type(L, arg)[2] == 'm') { /* nuMber? */ /* LUA_NUMBER */
/* optimization: could be done exactly as for strings */
- status = status && fprintf(f, "%.16g", lua_getnumber(L, o)) > 0;
+ status = status && fprintf(f, "%.16g", lua_tonumber(L, arg)) > 0;
}
else {
size_t l;
const char *s = luaL_check_lstr(L, arg, &l);
status = status && (fwrite(s, sizeof(char), l, f) == l);
}
- arg++;
}
pushresult(L, status);
+ return 1;
}
-static void io_seek (lua_State *L) {
+static int io_seek (lua_State *L) {
static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
static const char *const modenames[] = {"set", "cur", "end", NULL};
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
FILE *f = getnonullfile(L, ctrl, 2);
int op = luaL_findstring(luaL_opt_string(L, 3, "cur"), modenames);
long offset = luaL_opt_long(L, 4, 0);
luaL_arg_check(L, op != -1, 3, "invalid mode");
op = fseek(f, offset, mode[op]);
if (op)
- pushresult(L, 0); /* error */
- else
+ return pushresult(L, 0); /* error */
+ else {
lua_pushnumber(L, ftell(f));
+ return 1;
+ }
}
-static void io_flush (lua_State *L) {
- IOCtrl *ctrl = (IOCtrl *)lua_getuserdata(L, lua_getparam(L, 1));
- lua_Object of = lua_getparam(L, 2);
- FILE *f = gethandle(L, ctrl, of);
- luaL_arg_check(L, f || of == LUA_NOOBJECT, 2, "invalid file handle");
- pushresult(L, fflush(f) == 0);
+static int io_flush (lua_State *L) {
+ IOCtrl *ctrl = (IOCtrl *)lua_touserdata(L, 1);
+ FILE *f = gethandle(L, ctrl, 2);
+ luaL_arg_check(L, f || lua_isnull(L, 2), 2, "invalid file handle");
+ return pushresult(L, fflush(f) == 0);
}
/* }====================================================== */
@@ -448,39 +462,43 @@ static void io_flush (lua_State *L) {
** =======================================================
*/
-static void io_execute (lua_State *L) {
+static int io_execute (lua_State *L) {
lua_pushnumber(L, system(luaL_check_string(L, 1)));
+ return 1;
}
-static void io_remove (lua_State *L) {
- pushresult(L, remove(luaL_check_string(L, 1)) == 0);
+static int io_remove (lua_State *L) {
+ return pushresult(L, remove(luaL_check_string(L, 1)) == 0);
}
-static void io_rename (lua_State *L) {
- pushresult(L, rename(luaL_check_string(L, 1),
+static int io_rename (lua_State *L) {
+ return pushresult(L, rename(luaL_check_string(L, 1),
luaL_check_string(L, 2)) == 0);
}
-static void io_tmpname (lua_State *L) {
+static int io_tmpname (lua_State *L) {
lua_pushstring(L, tmpnam(NULL));
+ return 1;
}
-static void io_getenv (lua_State *L) {
+static int io_getenv (lua_State *L) {
lua_pushstring(L, getenv(luaL_check_string(L, 1))); /* if NULL push nil */
+ return 1;
}
-static void io_clock (lua_State *L) {
+static int io_clock (lua_State *L) {
lua_pushnumber(L, ((double)clock())/CLOCKS_PER_SEC);
+ return 1;
}
-static void io_date (lua_State *L) {
+static int io_date (lua_State *L) {
char b[256];
const char *s = luaL_opt_string(L, 1, "%c");
struct tm *stm;
@@ -490,10 +508,11 @@ static void io_date (lua_State *L) {
lua_pushstring(L, b);
else
lua_error(L, "invalid `date' format");
+ return 1;
}
-static void setloc (lua_State *L) {
+static int setloc (lua_State *L) {
static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
LC_NUMERIC, LC_TIME};
static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
@@ -501,25 +520,28 @@ static void setloc (lua_State *L) {
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;
}
-static void io_exit (lua_State *L) {
+static int io_exit (lua_State *L) {
exit(luaL_opt_int(L, 1, EXIT_SUCCESS));
+ return 0; /* to avoid warnings */
}
/* }====================================================== */
-static void io_debug (lua_State *L) {
+static int io_debug (lua_State *L) {
for (;;) {
char buffer[250];
fprintf(stderr, "lua_debug> ");
if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
strcmp(buffer, "cont\n") == 0)
- return;
+ return 0;
lua_dostring(L, buffer);
+ lua_settop(L, 0); /* remove eventual returns */
}
}
@@ -529,12 +551,11 @@ static void io_debug (lua_State *L) {
#define MAXMESSAGE (MESSAGESIZE*10)
-static void errorfb (lua_State *L) {
+static int errorfb (lua_State *L) {
char buff[MAXMESSAGE];
int level = 1; /* skip level 0 (it's this function) */
lua_Debug ar;
- lua_Object alertfunc;
- sprintf(buff, "error: %.200s\n", lua_getstring(L, lua_getparam(L, 1)));
+ sprintf(buff, "error: %.200s\n", lua_tostring(L, 1));
while (lua_getstack(L, level++, &ar)) {
char buffchunk[60];
lua_getinfo(L, "Snl", &ar);
@@ -572,13 +593,14 @@ static void errorfb (lua_State *L) {
sprintf(buff+strlen(buff), " [%.70s]", buffchunk);
strcat(buff, "\n");
}
- lua_pushglobals(L);
+ lua_getglobals(L);
lua_pushstring(L, LUA_ALERT);
- alertfunc = lua_rawget(L);
- if (lua_isfunction(L, alertfunc)) { /* avoid loop if _ALERT is not defined */
+ lua_rawget(L);
+ if (lua_isfunction(L, -1)) { /* avoid loop if _ALERT is not defined */
lua_pushstring(L, buff);
- lua_callfunction(L, alertfunc);
+ lua_call(L, 1, 0);
}
+ return 0;
}
diff --git a/llimits.h b/llimits.h
@@ -1,5 +1,5 @@
/*
-** $Id: llimits.h,v 1.11 2000/06/28 17:03:32 roberto Exp roberto $
+** $Id: llimits.h,v 1.12 2000/08/15 18:28:48 roberto Exp roberto $
** Limits, basic types, and some other "installation-dependent" definitions
** See Copyright Notice in lua.h
*/
@@ -197,12 +197,6 @@ typedef unsigned long Instruction;
#define RFIELDS_PER_FLUSH (LFIELDS_PER_FLUSH/2)
-/* maximum number of values printed in one call to `print' */
-#ifndef MAXPRINT
-#define MAXPRINT 40 /* arbitrary limit */
-#endif
-
-
/* maximum lookback to find a real constant (for code generation) */
#ifndef LOOKBACKNUMS
#define LOOKBACKNUMS 20 /* arbitrary constant */
diff --git a/lmathlib.c b/lmathlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lmathlib.c,v 1.25 2000/06/12 13:52:05 roberto Exp roberto $
+** $Id: lmathlib.c,v 1.26 2000/08/09 19:16:57 roberto Exp roberto $
** Standard mathematical library
** See Copyright Notice in lua.h
*/
@@ -33,138 +33,169 @@
#endif
-static void math_abs (lua_State *L) {
+static int math_abs (lua_State *L) {
lua_pushnumber(L, fabs(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_sin (lua_State *L) {
+static int math_sin (lua_State *L) {
lua_pushnumber(L, sin(TORAD(luaL_check_number(L, 1))));
+ return 1;
}
-static void math_cos (lua_State *L) {
+static int math_cos (lua_State *L) {
lua_pushnumber(L, cos(TORAD(luaL_check_number(L, 1))));
+ return 1;
}
-static void math_tan (lua_State *L) {
+static int math_tan (lua_State *L) {
lua_pushnumber(L, tan(TORAD(luaL_check_number(L, 1))));
+ return 1;
}
-static void math_asin (lua_State *L) {
+static int math_asin (lua_State *L) {
lua_pushnumber(L, FROMRAD(asin(luaL_check_number(L, 1))));
+ return 1;
}
-static void math_acos (lua_State *L) {
+static int math_acos (lua_State *L) {
lua_pushnumber(L, FROMRAD(acos(luaL_check_number(L, 1))));
+ return 1;
}
-static void math_atan (lua_State *L) {
+static int math_atan (lua_State *L) {
lua_pushnumber(L, FROMRAD(atan(luaL_check_number(L, 1))));
+ return 1;
}
-static void math_atan2 (lua_State *L) {
+static int math_atan2 (lua_State *L) {
lua_pushnumber(L, FROMRAD(atan2(luaL_check_number(L, 1), luaL_check_number(L, 2))));
+ return 1;
}
-static void math_ceil (lua_State *L) {
+static int math_ceil (lua_State *L) {
lua_pushnumber(L, ceil(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_floor (lua_State *L) {
+static int math_floor (lua_State *L) {
lua_pushnumber(L, floor(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_mod (lua_State *L) {
+static int math_mod (lua_State *L) {
lua_pushnumber(L, fmod(luaL_check_number(L, 1), luaL_check_number(L, 2)));
+ return 1;
}
-static void math_sqrt (lua_State *L) {
+static int math_sqrt (lua_State *L) {
lua_pushnumber(L, sqrt(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_pow (lua_State *L) {
+static int math_pow (lua_State *L) {
lua_pushnumber(L, pow(luaL_check_number(L, 1), luaL_check_number(L, 2)));
+ return 1;
}
-static void math_log (lua_State *L) {
+static int math_log (lua_State *L) {
lua_pushnumber(L, log(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_log10 (lua_State *L) {
+static int math_log10 (lua_State *L) {
lua_pushnumber(L, log10(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_exp (lua_State *L) {
+static int math_exp (lua_State *L) {
lua_pushnumber(L, exp(luaL_check_number(L, 1)));
+ return 1;
}
-static void math_deg (lua_State *L) {
+static int math_deg (lua_State *L) {
lua_pushnumber(L, luaL_check_number(L, 1)/RADIANS_PER_DEGREE);
+ return 1;
}
-static void math_rad (lua_State *L) {
+static int math_rad (lua_State *L) {
lua_pushnumber(L, luaL_check_number(L, 1)*RADIANS_PER_DEGREE);
+ return 1;
}
-static void math_frexp (lua_State *L) {
+static int math_frexp (lua_State *L) {
int e;
lua_pushnumber(L, frexp(luaL_check_number(L, 1), &e));
lua_pushnumber(L, e);
+ return 2;
}
-static void math_ldexp (lua_State *L) {
+static int math_ldexp (lua_State *L) {
lua_pushnumber(L, ldexp(luaL_check_number(L, 1), luaL_check_int(L, 2)));
+ return 1;
}
-static void math_min (lua_State *L) {
- int i = 1;
- double dmin = luaL_check_number(L, i);
- while (lua_getparam(L, ++i) != LUA_NOOBJECT) {
+static int math_min (lua_State *L) {
+ int n = lua_gettop(L); /* number of arguments */
+ double dmin = luaL_check_number(L, 1);
+ int i;
+ for (i=2; i<=n; i++) {
double d = luaL_check_number(L, i);
if (d < dmin)
dmin = d;
}
lua_pushnumber(L, dmin);
+ return 1;
}
-static void math_max (lua_State *L) {
- int i = 1;
- double dmax = luaL_check_number(L, i);
- while (lua_getparam(L, ++i) != LUA_NOOBJECT) {
+static int math_max (lua_State *L) {
+ int n = lua_gettop(L); /* number of arguments */
+ double dmax = luaL_check_number(L, 1);
+ int i;
+ for (i=2; i<=n; i++) {
double d = luaL_check_number(L, i);
if (d > dmax)
dmax = d;
}
lua_pushnumber(L, dmax);
+ return 1;
}
-static void math_random (lua_State *L) {
+static int math_random (lua_State *L) {
/* the '%' avoids the (rare) case of r==1, and is needed also because on
some systems (SunOS!) "rand()" may return a value larger than RAND_MAX */
double r = (double)(rand()%RAND_MAX) / (double)RAND_MAX;
- if (lua_getparam(L, 1) == LUA_NOOBJECT) /* no arguments? */
- lua_pushnumber(L, r); /* Number between 0 and 1 */
- else {
- int l, u; /* lower & upper limits */
- if (lua_getparam(L, 2) == LUA_NOOBJECT) { /* only one argument? */
- l = 1;
- u = luaL_check_int(L, 1);
+ switch (lua_gettop(L)) { /* check number of arguments */
+ case 0: { /* no arguments */
+ lua_pushnumber(L, r); /* Number between 0 and 1 */
+ break;
}
- else { /* two arguments */
- l = luaL_check_int(L, 1);
- u = luaL_check_int(L, 2);
+ case 1: { /* only upper limit */
+ int u = luaL_check_int(L, 1);
+ luaL_arg_check(L, 1<=u, 1, "interval is empty");
+ lua_pushnumber(L, (int)(r*u)+1); /* integer between 1 and `u' */
+ break;
}
- luaL_arg_check(L, l<=u, 1, "interval is empty");
- lua_pushnumber(L, (int)(r*(u-l+1))+l); /* integer between `l' and `u' */
+ 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, "interval is empty");
+ lua_pushnumber(L, (int)(r*(u-l+1))+l); /* integer between `l' and `u' */
+ break;
+ }
+ default: lua_error(L, "wrong number of arguments");
}
+ return 1;
}
-static void math_randomseed (lua_State *L) {
+static int math_randomseed (lua_State *L) {
srand(luaL_check_int(L, 1));
+ return 0;
}
@@ -199,9 +230,10 @@ static const struct luaL_reg mathlib[] = {
*/
void lua_mathlibopen (lua_State *L) {
luaL_openl(L, mathlib);
- lua_pushcfunction(L, math_pow);
lua_pushnumber(L, 0); /* to get its tag */
- lua_settagmethod(L, lua_tag(L, lua_pop(L)), "pow");
+ lua_pushcfunction(L, math_pow);
+ lua_settagmethod(L, lua_tag(L, -2), "pow");
+ lua_settop(L, -1); /* remove number */
lua_pushnumber(L, PI); lua_setglobal(L, "PI");
}
diff --git a/lref.c b/lref.c
@@ -1,118 +0,0 @@
-/*
-** $Id: lref.c,v 1.17 2000/08/09 19:16:57 roberto Exp roberto $
-** reference mechanism
-** See Copyright Notice in lua.h
-*/
-
-
-#include "lua.h"
-
-#include "lapi.h"
-#include "ldo.h"
-#include "lmem.h"
-#include "lref.h"
-#include "lstate.h"
-
-
-int lua_ref (lua_State *L, int lock) {
- int ref;
- luaA_checkCargs(L, 1);
- if (ttype(L->top-1) == TAG_NIL)
- ref = LUA_REFNIL;
- else {
- if (L->refFree != NONEXT) { /* is there a free place? */
- ref = L->refFree;
- L->refFree = L->refArray[ref].st;
- }
- else { /* no more free places */
- luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref,
- "reference table overflow", MAX_INT);
- ref = L->refSize++;
- }
- L->refArray[ref].o = *(L->top-1);
- L->refArray[ref].st = lock ? LOCK : HOLD;
- }
- L->top--;
- return ref;
-}
-
-
-void lua_unref (lua_State *L, int ref) {
- if (ref >= 0) {
- if (ref >= L->refSize || L->refArray[ref].st >= 0)
- lua_error(L, "Lua API error - "
- "invalid argument for function `lua_unref'");
- L->refArray[ref].st = L->refFree;
- L->refFree = ref;
- }
-}
-
-
-int lua_pushref (lua_State *L, int ref) {
- if (ref == LUA_REFNIL)
- ttype(L->top) = TAG_NIL;
- else if (0 <= ref && ref < L->refSize &&
- (L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD))
- *L->top = L->refArray[ref].o;
- else
- return 0;
- incr_top;
- return 1;
-}
-
-
-void lua_beginblock (lua_State *L) {
- luaM_growvector(L, L->Cblocks, L->numCblocks, 1, struct C_Lua_Stack,
- "too many nested blocks", L->stacksize);
- L->Cblocks[L->numCblocks] = L->Cstack;
- L->numCblocks++;
-}
-
-
-void lua_endblock (lua_State *L) {
- if (L->numCblocks <= 0)
- lua_error(L, "Lua API error - no block to end");
- --L->numCblocks;
- L->Cstack = L->Cblocks[L->numCblocks];
- L->top = L->Cstack.base;
-}
-
-
-
-
-
-
-static int hasmark (const TObject *o) {
- /* valid only for locked objects */
- switch (o->ttype) {
- case TAG_STRING: case TAG_USERDATA:
- return tsvalue(o)->marked;
- case TAG_TABLE:
- return ismarked(hvalue(o));
- case TAG_LCLOSURE: case TAG_CCLOSURE:
- return ismarked(clvalue(o)->mark);
- default: /* number */
- return 1;
- }
-}
-
-
-/* for internal debugging only; check if a link of free refs is valid */
-#define VALIDLINK(L, st,n) (NONEXT <= (st) && (st) < (n))
-
-void luaR_invalidaterefs (lua_State *L) {
- int n = L->refSize;
- int i;
- for (i=0; i<n; i++) {
- struct Ref *r = &L->refArray[i];
- if (r->st == HOLD && !hasmark(&r->o))
- r->st = COLLECTED;
- LUA_ASSERT((r->st == LOCK && hasmark(&r->o)) ||
- r->st == COLLECTED ||
- r->st == NONEXT ||
- (r->st < n && VALIDLINK(L, L->refArray[r->st].st, n)),
- "inconsistent ref table");
- }
- LUA_ASSERT(VALIDLINK(L, L->refFree, n), "inconsistent ref table");
-}
-
diff --git a/lref.h b/lref.h
@@ -1,27 +0,0 @@
-/*
-** $Id: lref.h,v 1.5 1999/12/27 17:33:22 roberto Exp roberto $
-** reference mechanism
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lref_h
-#define lref_h
-
-#include "lobject.h"
-
-
-#define NONEXT -1 /* to end the free list */
-#define HOLD -2
-#define COLLECTED -3
-#define LOCK -4
-
-
-struct Ref {
- TObject o;
- int st; /* can be LOCK, HOLD, COLLECTED, or next (for free list) */
-};
-
-
-void luaR_invalidaterefs (lua_State *L);
-
-#endif
diff --git a/lstate.c b/lstate.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstate.c,v 1.32 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: lstate.c,v 1.33 2000/08/14 17:46:07 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@@ -9,13 +9,11 @@
#include "lua.h"
-#include "lauxlib.h"
#include "lbuiltin.h"
#include "ldo.h"
#include "lgc.h"
#include "llex.h"
#include "lmem.h"
-#include "lref.h"
#include "lstate.h"
#include "lstring.h"
#include "ltable.h"
@@ -35,8 +33,6 @@ lua_State *lua_newstate (int stacksize, int put_builtin) {
L->Mbuffbase = 0;
L->Mbuffsize = 0;
L->Mbuffnext = 0;
- L->Cblocks = NULL;
- L->numCblocks = 0;
L->rootproto = NULL;
L->rootcl = NULL;
L->roottable = NULL;
@@ -84,8 +80,6 @@ void lua_close (lua_State *L) {
luaM_free(L, L->IMtable);
luaM_free(L, L->refArray);
luaM_free(L, L->Mbuffer);
- luaM_free(L, L->Cblocks);
- LUA_ASSERT(L->numCblocks == 0, "Cblocks still open");
LUA_ASSERT(L->nblocks == 0, "wrong count for nblocks");
luaM_free(L, L);
LUA_ASSERT(L != lua_state || memdebug_numblocks == 0, "memory leak!");
diff --git a/lstate.h b/lstate.h
@@ -1,5 +1,5 @@
/*
-** $Id: lstate.h,v 1.35 2000/08/07 18:39:16 roberto Exp roberto $
+** $Id: lstate.h,v 1.36 2000/08/08 20:42:07 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@@ -19,27 +19,28 @@ typedef TObject *StkId; /* index to stack elements */
/*
-** chain list of long jumps
+** marks for Reference array
*/
-struct lua_longjmp {
- jmp_buf b;
- struct lua_longjmp *previous;
- volatile int status; /* error code */
- StkId base;
- int numCblocks;
+#define NONEXT -1 /* to end the free list */
+#define HOLD -2
+#define COLLECTED -3
+#define LOCK -4
+
+
+struct Ref {
+ TObject o;
+ int st; /* can be LOCK, HOLD, COLLECTED, or next (for free list) */
};
/*
-** stack layout for C point of view:
-** [lua2C, lua2C+num) - `array' lua2C
-** [lua2C+num, base) - space for extra lua_Objects (limbo)
-** [base, L->top) - `stack' C2Lua
+** chain list of long jumps
*/
-struct C_Lua_Stack {
+struct lua_longjmp {
+ jmp_buf b;
+ struct lua_longjmp *previous;
+ volatile int status; /* error code */
StkId base;
- StkId lua2C;
- int num;
};
@@ -57,14 +58,12 @@ struct lua_State {
StkId stack; /* stack base */
StkId stack_last; /* last free slot in the stack */
int stacksize;
- struct C_Lua_Stack Cstack; /* C2lua struct */
+ StkId Cbase; /* base for current C function */
struct lua_longjmp *errorJmp; /* current error recover point */
char *Mbuffer; /* global buffer */
size_t Mbuffbase; /* current first position of Mbuffer */
size_t Mbuffsize; /* size of Mbuffer */
size_t Mbuffnext; /* next position to fill in Mbuffer */
- struct C_Lua_Stack *Cblocks;
- int numCblocks; /* number of nested Cblocks */
/* global state */
Proto *rootproto; /* list of all prototypes */
Closure *rootcl; /* list of all closures */
diff --git a/lstrlib.c b/lstrlib.c
@@ -1,5 +1,5 @@
/*
-** $Id: lstrlib.c,v 1.45 2000/06/12 14:37:18 roberto Exp roberto $
+** $Id: lstrlib.c,v 1.46 2000/08/09 19:16:57 roberto Exp roberto $
** Standard library for string operations and pattern-matching
** See Copyright Notice in lua.h
*/
@@ -25,10 +25,11 @@ static void addnchar (lua_State *L, const char *s, size_t n) {
}
-static void str_len (lua_State *L) {
+static int str_len (lua_State *L) {
size_t l;
luaL_check_lstr(L, 1, &l);
lua_pushnumber(L, l);
+ return 1;
}
@@ -43,7 +44,7 @@ static long posrelat (long pos, size_t len) {
}
-static void str_sub (lua_State *L) {
+static int str_sub (lua_State *L) {
size_t l;
const char *s = luaL_check_lstr(L, 1, &l);
long start = posrelat(luaL_check_long(L, 2), l);
@@ -53,10 +54,11 @@ static void str_sub (lua_State *L) {
if (start <= end)
lua_pushlstring(L, s+start-1, end-start+1);
else lua_pushstring(L, "");
+ return 1;
}
-static void str_lower (lua_State *L) {
+static int str_lower (lua_State *L) {
size_t l;
size_t i;
const char *s = luaL_check_lstr(L, 1, &l);
@@ -64,10 +66,11 @@ static void str_lower (lua_State *L) {
for (i=0; i<l; i++)
luaL_addchar(L, tolower((unsigned char)(s[i])));
closeandpush(L);
+ return 1;
}
-static void str_upper (lua_State *L) {
+static int str_upper (lua_State *L) {
size_t l;
size_t i;
const char *s = luaL_check_lstr(L, 1, &l);
@@ -75,9 +78,10 @@ static void str_upper (lua_State *L) {
for (i=0; i<l; i++)
luaL_addchar(L, toupper((unsigned char)(s[i])));
closeandpush(L);
+ return 1;
}
-static void str_rep (lua_State *L) {
+static int str_rep (lua_State *L) {
size_t l;
const char *s = luaL_check_lstr(L, 1, &l);
int n = luaL_check_int(L, 2);
@@ -85,27 +89,31 @@ static void str_rep (lua_State *L) {
while (n-- > 0)
addnchar(L, s, l);
closeandpush(L);
+ return 1;
}
-static void str_byte (lua_State *L) {
+static int str_byte (lua_State *L) {
size_t l;
const char *s = luaL_check_lstr(L, 1, &l);
long pos = posrelat(luaL_opt_long(L, 2, 1), l);
luaL_arg_check(L, 0<pos && (size_t)pos<=l, 2, "out of range");
lua_pushnumber(L, (unsigned char)s[pos-1]);
+ return 1;
}
-static void str_char (lua_State *L) {
- int i = 0;
+static int str_char (lua_State *L) {
+ int n = lua_gettop(L); /* number of arguments */
+ int i;
luaL_resetbuffer(L);
- while (lua_getparam(L, ++i) != LUA_NOOBJECT) {
+ for (i=1; i<=n; i++) {
int c = luaL_check_int(L, i);
luaL_arg_check(L, (unsigned char)c == c, i, "invalid value");
luaL_addchar(L, (unsigned char)c);
}
closeandpush(L);
+ return 1;
}
@@ -135,16 +143,6 @@ struct Capture {
#define SPECIALS "^$*+?.([%-"
-static void push_captures (lua_State *L, struct Capture *cap) {
- int i;
- for (i=0; i<cap->level; i++) {
- int l = cap->capture[i].len;
- if (l == -1) lua_error(L, "unfinished capture");
- lua_pushlstring(L, cap->capture[i].init, l);
- }
-}
-
-
static int check_capture (lua_State *L, int l, struct Capture *cap) {
l -= '1';
if (!(0 <= l && l < cap->level && cap->capture[l].len != -1))
@@ -400,20 +398,31 @@ static const char *lmemfind (const char *s1, size_t l1,
}
-static void str_find (lua_State *L) {
+static int push_captures (lua_State *L, struct Capture *cap) {
+ int i;
+ for (i=0; i<cap->level; i++) {
+ int l = cap->capture[i].len;
+ if (l == -1) lua_error(L, "unfinished capture");
+ lua_pushlstring(L, cap->capture[i].init, l);
+ }
+ return cap->level; /* number of strings pushed */
+}
+
+
+static int str_find (lua_State *L) {
size_t l1, l2;
const char *s = luaL_check_lstr(L, 1, &l1);
const char *p = luaL_check_lstr(L, 2, &l2);
long init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1;
struct Capture cap;
luaL_arg_check(L, 0 <= init && (size_t)init <= l1, 3, "out of range");
- if (lua_getparam(L, 4) != LUA_NOOBJECT ||
- strpbrk(p, SPECIALS) == NULL) { /* no special characters? */
+ if (lua_gettop(L) > 3 || /* extra argument? */
+ strpbrk(p, SPECIALS) == NULL) { /* or no special characters? */
const char *s2 = lmemfind(s+init, l1-init, p, l2);
if (s2) {
lua_pushnumber(L, s2-s+1);
lua_pushnumber(L, s2-s+l2);
- return;
+ return 2;
}
}
else {
@@ -426,19 +435,19 @@ static void str_find (lua_State *L) {
if ((res=match(L, s1, p, &cap)) != NULL) {
lua_pushnumber(L, s1-s+1); /* start */
lua_pushnumber(L, res-s); /* end */
- push_captures(L, &cap);
- return;
+ return push_captures(L, &cap) + 2;
}
} while (s1++<cap.src_end && !anchor);
}
lua_pushnil(L); /* not found */
+ return 1;
}
-static void add_s (lua_State *L, lua_Object newp, struct Capture *cap) {
- if (lua_isstring(L, newp)) {
- const char *news = lua_getstring(L, newp);
- size_t l = lua_strlen(L, newp);
+static void add_s (lua_State *L, struct Capture *cap) {
+ if (lua_isstring(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++) {
if (news[i] != ESC)
@@ -455,39 +464,38 @@ static void add_s (lua_State *L, lua_Object newp, struct Capture *cap) {
}
}
else { /* is a function */
- lua_Object res;
int status;
size_t oldbuff;
- lua_beginblock(L);
- push_captures(L, cap);
+ int n;
+ const char *s;
+ lua_pushobject(L, 3);
+ n = push_captures(L, cap);
/* function may use buffer, so save it and create a new one */
oldbuff = luaL_newbuffer(L, 0);
- status = lua_callfunction(L, newp);
+ status = lua_call(L, n, 1);
/* restore old buffer */
luaL_oldbuffer(L, oldbuff);
- if (status != 0) {
- lua_endblock(L);
+ if (status != 0)
lua_error(L, NULL);
- }
- res = lua_getresult(L, 1);
- if (lua_isstring(L, res))
- addnchar(L, lua_getstring(L, res), lua_strlen(L, res));
- lua_endblock(L);
+ s = lua_tostring(L, -1);
+ if (s)
+ addnchar(L, lua_tostring(L, -1), lua_strlen(L, -1));
+ lua_settop(L, -1); /* pop function result */
}
}
-static void str_gsub (lua_State *L) {
+static int str_gsub (lua_State *L) {
size_t srcl;
const char *src = luaL_check_lstr(L, 1, &srcl);
const char *p = luaL_check_string(L, 2);
- lua_Object newp = lua_getparam(L, 3);
int max_s = luaL_opt_int(L, 4, srcl+1);
int anchor = (*p == '^') ? (p++, 1) : 0;
int n = 0;
struct Capture cap;
- luaL_arg_check(L, lua_isstring(L, newp) || lua_isfunction(L, newp), 3,
- "string or function expected");
+ luaL_arg_check(L,
+ lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)),
+ 3, "string or function expected");
luaL_resetbuffer(L);
cap.src_end = src+srcl;
while (n < max_s) {
@@ -496,7 +504,7 @@ static void str_gsub (lua_State *L) {
e = match(L, src, p, &cap);
if (e) {
n++;
- add_s(L, newp, &cap);
+ add_s(L, &cap);
}
if (e && e>src) /* non empty match? */
src = e; /* skip it */
@@ -508,6 +516,7 @@ static void str_gsub (lua_State *L) {
addnchar(L, src, cap.src_end-src);
closeandpush(L);
lua_pushnumber(L, n); /* number of substitutions */
+ return 2;
}
/* }====================================================== */
@@ -534,7 +543,7 @@ static void luaI_addquoted (lua_State *L, int arg) {
/* maximum size of each format specification (such as '%-099.99d') */
#define MAX_FORMAT 20 /* arbitrary limit */
-static void str_format (lua_State *L) {
+static int str_format (lua_State *L) {
int arg = 1;
const char *strfrmt = luaL_check_string(L, arg);
luaL_resetbuffer(L);
@@ -597,6 +606,7 @@ static void str_format (lua_State *L) {
}
}
closeandpush(L); /* push the result */
+ return 1;
}
diff --git a/ltests.c b/ltests.c
@@ -1,5 +1,5 @@
/*
-** $Id: ltests.c,v 1.33 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: ltests.c,v 1.34 2000/08/15 20:14:27 roberto Exp roberto $
** Internal Module for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/
@@ -10,7 +10,6 @@
#include <stdlib.h>
#include <string.h>
-#define LUA_SINGLESTATE
#include "lua.h"
@@ -38,11 +37,11 @@ void luaB_opentests (lua_State *L);
-static void setnameval (lua_Object t, const char *name, int val) {
- lua_pushobject(t);
- lua_pushstring(name);
- lua_pushnumber(val);
- lua_settable();
+static void setnameval (lua_State *L, const char *name, int val) {
+ lua_pushobject(L, -1);
+ lua_pushstring(L, name);
+ lua_pushnumber(L, val);
+ lua_settable(L);
}
@@ -65,7 +64,7 @@ static const char *const instrname[NUM_OPCODES] = {
};
-static int pushop (Proto *p, int pc) {
+static int pushop (lua_State *L, Proto *p, int pc) {
char buff[100];
Instruction i = p->code[pc];
OpCode o = GET_OPCODE(i);
@@ -85,146 +84,161 @@ static int pushop (Proto *p, int pc) {
sprintf(buff+8, "%-12s%4d %4d", name, GETARG_A(i), GETARG_B(i));
break;
}
- lua_pushstring(buff);
+ lua_pushstring(L, buff);
return (o != OP_END);
}
-static void listcode (void) {
- lua_Object o = luaL_nonnullarg(1);
- lua_Object t = lua_createtable();
+static int listcode (lua_State *L) {
int pc;
Proto *p;
int res;
- luaL_arg_check(ttype(o) == TAG_LCLOSURE, 1, "Lua function expected");
- p = clvalue(o)->f.l;
- setnameval(t, "maxstack", p->maxstacksize);
- setnameval(t, "numparams", p->numparams);
+ luaL_arg_check(L, lua_tag(L, 1) == TAG_LCLOSURE, 1, "Lua function expected");
+ p = clvalue(luaA_index(L, 1))->f.l;
+ lua_newtable(L);
+ setnameval(L, "maxstack", p->maxstacksize);
+ setnameval(L, "numparams", p->numparams);
pc = 0;
do {
- lua_pushobject(t);
- lua_pushnumber(pc+1);
- res = pushop(p, pc++);
- lua_settable();
+ lua_pushobject(L, -1);
+ lua_pushnumber(L, pc+1);
+ res = pushop(L, p, pc++);
+ lua_settable(L);
} while (res);
- lua_pushobject(t);
+ return 1;
}
-static void liststrings (void) {
- lua_Object o = luaL_nonnullarg(1);
- lua_Object t = lua_createtable();
+static int liststrings (lua_State *L) {
Proto *p;
int i;
- luaL_arg_check(ttype(o) == TAG_LCLOSURE, 1, "Lua function expected");
- p = clvalue(o)->f.l;
+ luaL_arg_check(L, lua_tag(L, 1) == TAG_LCLOSURE, 1, "Lua function expected");
+ p = clvalue(luaA_index(L, 1))->f.l;
+ lua_newtable(L);
for (i=0; i<p->nkstr; i++) {
- lua_pushobject(t);
- lua_pushnumber(i+1);
- lua_pushstring(p->kstr[i]->str);
- lua_settable();
+ lua_pushobject(L, -1);
+ lua_pushnumber(L, i+1);
+ lua_pushstring(L, p->kstr[i]->str);
+ lua_settable(L);
}
- lua_pushobject(t);
+ return 1;
}
-static void listlocals (void) {
- lua_Object o = luaL_nonnullarg(1);
+static int listlocals (lua_State *L) {
Proto *p;
- int pc = luaL_check_int(2) - 1;
- int i = 1;
+ int pc = luaL_check_int(L, 2) - 1;
+ int i = 0;
const char *name;
- luaL_arg_check(ttype(o) == TAG_LCLOSURE, 1, "Lua function expected");
- p = clvalue(o)->f.l;
- while ((name = luaF_getlocalname(p, i++, pc)) != NULL)
- lua_pushstring(name);
+ luaL_arg_check(L, lua_tag(L, 1) == TAG_LCLOSURE, 1, "Lua function expected");
+ p = clvalue(luaA_index(L, 1))->f.l;
+ while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
+ lua_pushstring(L, name);
+ return i-1;
}
/* }====================================================== */
-static void get_limits (void) {
- lua_Object t = lua_createtable();
- setnameval(t, "BITS_INT", BITS_INT);
- setnameval(t, "LFPF", LFIELDS_PER_FLUSH);
- setnameval(t, "MAXARG_A", MAXARG_A);
- setnameval(t, "MAXARG_B", MAXARG_B);
- setnameval(t, "MAXARG_S", MAXARG_S);
- setnameval(t, "MAXARG_U", MAXARG_U);
- setnameval(t, "MAXLOCALS", MAXLOCALS);
- setnameval(t, "MAXPARAMS", MAXPARAMS);
- setnameval(t, "MAXSTACK", MAXSTACK);
- setnameval(t, "MAXUPVALUES", MAXUPVALUES);
- setnameval(t, "MAXVARSLH", MAXVARSLH);
- setnameval(t, "RFPF", RFIELDS_PER_FLUSH);
- setnameval(t, "SIZE_A", SIZE_A);
- setnameval(t, "SIZE_B", SIZE_B);
- setnameval(t, "SIZE_OP", SIZE_OP);
- setnameval(t, "SIZE_U", SIZE_U);
- lua_pushobject(t);
+static int get_limits (lua_State *L) {
+ lua_newtable(L);
+ setnameval(L, "BITS_INT", BITS_INT);
+ setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
+ setnameval(L, "MAXARG_A", MAXARG_A);
+ setnameval(L, "MAXARG_B", MAXARG_B);
+ setnameval(L, "MAXARG_S", MAXARG_S);
+ setnameval(L, "MAXARG_U", MAXARG_U);
+ setnameval(L, "MAXLOCALS", MAXLOCALS);
+ setnameval(L, "MAXPARAMS", MAXPARAMS);
+ setnameval(L, "MAXSTACK", MAXSTACK);
+ setnameval(L, "MAXUPVALUES", MAXUPVALUES);
+ setnameval(L, "MAXVARSLH", MAXVARSLH);
+ setnameval(L, "RFPF", RFIELDS_PER_FLUSH);
+ setnameval(L, "SIZE_A", SIZE_A);
+ setnameval(L, "SIZE_B", SIZE_B);
+ setnameval(L, "SIZE_OP", SIZE_OP);
+ setnameval(L, "SIZE_U", SIZE_U);
+ return 1;
}
-static void mem_query (void) {
- lua_Object arg = lua_getparam(1);
- if (arg == LUA_NOOBJECT) {
- lua_pushnumber(memdebug_total);
- lua_pushnumber(memdebug_numblocks);
- lua_pushnumber(memdebug_maxmem);
+static int mem_query (lua_State *L) {
+ if (lua_isnull(L, 1)) {
+ lua_pushnumber(L, memdebug_total);
+ lua_pushnumber(L, memdebug_numblocks);
+ lua_pushnumber(L, memdebug_maxmem);
+ return 3;
+ }
+ else {
+ memdebug_memlimit = luaL_check_int(L, 1);
+ return 0;
}
- else
- memdebug_memlimit = luaL_check_int(1);
}
-static void hash_query (void) {
- lua_Object o = luaL_nonnullarg(1);
- if (lua_getparam(2) == LUA_NOOBJECT) {
- luaL_arg_check(ttype(o) == TAG_STRING, 1, "string expected");
- lua_pushnumber(tsvalue(o)->u.s.hash);
+static int hash_query (lua_State *L) {
+ if (lua_isnull(L, 2)) {
+ luaL_arg_check(L, lua_tag(L, 1) == TAG_STRING, 1, "string expected");
+ lua_pushnumber(L, tsvalue(luaA_index(L, 1))->u.s.hash);
}
else {
- const Hash *t = hvalue(luaL_tablearg(2));
- lua_pushnumber(luaH_mainposition(t, o) - t->node);
+ Hash *t;
+ luaL_checktype(L, 2, "table");
+ t = hvalue(luaA_index(L, 2));
+ lua_pushnumber(L, luaH_mainposition(t, luaA_index(L, 1)) - t->node);
}
+ return 1;
}
-static void table_query (void) {
- const Hash *t = hvalue(luaL_tablearg(1));
- int i = luaL_opt_int(2, -1);
+static int table_query (lua_State *L) {
+ const Hash *t;
+ int i = luaL_opt_int(L, 2, -1);
+ luaL_checktype(L, 1, "table");
+ t = hvalue(luaA_index(L, 1));
if (i == -1) {
- lua_pushnumber(t->size);
- lua_pushnumber(t->firstfree - t->node);
+ lua_pushnumber(L, t->size);
+ lua_pushnumber(L, t->firstfree - t->node);
+ return 2;
}
else if (i < t->size) {
- luaA_pushobject(lua_state, &t->node[i].key);
- luaA_pushobject(lua_state, &t->node[i].val);
- if (t->node[i].next)
- lua_pushnumber(t->node[i].next - t->node);
+ luaA_pushobject(L, &t->node[i].key);
+ luaA_pushobject(L, &t->node[i].val);
+ if (t->node[i].next) {
+ lua_pushnumber(L, t->node[i].next - t->node);
+ return 3;
+ }
+ else
+ return 2;
}
+ return 0;
}
-static void string_query (void) {
- lua_State *L = lua_state;
- stringtable *tb = (*luaL_check_string(1) == 's') ? &L->strt : &L->udt;
- int s = luaL_opt_int(2, 0) - 1;
+static int string_query (lua_State *L) {
+ stringtable *tb = (*luaL_check_string(L, 1) == 's') ? &L->strt : &L->udt;
+ int s = luaL_opt_int(L, 2, 0) - 1;
if (s==-1) {
- lua_pushnumber(tb->nuse);
- lua_pushnumber(tb->size);
+ lua_pushnumber(L ,tb->nuse);
+ lua_pushnumber(L ,tb->size);
+ return 2;
}
else if (s < tb->size) {
TString *ts;
+ int n = 0;
for (ts = tb->hash[s]; ts; ts = ts->nexthash) {
ttype(L->top) = TAG_STRING;
tsvalue(L->top) = ts;
incr_top;
+ n++;
}
+ return n;
}
+ return 0;
}
+
/*
** {======================================================
** function to test the API with C. It interprets a kind of "assembler"
@@ -238,21 +252,33 @@ static void skip (const char **pc) {
while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
}
-static int getnum (const char **pc) {
+static int getnum (const char **pc, int *reg) {
int res = 0;
+ int sig = 1;
+ int ref = 0;
skip(pc);
+ if (**pc == 'r') {
+ ref = 1;
+ (*pc)++;
+ }
+ else if (**pc == '-') {
+ sig = -1;
+ (*pc)++;
+ }
while (isdigit(**pc)) res = res*10 + (*(*pc)++) - '0';
- return res;
+ if (!ref)
+ return sig*res;
+ else
+ return reg[res];
}
static int getreg (const char **pc) {
skip(pc);
- if (*(*pc)++ != 'r') lua_error("`testC' expecting a register");
- return getnum(pc);
+ (*pc)++; /* skip the `r' */
+ return getnum(pc, NULL);
}
-static const char *getname (const char **pc) {
- static char buff[30];
+static const char *getname (char *buff, const char **pc) {
int i = 0;
skip(pc);
while (**pc != '\0' && !strchr(delimits, **pc))
@@ -264,159 +290,148 @@ static const char *getname (const char **pc) {
#define EQ(s1) (strcmp(s1, inst) == 0)
+#define getnum ((getnum)(&pc, reg))
+#define getreg ((getreg)(&pc))
+#define getname ((getname)(buff, &pc))
+
-static void testC (void) {
- lua_Object reg[10];
- const char *pc = luaL_check_string(1);
+static int testC (lua_State *L) {
+ char buff[30];
+ int reg[10];
+ const char *pc = luaL_check_string(L, 1);
for (;;) {
- const char *inst = getname(&pc);
- if EQ("") return;
+ const char *inst = getname;
+ if EQ("") return 0;
+ else if EQ("return") {
+ return getnum;
+ }
+ else if EQ("retall") {
+ return lua_gettop(L) - 1;
+ }
+ else if EQ("gettop") {
+ reg[getreg] = lua_gettop(L);
+ }
+ else if EQ("settop") {
+ lua_settop(L, getnum);
+ }
+ else if EQ("setreg") {
+ int n = getreg;
+ reg[n] = lua_tonumber(L, getnum);
+ }
else if EQ("pushnum") {
- lua_pushnumber(getnum(&pc));
+ lua_pushnumber(L, getnum);
}
- else if EQ("createtable") {
- reg[getreg(&pc)] = lua_createtable();
+ else if EQ("newtable") {
+ lua_newtable(L);
}
else if EQ("closure") {
- lua_CFunction f = lua_getcfunction(lua_getglobal(getname(&pc)));
- lua_pushcclosure(f, getnum(&pc));
+ lua_CFunction f;
+ lua_getglobal(L, getname);
+ f = lua_tocfunction(L, -1);
+ lua_settop(L, -1);
+ lua_pushcclosure(L, f, getnum);
}
- else if EQ("pop") {
- reg[getreg(&pc)] = lua_pop();
+ else if EQ("pushobject") {
+ lua_pushobject(L, getnum);
}
else if EQ("getglobal") {
- int n = getreg(&pc);
- reg[n] = lua_getglobal(getname(&pc));
+ lua_getglobal(L, getname);
}
else if EQ("ref") {
- lua_pushnumber(lua_ref(0));
- reg[getreg(&pc)] = lua_pop();
+ reg[getreg] = lua_ref(L, 0);
}
else if EQ("reflock") {
- lua_pushnumber(lua_ref(1));
- reg[getreg(&pc)] = lua_pop();
+ reg[getreg] = lua_ref(L, 1);
}
else if EQ("getref") {
- int n = getreg(&pc);
- reg[n] = lua_getref((int)lua_getnumber(reg[getreg(&pc)]));
+ int n = getreg;
+ reg[n] = lua_getref(L, getnum);
}
else if EQ("unref") {
- lua_unref((int)lua_getnumber(reg[getreg(&pc)]));
- }
- else if EQ("getparam") {
- int n = getreg(&pc);
- reg[n] = lua_getparam(getnum(&pc)+1); /* skips the command itself */
- }
- else if EQ("getresult") {
- int n = getreg(&pc);
- reg[n] = lua_getparam(getnum(&pc));
+ lua_unref(L, getnum);
}
else if EQ("setglobal") {
- lua_setglobal(getname(&pc));
- }
- else if EQ("pushglobals") {
- lua_pushglobals();
+ lua_setglobal(L, getname);
}
else if EQ("pushstring") {
- lua_pushstring(getname(&pc));
- }
- else if EQ("pushreg") {
- lua_pushobject(reg[getreg(&pc)]);
+ lua_pushstring(L, getname);
}
else if EQ("call") {
- if (lua_call(getname(&pc))) lua_error(NULL);
+ int narg = getnum;
+ int nres = getnum;
+ if (lua_call(L, narg, nres)) lua_error(L, NULL);
}
else if EQ("gettable") {
- reg[getreg(&pc)] = lua_gettable();
+ lua_gettable(L);
}
else if EQ("rawget") {
- reg[getreg(&pc)] = lua_rawget();
+ lua_rawget(L);
}
else if EQ("settable") {
- lua_settable();
+ lua_settable(L);
}
else if EQ("rawset") {
- lua_rawset();
+ lua_rawset(L);
}
else if EQ("tag") {
- lua_pushnumber(lua_tag(reg[getreg(&pc)]));
+ int n = getreg;
+ reg[n] = lua_tag(L, getnum);
}
else if EQ("type") {
- lua_pushstring(lua_type(reg[getreg(&pc)]));
- }
- else if EQ("next") {
- int n = getreg(&pc);
- n = lua_next(reg[n], (int)lua_getnumber(reg[getreg(&pc)]));
- lua_pushnumber(n);
+ lua_pushstring(L, lua_type(L, getnum));
}
else if EQ("equal") {
- int n1 = getreg(&pc);
- int n2 = getreg(&pc);
- lua_pushnumber(lua_equal(reg[n1], reg[n2]));
+ int n1 = getreg;
+ int n2 = getnum;
+ int n3 = getnum;
+ reg[n1] = lua_equal(L, n2, n3);
}
else if EQ("pushusertag") {
- int val = getreg(&pc);
- int tag = getreg(&pc);
- lua_pushusertag((void *)(int)lua_getnumber(reg[val]),
- (int)lua_getnumber(reg[tag]));
+ int val = getnum;
+ int tag = getnum;
+ lua_pushusertag(L, (void *)val, tag);
}
else if EQ("udataval") {
- int n = getreg(&pc);
- lua_pushnumber((int)lua_getuserdata(reg[getreg(&pc)]));
- reg[n] = lua_pop();
+ int n = getreg;
+ reg[n] = (int)lua_touserdata(L, getnum);
}
else if EQ("settagmethod") {
- int n = getreg(&pc);
- lua_settagmethod((int)lua_getnumber(reg[n]), getname(&pc));
- }
- else if EQ("beginblock") {
- lua_beginblock();
- }
- else if EQ("endblock") {
- lua_endblock();
+ int n = getnum;
+ lua_settagmethod(L, n, getname);
}
else if EQ("newstate") {
- int stacksize = getnum(&pc);
- lua_State *L1 = lua_newstate(stacksize, getnum(&pc));
+ int stacksize = getnum;
+ lua_State *L1 = lua_newstate(stacksize, getnum);
if (L1)
- lua_pushuserdata(L1);
+ lua_pushuserdata(L, L1);
else
- lua_pushnil();
+ lua_pushnil(L);
}
else if EQ("closestate") {
- (lua_close)((lua_State *)lua_getuserdata(reg[getreg(&pc)]));
+ (lua_close)((lua_State *)lua_touserdata(L, getnum));
}
else if EQ("doremote") {
- lua_Object ol1 = reg[getreg(&pc)];
- lua_Object str = reg[getreg(&pc)];
+ int ol1 = getnum;
+ int str = getnum;
lua_State *L1;
- lua_Object temp;
int status;
- if (!lua_isuserdata(ol1) || !lua_isstring(str))
- lua_error("bad arguments for `doremote'");
- L1 = (lua_State *)lua_getuserdata(ol1);
- status = (lua_dostring)(L1, lua_getstring(str));
+ if (!lua_isuserdata(L, ol1) || !lua_isstring(L, str))
+ lua_error(L, "bad arguments for `doremote'");
+ L1 = (lua_State *)lua_touserdata(L, ol1);
+ status = lua_dostring(L1, lua_tostring(L, str));
if (status != 0) {
- lua_pushnil();
- lua_pushnumber(status);
+ lua_pushnil(L);
+ lua_pushnumber(L, status);
}
else {
- int i = 1;
- while ((temp = (lua_getresult)(L1, i++)) != LUA_NOOBJECT)
- lua_pushstring((lua_getstring)(L1, temp));
+ int i = 0;
+ while (!lua_isnull(L, ++i))
+ lua_pushstring(L, lua_tostring(L1, i));
}
}
-#if LUA_DEPRECATETFUNCS
- else if EQ("rawsetglobal") {
- lua_rawsetglobal(getname(&pc));
- }
- else if EQ("rawgetglobal") {
- int n = getreg(&pc);
- reg[n] = lua_rawgetglobal(getname(&pc));
- }
-#endif
- else luaL_verror(lua_state, "unknown command in `testC': %.20s", inst);
+ else luaL_verror(L, "unknown instruction %.30s", buff);
}
+ return 0;
}
/* }====================================================== */
@@ -424,22 +439,20 @@ static void testC (void) {
static const struct luaL_reg tests_funcs[] = {
- {"hash", (lua_CFunction)hash_query},
- {"limits", (lua_CFunction)get_limits},
- {"listcode", (lua_CFunction)listcode},
- {"liststrings", (lua_CFunction)liststrings},
- {"listlocals", (lua_CFunction)listlocals},
- {"querystr", (lua_CFunction)string_query},
- {"querytab", (lua_CFunction)table_query},
- {"testC", (lua_CFunction)testC},
- {"totalmem", (lua_CFunction)mem_query}
+ {"hash", hash_query},
+ {"limits", get_limits},
+ {"listcode", listcode},
+ {"liststrings", liststrings},
+ {"listlocals", listlocals},
+ {"querystr", string_query},
+ {"querytab", table_query},
+ {"testC", testC},
+ {"totalmem", mem_query}
};
void luaB_opentests (lua_State *L) {
- if (lua_state != NULL) return; /* do not open tests for auxiliar states */
- lua_state = L;
- luaL_openl(tests_funcs);
+ luaL_openl(L, tests_funcs);
}
#endif
diff --git a/lua.c b/lua.c
@@ -1,5 +1,5 @@
/*
-** $Id: lua.c,v 1.44 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: lua.c,v 1.45 2000/08/14 17:45:59 roberto Exp roberto $
** Lua stand-alone interpreter
** See Copyright Notice in lua.h
*/
@@ -10,14 +10,14 @@
#include <stdlib.h>
#include <string.h>
-#define LUA_SINGLESTATE
-
#include "lua.h"
#include "luadebug.h"
#include "lualib.h"
+
lua_State *lua_state = NULL;
+#define L lua_state
#ifndef PROMPT
@@ -54,10 +54,10 @@ extern void USERINIT (void);
#else
#define USERINIT userinit
static void userinit (void) {
- lua_iolibopen();
- lua_strlibopen();
- lua_mathlibopen();
- lua_dblibopen();
+ lua_iolibopen(L);
+ lua_strlibopen(L);
+ lua_mathlibopen(L);
+ lua_dblibopen(L);
}
#endif
@@ -68,10 +68,10 @@ static handler lreset (void) {
static void lstop (void) {
- lua_setlinehook(lua_state, old_linehook);
- lua_setcallhook(lua_state, old_callhook);
+ lua_setlinehook(L, old_linehook);
+ lua_setcallhook(L, old_callhook);
lreset();
- lua_error("interrupted!");
+ lua_error(L, "interrupted!");
}
@@ -79,15 +79,15 @@ static void laction (int i) {
(void)i; /* to avoid warnings */
signal(SIGINT, SIG_DFL); /* if another SIGINT happens before lstop,
terminate process (default action) */
- old_linehook = lua_setlinehook(lua_state, (lua_Hook)lstop);
- old_callhook = lua_setcallhook(lua_state, (lua_Hook)lstop);
+ old_linehook = lua_setlinehook(L, (lua_Hook)lstop);
+ old_callhook = lua_setcallhook(L, (lua_Hook)lstop);
}
-static int ldo (int (*f)(lua_State *L, const char *), const char *name) {
+static int ldo (int (*f)(lua_State *l, const char *), const char *name) {
int res;
handler h = lreset();
- res = f(lua_state, name); /* dostring | dofile */
+ res = f(L, name); /* dostring | dofile */
signal(SIGINT, h); /* restore old action */
if (res == LUA_ERRMEM) {
/* Lua gives no message in such case, so lua.c provides one */
@@ -122,29 +122,29 @@ static void print_version (void) {
static void assign (char *arg) {
char *eq = strchr(arg, '=');
*eq = '\0'; /* spilt `arg' in two strings (name & value) */
- lua_pushstring(eq+1);
- lua_setglobal(arg);
+ lua_pushstring(L, eq+1);
+ lua_setglobal(L, arg);
}
-static lua_Object getargs (char *argv[]) {
- lua_Object args = lua_createtable();
+static void getargs (char *argv[]) {
int i;
+ lua_newtable(L);
for (i=0; argv[i]; i++) {
/* arg[i] = argv[i] */
- lua_pushobject(args); lua_pushnumber(i);
- lua_pushstring(argv[i]); lua_settable();
+ lua_pushobject(L, -1); lua_pushnumber(L, i);
+ lua_pushstring(L, argv[i]); lua_settable(L);
}
/* arg.n = maximum index in table `arg' */
- lua_pushobject(args); lua_pushstring("n");
- lua_pushnumber(i-1); lua_settable();
- return args;
+ lua_pushobject(L, -1); lua_pushstring(L, "n");
+ lua_pushnumber(L, i-1); lua_settable(L);
}
-static void l_getargs (void) {
- char **argv = (char **)lua_getuserdata(lua_getparam(1));
- lua_pushobject(getargs(argv));
+static int l_getargs (lua_State *l) {
+ char **argv = (char **)lua_touserdata(l, 1);
+ getargs(argv);
+ return 1;
}
@@ -173,9 +173,11 @@ static void manual_input (int version, int prompt) {
while (cont) {
char buffer[MAXINPUT];
int i = 0;
- lua_beginblock();
if (prompt) {
- const char *s = lua_getstring(lua_getglobal("_PROMPT"));
+ const char *s;
+ lua_getglobal(L, "_PROMPT");
+ s = lua_tostring(L, -1);
+ lua_settop(L, -1); /* remove global */
if (!s) s = PROMPT;
fputs(s, stdout);
}
@@ -198,7 +200,7 @@ static void manual_input (int version, int prompt) {
}
buffer[i] = '\0';
ldo(lua_dostring, buffer);
- lua_endblock();
+ lua_settop(L, 0); /* remove eventual results */
}
printf("\n");
}
@@ -262,8 +264,8 @@ static int handle_argv (char *argv[], struct Options *opt) {
print_message();
return EXIT_FAILURE;
}
- lua_pushobject(getargs(argv+i)); /* collect remaining arguments */
- lua_setglobal("arg");
+ getargs(argv+i); /* collect remaining arguments */
+ lua_setglobal(L, "arg");
return file_input(argv[i]); /* stop scanning arguments */
}
case 's': {
@@ -296,9 +298,9 @@ static void getstacksize (int argc, char *argv[], struct Options *opt) {
static void register_getargs (char *argv[]) {
- lua_pushuserdata(argv);
- lua_pushcclosure(l_getargs, 1);
- lua_setglobal("getargs");
+ lua_pushuserdata(L, argv);
+ lua_pushcclosure(L, l_getargs, 1);
+ lua_setglobal(L, "getargs");
}
@@ -307,12 +309,12 @@ int main (int argc, char *argv[]) {
int status;
opt.toclose = 0;
getstacksize(argc, argv, &opt); /* handle option `-s' */
- lua_state = lua_newstate(opt.stacksize, 1); /* create state */
+ L = lua_newstate(opt.stacksize, 1); /* create state */
USERINIT(); /* open libraries */
register_getargs(argv); /* create `getargs' function */
status = handle_argv(argv+1, &opt);
if (opt.toclose)
- lua_close();
+ lua_close(L);
return status;
}
diff --git a/lua.h b/lua.h
@@ -1,5 +1,5 @@
/*
-** $Id: lua.h,v 1.58 2000/08/14 19:10:14 roberto Exp roberto $
+** $Id: lua.h,v 1.59 2000/08/17 13:18:01 roberto Exp roberto $
** Lua - An Extensible Extension Language
** TeCGraf: Grupo de Tecnologia em Computacao Grafica, PUC-Rio, Brazil
** e-mail: lua@tecgraf.puc-rio.br
@@ -30,8 +30,10 @@
#define LUA_ANYTAG (-1)
+#define LUA_MULTRET (-1)
-/* error code for lua_do* */
+
+/* error codes for lua_do* */
#define LUA_ERRFILE 2
#define LUA_ERRSYNTAX 3
#define LUA_ERRRUN 1
@@ -40,95 +42,103 @@
typedef struct lua_State lua_State;
-typedef void (*lua_CFunction) (lua_State *L);
-
-typedef struct lua_TObject *lua_Object;
-
-#define LUA_NOOBJECT ((lua_Object)0)
+typedef int (*lua_CFunction) (lua_State *L);
+/*
+** state manipulation
+*/
lua_State *lua_newstate (int stacksize, int builtin);
void lua_close (lua_State *L);
-lua_Object lua_settagmethod (lua_State *L, int tag, const char *event);
- /* In: new method */
-lua_Object lua_gettagmethod (lua_State *L, int tag, const char *event);
-int lua_newtag (lua_State *L);
-int lua_copytagmethods (lua_State *L, int tagto, int tagfrom);
-void lua_settag (lua_State *L, int tag); /* In: object */
-
-void lua_error (lua_State *L, const char *s);
-int lua_dofile (lua_State *L, const char *filename);
- /* Out: returns */
-int lua_dostring (lua_State *L, const char *str);
- /* Out: returns */
-int lua_dobuffer (lua_State *L, const char *buff, size_t size,
- const char *name); /* Out: returns */
-int lua_callfunction (lua_State *L, lua_Object f);
- /* In: arguments; Out: returns */
-
-void lua_beginblock (lua_State *L);
-void lua_endblock (lua_State *L);
-
-void lua_pushglobals (lua_State *L);
-void lua_setglobals (lua_State *L, lua_Object newtable);
+/*
+** basic stack manipulation
+*/
+int lua_gettop (lua_State *L);
+void lua_settop (lua_State *L, int index);
+void lua_pushobject (lua_State *L, int index);
-lua_Object lua_lua2C (lua_State *L, int number);
-#define lua_getparam lua_lua2C
-#define lua_getresult lua_lua2C
-const char *lua_type (lua_State *L, lua_Object obj);
+/*
+** access functions (stack -> C)
+*/
-int lua_isnil (lua_State *L, lua_Object obj);
-int lua_istable (lua_State *L, lua_Object obj);
-int lua_isuserdata (lua_State *L, lua_Object obj);
-int lua_iscfunction (lua_State *L, lua_Object obj);
-int lua_isnumber (lua_State *L, lua_Object obj);
-int lua_isstring (lua_State *L, lua_Object obj);
-int lua_isfunction (lua_State *L, lua_Object obj);
+const char *lua_type (lua_State *L, int index);
+int lua_isnumber (lua_State *L, int index);
+int lua_iscfunction (lua_State *L, int index);
+int lua_tag (lua_State *L, int index);
-int lua_equal (lua_State *L, lua_Object o1, lua_Object o2);
+int lua_equal (lua_State *L, int index1, int index2);
-double lua_getnumber (lua_State *L, lua_Object obj);
-const char *lua_getstring (lua_State *L, lua_Object obj);
-size_t lua_strlen (lua_State *L, lua_Object obj);
-lua_CFunction lua_getcfunction (lua_State *L, lua_Object obj);
-void *lua_getuserdata (lua_State *L, lua_Object obj);
+double lua_tonumber (lua_State *L, int index);
+const char *lua_tostring (lua_State *L, int index);
+size_t lua_strlen (lua_State *L, int index);
+lua_CFunction lua_tocfunction (lua_State *L, int index);
+void *lua_touserdata (lua_State *L, int index);
-void lua_pushnil (lua_State *L);
+/*
+** push functions (C -> stack)
+*/
+void lua_pushnil (lua_State *L);
void lua_pushnumber (lua_State *L, double n);
void lua_pushlstring (lua_State *L, const char *s, size_t len);
void lua_pushstring (lua_State *L, const char *s);
void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
void lua_pushusertag (lua_State *L, void *u, int tag);
-void lua_pushobject (lua_State *L, lua_Object obj);
-lua_Object lua_pop (lua_State *L);
-lua_Object lua_getglobal (lua_State *L, const char *name);
-void lua_setglobal (lua_State *L, const char *name); /* In: value */
+/*
+** get functions (Lua -> stack)
+*/
+void lua_getglobal (lua_State *L, const char *name);
+void lua_gettable (lua_State *L);
+void lua_rawget (lua_State *L);
+void lua_getglobals (lua_State *L);
+void lua_gettagmethod (lua_State *L, int tag, const char *event);
-void lua_settable (lua_State *L); /* In: table, index, value */
-lua_Object lua_gettable (lua_State *L); /* In: table, index */
+int lua_getref (lua_State *L, int ref);
-void lua_rawset (lua_State *L); /* In: table, index, value */
-lua_Object lua_rawget (lua_State *L); /* In: table, index */
+void lua_newtable (lua_State *L);
-int lua_tag (lua_State *L, lua_Object obj);
-int lua_next (lua_State *L, lua_Object o, int i);
- /* Out: index, value */
+/*
+** set functions (stack -> Lua)
+*/
+void lua_setglobal (lua_State *L, const char *name);
+void lua_settable (lua_State *L);
+void lua_rawset (lua_State *L);
+void lua_setglobals (lua_State *L);
+void lua_settagmethod (lua_State *L, int tag, const char *event);
+int lua_ref (lua_State *L, int lock);
-int lua_ref (lua_State *L, int lock); /* In: value */
-int lua_pushref (lua_State *L, int ref); /* Out: value */
-void lua_unref (lua_State *L, int ref);
-lua_Object lua_createtable (lua_State *L);
+/*
+** "do" functions (run Lua code)
+*/
+int lua_call (lua_State *L, int nargs, int nresults);
+int lua_dofile (lua_State *L, const char *filename);
+int lua_dostring (lua_State *L, const char *str);
+int lua_dobuffer (lua_State *L, const char *buff, size_t size,
+ const char *name);
+
+
+/*
+** miscelaneous functions
+*/
+int lua_newtag (lua_State *L);
+int lua_copytagmethods (lua_State *L, int tagto, int tagfrom);
+void lua_settag (lua_State *L, int tag);
+
+void lua_error (lua_State *L, const char *s);
+
+void lua_unref (lua_State *L, int ref);
long lua_collectgarbage (lua_State *L, long limit);
+int lua_next (lua_State *L, int index, int i);
+
/*
@@ -137,122 +147,17 @@ long lua_collectgarbage (lua_State *L, long limit);
** ===============================================================
*/
-#ifndef LUA_SINGLESTATE
-
-#define lua_call(L,name) lua_callfunction(L, lua_getglobal(L, name))
-#define lua_getref(L, ref) (lua_pushref(L, ref) ? lua_pop(L) : LUA_NOOBJECT)
-#define lua_refobject(L,o,l) (lua_pushobject(L, o), lua_ref(L, l))
#define lua_register(L,n,f) (lua_pushcfunction(L, f), lua_setglobal(L, n))
#define lua_pushuserdata(L,u) lua_pushusertag(L, u, 0)
#define lua_pushcfunction(L,f) lua_pushcclosure(L, f, 0)
#define lua_clonetag(L,t) lua_copytagmethods(L, lua_newtag(L), (t))
-#else
-
-#define lua_call(name) lua_callfunction(lua_getglobal(name))
-#define lua_getref(ref) (lua_pushref(ref) ? lua_pop() : LUA_NOOBJECT)
-#define lua_refobject(o,l) (lua_pushobject(o), lua_ref(l))
-#define lua_register(n,f) (lua_pushcfunction(f), lua_setglobal(n))
-#define lua_pushuserdata(u) lua_pushusertag(u, 0)
-#define lua_pushcfunction(f) lua_pushcclosure(f, 0)
-#define lua_clonetag(t) lua_copytagmethods(lua_newtag(), (t))
-
-#endif
-
-
-
-#ifdef LUA_SINGLESTATE
-/*
-** {==============================================================
-** Macros for single-state use
-** ===============================================================
-*/
-
-extern lua_State *lua_state;
-
-#define lua_open() ((void)(lua_state?0:(lua_state=lua_newstate(0, 1))))
-
-#define lua_close() (lua_close)(lua_state)
-#define lua_settagmethod(tag,event) (lua_settagmethod)(lua_state, tag,event)
-#define lua_gettagmethod(tag,event) (lua_gettagmethod)(lua_state, tag,event)
-#define lua_newtag() (lua_newtag)(lua_state)
-#define lua_copytagmethods(tagto,tagfrom) \
- (lua_copytagmethods)(lua_state, tagto,tagfrom)
-#define lua_settag(tag) (lua_settag)(lua_state, tag)
-#define lua_error(s) (lua_error)(lua_state, s)
-#define lua_dofile(filename) (lua_dofile)(lua_state, filename)
-#define lua_dostring(str) (lua_dostring)(lua_state, str)
-#define lua_dobuffer(b,s,n) (lua_dobuffer)(lua_state, b,s,n)
-#define lua_callfunction(f) (lua_callfunction)(lua_state, f)
-#define lua_beginblock() (lua_beginblock)(lua_state)
-#define lua_endblock() (lua_endblock)(lua_state)
-#define lua_pushglobals() (lua_pushglobals)(lua_state)
-#define lua_setglobals(t) (lua_setglobals)(lua_state, t)
-#define lua_lua2C(number) (lua_lua2C)(lua_state, number)
-#define lua_type(obj) (lua_type)(lua_state, obj)
-#define lua_isnil(obj) (lua_isnil)(lua_state, obj)
-#define lua_istable(obj) (lua_istable)(lua_state, obj)
-#define lua_isuserdata(obj) (lua_isuserdata)(lua_state, obj)
-#define lua_iscfunction(obj) (lua_iscfunction)(lua_state, obj)
-#define lua_isnumber(obj) (lua_isnumber)(lua_state, obj)
-#define lua_isstring(obj) (lua_isstring)(lua_state, obj)
-#define lua_isfunction(obj) (lua_isfunction)(lua_state, obj)
-#define lua_equal(o1,o2) (lua_equal)(lua_state, o1,o2)
-#define lua_getnumber(obj) (lua_getnumber)(lua_state, obj)
-#define lua_getstring(obj) (lua_getstring)(lua_state, obj)
-#define lua_strlen(obj) (lua_strlen)(lua_state, obj)
-#define lua_getcfunction(obj) (lua_getcfunction)(lua_state, obj)
-#define lua_getuserdata(obj) (lua_getuserdata)(lua_state, obj)
-#define lua_pushnil() (lua_pushnil)(lua_state)
-#define lua_pushnumber(n) (lua_pushnumber)(lua_state, n)
-#define lua_pushlstring(s,len) (lua_pushlstring)(lua_state, s,len)
-#define lua_pushstring(s) (lua_pushstring)(lua_state, s)
-#define lua_pushusertag(u,tag) (lua_pushusertag)(lua_state, u,tag)
-#define lua_pushobject(obj) (lua_pushobject)(lua_state, obj)
-#define lua_pop() (lua_pop)(lua_state)
-#define lua_getglobal(name) (lua_getglobal)(lua_state, name)
-#define lua_setglobal(name) (lua_setglobal)(lua_state, name)
-#define lua_settable() (lua_settable)(lua_state)
-#define lua_gettable() (lua_gettable)(lua_state)
-#define lua_rawset() (lua_rawset)(lua_state)
-#define lua_rawget() (lua_rawget)(lua_state)
-#define lua_tag(obj) (lua_tag)(lua_state, obj)
-#define lua_next(o,i) (lua_next)(lua_state, o,i)
-#define lua_ref(lock) (lua_ref)(lua_state, lock)
-#define lua_pushref(ref) (lua_pushref)(lua_state, ref)
-#define lua_unref(ref) (lua_unref)(lua_state, ref)
-#define lua_createtable() (lua_createtable)(lua_state)
-#define lua_collectgarbage(limit) (lua_collectgarbage)(lua_state, limit)
-/*
-** the following typecast is a little dirty, but we know of no other
-** way to keep compatibility with old definition of `lua_CFunction'
-*/
-#define lua_pushcclosure(fn,n) \
- (lua_pushcclosure)(lua_state, (lua_CFunction)(fn), n)
-
-
-/*
-** }==============================================================
-*/
-#endif
-
-/*
-** compatibility with 3.2
-** these functions are only available when Lua is compiled with
-** the option LUA_DEPRECATETFUNCS
-*/
-
-#define lua_rawsettable lua_rawset
-#define lua_rawgettable lua_rawget
-
-lua_Object lua_rawgetglobal (lua_State *L, const char *name);
-void lua_rawsetglobal (lua_State *L, const char *name);/* In: value */
-
-#ifdef LUA_SINGLESTATE
-#define lua_rawgetglobal(name) (lua_rawgetglobal(lua_state, name))
-#define lua_rawsetglobal(name) (lua_rawsetglobal(lua_state, name))
-#endif
-
+#define lua_isfunction(L,n) (*lua_type(L,n) == 'f')
+#define lua_isstring(L,n) (lua_tostring(L,n))
+#define lua_istable(L,n) (*lua_type(L,n) == 't')
+#define lua_isuserdata(L,n) (*lua_type(L,n) == 'u')
+#define lua_isnil(L,n) (lua_type(L,n)[2] == 'l')
+#define lua_isnull(L,n) (*lua_type(L,n) == 'N')
#endif
diff --git a/luadebug.h b/luadebug.h
@@ -1,5 +1,5 @@
/*
-** $Id: luadebug.h,v 1.11 2000/08/08 20:42:07 roberto Exp roberto $
+** $Id: luadebug.h,v 1.12 2000/08/11 16:17:28 roberto Exp roberto $
** Debugging API
** See Copyright Notice in lua.h
*/
@@ -19,8 +19,8 @@ typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
int lua_getstack (lua_State *L, int level, lua_Debug *ar);
int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
-int lua_getlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v);
-int lua_setlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v);
+const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int localnum);
+const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int localnum);
lua_Hook lua_setcallhook (lua_State *L, lua_Hook func);
lua_Hook lua_setlinehook (lua_State *L, lua_Hook func);
@@ -36,16 +36,8 @@ struct lua_Debug {
const char *name; /* (n) */
const char *namewhat; /* (n) `global', `tag method', `local', `field' */
int nups; /* (u) number of upvalues */
- lua_Object func; /* (f) function being executed */
/* private part */
- lua_Object _func; /* active function */
-};
-
-
-struct lua_Localvar {
- int index;
- const char *name;
- lua_Object value;
+ struct lua_TObject *_func; /* active function */
};
diff --git a/lundump.c b/lundump.c
@@ -1,5 +1,5 @@
/*
-** $Id: lundump.c,v 1.24 2000/08/09 19:16:57 roberto Exp roberto $
+** $Id: lundump.c,v 1.25 2000/08/24 14:19:39 roberto Exp roberto $
** load bytecodes from files
** See Copyright Notice in lua.h
*/
@@ -130,7 +130,7 @@ static void LoadCode (lua_State* L, Proto* tf, ZIO* Z)
}
static void LoadLocals (lua_State* L, Proto* tf, ZIO* Z)
-{
+{
}
static Proto* LoadFunction (lua_State* L, ZIO* Z, int native);