mirror of https://github.com/rusefi/lua.git
new definition for types-tags
This commit is contained in:
Roberto Ierusalimschy
parent
cd2ddaded9
commit
001f2bdd0e
77
lapi.c
77
lapi.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lapi.c,v 1.103 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** $Id: lapi.c,v 1.104 2000/10/03 14:27:44 roberto Exp roberto $
|
||||
** Lua API
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -116,20 +116,18 @@ void lua_pushvalue (lua_State *L, int index) {
|
|||
return ((test) ? (value) : (default)); }
|
||||
|
||||
|
||||
lua_Type lua_type (lua_State *L, int index) {
|
||||
btest(L, index, luaO_type(o), LUA_NOVALUE);
|
||||
int lua_type (lua_State *L, int index) {
|
||||
btest(L, index, ttype(o), LUA_TNONE);
|
||||
}
|
||||
|
||||
const char *lua_typename (lua_State *L, lua_Type t) {
|
||||
static const char *const names[] = {
|
||||
"NO VALUE", "userdata", "number", "string", "table", "function", "nil"
|
||||
};
|
||||
const char *lua_typename (lua_State *L, int t) {
|
||||
UNUSED(L);
|
||||
return names[(int)t];
|
||||
return luaO_typenames[t];
|
||||
}
|
||||
|
||||
|
||||
int lua_iscfunction (lua_State *L, int index) {
|
||||
btest(L, index, (ttype(o) == TAG_CCLOSURE), 0);
|
||||
btest(L, index, iscfunction(o), 0);
|
||||
}
|
||||
|
||||
int lua_isnumber (lua_State *L, int index) {
|
||||
|
|
@ -137,18 +135,13 @@ int lua_isnumber (lua_State *L, int index) {
|
|||
}
|
||||
|
||||
int lua_isstring (lua_State *L, int index) {
|
||||
lua_Type t = lua_type(L, index);
|
||||
int t = lua_type(L, index);
|
||||
return (t == LUA_TSTRING || t == LUA_TNUMBER);
|
||||
}
|
||||
|
||||
|
||||
static int auxtag (const TObject *o) {
|
||||
return ((ttype(o) == TAG_USERDATA) ? tsvalue(o)->u.d.tag :
|
||||
(ttype(o) == TAG_TABLE) ? hvalue(o)->htag : (int)ttype(o));
|
||||
}
|
||||
|
||||
int lua_tag (lua_State *L, int index) {
|
||||
btest(L, index, auxtag(o), LUA_NOTAG);
|
||||
btest(L, index, luaT_tag(o), LUA_NOTAG);
|
||||
}
|
||||
|
||||
int lua_equal (lua_State *L, int index1, int index2) {
|
||||
|
|
@ -168,7 +161,7 @@ int lua_lessthan (lua_State *L, int index1, int index2) {
|
|||
|
||||
|
||||
double lua_tonumber (lua_State *L, int index) {
|
||||
access(L, index, (tonumber(o) == 0), 0.0, nvalue(o));
|
||||
access(L, index, (tonumber(o) == 0), 0, nvalue(o));
|
||||
}
|
||||
|
||||
const char *lua_tostring (lua_State *L, int index) {
|
||||
|
|
@ -180,19 +173,19 @@ size_t lua_strlen (lua_State *L, int index) {
|
|||
}
|
||||
|
||||
lua_CFunction lua_tocfunction (lua_State *L, int index) {
|
||||
access(L, index, (ttype(o) == TAG_CCLOSURE), NULL, clvalue(o)->f.c);
|
||||
access(L, index, iscfunction(o), NULL, clvalue(o)->f.c);
|
||||
}
|
||||
|
||||
void *lua_touserdata (lua_State *L, int index) {
|
||||
access(L, index, (ttype(o) == TAG_USERDATA), NULL, tsvalue(o)->u.d.value);
|
||||
access(L, index, (ttype(o) == LUA_TUSERDATA), NULL, tsvalue(o)->u.d.value);
|
||||
}
|
||||
|
||||
const void *lua_topointer (lua_State *L, int index) {
|
||||
StkId o = Index(L, index);
|
||||
switch (ttype(o)) {
|
||||
case TAG_TABLE:
|
||||
case LUA_TTABLE:
|
||||
return hvalue(o);
|
||||
case TAG_CCLOSURE: case TAG_LCLOSURE:
|
||||
case LUA_TFUNCTION:
|
||||
return clvalue(o);
|
||||
default: return NULL;
|
||||
}
|
||||
|
|
@ -206,13 +199,13 @@ const void *lua_topointer (lua_State *L, int index) {
|
|||
|
||||
|
||||
void lua_pushnil (lua_State *L) {
|
||||
ttype(L->top) = TAG_NIL;
|
||||
ttype(L->top) = LUA_TNIL;
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
||||
|
||||
void lua_pushnumber (lua_State *L, double n) {
|
||||
ttype(L->top) = TAG_NUMBER;
|
||||
ttype(L->top) = LUA_TNUMBER;
|
||||
nvalue(L->top) = n;
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
|
@ -220,7 +213,7 @@ void lua_pushnumber (lua_State *L, double n) {
|
|||
|
||||
void lua_pushlstring (lua_State *L, const char *s, size_t len) {
|
||||
tsvalue(L->top) = luaS_newlstr(L, s, len);
|
||||
ttype(L->top) = TAG_STRING;
|
||||
ttype(L->top) = LUA_TSTRING;
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
||||
|
|
@ -239,10 +232,10 @@ void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
|
|||
|
||||
|
||||
void lua_pushusertag (lua_State *L, void *u, int tag) { /* ORDER LUA_T */
|
||||
if (tag != LUA_ANYTAG && tag != TAG_USERDATA && tag < NUM_TAGS)
|
||||
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) = TAG_USERDATA;
|
||||
ttype(L->top) = LUA_TUSERDATA;
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
||||
|
|
@ -271,14 +264,14 @@ void lua_gettable (lua_State *L, int index) {
|
|||
|
||||
void lua_rawget (lua_State *L, int index) {
|
||||
StkId t = Index(L, index);
|
||||
LUA_ASSERT(ttype(t) == TAG_TABLE, "table expected");
|
||||
LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
|
||||
*(L->top - 1) = *luaH_get(L, hvalue(t), L->top - 1);
|
||||
}
|
||||
|
||||
|
||||
void lua_rawgeti (lua_State *L, int index, int n) {
|
||||
StkId o = Index(L, index);
|
||||
LUA_ASSERT(ttype(o) == TAG_TABLE, "table expected");
|
||||
LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected");
|
||||
*L->top = *luaH_getnum(hvalue(o), n);
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
|
@ -286,14 +279,14 @@ void lua_rawgeti (lua_State *L, int index, int n) {
|
|||
|
||||
void lua_getglobals (lua_State *L) {
|
||||
hvalue(L->top) = L->gt;
|
||||
ttype(L->top) = TAG_TABLE;
|
||||
ttype(L->top) = LUA_TTABLE;
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
||||
|
||||
int lua_getref (lua_State *L, int ref) {
|
||||
if (ref == LUA_REFNIL)
|
||||
ttype(L->top) = TAG_NIL;
|
||||
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;
|
||||
|
|
@ -306,7 +299,7 @@ int lua_getref (lua_State *L, int ref) {
|
|||
|
||||
void lua_newtable (lua_State *L) {
|
||||
hvalue(L->top) = luaH_new(L, 0);
|
||||
ttype(L->top) = TAG_TABLE;
|
||||
ttype(L->top) = LUA_TTABLE;
|
||||
api_incr_top(L);
|
||||
}
|
||||
|
||||
|
|
@ -334,7 +327,7 @@ void lua_settable (lua_State *L, int index) {
|
|||
|
||||
void lua_rawset (lua_State *L, int index) {
|
||||
StkId t = Index(L, index);
|
||||
LUA_ASSERT(ttype(t) == TAG_TABLE, "table expected");
|
||||
LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
|
||||
*luaH_set(L, hvalue(t), L->top-2) = *(L->top-1);
|
||||
L->top -= 2;
|
||||
}
|
||||
|
|
@ -342,7 +335,7 @@ void lua_rawset (lua_State *L, int index) {
|
|||
|
||||
void lua_rawseti (lua_State *L, int index, int n) {
|
||||
StkId o = Index(L, index);
|
||||
LUA_ASSERT(ttype(o) == TAG_TABLE, "table expected");
|
||||
LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected");
|
||||
*luaH_setint(L, hvalue(o), n) = *(L->top-1);
|
||||
L->top--;
|
||||
}
|
||||
|
|
@ -350,14 +343,14 @@ void lua_rawseti (lua_State *L, int index, int n) {
|
|||
|
||||
void lua_setglobals (lua_State *L) {
|
||||
StkId newtable = --L->top;
|
||||
LUA_ASSERT(ttype(newtable) == TAG_TABLE, "table expected");
|
||||
LUA_ASSERT(ttype(newtable) == LUA_TTABLE, "table expected");
|
||||
L->gt = hvalue(newtable);
|
||||
}
|
||||
|
||||
|
||||
int lua_ref (lua_State *L, int lock) {
|
||||
int ref;
|
||||
if (ttype(L->top-1) == TAG_NIL)
|
||||
if (ttype(L->top-1) == LUA_TNIL)
|
||||
ref = LUA_REFNIL;
|
||||
else {
|
||||
if (L->refFree != NONEXT) { /* is there a free place? */
|
||||
|
|
@ -420,15 +413,15 @@ void lua_setgcthreshold (lua_State *L, int newthreshold) {
|
|||
void lua_settag (lua_State *L, int tag) {
|
||||
luaT_realtag(L, tag);
|
||||
switch (ttype(L->top-1)) {
|
||||
case TAG_TABLE:
|
||||
case LUA_TTABLE:
|
||||
hvalue(L->top-1)->htag = tag;
|
||||
break;
|
||||
case TAG_USERDATA:
|
||||
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, L->top-1));
|
||||
luaO_typename(L->top-1));
|
||||
}
|
||||
L->top--;
|
||||
}
|
||||
|
|
@ -446,7 +439,7 @@ void lua_unref (lua_State *L, int ref) {
|
|||
int lua_next (lua_State *L, int index) {
|
||||
StkId t = Index(L, index);
|
||||
Node *n;
|
||||
LUA_ASSERT(ttype(t) == TAG_TABLE, "table expected");
|
||||
LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
|
||||
n = luaH_next(L, hvalue(t), Index(L, -1));
|
||||
if (n) {
|
||||
*(L->top-1) = *key(n);
|
||||
|
|
@ -464,15 +457,15 @@ int lua_next (lua_State *L, int index) {
|
|||
int lua_getn (lua_State *L, int index) {
|
||||
Hash *h = hvalue(Index(L, index));
|
||||
const TObject *value = luaH_getstr(h, luaS_new(L, "n")); /* value = h.n */
|
||||
if (ttype(value) == TAG_NUMBER)
|
||||
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)) == TAG_NUMBER &&
|
||||
ttype(val(n)) != TAG_NIL &&
|
||||
if (ttype(key(n)) == LUA_TNUMBER &&
|
||||
ttype(val(n)) != LUA_TNIL &&
|
||||
nvalue(key(n)) > max)
|
||||
max = nvalue(key(n));
|
||||
n++;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lauxlib.c,v 1.37 2000/09/29 12:40:56 roberto Exp roberto $
|
||||
** $Id: lauxlib.c,v 1.38 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Auxiliary functions for building Lua libraries
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -40,7 +40,7 @@ void luaL_argerror (lua_State *L, int narg, const char *extramsg) {
|
|||
}
|
||||
|
||||
|
||||
static void type_error (lua_State *L, int narg, lua_Type t) {
|
||||
static void type_error (lua_State *L, int narg, int t) {
|
||||
char buff[100];
|
||||
const char *rt = lua_typename(L, lua_type(L, narg));
|
||||
if (*rt == 'N') rt = "no value";
|
||||
|
|
@ -55,14 +55,14 @@ void luaL_checkstack (lua_State *L, int space, const char *mes) {
|
|||
}
|
||||
|
||||
|
||||
void luaL_checktype(lua_State *L, int narg, lua_Type t) {
|
||||
void luaL_checktype(lua_State *L, int narg, int t) {
|
||||
if (lua_type(L, narg) != t)
|
||||
type_error(L, narg, t);
|
||||
}
|
||||
|
||||
|
||||
void luaL_checkany (lua_State *L, int narg) {
|
||||
if (lua_type(L, narg) == LUA_NOVALUE)
|
||||
if (lua_type(L, narg) == LUA_TNONE)
|
||||
luaL_argerror(L, narg, "value expected");
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lauxlib.h,v 1.25 2000/09/12 13:48:22 roberto Exp roberto $
|
||||
** $Id: lauxlib.h,v 1.26 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Auxiliary functions for building Lua libraries
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -30,7 +30,7 @@ double luaL_check_number (lua_State *L, int numArg);
|
|||
double luaL_opt_number (lua_State *L, int numArg, double def);
|
||||
|
||||
void luaL_checkstack (lua_State *L, int space, const char *msg);
|
||||
void luaL_checktype (lua_State *L, int narg, lua_Type t);
|
||||
void luaL_checktype (lua_State *L, int narg, int t);
|
||||
void luaL_checkany (lua_State *L, int narg);
|
||||
|
||||
void luaL_verror (lua_State *L, const char *fmt, ...);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lbaselib.c,v 1.7 2000/10/02 14:47:43 roberto Exp roberto $
|
||||
** $Id: lbaselib.c,v 1.8 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Basic library
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -322,7 +322,7 @@ static int luaB_tostring (lua_State *L) {
|
|||
case LUA_TNIL:
|
||||
lua_pushstring(L, "nil");
|
||||
return 1;
|
||||
case LUA_NOVALUE:
|
||||
default:
|
||||
luaL_argerror(L, 1, "value expected");
|
||||
}
|
||||
lua_pushstring(L, buff);
|
||||
|
|
|
|||
71
ldebug.c
71
ldebug.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ldebug.c,v 1.42 2000/09/18 19:39:49 roberto Exp roberto $
|
||||
** $Id: ldebug.c,v 1.43 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Debug Interface
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -23,23 +23,21 @@
|
|||
#include "luadebug.h"
|
||||
|
||||
|
||||
|
||||
static const char *getfuncname (lua_State *L, StkId f, const char **name);
|
||||
|
||||
|
||||
static void setnormalized (TObject *d, const TObject *s) {
|
||||
switch (s->ttype) {
|
||||
case TAG_CMARK: {
|
||||
clvalue(d) = clvalue(s);
|
||||
ttype(d) = TAG_CCLOSURE;
|
||||
break;
|
||||
}
|
||||
case TAG_LMARK: {
|
||||
if (ttype(s) == LUA_TMARK) {
|
||||
clvalue(d) = infovalue(s)->func;
|
||||
ttype(d) = TAG_LCLOSURE;
|
||||
break;
|
||||
ttype(d) = LUA_TFUNCTION;
|
||||
}
|
||||
default: *d = *s;
|
||||
else *d = *s;
|
||||
}
|
||||
|
||||
|
||||
static int isLmark (StkId o) {
|
||||
return (o && ttype(o) == LUA_TMARK && !infovalue(o)->func->isC);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -82,9 +80,9 @@ int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
|
|||
|
||||
static int lua_nups (StkId f) {
|
||||
switch (ttype(f)) {
|
||||
case TAG_LCLOSURE: case TAG_CCLOSURE: case TAG_CMARK:
|
||||
case LUA_TFUNCTION:
|
||||
return clvalue(f)->nupvalues;
|
||||
case TAG_LMARK:
|
||||
case LUA_TMARK:
|
||||
return infovalue(f)->func->nupvalues;
|
||||
default:
|
||||
return 0;
|
||||
|
|
@ -125,13 +123,13 @@ int luaG_getline (int *lineinfo, int pc, int refline, int *prefi) {
|
|||
|
||||
static int lua_currentpc (StkId f) {
|
||||
CallInfo *ci = infovalue(f);
|
||||
LUA_ASSERT(ttype(f) == TAG_LMARK, "function has no pc");
|
||||
LUA_ASSERT(isLmark(f), "function has no pc");
|
||||
return (*ci->pc - ci->func->f.l->code) - 1;
|
||||
}
|
||||
|
||||
|
||||
static int lua_currentline (StkId f) {
|
||||
if (ttype(f) != TAG_LMARK)
|
||||
if (!isLmark(f))
|
||||
return -1; /* only active lua functions have current-line information */
|
||||
else {
|
||||
CallInfo *ci = infovalue(f);
|
||||
|
|
@ -143,7 +141,7 @@ static int lua_currentline (StkId f) {
|
|||
|
||||
|
||||
static Proto *getluaproto (StkId f) {
|
||||
return (ttype(f) == TAG_LMARK) ? infovalue(f)->func->f.l : NULL;
|
||||
return (isLmark(f) ? infovalue(f)->func->f.l : NULL);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -179,22 +177,25 @@ static void infoLproto (lua_Debug *ar, Proto *f) {
|
|||
}
|
||||
|
||||
|
||||
static void lua_funcinfo (lua_Debug *ar, StkId func) {
|
||||
static void lua_funcinfo (lua_State *L, lua_Debug *ar, StkId func) {
|
||||
Closure *cl = NULL;
|
||||
switch (ttype(func)) {
|
||||
case TAG_LCLOSURE:
|
||||
infoLproto(ar, clvalue(func)->f.l);
|
||||
case LUA_TFUNCTION:
|
||||
cl = clvalue(func);
|
||||
break;
|
||||
case TAG_LMARK:
|
||||
infoLproto(ar, infovalue(func)->func->f.l);
|
||||
case LUA_TMARK:
|
||||
cl = infovalue(func)->func;
|
||||
break;
|
||||
case TAG_CCLOSURE: case TAG_CMARK:
|
||||
default:
|
||||
lua_error(L, "value for `lua_getinfo' is not a function");
|
||||
}
|
||||
if (cl->isC) {
|
||||
ar->source = "(C)";
|
||||
ar->linedefined = -1;
|
||||
ar->what = "C";
|
||||
break;
|
||||
default:
|
||||
LUA_INTERNALERROR("invalid `func' value");
|
||||
}
|
||||
else
|
||||
infoLproto(ar, cl->f.l);
|
||||
luaO_chunkid(ar->short_src, ar->source, sizeof(ar->short_src));
|
||||
if (ar->linedefined == 0)
|
||||
ar->what = "main";
|
||||
|
|
@ -218,7 +219,7 @@ static const char *travglobals (lua_State *L, const TObject *o) {
|
|||
int i;
|
||||
for (i=0; i<g->size; i++) {
|
||||
if (luaO_equalObj(o, val(node(g, i))) &&
|
||||
ttype(key(node(g, i))) == TAG_STRING)
|
||||
ttype(key(node(g, i))) == LUA_TSTRING)
|
||||
return tsvalue(key(node(g, i)))->str;
|
||||
}
|
||||
return NULL;
|
||||
|
|
@ -250,7 +251,7 @@ int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
|
|||
for (; *what; what++) {
|
||||
switch (*what) {
|
||||
case 'S': {
|
||||
lua_funcinfo(ar, func);
|
||||
lua_funcinfo(L, ar, func);
|
||||
break;
|
||||
}
|
||||
case 'l': {
|
||||
|
|
@ -377,8 +378,8 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int stackpos) {
|
|||
|
||||
static const char *getobjname (lua_State *L, StkId obj, const char **name) {
|
||||
StkId func = aux_stackedfunction(L, 0, obj);
|
||||
if (func == NULL || ttype(func) != TAG_LMARK)
|
||||
return NULL; /* not a Lua function */
|
||||
if (!isLmark(func))
|
||||
return NULL; /* not an active Lua function */
|
||||
else {
|
||||
Proto *p = infovalue(func)->func->f.l;
|
||||
int pc = lua_currentpc(func);
|
||||
|
|
@ -409,8 +410,8 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
|
|||
|
||||
static const char *getfuncname (lua_State *L, StkId f, const char **name) {
|
||||
StkId func = aux_stackedfunction(L, 0, f); /* calling function */
|
||||
if (func == NULL || ttype(func) != TAG_LMARK)
|
||||
return NULL; /* not a Lua function */
|
||||
if (!isLmark(func))
|
||||
return NULL; /* not an active Lua function */
|
||||
else {
|
||||
Proto *p = infovalue(func)->func->f.l;
|
||||
int pc = lua_currentpc(func);
|
||||
|
|
@ -433,7 +434,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 = luaO_typename(L, o);
|
||||
const char *t = luaO_typename(o);
|
||||
if (kind)
|
||||
luaO_verror(L, "attempt to %.30s %.20s `%.40s' (a %.10s value)",
|
||||
op, kind, name, t);
|
||||
|
|
@ -442,7 +443,7 @@ void luaG_typeerror (lua_State *L, StkId o, const char *op) {
|
|||
}
|
||||
|
||||
|
||||
void luaG_binerror (lua_State *L, StkId p1, lua_Tag t, const char *op) {
|
||||
void luaG_binerror (lua_State *L, StkId p1, int t, const char *op) {
|
||||
if (ttype(p1) == t) p1++;
|
||||
LUA_ASSERT(ttype(p1) != t, "must be an error");
|
||||
luaG_typeerror(L, p1, op);
|
||||
|
|
@ -450,8 +451,8 @@ void luaG_binerror (lua_State *L, StkId p1, lua_Tag t, const char *op) {
|
|||
|
||||
|
||||
void luaG_ordererror (lua_State *L, StkId top) {
|
||||
const char *t1 = luaO_typename(L, top-2);
|
||||
const char *t2 = luaO_typename(L, top-1);
|
||||
const char *t1 = luaO_typename(top-2);
|
||||
const char *t2 = luaO_typename(top-1);
|
||||
if (t1[2] == t2[2])
|
||||
luaO_verror(L, "attempt to compare two %.10s values", t1);
|
||||
else
|
||||
|
|
|
|||
4
ldebug.h
4
ldebug.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ldebug.h,v 1.5 2000/08/11 16:17:28 roberto Exp roberto $
|
||||
** $Id: ldebug.h,v 1.6 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Auxiliary functions from Debug Interface module
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
|
||||
void luaG_typeerror (lua_State *L, StkId o, const char *op);
|
||||
void luaG_binerror (lua_State *L, StkId p1, lua_Tag t, const char *op);
|
||||
void luaG_binerror (lua_State *L, StkId p1, int t, const char *op);
|
||||
int luaG_getline (int *lineinfo, int pc, int refline, int *refi);
|
||||
void luaG_ordererror (lua_State *L, StkId top);
|
||||
|
||||
|
|
|
|||
46
ldo.c
46
ldo.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ldo.c,v 1.100 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** $Id: ldo.c,v 1.101 2000/10/04 12:16:08 roberto Exp roberto $
|
||||
** Stack and Call structure of Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -73,7 +73,7 @@ void luaD_adjusttop (lua_State *L, StkId base, int extra) {
|
|||
else {
|
||||
luaD_checkstack(L, diff);
|
||||
while (diff--)
|
||||
ttype(L->top++) = TAG_NIL;
|
||||
ttype(L->top++) = LUA_TNIL;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -91,7 +91,7 @@ static void luaD_openstack (lua_State *L, StkId pos) {
|
|||
static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) {
|
||||
StkId old_Cbase = L->Cbase;
|
||||
StkId old_top = L->Cbase = L->top;
|
||||
luaD_checkstack(L, LUA_MINSTACK); /* assures minimum stack size */
|
||||
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
|
||||
L->allowhooks = 0; /* cannot call hooks inside a hook */
|
||||
(*hook)(L, ar);
|
||||
LUA_ASSERT(L->allowhooks == 0, "invalid allow");
|
||||
|
|
@ -129,7 +129,7 @@ static StkId callCclosure (lua_State *L, const struct Closure *cl, StkId base) {
|
|||
StkId old_Cbase = L->Cbase;
|
||||
int n;
|
||||
L->Cbase = base; /* new base for C function */
|
||||
luaD_checkstack(L, nup+LUA_MINSTACK); /* assures minimum stack size */
|
||||
luaD_checkstack(L, nup+LUA_MINSTACK); /* ensure minimum stack size */
|
||||
for (n=0; n<nup; n++) /* copy upvalues as extra arguments */
|
||||
*(L->top++) = cl->upvalue[n];
|
||||
if (callhook)
|
||||
|
|
@ -159,32 +159,26 @@ void luaD_callTM (lua_State *L, const TObject *f, int nParams, int nResults) {
|
|||
*/
|
||||
void luaD_call (lua_State *L, StkId func, int nResults) {
|
||||
StkId firstResult;
|
||||
retry: /* for `function' tag method */
|
||||
switch (ttype(func)) {
|
||||
case TAG_LCLOSURE: {
|
||||
CallInfo ci;
|
||||
ci.func = clvalue(func);
|
||||
infovalue(func) = &ci;
|
||||
ttype(func) = TAG_LMARK;
|
||||
firstResult = luaV_execute(L, ci.func, func+1);
|
||||
LUA_ASSERT(ttype(func) == TAG_LMARK, "invalid tag");
|
||||
break;
|
||||
}
|
||||
case TAG_CCLOSURE: {
|
||||
ttype(func) = TAG_CMARK;
|
||||
firstResult = callCclosure(L, clvalue(func), func+1);
|
||||
LUA_ASSERT(ttype(func) == TAG_CMARK, "invalid tag");
|
||||
break;
|
||||
}
|
||||
default: { /* `func' is not a function; check the `function' tag method */
|
||||
Closure *cl;
|
||||
if (ttype(func) != LUA_TFUNCTION) {
|
||||
/* `func' is not a function; check the `function' tag method */
|
||||
const TObject *im = luaT_getimbyObj(L, func, IM_FUNCTION);
|
||||
if (ttype(im) == TAG_NIL)
|
||||
if (ttype(im) == LUA_TNIL)
|
||||
luaG_typeerror(L, func, "call");
|
||||
luaD_openstack(L, func);
|
||||
*func = *im; /* tag method is the new function to be called */
|
||||
goto retry; /* retry the call */
|
||||
}
|
||||
LUA_ASSERT(ttype(func) == LUA_TFUNCTION, "invalid tag method");
|
||||
}
|
||||
cl = clvalue(func);
|
||||
ci.func = cl;
|
||||
infovalue(func) = &ci;
|
||||
ttype(func) = LUA_TMARK;
|
||||
if (cl->isC)
|
||||
firstResult = callCclosure(L, cl, func+1);
|
||||
else
|
||||
firstResult = luaV_execute(L, cl, func+1);
|
||||
LUA_ASSERT(ttype(func) == LUA_TMARK, "invalid tag");
|
||||
/* adjust the number of results */
|
||||
if (nResults == LUA_MULTRET)
|
||||
nResults = L->top - firstResult;
|
||||
|
|
@ -250,7 +244,7 @@ static int protectedparser (lua_State *L, ZIO *z, int bin) {
|
|||
old_blocks = L->nblocks;
|
||||
status = luaD_runprotected(L, f_parser, &p);
|
||||
if (status == 0) {
|
||||
/* add new memory to threshould (as it probably will stay) */
|
||||
/* add new memory to threshold (as it probably will stay) */
|
||||
L->GCthreshold += (L->nblocks - old_blocks);
|
||||
}
|
||||
else if (status == LUA_ERRRUN) /* an error occurred: correct error code */
|
||||
|
|
@ -331,7 +325,7 @@ struct lua_longjmp {
|
|||
|
||||
static void message (lua_State *L, const char *s) {
|
||||
const TObject *em = luaH_getglobal(L, LUA_ERRORMESSAGE);
|
||||
if (luaO_type(em) == LUA_TFUNCTION) {
|
||||
if (ttype(em) == LUA_TFUNCTION) {
|
||||
*L->top = *em;
|
||||
incr_top;
|
||||
lua_pushstring(L, s);
|
||||
|
|
|
|||
60
lgc.c
60
lgc.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lgc.c,v 1.68 2000/09/29 12:42:13 roberto Exp roberto $
|
||||
** $Id: lgc.c,v 1.69 2000/10/02 14:47:43 roberto Exp roberto $
|
||||
** Garbage Collector
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -24,7 +24,7 @@ typedef struct GCState {
|
|||
|
||||
|
||||
|
||||
static int markobject (GCState *st, TObject *o);
|
||||
static void markobject (GCState *st, TObject *o);
|
||||
|
||||
|
||||
/* mark a string; marks larger than 1 cannot be changed */
|
||||
|
|
@ -73,39 +73,36 @@ static void marktagmethods (lua_State *L, GCState *st) {
|
|||
}
|
||||
|
||||
|
||||
static int markobject (GCState *st, TObject *o) {
|
||||
static void markclosure (GCState *st, Closure *cl) {
|
||||
if (!ismarked(cl)) {
|
||||
if (!cl->isC)
|
||||
protomark(cl->f.l);
|
||||
cl->mark = st->cmark; /* chain it for later traversal */
|
||||
st->cmark = cl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static void markobject (GCState *st, TObject *o) {
|
||||
switch (ttype(o)) {
|
||||
case TAG_USERDATA: case TAG_STRING:
|
||||
case LUA_TUSERDATA: case LUA_TSTRING:
|
||||
strmark(tsvalue(o));
|
||||
break;
|
||||
case TAG_TABLE: {
|
||||
case LUA_TMARK:
|
||||
markclosure(st, infovalue(o)->func);
|
||||
break;
|
||||
case LUA_TFUNCTION:
|
||||
markclosure(st, clvalue(o));
|
||||
break;
|
||||
case LUA_TTABLE: {
|
||||
if (!ismarked(hvalue(o))) {
|
||||
hvalue(o)->mark = st->tmark; /* chain it in list of marked */
|
||||
st->tmark = hvalue(o);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TAG_LMARK: {
|
||||
Closure *cl = infovalue(o)->func;
|
||||
if (!ismarked(cl)) {
|
||||
protomark(cl->f.l);
|
||||
cl->mark = st->cmark; /* chain it for later traversal */
|
||||
st->cmark = cl;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case TAG_LCLOSURE:
|
||||
protomark(clvalue(o)->f.l);
|
||||
/* go through */
|
||||
case TAG_CCLOSURE: case TAG_CMARK:
|
||||
if (!ismarked(clvalue(o))) {
|
||||
clvalue(o)->mark = st->cmark; /* chain it for later traversal */
|
||||
st->cmark = clvalue(o);
|
||||
}
|
||||
break;
|
||||
default: break; /* numbers, etc */
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -131,8 +128,8 @@ static void markall (lua_State *L) {
|
|||
st.tmark = h->mark; /* remove it from list */
|
||||
for (i=0; i<h->size; i++) {
|
||||
Node *n = node(h, i);
|
||||
if (ttype(key(n)) != TAG_NIL) {
|
||||
if (ttype(val(n)) == TAG_NIL)
|
||||
if (ttype(key(n)) != LUA_TNIL) {
|
||||
if (ttype(val(n)) == LUA_TNIL)
|
||||
luaH_remove(h, key(n)); /* dead element; try to remove it */
|
||||
markobject(&st, &n->key);
|
||||
markobject(&st, &n->val);
|
||||
|
|
@ -147,11 +144,11 @@ 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:
|
||||
case LUA_TSTRING: case LUA_TUSERDATA:
|
||||
return tsvalue(o)->marked;
|
||||
case TAG_TABLE:
|
||||
case LUA_TTABLE:
|
||||
return ismarked(hvalue(o));
|
||||
case TAG_LCLOSURE: case TAG_CCLOSURE:
|
||||
case LUA_TFUNCTION:
|
||||
return ismarked(clvalue(o));
|
||||
default: /* number */
|
||||
return 1;
|
||||
|
|
@ -271,7 +268,6 @@ static void collectudata (lua_State *L, int all) {
|
|||
}
|
||||
else { /* collect */
|
||||
int tag = next->u.d.tag;
|
||||
if (tag > L->last_tag) tag = TAG_USERDATA;
|
||||
*p = next->nexthash;
|
||||
next->nexthash = L->IMtable[tag].collected; /* chain udata */
|
||||
L->IMtable[tag].collected = next;
|
||||
|
|
@ -297,7 +293,7 @@ static void checkMbuffer (lua_State *L) {
|
|||
|
||||
static void callgcTM (lua_State *L, const TObject *o) {
|
||||
const TObject *im = luaT_getimbyObj(L, o, IM_GC);
|
||||
if (ttype(im) != TAG_NIL) {
|
||||
if (ttype(im) != LUA_TNIL) {
|
||||
int oldah = L->allowhooks;
|
||||
L->allowhooks = 0; /* stop debug hooks during GC tag methods */
|
||||
luaD_checkstack(L, 2);
|
||||
|
|
@ -313,7 +309,7 @@ static void callgcTM (lua_State *L, const TObject *o) {
|
|||
static void callgcTMudata (lua_State *L) {
|
||||
int tag;
|
||||
TObject o;
|
||||
ttype(&o) = TAG_USERDATA;
|
||||
ttype(&o) = LUA_TUSERDATA;
|
||||
L->GCthreshold = 2*L->nblocks; /* avoid GC during tag methods */
|
||||
for (tag=L->last_tag; tag>=0; tag--) { /* for each tag (in reverse order) */
|
||||
TString *udata;
|
||||
|
|
|
|||
27
lobject.c
27
lobject.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lobject.c,v 1.50 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** $Id: lobject.c,v 1.51 2000/10/03 14:03:21 roberto Exp roberto $
|
||||
** Some generic functions over Lua objects
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -18,16 +18,15 @@
|
|||
|
||||
|
||||
|
||||
const lua_Type luaO_typearr[] = { /* ORDER LUA_T */
|
||||
LUA_TUSERDATA, LUA_TNUMBER, LUA_TSTRING, LUA_TTABLE,
|
||||
LUA_TFUNCTION, LUA_TFUNCTION, LUA_TNIL
|
||||
const TObject luaO_nilobject = {LUA_TNIL, {NULL}};
|
||||
|
||||
|
||||
const char *const luaO_typenames[] = {
|
||||
"userdata", "nil", "number", "string", "table", "function"
|
||||
};
|
||||
|
||||
|
||||
|
||||
const TObject luaO_nilobject = {TAG_NIL, {NULL}};
|
||||
|
||||
|
||||
/*
|
||||
** returns smaller power of 2 larger than `n' (minimum is MINPOWER2)
|
||||
*/
|
||||
|
|
@ -41,17 +40,17 @@ lint32 luaO_power2 (lint32 n) {
|
|||
int luaO_equalObj (const TObject *t1, const TObject *t2) {
|
||||
if (ttype(t1) != ttype(t2)) return 0;
|
||||
switch (ttype(t1)) {
|
||||
case TAG_NUMBER:
|
||||
case LUA_TNUMBER:
|
||||
return nvalue(t1) == nvalue(t2);
|
||||
case TAG_STRING: case TAG_USERDATA:
|
||||
case LUA_TSTRING: case LUA_TUSERDATA:
|
||||
return tsvalue(t1) == tsvalue(t2);
|
||||
case TAG_TABLE:
|
||||
case LUA_TTABLE:
|
||||
return hvalue(t1) == hvalue(t2);
|
||||
case TAG_CCLOSURE: case TAG_LCLOSURE:
|
||||
case LUA_TFUNCTION:
|
||||
return clvalue(t1) == clvalue(t2);
|
||||
default:
|
||||
LUA_ASSERT(ttype(t1) == TAG_NIL, "invalid type");
|
||||
return 1; /* TAG_NIL */
|
||||
LUA_ASSERT(ttype(t1) == LUA_TNIL, "invalid type");
|
||||
return 1; /* LUA_TNIL */
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -80,7 +79,7 @@ int luaO_str2d (const char *s, Number *result) { /* LUA_NUMBER */
|
|||
/* this function needs to handle only '%d' and '%.XXs' formats */
|
||||
void luaO_verror (lua_State *L, const char *fmt, ...) {
|
||||
va_list argp;
|
||||
char buff[600]; /* to hold formated message */
|
||||
char buff[600]; /* to hold formatted message */
|
||||
va_start(argp, fmt);
|
||||
vsprintf(buff, fmt, argp);
|
||||
va_end(argp);
|
||||
|
|
|
|||
55
lobject.h
55
lobject.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lobject.h,v 1.77 2000/09/29 12:42:13 roberto Exp roberto $
|
||||
** $Id: lobject.h,v 1.78 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Type definitions for Lua objects
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -31,41 +31,24 @@
|
|||
#endif
|
||||
|
||||
|
||||
/*
|
||||
** Lua TYPES
|
||||
** WARNING: if you change the order of this enumeration,
|
||||
** grep "ORDER LUA_T"
|
||||
*/
|
||||
typedef enum {
|
||||
TAG_USERDATA = 0, /* default tag for userdata */
|
||||
TAG_NUMBER, /* fixed tag for numbers */
|
||||
TAG_STRING, /* fixed tag for strings */
|
||||
TAG_TABLE, /* default tag for tables */
|
||||
TAG_LCLOSURE, /* fixed tag for Lua closures */
|
||||
TAG_CCLOSURE, /* fixed tag for C closures */
|
||||
TAG_NIL, /* last "pre-defined" tag */
|
||||
/* mark for closures active in the stack */
|
||||
#define LUA_TMARK 6
|
||||
|
||||
TAG_LMARK, /* mark for Lua closures */
|
||||
TAG_CMARK /* mark for C closures */
|
||||
|
||||
} lua_Tag;
|
||||
|
||||
/* tags for values visible from Lua == first user-created tag */
|
||||
#define NUM_TAGS 7
|
||||
#define NUM_TAGS 6
|
||||
|
||||
|
||||
/*
|
||||
** check whether `t' is a mark
|
||||
*/
|
||||
#define is_T_MARK(t) ((t) == TAG_LMARK || (t) == TAG_CMARK)
|
||||
/* check whether `t' is a mark */
|
||||
#define is_T_MARK(t) ((t) == LUA_TMARK)
|
||||
|
||||
|
||||
typedef union {
|
||||
struct TString *ts; /* TAG_STRING, TAG_USERDATA */
|
||||
struct Closure *cl; /* TAG_[CL]CLOSURE, TAG_CMARK */
|
||||
struct Hash *a; /* TAG_TABLE */
|
||||
struct CallInfo *i; /* TAG_LMARK */
|
||||
Number n; /* TAG_NUMBER */
|
||||
struct TString *ts; /* LUA_TSTRING, LUA_TUSERDATA */
|
||||
struct Closure *cl; /* LUA_TFUNCTION */
|
||||
struct Hash *a; /* LUA_TTABLE */
|
||||
struct CallInfo *i; /* LUA_TLMARK */
|
||||
Number n; /* LUA_TNUMBER */
|
||||
} Value;
|
||||
|
||||
|
||||
|
|
@ -80,7 +63,7 @@ typedef union {
|
|||
|
||||
|
||||
typedef struct lua_TObject {
|
||||
lua_Tag ttype;
|
||||
int ttype;
|
||||
Value value;
|
||||
} TObject;
|
||||
|
||||
|
|
@ -150,11 +133,15 @@ typedef struct Closure {
|
|||
} f;
|
||||
struct Closure *next;
|
||||
struct Closure *mark; /* marked closures (point to itself when not marked) */
|
||||
int nupvalues;
|
||||
short isC; /* 0 for Lua functions, 1 for C functions */
|
||||
short nupvalues;
|
||||
TObject upvalue[1];
|
||||
} Closure;
|
||||
|
||||
|
||||
#define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->isC)
|
||||
|
||||
|
||||
typedef struct Node {
|
||||
TObject key;
|
||||
TObject val;
|
||||
|
|
@ -189,12 +176,12 @@ typedef struct CallInfo {
|
|||
} CallInfo;
|
||||
|
||||
|
||||
extern const lua_Type luaO_typearr[];
|
||||
extern const TObject luaO_nilobject;
|
||||
extern const char *const luaO_typenames[];
|
||||
|
||||
|
||||
#define luaO_typename(o) (luaO_typenames[ttype(o)])
|
||||
|
||||
#define luaO_tag2type(t) (luaO_typearr[(int)(t)])
|
||||
#define luaO_type(o) (luaO_tag2type(ttype(o)))
|
||||
#define luaO_typename(L, o) (lua_typename(L, luaO_type(o)))
|
||||
|
||||
lint32 luaO_power2 (lint32 n);
|
||||
char *luaO_openspace (lua_State *L, size_t n);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lstrlib.c,v 1.52 2000/09/11 17:38:42 roberto Exp roberto $
|
||||
** $Id: lstrlib.c,v 1.53 2000/09/14 14:09:31 roberto Exp roberto $
|
||||
** Standard library for string operations and pattern-matching
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -525,7 +525,7 @@ static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) {
|
|||
luaL_putchar(b, '"');
|
||||
}
|
||||
|
||||
/* maximum size of each formated item (> len(format('%99.99f', -1e308))) */
|
||||
/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
|
||||
#define MAX_ITEM 512
|
||||
/* maximum size of each format specification (such as '%-099.99d') */
|
||||
#define MAX_FORMAT 20
|
||||
|
|
|
|||
48
ltable.c
48
ltable.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ltable.c,v 1.55 2000/09/11 20:29:27 roberto Exp roberto $
|
||||
** $Id: ltable.c,v 1.56 2000/09/29 12:42:13 roberto Exp roberto $
|
||||
** Lua tables (hash)
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -31,7 +31,7 @@
|
|||
|
||||
|
||||
|
||||
#define TagDefault TAG_TABLE
|
||||
#define TagDefault LUA_TTABLE
|
||||
|
||||
|
||||
|
||||
|
|
@ -42,19 +42,19 @@
|
|||
Node *luaH_mainposition (const Hash *t, const TObject *key) {
|
||||
unsigned long h;
|
||||
switch (ttype(key)) {
|
||||
case TAG_NUMBER:
|
||||
case LUA_TNUMBER:
|
||||
h = (unsigned long)(long)nvalue(key);
|
||||
break;
|
||||
case TAG_STRING:
|
||||
case LUA_TSTRING:
|
||||
h = tsvalue(key)->u.s.hash;
|
||||
break;
|
||||
case TAG_USERDATA:
|
||||
case LUA_TUSERDATA:
|
||||
h = IntPoint(tsvalue(key));
|
||||
break;
|
||||
case TAG_TABLE:
|
||||
case LUA_TTABLE:
|
||||
h = IntPoint(hvalue(key));
|
||||
break;
|
||||
case TAG_LCLOSURE: case TAG_CCLOSURE:
|
||||
case LUA_TFUNCTION:
|
||||
h = IntPoint(clvalue(key));
|
||||
break;
|
||||
default:
|
||||
|
|
@ -84,7 +84,7 @@ static const TObject *luaH_getany (lua_State *L, const Hash *t,
|
|||
const TObject *luaH_getnum (const Hash *t, Number key) {
|
||||
Node *n = &t->node[(unsigned long)(long)key&(t->size-1)];
|
||||
do {
|
||||
if (ttype(&n->key) == TAG_NUMBER && nvalue(&n->key) == key)
|
||||
if (ttype(&n->key) == LUA_TNUMBER && nvalue(&n->key) == key)
|
||||
return &n->val;
|
||||
n = n->next;
|
||||
} while (n);
|
||||
|
|
@ -96,7 +96,7 @@ const TObject *luaH_getnum (const Hash *t, Number key) {
|
|||
const TObject *luaH_getstr (const Hash *t, TString *key) {
|
||||
Node *n = &t->node[key->u.s.hash&(t->size-1)];
|
||||
do {
|
||||
if (ttype(&n->key) == TAG_STRING && tsvalue(&n->key) == key)
|
||||
if (ttype(&n->key) == LUA_TSTRING && tsvalue(&n->key) == key)
|
||||
return &n->val;
|
||||
n = n->next;
|
||||
} while (n);
|
||||
|
|
@ -106,8 +106,8 @@ const TObject *luaH_getstr (const Hash *t, TString *key) {
|
|||
|
||||
const TObject *luaH_get (lua_State *L, const Hash *t, const TObject *key) {
|
||||
switch (ttype(key)) {
|
||||
case TAG_NUMBER: return luaH_getnum(t, nvalue(key));
|
||||
case TAG_STRING: return luaH_getstr(t, tsvalue(key));
|
||||
case LUA_TNUMBER: return luaH_getnum(t, nvalue(key));
|
||||
case LUA_TSTRING: return luaH_getstr(t, tsvalue(key));
|
||||
default: return luaH_getany(L, t, key);
|
||||
}
|
||||
}
|
||||
|
|
@ -115,7 +115,7 @@ const TObject *luaH_get (lua_State *L, const Hash *t, const TObject *key) {
|
|||
|
||||
Node *luaH_next (lua_State *L, const Hash *t, const TObject *key) {
|
||||
int i;
|
||||
if (ttype(key) == TAG_NIL)
|
||||
if (ttype(key) == LUA_TNIL)
|
||||
i = 0; /* first iteration */
|
||||
else {
|
||||
const TObject *v = luaH_get(L, t, key);
|
||||
|
|
@ -126,7 +126,7 @@ Node *luaH_next (lua_State *L, const Hash *t, const TObject *key) {
|
|||
}
|
||||
for (; i<t->size; i++) {
|
||||
Node *n = node(t, i);
|
||||
if (ttype(val(n)) != TAG_NIL)
|
||||
if (ttype(val(n)) != LUA_TNIL)
|
||||
return n;
|
||||
}
|
||||
return NULL; /* no more elements */
|
||||
|
|
@ -138,8 +138,8 @@ Node *luaH_next (lua_State *L, const Hash *t, const TObject *key) {
|
|||
** hash, change `key' for a number with the same hash.
|
||||
*/
|
||||
void luaH_remove (Hash *t, TObject *key) {
|
||||
if (ttype(key) == TAG_NUMBER ||
|
||||
(ttype(key) == TAG_STRING && tsvalue(key)->u.s.len <= 30))
|
||||
if (ttype(key) == LUA_TNUMBER ||
|
||||
(ttype(key) == LUA_TSTRING && tsvalue(key)->u.s.len <= 30))
|
||||
return; /* do not remove numbers nor small strings */
|
||||
else {
|
||||
/* try to find a number `n' with the same hash as `key' */
|
||||
|
|
@ -151,7 +151,7 @@ void luaH_remove (Hash *t, TObject *key) {
|
|||
return; /* give up; (to avoid overflow) */
|
||||
n += t->size;
|
||||
}
|
||||
ttype(key) = TAG_NUMBER;
|
||||
ttype(key) = LUA_TNUMBER;
|
||||
nvalue(key) = n;
|
||||
LUA_ASSERT(luaH_mainposition(t, key) == mp, "cannot change hash");
|
||||
}
|
||||
|
|
@ -164,7 +164,7 @@ static void setnodevector (lua_State *L, Hash *t, lint32 size) {
|
|||
lua_error(L, "table overflow");
|
||||
t->node = luaM_newvector(L, size, Node);
|
||||
for (i=0; i<(int)size; i++) {
|
||||
ttype(&t->node[i].key) = ttype(&t->node[i].val) = TAG_NIL;
|
||||
ttype(&t->node[i].key) = ttype(&t->node[i].val) = LUA_TNIL;
|
||||
t->node[i].next = NULL;
|
||||
}
|
||||
L->nblocks += gcsize(L, size) - gcsize(L, t->size);
|
||||
|
|
@ -200,7 +200,7 @@ static int numuse (const Hash *t) {
|
|||
int realuse = 0;
|
||||
int i;
|
||||
for (i=0; i<size; i++) {
|
||||
if (ttype(&v[i].val) != TAG_NIL)
|
||||
if (ttype(&v[i].val) != LUA_TNIL)
|
||||
realuse++;
|
||||
}
|
||||
return realuse;
|
||||
|
|
@ -222,7 +222,7 @@ static void rehash (lua_State *L, Hash *t) {
|
|||
setnodevector(L, t, oldsize);
|
||||
for (i=0; i<oldsize; i++) {
|
||||
Node *old = nold+i;
|
||||
if (ttype(&old->val) != TAG_NIL)
|
||||
if (ttype(&old->val) != LUA_TNIL)
|
||||
*luaH_set(L, t, &old->key) = old->val;
|
||||
}
|
||||
luaM_free(L, nold); /* free old array */
|
||||
|
|
@ -248,7 +248,7 @@ TObject *luaH_set (lua_State *L, Hash *t, const TObject *key) {
|
|||
else n = n->next;
|
||||
} while (n);
|
||||
/* `key' not found; must insert it */
|
||||
if (ttype(&mp->key) != TAG_NIL) { /* main position is not free? */
|
||||
if (ttype(&mp->key) != LUA_TNIL) { /* main position is not free? */
|
||||
Node *othern; /* main position of colliding node */
|
||||
n = t->firstfree; /* get a free place */
|
||||
/* is colliding node out of its main position? (can only happens if
|
||||
|
|
@ -269,7 +269,7 @@ TObject *luaH_set (lua_State *L, Hash *t, const TObject *key) {
|
|||
}
|
||||
mp->key = *key;
|
||||
for (;;) { /* correct `firstfree' */
|
||||
if (ttype(&t->firstfree->key) == TAG_NIL)
|
||||
if (ttype(&t->firstfree->key) == LUA_TNIL)
|
||||
return &mp->val; /* OK; table still has a free place */
|
||||
else if (t->firstfree == t->node) break; /* cannot decrement from here */
|
||||
else (t->firstfree)--;
|
||||
|
|
@ -281,7 +281,7 @@ TObject *luaH_set (lua_State *L, Hash *t, const TObject *key) {
|
|||
|
||||
TObject *luaH_setint (lua_State *L, Hash *t, int key) {
|
||||
TObject index;
|
||||
ttype(&index) = TAG_NUMBER;
|
||||
ttype(&index) = LUA_TNUMBER;
|
||||
nvalue(&index) = key;
|
||||
return luaH_set(L, t, &index);
|
||||
}
|
||||
|
|
@ -289,10 +289,10 @@ TObject *luaH_setint (lua_State *L, Hash *t, int key) {
|
|||
|
||||
void luaH_setstrnum (lua_State *L, Hash *t, TString *key, Number val) {
|
||||
TObject *value, index;
|
||||
ttype(&index) = TAG_STRING;
|
||||
ttype(&index) = LUA_TSTRING;
|
||||
tsvalue(&index) = key;
|
||||
value = luaH_set(L, t, &index);
|
||||
ttype(value) = TAG_NUMBER;
|
||||
ttype(value) = LUA_TNUMBER;
|
||||
nvalue(value) = val;
|
||||
}
|
||||
|
||||
|
|
|
|||
15
ltests.c
15
ltests.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ltests.c,v 1.46 2000/10/02 14:47:43 roberto Exp roberto $
|
||||
** $Id: ltests.c,v 1.47 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** Internal Module for Debugging of the Lua Implementation
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -93,7 +93,8 @@ static int listcode (lua_State *L) {
|
|||
int pc;
|
||||
Proto *p;
|
||||
int res;
|
||||
luaL_arg_check(L, lua_tag(L, 1) == TAG_LCLOSURE, 1, "Lua function expected");
|
||||
luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
|
||||
1, "Lua function expected");
|
||||
p = clvalue(luaA_index(L, 1))->f.l;
|
||||
lua_newtable(L);
|
||||
setnameval(L, "maxstack", p->maxstacksize);
|
||||
|
|
@ -111,7 +112,8 @@ static int listcode (lua_State *L) {
|
|||
static int liststrings (lua_State *L) {
|
||||
Proto *p;
|
||||
int i;
|
||||
luaL_arg_check(L, lua_tag(L, 1) == TAG_LCLOSURE, 1, "Lua function expected");
|
||||
luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
|
||||
1, "Lua function expected");
|
||||
p = clvalue(luaA_index(L, 1))->f.l;
|
||||
lua_newtable(L);
|
||||
for (i=0; i<p->nkstr; i++) {
|
||||
|
|
@ -128,7 +130,8 @@ static int listlocals (lua_State *L) {
|
|||
int pc = luaL_check_int(L, 2) - 1;
|
||||
int i = 0;
|
||||
const char *name;
|
||||
luaL_arg_check(L, lua_tag(L, 1) == TAG_LCLOSURE, 1, "Lua function expected");
|
||||
luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
|
||||
1, "Lua function expected");
|
||||
p = clvalue(luaA_index(L, 1))->f.l;
|
||||
while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
|
||||
lua_pushstring(L, name);
|
||||
|
|
@ -177,7 +180,7 @@ static int mem_query (lua_State *L) {
|
|||
|
||||
static int hash_query (lua_State *L) {
|
||||
if (lua_isnull(L, 2)) {
|
||||
luaL_arg_check(L, lua_tag(L, 1) == TAG_STRING, 1, "string expected");
|
||||
luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, "string expected");
|
||||
lua_pushnumber(L, tsvalue(luaA_index(L, 1))->u.s.hash);
|
||||
}
|
||||
else {
|
||||
|
|
@ -226,7 +229,7 @@ static int string_query (lua_State *L) {
|
|||
TString *ts;
|
||||
int n = 0;
|
||||
for (ts = tb->hash[s]; ts; ts = ts->nexthash) {
|
||||
ttype(L->top) = TAG_STRING;
|
||||
ttype(L->top) = LUA_TSTRING;
|
||||
tsvalue(L->top) = ts;
|
||||
incr_top;
|
||||
n++;
|
||||
|
|
|
|||
49
ltm.c
49
ltm.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ltm.c,v 1.51 2000/10/02 20:10:55 roberto Exp roberto $
|
||||
** $Id: ltm.c,v 1.52 2000/10/03 14:27:44 roberto Exp roberto $
|
||||
** Tag methods
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -38,7 +38,7 @@ static int luaI_checkevent (lua_State *L, const char *name, int t) {
|
|||
int e = findevent(name);
|
||||
if (e >= IM_N)
|
||||
luaO_verror(L, "event `%.50s' is deprecated", name);
|
||||
if (e == IM_GC && t == TAG_TABLE)
|
||||
if (e == IM_GC && t == LUA_TTABLE)
|
||||
luaO_verror(L, "event `gc' for tables is deprecated");
|
||||
if (e < 0)
|
||||
luaO_verror(L, "`%.50s' is not a valid event name", name);
|
||||
|
|
@ -47,29 +47,28 @@ static int luaI_checkevent (lua_State *L, const char *name, int t) {
|
|||
|
||||
|
||||
|
||||
/* events in TAG_NIL are all allowed, since this is used as a
|
||||
/* events in LUA_TNIL are all allowed, since this is used as a
|
||||
* 'placeholder' for "default" fallbacks
|
||||
*/
|
||||
/* ORDER LUA_T, ORDER IM */
|
||||
static const char luaT_validevents[NUM_TAGS][IM_N] = {
|
||||
{1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* TAG_USERDATA */
|
||||
{1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}, /* TAG_NUMBER */
|
||||
{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, /* TAG_STRING */
|
||||
{0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* TAG_TABLE */
|
||||
{1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0}, /* TAG_LCLOSURE */
|
||||
{1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0}, /* TAG_CCLOSURE */
|
||||
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1} /* TAG_NIL */
|
||||
{1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* LUA_TUSERDATA */
|
||||
{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}, /* LUA_TNIL */
|
||||
{1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1}, /* LUA_TNUMBER */
|
||||
{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, /* LUA_TSTRING */
|
||||
{0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1}, /* LUA_TTABLE */
|
||||
{1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0} /* LUA_TFUNCTION */
|
||||
};
|
||||
|
||||
int luaT_validevent (int t, int e) { /* ORDER LUA_T */
|
||||
return (t > TAG_NIL) ? 1 : luaT_validevents[t][e];
|
||||
return (t >= NUM_TAGS) ? 1 : luaT_validevents[t][e];
|
||||
}
|
||||
|
||||
|
||||
static void init_entry (lua_State *L, int tag) {
|
||||
int i;
|
||||
for (i=0; i<IM_N; i++)
|
||||
ttype(luaT_getim(L, tag, i)) = TAG_NIL;
|
||||
ttype(luaT_getim(L, tag, i)) = LUA_TNIL;
|
||||
L->IMtable[tag].collected = NULL;
|
||||
}
|
||||
|
||||
|
|
@ -100,7 +99,7 @@ static void checktag (lua_State *L, int tag) {
|
|||
}
|
||||
|
||||
void luaT_realtag (lua_State *L, int tag) {
|
||||
if (!(NUM_TAGS <= tag && tag <= L->last_tag))
|
||||
if (!validtag(tag))
|
||||
luaO_verror(L, "tag %d was not created by `newtag'", tag);
|
||||
}
|
||||
|
||||
|
|
@ -117,20 +116,12 @@ int lua_copytagmethods (lua_State *L, int tagto, int tagfrom) {
|
|||
}
|
||||
|
||||
|
||||
const TObject *luaT_gettagmethods (lua_State *L, const TObject *o) {
|
||||
lua_Tag t = ttype(o);
|
||||
int luaT_tag (const TObject *o) {
|
||||
int t = ttype(o);
|
||||
switch (t) {
|
||||
case TAG_USERDATA: {
|
||||
int tag = tsvalue(o)->u.d.tag;
|
||||
if (tag > L->last_tag)
|
||||
return L->IMtable[TAG_USERDATA].int_method;
|
||||
else
|
||||
return L->IMtable[tag].int_method;
|
||||
}
|
||||
case TAG_TABLE:
|
||||
return L->IMtable[hvalue(o)->htag].int_method;
|
||||
default:
|
||||
return L->IMtable[(int)t].int_method;;
|
||||
case LUA_TUSERDATA: return tsvalue(o)->u.d.tag;
|
||||
case LUA_TTABLE: return hvalue(o)->htag;
|
||||
default: return t;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -142,7 +133,7 @@ void lua_gettagmethod (lua_State *L, int t, const char *event) {
|
|||
if (luaT_validevent(t, e))
|
||||
*L->top = *luaT_getim(L, t,e);
|
||||
else
|
||||
ttype(L->top) = TAG_NIL;
|
||||
ttype(L->top) = LUA_TNIL;
|
||||
incr_top;
|
||||
}
|
||||
|
||||
|
|
@ -156,8 +147,8 @@ void lua_settagmethod (lua_State *L, int t, const char *event) {
|
|||
checktag(L, t);
|
||||
if (!luaT_validevent(t, e))
|
||||
luaO_verror(L, "cannot change `%.20s' tag method for type `%.20s'%.20s",
|
||||
luaT_eventname[e], lua_typename(L, luaO_tag2type(t)),
|
||||
(t == TAG_TABLE || t == TAG_USERDATA) ? " with default tag"
|
||||
luaT_eventname[e], luaO_typenames[t],
|
||||
(t == LUA_TTABLE || t == LUA_TUSERDATA) ? " with default tag"
|
||||
: "");
|
||||
temp = *(L->top - 1);
|
||||
*(L->top - 1) = *luaT_getim(L, t,e);
|
||||
|
|
|
|||
9
ltm.h
9
ltm.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: ltm.h,v 1.15 2000/09/05 19:33:32 roberto Exp roberto $
|
||||
** $Id: ltm.h,v 1.16 2000/10/03 14:27:44 roberto Exp roberto $
|
||||
** Tag methods
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -42,14 +42,17 @@ struct IM {
|
|||
|
||||
|
||||
#define luaT_getim(L,tag,event) (&L->IMtable[tag].int_method[event])
|
||||
#define luaT_getimbyObj(L,o,e) (&luaT_gettagmethods((L),(o))[e])
|
||||
#define luaT_getimbyObj(L,o,e) (luaT_getim((L),luaT_tag(o),(e)))
|
||||
|
||||
|
||||
#define validtag(t) (NUM_TAGS <= (t) && (t) <= L->last_tag)
|
||||
|
||||
extern const char *const luaT_eventname[];
|
||||
|
||||
|
||||
void luaT_init (lua_State *L);
|
||||
void luaT_realtag (lua_State *L, int tag);
|
||||
const TObject *luaT_gettagmethods (lua_State *L, const TObject *o);
|
||||
int luaT_tag (const TObject *o);
|
||||
int luaT_validevent (int t, int e); /* used by compatibility module */
|
||||
|
||||
|
||||
|
|
|
|||
23
lua.h
23
lua.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lua.h,v 1.71 2000/10/02 14:47:43 roberto Exp roberto $
|
||||
** $Id: lua.h,v 1.72 2000/10/02 20:10:55 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
|
||||
|
|
@ -47,11 +47,17 @@ typedef struct lua_State lua_State;
|
|||
|
||||
typedef int (*lua_CFunction) (lua_State *L);
|
||||
|
||||
/*
|
||||
** types returned by `lua_type'
|
||||
*/
|
||||
#define LUA_TNONE (-1)
|
||||
|
||||
typedef enum lua_Type {
|
||||
LUA_NOVALUE, LUA_TUSERDATA, LUA_TNUMBER, LUA_TSTRING,
|
||||
LUA_TTABLE, LUA_TFUNCTION, LUA_TNIL
|
||||
} lua_Type;
|
||||
#define LUA_TUSERDATA 0
|
||||
#define LUA_TNIL 1
|
||||
#define LUA_TNUMBER 2
|
||||
#define LUA_TSTRING 3
|
||||
#define LUA_TTABLE 4
|
||||
#define LUA_TFUNCTION 5
|
||||
|
||||
|
||||
|
||||
|
|
@ -77,8 +83,8 @@ int lua_stackspace (lua_State *L);
|
|||
** access functions (stack -> C)
|
||||
*/
|
||||
|
||||
lua_Type lua_type (lua_State *L, int index);
|
||||
const char *lua_typename (lua_State *L, lua_Type t);
|
||||
int lua_type (lua_State *L, int index);
|
||||
const char *lua_typename (lua_State *L, int t);
|
||||
int lua_isnumber (lua_State *L, int index);
|
||||
int lua_isstring (lua_State *L, int index);
|
||||
int lua_iscfunction (lua_State *L, int index);
|
||||
|
|
@ -184,7 +190,7 @@ void lua_concat (lua_State *L, int n);
|
|||
#define lua_istable(L,n) (lua_type(L,n) == LUA_TTABLE)
|
||||
#define lua_isuserdata(L,n) (lua_type(L,n) == LUA_TUSERDATA)
|
||||
#define lua_isnil(L,n) (lua_type(L,n) == LUA_TNIL)
|
||||
#define lua_isnull(L,n) (lua_type(L,n) == LUA_NOVALUE)
|
||||
#define lua_isnull(L,n) (lua_type(L,n) == LUA_TNONE)
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -224,3 +230,4 @@ void lua_concat (lua_State *L, int n);
|
|||
*
|
||||
* This implementation contains no third-party code.
|
||||
******************************************************************************/
|
||||
|
||||
|
|
|
|||
112
lvm.c
112
lvm.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lvm.c,v 1.141 2000/10/03 14:27:44 roberto Exp roberto $
|
||||
** $Id: lvm.c,v 1.142 2000/10/04 12:16:08 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -40,25 +40,25 @@
|
|||
|
||||
|
||||
int luaV_tonumber (TObject *obj) {
|
||||
if (ttype(obj) != TAG_STRING)
|
||||
if (ttype(obj) != LUA_TSTRING)
|
||||
return 1;
|
||||
else {
|
||||
if (!luaO_str2d(svalue(obj), &nvalue(obj)))
|
||||
return 2;
|
||||
ttype(obj) = TAG_NUMBER;
|
||||
ttype(obj) = LUA_TNUMBER;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int luaV_tostring (lua_State *L, TObject *obj) { /* LUA_NUMBER */
|
||||
if (ttype(obj) != TAG_NUMBER)
|
||||
if (ttype(obj) != LUA_TNUMBER)
|
||||
return 1;
|
||||
else {
|
||||
char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */
|
||||
lua_number2str(s, nvalue(obj)); /* convert `s' to number */
|
||||
tsvalue(obj) = luaS_new(L, s);
|
||||
ttype(obj) = TAG_STRING;
|
||||
ttype(obj) = LUA_TSTRING;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
|
@ -85,27 +85,29 @@ static void traceexec (lua_State *L, StkId base, StkId top, lua_Hook linehook) {
|
|||
}
|
||||
|
||||
|
||||
static Closure *luaV_closure (lua_State *L, lua_Tag t, int nelems) {
|
||||
static Closure *luaV_closure (lua_State *L, int nelems) {
|
||||
Closure *c = luaF_newclosure(L, nelems);
|
||||
L->top -= nelems;
|
||||
while (nelems--)
|
||||
c->upvalue[nelems] = *(L->top+nelems);
|
||||
ttype(L->top) = t;
|
||||
clvalue(L->top) = c;
|
||||
ttype(L->top) = LUA_TFUNCTION;
|
||||
incr_top;
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
void luaV_Cclosure (lua_State *L, lua_CFunction c, int nelems) {
|
||||
Closure *cl = luaV_closure(L, TAG_CCLOSURE, nelems);
|
||||
Closure *cl = luaV_closure(L, nelems);
|
||||
cl->f.c = c;
|
||||
cl->isC = 1;
|
||||
}
|
||||
|
||||
|
||||
void luaV_Lclosure (lua_State *L, Proto *l, int nelems) {
|
||||
Closure *cl = luaV_closure(L, TAG_LCLOSURE, nelems);
|
||||
Closure *cl = luaV_closure(L, nelems);
|
||||
cl->f.l = l;
|
||||
cl->isC = 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -116,21 +118,21 @@ void luaV_Lclosure (lua_State *L, Proto *l, int nelems) {
|
|||
const TObject *luaV_gettable (lua_State *L, StkId t) {
|
||||
const TObject *im;
|
||||
int tg;
|
||||
if (ttype(t) == TAG_TABLE && /* `t' is a table? */
|
||||
((tg = hvalue(t)->htag) == TAG_TABLE || /* with default tag? */
|
||||
ttype(luaT_getim(L, tg, IM_GETTABLE)) == TAG_NIL)) { /* or no TM? */
|
||||
if (ttype(t) == LUA_TTABLE && /* `t' is a table? */
|
||||
((tg = hvalue(t)->htag) == LUA_TTABLE || /* with default tag? */
|
||||
ttype(luaT_getim(L, tg, IM_GETTABLE)) == LUA_TNIL)) { /* or no TM? */
|
||||
/* do a primitive get */
|
||||
const TObject *h = luaH_get(L, hvalue(t), L->top-1);
|
||||
/* result is no nil or there is no `index' tag method? */
|
||||
if (ttype(h) != TAG_NIL ||
|
||||
(ttype(im=luaT_getim(L, tg, IM_INDEX)) == TAG_NIL))
|
||||
if (ttype(h) != LUA_TNIL ||
|
||||
(ttype(im=luaT_getim(L, tg, IM_INDEX)) == LUA_TNIL))
|
||||
return h; /* return result */
|
||||
/* else call `index' tag method */
|
||||
}
|
||||
else { /* try a 'gettable' TM */
|
||||
else { /* try a `gettable' tag method */
|
||||
im = luaT_getimbyObj(L, t, IM_GETTABLE);
|
||||
}
|
||||
if (ttype(im) != TAG_NIL) { /* is there a tag method? */
|
||||
if (ttype(im) != LUA_TNIL) { /* is there a tag method? */
|
||||
luaD_checkstack(L, 2);
|
||||
*(L->top+1) = *(L->top-1); /* key */
|
||||
*L->top = *t; /* table */
|
||||
|
|
@ -151,13 +153,13 @@ const TObject *luaV_gettable (lua_State *L, StkId t) {
|
|||
*/
|
||||
void luaV_settable (lua_State *L, StkId t, StkId key) {
|
||||
int tg;
|
||||
if (ttype(t) == TAG_TABLE && /* `t' is a table? */
|
||||
((tg = hvalue(t)->htag) == TAG_TABLE || /* with default tag? */
|
||||
ttype(luaT_getim(L, tg, IM_SETTABLE)) == TAG_NIL)) /* or no TM? */
|
||||
if (ttype(t) == LUA_TTABLE && /* `t' is a table? */
|
||||
((tg = hvalue(t)->htag) == LUA_TTABLE || /* with default tag? */
|
||||
ttype(luaT_getim(L, tg, IM_SETTABLE)) == LUA_TNIL)) /* or no TM? */
|
||||
*luaH_set(L, hvalue(t), key) = *(L->top-1); /* do a primitive set */
|
||||
else { /* try a `settable' tag method */
|
||||
const TObject *im = luaT_getimbyObj(L, t, IM_SETTABLE);
|
||||
if (ttype(im) != TAG_NIL) {
|
||||
if (ttype(im) != LUA_TNIL) {
|
||||
luaD_checkstack(L, 3);
|
||||
*(L->top+2) = *(L->top-1);
|
||||
*(L->top+1) = *key;
|
||||
|
|
@ -175,12 +177,12 @@ void luaV_settable (lua_State *L, StkId t, StkId key) {
|
|||
const TObject *luaV_getglobal (lua_State *L, TString *s) {
|
||||
const TObject *value = luaH_getstr(L->gt, s);
|
||||
const TObject *im = luaT_getimbyObj(L, value, IM_GETGLOBAL);
|
||||
if (ttype(im) == TAG_NIL) /* is there a tag method? */
|
||||
if (ttype(im) == LUA_TNIL) /* is there a tag method? */
|
||||
return value; /* default behavior */
|
||||
else { /* tag method */
|
||||
luaD_checkstack(L, 3);
|
||||
*L->top = *im;
|
||||
ttype(L->top+1) = TAG_STRING;
|
||||
ttype(L->top+1) = LUA_TSTRING;
|
||||
tsvalue(L->top+1) = s; /* global name */
|
||||
*(L->top+2) = *value;
|
||||
L->top += 3;
|
||||
|
|
@ -193,14 +195,14 @@ const TObject *luaV_getglobal (lua_State *L, TString *s) {
|
|||
void luaV_setglobal (lua_State *L, TString *s) {
|
||||
const TObject *oldvalue = luaH_getstr(L->gt, s);
|
||||
const TObject *im = luaT_getimbyObj(L, oldvalue, IM_SETGLOBAL);
|
||||
if (ttype(im) == TAG_NIL) { /* is there a tag method? */
|
||||
if (ttype(im) == LUA_TNIL) { /* is there a tag method? */
|
||||
if (oldvalue != &luaO_nilobject) {
|
||||
/* cast to remove `const' is OK, because `oldvalue' != luaO_nilobject */
|
||||
*(TObject *)oldvalue = *(L->top - 1);
|
||||
}
|
||||
else {
|
||||
TObject key;
|
||||
ttype(&key) = TAG_STRING;
|
||||
ttype(&key) = LUA_TSTRING;
|
||||
tsvalue(&key) = s;
|
||||
*luaH_set(L, L->gt, &key) = *(L->top - 1);
|
||||
}
|
||||
|
|
@ -209,7 +211,7 @@ void luaV_setglobal (lua_State *L, TString *s) {
|
|||
luaD_checkstack(L, 3);
|
||||
*(L->top+2) = *(L->top-1); /* new value */
|
||||
*(L->top+1) = *oldvalue;
|
||||
ttype(L->top) = TAG_STRING;
|
||||
ttype(L->top) = LUA_TSTRING;
|
||||
tsvalue(L->top) = s;
|
||||
*(L->top-1) = *im;
|
||||
L->top += 3;
|
||||
|
|
@ -222,11 +224,11 @@ static int call_binTM (lua_State *L, StkId top, IMS event) {
|
|||
/* try first operand */
|
||||
const TObject *im = luaT_getimbyObj(L, top-2, event);
|
||||
L->top = top;
|
||||
if (ttype(im) == TAG_NIL) {
|
||||
if (ttype(im) == LUA_TNIL) {
|
||||
im = luaT_getimbyObj(L, top-1, event); /* try second operand */
|
||||
if (ttype(im) == TAG_NIL) {
|
||||
if (ttype(im) == LUA_TNIL) {
|
||||
im = luaT_getim(L, 0, event); /* try a `global' method */
|
||||
if (ttype(im) == TAG_NIL)
|
||||
if (ttype(im) == LUA_TNIL)
|
||||
return 0; /* error */
|
||||
}
|
||||
}
|
||||
|
|
@ -238,7 +240,7 @@ static int call_binTM (lua_State *L, StkId top, IMS event) {
|
|||
|
||||
static void call_arith (lua_State *L, StkId top, IMS event) {
|
||||
if (!call_binTM(L, top, event))
|
||||
luaG_binerror(L, top-2, TAG_NUMBER, "perform arithmetic on");
|
||||
luaG_binerror(L, top-2, LUA_TNUMBER, "perform arithmetic on");
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -265,9 +267,9 @@ static int luaV_strcomp (const TString *ls, const TString *rs) {
|
|||
|
||||
|
||||
int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r, StkId top) {
|
||||
if (ttype(l) == TAG_NUMBER && ttype(r) == TAG_NUMBER)
|
||||
if (ttype(l) == LUA_TNUMBER && ttype(r) == LUA_TNUMBER)
|
||||
return (nvalue(l) < nvalue(r));
|
||||
else if (ttype(l) == TAG_STRING && ttype(r) == TAG_STRING)
|
||||
else if (ttype(l) == LUA_TSTRING && ttype(r) == LUA_TSTRING)
|
||||
return (luaV_strcomp(tsvalue(l), tsvalue(r)) < 0);
|
||||
else { /* call TM */
|
||||
luaD_checkstack(L, 2);
|
||||
|
|
@ -276,7 +278,7 @@ int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r, StkId top)
|
|||
if (!call_binTM(L, top, IM_LT))
|
||||
luaG_ordererror(L, top-2);
|
||||
L->top--;
|
||||
return (ttype(L->top) != TAG_NIL);
|
||||
return (ttype(L->top) != LUA_TNIL);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -286,7 +288,7 @@ void luaV_strconc (lua_State *L, int total, StkId top) {
|
|||
int n = 2; /* number of elements handled in this pass (at least 2) */
|
||||
if (tostring(L, top-2) || tostring(L, top-1)) {
|
||||
if (!call_binTM(L, top, IM_CONCAT))
|
||||
luaG_binerror(L, top-2, TAG_STRING, "concat");
|
||||
luaG_binerror(L, top-2, LUA_TSTRING, "concat");
|
||||
}
|
||||
else if (tsvalue(top-1)->u.s.len > 0) { /* if len=0, do nothing */
|
||||
/* at least two string values; get as many as possible */
|
||||
|
|
@ -322,7 +324,7 @@ static void luaV_pack (lua_State *L, StkId firstelem) {
|
|||
/* store counter in field `n' */
|
||||
luaH_setstrnum(L, htab, luaS_new(L, "n"), i);
|
||||
L->top = firstelem; /* remove elements from the stack */
|
||||
ttype(L->top) = TAG_TABLE;
|
||||
ttype(L->top) = LUA_TTABLE;
|
||||
hvalue(L->top) = htab;
|
||||
incr_top;
|
||||
}
|
||||
|
|
@ -393,7 +395,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
int n = GETARG_U(i);
|
||||
LUA_ASSERT(n>0, "invalid argument");
|
||||
do {
|
||||
ttype(top++) = TAG_NIL;
|
||||
ttype(top++) = LUA_TNIL;
|
||||
} while (--n > 0);
|
||||
break;
|
||||
}
|
||||
|
|
@ -402,25 +404,25 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
break;
|
||||
}
|
||||
case OP_PUSHINT: {
|
||||
ttype(top) = TAG_NUMBER;
|
||||
ttype(top) = LUA_TNUMBER;
|
||||
nvalue(top) = (Number)GETARG_S(i);
|
||||
top++;
|
||||
break;
|
||||
}
|
||||
case OP_PUSHSTRING: {
|
||||
ttype(top) = TAG_STRING;
|
||||
ttype(top) = LUA_TSTRING;
|
||||
tsvalue(top) = kstr[GETARG_U(i)];
|
||||
top++;
|
||||
break;
|
||||
}
|
||||
case OP_PUSHNUM: {
|
||||
ttype(top) = TAG_NUMBER;
|
||||
ttype(top) = LUA_TNUMBER;
|
||||
nvalue(top) = tf->knum[GETARG_U(i)];
|
||||
top++;
|
||||
break;
|
||||
}
|
||||
case OP_PUSHNEGNUM: {
|
||||
ttype(top) = TAG_NUMBER;
|
||||
ttype(top) = LUA_TNUMBER;
|
||||
nvalue(top) = -tf->knum[GETARG_U(i)];
|
||||
top++;
|
||||
break;
|
||||
|
|
@ -446,7 +448,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
break;
|
||||
}
|
||||
case OP_GETDOTTED: {
|
||||
ttype(top) = TAG_STRING;
|
||||
ttype(top) = LUA_TSTRING;
|
||||
tsvalue(top) = kstr[GETARG_U(i)];
|
||||
L->top = top+1;
|
||||
*(top-1) = *luaV_gettable(L, top-1);
|
||||
|
|
@ -461,7 +463,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
case OP_PUSHSELF: {
|
||||
TObject receiver;
|
||||
receiver = *(top-1);
|
||||
ttype(top) = TAG_STRING;
|
||||
ttype(top) = LUA_TSTRING;
|
||||
tsvalue(top++) = kstr[GETARG_U(i)];
|
||||
L->top = top;
|
||||
*(top-2) = *luaV_gettable(L, top-2);
|
||||
|
|
@ -472,7 +474,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
L->top = top;
|
||||
luaC_checkGC(L);
|
||||
hvalue(top) = luaH_new(L, GETARG_U(i));
|
||||
ttype(top) = TAG_TABLE;
|
||||
ttype(top) = LUA_TTABLE;
|
||||
top++;
|
||||
break;
|
||||
}
|
||||
|
|
@ -523,7 +525,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
}
|
||||
case OP_ADDI: {
|
||||
if (tonumber(top-1)) {
|
||||
ttype(top) = TAG_NUMBER;
|
||||
ttype(top) = LUA_TNUMBER;
|
||||
nvalue(top) = (Number)GETARG_S(i);
|
||||
call_arith(L, top+1, IM_ADD);
|
||||
}
|
||||
|
|
@ -571,7 +573,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
}
|
||||
case OP_MINUS: {
|
||||
if (tonumber(top-1)) {
|
||||
ttype(top) = TAG_NIL;
|
||||
ttype(top) = LUA_TNIL;
|
||||
call_arith(L, top+1, IM_UNM);
|
||||
}
|
||||
else
|
||||
|
|
@ -580,7 +582,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
}
|
||||
case OP_NOT: {
|
||||
ttype(top-1) =
|
||||
(ttype(top-1) == TAG_NIL) ? TAG_NUMBER : TAG_NIL;
|
||||
(ttype(top-1) == LUA_TNIL) ? LUA_TNUMBER : LUA_TNIL;
|
||||
nvalue(top-1) = 1;
|
||||
break;
|
||||
}
|
||||
|
|
@ -615,20 +617,20 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
break;
|
||||
}
|
||||
case OP_JMPT: {
|
||||
if (ttype(--top) != TAG_NIL) dojump(pc, i);
|
||||
if (ttype(--top) != LUA_TNIL) dojump(pc, i);
|
||||
break;
|
||||
}
|
||||
case OP_JMPF: {
|
||||
if (ttype(--top) == TAG_NIL) dojump(pc, i);
|
||||
if (ttype(--top) == LUA_TNIL) dojump(pc, i);
|
||||
break;
|
||||
}
|
||||
case OP_JMPONT: {
|
||||
if (ttype(top-1) == TAG_NIL) top--;
|
||||
if (ttype(top-1) == LUA_TNIL) top--;
|
||||
else dojump(pc, i);
|
||||
break;
|
||||
}
|
||||
case OP_JMPONF: {
|
||||
if (ttype(top-1) != TAG_NIL) top--;
|
||||
if (ttype(top-1) != LUA_TNIL) top--;
|
||||
else dojump(pc, i);
|
||||
break;
|
||||
}
|
||||
|
|
@ -637,7 +639,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
break;
|
||||
}
|
||||
case OP_PUSHNILJMP: {
|
||||
ttype(top++) = TAG_NIL;
|
||||
ttype(top++) = LUA_TNIL;
|
||||
pc++;
|
||||
break;
|
||||
}
|
||||
|
|
@ -657,9 +659,9 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
break;
|
||||
}
|
||||
case OP_FORLOOP: {
|
||||
LUA_ASSERT(ttype(top-1) == TAG_NUMBER, "invalid step");
|
||||
LUA_ASSERT(ttype(top-2) == TAG_NUMBER, "invalid limit");
|
||||
if (ttype(top-3) != TAG_NUMBER)
|
||||
LUA_ASSERT(ttype(top-1) == LUA_TNUMBER, "invalid step");
|
||||
LUA_ASSERT(ttype(top-2) == LUA_TNUMBER, "invalid limit");
|
||||
if (ttype(top-3) != LUA_TNUMBER)
|
||||
lua_error(L, "`for' index must be a number");
|
||||
nvalue(top-3) += nvalue(top-1); /* increment index */
|
||||
if (nvalue(top-1) > 0 ?
|
||||
|
|
@ -672,7 +674,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
}
|
||||
case OP_LFORPREP: {
|
||||
Node *node;
|
||||
if (ttype(top-1) != TAG_TABLE)
|
||||
if (ttype(top-1) != LUA_TTABLE)
|
||||
lua_error(L, "`for' table must be a table");
|
||||
node = luaH_next(L, hvalue(top-1), &luaO_nilobject);
|
||||
if (node == NULL) { /* `empty' loop? */
|
||||
|
|
@ -688,7 +690,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
|
|||
}
|
||||
case OP_LFORLOOP: {
|
||||
Node *node;
|
||||
LUA_ASSERT(ttype(top-3) == TAG_TABLE, "invalid table");
|
||||
LUA_ASSERT(ttype(top-3) == LUA_TTABLE, "invalid table");
|
||||
node = luaH_next(L, hvalue(top-3), top-2);
|
||||
if (node == NULL) /* end loop? */
|
||||
top -= 3; /* remove table, key, and value */
|
||||
|
|
|
|||
6
lvm.h
6
lvm.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lvm.h,v 1.25 2000/08/31 21:02:55 roberto Exp roberto $
|
||||
** $Id: lvm.h,v 1.26 2000/09/05 19:33:32 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -13,8 +13,8 @@
|
|||
#include "ltm.h"
|
||||
|
||||
|
||||
#define tonumber(o) ((ttype(o) != TAG_NUMBER) && (luaV_tonumber(o) != 0))
|
||||
#define tostring(L,o) ((ttype(o) != TAG_STRING) && (luaV_tostring(L, o) != 0))
|
||||
#define tonumber(o) ((ttype(o) != LUA_TNUMBER) && (luaV_tonumber(o) != 0))
|
||||
#define tostring(L,o) ((ttype(o) != LUA_TSTRING) && (luaV_tostring(L, o) != 0))
|
||||
|
||||
|
||||
int luaV_tonumber (TObject *obj);
|
||||
|
|
|
|||
Loading…
Reference in New Issue