forks/geef
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Keep references purely in erlang

Browse Source 
Refernces contain three pieces of data which we already keep in the
erlang record. Keep the repository it belongs to in the record as well
and remove resource in the NIF. This makes the code easier to reason
about, as we don't need to keep any reference counts or GC the C
struct.

This does mean we cannot re-use references across geef_repo restarts,
but that's probably a good thing.
This commit is contained in:
Carlos Martín Nieto
2013-08-31 17:23:46 +02:00
parent da7a070522
commit 70867b9615
6 changed files with 185 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

266
c_src/reference.c
View File

@@ -40,14 +40,59 @@ on_error:
return geef_oom(env);
}
static int ref_target(ERL_NIF_TERM *out, ErlNifEnv *env, git_reference *ref)
{
ErlNifBinary bin;
if (git_reference_type(ref) == GIT_REF_OID) {
const git_oid *id;
id = git_reference_target(ref);
if (geef_oid_bin(&bin, id) < 0)
return -1;
} else {
const char *name;
size_t len;
name = git_reference_symbolic_target(ref);
len = strlen(name);
if (enif_alloc_binary(len, &bin) < 0)
return -1;
memcpy(bin.data, name, len);
}
*out = enif_make_binary(env, &bin);
return 0;
}
static ERL_NIF_TERM ref_type(git_reference *ref)
{
ERL_NIF_TERM type;
switch (git_reference_type(ref)) {
case GIT_REF_OID:
type = atoms.oid;
break;
case GIT_REF_SYMBOLIC:
type = atoms.symbolic;
break;
default:
type = atoms.error;
break;
}
return type;
}
ERL_NIF_TERM
geef_reference_lookup(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_repository *repo;
geef_ref *res_ref;
git_reference *ref;
git_reference *ref = NULL;
ERL_NIF_TERM target, type;
ErlNifBinary bin;
ERL_NIF_TERM term_ref;
int error;
if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
@@ -57,20 +102,24 @@ geef_reference_lookup(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
return enif_make_badarg(env);
if (!geef_terminate_binary(&bin))
return geef_oom(env);
goto on_oom;
error = git_reference_lookup(&ref, repo->repo, (char *)bin.data);
enif_release_binary(&bin);
if (error < 0)
return geef_error(env);
res_ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
res_ref->ref = ref;
term_ref = enif_make_resource(env, res_ref);
enif_release_resource(res_ref);
type = ref_type(ref);
if (ref_target(&target, env, ref) < 0)
goto on_oom;
return enif_make_tuple2(env, atoms.ok, term_ref);
return enif_make_tuple3(env, atoms.ok, type, target);
on_oom:
git_reference_free(ref);
enif_release_binary(&bin);
return geef_oom(env);
}
ERL_NIF_TERM
@@ -120,10 +169,12 @@ ERL_NIF_TERM
geef_reference_next(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
int error;
geef_ref *res_ref;
size_t len;
const char *name;
git_reference *ref;
ErlNifBinary bin;
geef_ref_iter *iter;
ERL_NIF_TERM term_ref;
ERL_NIF_TERM type, target;
if (!enif_get_resource(env, argv[0], geef_ref_iter_type, (void **) &iter))
return enif_make_badarg(env);
@@ -134,12 +185,22 @@ geef_reference_next(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
if (error < 0)
return geef_error(env);
res_ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
res_ref->ref = ref;
term_ref = enif_make_resource(env, res_ref);
enif_release_resource(res_ref);
type = ref_type(ref);
if (ref_target(&target, env, ref) < 0) {
git_reference_free(ref);
return geef_oom(env);
}
return enif_make_tuple2(env, atoms.ok, term_ref);
name = git_reference_name(ref);
len = strlen(name);
if (!enif_alloc_binary(len, &bin)) {
git_reference_free(ref);
return geef_oom(env);
}
memcpy(bin.data, name, len);
return enif_make_tuple4(env, atoms.ok, enif_make_binary(env, &bin), type, target);
}
void geef_ref_iter_free(ErlNifEnv *env, void *cd)
@@ -152,31 +213,57 @@ void geef_ref_iter_free(ErlNifEnv *env, void *cd)
ERL_NIF_TERM
geef_reference_resolve(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_ref *in_ref, *res_ref;
ERL_NIF_TERM term_ref;
git_reference *ref;
size_t len;
const char *name;
ErlNifBinary bin, id;
geef_repository *repo;
git_reference *ref, *resolved;
if (!enif_get_resource(env, argv[0], geef_ref_type, (void **) &in_ref))
if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
return enif_make_badarg(env);
if (git_reference_resolve(&ref, in_ref->ref) < 0)
if (!enif_inspect_binary(env, argv[1], &bin))
return enif_make_badarg(env);
if (!geef_terminate_binary(&bin))
return geef_oom(env);
if (git_reference_lookup(&ref, repo->repo, (char *) bin.data) < 0)
return geef_error(env);
res_ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
res_ref->ref = ref;
term_ref = enif_make_resource(env, res_ref);
enif_release_resource(res_ref);
if (git_reference_resolve(&resolved, ref) < 0)
return geef_error(env);
return enif_make_tuple2(env, atoms.ok, term_ref);
git_reference_free(ref);
name = git_reference_name(resolved);
len = strlen(name);
if (enif_realloc_binary(&bin, len) < 0)
goto on_oom;
memcpy(bin.data, name, len);
if (geef_oid_bin(&id, git_reference_target(resolved)) < 0)
goto on_oom;
git_reference_free(resolved);
return enif_make_tuple3(env, atoms.ok, enif_make_binary(env, &bin), enif_make_binary(env, &id));
on_oom:
git_reference_free(resolved);
return geef_oom(env);
}
ERL_NIF_TERM
geef_reference_dwim(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary bin;
geef_ref *ref;
ERL_NIF_TERM term_ref;
ERL_NIF_TERM target, type;
geef_repository *repo;
git_reference *ref;
const char *name;
size_t len;
if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
return enif_make_badarg(env);
@@ -187,22 +274,27 @@ geef_reference_dwim(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
if (!geef_terminate_binary(&bin))
return geef_oom(env);
ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
if (git_reference_dwim(&ref->ref, repo->repo, (char *)bin.data) < 0) {
if (git_reference_dwim(&ref, repo->repo, (char *)bin.data) < 0) {
enif_release_binary(&bin);
return geef_error(env);
}
term_ref = enif_make_resource(env, ref);
enif_release_resource(ref);
type = ref_type(ref);
if (ref_target(&target, env, ref) < 0) {
git_reference_free(ref);
return geef_oom(env);
}
return enif_make_tuple2(env, atoms.ok, term_ref);
}
name = git_reference_name(ref);
len = strlen(name);
if (!enif_realloc_binary(&bin, len)) {
git_reference_free(ref);
enif_release_binary(&bin);
}
void geef_ref_free(ErlNifEnv *env, void *cd)
{
geef_ref *ref = (geef_ref *) cd;
git_reference_free(ref->ref);
memcpy(bin.data, name, len);
return enif_make_tuple4(env, atoms.ok, enif_make_binary(env, &bin), type, target);
}
struct list_data {
@@ -253,37 +345,6 @@ geef_reference_glob(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
return data.list;
}
ERL_NIF_TERM
geef_reference_target(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_ref *ref;
ErlNifBinary bin;
if (!enif_get_resource(env, argv[0], geef_ref_type, (void **) &ref))
return enif_make_badarg(env);
if (git_reference_type(ref->ref) == GIT_REF_OID) {
const git_oid *id;
id = git_reference_target(ref->ref);
if (geef_oid_bin(&bin, id) < 0)
return geef_oom(env);
} else {
const char *name;
size_t len;
name = git_reference_symbolic_target(ref->ref);
len = strlen(name);
if (enif_alloc_binary(len, &bin) < 0)
return geef_oom(env);
memcpy(bin.data, name, len + 1);
}
return enif_make_binary(env, &bin);
}
ERL_NIF_TERM
geef_reference_to_id(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
@@ -309,63 +370,13 @@ geef_reference_to_id(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
return enif_make_tuple2(env, atoms.ok, enif_make_binary(env, &bin));
}
ERL_NIF_TERM
geef_reference_type(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_ref *ref;
int type;
ERL_NIF_TERM term_type;
if (!enif_get_resource(env, argv[0], geef_ref_type, (void **) &ref))
return enif_make_badarg(env);
type = git_reference_type(ref->ref);
switch (type) {
case GIT_REF_OID:
term_type = atoms.oid;
break;
case GIT_REF_SYMBOLIC:
term_type = atoms.symbolic;
break;
default:
term_type = atoms.error;
break;
}
return term_type;
}
ERL_NIF_TERM
geef_reference_name(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_ref *ref;
const char *name;
ErlNifBinary bin;
size_t len;
if (!enif_get_resource(env, argv[0], geef_ref_type, (void **) &ref))
return enif_make_badarg(env);
name = git_reference_name(ref->ref);
len = strlen(name);
if (enif_alloc_binary(len, &bin) < 0)
return geef_oom(env);
memcpy(bin.data, name, len + 1);
return enif_make_tuple2(env, atoms.ok, enif_make_binary(env, &bin));
}
ERL_NIF_TERM
geef_reference_create(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
geef_repository *repo;
geef_ref *ref;
ErlNifBinary name, target;
ERL_NIF_TERM term_ref;
int error, force;
git_reference *ref;
const char *pname, *ptarget;
if (!enif_get_resource(env, argv[0], geef_repository_type, (void **) &repo))
@@ -380,20 +391,18 @@ geef_reference_create(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
if (!geef_terminate_binary(&name))
return geef_oom(env);
ref = enif_alloc_resource(geef_ref_type, sizeof(geef_ref));
force = enif_is_identical(argv[4], atoms.true);
pname = (const char *) name.data;
if (enif_is_identical(argv[2], atoms.oid)) {
const git_oid *oid = (const git_oid *) target.data;
error = git_reference_create(&ref->ref, repo->repo, pname, oid, force);
error = git_reference_create(&ref, repo->repo, pname, oid, force);
} else if (enif_is_identical(argv[2], atoms.symbolic)) {
if (!geef_terminate_binary(&target))
return geef_oom(env);
ptarget = (const char *) target.data;
error = git_reference_symbolic_create(&ref->ref, repo->repo, pname, ptarget, force);
error = git_reference_symbolic_create(&ref, repo->repo, pname, ptarget, force);
enif_release_binary(&target);
} else {
enif_release_binary(&target);
@@ -401,14 +410,11 @@ geef_reference_create(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
return enif_make_badarg(env);
}
git_reference_free(ref);
enif_release_binary(&name);
if (error < 0)
return geef_error(env);
term_ref = enif_make_resource(env, ref);
enif_release_resource(ref);
return enif_make_tuple2(env, atoms.ok, term_ref);
return atoms.ok;
}