static ERL_NIF_TERM
push_command(ErlNifEnv *env, elua_t *res, msg_t *msg)
{
Tracker *tracker = (Tracker*) enif_priv_data(env);
int hash_idx;
if(res==NULL){
hash_idx=0;
}else{
hash_idx=worker_hash(res->L);
}
assert(hash_idx>=0 && hash_idx< WORKER_NO);
worker_t *w = &tracker->workers[hash_idx];
if(res!=NULL) {
enif_keep_resource(res);
}
if(!queue_push(w->q, msg)){
if(res!=NULL) {
enif_release_resource(res);
}
return make_error_tuple(env, "command_push_failed");
}
// printf("%d send\n", w->id);
return atom_ok;
}
static ERL_NIF_TERM
do_prepare(ErlNifEnv *env, esqlite_connection *conn, const ERL_NIF_TERM arg)
{
ErlNifBinary bin;
esqlite_statement *stmt;
ERL_NIF_TERM esqlite_stmt;
const char *tail;
int rc;
enif_inspect_iolist_as_binary(env, arg, &bin);
stmt = enif_alloc_resource(esqlite_statement_type, sizeof(esqlite_statement));
if(!stmt)
return make_error_tuple(env, "no_memory");
rc = sqlite3_prepare_v2(conn->db, (char *) bin.data, bin.size, &(stmt->statement), &tail);
if(rc != SQLITE_OK)
return make_sqlite3_error_tuple(env, rc, conn->db);
enif_keep_resource(conn);
stmt->connection = conn;
esqlite_stmt = enif_make_resource(env, stmt);
enif_release_resource(stmt);
return make_ok_tuple(env, esqlite_stmt);
}
static ERL_NIF_TERM send_blob_thread(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
union { void* vp; struct make_term_info* p; }mti;
ERL_NIF_TERM copy;
if (!enif_get_resource(env, argv[0], msgenv_resource_type, &mti.vp)
|| !enif_get_local_pid(env,argv[1], &mti.p->to_pid)) {
return enif_make_badarg(env);
}
copy = enif_make_copy(env, mti.p->blob);
mti.p->send_it = enif_is_identical(argv[2],atom_join);
if (enif_thread_create("nif_SUITE:send_from_thread", &mti.p->tid,
threaded_sender, mti.p, NULL) != 0) {
return enif_make_badarg(env);
}
if (enif_is_identical(argv[2],atom_join)) {
int err = enif_thread_join(mti.p->tid, NULL);
assert(err == 0);
return enif_make_tuple3(env, atom_ok, enif_make_int(env, mti.p->send_res), copy);
}
else {
enif_keep_resource(mti.vp);
return enif_make_tuple2(env, atom_ok, copy);
}
}
ERL_NIF_TERM
geef_revparse_single(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin, id;
geef_repository *repo;
geef_object *obj;
ERL_NIF_TERM type, term_obj;
if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
return enif_make_badarg(env);
if (!enif_inspect_iolist_as_binary(env, argv[1], &bin))
return enif_make_badarg(env);
if (geef_terminate_binary(&bin) < 0)
return geef_oom(env);
obj = enif_alloc_resource(geef_object_type, sizeof(geef_object));
if (!obj)
return geef_oom(env);
if (git_revparse_single(&obj->obj, repo->repo, (char *) bin.data) < 0) {
enif_release_binary(&bin);
enif_release_resource(obj);
return geef_error(env);
}
type = geef_object_type2atom(git_object_type(obj->obj));
if (geef_oid_bin(&id, git_object_id(obj->obj)) < 0)
return geef_oom(env);
term_obj = enif_make_resource(env, obj);
enif_release_resource(obj);
obj->repo = repo;
enif_keep_resource(repo);
return enif_make_tuple4(env, atoms.ok, term_obj, type, enif_make_binary(env, &id));
}
static ERL_NIF_TERM do_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
char deviceName[MAXBUFLEN];
long latency;
ERL_NIF_TERM streamTerm;
PortMidiStream **streamAlloc;
PmError result;
ErlNifResourceType* streamType = (ErlNifResourceType*)enif_priv_data(env);
streamAlloc = (PortMidiStream**)enif_alloc_resource(streamType, sizeof(PortMidiStream*));
enif_get_string(env, argv[0], deviceName, MAXBUFLEN, ERL_NIF_LATIN1);
enif_get_long(env, argv[1], &latency);
if((result = findDevice(streamAlloc, deviceName, OUTPUT, latency)) != pmNoError) {
ERL_NIF_TERM reason = enif_make_atom(env, makePmErrorAtom(result));
return enif_make_tuple2(env, enif_make_atom(env, "error"), reason);
}
streamTerm = enif_make_resource(env, streamAlloc);
enif_keep_resource(streamAlloc);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), streamTerm);
}
