// query_frame/1 :: (device, frame) -> ok | error
static ERL_NIF_TERM
query_frame(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
device_t* dev;
frame_t* frame;
if (!enif_get_resource(env, argv[0], device_res, (void**) &dev) ||
!enif_get_resource(env, argv[1], frame_res, (void**) &frame)) {
return enif_make_badarg(env);
}
cvReleaseImage(&frame->_frame);
IplImage* raw_image = (IplImage*) cvQueryFrame(dev->_device);
IplImage* gray_image = cvCreateImage(cvGetSize(raw_image), IPL_DEPTH_8U, 1);
cvCvtColor(raw_image, gray_image, CV_RGB2GRAY);
frame->_frame = gray_image;
return enif_make_atom(env, "ok");
}
/**
* Remove an object from LRU-Storage
*/
static ERL_NIF_TERM leo_mcerl_nif_delete(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
lcu_cache* cache;
String key;
ErlNifResourceType* pert;
ErlNifBinary keybin;
if (argc < 2) {
return enif_make_badarg(env);
}
pert = (ErlNifResourceType*)enif_priv_data(env);
if (!enif_get_resource(env, argv[0], pert, (void**)&cache)) {
return enif_make_badarg(env);
}
if (!enif_inspect_binary(env, argv[1], &keybin)) {
return enif_make_badarg(env);
}
if (keybin.size <= 0) {
return enif_make_badarg(env);
}
key.str = keybin.data;
key.len = keybin.size;
lcu_cache_delete(cache, key);
return atom_ok;
}
/*
* Prepare the sql statement
*/
static ERL_NIF_TERM
esqlite_prepare(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
esqlite_connection *conn;
esqlite_command *cmd = NULL;
ErlNifPid pid;
if(argc != 4)
return enif_make_badarg(env);
if(!enif_get_resource(env, argv[0], esqlite_connection_type, (void **) &conn))
return enif_make_badarg(env);
if(!enif_is_ref(env, argv[1]))
return make_error_tuple(env, "invalid_ref");
if(!enif_get_local_pid(env, argv[2], &pid))
return make_error_tuple(env, "invalid_pid");
cmd = command_create();
if(!cmd)
return make_error_tuple(env, "command_create_failed");
cmd->type = cmd_prepare;
cmd->ref = enif_make_copy(cmd->env, argv[1]);
cmd->pid = pid;
cmd->arg = enif_make_copy(cmd->env, argv[3]);
return push_command(env, conn, cmd);
}
static
ERL_NIF_TERM exmagick_num_pages (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
exm_resource_t *resource;
Image* image;
int num_pages;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (resource->image == NULL)
{ EXM_FAIL(ehandler, "image not loaded"); }
image = resource->image;
num_pages = 1;
while((image = image->next))
{ ++num_pages; }
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_int(env, num_pages)));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static
ERL_NIF_TERM exmagick_image_dump_file (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
char filename[MaxTextExtent];
ErlNifBinary utf8;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (0 == exmagick_get_utf8str(env, argv[1], &utf8))
{ EXM_FAIL(ehandler, "argv[1]: bad argument"); }
exmagick_utf8strcpy (filename, &utf8, MaxTextExtent);
if (0 == WriteImages(resource->i_info, resource->image, filename, &resource->e_info))
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static ERL_NIF_TERM
nif_write(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
SRLY_STATE *sp = NULL;
ErlNifBinary buf = {0};
ssize_t n = -1;
ERL_NIF_TERM rv = atom_ok;
if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
return enif_make_badarg(env);
if (!enif_inspect_iolist_as_binary(env, argv[1], (ErlNifBinary *)&buf))
return enif_make_badarg(env);
n = write(sp->fd, buf.data, buf.size);
if (n < 0)
rv = error_tuple(env, errno);
else if (n != buf.size)
rv = enif_make_tuple2(env,
atom_ok,
enif_make_long(env, n));
return rv;
}
static ERL_NIF_TERM
nif_tcgetattr(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
SRLY_STATE *sp = NULL;
ErlNifBinary buf = {0};
int err = 0;
if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
return enif_make_badarg(env);
if (!enif_alloc_binary(sizeof(struct termios), &buf))
return error_tuple(env, ENOMEM);
if (tcgetattr(sp->fd, (struct termios *)buf.data) < 0) {
err = errno;
enif_release_binary(&buf);
return error_tuple(env, err);
}
return enif_make_tuple2(env,
atom_ok,
enif_make_binary(env, &buf));
}
ERL_NIF_TERM engine_remove_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{/* (Engine) */
#ifdef HAS_ENGINE_SUPPORT
struct engine_ctx *ctx;
// Get Engine
ASSERT(argc == 1);
if (!enif_get_resource(env, argv[0], engine_ctx_rtype, (void**)&ctx))
goto bad_arg;
if (!ENGINE_remove(ctx->engine))
goto failed;
return atom_ok;
bad_arg:
return enif_make_badarg(env);
failed:
return ERROR_Atom(env, "remove_engine_failed");
#else
return atom_notsup;
#endif
}
/*
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, FeatureDefn} = lgeo_ogr:l_get_layer_defn(Layer),
{ok, Types} = lgeo_ogr:fd_get_fields_type(FeatureDefn).
{"Integer","String"}
*/
static ERL_NIF_TERM
fd_get_fields_type(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvFeatureDefn_t **feat_defn;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if(!enif_get_resource(env, argv[0], OGR_FD_RESOURCE, (void**)&feat_defn)) {
return enif_make_badarg(env);
}
int count = OGR_FD_GetFieldCount((**feat_defn).obj);
ERL_NIF_TERM *arr = (ERL_NIF_TERM *) malloc(sizeof(ERL_NIF_TERM)*count);
int index;
for(index=0; index<count; index++)
{
OGRFieldDefnH field_defn = OGR_FD_GetFieldDefn((**feat_defn).obj, index);
arr[index] = enif_make_string(env,
OGR_GetFieldTypeName(OGR_Fld_GetType(field_defn)),
ERL_NIF_LATIN1);
}
eterm = enif_make_tuple_from_array(env, arr, index);
free(arr);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
static ERL_NIF_TERM
_listener (ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
CAN_handle* handle;
ErlNifPid pid = { 0 }; // NOTE: breaking opaque type!
enif_get_resource(env, argv[0], CAN_handle_type, (void**) &handle);
if (handle->threaded) // there is a thread already and some pid!
{
pid = handle->receiver;
}
if (!enif_get_local_pid(env, argv[1], &handle->receiver)) // NOTE: use lock if pid type is structural!
{
handle->threaded = 0;
return enif_make_badarg(env);
}
else
{
enif_get_uint(env, argv[2], &handle->chunk_size);
enif_get_long(env, argv[3], &handle->timeout);
if (!handle->threaded) // a thread was not created already
{
if (enif_thread_create("can_reading_thread",
&handle->tid,
_reading_thread,
handle, 0))
{
handle->threaded = 0;
return enif_make_int(env, -1004);
}
}
}
return pid.pid ? enif_make_pid(env, &pid) : enif_make_int(env, 0);
}
static ERL_NIF_TERM
_set_filter (ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
CAN_handle* handle;
int flags, queueid, cob, id, mask;
ERL_NIF_TERM result;
if (!enif_get_resource(env, argv[0], CAN_handle_type, (void**) &handle) ||
!enif_get_int(env, argv[1], &flags) ||
!enif_get_int(env, argv[2], &queueid) ||
!enif_get_int(env, argv[1], &cob) ||
!enif_get_int(env, argv[1], &id) ||
!enif_get_int(env, argv[1], &mask))
return enif_make_badarg(env);
else
{
canfilt_t filter = {
/*.flags = */flags,
/*.queid = */queueid,
/*.cob = */cob,
/*.id = */id,
/*.mask = */mask
};
int status = ioctl(handle->device, CANQUE_FILTER, &filter);
result = enif_make_int(env, status != 0 ? errno : status);
}
return result;
}
ERL_NIF_TERM date_get6(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
int32_t year, month, day, hour, minute, second;
if(!((argc == 7)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_int(env, argv[1], &year)
&& enif_get_int(env, argv[2], &month)
&& enif_get_int(env, argv[3], &day)
&& enif_get_int(env, argv[4], &hour)
&& enif_get_int(env, argv[5], &minute)
&& enif_get_int(env, argv[6], &second))) {
return enif_make_badarg(env);
}
month--;
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setDateTime(cal,
year,
month,
day,
hour,
minute,
second,
&status);
CHECK(env, status);
return calendar_to_double(env, (const UCalendar*) cal);
}
ERL_NIF_TERM date_get_field(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
double date;
ERL_NIF_TERM res;
if(!((argc == 3)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_double(env, argv[1], &date))) {
return enif_make_badarg(env);
}
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setMillis(cal, (UDate) date, &status);
CHECK(env, status);
res = do_date_get_field(env, cal, argv[2], status);
CHECK(env, status);
return res;
}
ERL_NIF_TERM histogram_stats(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
histogram_handle* handle;
if (enif_get_resource(env,argv[0],histogram_RESOURCE,(void**)&handle))
{
pthread_mutex_lock(&(handle->m));
std::vector<double> percentiles;
percentiles.push_back(0.500);
percentiles.push_back(0.950);
percentiles.push_back(0.990);
std::vector<double> scores(handle->p->percentiles(percentiles));
ERL_NIF_TERM result =
enif_make_list8(env,
STAT_TUPLE(ATOM_MIN, handle->p->min()),
STAT_TUPLE(ATOM_MAX, handle->p->max()),
STAT_TUPLE(ATOM_MEAN, handle->p->mean()),
STAT_TUPLE(ATOM_COUNT, handle->p->count()),
STAT_TUPLE(ATOM_STDDEV, handle->p->stddev()),
STAT_TUPLE(ATOM_P50, scores[0]),
STAT_TUPLE(ATOM_P95, scores[1]),
STAT_TUPLE(ATOM_P99, scores[2]));
pthread_mutex_unlock(&(handle->m));
return result;
}
else
return enif_make_badarg(env);
}
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);
}
}
/* OGR_G_ExportToWkb (OGRGeometryH, OGRwkbByteOrder, unsigned char *)
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, Feature} = lgeo_ogr:l_get_feature(Layer, 0),
{ok, Geometry} = lgeo_ogr:f_get_geometry_ref(Feature),
{ok, Wkb} = lgeo_ogr:g_export_to_wkb(Geometry).
*/
static ERL_NIF_TERM
g_export_to_wkb(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvGeometry_t **geom;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if (!enif_get_resource(env, argv[0], OGR_G_RESOURCE, (void**)&geom)) {
return enif_make_badarg(env);
}
int size = OGR_G_WkbSize((**geom).obj);
unsigned char *wkb = malloc(sizeof(char)*(size));
OGRErr eErr = OGR_G_ExportToWkb((**geom).obj,
(OGRwkbByteOrder)(( htonl( 1 ) == 1 ) ? 0 : 1),
wkb);
if (eErr != OGRERR_NONE) {
return enif_make_tuple2(env,
enif_make_atom(env, "error"),
enif_make_int(env, eErr));
}
ErlNifBinary bin = {.size = size, .data = wkb};
eterm = enif_make_binary(env, &bin);
OGRFree(wkb);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
ERL_NIF_TERM split(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary in;
cloner* ptr;
UBreakIterator* iter;
int len = -1, last, pos, is_valid;
UErrorCode status = U_ZERO_ERROR;
ERL_NIF_TERM head, tail;
UChar* bin;
UChar* text;
if (argc != 2)
return enif_make_badarg(env);
/* Last argument must be a binary */
if (!(enif_inspect_binary(env, argv[1], &in)
&& enif_get_resource(env, argv[0], iterator_type, (void**) &ptr))) {
return enif_make_badarg(env);
}
iter = (UBreakIterator*) cloner_get(ptr);
CHECK_RES(env, iter);
if (iter == NULL) {
return enif_make_badarg(env);
}
text = (UChar*) in.data;
ubrk_setText(iter, text, TO_ULEN(in.size), &status);
CHECK(env, status);
tail = enif_make_list(env, 0);
pos = (int) ubrk_last(iter);
while (pos) {
last = pos;
is_valid = is_valid_elem(ptr, iter);
/* get the next elem. */
pos = (int) ubrk_previous(iter);
if (pos == UBRK_DONE)
pos = 0;
if (is_valid) /* Is the old element valid? */
{
len = FROM_ULEN(last - pos);
bin = (UChar*) enif_make_new_binary(env, len, &head);
memcpy(bin,
(const char*) (text + pos),
len);
tail = enif_make_list_cell(env, head, tail);
}
};
return tail;
}
/* OGR_G_ExportToWkt(OGRGeometryH, char **)
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, Feature} = lgeo_ogr:l_get_feature(Layer, 0),
{ok, Geometry} = lgeo_ogr:f_get_geometry_ref(Feature),
{ok, Wkt} = lgeo_ogr:g_export_to_wkt(Geometry).
*/
static ERL_NIF_TERM
g_export_to_wkt(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvGeometry_t **geom;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if (!enif_get_resource(env, argv[0], OGR_G_RESOURCE, (void**)&geom)) {
return enif_make_badarg(env);
}
char *wkt = NULL;
OGRErr eErr = OGR_G_ExportToWkt((**geom).obj, &wkt);
if (eErr != OGRERR_NONE) {
return enif_make_tuple2(env,
enif_make_atom(env, "error"),
enif_make_int(env, eErr));
}
eterm = enif_make_string(env, wkt, ERL_NIF_LATIN1);
OGRFree(wkt);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
static ERL_NIF_TERM
nif_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
SRLY_STATE *sp = NULL;
unsigned long len = 0;
ErlNifBinary buf = {0};
ssize_t bufsz = 0;
if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &len))
return enif_make_badarg(env);
if (!enif_alloc_binary(len, &buf))
return error_tuple(env, ENOMEM);
if ( (bufsz = read(sp->fd, buf.data, buf.size)) < 0) {
int err = errno;
enif_release_binary(&buf);
return error_tuple(env, err);
}
if (bufsz < buf.size && !enif_realloc_binary(&buf, bufsz)) {
enif_release_binary(&buf);
return error_tuple(env, ENOMEM);
}
return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf));
}
/*
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, Feature} = lgeo_ogr:l_get_feature(Layer, 0),
{ok, Geometry} = lgeo_ogr:f_get_geometry(Feature).
*/
static ERL_NIF_TERM
f_get_geometry(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvFeature_t **feature;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if(!enif_get_resource(env, argv[0], OGR_F_RESOURCE, (void**)&feature)) {
return enif_make_badarg(env);
}
OGRGeometryH geom = OGR_F_GetGeometryRef((**feature).obj);
if(geom == NULL) {
return enif_make_atom(env, "undefined");
}
OGRGeometryH geom_clone = OGR_G_Clone(geom);
EnvGeometry_t **geometry = \
enif_alloc_resource(OGR_G_RESOURCE, sizeof(EnvGeometry_t*));
*geometry = (EnvGeometry_t*) enif_alloc(sizeof(EnvGeometry_t));
(**geometry).env = NULL;
(**geometry).obj = geom_clone;
eterm = enif_make_resource(env, geometry);
enif_release_resource(geometry);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
static ERL_NIF_TERM
nif_ioctl(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
SRLY_STATE *sp = NULL;
unsigned long req = 0;
ErlNifBinary arg = {0};
if (!enif_get_resource(env, argv[0], SRLY_STATE_RESOURCE, (void **)&sp))
return enif_make_badarg(env);
if (!enif_get_ulong(env, argv[1], &req))
return enif_make_badarg(env);
if (!enif_inspect_binary(env, argv[2], &arg))
return enif_make_badarg(env);
/* Make the binary mutable for in/out args */
if (!enif_realloc_binary(&arg, arg.size))
return error_tuple(env, ENOMEM);
if (ioctl(sp->fd, req, arg.data) < 0)
return error_tuple(env, errno);
return enif_make_tuple2(env,
atom_ok,
enif_make_binary(env, &arg));
}
/* OGRFeatureDefnH OGR_L_GetLayerDefn(OGRLayerH hLayer)
{ok, DataSource} = lgeo_ogr:open("test/polygon.shp"),
{ok, Layer} = lgeo_ogr:ds_get_layer(DataSource, 0),
{ok, FeatureDefn} = lgeo_ogr:l_get_layer_defn(Layer).
*/
static ERL_NIF_TERM
l_get_layer_defn(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
EnvLayer_t **layer;
ERL_NIF_TERM eterm;
if (argc != 1) {
return enif_make_badarg(env);
}
if(!enif_get_resource(env, argv[0], OGR_L_RESOURCE, (void**)&layer)) {
return enif_make_badarg(env);
}
OGRFeatureDefnH feat_defn = OGR_L_GetLayerDefn((**layer).obj);
EnvFeatureDefn_t **feature_defn = \
enif_alloc_resource(OGR_FD_RESOURCE, sizeof(EnvFeatureDefn_t*));
ErlNifEnv *feature_defn_env = enif_alloc_env();
*feature_defn = (EnvFeatureDefn_t*) enif_alloc(sizeof(EnvFeatureDefn_t));
(**feature_defn).env = feature_defn_env;
(**feature_defn).obj = feat_defn;
// Save copy of layer so is not garbage collected
enif_make_copy(feature_defn_env, argv[0]);
eterm = enif_make_resource(env, feature_defn);
enif_release_resource(feature_defn);
return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm);
}
static
ERL_NIF_TERM exmagick_image_load_blob (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary blob;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
if (0 == enif_inspect_binary(env, argv[1], &blob))
{ EXM_FAIL(ehandler, "argv[1]: bad argument"); }
if (resource->image != NULL)
{
DestroyImage(resource->image);
resource->image = NULL;
}
resource->image = BlobToImage(resource->i_info, blob.data, blob.size, &resource->e_info);
if (resource->image == NULL)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
return(enif_make_tuple2(env, enif_make_atom(env, "ok"), argv[0]));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
ERL_NIF_TERM pteracuda_nifs_buffer_size(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
PCudaBufferRef *ref;
if (argc != 1 || !enif_get_resource(env, argv[0], pteracuda_buffer_resource, (void **) &ref)) {
return enif_make_badarg(env);
}
return enif_make_tuple2(env, ATOM_OK, enif_make_long(env, ref->buffer->size()));
}
static
ERL_NIF_TERM exmagick_image_dump_blob (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
void *blob;
size_t size;
exm_resource_t *resource;
EXM_INIT;
ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env);
if (0 == enif_get_resource(env, argv[0], type, (void **) &resource))
{ EXM_FAIL(ehandler, "invalid handle"); }
blob = ImageToBlob(resource->i_info, resource->image, &size, &resource->e_info);
if (NULL == blob)
{
CatchException(&resource->e_info);
EXM_FAIL(ehandler, resource->e_info.reason);
}
return(enif_make_tuple2(env,
enif_make_atom(env, "ok"),
enif_make_resource_binary(env, resource, blob, size)));
ehandler:
return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg)));
}
static ERL_NIF_TERM parse(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
XML_Parser **parser;
int is_final, res, errcode;
ErlNifBinary stream;
char *errstring;
assert(argc == 3);
if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser))
return enif_make_badarg(env);
if (!enif_is_binary(env, argv[1]))
return enif_make_badarg(env);
enif_get_int(env, argv[2], &is_final);
enif_inspect_binary(env, argv[1], &stream);
expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser));
parser_data->result = enif_make_list(env, 0);
parser_data->env = env;
XML_SetUserData((XML_Parser)(*parser), parser_data);
res = XML_Parse((XML_Parser)(*parser), (const char *)stream.data, stream.size, is_final);
if(!res)
{
errcode = XML_GetErrorCode((XML_Parser)(*parser));
errstring = (char *)XML_ErrorString(errcode);
return enif_make_tuple(env, 2, ERROR,
enif_make_string(env, errstring, ERL_NIF_LATIN1));
}
return enif_make_tuple(env, 2, OK, parser_data->result);
};
/*
* Step to a prepared statement
*/
static ERL_NIF_TERM
esqlite_column_names(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
esqlite_statement *stmt;
esqlite_command *cmd = NULL;
ErlNifPid pid;
if(argc != 3)
return enif_make_badarg(env);
if(!enif_get_resource(env, argv[0], esqlite_statement_type, (void **) &stmt))
return enif_make_badarg(env);
if(!enif_is_ref(env, argv[1]))
return make_error_tuple(env, "invalid_ref");
if(!enif_get_local_pid(env, argv[2], &pid))
return make_error_tuple(env, "invalid_pid");
if(!stmt->statement)
return make_error_tuple(env, "no_prepared_statement");
cmd = command_create();
if(!cmd)
return make_error_tuple(env, "command_create_failed");
cmd->type = cmd_column_names;
cmd->ref = enif_make_copy(cmd->env, argv[1]);
cmd->pid = pid;
cmd->stmt = stmt->statement;
if(!stmt->connection)
return make_error_tuple(env, "no_connection");
if(!stmt->connection->commands)
return make_error_tuple(env, "no_command_queue");
return push_command(env, stmt->connection, cmd);
}
ERL_NIF_TERM trans(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary in;
cloner* ptr;
const Transliterator* t;
UnicodeString input;
if (argc != 2)
return enif_make_badarg(env);
/* Second argument must be a binary */
if(!(enif_inspect_binary(env, argv[1], &in)
&& enif_get_resource(env, argv[0], trans_type, (void**) &ptr))) {
return enif_make_badarg(env);
}
t = (Transliterator*) cloner_get(ptr);
CHECK_RES(env, t);
input = copy_binary_to_string(in);
t->transliterate(input);
return string_to_term(env, input);
}
/*
* Open the database
*/
static ERL_NIF_TERM
esqlite_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
esqlite_connection *db;
esqlite_command *cmd = NULL;
ErlNifPid pid;
if(argc != 4)
return enif_make_badarg(env);
if(!enif_get_resource(env, argv[0], esqlite_connection_type, (void **) &db))
return enif_make_badarg(env);
if(!enif_is_ref(env, argv[1]))
return make_error_tuple(env, "invalid_ref");
if(!enif_get_local_pid(env, argv[2], &pid))
return make_error_tuple(env, "invalid_pid");
/* Note, no check is made for the type of the argument */
cmd = command_create();
if(!cmd)
return make_error_tuple(env, "command_create_failed");
cmd->type = cmd_open;
cmd->ref = enif_make_copy(cmd->env, argv[1]);
cmd->pid = pid;
cmd->arg = enif_make_copy(cmd->env, argv[3]);
return push_command(env, db, cmd);
}
ERL_NIF_TERM ucrypto_ec_sign_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
unsigned int length;
struct ec_key_handle *handle = NULL;
ErlNifBinary data;
ErlNifBinary signature;
if (! enif_get_resource(env, argv[0], ec_key_resource, (void **)&handle))
return enif_make_badarg(env);
if (! enif_inspect_iolist_as_binary(env, argv[1], &data))
return enif_make_badarg(env);
if (! handle->key)
return enif_make_tuple2(env, ATOM_ERROR, ATOM_UNINITIALIZED_KEY);
length = ECDSA_size(handle->key);
if (! enif_alloc_binary(length, &signature))
return ATOM_ERROR;
if (! ECDSA_sign(0, data.data, data.size, signature.data, &length, handle->key))
return ATOM_ERROR;
if (! enif_realloc_binary(&signature, length))
return ATOM_ERROR;
return enif_make_binary(env, &signature);
}
