/*

** $Id: lapi.c $

** Lua API

** See Copyright Notice in lua.h

*/

#define lapi_c

#define LUA_CORE

#include "lprefix.h"

#include <limits.h>

#include <stdarg.h>

#include <string.h>

#include "lua.h"

#include "lapi.h"

#include "ldebug.h"

#include "ldo.h"

#include "lfunc.h"

#include "lgc.h"

#include "lmem.h"

#include "lobject.h"

#include "lstate.h"

#include "lstring.h"

#include "ltable.h"

#include "larray.h"

#include "ltm.h"

#include "lundump.h"

#include "lvm.h"

const char lua_ident[] =

"$LuaVersion: " LUA_COPYRIGHT " $"

"$LuaAuthors: " LUA_AUTHORS " $";

/*

** Test for a valid index (one that is not the 'nilvalue').

** '!ttisnil(o)' implies 'o != &G(L)->nilvalue', so it is not needed.

** However, it covers the most common cases in a faster way.

*/

#define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue)

/* test for pseudo index */

#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX)

/* test for upvalue */

#define isupvalue(i) ((i) < LUA_REGISTRYINDEX)

static TValue *index2value (lua_State *L, int idx) {

CallInfo *ci = L->ci;

if (idx > 0) {

StkId o = ci->func + idx;

api_check(L, idx <= L->ci->top - (ci->func + 1), "unacceptable index");

if (o >= L->top) return &G(L)->nilvalue;

else return s2v(o);

}

else if (!ispseudo(idx)) { /* negative index */

api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");

return s2v(L->top + idx);

}

else if (idx == LUA_REGISTRYINDEX)

return &G(L)->l_registry;

else { /* upvalues */

idx = LUA_REGISTRYINDEX - idx;

api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");

if (ttislcf(s2v(ci->func))) /* light C function? */

return &G(L)->nilvalue; /* it has no upvalues */

else {

CClosure *func = clCvalue(s2v(ci->func));

return (idx <= func->nupvalues) ? &func->upvalue[idx-1]

: &G(L)->nilvalue;

}

}

}

static StkId index2stack (lua_State *L, int idx) {

CallInfo *ci = L->ci;

if (idx > 0) {

StkId o = ci->func + idx;

api_check(L, o < L->top, "unacceptable index");

return o;

}

else { /* non-positive index */

api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");

api_check(L, !ispseudo(idx), "invalid index");

return L->top + idx;

}

}

LUA_API int lua_checkstack (lua_State *L, int n) {

int res;

CallInfo *ci;

lua_lock(L);

ci = L->ci;

api_check(L, n >= 0, "negative 'n'");

if (L->stack_last - L->top > n) /* stack large enough? */

res = 1; /* yes; check is OK */

else { /* no; need to grow stack */

int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;

if (inuse > LUAI_MAXSTACK - n) /* can grow without overflow? */

res = 0; /* no */

else /* try to grow stack */

res = luaD_growstack(L, n, 0);

}

if (res && ci->top < L->top + n)

ci->top = L->top + n; /* adjust frame top */

lua_unlock(L);

return res;

}

LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {

int i;

if (from == to) return;

lua_lock(to);

api_checknelems(from, n);

api_check(from, G(from) == G(to), "moving among independent states");

api_check(from, to->ci->top - to->top >= n, "stack overflow");

from->top -= n;

for (i = 0; i < n; i++) {

setobjs2s(to, to->top, from->top + i);

to->top++; /* stack already checked by previous 'api_check' */

}

lua_unlock(to);

}

LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {

lua_CFunction old;

lua_lock(L);

old = G(L)->panic;

G(L)->panic = panicf;

lua_unlock(L);

return old;

}

LUA_API lua_Number lua_version (lua_State *L) {

UNUSED(L);

return LUA_VERSION_NUM;

}

/*

** basic stack manipulation

*/

/*

** convert an acceptable stack index into an absolute index

*/

LUA_API int lua_absindex (lua_State *L, int idx) {

return (idx > 0 || ispseudo(idx))

? idx

: cast_int(L->top - L->ci->func) + idx;

}

LUA_API int lua_gettop (lua_State *L) {

return cast_int(L->top - (L->ci->func + 1));

}

