void
test_map_push() {
{
std::map<std::string, std::string> my_map{
{"a", "1"}, {"b", "2"}, {"c", "3"}};
lua_raii L;
primer::push(L, my_map);
CHECK_STACK(L, 1);
test_top_type(L, LUA_TTABLE, __LINE__);
lua_pushnil(L);
int counter = 0;
while (lua_next(L, 1)) {
++counter;
TEST(lua_isstring(L, 2), "expected a string key");
std::string key = lua_tostring(L, 2);
TEST(lua_isstring(L, 3), "expected a string val");
std::string val = lua_tostring(L, 3);
TEST_EQ(val, my_map[key]);
my_map.erase(key);
lua_pop(L, 1);
}
TEST_EQ(my_map.size(), 0);
TEST_EQ(counter, 3);
}
{
std::map<int, int> my_map{{'a', 1}, {'b', 2}, {'c', 3}};
lua_raii L;
primer::push(L, my_map);
CHECK_STACK(L, 1);
test_top_type(L, LUA_TTABLE, __LINE__);
lua_pushnil(L);
int counter = 0;
while (lua_next(L, 1)) {
++counter;
TEST(lua_isinteger(L, 2), "expected an int key");
int key = lua_tointeger(L, 2);
TEST(lua_isinteger(L, 3), "expected an int val");
int val = lua_tointeger(L, 3);
TEST_EQ(val, my_map[key]);
my_map.erase(key);
lua_pop(L, 1);
}
TEST_EQ(my_map.size(), 0);
TEST_EQ(counter, 3);
}
}
static int lz_checksum(lua_State *L) {
if ( lua_gettop(L) <= 0 ) {
lua_pushvalue(L, lua_upvalueindex(3));
lua_pushvalue(L, lua_upvalueindex(4));
} else if ( lua_isfunction(L, 1) ) {
checksum_combine_t combine = (checksum_combine_t)
lua_touserdata(L, lua_upvalueindex(2));
lua_pushvalue(L, 1);
lua_call(L, 0, 2);
if ( ! lua_isinteger(L, -2) || ! lua_isinteger(L, -1) ) {
luaL_argerror(L, 1, "expected function to return two numbers");
}
/* Calculate and replace the checksum */
lua_pushinteger(L,
combine((uLong)lua_tointeger(L, lua_upvalueindex(3)),
(uLong)lua_tointeger(L, -2),
(z_off_t)lua_tointeger(L, -1)));
lua_pushvalue(L, -1);
lua_replace(L, lua_upvalueindex(3));
/* Calculate and replace the length */
lua_pushinteger(L,
lua_tointeger(L, lua_upvalueindex(4)) + lua_tointeger(L, -2));
lua_pushvalue(L, -1);
lua_replace(L, lua_upvalueindex(4));
} else {
const Bytef* str;
size_t len;
checksum_t checksum = (checksum_t)
lua_touserdata(L, lua_upvalueindex(1));
str = (const Bytef*)luaL_checklstring(L, 1, &len);
/* Calculate and replace the checksum */
lua_pushinteger(L,
checksum((uLong)lua_tointeger(L, lua_upvalueindex(3)),
str,
(uInt)len));
lua_pushvalue(L, -1);
lua_replace(L, lua_upvalueindex(3));
/* Calculate and replace the length */
lua_pushinteger(L,
lua_tointeger(L, lua_upvalueindex(4)) + len);
lua_pushvalue(L, -1);
lua_replace(L, lua_upvalueindex(4));
}
return 2;
}
static int math_fmod(lua_State *L) {
if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
lua_Integer d = lua_tointeger(L, 2);
if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
luaL_argcheck(L, d != 0, 2, "zero");
lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
}
else
lua_pushinteger(L, lua_tointeger(L, 1) % d);
}
else
lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
luaL_checknumber(L, 2)));
return 1;
}
static int math_abs (lua_State *L) {
lua_Number v;
float x, y, z, w;
switch (lua_type(L,1)) {
case LUA_TNUMBER:
if (lua_isinteger(L, 1)) {
lua_Integer n = lua_tointeger(L, 1);
if (n < 0) n = (lua_Integer)(0u - n);
lua_pushinteger(L, n);
} else {
v = lua_tonumber(L,1);
lua_pushnumber(L,l_mathop(fabs)(v));
}
return 1;
case LUA_TVECTOR2:
lua_checkvector2(L,1,&x,&y);
lua_pushvector2(L,fabsf(x),fabsf(y));
return 1;
case LUA_TVECTOR3:
lua_checkvector3(L,1,&x,&y,&z);
lua_pushvector3(L,fabsf(x),fabsf(y),fabsf(z));
return 1;
case LUA_TVECTOR4:
lua_checkvector4(L,1,&x,&y,&z,&w);
lua_pushvector4(L,fabsf(x),fabsf(y),fabsf(z),fabsf(w));
return 1;
}
luaL_error(L, "abs takes a number, integer, vector2, vector3, or vector4.");
return 1;
}
static int math_ceil (lua_State *L) {
lua_Number v;
float x, y, z, w;
switch (lua_type(L,1)) {
case LUA_TNUMBER:
if (lua_isinteger(L, 1)) {
lua_settop(L, 1); /* integer is its own ceil */
} else {
v = lua_tonumber(L,1);
pushnumint(L,ceil(v));
}
return 1;
case LUA_TVECTOR2:
lua_checkvector2(L,1,&x,&y);
lua_pushvector2(L,ceilf(x),ceilf(y));
return 1;
case LUA_TVECTOR3:
lua_checkvector3(L,1,&x,&y,&z);
lua_pushvector3(L,ceilf(x),ceilf(y),ceilf(z));
return 1;
case LUA_TVECTOR4:
lua_checkvector4(L,1,&x,&y,&z,&w);
lua_pushvector4(L,ceilf(x),ceilf(y),ceilf(z),ceilf(w));
return 1;
}
luaL_error(L, "ceil takes a number, integer, vector2, vector3, or vector4.");
return 1;
}
static int Scissor(lua_State *L)
{
GLint x, y;
GLsizei width, height;
GLint v[4];
GLint index;
if(lua_isinteger(L, 5))
{
v[0] = luaL_checkinteger(L, 1);
v[1] = luaL_checkinteger(L, 2);
v[2] = luaL_checkinteger(L, 3);
v[3] = luaL_checkinteger(L, 4);
index = luaL_checkinteger(L, 5);
glScissorIndexedv(index, v);
}
else
{
x = luaL_checkinteger(L, 1);
y = luaL_checkinteger(L, 2);
width = luaL_checkinteger(L, 3);
height = luaL_checkinteger(L, 4);
glScissor(x, y, width, height);
}
CheckError(L);
return 0;
}
void print_luavar(lua_State *L, int index, int layer) {
int type = lua_type(L, index);
switch(type) {
case LUA_TNIL:
printf("nil");
break;
case LUA_TNUMBER:
if(lua_isinteger(L, index)) {
printf("%s", lua_tostring(L, index));
} else {
printf("%f",lua_tonumber(L, index));
}
break;
case LUA_TSTRING:
printf("\"%s\"", lua_tostring(L, index));
break;
case LUA_TBOOLEAN:
printf("%s", lua_toboolean(L, index) ? "true" : "false");
break;
case LUA_TTABLE:
print_luatable(L, index, layer);
break;
case LUA_TFUNCTION:
case LUA_TUSERDATA:
case LUA_TTHREAD:
case LUA_TLIGHTUSERDATA:
printf("%p(%s)", lua_topointer(L, index), luaL_typename(L, index));
break;
default:
break;
}
}
LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
if (!luaL_callmeta(L, idx, "__tostring")) { /* no metafield? */
switch (lua_type(L, idx)) {
case LUA_TNUMBER: {
if (lua_isinteger(L, idx))
lua_pushfstring(L, "%I", lua_tointeger(L, idx));
else
lua_pushfstring(L, "%f", lua_tonumber(L, idx));
break;
}
case LUA_TSTRING:
lua_pushvalue(L, idx);
break;
case LUA_TBOOLEAN:
lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));
break;
case LUA_TNIL:
lua_pushliteral(L, "nil");
break;
default:
lua_pushfstring(L, "%s: %p", luaL_typename(L, idx),
lua_topointer(L, idx));
break;
}
}
return lua_tolstring(L, -1, len);
}
static int BlendEquation(lua_State *L)
{
GLuint buf;
GLenum mode, alpha;
if(lua_isinteger(L, 1))
{
buf = luaL_checkinteger(L, 1);
mode = checkblendmode(L, 2);
if(lua_isstring(L, 3))
{
alpha = checkblendmode(L,3);
glBlendEquationSeparatei(buf, mode, alpha);
}
else
glBlendEquationi(buf, mode);
}
else
{
mode = checkblendmode(L, 1);
if(lua_isstring(L, 2))
{
alpha = checkblendmode(L,2);
glBlendEquationSeparate(mode, alpha);
}
else
glBlendEquation(mode);
}
CheckError(L);
return 0;
}
static void addliteral (lua_State *L, luaL_Buffer *b, int arg) {
switch (lua_type(L, arg)) {
case LUA_TSTRING: {
size_t len;
const char *s = lua_tolstring(L, arg, &len);
addquoted(b, s, len);
break;
}
case LUA_TNUMBER: {
char *buff = luaL_prepbuffsize(b, MAX_ITEM);
int nb;
if (!lua_isinteger(L, arg)) /* float? */
nb = quotefloat(L, buff, lua_tonumber(L, arg));
else { /* integers */
lua_Integer n = lua_tointeger(L, arg);
const char *format = (n == LUA_MININTEGER) /* corner case? */
? "0x%" LUA_INTEGER_FRMLEN "x" /* use hex */
: LUA_INTEGER_FMT; /* else use default format */
nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n);
}
luaL_addsize(b, nb);
break;
}
case LUA_TNIL: case LUA_TBOOLEAN: {
luaL_tolstring(L, arg, NULL);
luaL_addvalue(b);
break;
}
default: {
luaL_argerror(L, arg, "value has no literal form");
}
}
}
static void
proxy_unmap(lua_State *L, lua_State *R)
{
proxy_object *o;
switch (lua_type(R, -1)) {
case LUA_TBOOLEAN:
lua_pushboolean(L, lua_toboolean(R, -1));
break;
case LUA_TNUMBER:
#if LUA_VERSION_NUM >= 503
if (lua_isinteger(R, -1))
lua_pushinteger(L, lua_tointeger(R, -1));
else
#endif
lua_pushnumber(L, lua_tonumber(R, -1));
break;
case LUA_TSTRING:
lua_pushstring(L, lua_tostring(R, -1));
break;
case LUA_TNIL:
lua_pushnil(L);
break;
case LUA_TFUNCTION:
case LUA_TTABLE:
o = lua_newuserdata(L, sizeof(proxy_object));
luaL_getmetatable(L, OBJECT_METATABLE);
lua_setmetatable(L, -2);
o->L = R;
o->ref = luaL_ref(R, LUA_REGISTRYINDEX);
break;
default:
printf("unsupported type %s\n", luaL_typename(R, -1));
}
}
static int g_write (lua_State *L, FILE *f, int arg) {
int nargs = lua_gettop(L) - arg;
int status = 1;
for (; nargs--; arg++) {
if (lua_type(L, arg) == LUA_TNUMBER) {
/* optimization: could be done exactly as for strings */
int len = lua_isinteger(L, arg)
? fprintf(f, LUA_INTEGER_FMT, lua_tointeger(L, arg))
: fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg));
status = status && (len > 0);
}
else {
size_t l;
const char *s = luaL_checklstring(L, arg, &l);
#ifdef U8W_H
if (f == stdout || f == stderr)
status = status && (fprintf(f, "%s", s) > 0);
else
status = status && (fwrite(s, sizeof(char), l, f) == l);
#else
status = status && (fwrite(s, sizeof(char), l, f) == l);
#endif
}
}
if (status) return 1; /* file handle already on stack top */
else return luaL_fileresult(L, status, NULL);
}
static int BlendFunc(lua_State *L)
{
GLuint buf;
GLenum sfactor, dfactor, sfactorAlpha, dfactorAlpha;
if(lua_isinteger(L, 1))
{
buf = luaL_checkinteger(L, 1);
sfactor = checkblendfactor(L, 2);
dfactor = checkblendfactor(L, 3);
if(lua_isstring(L, 4))
{
sfactorAlpha = checkblendfactor(L, 4);
dfactorAlpha = checkblendfactor(L, 5);
glBlendFuncSeparatei(buf, sfactor, dfactor, sfactorAlpha, dfactorAlpha);
}
else
glBlendFunci(buf, sfactor, dfactor);
}
else
{
sfactor = checkblendfactor(L, 1);
dfactor = checkblendfactor(L, 2);
if(lua_isstring(L, 3))
{
sfactorAlpha = checkblendfactor(L, 3);
dfactorAlpha = checkblendfactor(L, 4);
glBlendFuncSeparate(sfactor, dfactor, sfactorAlpha, dfactorAlpha);
}
else
glBlendFunc(sfactor, dfactor);
}
CheckError(L);
return 0;
}
static lua_Integer checkinteger(lua_State *L, int narg, const char *expected)
{
lua_Integer d = lua_tointeger(L, narg);
if (d == 0 && !lua_isinteger(L, narg))
argtypeerror(L, narg, expected);
return d;
}
static int Size(lua_State *L)
{
size_t offset;
char *ptr;
hostmem_t* hostmem = checkhostmem(L, 1, NULL);
if(lua_isnoneornil(L, 2))
lua_pushinteger(L, hostmem->size);
else if(lua_isinteger(L, 2))
{
offset = luaL_checkinteger(L, 2);
if(offset >= hostmem->size)
lua_pushinteger(L, 0);
else
lua_pushinteger(L, hostmem->size - offset);
}
else
{
ptr = (char*)checklightuserdata(L, 2);
if((ptr < hostmem->ptr) || (ptr > (hostmem->ptr + hostmem->size)))
lua_pushinteger(L, 0);
else
lua_pushinteger(L, hostmem->ptr + hostmem->size - ptr);
}
return 1;
}
static int
object_index(lua_State *L)
{
proxy_object *o;
o = luaL_checkudata(L, -2, OBJECT_METATABLE);
lua_rawgeti(o->L, LUA_REGISTRYINDEX, o->ref);
switch (lua_type(L, -1)) {
case LUA_TNUMBER:
#if LUA_VERSION_NUM >= 503
if (lua_isinteger(L, -1))
lua_pushinteger(o->L, lua_tointeger(L, -1));
else
#endif
lua_pushnumber(o->L, lua_tonumber(L, -1));
break;
case LUA_TSTRING:
lua_pushstring(o->L, lua_tostring(L, -1));
break;
default:
return luaL_error(L, "proxy: data type '%s' is not "
"supported as an index value", luaL_typename(L, -1));
}
lua_gettable(o->L, -2);
proxy_unmap(L, o->L);
lua_pop(o->L, 1);
return 1;
}
inline bool is_strict<lua_Integer>(lua_State* L, int index)
{
LUNA_INDEX_ASSERT(L, index);
if(! lua_isinteger (L, index) )
return false; // FIXME
return (lua_type(L, index) == LUA_TNUMBER);
}
static void
proxy_map(lua_State *L, lua_State *R, int t, int global)
{
int top;
char nam[64];
luaL_checkstack(R, 3, "out of stack space");
switch (lua_type(L, -2)) {
case LUA_TNUMBER:
lua_pushnumber(R, lua_tonumber(L, -2));
snprintf(nam, sizeof nam, "%d", (int)lua_tonumber(L, -2));
break;
case LUA_TSTRING:
snprintf(nam, sizeof nam, "%s", lua_tostring(L, -2));
lua_pushstring(R, lua_tostring(L, -2));
break;
default:
luaL_error(L, "proxy: data type '%s' is not "
"supported as an index value", luaL_typename(L, -2));
return;
}
switch (lua_type(L, -1)) {
case LUA_TBOOLEAN:
lua_pushboolean(R, lua_toboolean(L, -1));
break;
case LUA_TNUMBER:
#if LUA_VERSION_NUM >= 503
if (lua_isinteger(L, -1))
lua_pushinteger(R, lua_tointeger(L, -1));
else
#endif
lua_pushnumber(R, lua_tonumber(L, -1));
break;
case LUA_TSTRING:
lua_pushstring(R, lua_tostring(L, -1));
break;
case LUA_TNIL:
lua_pushnil(R);
break;
case LUA_TTABLE:
top = lua_gettop(L);
lua_newtable(R);
lua_pushnil(L); /* first key */
while (lua_next(L, top) != 0) {
proxy_map(L, R, lua_gettop(R), 0);
lua_pop(L, 1);
}
break;
default:
printf("unknown type %s\n", nam);
}
if (global) {
lua_setglobal(R, nam);
lua_pop(R, 1);
} else
lua_settable(R, t);
}
static LUA_FUNCTION(openssl_crl_get)
{
X509_CRL * crl = CHECK_OBJECT(1, X509_CRL, "openssl.x509_crl");
int i = 0;
X509_REVOKED *revoked = NULL;
if (lua_isinteger(L, 2))
{
i = lua_tointeger(L, 2);
luaL_argcheck(L, (i >= 0 && i < sk_X509_REVOKED_num(crl->crl->revoked)), 2, "Out of range");
revoked = sk_X509_REVOKED_value(crl->crl->revoked, i);
}
else
{
ASN1_STRING *sn = CHECK_OBJECT(2, ASN1_STRING, "openssl.asn1_integer");
int cnt = sk_X509_REVOKED_num(crl->crl->revoked);
for (i = 0; i < cnt; i++)
{
X509_REVOKED *rev = sk_X509_REVOKED_value(crl->crl->revoked, i);
if (ASN1_STRING_cmp(rev->serialNumber, sn) == 0)
{
revoked = rev;
break;
}
}
}
if (revoked)
{
lua_newtable(L);
#if OPENSSL_VERSION_NUMBER > 0x10000000L
AUXILIAR_SET(L, -1, "code", revoked->reason, number);
AUXILIAR_SET(L, -1, "reason", openssl_i2s_revoke_reason(revoked->reason), string);
#else
{
int crit = 0;
void* reason = X509_REVOKED_get_ext_d2i(revoked, NID_crl_reason, &crit, NULL);
AUXILIAR_SET(L, -1, "code", ASN1_ENUMERATED_get(reason), number);
AUXILIAR_SET(L, -1, "reason", openssl_i2s_revoke_reason(ASN1_ENUMERATED_get(reason)), string);
ASN1_ENUMERATED_free(reason);
}
#endif
PUSH_ASN1_INTEGER(L, revoked->serialNumber);
lua_setfield(L, -2, "serialNumber");
PUSH_ASN1_TIME(L, revoked->revocationDate);
lua_setfield(L, -2, "revocationDate");
if (crl->crl->extensions)
{
lua_pushstring(L, "extensions");
openssl_sk_x509_extension_totable(L, crl->crl->extensions);
lua_rawset(L, -3);
}
}
else
lua_pushnil(L);
return 1;
}
inline bool is<lua_Integer>(lua_State* L, int index)
{
LUNA_INDEX_ASSERT(L, index);
#if defined LUA_VERSION_NUM && LUA_VERSION_NUM >= 503
return(lua_isinteger(L, index));
#else
return(lua_isnumber(L, index));
#endif
}
static void infIAT(lua_State* L, hook_t* h) {
h->type = hook_t::type::IAT;
const char* dllname = luaL_checkstring(L, 3);
const char* apiname = nullptr;
if (lua_isinteger(L, 4)) {
apiname = (const char*)luaL_checkinteger(L, 4);
}
else {
apiname = luaL_checkstring(L, 4);
}
if (lua_isinteger(L, 2)) {
h->real = base::hook::iat((HMODULE)luaL_checkinteger(L, 2), dllname, apiname, h->fake);
}
else {
std::wstring modulename = lua_towstring(L, 2);
h->real = base::hook::iat(modulename.c_str(), dllname, apiname, h->fake);
}
}
static int math_ceil(lua_State *L) {
if (lua_isinteger(L, 1))
lua_settop(L, 1); /* integer is its own ceil */
else {
lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
pushnumint(L, d);
}
return 1;
}
static int new_progress( lua_State* L )
{
uiProgressBar* p = uiNewProgressBar();
object_create( L, p, uiProgressBarSignature, control_common, progress_functions, 0 );
if( lua_isinteger( L, 1 ) )
{
uiProgressBarSetValue( p, lua_tointeger( L, 1 ) );
}
return 1;
}
static int math_abs(lua_State *L) {
if (lua_isinteger(L, 1)) {
lua_Integer n = lua_tointeger(L, 1);
if (n < 0) n = (lua_Integer)(0u - n);
lua_pushinteger(L, n);
}
else
lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
return 1;
}
int32_t context_lua_t::context_check_message(lua_State *L, int32_t idx, uint32_t msg_type, message_t& message)
{
buffer_t* buffer;
int32_t* bson;
switch (lua_type(L, idx)) {
case LUA_TNUMBER:
if (lua_isinteger(L, idx)) {
message.m_type = MAKE_MESSAGE_TYPE(msg_type, INTEGER);
message.m_data.m_integer = (int64_t)lua_tointeger(L, idx);
} else {
message.m_type = MAKE_MESSAGE_TYPE(msg_type, NUMBER);
message.m_data.m_number = (double)lua_tonumber(L, idx);
}
message.m_source = lua_get_context_handle(L);
return UV_OK;
case LUA_TSTRING:
message.m_type = MAKE_MESSAGE_TYPE(msg_type, STRING);
message.m_data.m_string = (char*)lua_tostring(L, idx);
message.m_source = lua_get_context_handle(L);
return UV_OK;
case LUA_TBOOLEAN:
message.m_type = MAKE_MESSAGE_TYPE(msg_type, TBOOLEAN);
message.m_data.m_bool = (bool)lua_toboolean(L, idx);
message.m_source = lua_get_context_handle(L);
return UV_OK;
case LUA_TNIL:
message.m_type = MAKE_MESSAGE_TYPE(msg_type, NIL);
message.m_source = lua_get_context_handle(L);
return UV_OK;
case LUA_TUSERDATA:
buffer = (buffer_t*)luaL_testudata(L, idx, BUFFER_METATABLE);
if (buffer) {
message.m_type = MAKE_MESSAGE_TYPE(msg_type, BUFFER);
message.m_data.m_buffer = *buffer;
message.m_source = lua_get_context_handle(L);
return UV_OK;
}
//to be fix : bson, array
//bson = (int32_t*)luaL_testudata(L, idx, BSON_METATABLE);
//if (bson) {
// message.m_type = MAKE_MESSAGE_TYPE(msg_type, BSON);
// message.m_data.m_bson = (bson_t*)bson; //temporary store the pointer here, which is not illegal.
// message.m_source = lua_get_context_handle(L);
// return UV_OK;
//}
return NL_ETRANSTYPE;
case LUA_TLIGHTUSERDATA:
message.m_type = MAKE_MESSAGE_TYPE(msg_type, USERDATA);
message.m_data.m_userdata = (void*)lua_touserdata(L, idx);
message.m_source = lua_get_context_handle(L);
return UV_OK;
default:
return NL_ETRANSTYPE;
}
}
int register_graphics::createBatch(lua_State *L)
{
batch2d* batch = checkBatch(L, 1);
shader* s = checkShader(L, 2);
int limit = 9000;
if(lua_isinteger(L, 3))
limit = lua_tointeger(L, 3);
batch->create(s, limit);
return 1;
}
static int math_type (lua_State *L) {
luaL_checkany(L, 1);
if (lua_type(L, 1) == LUA_TNUMBER) {
if (lua_isinteger(L, 1))
lua_pushliteral(L, "integer");
else
lua_pushliteral(L, "float");
}
else
lua_pushnil(L);
return 1;
}
virtual void from_lua(state_type state, std::size_t idx, variable_type& var, std::string& error_msg, const policy_node&) const override
{
if(lua_isinteger(state, idx))
{
lua_Integer tmp = lua_tointeger(state, idx);
var = static_cast<type>(tmp);
lua_remove(state, idx);
}
else
{
error_msg = msg_error_invalid_integer;
}
}
int lua_player_newindex(lua_State* state)
{
const char* index = lua_tostring(state, 2);
if(!strcmp(index, "hp") && (lua_isinteger(state, 3) || lua_isnumber(state, 3))) { update_hp(lua_tointeger(state, 3)); }
else if(!strcmp(index, "hp_max")) hp_max = lua_tointeger(state, 3);
else if(!strcmp(index, "ep")) ep_current = lua_tointeger(state, 3);
else if(!strcmp(index, "ep_max")) ep_max = lua_tointeger(state, 3);
else if(!strcmp(index, "str")) str = lua_tointeger(state, 3);
else if(!strcmp(index, "def")) def = lua_tointeger(state, 3);
else if(!strcmp(index, "x")) x = lua_tointeger(state, 3);
else if(!strcmp(index, "y")) y = lua_tointeger(state, 3);
return 0;
}
static void
append_number(struct bson *bs, lua_State *L, const char *key, size_t sz) {
if (lua_isinteger(L, -1)) {
int64_t i = lua_tointeger(L, -1);
int si = i >> 31;
if (si == 0 || si == -1) {
append_key(bs, BSON_INT32, key, sz);
write_int32(bs, i);
} else {
append_key(bs, BSON_INT64, key, sz);
write_int64(bs, i);
}
} else {
