compiled_chunk* lua_context::compile_chunk(const std::string& name, const std::string& str)
{
compiled_chunk* chunk = new compiled_chunk();
luaL_loadbuffer(context_ptr(), str.c_str(), str.size(), name.c_str()); // (-0,+1,-)
lua_dump(context_ptr(), chunk_writer, reinterpret_cast<void*>(chunk)); // (-0,+0,-)
lua_pop(context_ptr(), 1); // (-n(1),+0,-)
chunk->add_chunk(0, 0);
return chunk;
}
static BOOL ProvStore_addCert(WINECRYPT_CERTSTORE *store, context_t *cert,
context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
{
WINE_PROVIDERSTORE *ps = (WINE_PROVIDERSTORE*)store;
BOOL ret;
TRACE("(%p, %p, %p, %p)\n", store, cert, toReplace, ppStoreContext);
if (toReplace)
ret = ps->memStore->vtbl->certs.addContext(ps->memStore, cert, toReplace,
ppStoreContext, TRUE);
else
{
ret = TRUE;
if (ps->provWriteCert)
ret = ps->provWriteCert(ps->hStoreProv, context_ptr(cert), CERT_STORE_PROV_WRITE_ADD_FLAG);
if (ret)
ret = ps->memStore->vtbl->certs.addContext(ps->memStore, cert, NULL,
ppStoreContext, TRUE);
}
/* dirty trick: replace the returned context's hCertStore with
* store.
*/
if (ret && ppStoreContext)
(*(cert_t**)ppStoreContext)->ctx.hCertStore = store;
return ret;
}
int uvplus_tcp::connect(const struct sockaddr *addr, std::function<void(uvplus_tcp *self, int status)> connect_callback) {
uv_connect_t *req = new uv_connect_t;
auto connect_callback_ptr = new std::function<void(uvplus_tcp *self, int status)>(connect_callback);
auto tcp = (uv_tcp_t *)context_ptr();
req->data = static_cast<void *>(connect_callback_ptr);
return uv_tcp_connect(req, tcp, addr, connect_cb);
}
/* Note: the programmer must not allow the context to be
GC'd until all connections are closed, or they'll be killed. */
void mltds_ct_ctx_finalize(value context)
{
CS_CONTEXT* ctx = context_ptr(context);
ct_exit(ctx, CS_FORCE_EXIT);
cs_ctx_drop(ctx);
}
static BOOL ProvStore_deleteCTL(WINECRYPT_CERTSTORE *store, context_t *ctl)
{
WINE_PROVIDERSTORE *ps = (WINE_PROVIDERSTORE*)store;
BOOL ret = TRUE;
TRACE("(%p, %p)\n", store, ctl);
if (ps->provDeleteCtl)
ret = ps->provDeleteCtl(ps->hStoreProv, context_ptr(ctl), 0);
if (ret)
ret = ps->memStore->vtbl->ctls.delete(ps->memStore, ctl);
return ret;
}
context_t *Context_CreateLinkContext(unsigned int contextSize, context_t *linked, WINECRYPT_CERTSTORE *store)
{
context_t *context;
TRACE("(%d, %p)\n", contextSize, linked);
context = CryptMemAlloc(sizeof(context_t) + contextSize);
if (!context)
return NULL;
memcpy(context_ptr(context), context_ptr(linked), contextSize);
context->vtbl = linked->vtbl;
context->ref = 1;
context->linked = linked;
context->properties = linked->properties;
Context_AddRef(linked);
store->vtbl->addref(store);
context->store = store;
TRACE("returning %p\n", context);
return context;
}
/*** Allocation ***/
CAMLprim value mltds_cs_ctx_create(value unit)
{
CAMLparam1(unit);
CS_CONTEXT* context;
CAMLlocal1(result);
retval_inspect( "cs_ctx_alloc", cs_ctx_alloc(CS_VERSION_100, &context) );
retval_inspect( "ct_init", ct_init(context, CS_VERSION_100) );
result = alloc_custom(&context_operations, sizeof(CS_CONTEXT*), 0, 1);
context_ptr(result) = context;
CAMLreturn(result);
}
bool lua_context::execute(const variant& value, game_logic::formula_callable* callable)
{
bool res = false;
if(callable) {
set_self_callable(*callable);
}
if(value.is_string()) {
res = dostring("", value.as_string());
} else {
lua_compiled_ptr compiled = value.try_convert<lua_compiled>();
ASSERT_LOG(compiled != NULL, "FATAL: object given couldn't be converted to type 'lua_compiled'");
res = compiled->run(context_ptr());
}
return res;
}
CAMLprim value mltds_ct_con_alloc(value context)
{
CAMLparam1(context);
CS_CONNECTION* conn;
CAMLlocal1(result);
retval_inspect( "ct_con_alloc", ct_con_alloc(context_ptr(context), &conn) );
retval_inspect( "ct_diag",
ct_diag(conn, CS_INIT, CS_UNUSED, CS_UNUSED, NULL) );
result = alloc_custom(&connection_operations, sizeof(CS_CONNECTION*), 0, 1);
connection_ptr(result) = conn;
CAMLreturn(result);
}
static BOOL ProvStore_addCTL(WINECRYPT_CERTSTORE *store, context_t *ctl,
context_t *toReplace, context_t **ppStoreContext, BOOL use_link)
{
WINE_PROVIDERSTORE *ps = (WINE_PROVIDERSTORE*)store;
BOOL ret;
TRACE("(%p, %p, %p, %p)\n", store, ctl, toReplace, ppStoreContext);
if (toReplace)
ret = ps->memStore->vtbl->ctls.addContext(ps->memStore, ctl, toReplace,
ppStoreContext, TRUE);
else
{
if (ps->hdr.dwOpenFlags & CERT_STORE_READONLY_FLAG)
{
SetLastError(ERROR_ACCESS_DENIED);
ret = FALSE;
}
else
{
ret = TRUE;
if (ps->provWriteCtl)
ret = ps->provWriteCtl(ps->hStoreProv, context_ptr(ctl),
CERT_STORE_PROV_WRITE_ADD_FLAG);
if (ret)
ret = ps->memStore->vtbl->ctls.addContext(ps->memStore, ctl, NULL,
ppStoreContext, TRUE);
}
}
/* dirty trick: replace the returned context's hCertStore with
* store.
*/
if (ret && ppStoreContext)
(*(ctl_t**)ppStoreContext)->ctx.hCertStore = store;
return ret;
}
int uvplus_tcp::keepalive(int enable, unsigned int delay) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_keepalive(tcp, enable, delay);
}
/** Default constructor */
fast_client()
: basic_client<T>(context_ptr(new zmq::context_t(1)))
, _enable_skip(false), _recv_skip(0)
{}
/** Default constructor. */
fast_server()
: basic_server<T>(context_ptr(new zmq::context_t(1)))
{}
int uvplus_tcp::getpeername(struct sockaddr *name, int *namelen) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_getpeername(tcp, name, namelen);
}
int uvplus_tcp::bind(const sockaddr *addr, unsigned int flags) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_bind(tcp, addr, flags);
}
int uvplus_tcp::init(uvplus_loop &loop) {
this->uvplus_handle::init();
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_init(loop.context_ptr(), tcp);
}
void lua_context::init()
{
// initialize Lua
state_.reset(luaL_newstate(), [](lua_State* L) { lua_close(L); });
// load various Lua libraries
luaopen_base(context_ptr());
luaopen_string(context_ptr());
luaopen_table(context_ptr());
luaopen_math(context_ptr());
luaopen_io(context_ptr());
luaopen_debug(context_ptr());
luaL_openlibs(context_ptr());
luaL_newmetatable(context_ptr(), function_str);
luaL_setfuncs(context_ptr(), gFFLFunctions, 0);
luaL_newmetatable(context_ptr(), callable_str);
luaL_setfuncs(context_ptr(), gCallableFunctions, 0);
luaL_newmetatable(context_ptr(), callable_function_str);
luaL_setfuncs(context_ptr(), gFFLCallableFunctions, 0);
luaL_newmetatable(context_ptr(), lib_functions_str);
luaL_setfuncs(context_ptr(), gLibMetaFunctions, 0);
push_anura_table(context_ptr());
/*dostring(
"local lvl = Anura.level()\n"
"print(lvl.id, lvl.music_volume, lvl.in_editor)\n"
"Anura.debug('abcd')\n"
"Anura.eval('debug(map(range(10),value))')\n"
"local camera = lvl.camera\n"
"print('Camera speed: ' .. camera.speed)\n"
"for n = 1, 10 do\n"
" camera.speed = n\n"
" print('Camera speed: ' .. camera.speed)\n"
"end\n"
"lvl.player:debug_rect(lvl.player.mid_x-50, lvl.player.mid_y-50, 100, 100)\n"
//"for i,v in ipairs(lvl.active_chars) do\n"
//"for i,v in ipairs(Anura.eval('range(10)')) do\n"
"local mm = Anura.eval('{q(a):1,q(b):2}')\n"
//"print(mm.a)\n"
"for i,v in pairs(mm) do\n"
" print(i, v)\n"
"end\n"
);*/
/*dostring("local me = Anura.me\n"
"print(me.speed)",
level::current().camera().get()
);*/
}
int uvplus_tcp::nodelay(int enable) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_nodelay(tcp, enable);
}
int uvplus_tcp::open(uv_os_sock_t sock) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_open(tcp, sock);
}
int uvplus_tcp::init_ex(uvplus_loop &loop, int flags) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_init_ex(loop.context_ptr(), tcp, flags);
}
static context_ptr create(logger_ptr l, platform_t const& platform) {
context_ptr result = context_ptr(new context(l, platform));
return result;
}
int uvplus_tcp::simultaneous_accepts(int enable) {
auto tcp = (uv_tcp_t *)context_ptr();
return uv_tcp_simultaneous_accepts(tcp, enable);
}