LUA_API void lua_settop (lua_State *L, int idx) {

CallInfo *ci;

StkId func, newtop;

ptrdiff_t diff; /* difference for new top */

lua_lock(L);

ci = L->ci;

func = ci->func;

if (idx >= 0) {

api_check(L, idx <= ci->top - (func + 1), "new top too large");

diff = ((func + 1) + idx) - L->top;

for (; diff > 0; diff--)

setnilvalue(s2v(L->top++)); /* clear new slots */

}

else {

api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");

diff = idx + 1; /* will "subtract" index (as it is negative) */

}

api_check(L, L->tbclist < L->top, "previous pop of an unclosed slot");

newtop = L->top + diff;

if (diff < 0 && L->tbclist >= newtop) {

lua_assert(hastocloseCfunc(ci->nresults));

luaF_close(L, newtop, CLOSEKTOP, 0);

}

L->top = newtop; /* correct top only after closing any upvalue */

lua_unlock(L);

}

LUA_API void lua_closeslot (lua_State *L, int idx) {

StkId level;

lua_lock(L);

level = index2stack(L, idx);

api_check(L, hastocloseCfunc(L->ci->nresults) && L->tbclist == level,

"no variable to close at given level");

luaF_close(L, level, CLOSEKTOP, 0);

level = index2stack(L, idx); /* stack may be moved */

setnilvalue(s2v(level));

lua_unlock(L);

}

/*

** Reverse the stack segment from 'from' to 'to'

** (auxiliary to 'lua_rotate')

** Note that we move(copy) only the value inside the stack.

** (We do not move additional fields that may exist.)

*/

static void reverse (lua_State *L, StkId from, StkId to) {

for (; from < to; from++, to--) {

TValue temp;

setobj(L, &temp, s2v(from));

setobjs2s(L, from, to);

setobj2s(L, to, &temp);

}

}

/*

** Let x = AB, where A is a prefix of length 'n'. Then,

** rotate x n == BA. But BA == (A^r . B^r)^r.

*/

LUA_API void lua_rotate (lua_State *L, int idx, int n) {

StkId p, t, m;

lua_lock(L);

t = L->top - 1; /* end of stack segment being rotated */

p = index2stack(L, idx); /* start of segment */

api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");

m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */

reverse(L, p, m); /* reverse the prefix with length 'n' */

reverse(L, m + 1, t); /* reverse the suffix */

reverse(L, p, t); /* reverse the entire segment */

lua_unlock(L);

}

LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {

TValue *fr, *to;

lua_lock(L);

fr = index2value(L, fromidx);

to = index2value(L, toidx);

api_check(L, isvalid(L, to), "invalid index");

setobj(L, to, fr);

if (isupvalue(toidx)) /* function upvalue? */

luaC_barrier(L, clCvalue(s2v(L->ci->func)), fr);

/* LUA_REGISTRYINDEX does not need gc barrier

(collector revisits it before finishing collection) */

lua_unlock(L);

}

LUA_API void lua_pushvalue (lua_State *L, int idx) {

lua_lock(L);

setobj2s(L, L->top, index2value(L, idx));

api_incr_top(L);

lua_unlock(L);

}

/*

** access functions (stack -> C)

*/

LUA_API int lua_type (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return (isvalid(L, o) ? ttype(o) : LUA_TNONE);

}

LUA_API const char *lua_typename (lua_State *L, int t) {

UNUSED(L);

api_check(L, LUA_TNONE <= t && t < LUA_NUMTYPES, "invalid type");

return ttypename(t);

}

LUA_API int lua_iscfunction (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return (ttislcf(o) || (ttisCclosure(o)));

}

LUA_API int lua_isinteger (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return ttisinteger(o);

}

LUA_API int lua_isnumber (lua_State *L, int idx) {

lua_Number n;

const TValue *o = index2value(L, idx);

return tonumber(o, &n);

}

LUA_API int lua_isstring (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return (ttisstring(o) || cvt2str(o));

}

LUA_API int lua_isuserdata (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return (ttisfulluserdata(o) || ttislightuserdata(o));

}

LUA_API int lua_isarray (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return (isvalid(L, o) && ttype(o) == LUA_TTABLE && hvalue(o)->truearray);

}

LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {

const TValue *o1 = index2value(L, index1);

const TValue *o2 = index2value(L, index2);

return (isvalid(L, o1) && isvalid(L, o2)) ? luaV_rawequalobj(o1, o2) : 0;

}

LUA_API void lua_arith (lua_State *L, int op) {

lua_lock(L);

if (op != LUA_OPUNM && op != LUA_OPBNOT)

api_checknelems(L, 2); /* all other operations expect two operands */

else { /* for unary operations, add fake 2nd operand */

api_checknelems(L, 1);

setobjs2s(L, L->top, L->top - 1);

api_incr_top(L);

}

/* first operand at top - 2, second at top - 1; result go to top - 2 */

luaO_arith(L, op, s2v(L->top - 2), s2v(L->top - 1), L->top - 2);

L->top--; /* remove second operand */

lua_unlock(L);

}

LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {

const TValue *o1;

const TValue *o2;

int i = 0;

lua_lock(L); /* may call tag method */

o1 = index2value(L, index1);

o2 = index2value(L, index2);

if (isvalid(L, o1) && isvalid(L, o2)) {

switch (op) {

case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;

case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;

case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;

default: api_check(L, 0, "invalid option");

}

}

lua_unlock(L);

return i;

}

LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {

size_t sz = luaO_str2num(s, s2v(L->top));

if (sz != 0)

api_incr_top(L);

return sz;

}

LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {

lua_Number n = 0;

const TValue *o = index2value(L, idx);

int isnum = tonumber(o, &n);

if (pisnum)

*pisnum = isnum;

return n;

}

LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {

lua_Integer res = 0;

const TValue *o = index2value(L, idx);

int isnum = tointeger(o, &res);

if (pisnum)

*pisnum = isnum;

return res;

}

LUA_API int lua_toboolean (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return !l_isfalse(o);

}

LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {

TValue *o;

lua_lock(L);

o = index2value(L, idx);

if (!ttisstring(o)) {

if (!cvt2str(o)) { /* not convertible? */

if (len != NULL) *len = 0;

lua_unlock(L);

return NULL;

}

luaO_tostring(L, o);

luaC_checkGC(L);

o = index2value(L, idx); /* previous call may reallocate the stack */

}

if (len != NULL)

*len = vslen(o);

lua_unlock(L);

return svalue(o);

}

LUA_API lua_Unsigned lua_rawlen (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

switch (ttypetag(o)) {

case LUA_VSHRSTR: return tsvalue(o)->shrlen;

case LUA_VLNGSTR: return tsvalue(o)->u.lnglen;

case LUA_VUSERDATA: return uvalue(o)->len;

case LUA_VTABLE: return luaH_getn(hvalue(o));

default: return 0;

}

}

LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

if (ttislcf(o)) return fvalue(o);

else if (ttisCclosure(o))

return clCvalue(o)->f;

else return NULL; /* not a C function */

}

static void *touserdata (const TValue *o) {

switch (ttype(o)) {

case LUA_TUSERDATA: return getudatamem(uvalue(o));

case LUA_TLIGHTUSERDATA: return pvalue(o);

default: return NULL;

}

}

LUA_API void *lua_touserdata (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return touserdata(o);

}

LUA_API lua_State *lua_tothread (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

return (!ttisthread(o)) ? NULL : thvalue(o);

}

/*

** Returns a pointer to the internal representation of an object.

** Note that ANSI C does not allow the conversion of a pointer to

** function to a 'void*', so the conversion here goes through

** a 'size_t'. (As the returned pointer is only informative, this

** conversion should not be a problem.)

*/

LUA_API const void *lua_topointer (lua_State *L, int idx) {

const TValue *o = index2value(L, idx);

switch (ttypetag(o)) {

case LUA_VLCF: return cast_voidp(cast_sizet(fvalue(o)));

case LUA_VUSERDATA: case LUA_VLIGHTUSERDATA:

return touserdata(o);

default: {

if (iscollectable(o))

return gcvalue(o);

else

return NULL;

}

}

}

/*

** push functions (C -> stack)

*/

