C++ (Cpp) enif_release_resource_compat Examples

Example #1

File: blake2_nifs.c Project: b/blake2

ERL_NIF_TERM blake2_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{   
    ERL_NIF_TERM handle_term;
    int bits = 0;
    if(!enif_get_int(env, argv[0], &bits))
        return enif_make_badarg(env);
    
    blake2_handle *handle = (blake2_handle *)enif_alloc_resource_compat(env, blake2_hashstate, sizeof(blake2_handle));
    handle->digest_length = bits / 8;

    int r = blake2b_init(&(handle->state), handle->digest_length);
    if (r == 0) {
        handle_term = enif_make_resource(env, handle);
        enif_release_resource_compat(env, handle);
        return enif_make_tuple2(env, enif_make_atom(env, "ok"), handle_term);
    } else {
        enif_release_resource_compat(env, handle);
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_atom(env, "init_failure"));
    }
}

Example #2

File: eim_nifs.cpp Project: Jasson/eim

ERL_NIF_TERM load_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
    ErlNifBinary data;
    if(enif_inspect_binary(env, argv[0], &data))
    {
        try
        {
            ihandle* handle = (ihandle*)enif_alloc_resource_compat(env, EIM_IMAGE_RESOURCE, sizeof(ihandle));
            handle->image = new eim_image(data.data, data.size);
            ERL_NIF_TERM result = enif_make_resource(env, handle);
            enif_release_resource_compat(env, handle);
            return enif_make_tuple2(env, enif_make_atom(env, "ok"), result);
        }
        catch(const char* msg)
        {
            return enif_make_atom(env, "error");
        }
    }
    else
    {
        return enif_make_badarg(env);
    }
}

Example #3

File: emmap.cpp Project: alepharchives/emmap

static ERL_NIF_TERM emmap_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
  int flags;
  int prot;
  bool direct, lock;
  unsigned long int len;
  unsigned long int offset;
  char buf[1024];

#ifndef NDEBUG
  if ( sizeof(long int) != sizeof(size_t) ) {
    abort();
  }
#endif

  if (argc == 4
      && enif_get_string(env, argv[0], buf, 1024, ERL_NIF_LATIN1)
      && enif_get_ulong(env, argv[1], &offset)
      && enif_get_ulong(env, argv[2], &len)
      && decode_flags(env, argv[3], &prot, &flags, &direct, &lock)) {

    int mode = (((prot & PROT_WRITE)==PROT_WRITE) ? O_RDWR : O_RDONLY);

    int fd = open(buf, mode);
    if (fd < 0) {
      return make_error_tuple(env, errno);
    }

    void * res = mmap(0, (size_t) len, prot, flags, fd, (size_t) offset);
    if (res == MAP_FAILED) {
      return make_error_tuple(env, errno);
    }

    close(fd);

    mhandle* handle = (mhandle*)enif_alloc_resource_compat(env, MMAP_RESOURCE,
                                                           sizeof(mhandle));

    if (lock)
      handle->rwlock = enif_rwlock_create((char*)"mmap");
    else
      handle->rwlock = 0;

    handle->prot = prot;
    handle->mem = res;
    handle->len = len;
    handle->closed = false;
    handle->direct = direct;
    handle->position = 0;

    ERL_NIF_TERM resource = enif_make_resource(env, handle);
    enif_release_resource_compat(env, handle);

    return enif_make_tuple2(env,
                            enif_make_atom(env, "ok"),
                            resource);

  } else {
      return enif_make_badarg(env);
  }
}