/*
:1 lightuserdata env
:2 function decode_message
:3 table target
:4 string type
:5 string data
:5 lightuserdata pointer
:6 integer len
table
*/
static int
_decode(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L,1);
luaL_checktype(L, 2 , LUA_TFUNCTION);
luaL_checktype(L, 3 , LUA_TTABLE);
const char * type = luaL_checkstring(L,4);
struct pbc_slice slice;
if (lua_type(L,5) == LUA_TSTRING) {
size_t len;
slice.buffer = (void *)luaL_checklstring(L,5,&len);
slice.len = (int)len;
} else {
slice.buffer = checkuserdata(L,5);
slice.len = luaL_checkinteger(L,6);
}
lua_pushvalue(L, 2);
lua_pushvalue(L, 3);
lua_newtable(L);
int n = pbc_decode(env, type, &slice, decode_cb, L);
if (n<0) {
lua_pushboolean(L,0);
} else {
lua_pushboolean(L,1);
}
return 1;
}
static int
_rmessage_delete(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
pbc_rmessage_delete(m);
return 0;
}
/*
lightuserdata env
*/
static int
_last_error(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L, 1);
const char * err = pbc_error(env);
lua_pushstring(L,err);
return 1;
}
static int
_wmessage_int64(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
switch (lua_type(L,3)) {
case LUA_TSTRING : {
size_t len = 0;
const char * number = lua_tolstring(L,3,&len);
if (len !=8 ) {
return luaL_error(L,"Need an 8 length string for int64");
}
const uint32_t * v = (const uint32_t *) number;
pbc_wmessage_integer(m, key, v[0] , v[1]);
break;
}
case LUA_TLIGHTUSERDATA : {
void * v = lua_touserdata(L,3);
uint64_t v64 = (uintptr_t)v;
pbc_wmessage_integer(m, key, (uint32_t)v64 , (uint32_t)(v64>>32));
break;
}
default :
return luaL_error(L, "Need an int64 type");
}
return 0;
}
static int
_wmessage_buffer_string(lua_State *L) {
struct pbc_slice slice;
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
pbc_wmessage_buffer(m , &slice);
lua_pushlstring(L, (const char *)slice.buffer, slice.len);
return 1;
}
static int
_wmessage_new(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L,1);
const char * type_name = luaL_checkstring(L,2);
struct pbc_wmessage * ret = pbc_wmessage_new(env, type_name);
lua_pushlightuserdata(L,ret);
return 1;
}
static int
_wmessage_buffer(lua_State *L) {
struct pbc_slice slice;
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
pbc_wmessage_buffer(m , &slice);
lua_pushlightuserdata(L, slice.buffer);
lua_pushinteger(L, slice.len);
return 2;
}
static int
_wmessage_message(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
struct pbc_wmessage * ret = pbc_wmessage_message(m, key);
lua_pushlightuserdata(L, ret);
return 1;
}
static int
_rmessage_message(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = lua_tointeger(L,3);
struct pbc_rmessage * v = pbc_rmessage_message(m,key,index);
lua_pushlightuserdata(L,v);
return 1;
}
static int
_wmessage_real(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
double number = luaL_checknumber(L,3);
pbc_wmessage_real(m, key, number);
return 0;
}
static int
_env_type(lua_State *L) {
lua_settop(L,3);
struct pbc_env * env = checkuserdata(L,1);
const char * typename = luaL_checkstring(L,2);
if (lua_isnil(L,3)) {
int ret = pbc_type(env, typename, NULL, NULL);
lua_pushboolean(L,ret);
return 1;
}
static int
_rmessage_int32(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = (int)luaL_checkinteger(L,3);
uint32_t v = pbc_rmessage_integer(m, key, index, NULL);
lua_pushlightuserdata(L,(void *)(intptr_t)v);
return 1;
}
static int
_rmessage_string(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = lua_tointeger(L,3);
int sz = 0;
const char * v = pbc_rmessage_string(m,key,index,&sz);
lua_pushlstring(L,v,sz);
return 1;
}
static int
_wmessage_int52(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int64_t number = (int64_t)(luaL_checknumber(L,3));
uint32_t hi = (uint32_t)(number >> 32);
pbc_wmessage_integer(m, key, (uint32_t)number, hi);
return 0;
}
static int
_rmessage_integer(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = luaL_checkinteger(L,3);
int32_t v = (int32_t)pbc_rmessage_integer(m, key, index, NULL);
lua_pushinteger(L,v);
return 1;
}
static int
_rmessage_real(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = luaL_checkinteger(L,3);
double v = pbc_rmessage_real(m, key, index);
lua_pushnumber(L,v);
return 1;
}
static int
_wmessage_int32(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
if (!lua_islightuserdata(L,3)) {
return luaL_error(L,"Need a lightuserdata for int32");
}
void *number = lua_touserdata(L,3);
pbc_wmessage_integer(m, key, (uint32_t)(intptr_t)number , 0);
return 0;
}
static int
_rmessage_size(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int sz = pbc_rmessage_size(m, key);
lua_pushinteger(L, sz);
return 1;
}
static int
_env_enum_id(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L,1);
size_t sz = 0;
const char* enum_type = luaL_checklstring(L, 2, &sz);
const char* enum_name = luaL_checklstring(L, 3, &sz);
int32_t enum_id = pbc_enum_id(env, enum_type, enum_name);
if (enum_id < 0)
return 0;
lua_pushinteger(L, enum_id);
return 1;
}
static int
_rmessage_int64(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = (int)luaL_checkinteger(L,3);
uint32_t v[2];
v[0] = pbc_rmessage_integer(m, key, index, &v[1]);
lua_pushlstring(L,(const char *)v,sizeof(v));
return 1;
}
static int
_wmessage_integer(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int number = (int)luaL_checkinteger(L,3);
uint32_t hi = 0;
if (number < 0)
hi = ~0;
pbc_wmessage_integer(m, key, number, hi);
return 0;
}
static int
_rmessage_int(lua_State *L) {
struct pbc_rmessage * m = (struct pbc_rmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int index = luaL_checkinteger(L,3);
uint32_t hi,low;
low = pbc_rmessage_integer(m, key, index, &hi);
int64_t v = (int64_t)((uint64_t)hi << 32 | (uint64_t)low);
lua_pushinteger(L,v);
return 1;
}
/*
lightuserdata pattern
string format "ixrsmb"
integer size
lightuserdata buffer
integer buffer_len
*/
static int
_pattern_unpack(lua_State *L) {
struct pbc_pattern * pat = (struct pbc_pattern *)checkuserdata(L, 1);
if (pat == NULL) {
return luaL_error(L, "unpack pattern is NULL");
}
size_t format_sz = 0;
const char * format = lua_tolstring(L,2,&format_sz);
int size = lua_tointeger(L,3);
struct pbc_slice slice;
if (lua_isstring(L,4)) {
size_t buffer_len = 0;
const char *buffer = luaL_checklstring(L,4,&buffer_len);
slice.buffer = (void *)buffer;
slice.len = buffer_len;
} else {
if (!lua_isuserdata(L,4)) {
return luaL_error(L, "Need a userdata");
}
slice.buffer = lua_touserdata(L,4);
slice.len = luaL_checkinteger(L,5);
}
char * temp = (char *)alloca(size);
int ret = pbc_pattern_unpack(pat, &slice, temp);
if (ret < 0) {
return 0;
}
lua_checkstack(L, format_sz + 3);
int i;
char * ptr = temp;
bool array = false;
for (i=0;i<format_sz;i++) {
char type = format[i];
if (type >= 'a' && type <='z') {
ptr = (char *)_push_value(L,ptr,type);
} else {
array = true;
int n = pbc_array_size((struct _pbc_array *)ptr);
lua_createtable(L,n,0);
int j;
for (j=0;j<n;j++) {
_push_array(L,(struct _pbc_array *)ptr, type, j);
}
ptr += sizeof(pbc_array);
}
}
if (array) {
pbc_pattern_close_arrays(pat, temp);
}
return format_sz;
}
/*
lightuserdata env
string message
string format
*/
static int
_pattern_new(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L, 1);
const char * message = luaL_checkstring(L,2);
const char * format = luaL_checkstring(L,3);
struct pbc_pattern * pat = pbc_pattern_new(env, message, format);
if (pat == NULL) {
return luaL_error(L, "create patten %s (%s) failed", message , format);
}
lua_pushlightuserdata(L,pat);
return 1;
}
static int
_wmessage_string(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
size_t len = 0;
const char * v = luaL_checklstring(L,3,&len);
int err = pbc_wmessage_string(m, key, v, (int)len);
if (err) {
return luaL_error(L, "Write string error : %s", v);
}
return 0;
}
static int
_wmessage_uint52(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
lua_Number v = (luaL_checknumber(L,3));
if (v < 0) {
return luaL_error(L, "negative number : %f passed to unsigned field",v);
}
uint64_t number = (uint64_t)v;
uint32_t hi = (uint32_t)(number >> 32);
pbc_wmessage_integer(m, key, (uint32_t)number, hi);
return 0;
}
static int
_env_register(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L,1);
size_t sz = 0;
const char * buffer = luaL_checklstring(L, 2 , &sz);
struct pbc_slice slice;
slice.buffer = (void *)buffer;
slice.len = (int)sz;
int ret = pbc_register(env, &slice);
if (ret) {
return luaL_error(L, "register fail");
}
return 0;
}
static int
_wmessage_int(lua_State *L) {
struct pbc_wmessage * m = (struct pbc_wmessage *)checkuserdata(L,1);
const char * key = luaL_checkstring(L,2);
int64_t number;
// compat float for some historical reasons.
if (lua_isinteger(L, 3)) {
number = lua_tointeger(L,3);
} else {
number = (int64_t)lua_tonumber(L,3);
}
uint32_t hi = (uint32_t)(number >> 32);
pbc_wmessage_integer(m, key, (uint32_t)number, hi);
return 0;
}
static int
_rmessage_new(lua_State *L) {
struct pbc_env * env = (struct pbc_env *)checkuserdata(L,1);
const char * type_name = luaL_checkstring(L,2);
struct pbc_slice slice;
if (lua_isstring(L,3)) {
size_t sz = 0;
slice.buffer = (void *)lua_tolstring(L,3,&sz);
slice.len = (int)sz;
} else {
slice.buffer = lua_touserdata(L,3);
slice.len = luaL_checkinteger(L,4);
}
struct pbc_rmessage * m = pbc_rmessage_new(env, type_name, &slice);
if (m==NULL)
return 0;
lua_pushlightuserdata(L,m);
return 1;
}
static int
_env_type(lua_State *L) {
lua_settop(L,3);
struct pbc_env * env = (struct pbc_env *)checkuserdata(L,1);
const char * type_name = luaL_checkstring(L,2);
if (lua_isnil(L,3)) {
int ret = pbc_type(env, type_name, NULL, NULL);
lua_pushboolean(L,ret);
return 1;
}
const char * key = luaL_checkstring(L,3);
const char * type = NULL;
int ret = pbc_type(env, type_name, key, &type);
lua_pushinteger(L,ret);
if (type == NULL) {
return 1;
} {
lua_pushstring(L, type);
return 2;
}
}