LUA_API void lua_pushnil (lua_State *L) {

lua_lock(L);

setnilvalue(s2v(L->top));

api_incr_top(L);

lua_unlock(L);

}

LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {

lua_lock(L);

setfltvalue(s2v(L->top), n);

api_incr_top(L);

lua_unlock(L);

}

LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {

lua_lock(L);

setivalue(s2v(L->top), n);

api_incr_top(L);

lua_unlock(L);

}

/*

** Pushes on the stack a string with given length. Avoid using 's' when

** 'len' == 0 (as 's' can be NULL in that case), due to later use of

** 'memcmp' and 'memcpy'.

*/

LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {

TString *ts;

lua_lock(L);

ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);

setsvalue2s(L, L->top, ts);

api_incr_top(L);

luaC_checkGC(L);

lua_unlock(L);

return getstr(ts);

}

LUA_API const char *lua_pushstring (lua_State *L, const char *s) {

lua_lock(L);

if (s == NULL)

setnilvalue(s2v(L->top));

else {

TString *ts;

ts = luaS_new(L, s);

setsvalue2s(L, L->top, ts);

s = getstr(ts); /* internal copy's address */

}

api_incr_top(L);

luaC_checkGC(L);

lua_unlock(L);

return s;

}

LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,

va_list argp) {

const char *ret;

lua_lock(L);

ret = luaO_pushvfstring(L, fmt, argp);

luaC_checkGC(L);

lua_unlock(L);

return ret;

}

LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {

const char *ret;

va_list argp;

lua_lock(L);

va_start(argp, fmt);

ret = luaO_pushvfstring(L, fmt, argp);

va_end(argp);

luaC_checkGC(L);

lua_unlock(L);

return ret;

}

LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {

lua_lock(L);

if (n == 0) {

setfvalue(s2v(L->top), fn);

api_incr_top(L);

}

else {

CClosure *cl;

api_checknelems(L, n);

api_check(L, n <= MAXUPVAL, "upvalue index too large");

cl = luaF_newCclosure(L, n);

cl->f = fn;

L->top -= n;

while (n--) {

setobj2n(L, &cl->upvalue[n], s2v(L->top + n));

/* does not need barrier because closure is white */

lua_assert(iswhite(cl));

}

setclCvalue(L, s2v(L->top), cl);

api_incr_top(L);

luaC_checkGC(L);

}

lua_unlock(L);

}

LUA_API void lua_pushboolean (lua_State *L, int b) {

lua_lock(L);

if (b)

setbtvalue(s2v(L->top));

else

setbfvalue(s2v(L->top));

api_incr_top(L);

lua_unlock(L);

}

LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {

lua_lock(L);

setpvalue(s2v(L->top), p);

api_incr_top(L);

lua_unlock(L);

}

LUA_API int lua_pushthread (lua_State *L) {

lua_lock(L);

setthvalue(L, s2v(L->top), L);

api_incr_top(L);

lua_unlock(L);

return (G(L)->mainthread == L);

}

/*

** get functions (Lua -> stack)

*/

static int auxgetstr (lua_State *L, const TValue *t, const char *k) {

const TValue *slot;

TString *str = luaS_new(L, k);

if (luaV_fastget(L, t, str, slot, luaH_getstr)) {

setobj2s(L, L->top, slot);

api_incr_top(L);

}

else {

setsvalue2s(L, L->top, str);

api_incr_top(L);

luaV_finishget(L, t, s2v(L->top - 1), L->top - 1, slot);

}

lua_unlock(L);

return ttype(s2v(L->top - 1));

}

/*

** Get the global table in the registry. Since all predefined

** indices in the registry were inserted right when the registry

** was created and never removed, they must always be in the array

** part of the registry.

*/

#define getGtable(L) \

(&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1])

LUA_API int lua_getglobal (lua_State *L, const char *name) {

const TValue *G;

lua_lock(L);

G = getGtable(L);

return auxgetstr(L, G, name);

}

LUA_API int lua_gettable (lua_State *L, int idx) {

const TValue *slot;

TValue *t;

lua_lock(L);

t = index2value(L, idx);

if (luaV_fastget(L, t, s2v(L->top - 1), slot, luaH_get)) {

setobj2s(L, L->top - 1, slot);

}

else

luaV_finishget(L, t, s2v(L->top - 1), L->top - 1, slot);

lua_unlock(L);

return ttype(s2v(L->top - 1));

}

LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {

lua_lock(L);

return auxgetstr(L, index2value(L, idx), k);

}

LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {

TValue *t;

const TValue *slot;

lua_lock(L);

t = index2value(L, idx);

if (luaV_fastgeti(L, t, n, slot)) {

setobj2s(L, L->top, slot);

}

else {

TValue aux;

setivalue(&aux, n);

luaV_finishget(L, t, &aux, L->top, slot);

}

api_incr_top(L);

lua_unlock(L);

return ttype(s2v(L->top - 1));

}

static int finishrawget (lua_State *L, const TValue *val) {

if (isempty(val)) /* avoid copying empty items to the stack */

setnilvalue(s2v(L->top));

else

setobj2s(L, L->top, val);

api_incr_top(L);

lua_unlock(L);

return ttype(s2v(L->top - 1));

}

static Table *gettable (lua_State *L, int idx) {

TValue *t = index2value(L, idx);

api_check(L, ttistable(t), "table expected");

return hvalue(t);

}

LUA_API int lua_rawget (lua_State *L, int idx) {

Table *t;

const TValue *val;

lua_lock(L);

api_checknelems(L, 1);

t = gettable(L, idx);

val = luaH_get(t, s2v(L->top - 1));

L->top--; /* remove key */

return finishrawget(L, val);

}

LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {

Table *t;

lua_lock(L);

t = gettable(L, idx);

return finishrawget(L, luaH_getint(t, n));

}

LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {

Table *t;

TValue k;

lua_lock(L);

t = gettable(L, idx);

setpvalue(&k, cast_voidp(p));

return finishrawget(L, luaH_get(t, &k));

}

LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {

Table *t;

lua_lock(L);

t = luaH_new(L);

sethvalue2s(L, L->top, t);

api_incr_top(L);

if (narray > 0 || nrec > 0) {

luaH_resize(L, t, narray, nrec);

}

luaC_checkGC(L);

lua_unlock(L);

}

LUA_API void lua_createarray (lua_State *L, int narray) {

Array *a;

lua_lock(L);

a = luaA_new(L);

setavalue2s(L, L->top, a);

api_incr_top(L);

if (narray > 0)

luaA_resize(L, a, narray);

luaC_checkGC(L);

lua_unlock(L);

}

LUA_API void lua_resize (lua_State *L, int idx, unsigned int size) {

TValue *o;

Table *t;

unsigned int i, oldsize;

lua_lock(L);

o = index2value(L, idx);

api_check(L, ttistable(o), "table expected");

t = hvalue(o);

oldsize = t->sizeused;

if (size > luaH_realasize(t)) {

luaH_resizearray(L, t, size);

}

lua_unlock(L);

/* set removed elements to nil when shrinking array size */

for(i = size + 1; i <= oldsize; i++) {

lua_pushnil(L);

lua_seti(L, idx, i);

}

t->sizeused = size;

}

LUA_API int lua_getmetatable (lua_State *L, int objindex) {

const TValue *obj;

Table *mt;

int res = 0;

lua_lock(L);

obj = index2value(L, objindex);

switch (ttype(obj)) {

case LUA_TTABLE:

mt = hvalue(obj)->metatable;

break;

case LUA_TUSERDATA:

mt = uvalue(obj)->metatable;

break;

default:

mt = G(L)->mt[ttype(obj)];

break;

}

if (mt != NULL) {

sethvalue2s(L, L->top, mt);

api_incr_top(L);

res = 1;

}

lua_unlock(L);

return res;

}

LUA_API int lua_getiuservalue (lua_State *L, int idx, int n) {

TValue *o;

int t;

lua_lock(L);

o = index2value(L, idx);

api_check(L, ttisfulluserdata(o), "full userdata expected");

if (n <= 0 || n > uvalue(o)->nuvalue) {

setnilvalue(s2v(L->top));

t = LUA_TNONE;

}

else {

setobj2s(L, L->top, &uvalue(o)->uv[n - 1].uv);

t = ttype(s2v(L->top));

}

api_incr_top(L);

lua_unlock(L);

return t;

}

