GEOSGeometry*
eterm_to_geom_polygon(ErlNifEnv *env, const ERL_NIF_TERM *eterm)
{
ERL_NIF_TERM outer_eterm, inner_eterm, tail;
unsigned int rings_num, i;
GEOSCoordSequence *outer_seq, *inner_seq;
GEOSGeometry *outer_geom, *geom;
GEOSGeometry **geoms;
enif_get_list_length(env, *eterm, &rings_num);
enif_get_list_cell(env, *eterm, &outer_eterm, &inner_eterm);
outer_seq = eterm_to_geom_linestring_coords(env, &outer_eterm);
outer_geom = GEOSGeom_createLinearRing(outer_seq);
// if there are holes
geoms = malloc(sizeof(GEOSGeometry*)*rings_num-1);
for (i=0; enif_get_list_cell(env, inner_eterm, &inner_eterm, &tail); i++) {
inner_seq = eterm_to_geom_linestring_coords(env, &inner_eterm);
geoms[i] = GEOSGeom_createLinearRing(inner_seq);
inner_eterm = tail;
}
geom = GEOSGeom_createPolygon(outer_geom, geoms, rings_num-1);
free(geoms);
return geom;
}
int
compare_lists(int depth, couch_ejson_ctx_t* ctx, ERL_NIF_TERM a, ERL_NIF_TERM b)
{
ERL_NIF_TERM headA, tailA;
ERL_NIF_TERM headB, tailB;
int aIsEmpty, bIsEmpty;
int result;
while (1) {
aIsEmpty = !enif_get_list_cell(ctx->env, a, &headA, &tailA);
bIsEmpty = !enif_get_list_cell(ctx->env, b, &headB, &tailB);
if (aIsEmpty) {
if (bIsEmpty) {
return 0;
}
return -1;
}
if (bIsEmpty) {
return 1;
}
result = less_ejson(depth + 1, ctx, headA, headB);
if (ctx->error || result != 0) {
return result;
}
a = tailA;
b = tailB;
}
return result;
}
/* Currently support for 2 dimensions only */
int
set_GEOSCoordSeq_from_eterm_list(GEOSCoordSequence *seq, int pos,
ErlNifEnv *env, const ERL_NIF_TERM *coords) {
double dbl_coord;
int int_coord;
ERL_NIF_TERM head, tail;
if (enif_get_list_cell(env, *coords, &head, &tail)) {
if (enif_get_int(env, head, &int_coord)) {
dbl_coord = int_coord;
}
else if (!enif_get_double(env, head, &dbl_coord)) {
return 0;
}
GEOSCoordSeq_setX(seq, pos, dbl_coord);
enif_get_list_cell(env, tail, &head, &tail);
if (enif_get_int(env, head, &int_coord)) {
dbl_coord = int_coord;
}
else if (!enif_get_double(env, head, &dbl_coord)) {
return 0;
}
GEOSCoordSeq_setY(seq, pos, dbl_coord);
return 1;
}
return 0;
}
ERL_NIF_TERM dh_compute_key_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{/* (OthersPublicKey, MyPrivateKey, DHParams=[P,G]) */
BIGNUM *other_pub_key = NULL,
*dh_p = NULL,
*dh_g = NULL;
DH *dh_priv = DH_new();
/* Check the arguments and get
my private key (dh_priv),
the peer's public key (other_pub_key),
the parameters p & q
*/
{
BIGNUM *dummy_pub_key = NULL,
*priv_key = NULL;
ERL_NIF_TERM head, tail;
if (!get_bn_from_bin(env, argv[0], &other_pub_key)
|| !get_bn_from_bin(env, argv[1], &priv_key)
|| !enif_get_list_cell(env, argv[2], &head, &tail)
|| !get_bn_from_bin(env, head, &dh_p)
|| !enif_get_list_cell(env, tail, &head, &tail)
|| !get_bn_from_bin(env, head, &dh_g)
|| !enif_is_empty_list(env, tail)
/* Note: DH_set0_key() does not allow setting only the
* private key, although DH_compute_key() does not use the
* public key. Work around this limitation by setting
* the public key to a copy of the private key.
*/
|| !(dummy_pub_key = BN_dup(priv_key))
|| !DH_set0_key(dh_priv, dummy_pub_key, priv_key)
|| !DH_set0_pqg(dh_priv, dh_p, NULL, dh_g)
) {
if (dh_p) BN_free(dh_p);
if (dh_g) BN_free(dh_g);
if (other_pub_key) BN_free(other_pub_key);
if (dummy_pub_key) BN_free(dummy_pub_key);
if (priv_key) BN_free(priv_key);
return enif_make_badarg(env);
}
}
{
ErlNifBinary ret_bin;
int size;
enif_alloc_binary(DH_size(dh_priv), &ret_bin);
size = DH_compute_key(ret_bin.data, other_pub_key, dh_priv);
BN_free(other_pub_key);
DH_free(dh_priv);
if (size<=0) {
enif_release_binary(&ret_bin);
return atom_error;
}
if (size != ret_bin.size) enif_realloc_binary(&ret_bin, size);
return enif_make_binary(env, &ret_bin);
}
}
static int x509_parse_subject(ErlNifEnv* env, ERL_NIF_TERM subject_tuple, int *num_subject_entries, x509_subject_entry **subject_entries){
int num_subject_tuple;
unsigned num_subject_terms;
ERL_NIF_TERM head, tail;
int pair_arity;
char *name;
char *value;
char *subject_string = NULL;
const ERL_NIF_TERM* pair;
int idx;
x509_subject_entry* se;
unsigned value_len;
const ERL_NIF_TERM* subject_terms;
*subject_entries = NULL;
*num_subject_entries = 0;
/* make sure this is a tuple with first term 'subject' */
if(!enif_get_tuple(env, subject_tuple, &num_subject_tuple, &subject_terms) ||
!atom_to_string(env, subject_terms[0], &subject_string) ||
strncmp(subject_string, SUBJECT_STR, subject_strlen)) {
if(subject_string) free(subject_string);
return 0;
}
free(subject_string);
/* create room for the x509_subject_entry structs */
if(!enif_get_list_length(env, subject_terms[1], &num_subject_terms) ||
(NULL == (se = (x509_subject_entry*)malloc(num_subject_terms * sizeof(x509_subject_entry))))) return 0;
/* get the first entry and prime the pump for walking the rest */
if(!enif_get_list_cell(env, subject_terms[1], &head, &tail) ||
!enif_get_tuple(env, head, &pair_arity, &pair) ||
pair_arity!=2) { return 0; }
for(idx=0; idx<num_subject_terms; idx++){
atom_to_string(env, pair[0], &name);
enif_get_list_length(env, pair[1], &value_len);
value = (char*)malloc(value_len+1);
enif_get_string(env, pair[1], value, value_len+1, ERL_NIF_LATIN1);
(se+idx)->name = name;
(se+idx)->value = value;
if(!enif_get_list_cell(env, tail, &head, &tail) ||
!enif_get_tuple(env, head, &pair_arity, &pair) ||
pair_arity!=2) { break; }
}
*num_subject_entries = num_subject_terms;
*subject_entries = se;
return 1;
}
// convert an erlang term to a python object
// return None if the type can't be converted
static PyObject* pynerl_term_to_obj(ErlNifEnv* env, ERL_NIF_TERM term) {
int vint;
Py_ssize_t arity, i;
long int vlong;
double vdouble;
char buff[BUFF_SIZE];
PyObject* obj;
ERL_NIF_TERM list, head, tail;
const ERL_NIF_TERM *terms;
// TODO: add more types
if (enif_get_long(env, term, &vlong)) {
obj = PyLong_FromLong(vlong);
}
else if (enif_get_double(env, term, &vdouble)) {
obj = PyFloat_FromDouble(vlong);
}
else if (enif_is_empty_list(env, term)) {
obj = PyList_New(0);
}
else if (enif_get_tuple(env, term, &vint, &terms)) {
arity = vint;
obj = PyTuple_New(arity);
for (i = 0; i < arity; i++) {
PyTuple_SetItem(obj, i, pynerl_term_to_obj(env, terms[(int)i]));
}
}
else if (enif_is_identical(term, enif_make_atom(env, "true"))) {
obj = Py_True;
}
else if (enif_is_identical(term, enif_make_atom(env, "false"))) {
obj = Py_False;
}
else if (enif_get_string(env, term, buff, BUFF_SIZE, ERL_NIF_LATIN1)) {
obj = PyUnicode_FromString(buff);
}
else if (enif_get_list_cell(env, term, &head, &tail)) {
obj = PyList_New(0);
list = term;
while (enif_get_list_cell(env, list, &head, &tail)) {
PyList_Append(obj, pynerl_term_to_obj(env, head));
list = tail;
}
}
else {
obj = Py_None;
}
return obj;
}
jsval
to_js_object(ErlNifEnv* env, JSContext* cx, ERL_NIF_TERM list)
{
JSObject* ret;
jsval kval;
jsval vval;
jsid idp;
ERL_NIF_TERM head;
ERL_NIF_TERM tail;
const ERL_NIF_TERM* pair;
int arity;
ret = JS_NewObject(cx, NULL, NULL, NULL);
if(ret == NULL) return JSVAL_VOID;
if(enif_is_empty_list(env, list))
{
return OBJECT_TO_JSVAL(ret);
}
if(!enif_get_list_cell(env, list, &head, &tail))
{
return JSVAL_VOID;
}
do {
if(!enif_get_tuple(env, head, &arity, &pair))
{
return JSVAL_VOID;
}
if(arity != 2)
{
return JSVAL_VOID;
}
kval = to_js_key(env, cx, pair[0]);
if(kval == JSVAL_VOID) return JSVAL_VOID;
if(!JS_ValueToId(cx, kval, &idp)) return JSVAL_VOID;
vval = to_js(env, cx, pair[1]);
if(vval == JSVAL_VOID) return JSVAL_VOID;
if(!JS_SetPropertyById(cx, ret, idp, &vval))
{
return JSVAL_VOID;
}
} while(enif_get_list_cell(env, tail, &head, &tail));
return OBJECT_TO_JSVAL(ret);
}
void* cb_mtouch_args(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
mtouch_args_t* args = (mtouch_args_t*)enif_alloc(sizeof(mtouch_args_t));
ERL_NIF_TERM* currKey;
ERL_NIF_TERM tail;
ErlNifBinary key_binary;
if (!enif_get_list_length(env, argv[0], &args->numkeys)) goto error0;
args->keys = malloc(sizeof(char*) * args->numkeys);
args->nkeys = malloc(sizeof(size_t) * args->numkeys);
currKey = malloc(sizeof(ERL_NIF_TERM));
tail = argv[0];
int i = 0;
while(0 != enif_get_list_cell(env, tail, currKey, &tail)) {
if (!enif_inspect_iolist_as_binary(env, *currKey, &key_binary)) goto error1;
args->keys[i] = malloc(sizeof(char) * key_binary.size);
memcpy(args->keys[i], key_binary.data, key_binary.size);
args->nkeys[i] = key_binary.size;
i++;
}
args->exp = malloc(sizeof(int64_t) * args->numkeys);
tail = argv[1];
int i2 = 0;
while(0 != enif_get_list_cell(env, tail, currKey, &tail)) {
if (!enif_get_long(env, *currKey, &args->exp[i2])) goto error2;
i2++;
}
free(currKey);
return (void*)args;
int f = 0;
error2:
free(args->exp);
error1:
for(f = 0; f < i; f++) {
free(args->keys[f]);
}
free(args->keys);
free(args->nkeys);
error0:
enif_free(args);
return NULL;
}
static ERL_NIF_TERM zip(ErlNifEnv* env, ERL_NIF_TERM list)
{
ERL_NIF_TERM key, val, tmp1, tmp2;
if (enif_get_list_cell(env, list, &key, &tmp1)) {
if (enif_get_list_cell(env, tmp1, &val, &tmp2)) {
return enif_make_list_cell(env,
enif_make_tuple2(env, key, val),
zip(env, tmp2));
} else {
return enif_make_list_cell(env, key, enif_make_list(env, 0));
}
} else
return list;
}
static ERL_NIF_TERM
do_bind(ErlNifEnv *env, sqlite3 *db, sqlite3_stmt *stmt, const ERL_NIF_TERM arg)
{
int parameter_count = sqlite3_bind_parameter_count(stmt);
int i, is_list, r;
ERL_NIF_TERM list, head, tail;
unsigned int list_length;
is_list = enif_get_list_length(env, arg, &list_length);
if(!is_list)
return make_error_tuple(env, "bad_arg_list");
if(parameter_count != list_length)
return make_error_tuple(env, "args_wrong_length");
sqlite3_reset(stmt);
list = arg;
for(i=0; i < list_length; i++) {
enif_get_list_cell(env, list, &head, &tail);
r = bind_cell(env, head, stmt, i+1);
if(r == -1)
return make_error_tuple(env, "wrong_type");
if(r != SQLITE_OK)
return make_sqlite3_error_tuple(env, r, db);
list = tail;
}
return make_atom(env, "ok");
}
char *nif_arg_list_to_string(ErlNifEnv *env, ERL_NIF_TERM list, int *arg_size)
{
ERL_NIF_TERM head, tail;
char str_length[PREFIX_LEN], *args;
int i, length, character;
for(i=0; i<PREFIX_LEN; i++) {
if(enif_get_list_cell(env, list, &head, &tail)) {
if(!enif_get_int(env, head, &character)) {
return NULL;
}
str_length[i] = (char)character;
list = tail;
} else {
return NULL;
}
};
length = atoi(str_length)+1;
args = (char *)calloc(length, sizeof(char));
nif_list_to_string(env, list, args);
*arg_size = length;
return args;
};
static void do_load_info(ErlNifEnv* env, ERL_NIF_TERM load_info, int* retvalp)
{
NifModPrivData* data = priv_data(env);
ERL_NIF_TERM head, tail;
unsigned ix;
for (ix=0; ix<RT_MAX; ix++) {
data->rt_arr[ix] = NULL;
}
for (head = load_info; enif_get_list_cell(env, head, &head, &tail);
head = tail) {
const ERL_NIF_TERM* arr;
int arity;
CHECK(enif_get_tuple(env, head, &arity, &arr));
switch (arity) {
case 6:
open_resource_type(env, arr);
break;
case 2:
CHECK(arr[0] == am_return);
CHECK(enif_get_int(env, arr[1], retvalp));
break;
default:
CHECK(0);
}
}
CHECK(enif_is_empty_list(env, head));
}
int init_parser(Parser* parser, ErlNifEnv* env, ERL_NIF_TERM arg, ErlNifBinary* buffer, ERL_NIF_TERM columns) {
parser->env = env;
parser->atoms = enif_priv_data(env);
parser->raw = arg;
parser->buffer = buffer->data;
if(!enif_get_list_length(env, columns, &parser->table_width)) return 0;
ERL_NIF_TERM list, head, tail;
int val, index = 0;
parser->columns = (int *) enif_alloc(parser->table_width * sizeof(int));
list = columns;
while(enif_get_list_cell(env, list, &head, &tail)) {
if (!enif_get_int(env, head, &val)) return 0;
parser->columns[index] = val;
index++;
list = tail;
}
parser->frame_start = 0;
parser->frame_size = 0;
parser->buffer_size = buffer->size;
return 1;
}
static int make_attrs(ErlNifEnv* env, struct buf *rbuf, ERL_NIF_TERM attrs)
{
ErlNifBinary name, data;
ERL_NIF_TERM head, tail;
const ERL_NIF_TERM *tuple;
int arity, ret = 1;
while (enif_get_list_cell(env, attrs, &head, &tail)) {
if (enif_get_tuple(env, head, &arity, &tuple)) {
if (arity == 2) {
if (enif_inspect_iolist_as_binary(env, tuple[0], &name) &&
enif_inspect_iolist_as_binary(env, tuple[1], &data)) {
buf_add_char(env, rbuf, ' ');
buf_add_str(env, rbuf, (char *)name.data, name.size);
buf_add_str(env, rbuf, "='", 2);
crypt(env, rbuf, data.data, data.size);
buf_add_char(env, rbuf, '\'');
attrs = tail;
} else {
ret = 0;
break;
};
} else {
ret = 0;
break;
};
} else {
ret = 0;
break;
};
};
return ret;
}
int decode_flags(ErlNifEnv* env, ERL_NIF_TERM list, int *prot, int *flags, bool *direct, bool *lock)
{
bool l = true;
bool d = false;
int f = MAP_FILE;
int p = 0;
ERL_NIF_TERM head;
while (enif_get_list_cell(env, list, &head, &list)) {
if (enif_is_identical(head, ATOM_READ)) {
p |= PROT_READ;
} else if (enif_is_identical(head, ATOM_DIRECT)) {
d = true;
} else if (enif_is_identical(head, ATOM_LOCK)) {
l = true;
} else if (enif_is_identical(head, ATOM_NOLOCK)) {
l = false;
} else if (enif_is_identical(head, ATOM_WRITE)) {
p |= PROT_WRITE;
// } else if (enif_is_identical(head, ATOM_NONE)) {
// p |= PROT_NONE;
} else if (enif_is_identical(head, ATOM_PRIVATE)) {
f |= MAP_PRIVATE;
} else if (enif_is_identical(head, ATOM_SHARED)) {
f |= MAP_SHARED;
// } else if (enif_is_identical(head, ATOM_ANON)) {
// f |= MAP_ANON;
// } else if (enif_is_identical(head, ATOM_FILE)) {
// f |= MAP_FILE;
// } else if (enif_is_identical(head, ATOM_FIXED)) {
// f |= MAP_FIXED;
} else if (enif_is_identical(head, ATOM_NOCACHE)) {
f |= MAP_NOCACHE;
} else {
return 0;
}
}
// direct cannot be write
if (d & ((p & PROT_WRITE) != 0))
return 0;
// default to private
if ((f & (MAP_SHARED|MAP_PRIVATE)) == 0)
f |= MAP_PRIVATE;
// default to read-only
if ((p & (PROT_READ|PROT_WRITE)) == 0)
p |= PROT_READ;
*flags = f;
*prot = p;
*direct = d;
*lock = l;
return 1;
}
int get_rsa_public_key(ErlNifEnv* env, ERL_NIF_TERM key, RSA *rsa)
{
/* key=[E,N] */
ERL_NIF_TERM head, tail;
BIGNUM *e, *n;
if (!enif_get_list_cell(env, key, &head, &tail)
|| !get_bn_from_bin(env, head, &e)
|| !enif_get_list_cell(env, tail, &head, &tail)
|| !get_bn_from_bin(env, head, &n)
|| !enif_is_empty_list(env, tail)) {
return 0;
}
(void) RSA_set0_key(rsa, n, e, NULL);
return 1;
}
static ERL_NIF_TERM trace_garbage_collection(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
lttng_decl_procbuf(pid);
ERL_NIF_TERM gci, tup;
const ERL_NIF_TERM *vals;
int arity;
unsigned long ohbsz, nhbsz, size;
ASSERT(argc == 6);
/* Assume gc info order does not change */
gci = argv[3];
/* get reclaimed or need */
enif_get_list_cell(env, gci, &tup, &gci);
enif_get_tuple(env, tup, &arity, &vals);
ASSERT(arity == 2);
enif_get_ulong(env, vals[1], &size);
/* get old heap block size */
enif_get_list_cell(env, gci, &tup, &gci);
enif_get_tuple(env, tup, &arity, &vals);
ASSERT(arity == 2);
ASSERT(vals[0] == atom_old_heap_block_size);
enif_get_ulong(env, vals[1], &ohbsz);
/* get new heap block size */
enif_get_list_cell(env, gci, &tup, &gci);
enif_get_tuple(env, tup, &arity, &vals);
ASSERT(arity == 2);
ASSERT(vals[0] == atom_heap_block_size);
enif_get_ulong(env, vals[1], &nhbsz);
lttng_pid_to_str(argv[2], pid);
if (argv[0] == atom_gc_minor_start) {
LTTNG4(gc_minor_start, pid, size, nhbsz, ohbsz);
} else if (argv[0] == atom_gc_minor_end) {
LTTNG4(gc_minor_end, pid, size, nhbsz, ohbsz);
} else if (argv[0] == atom_gc_major_start) {
LTTNG4(gc_major_start, pid, size, nhbsz, ohbsz);
} else if (argv[0] == atom_gc_major_end) {
LTTNG4(gc_major_end, pid, size, nhbsz, ohbsz);
}
return atom_ok;
}
inline static ERL_NIF_TERM do_offset(ErlNifEnv* env,
UCalendar* cal,
date_fun_ptr fun,
const ERL_NIF_TERM in)
{
UCalendarDateFields field;
UErrorCode status = U_ZERO_ERROR;
ERL_NIF_TERM head, tail;
ERL_NIF_TERM* tuple;
unsigned int count, i;
int32_t len, offset;
char value[ATOM_LEN];
int parsed_value;
i = 0;
if (!enif_get_list_length(env, in, &count))
return enif_make_badarg(env);
tail = in;
while (enif_get_list_cell(env, tail, &head, &tail)) {
if (enif_get_tuple(env, head, &len, (const ERL_NIF_TERM**) &tuple)
&& (len == 2)) {
/* Set an attribute start */
if (!(enif_get_atom(env, tuple[0], (char*) value,
ATOM_LEN, ERL_NIF_LATIN1)
&& enif_get_int(env, tuple[1], &offset)))
goto bad_elem;
parsed_value = parseCalendarDateField(value);
if ((parsed_value == -1))
goto bad_elem;
field = (UCalendarDateFields) parsed_value;
fun(cal, field, offset, &status);
if (U_FAILURE(status))
goto bad_elem;
/* Set an attribute end */
} else
goto bad_elem;
}
return calendar_to_double(env, (const UCalendar*) cal);
bad_elem:
return list_element_error(env, in, i);
}
ERL_NIF_TERM date_clear(ErlNifEnv* env, int argc,
const ERL_NIF_TERM argv[])
{
UErrorCode status = U_ZERO_ERROR;
UCalendar* cal;
cloner* ptr;
double date;
UCalendarDateFields field;
ERL_NIF_TERM head, tail;
unsigned int count, i = 0;
char value[ATOM_LEN];
int parsed_value;
if(!((argc == 3)
&& enif_get_resource(env, argv[0], calendar_type, (void**) &ptr)
&& enif_get_double(env, argv[1], &date)
&& enif_get_list_length(env, argv[2], &count))) {
return enif_make_badarg(env);
}
cal = (UCalendar*) cloner_get(ptr);
CHECK_RES(env, cal);
ucal_setMillis(cal, (UDate) date, &status);
CHECK(env, status);
tail = argv[2];
while (enif_get_list_cell(env, tail, &head, &tail)) {
/* Set an attribute start */
if (!enif_get_atom(env, head, (char*) value,
ATOM_LEN, ERL_NIF_LATIN1))
goto bad_elem;
parsed_value = parseCalendarDateField(value);
if ((parsed_value == -1))
goto bad_elem;
field = (UCalendarDateFields) parsed_value;
ucal_clearField(cal, field);
if (U_FAILURE(status))
goto bad_elem;
/* Set an attribute end */
}
return calendar_to_double(env, (const UCalendar*) cal);
bad_elem:
return list_element_error(env, argv[2], i);
}
/**
* Reverse an Erlang list.
*/
ERL_NIF_TERM reverse_list(ErlNifEnv *env, ERL_NIF_TERM tail) {
ERL_NIF_TERM out = enif_make_list(env, 0);
ERL_NIF_TERM head;
while(enif_get_list_cell(env, tail, &head, &tail))
out = enif_make_list_cell(env, head, out);
return out;
}
ERL_NIF_TERM
decode_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
Decoder* d;
jiffy_st* st = (jiffy_st*) enif_priv_data(env);
ERL_NIF_TERM tmp_argv[5];
ERL_NIF_TERM opts;
ERL_NIF_TERM val;
if(argc != 2) {
return enif_make_badarg(env);
}
d = dec_new(env);
if(d == NULL) {
return make_error(st, env, "internal_error");
}
tmp_argv[0] = argv[0];
tmp_argv[1] = enif_make_resource(env, d);
tmp_argv[2] = st->atom_error;
tmp_argv[3] = enif_make_list(env, 0);
tmp_argv[4] = enif_make_list(env, 0);
enif_release_resource(d);
opts = argv[1];
if(!enif_is_list(env, opts)) {
return enif_make_badarg(env);
}
while(enif_get_list_cell(env, opts, &val, &opts)) {
if(get_bytes_per_iter(env, val, &(d->bytes_per_red))) {
continue;
} else if(get_bytes_per_red(env, val, &(d->bytes_per_red))) {
continue;
} else if(enif_compare(val, d->atoms->atom_return_maps) == 0) {
#if MAP_TYPE_PRESENT
d->return_maps = 1;
#else
return enif_make_badarg(env);
#endif
} else if(enif_compare(val, d->atoms->atom_return_trailer) == 0) {
d->return_trailer = 1;
} else if(enif_compare(val, d->atoms->atom_dedupe_keys) == 0) {
d->dedupe_keys = 1;
} else if(enif_compare(val, d->atoms->atom_use_nil) == 0) {
d->null_term = d->atoms->atom_nil;
} else if(get_null_term(env, val, &(d->null_term))) {
continue;
} else {
return enif_make_badarg(env);
}
}
return decode_iter(env, 5, tmp_argv);
}
static ERL_NIF_TERM create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
/* create(Nrows, Ncolumns, [[first row],[second row],...,[last row]]) -> Matrix */
unsigned nrows, ncols;
unsigned i, j;
ERL_NIF_TERM list, row, ret;
Matrix* mx = NULL;
if (!enif_get_uint(env, argv[0], &nrows) || nrows < 1 ||
!enif_get_uint(env, argv[1], &ncols) || ncols < 1) {
goto badarg;
}
mx = alloc_matrix(env, nrows, ncols);
list = argv[2];
for (i = 0; i<nrows; i++) {
if (!enif_get_list_cell(env, list, &row, &list)) {
goto badarg;
}
for (j = 0; j<ncols; j++) {
ERL_NIF_TERM v;
if (!enif_get_list_cell(env, row, &v, &row) ||
!get_number(env, v, &POS(mx,i,j))) {
goto badarg;
}
}
if (!enif_is_empty_list(env, row)) {
goto badarg;
}
}
if (!enif_is_empty_list(env, list)) {
goto badarg;
}
ret = enif_make_resource(env, mx);
enif_release_resource(mx);
return ret;
badarg:
if (mx != NULL) {
enif_release_resource(mx);
}
return enif_make_badarg(env);
}
static void push_nif_list(lua_State* lua, ERL_NIF_TERM list, ErlNifEnv* env, ErlNifResourceType* resource_type)
{
const int top = lua_gettop(lua);
int map_count = 0;
int array_count = 0;
if(enif_is_list(env, list))
{
ERL_NIF_TERM head;
ERL_NIF_TERM tail = list;
while(enif_get_list_cell(env, tail, &head, &tail))
{
if(push_table_iskvp(env, head, NULL))
{
++map_count;
}
else
{
++array_count;
}
}
luaL_checkstack(lua, 1, ERROR_STACK_MESSAGE);
lua_createtable(lua, array_count, map_count);
ERL_NIF_TERM array_items[array_count + map_count];
tail = list;
int index = 0;
while(enif_get_list_cell(env, tail, &head, &tail))
{
if(!push_table_set(lua, env, head, resource_type))
{
array_items[index++] = head;
}
}
push_table_append(lua, env, resource_type, array_items, index);
}
assert(lua_gettop(lua) == top+1);
}
static ERL_NIF_TERM do_write(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
static PortMidiStream ** stream;
ErlNifResourceType* streamType = (ErlNifResourceType*)enif_priv_data(env);
if(!enif_get_resource(env, argv[0], streamType, (PortMidiStream **) &stream)) {
return enif_make_badarg(env);
}
ERL_NIF_TERM erlMessages = argv[1];
const ERL_NIF_TERM * erlEvent;
const ERL_NIF_TERM * erlMessage;
ERL_NIF_TERM erlTuple;
unsigned int numOfMessages;
int tupleSize;
enif_get_list_length(env, erlMessages, &numOfMessages);
PmEvent events[numOfMessages];
long int status, note, velocity, timestamp;
for(unsigned int i = 0; i < numOfMessages; i++) {
enif_get_list_cell(env, erlMessages, &erlTuple, &erlMessages);
enif_get_tuple(env, erlTuple, &tupleSize, &erlEvent);
enif_get_tuple(env, erlEvent[0], &tupleSize, &erlMessage);
enif_get_long(env, erlMessage[0], &status);
enif_get_long(env, erlMessage[1], ¬e);
enif_get_long(env, erlMessage[2], &velocity);
enif_get_long(env, erlEvent[1], ×tamp);
PmEvent event;
event.message = Pm_Message(status, note, velocity);
event.timestamp = timestamp;
events[i] = event;
}
PmError writeError;
writeError = Pm_Write(*stream, events, numOfMessages);
if (writeError == pmNoError) {
return enif_make_atom(env, "ok");
}
const char * writeErrorMsg;
writeErrorMsg = Pm_GetErrorText(writeError);
return enif_make_tuple2(
env,
enif_make_atom(env, "error"),
enif_make_string(env, writeErrorMsg, ERL_NIF_LATIN1)
);
}
ERL_NIF_TERM
make_array(ErlNifEnv* env, ERL_NIF_TERM list)
{
ERL_NIF_TERM ret = enif_make_list(env, 0);
ERL_NIF_TERM item;
while(enif_get_list_cell(env, list, &item, &list)) {
ret = enif_make_list_cell(env, item, ret);
}
return ret;
}
static int get_engine_load_cmd_list(ErlNifEnv* env, const ERL_NIF_TERM term, char **cmds, int i)
{
ERL_NIF_TERM head, tail;
const ERL_NIF_TERM *tmp_tuple;
ErlNifBinary tmpbin;
int arity;
char *tuple1 = NULL, *tuple2 = NULL;
if (enif_is_empty_list(env, term)) {
cmds[i] = NULL;
return 0;
}
if (!enif_get_list_cell(env, term, &head, &tail))
goto err;
if (!enif_get_tuple(env, head, &arity, &tmp_tuple))
goto err;
if (arity != 2)
goto err;
if (!enif_inspect_binary(env, tmp_tuple[0], &tmpbin))
goto err;
if ((tuple1 = enif_alloc(tmpbin.size + 1)) == NULL)
goto err;
(void) memcpy(tuple1, tmpbin.data, tmpbin.size);
tuple1[tmpbin.size] = '\0';
cmds[i] = tuple1;
i++;
if (!enif_inspect_binary(env, tmp_tuple[1], &tmpbin))
goto err;
if (tmpbin.size == 0) {
cmds[i] = NULL;
} else {
if ((tuple2 = enif_alloc(tmpbin.size + 1)) == NULL)
goto err;
(void) memcpy(tuple2, tmpbin.data, tmpbin.size);
tuple2[tmpbin.size] = '\0';
cmds[i] = tuple2;
}
i++;
return get_engine_load_cmd_list(env, tail, cmds, i);
err:
if (tuple1 != NULL) {
i--;
enif_free(tuple1);
}
cmds[i] = NULL;
return -1;
}
static int do_iterator_options(ErlNifEnv* env, UCollator* col,
const ERL_NIF_TERM in, unsigned int& i) {
ERL_NIF_TERM out, list;
ERL_NIF_TERM* tuple;
unsigned int count;
UErrorCode status = U_ZERO_ERROR;
int32_t len;
char value[ATOM_LEN], key[ATOM_LEN];
int parsed_value, parsed_key;
i = 0;
if (!enif_get_list_length(env, in, &count))
return 0;
list = in;
while (enif_get_list_cell(env, list, &out, &list)) {
if (enif_get_tuple(env, out, &len, (const ERL_NIF_TERM**) &tuple)
&& (len == 2)) {
/* Set an attribute start */
if (!(enif_get_atom(env, tuple[0], (char*) key,
ATOM_LEN, ERL_NIF_LATIN1)
&& enif_get_atom(env, tuple[1], (char*) value,
ATOM_LEN, ERL_NIF_LATIN1)))
return 0;
parsed_key = parseAttrKey(key);
parsed_value = parseAttrValue(value);
if ((parsed_value == -1) || (parsed_key == -1))
return 0;
ucol_setAttribute(col,
(UColAttribute) parsed_key,
(UColAttributeValue) parsed_value,
&status);
if (U_FAILURE(status))
return 0;
/* Set an attribute end */
} else
return 0;
}
return 1;
}
ERL_NIF_TERM
encode_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
{
jiffy_st* st = (jiffy_st*) enif_priv_data(env);
Encoder* e;
ERL_NIF_TERM opts;
ERL_NIF_TERM val;
ERL_NIF_TERM tmp_argv[3];
if(argc != 2) {
return enif_make_badarg(env);
}
e = enc_new(env);
if(e == NULL) {
return make_error(st, env, "internal_error");
}
tmp_argv[0] = enif_make_resource(env, e);
tmp_argv[1] = enif_make_list(env, 1, argv[0]);
tmp_argv[2] = enif_make_list(env, 0);
enif_release_resource(e);
opts = argv[1];
if(!enif_is_list(env, opts)) {
return enif_make_badarg(env);
}
while(enif_get_list_cell(env, opts, &val, &opts)) {
if(enif_compare(val, e->atoms->atom_uescape) == 0) {
e->uescape = 1;
} else if(enif_compare(val, e->atoms->atom_pretty) == 0) {
e->pretty = 1;
} else if(enif_compare(val, e->atoms->atom_escape_forward_slashes) == 0) {
e->escape_forward_slashes = 1;
} else if(enif_compare(val, e->atoms->atom_use_nil) == 0) {
e->use_nil = 1;
} else if(enif_compare(val, e->atoms->atom_force_utf8) == 0) {
// Ignore, handled in Erlang
} else if(get_bytes_per_iter(env, val, &(e->bytes_per_red))) {
continue;
} else if(get_bytes_per_red(env, val, &(e->bytes_per_red))) {
continue;
} else {
return enif_make_badarg(env);
}
}
return encode_iter(env, 3, tmp_argv);
}
void PCudaFloatBuffer::write(ErlNifEnv *env, ERL_NIF_TERM data) {
ERL_NIF_TERM head;
double value;
long lvalue;
while (enif_get_list_cell(env, data, &head, &data)) {
if (enif_get_double(env, head, &value)) {
this->data->push_back(value);
}else if (enif_get_long(env, head, &lvalue)) {
this->data->push_back((double)lvalue);
}
}
}
static ERL_NIF_TERM eval2(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
ErlNifBinary script_binary;
if (!enif_inspect_binary(env, argv[0], &script_binary)){
return enif_make_badarg(env);
}
if (!enif_is_list(env, argv[1])) {
enif_release_binary(&script_binary);
return enif_make_badarg(env);
}
mrb_state *mrb;
mrbc_context *cxt;
mrb = mrb_open();
if (mrb == NULL) {
return enif_make_atom(env, "error");
}
unsigned int mrb_argv_len;
enif_get_list_length(env, argv[1], &mrb_argv_len);
mrb_value mrb_argv = mrb_ary_new(mrb);
ERL_NIF_TERM cur;
for(cur = argv[1]; !enif_is_empty_list(env, cur); ) {
ERL_NIF_TERM head, tail;
enif_get_list_cell(env, cur, &head, &tail);
mrb_ary_push(mrb, mrb_argv, erl2mruby(env, mrb, head));
cur = tail;
}
mrb_define_global_const(mrb, "ARGV", mrb_argv);
char *script = malloc(script_binary.size+1);
strncpy(script, (const char *)script_binary.data, (int)script_binary.size);
script[script_binary.size] = '\0';
cxt = mrbc_context_new(mrb);
struct mrb_parser_state* st = mrb_parse_string(mrb, (const char *)script, cxt);
int n = mrb_generate_code(mrb, st);
mrb_pool_close(st->pool);
mrb_value result = mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_nil_value());
ERL_NIF_TERM erl_result = mruby2erl(env, mrb, result);
free(script);
mrbc_context_free(mrb, cxt);
mrb_close(mrb);
enif_release_binary(&script_binary);
return erl_result;
}
