summaryrefslogtreecommitdiff
path: root/src/lapi.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/lapi.c')
-rw-r--r--src/lapi.c796
1 files changed, 298 insertions, 498 deletions
diff --git a/src/lapi.c b/src/lapi.c
index 16bd9ff9..e8002342 100644
--- a/src/lapi.c
+++ b/src/lapi.c
@@ -1,15 +1,15 @@
/*
-** $Id: lapi.c,v 1.47b 1999/06/22 20:37:23 roberto Exp $
+** $Id: lapi.c,v 1.110 2000/10/30 12:50:09 roberto Exp $
** Lua API
** See Copyright Notice in lua.h
*/
-#include <stdlib.h>
#include <string.h>
+#include "lua.h"
+
#include "lapi.h"
-#include "lauxlib.h"
#include "ldo.h"
#include "lfunc.h"
#include "lgc.h"
@@ -19,676 +19,476 @@
#include "lstring.h"
#include "ltable.h"
#include "ltm.h"
-#include "lua.h"
-#include "luadebug.h"
#include "lvm.h"
-char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
- "$Authors: " LUA_AUTHORS " $";
-
-
-
-TObject *luaA_Address (lua_Object o) {
- return (o != LUA_NOOBJECT) ? Address(o) : NULL;
-}
-
-
-static lua_Type normalized_type (TObject *o)
-{
- int t = ttype(o);
- switch (t) {
- case LUA_T_PMARK:
- return LUA_T_PROTO;
- case LUA_T_CMARK:
- return LUA_T_CPROTO;
- case LUA_T_CLMARK:
- return LUA_T_CLOSURE;
- default:
- return t;
- }
-}
+const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
+ "$Authors: " LUA_AUTHORS " $";
-static void set_normalized (TObject *d, TObject *s)
-{
- d->value = s->value;
- d->ttype = normalized_type(s);
-}
+#define Index(L,i) ((i) >= 0 ? (L->Cbase+((i)-1)) : (L->top+(i)))
-static TObject *luaA_protovalue (TObject *o)
-{
- return (normalized_type(o) == LUA_T_CLOSURE) ? protovalue(o) : o;
-}
+#define api_incr_top(L) incr_top
-void luaA_packresults (void)
-{
- luaV_pack(L->Cstack.lua2C, L->Cstack.num, L->stack.top);
- incr_top;
-}
-int luaA_passresults (void) {
- L->Cstack.base = L->Cstack.lua2C; /* position of first result */
- return L->Cstack.num;
+TObject *luaA_index (lua_State *L, int index) {
+ return Index(L, index);
}
-static void checkCparams (int nParams)
-{
- if (L->stack.top-L->stack.stack < L->Cstack.base+nParams)
- lua_error("API error - wrong number of arguments in C2lua stack");
-}
-
-
-static lua_Object put_luaObject (TObject *o) {
- luaD_openstack((L->stack.top-L->stack.stack)-L->Cstack.base);
- L->stack.stack[L->Cstack.base++] = *o;
- return L->Cstack.base; /* this is +1 real position (see Ref) */
+static TObject *luaA_indexAcceptable (lua_State *L, int index) {
+ if (index >= 0) {
+ TObject *o = L->Cbase+(index-1);
+ if (o >= L->top) return NULL;
+ else return o;
+ }
+ else return L->top+index;
}
-static lua_Object put_luaObjectonTop (void) {
- luaD_openstack((L->stack.top-L->stack.stack)-L->Cstack.base);
- L->stack.stack[L->Cstack.base++] = *(--L->stack.top);
- return L->Cstack.base; /* this is +1 real position (see Ref) */
+void luaA_pushobject (lua_State *L, const TObject *o) {
+ *L->top = *o;
+ incr_top;
}
-
-static void top2LC (int n) {
- /* Put the 'n' elements on the top as the Lua2C contents */
- L->Cstack.base = (L->stack.top-L->stack.stack); /* new base */
- L->Cstack.lua2C = L->Cstack.base-n; /* position of the new results */
- L->Cstack.num = n; /* number of results */
+LUA_API int lua_stackspace (lua_State *L) {
+ return (L->stack_last - L->top);
}
-lua_Object lua_pop (void) {
- checkCparams(1);
- return put_luaObjectonTop();
-}
-
/*
-** 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 (int number)
-{
- if (number <= 0 || number > L->Cstack.num) return LUA_NOOBJECT;
- /* Ref(L->stack.stack+(L->Cstack.lua2C+number-1)) ==
- L->stack.stack+(L->Cstack.lua2C+number-1)-L->stack.stack+1 == */
- return L->Cstack.lua2C+number;
-}
-int lua_callfunction (lua_Object function)
-{
- if (function == LUA_NOOBJECT)
- return 1;
- else {
- luaD_openstack((L->stack.top-L->stack.stack)-L->Cstack.base);
- set_normalized(L->stack.stack+L->Cstack.base, Address(function));
- return luaD_protectedrun();
- }
+LUA_API int lua_gettop (lua_State *L) {
+ return (L->top - L->Cbase);
}
-lua_Object lua_gettagmethod (int tag, char *event)
-{
- return put_luaObject(luaT_gettagmethod(tag, event));
+LUA_API void lua_settop (lua_State *L, int index) {
+ if (index >= 0)
+ luaD_adjusttop(L, L->Cbase, index);
+ else
+ L->top = L->top+index+1; /* index is negative */
}
-lua_Object lua_settagmethod (int tag, char *event)
-{
- checkCparams(1);
- luaT_settagmethod(tag, event, L->stack.top-1);
- return put_luaObjectonTop();
+LUA_API void lua_remove (lua_State *L, int index) {
+ StkId p = luaA_index(L, index);
+ while (++p < L->top) *(p-1) = *p;
+ L->top--;
}
-lua_Object lua_seterrormethod (void) {
- lua_Object temp;
- checkCparams(1);
- temp = lua_getglobal("_ERRORMESSAGE");
- lua_setglobal("_ERRORMESSAGE");
- return temp;
+LUA_API void lua_insert (lua_State *L, int index) {
+ StkId p = luaA_index(L, index);
+ StkId q;
+ for (q = L->top; q>p; q--)
+ *q = *(q-1);
+ *p = *L->top;
}
-lua_Object lua_gettable (void)
-{
- checkCparams(2);
- luaV_gettable();
- return put_luaObjectonTop();
+LUA_API void lua_pushvalue (lua_State *L, int index) {
+ *L->top = *luaA_index(L, index);
+ api_incr_top(L);
}
-lua_Object lua_rawgettable (void) {
- checkCparams(2);
- if (ttype(L->stack.top-2) != LUA_T_ARRAY)
- lua_error("indexed expression not a table in rawgettable");
- *(L->stack.top-2) = *luaH_get(avalue(L->stack.top-2), L->stack.top-1);
- --L->stack.top;
- return put_luaObjectonTop();
-}
-
-void lua_settable (void) {
- checkCparams(3);
- luaD_checkstack(3); /* may need that to call T.M. */
- luaV_settable(L->stack.top-3);
- L->stack.top -= 2; /* pop table and index */
-}
+/*
+** access functions (stack -> C)
+*/
-void lua_rawsettable (void) {
- checkCparams(3);
- luaV_rawsettable(L->stack.top-3);
+LUA_API int lua_type (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL) ? LUA_TNONE : ttype(o);
}
-
-lua_Object lua_createtable (void)
-{
- TObject o;
- luaC_checkGC();
- avalue(&o) = luaH_new(0);
- ttype(&o) = LUA_T_ARRAY;
- return put_luaObject(&o);
+LUA_API const char *lua_typename (lua_State *L, int t) {
+ UNUSED(L);
+ return (t == LUA_TNONE) ? "no value" : luaO_typenames[t];
}
-lua_Object lua_getglobal (char *name)
-{
- luaD_checkstack(2); /* may need that to call T.M. */
- luaV_getglobal(luaS_new(name));
- return put_luaObjectonTop();
+LUA_API int lua_iscfunction (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL) ? 0 : iscfunction(o);
}
+LUA_API int lua_isnumber (lua_State *L, int index) {
+ TObject *o = luaA_indexAcceptable(L, index);
+ return (o == NULL) ? 0 : (tonumber(o) == 0);
+}
-lua_Object lua_rawgetglobal (char *name)
-{
- TaggedString *ts = luaS_new(name);
- return put_luaObject(&ts->u.s.globalval);
+LUA_API int lua_isstring (lua_State *L, int index) {
+ int t = lua_type(L, index);
+ return (t == LUA_TSTRING || t == LUA_TNUMBER);
}
-void lua_setglobal (char *name)
-{
- checkCparams(1);
- luaD_checkstack(2); /* may need that to call T.M. */
- luaV_setglobal(luaS_new(name));
+LUA_API int lua_tag (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL) ? LUA_NOTAG : luaT_tag(o);
}
+LUA_API int lua_equal (lua_State *L, int index1, int index2) {
+ StkId o1 = luaA_indexAcceptable(L, index1);
+ StkId o2 = luaA_indexAcceptable(L, index2);
+ if (o1 == NULL || o2 == NULL) return 0; /* index out-of-range */
+ else return luaO_equalObj(o1, o2);
+}
-void lua_rawsetglobal (char *name)
-{
- TaggedString *ts = luaS_new(name);
- checkCparams(1);
- luaS_rawsetglobal(ts, --L->stack.top);
+LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {
+ StkId o1 = luaA_indexAcceptable(L, index1);
+ StkId o2 = luaA_indexAcceptable(L, index2);
+ if (o1 == NULL || o2 == NULL) return 0; /* index out-of-range */
+ else return luaV_lessthan(L, o1, o2, L->top);
}
-int lua_isnil (lua_Object o)
-{
- return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_NIL);
+LUA_API double lua_tonumber (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL || tonumber(o)) ? 0 : nvalue(o);
}
-int lua_istable (lua_Object o)
-{
- return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_ARRAY);
+LUA_API const char *lua_tostring (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL || tostring(L, o)) ? NULL : svalue(o);
}
-int lua_isuserdata (lua_Object o)
-{
- return (o!= LUA_NOOBJECT) && (ttype(Address(o)) == LUA_T_USERDATA);
+LUA_API size_t lua_strlen (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL || tostring(L, o)) ? 0 : tsvalue(o)->len;
}
-int lua_iscfunction (lua_Object o)
-{
- return (lua_tag(o) == LUA_T_CPROTO);
+LUA_API lua_CFunction lua_tocfunction (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL || !iscfunction(o)) ? NULL : clvalue(o)->f.c;
}
-int lua_isnumber (lua_Object o)
-{
- return (o!= LUA_NOOBJECT) && (tonumber(Address(o)) == 0);
+LUA_API void *lua_touserdata (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ return (o == NULL || ttype(o) != LUA_TUSERDATA) ? NULL :
+ tsvalue(o)->u.d.value;
}
-int lua_isstring (lua_Object o)
-{
- int t = lua_tag(o);
- return (t == LUA_T_STRING) || (t == LUA_T_NUMBER);
+LUA_API const void *lua_topointer (lua_State *L, int index) {
+ StkId o = luaA_indexAcceptable(L, index);
+ if (o == NULL) return NULL;
+ switch (ttype(o)) {
+ case LUA_TTABLE:
+ return hvalue(o);
+ case LUA_TFUNCTION:
+ return clvalue(o);
+ default: return NULL;
+ }
}
-int lua_isfunction (lua_Object o)
-{
- int t = lua_tag(o);
- return (t == LUA_T_PROTO) || (t == LUA_T_CPROTO);
-}
-double lua_getnumber (lua_Object object)
-{
- if (object == LUA_NOOBJECT) return 0.0;
- if (tonumber(Address(object))) return 0.0;
- else return (nvalue(Address(object)));
-}
+/*
+** push functions (C -> stack)
+*/
-char *lua_getstring (lua_Object object)
-{
- luaC_checkGC(); /* "tostring" may create a new string */
- if (object == LUA_NOOBJECT || tostring(Address(object)))
- return NULL;
- else return (svalue(Address(object)));
-}
-long lua_strlen (lua_Object object)
-{
- luaC_checkGC(); /* "tostring" may create a new string */
- if (object == LUA_NOOBJECT || tostring(Address(object)))
- return 0L;
- else return (tsvalue(Address(object))->u.s.len);
+LUA_API void lua_pushnil (lua_State *L) {
+ ttype(L->top) = LUA_TNIL;
+ api_incr_top(L);
}
-void *lua_getuserdata (lua_Object object)
-{
- if (object == LUA_NOOBJECT || ttype(Address(object)) != LUA_T_USERDATA)
- return NULL;
- else return tsvalue(Address(object))->u.d.v;
-}
-lua_CFunction lua_getcfunction (lua_Object object)
-{
- if (!lua_iscfunction(object))
- return NULL;
- else return fvalue(luaA_protovalue(Address(object)));
+LUA_API void lua_pushnumber (lua_State *L, double n) {
+ nvalue(L->top) = n;
+ ttype(L->top) = LUA_TNUMBER;
+ api_incr_top(L);
}
-void lua_pushnil (void)
-{
- ttype(L->stack.top) = LUA_T_NIL;
- incr_top;
+LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {
+ tsvalue(L->top) = luaS_newlstr(L, s, len);
+ ttype(L->top) = LUA_TSTRING;
+ api_incr_top(L);
}
-void lua_pushnumber (double n)
-{
- ttype(L->stack.top) = LUA_T_NUMBER;
- nvalue(L->stack.top) = n;
- incr_top;
-}
-void lua_pushlstring (char *s, long len)
-{
- tsvalue(L->stack.top) = luaS_newlstr(s, len);
- ttype(L->stack.top) = LUA_T_STRING;
- incr_top;
- luaC_checkGC();
-}
-
-void lua_pushstring (char *s)
-{
+LUA_API void lua_pushstring (lua_State *L, const char *s) {
if (s == NULL)
- lua_pushnil();
+ lua_pushnil(L);
else
- lua_pushlstring(s, strlen(s));
+ lua_pushlstring(L, s, strlen(s));
}
-void lua_pushcclosure (lua_CFunction fn, int n)
-{
- if (fn == NULL)
- lua_error("API error - attempt to push a NULL Cfunction");
- checkCparams(n);
- ttype(L->stack.top) = LUA_T_CPROTO;
- fvalue(L->stack.top) = fn;
- incr_top;
- luaV_closure(n);
- luaC_checkGC();
-}
-void lua_pushusertag (void *u, int tag)
-{
- if (tag < 0 && tag != LUA_ANYTAG)
- luaT_realtag(tag); /* error if tag is not valid */
- tsvalue(L->stack.top) = luaS_createudata(u, tag);
- ttype(L->stack.top) = LUA_T_USERDATA;
- incr_top;
- luaC_checkGC();
+LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
+ luaV_Cclosure(L, fn, n);
}
-void luaA_pushobject (TObject *o)
-{
- *L->stack.top = *o;
- incr_top;
-}
-void lua_pushobject (lua_Object o) {
- if (o == LUA_NOOBJECT)
- lua_error("API error - attempt to push a NOOBJECT");
- set_normalized(L->stack.top, Address(o));
- incr_top;
+LUA_API void lua_pushusertag (lua_State *L, void *u, int tag) {
+ /* ORDER LUA_T */
+ if (!(tag == LUA_ANYTAG || tag == LUA_TUSERDATA || validtag(tag)))
+ luaO_verror(L, "invalid tag for a userdata (%d)", tag);
+ tsvalue(L->top) = luaS_createudata(L, u, tag);
+ ttype(L->top) = LUA_TUSERDATA;
+ api_incr_top(L);
}
-int lua_tag (lua_Object lo)
-{
- if (lo == LUA_NOOBJECT)
- return LUA_T_NIL;
- else {
- TObject *o = Address(lo);
- int t;
- switch (t = ttype(o)) {
- case LUA_T_USERDATA:
- return o->value.ts->u.d.tag;
- case LUA_T_ARRAY:
- return o->value.a->htag;
- case LUA_T_PMARK:
- return LUA_T_PROTO;
- case LUA_T_CMARK:
- return LUA_T_CPROTO;
- case LUA_T_CLOSURE: case LUA_T_CLMARK:
- return o->value.cl->consts[0].ttype;
-#ifdef DEBUG
- case LUA_T_LINE:
- LUA_INTERNALERROR("invalid type");
-#endif
- default:
- return t;
- }
- }
-}
-
-void lua_settag (int tag)
-{
- checkCparams(1);
- luaT_realtag(tag);
- switch (ttype(L->stack.top-1)) {
- case LUA_T_ARRAY:
- (L->stack.top-1)->value.a->htag = tag;
- break;
- case LUA_T_USERDATA:
- (L->stack.top-1)->value.ts->u.d.tag = tag;
- break;
- default:
- luaL_verror("cannot change the tag of a %.20s",
- luaO_typename(L->stack.top-1));
- }
- L->stack.top--;
-}
+/*
+** get functions (Lua -> stack)
+*/
-TaggedString *luaA_nextvar (TaggedString *g) {
- if (g == NULL)
- g = (TaggedString *)L->rootglobal.next; /* first variable */
- else {
- /* check whether name is in global var list */
- luaL_arg_check((GCnode *)g != g->head.next, 1, "variable name expected");
- g = (TaggedString *)g->head.next; /* get next */
- }
- while (g && g->u.s.globalval.ttype == LUA_T_NIL) /* skip globals with nil */
- g = (TaggedString *)g->head.next;
- if (g) {
- ttype(L->stack.top) = LUA_T_STRING; tsvalue(L->stack.top) = g;
- incr_top;
- luaA_pushobject(&g->u.s.globalval);
- }
- return g;
+LUA_API void lua_getglobal (lua_State *L, const char *name) {
+ StkId top = L->top;
+ *top = *luaV_getglobal(L, luaS_new(L, name));
+ L->top = top;
+ api_incr_top(L);
}
-char *lua_nextvar (char *varname) {
- TaggedString *g = (varname == NULL) ? NULL : luaS_new(varname);
- g = luaA_nextvar(g);
- if (g) {
- top2LC(2);
- return g->str;
- }
- else {
- top2LC(0);
- return NULL;
- }
+LUA_API void lua_gettable (lua_State *L, int index) {
+ StkId t = Index(L, index);
+ StkId top = L->top;
+ *(top-1) = *luaV_gettable(L, t);
+ L->top = top; /* tag method may change top */
}
-int luaA_next (Hash *t, int i) {
- int tsize = nhash(t);
- for (; i<tsize; i++) {
- Node *n = node(t, i);
- if (ttype(val(n)) != LUA_T_NIL) {
- luaA_pushobject(ref(n));
- luaA_pushobject(val(n));
- return i+1; /* index to be used next time */
- }
- }
- return 0; /* no more elements */
+LUA_API void lua_rawget (lua_State *L, int index) {
+ StkId t = Index(L, index);
+ LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
+ *(L->top - 1) = *luaH_get(L, hvalue(t), L->top - 1);
}
-int lua_next (lua_Object o, int i) {
- TObject *t = Address(o);
- if (ttype(t) != LUA_T_ARRAY)
- lua_error("API error - object is not a table in `lua_next'");
- i = luaA_next(avalue(t), i);
- top2LC((i==0) ? 0 : 2);
- return i;
+LUA_API void lua_rawgeti (lua_State *L, int index, int n) {
+ StkId o = Index(L, index);
+ LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected");
+ *L->top = *luaH_getnum(hvalue(o), n);
+ api_incr_top(L);
}
-
-/*
-** {======================================================
-** To manipulate some state information
-** =======================================================
-*/
-
-lua_State *lua_setstate (lua_State *st) {
- lua_State *old = lua_state;
- lua_state = st;
- return old;
+LUA_API void lua_getglobals (lua_State *L) {
+ hvalue(L->top) = L->gt;
+ ttype(L->top) = LUA_TTABLE;
+ api_incr_top(L);
}
-lua_LHFunction lua_setlinehook (lua_LHFunction func) {
- lua_LHFunction old = L->linehook;
- L->linehook = func;
- return old;
-}
-lua_CHFunction lua_setcallhook (lua_CHFunction func) {
- lua_CHFunction old = L->callhook;
- L->callhook = func;
- return old;
+LUA_API int lua_getref (lua_State *L, int ref) {
+ if (ref == LUA_REFNIL)
+ ttype(L->top) = LUA_TNIL;
+ 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;
+ api_incr_top(L);
+ return 1;
}
-int lua_setdebug (int debug) {
- int old = L->debug;
- L->debug = debug;
- return old;
+
+LUA_API void lua_newtable (lua_State *L) {
+ hvalue(L->top) = luaH_new(L, 0);
+ ttype(L->top) = LUA_TTABLE;
+ api_incr_top(L);
}
-/* }====================================================== */
/*
-** {======================================================
-** Debug interface
-** =======================================================
+** set functions (stack -> Lua)
*/
-lua_Function lua_stackedfunction (int level)
-{
- StkId i;
- for (i = (L->stack.top-1)-L->stack.stack; i>=0; i--) {
- int t = L->stack.stack[i].ttype;
- if (t == LUA_T_CLMARK || t == LUA_T_PMARK || t == LUA_T_CMARK)
- if (level-- == 0)
- return Ref(L->stack.stack+i);
- }
- return LUA_NOOBJECT;
+LUA_API void lua_setglobal (lua_State *L, const char *name) {
+ StkId top = L->top;
+ luaV_setglobal(L, luaS_new(L, name));
+ L->top = top-1; /* remove element from the top */
}
-int lua_nups (lua_Function func) {
- TObject *o = luaA_Address(func);
- return (!o || normalized_type(o) != LUA_T_CLOSURE) ? 0 : o->value.cl->nelems;
+LUA_API void lua_settable (lua_State *L, int index) {
+ StkId t = Index(L, index);
+ StkId top = L->top;
+ luaV_settable(L, t, top-2);
+ L->top = top-2; /* pop index and value */
}
-int lua_currentline (lua_Function func)
-{
- TObject *f = Address(func);
- return (f+1 < L->stack.top && (f+1)->ttype == LUA_T_LINE) ?
- (f+1)->value.i : -1;
+LUA_API void lua_rawset (lua_State *L, int index) {
+ StkId t = Index(L, index);
+ LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
+ *luaH_set(L, hvalue(t), L->top-2) = *(L->top-1);
+ L->top -= 2;
}
-lua_Object lua_getlocal (lua_Function func, int local_number, char **name) {
- /* check whether func is a Lua function */
- if (lua_tag(func) != LUA_T_PROTO)
- return LUA_NOOBJECT;
- else {
- TObject *f = Address(func);
- TProtoFunc *fp = luaA_protovalue(f)->value.tf;
- *name = luaF_getlocalname(fp, local_number, lua_currentline(func));
- if (*name) {
- /* if "*name", there must be a LUA_T_LINE */
- /* therefore, f+2 points to function base */
- return put_luaObject((f+2)+(local_number-1));
- }
- else
- return LUA_NOOBJECT;
- }
+LUA_API void lua_rawseti (lua_State *L, int index, int n) {
+ StkId o = Index(L, index);
+ LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected");
+ *luaH_setint(L, hvalue(o), n) = *(L->top-1);
+ L->top--;
}
-int lua_setlocal (lua_Function func, int local_number)
-{
- /* check whether func is a Lua function */
- if (lua_tag(func) != LUA_T_PROTO)
- return 0;
- else {
- TObject *f = Address(func);
- TProtoFunc *fp = luaA_protovalue(f)->value.tf;
- char *name = luaF_getlocalname(fp, local_number, lua_currentline(func));
- checkCparams(1);
- --L->stack.top;
- if (name) {
- /* if "name", there must be a LUA_T_LINE */
- /* therefore, f+2 points to function base */
- *((f+2)+(local_number-1)) = *L->stack.top;
- return 1;
- }
- else
- return 0;
- }
+LUA_API void lua_setglobals (lua_State *L) {
+ StkId newtable = --L->top;
+ LUA_ASSERT(ttype(newtable) == LUA_TTABLE, "table expected");
+ L->gt = hvalue(newtable);
}
-void lua_funcinfo (lua_Object func, char **source, int *linedefined) {
- if (!lua_isfunction(func))
- lua_error("API error - `funcinfo' called with a non-function value");
+LUA_API int lua_ref (lua_State *L, int lock) {
+ int ref;
+ if (ttype(L->top-1) == LUA_TNIL)
+ ref = LUA_REFNIL;
else {
- TObject *f = luaA_protovalue(Address(func));
- if (normalized_type(f) == LUA_T_PROTO) {
- *source = tfvalue(f)->source->str;
- *linedefined = tfvalue(f)->lineDefined;
+ if (L->refFree != NONEXT) { /* is there a free place? */
+ ref = L->refFree;
+ L->refFree = L->refArray[ref].st;
}
- else {
- *source = "(C)";
- *linedefined = -1;
+ else { /* no more free places */
+ luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref,
+ "reference table overflow", MAX_INT);
+ L->nblocks += sizeof(struct Ref);
+ ref = L->refSize++;
}
+ L->refArray[ref].o = *(L->top-1);
+ L->refArray[ref].st = lock ? LOCK : HOLD;
}
+ L->top--;
+ return ref;
}
-static int checkfunc (TObject *o)
-{
- return luaO_equalObj(o, L->stack.top);
-}
-
+/*
+** "do" functions (run Lua code)
+** (most of them are in ldo.c)
+*/
-char *lua_getobjname (lua_Object o, char **name)
-{ /* try to find a name for given function */
- set_normalized(L->stack.top, Address(o)); /* to be accessed by "checkfunc" */
- if ((*name = luaS_travsymbol(checkfunc)) != NULL)
- return "global";
- else if ((*name = luaT_travtagmethods(checkfunc)) != NULL)
- return "tag-method";
- else return "";
+LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults) {
+ luaD_call(L, L->top-(nargs+1), nresults);
}
-/* }====================================================== */
-
/*
-** {======================================================
-** BLOCK mechanism
-** =======================================================
+** Garbage-collection functions
*/
+/* GC values are expressed in Kbytes: #bytes/2^10 */
+#define GCscale(x) ((int)((x)>>10))
+#define GCunscale(x) ((unsigned long)(x)<<10)
-#ifndef MAX_C_BLOCKS
-#define MAX_C_BLOCKS 1000 /* arbitrary limit */
-#endif
-
+LUA_API int lua_getgcthreshold (lua_State *L) {
+ return GCscale(L->GCthreshold);
+}
-void lua_beginblock (void) {
- luaM_growvector(L->Cblocks, L->numCblocks, 1, struct C_Lua_Stack,
- "too many nested blocks", MAX_C_BLOCKS);
- L->Cblocks[L->numCblocks] = L->Cstack;
- L->numCblocks++;
+LUA_API int lua_getgccount (lua_State *L) {
+ return GCscale(L->nblocks);
}
-void lua_endblock (void) {
- --L->numCblocks;
- L->Cstack = L->Cblocks[L->numCblocks];
- luaD_adjusttop(L->Cstack.base);
+LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) {
+ if (newthreshold > GCscale(ULONG_MAX))
+ L->GCthreshold = ULONG_MAX;
+ else
+ L->GCthreshold = GCunscale(newthreshold);
+ luaC_checkGC(L);
}
+/*
+** miscellaneous functions
+*/
-int lua_ref (int lock) {
- int ref;
- checkCparams(1);
- ref = luaC_ref(L->stack.top-1, lock);
- L->stack.top--;
- return ref;
+LUA_API void lua_settag (lua_State *L, int tag) {
+ luaT_realtag(L, tag);
+ switch (ttype(L->top-1)) {
+ case LUA_TTABLE:
+ hvalue(L->top-1)->htag = tag;
+ break;
+ case LUA_TUSERDATA:
+ tsvalue(L->top-1)->u.d.tag = tag;
+ break;
+ default:
+ luaO_verror(L, "cannot change the tag of a %.20s",
+ luaO_typename(L->top-1));
+ }
}
-
-lua_Object lua_getref (int ref) {
- TObject *o = luaC_getref(ref);
- return (o ? put_luaObject(o) : LUA_NOOBJECT);
+LUA_API void lua_unref (lua_State *L, int ref) {
+ if (ref >= 0) {
+ LUA_ASSERT(ref < L->refSize && L->refArray[ref].st < 0, "invalid ref");
+ L->refArray[ref].st = L->refFree;
+ L->refFree = ref;
+ }
}
-/* }====================================================== */
+LUA_API int lua_next (lua_State *L, int index) {
+ StkId t = luaA_index(L, index);
+ Node *n;
+ LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
+ n = luaH_next(L, hvalue(t), luaA_index(L, -1));
+ if (n) {
+ *(L->top-1) = *key(n);
+ *L->top = *val(n);
+ api_incr_top(L);
+ return 1;
+ }
+ else { /* no more elements */
+ L->top -= 1; /* remove key */
+ return 0;
+ }
+}
-#ifdef LUA_COMPAT2_5
-/*
-** API: set a function as a fallback
-*/
+LUA_API int lua_getn (lua_State *L, int index) {
+ Hash *h = hvalue(luaA_index(L, index));
+ const TObject *value = luaH_getstr(h, luaS_new(L, "n")); /* value = h.n */
+ if (ttype(value) == LUA_TNUMBER)
+ return (int)nvalue(value);
+ else {
+ Number max = 0;
+ int i = h->size;
+ Node *n = h->node;
+ while (i--) {
+ if (ttype(key(n)) == LUA_TNUMBER &&
+ ttype(val(n)) != LUA_TNIL &&
+ nvalue(key(n)) > max)
+ max = nvalue(key(n));
+ n++;
+ }
+ return (int)max;
+ }
+}
+
-static void do_unprotectedrun (lua_CFunction f, int nParams, int nResults) {
- luaD_openstack(nParams);
- (L->stack.top-nParams)->ttype = LUA_T_CPROTO;
- (L->stack.top-nParams)->value.f = f;
- luaD_calln(nParams, nResults);
+LUA_API void lua_concat (lua_State *L, int n) {
+ StkId top = L->top;
+ luaV_strconc(L, n, top);
+ L->top = top-(n-1);
+ luaC_checkGC(L);
}
-lua_Object lua_setfallback (char *name, lua_CFunction fallback) {
- lua_pushstring(name);
- lua_pushcfunction(fallback);
- do_unprotectedrun(luaT_setfallback, 2, 1);
- return put_luaObjectonTop();
+LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
+ TString *ts = luaS_newudata(L, size, NULL);
+ tsvalue(L->top) = ts;
+ ttype(L->top) = LUA_TUSERDATA;
+ api_incr_top(L);
+ return ts->u.d.value;
}
-#endif
View Lorry Controller Status