/*

** set functions (stack -> Lua)

*/

/*

** t[k] = value at the top of the stack (where 'k' is a string)

*/

static void auxsetstr (lua_State *L, const TValue *t, const char *k) {

const TValue *slot;

TString *str = luaS_new(L, k);

api_checknelems(L, 1);

if (luaV_fastget(L, t, str, slot, luaH_getstr)) {

luaV_finishfastset(L, t, slot, s2v(L->top - 1));

L->top--; /* pop value */

}

else {

setsvalue2s(L, L->top, str); /* push 'str' (to make it a TValue) */

api_incr_top(L);

luaV_finishset(L, t, s2v(L->top - 1), s2v(L->top - 2), slot);

L->top -= 2; /* pop value and key */

}

lua_unlock(L); /* lock done by caller */

}

LUA_API void lua_setglobal (lua_State *L, const char *name) {

const TValue *G;

lua_lock(L); /* unlock done in 'auxsetstr' */

G = getGtable(L);

auxsetstr(L, G, name);

}

LUA_API void lua_settable (lua_State *L, int idx) {

TValue *t;

const TValue *slot;

lua_lock(L);

api_checknelems(L, 2);

t = index2value(L, idx);

if (luaV_fastget(L, t, s2v(L->top - 2), slot, luaH_get)) {

luaV_finishfastset(L, t, slot, s2v(L->top - 1));

}

else

luaV_finishset(L, t, s2v(L->top - 2), s2v(L->top - 1), slot);

L->top -= 2; /* pop index and value */

lua_unlock(L);

}

LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {

lua_lock(L); /* unlock done in 'auxsetstr' */

auxsetstr(L, index2value(L, idx), k);

}

LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {

TValue *t;

const TValue *slot;

lua_lock(L);

api_checknelems(L, 1);

t = index2value(L, idx);

if (ttisarray(t)) {

luaA_setint(L, avalue(t), n, s2v(L->top - 1));

}

else if (luaV_fastgeti(L, t, n, slot)) {

luaV_finishfastset(L, t, slot, s2v(L->top - 1));

}

else {

TValue aux;

setivalue(&aux, n);

luaV_finishset(L, t, &aux, s2v(L->top - 1), slot);

}

L->top--; /* pop value */

lua_unlock(L);

}

static void aux_rawset (lua_State *L, int idx, TValue *key, int n) {

Table *t;

lua_lock(L);

api_checknelems(L, n);

t = gettable(L, idx);

luaH_set(L, t, key, s2v(L->top - 1));

invalidateTMcache(t);

luaC_barrierback(L, obj2gco(t), s2v(L->top - 1));

L->top -= n;

lua_unlock(L);

}

LUA_API void lua_rawset (lua_State *L, int idx) {

aux_rawset(L, idx, s2v(L->top - 2), 2);

}

LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {

TValue k;

setpvalue(&k, cast_voidp(p));

aux_rawset(L, idx, &k, 1);

}

LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {

Table *t;

lua_lock(L);

api_checknelems(L, 1);

t = gettable(L, idx);

luaH_setint(L, t, n, s2v(L->top - 1));

luaC_barrierback(L, obj2gco(t), s2v(L->top - 1));

L->top--;

lua_unlock(L);

}

LUA_API int lua_setmetatable (lua_State *L, int objindex) {

TValue *obj;

Table *mt;

lua_lock(L);

api_checknelems(L, 1);

obj = index2value(L, objindex);

if (ttisnil(s2v(L->top - 1)))

mt = NULL;

else {

api_check(L, ttistable(s2v(L->top - 1)), "table expected");

mt = hvalue(s2v(L->top - 1));

}

switch (ttype(obj)) {

case LUA_TTABLE: {

hvalue(obj)->metatable = mt;

if (mt) {

luaC_objbarrier(L, gcvalue(obj), mt);

luaC_checkfinalizer(L, gcvalue(obj), mt);

}

break;

}

case LUA_TUSERDATA: {

uvalue(obj)->metatable = mt;

if (mt) {

luaC_objbarrier(L, uvalue(obj), mt);

luaC_checkfinalizer(L, gcvalue(obj), mt);

}

break;