Exemplo n.º 1
0
Arquivo: stream.c Projeto: esmil/lem
static int
stream_close(lua_State *T)
{
	struct stream *s;

	luaL_checktype(T, 1, LUA_TUSERDATA);
	s = lua_touserdata(T, 1);
	if (!s->open)
		return io_closed(T);
	if (s->r.data != NULL) {
		ev_io_stop(LEM_ &s->r);
		lem_queue(s->r.data, io_closed(s->r.data));
		s->r.data = NULL;
	}
	if (s->w.data != NULL) {
		ev_io_stop(LEM_ &s->w);
		lem_queue(s->w.data, io_closed(s->w.data));
		s->w.data = NULL;
	}

	s->open = 0;
	if (close(s->r.fd))
		return io_strerror(T, errno);

	lua_pushboolean(T, 1);
	return 1;
}
Exemplo n.º 2
0
Arquivo: file.c Projeto: halfd/lem
static void
file_write_reap(struct lem_async *a)
{
	struct file *f = (struct file *)a;
	lua_State *T = f->T;
	int top;

	if (f->ret) {
		f->T = NULL;
		lem_queue(T, io_strerror(T, f->ret));
		return;
	}

	top = lua_gettop(T);
	do {
		if (f->write.idx == top) {
			f->T = NULL;
			lua_pushboolean(T, 1);
			lem_queue(T, 1);
			return;
		}

		f->write.str = lua_tolstring(T, ++f->write.idx, &f->write.len);
	} while (f->write.len == 0);

	lem_async_run(&f->a);
}
Exemplo n.º 3
0
static void
stmt_step_reap(struct lem_async *a)
{
	struct db *db = (struct db *)a;
	lua_State *T = db->T;
	sqlite3_stmt *stmt = db->req.prep.stmt;
	int ret;

	switch (db->ret) {
	case SQLITE_ROW:
		lem_debug("SQLITE_ROW");
		pushrow(T, stmt);
		ret = 1;
		break;

	case SQLITE_DONE:
		lem_debug("SQLITE_DONE");
		(void)sqlite3_reset(stmt);
		(void)sqlite3_clear_bindings(stmt);
		lua_pushboolean(T, 1);
		ret = 1;
		break;

	default:
		lem_debug("Ack!");
		lua_pushnil(T);
		lua_pushstring(T, sqlite3_errmsg(db->handle));
		ret = 2;
	}

	lem_queue(T, ret);
	db->T = NULL;
}
Exemplo n.º 4
0
Arquivo: stream.c Projeto: esmil/lem
static void
stream_readp_cb(EV_P_ struct ev_io *w, int revents)
{
	struct stream *s = STREAM_FROM_WATCH(w, r);
	lua_State *T = s->r.data;
	int ret;

	(void)revents;

	if (!s->open) {
		ret = 0;
		if (s->p->destroy)
			ret = s->p->destroy(T, &s->buf, LEM_PCLOSED);
		if (ret <= 0)
			ret = io_closed(T);
	} else {
		ret = stream__readp(T, s);
		if (ret == 0)
			return;
	}

	ev_io_stop(EV_A_ &s->r);
	s->r.data = NULL;
	lem_queue(T, ret);
}
Exemplo n.º 5
0
Arquivo: utils.c Projeto: esmil/lem
static int
sleeper_wakeup(lua_State *T)
{
	struct ev_timer *w;
	lua_State *S;
	int nargs;

	luaL_checktype(T, 1, LUA_TUSERDATA);
	w = lua_touserdata(T, 1);
	S = w->data;
	if (S == NULL) {
		lua_pushnil(T);
		lua_pushliteral(T, "not sleeping");
		return 2;
	}

	ev_timer_stop(LEM_ w);

	nargs = lua_gettop(T) - 1;
	lua_settop(S, 0);
	lua_xmove(T, S, nargs);
	lem_queue(S, nargs);
	w->data = NULL;

	/* return true */
	lua_pushboolean(T, 1);
	return 1;
}
Exemplo n.º 6
0
Arquivo: lem.c Projeto: esmil/lem
static int
queue_file(int argc, char *argv[], int fidx)
{
	lua_State *T = lem_newthread();
	const char *filename;
	int i;

	if (fidx < argc)
		filename = argv[fidx];
	else
		filename = LEM_LDIR "lem/repl.lua";

	switch (luaL_loadfile(T, filename)) {
	case LUA_OK: /* success */
		break;

	case LUA_ERRMEM:
		oom();

	default:
		lem_log_error("lem: %s", lua_tostring(T, 1));
		return -1;
	}

	lua_createtable(T, argc, 0);
	for (i = 0; i < argc; i++) {
		lua_pushstring(T, argv[i]);
		lua_rawseti(T, -2, i - fidx);
	}
	lua_setglobal(T, "arg");

	lem_queue(T, 0);
	return 0;
}
Exemplo n.º 7
0
Arquivo: file.c Projeto: halfd/lem
static void
file_seek_reap(struct lem_async *a)
{
	struct file *f = (struct file *)a;
	lua_State *T = f->T;

	f->T = NULL;

	if (f->ret) {
		lem_queue(T, io_strerror(T, f->ret));
		return;
	}

	lua_pushnumber(T, f->seek.offset);
	lem_queue(T, 1);
}
Exemplo n.º 8
0
static void
db_open_reap(struct lem_async *a)
{
	struct db *db = (struct db *)a;
	lua_State *T = db->T;
	int ret;

	if (db->handle == NULL) {
		lem_debug("db->handle == NULL");
		lua_pushnil(T);
		lua_pushliteral(T, "out of memory");
		db_unref(db);
		ret = 2;
	} else if (db->ret != SQLITE_OK) {
		lem_debug("db->ret != SQLITE_OK");
		lua_pushnil(T);
		lua_pushstring(T, sqlite3_errmsg(db->handle));
		db_unref(db);
		ret = 2;
	} else {
		struct box *box = lua_newuserdata(T, sizeof(struct box));

		lem_debug("Success!");
		box->db = db;

		/* set metatable */
		lua_pushvalue(T, 2);
		lua_setmetatable(T, -2);

		ret = 1;
	}

	lem_queue(T, ret);
	db->T = NULL;
}
Exemplo n.º 9
0
static DBusHandlerResult
signal_handler(lua_State *S, DBusMessage *msg)
{
	lua_State *T;
	const char *path = dbus_message_get_path(msg);
	const char *interface = dbus_message_get_interface(msg);
	const char *member = dbus_message_get_member(msg);

	lem_debug("received signal\n  %s\n  %s\n  %s(%s)",
	          path, interface, member,
	          dbus_message_get_signature(msg));

	/* NOTE: this magic string representation of an
	 * incoming signal must match the one in the Lua code */
	lua_pushfstring(S, "%s\n%s\n%s",
	                path      ? path      : "",
	                interface ? interface : "",
	                member    ? member    : "");

	lua_rawget(S, LEM_DBUS_SIGNAL_TABLE);
	if (lua_type(S, -1) != LUA_TFUNCTION) {
		lua_settop(S, LEM_DBUS_TOP);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}

	/* create new thread */
	T = lem_newthread();
	lua_xmove(S, T, 1);

	lem_queue(T, lem_dbus_push_arguments(T, msg));

	return DBUS_HANDLER_RESULT_HANDLED;
}
Exemplo n.º 10
0
Arquivo: server.c Projeto: esmil/lem
static int
server_close(lua_State *T)
{
	struct ev_io *w;
	int ret;

	luaL_checktype(T, 1, LUA_TUSERDATA);
	w = lua_touserdata(T, 1);
	if (w->fd < 0)
		return io_closed(T);

	if (w->data != NULL) {
		lem_debug("interrupting listen");
		ev_io_stop(LEM_ w);
		lua_pushnil(w->data);
		lua_pushliteral(w->data, "interrupted");
		lem_queue(w->data, 2);
		w->data = NULL;
	}

	lem_debug("closing server..");

	ret = close(w->fd);
	w->fd = -1;
	if (ret)
		return io_strerror(T, errno);

	lua_pushboolean(T, 1);
	return 1;
}
Exemplo n.º 11
0
Arquivo: file.c Projeto: halfd/lem
static void
file_close_reap(struct lem_async *a)
{
	struct file *f = (struct file *)a;
	lua_State *T = f->T;

	f->T = NULL;
	f->fd = -1;
	if (f->ret) {
		lem_queue(T, io_strerror(T, f->ret));
		return;
	}

	lua_pushboolean(T, 1);
	lem_queue(T, 1);
}
Exemplo n.º 12
0
Arquivo: utils.c Projeto: esmil/lem
static void
sleep_handler(EV_P_ struct ev_timer *w, int revents)
{
	lua_State *T = w->data;

	(void)revents;

	/* return nil, "timeout" */
	lem_queue(T, 2);
	w->data = NULL;
}
Exemplo n.º 13
0
Arquivo: core.c Projeto: ifzz/lem
static void
signal_child_handler(EV_P_ struct ev_child *w, int revents)
{
	lua_State *S;
	int status;
	int pid = w->pid;
	int rpid = w->rpid;

	(void)revents;

	S = lem_newthread();
	lua_pushlightuserdata(S, &sigmap);
	lua_rawget(S, LUA_REGISTRYINDEX);
	if (lua_type(S, 1) != LUA_TFUNCTION) {
		lem_forgetthread(S);
		return;
	}
	lua_pushinteger(S, SIGCHLD);

	status = w->rstatus;
	lua_createtable(S, 0, 5);

	lua_pushinteger(S, pid);
	lua_setfield(S, -2, "pid");
	lua_pushinteger(S, rpid);
	lua_setfield(S, -2, "rpid");

	if (WIFEXITED(status)) {
		lua_pushinteger(S, WEXITSTATUS(status));
		lua_setfield(S, -2, "status");
		lua_pushstring(S, "exited");
	} else if (WIFSIGNALED(status)) {
		lua_pushinteger(S, WTERMSIG(status));
		lua_setfield(S, -2, "signal");
#ifdef WCOREDUMP
		lua_pushboolean(S, WCOREDUMP(status));
		lua_setfield(S, -2, "coredumped");
#endif
		lua_pushstring(S, "signaled");
	} else if (WIFSTOPPED(status)) {
		lua_pushinteger(S, WSTOPSIG(status));
		lua_setfield(S, -2, "signal");
		lua_pushstring(S, "stopped");
	} else if (WIFCONTINUED(status)) {
		lua_pushstring(S, "continued");
	} else {
		assert(0); /* XXX do something more graceful */
	}
	lua_setfield(S, -2, "type");

	lem_queue(S, 2);
}
Exemplo n.º 14
0
static DBusHandlerResult
method_call_handler(lua_State *S, DBusMessage *msg)
{
	lua_State *T;
	struct message_object *m;
	const char *path = dbus_message_get_path(msg);
	const char *interface = dbus_message_get_interface(msg);
	const char *member = dbus_message_get_member(msg);

	lem_debug("received call\n  %s\n  %s\n  %s(%s)",
	          path, interface, member,
		  dbus_message_get_signature(msg));

	lua_pushstring(S, path ? path : "");
	lua_rawget(S, LEM_DBUS_OBJECT_TABLE);
	if (lua_type(S, -1) != LUA_TTABLE) {
		lua_settop(S, LEM_DBUS_TOP);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}

	lua_pushfstring(S, "%s.%s",
	                interface ? interface : "",
	                member    ? member    : "");
	lua_rawget(S, -2);
	if (lua_type(S, -1) != LUA_TFUNCTION) {
		lua_settop(S, LEM_DBUS_TOP);
		return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
	}

	/* create new thread */
	T = lem_newthread();
	lua_pushvalue(S, LEM_DBUS_BUS_OBJECT);
	lua_xmove(S, T, 2);
	lua_settop(S, LEM_DBUS_TOP);

	/* push the send_reply function */
	m = lua_newuserdata(T, sizeof(struct message_object));
	m->msg = msg;
	dbus_message_ref(msg);

	/* set metatable */
	lua_pushvalue(S, LEM_DBUS_MESSAGE_META);
	lua_xmove(S, T, 1);
	lua_setmetatable(T, -2);

	lua_pushcclosure(T, message_reply, 2);

	lem_queue(T, lem_dbus_push_arguments(T, msg) + 1);

	return DBUS_HANDLER_RESULT_HANDLED;
}
Exemplo n.º 15
0
Arquivo: utils.c Projeto: esmil/lem
static int
utils_resume(lua_State *T)
{
	int args;
	lua_State *S;

	luaL_checktype(T, 1, LUA_TTHREAD);
	S = lua_tothread(T, 1);

	args = lua_gettop(T) - 1;
	lua_xmove(T, S, args);
	lem_queue(S, args);

	return 0;
}
Exemplo n.º 16
0
Arquivo: file.c Projeto: halfd/lem
static void
file_readp_reap(struct lem_async *a)
{
	struct file *f = (struct file *)a;
	lua_State *T = f->T;
	int ret;

	if (f->ret) {
		enum lem_preason res = f->ret < 0 ? LEM_PCLOSED : LEM_PERROR;

		f->T = NULL;

		if (f->readp.p->destroy &&
				(ret = f->readp.p->destroy(T, &f->buf, res)) > 0) {
			lem_queue(T, ret);
			return;
		}

		lua_pushnil(T);
		if (res == LEM_PCLOSED)
			lua_pushliteral(T, "eof");
		else
			lua_pushstring(T, strerror(errno));
		lem_queue(T, 2);
		return;
	}

	ret = f->readp.p->process(T, &f->buf);
	if (ret > 0) {
		f->T = NULL;
		lem_queue(T, ret);
		return;
	}

	lem_async_run(&f->a);
}
Exemplo n.º 17
0
static void
connect_handler(EV_P_ struct ev_io *w, int revents)
{
	struct lem_ssl_stream *s = (struct lem_ssl_stream *)w;
	int ret;

	(void)revents;

	ret = stream_check_error(s->T, s, SSL_connect(s->ssl),
	                         "error establishing SSL connection: %s");
	if (ret == 0)
		return;

	stream_io_unregister(s);
	lem_queue(s->T, ret);
	s->T = NULL;
}
Exemplo n.º 18
0
static void
db_exec_step_reap(struct lem_async *a)
{
	struct db *db = (struct db *)a;
	lua_State *T = db->T;
	int ret;

	lem_debug("db->ret = %s", db->ret == SQLITE_ROW ? "SQLITE_ROW" :
			db->ret == SQLITE_DONE ? "SQLITE_DONE" : "error");
	switch (db->ret) {
	case SQLITE_ROW:
	case SQLITE_DONE:
		break;

	default:
		lua_pushnil(T);
		lua_pushstring(T, sqlite3_errmsg(db->handle));
		(void)sqlite3_finalize(db->req.prep.stmt);
		ret = 2;
		goto out;
	}

	if (sqlite3_finalize(db->req.prep.stmt) != SQLITE_OK) {
		lua_pushnil(T);
		lua_pushstring(T, sqlite3_errmsg(db->handle));
		ret = 2;
		goto out;
	}

	if (db->req.prep.tail == NULL) {
		lua_pushboolean(T, 1);
		ret = 1;
		goto out;
	}

	db->req.prep.len -= db->req.prep.tail - db->req.prep.sql;
	db->req.prep.sql = db->req.prep.tail;
	db->a.work = db_prepare_work;
	db->a.reap = db_exec_prepare_reap;
	lem_async_run(&db->a);
	return;
out:
	lem_queue(T, ret);
	db->T = NULL;
}
Exemplo n.º 19
0
Arquivo: utils.c Projeto: esmil/lem
static int
utils_spawn(lua_State *T)
{
	lua_State *S;
	int nargs;

	luaL_checktype(T, 1, LUA_TFUNCTION);

	S = lem_newthread();
	nargs = lua_gettop(T);

	lua_xmove(T, S, nargs);

	lem_queue(S, nargs - 1);

	lua_pushboolean(T, 1);
	return 1;
}
Exemplo n.º 20
0
Arquivo: core.c Projeto: ifzz/lem
static void
signal_os_handler(EV_P_ struct ev_signal *w, int revents)
{
	lua_State *S;

	(void)revents;

	S = lem_newthread();
	lua_pushlightuserdata(S, &sigmap);
	lua_rawget(S, LUA_REGISTRYINDEX);
	if (lua_type(S, 1) != LUA_TFUNCTION) {
		lem_forgetthread(S);
		return;
	}

	lua_pushinteger(S, w->signum);
	lem_queue(S, 1);
}
Exemplo n.º 21
0
static void
method_return_handler(DBusPendingCall *pending, void *data)
{
	lua_State *T = data;
	DBusMessage *msg = dbus_pending_call_steal_reply(pending);
	int nargs;

	dbus_pending_call_unref(pending);

	lem_debug("received return(%s)", dbus_message_get_signature(msg));

	if (msg == NULL) {
		lua_pushnil(T);
		lua_pushliteral(T, "null reply");
		nargs = 2;
	} else {
		switch (dbus_message_get_type(msg)) {
		case DBUS_MESSAGE_TYPE_METHOD_RETURN:
			nargs = lem_dbus_push_arguments(T, msg);
			break;

		case DBUS_MESSAGE_TYPE_ERROR:
			lua_pushnil(T);
			{
				DBusError err;

				dbus_error_init(&err);
				dbus_set_error_from_message(&err, msg);
				lua_pushstring(T, err.message);
				dbus_error_free(&err);
			}
			nargs = 2;
			break;

		default:
			lua_pushnil(T);
			lua_pushliteral(T, "unknown reply");
			nargs = 2;
		}
		dbus_message_unref(msg);
	}

	lem_queue(T, nargs);
}
Exemplo n.º 22
0
Arquivo: server.c Projeto: esmil/lem
static void
server_accept_cb(EV_P_ struct ev_io *w, int revents)
{
	int ret;

	(void)revents;

	ret = server__accept(w->data, w, 2);
	if (ret == 0)
		return;

	w->data = NULL;
	ev_io_stop(EV_A_ w);
	if (ret == 2) {
		close(w->fd);
		w->fd = -1;
	}
	lem_queue(w->data, ret);
}
Exemplo n.º 23
0
Arquivo: stream.c Projeto: esmil/lem
static void
stream_write_cb(EV_P_ struct ev_io *w, int revents)
{
	struct stream *s = STREAM_FROM_WATCH(w, w);
	lua_State *T = s->w.data;
	int ret;

	(void)revents;

	if (!s->open)
		ret = io_closed(T);
	else {
		ret = stream__write(T, s);
		if (ret == 0)
			return;
	}

	ev_io_stop(EV_A_ &s->w);
	s->w.data = NULL;
	lem_queue(T, ret);
}
Exemplo n.º 24
0
static void
db_exec_prepare_reap(struct lem_async *a)
{
	struct db *db = (struct db *)a;
	lua_State *T = db->T;
	int ret;

	if (db->ret != SQLITE_OK) {
		lem_debug("db->ret != SQLITE_OK");
		lua_pushnil(T);
		lua_pushstring(T, sqlite3_errmsg(db->handle));
		ret = 2;
		goto out;
	}

	lem_debug("db->ret == SQLITE_OK");
	if (db->req.prep.stmt == NULL) {
		lem_debug("db->req.prep.stmt == NULL");
		lua_pushboolean(T, 1);
		ret = 1;
		goto out;
	}

	if (lua_gettop(T) > 1 && bindtable(T, db->req.prep.stmt)) {
		(void)sqlite3_finalize(db->req.prep.stmt);
		lua_pushnil(T);
		lua_insert(T, -2);
		ret = 2;
		goto out;
	}

	db->a.work = db_step_work;
	db->a.reap = db_exec_step_reap;
	lem_async_run(&db->a);
	return;
out:
	lem_queue(T, ret);
	db->T = NULL;
}
Exemplo n.º 25
0
Arquivo: utils.c Projeto: esmil/lem
static int
sleeper_sleep(lua_State *T)
{
	struct ev_timer *w;

	luaL_checktype(T, 1, LUA_TUSERDATA);
	w = lua_touserdata(T, 1);
	if (w->data != NULL) {
		lua_pushnil(T);
		lua_pushliteral(T, "busy");
		return 2;
	}

	if (lua_gettop(T) > 1 && !lua_isnil(T, 2)) {
		ev_tstamp delay = (ev_tstamp)luaL_checknumber(T, 2);

		if (delay <= 0) {
			/* return nil, "timeout"
			 * ..but yield the thread */
			lua_pushnil(T);
			lua_pushvalue(T, lua_upvalueindex(1));
			lem_queue(T, 2);

			return lua_yield(T, 2);
		}

		ev_timer_set(w, delay, 0);
		ev_timer_start(LEM_ w);
	}

	w->data = T;

	/* yield sleeper, nil, "timeout" */
	lua_settop(T, 1);
	lua_pushnil(T);
	lua_pushvalue(T, lua_upvalueindex(1));
	return lua_yield(T, 3);
}
Exemplo n.º 26
0
Arquivo: stream.c Projeto: esmil/lem
static void
stream_sendfile_reap(struct lem_async *a)
{
	struct sfhandle *sf = (struct sfhandle *)a;
	lua_State *T = sf->T;
	struct stream *s = sf->s;
	int ret;

	if (sf->ret == 0) {
		lua_pushinteger(T, sf->size);
		ret = 1;
	} else {
		if (s->open)
			close(s->w.fd);
		s->open = 0;
		ret = io_strerror(T, sf->ret);
	}

	free(sf);

	s->w.data = NULL;
	lem_queue(T, ret);
}
Exemplo n.º 27
0
Arquivo: server.c Projeto: esmil/lem
static int
server_interrupt(lua_State *T)
{
	struct ev_io *w;

	luaL_checktype(T, 1, LUA_TUSERDATA);
	w = lua_touserdata(T, 1);
	if (w->data == NULL) {
		lua_pushnil(T);
		lua_pushliteral(T, "not busy");
		return 2;
	}

	lem_debug("interrupting listening");
	ev_io_stop(LEM_ w);
	lua_pushnil(w->data);
	lua_pushliteral(w->data, "interrupted");
	lem_queue(w->data, 2);
	w->data = NULL;

	lua_pushboolean(T, 1);
	return 1;
}
Exemplo n.º 28
0
static void
db_prepare_reap(struct lem_async *a)
{
	struct db *db = (struct db *)a;
	lua_State *T = db->T;
	int ret;

	if (db->ret != SQLITE_OK) {
		lem_debug("db->ret != SQLITE_OK");
		lua_pushnil(T);
		lua_pushstring(T, sqlite3_errmsg(db->handle));
		ret = 2;
		db_unref(db);
	} else if (db->req.prep.stmt == NULL) {
		lem_debug("db->req.prep.stmt == NULL");
		lua_pushnil(T);
		lua_pushliteral(T, "nosql");
		ret = 2;
		db_unref(db);
	} else {
		struct stmt *stmt = lua_newuserdata(T, sizeof(struct stmt));

		lem_debug("Success!");
		stmt->handle = db->req.prep.stmt;
		stmt->db = db;

		/* set metatable */
		lua_pushvalue(T, 3);
		lua_setmetatable(T, -2);

		ret = 1;
	}

	lem_queue(T, ret);
	db->T = NULL;
}
Exemplo n.º 29
0
Arquivo: server.c Projeto: esmil/lem
static void
server_autospawn_cb(EV_P_ struct ev_io *w, int revents)
{
	lua_State *T = w->data;
	int sock;
	lua_State *S;

	(void)revents;

	/* dequeue the incoming connection */
#ifdef SOCK_CLOEXEC
	sock = accept4(w->fd, NULL, NULL, SOCK_CLOEXEC | SOCK_NONBLOCK);
#else
	sock = accept(w->fd, NULL, NULL);
#endif
	if (sock < 0) {
		switch (errno) {
		case EAGAIN: case EINTR: case ECONNABORTED:
		case ENETDOWN: case EPROTO: case ENOPROTOOPT:
		case EHOSTDOWN:
#ifdef ENONET
		case ENONET:
#endif
		case EHOSTUNREACH: case EOPNOTSUPP: case ENETUNREACH:
			return;
		}
		lua_pushnil(T);
		lua_pushfstring(T, "error accepting connection: %s",
		                strerror(errno));
		goto error;
	}
#ifndef SOCK_CLOEXEC
	/* set FD_CLOEXEC and make the socket non-blocking */
	if (fcntl(sock, F_SETFD, FD_CLOEXEC) == -1 ||
			fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
		close(sock);
		lua_pushnil(T);
		lua_pushfstring(T, "error setting socket flags: %s",
		                strerror(errno));
		goto error;
	}
#endif
	S = lem_newthread();

	/* copy handler function */
	lua_pushvalue(T, 2);
	/* create stream */
	stream_new(T, sock, 3);
	/* move function and stream to new thread */
	lua_xmove(T, S, 2);

	lem_queue(S, 1);
	return;

error:
	ev_io_stop(EV_A_ w);
	close(w->fd);
	w->fd = -1;
	w->data = NULL;
	lem_queue(T, 2);
}
Exemplo n.º 30
0
Arquivo: utils.c Projeto: esmil/lem
static int
utils_yield(lua_State *T)
{
	lem_queue(T, 0);
	return lua_yield(T, 0);
}