static void *start_element_handler(expat_parser *parser_data, const XML_Char *name, const XML_Char **atts) { ErlNifBinary element_name; ERL_NIF_TERM attrs_list = enif_make_list(parser_data->env, 0); int i; element_name = encode_name(parser_data, name); for(i = 0; atts[i]; i += 2); while(i) { ErlNifBinary attr_name, attr_value; enif_alloc_binary(strlen(atts[i-1]), &attr_value); strcpy((char *) attr_value.data, (const char *)atts[i-1]); attr_name = encode_name(parser_data, atts[i-2]); ERL_NIF_TERM attr = enif_make_tuple(parser_data->env, 2, enif_make_binary(parser_data->env, &attr_name), enif_make_binary(parser_data->env, &attr_value)); attrs_list = enif_make_list_cell(parser_data->env, attr, attrs_list); i -= 2; }; ERL_NIF_TERM event = enif_make_tuple(parser_data->env, 4, XML_ELEMENT_START, enif_make_binary(parser_data->env, &element_name), parser_data->xmlns, attrs_list); parser_data->result = enif_make_list_cell(parser_data->env, event, parser_data->result); parser_data->xmlns = enif_make_list(parser_data->env, 0); return NULL; };
static void *start_element_handler(expat_parser *parser_data, const XML_Char *name, const XML_Char **atts) { ERL_NIF_TERM element_name; ERL_NIF_TERM attrs_list = enif_make_list(parser_data->env, 0); int i; element_name = encode_name(parser_data, name); for(i = 0; atts[i]; i += 2); while(i) { ERL_NIF_TERM attr_name, attr_value; size_t atts_len = strlen(atts[i-1]); unsigned char *attr_data = enif_make_new_binary(parser_data->env, atts_len, &attr_value); strncpy((char*)attr_data, (const char *)atts[i-1], atts_len); attr_name = encode_name(parser_data, atts[i-2]); ERL_NIF_TERM attr = enif_make_tuple(parser_data->env, 2, attr_name, attr_value); attrs_list = enif_make_list_cell(parser_data->env, attr, attrs_list); i -= 2; }; ERL_NIF_TERM event = enif_make_tuple(parser_data->env, 4, XML_ELEMENT_START, element_name, parser_data->xmlns, attrs_list); parser_data->result = enif_make_list_cell(parser_data->env, event, parser_data->result); parser_data->xmlns = enif_make_list(parser_data->env, 0); return NULL; };
static ERL_NIF_TERM macros(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { const ERL_NIF_TERM* a; ERL_NIF_TERM lists, tuples; int arity; if (!enif_get_tuple(env, argv[0], &arity, &a) || arity != 9) { return enif_make_badarg(env); } lists = enif_make_list(env,9, enif_make_list1(env,a[0]), enif_make_list2(env,a[0],a[1]), enif_make_list3(env,a[0],a[1],a[2]), enif_make_list4(env,a[0],a[1],a[2],a[3]), enif_make_list5(env,a[0],a[1],a[2],a[3],a[4]), enif_make_list6(env,a[0],a[1],a[2],a[3],a[4],a[5]), enif_make_list7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]), enif_make_list8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]), enif_make_list9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8])); tuples = enif_make_list(env,9, enif_make_tuple1(env,a[0]), enif_make_tuple2(env,a[0],a[1]), enif_make_tuple3(env,a[0],a[1],a[2]), enif_make_tuple4(env,a[0],a[1],a[2],a[3]), enif_make_tuple5(env,a[0],a[1],a[2],a[3],a[4]), enif_make_tuple6(env,a[0],a[1],a[2],a[3],a[4],a[5]), enif_make_tuple7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]), enif_make_tuple8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]), enif_make_tuple9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8])); return enif_make_tuple2(env,lists,tuples); }
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); }
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); }
ERL_NIF_TERM enum_to_term(ErlNifEnv* env, StringEnumeration* en) { ERL_NIF_TERM head, tail; UErrorCode status = U_ZERO_ERROR; const char* buf; int32_t len; en->reset(status); CHECK(env, status); tail = enif_make_list(env, 0); while (true) { buf = en->next(&len, status); CHECK(env, status); if (buf == NULL) return tail; if (len > 255) ERROR_STRING(env, "too_long_enum_element"); head = enif_make_atom(env, buf); tail = enif_make_list_cell(env, head, tail); } }
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); };
static ERL_NIF_TERM send_list_seq(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifPid to; ERL_NIF_TERM msg; ErlNifEnv* msg_env; int i, res; if (!enif_get_int(env, argv[0], &i)) { return enif_make_badarg(env); } if (argv[1] == atom_self) { enif_self(env, &to); } else if (!enif_get_local_pid(env, argv[1], &to)) { return enif_make_badarg(env); } msg_env = enif_alloc_env(); msg = enif_make_list(msg_env,0); for ( ; i>0 ; i--) { msg = enif_make_list_cell(msg_env, enif_make_int(msg_env, i), msg); } res = enif_send(env, &to, msg_env, msg); enif_free_env(msg_env); return enif_make_tuple2(env, atom_ok, enif_make_int(env,res)); }
static ERL_NIF_TERM mem_read(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { unsigned int err, l, i, tmp; char element; int ar; char* ptr; ERL_NIF_TERM list, head, *tpl; err = enif_get_tuple(env, argv[0], &ar, (const ERL_NIF_TERM**)(&tpl)); if (err) { err = nifty_get_ptr(env, tpl[0], (ptr_t*)&ptr); } if (!err) { goto error; } err = enif_get_uint(env, argv[1], &l); if (!err) { goto error; } list = enif_make_list(env, 0); for (i=0;i<l;i++) { element = (char)*(ptr+(l-1)-i); tmp = element & 0xff; head = enif_make_uint(env, tmp); list = enif_make_list_cell(env, head, list); } return list; error: return enif_make_badarg(env); }
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; }
ERL_NIF_TERM geef_reflog_read(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { git_reflog *reflog; geef_repository *repo; ErlNifBinary bin; int error; size_t count, i; ERL_NIF_TERM list; 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)) return geef_oom(env); if ((error = git_reflog_read(&reflog, repo->repo, (char *)bin.data)) < 0) return geef_error(env); count = git_reflog_entrycount(reflog); list = enif_make_list(env, 0); for (i = count; i > 0; i--) { ErlNifBinary id_old, id_new, message; ERL_NIF_TERM tentry, name, email, time, offset; const git_reflog_entry *entry; entry = git_reflog_entry_byindex(reflog, i-1); if (geef_oid_bin(&id_old, git_reflog_entry_id_old(entry))) goto on_oom; if (geef_oid_bin(&id_new, git_reflog_entry_id_new(entry))) goto on_oom; if (geef_signature_to_erl(&name, &email, &time, &offset, env, git_reflog_entry_committer(entry))) goto on_oom; if (geef_string_to_bin(&message, git_reflog_entry_message(entry))) goto on_oom; tentry = enif_make_tuple7(env, name, email, time, offset, enif_make_binary(env, &id_old), enif_make_binary(env, &id_new), enif_make_binary(env, &message)); list = enif_make_list_cell(env, tentry, list); } git_reflog_free(reflog); return enif_make_tuple2(env, atoms.ok, list); on_oom: git_reflog_free(reflog); return geef_oom(env); }
static ERL_NIF_TERM test_list_element_error(ErlNifEnv* env, int /*argc*/, const ERL_NIF_TERM /*argv*/[]) { ERL_NIF_TERM list; list = enif_make_list(env, 0); ERROR_ELEMENT(env, U_INTERNAL_PROGRAM_ERROR, list, 1); }
static ERL_NIF_TERM test_list_element_error(ErlNifEnv* env, int /*argc*/, const ERL_NIF_TERM /*argv*/[]) { ERL_NIF_TERM list; list = enif_make_list(env, 0); return list_element_error(env, list, 1); }
ERL_NIF_TERM x_cluster_stat(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { const char * func_name = "x_cluster_stat()"; uint64_t id; if (!enif_get_uint64(env, argv[0], &id)) { logger.error(MOD_NAME, func_name, "enif get params failed"); return enif_make_badarg(env); } logger.debug(MOD_NAME, func_name, "cluster : %ld", id); rados_t cluster = map_cluster_get(id); if (cluster == NULL) { logger.error(MOD_NAME, func_name, "cluster non-existing : %ld", id); return enif_make_badarg(env); } rados_cluster_stat_t stat; int err = rados_cluster_stat(cluster, &stat); if (err < 0) { logger.error(MOD_NAME, func_name, "failed to get stat for %ld: %s", id, strerror(-err)); return make_error_tuple(env, -err); } ERL_NIF_TERM term_list = enif_make_list(env, 0); ERL_NIF_TERM t = enif_make_uint64(env, stat.num_objects); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "num_objects"), t), term_list); t = enif_make_uint64(env, stat.kb_avail); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "kb_avail"), t), term_list); t = enif_make_uint64(env, stat.kb_used); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "kb_used"), t), term_list); t = enif_make_uint64(env, stat.kb); term_list = enif_make_list_cell(env, enif_make_tuple2(env, enif_make_atom(env, "kb"), t), term_list); return enif_make_tuple2(env, enif_make_atom(env, "ok"), term_list); }
static ERL_NIF_TERM i18n_info(ErlNifEnv* env, int /*argc*/, const ERL_NIF_TERM /*argv*/[]) { #if I18N_INFO ERL_NIF_TERM head, tail; tail = enif_make_list(env, 0); #if I18N_SEARCH head = enif_make_tuple2(env, ATOM_SEARCH, i18n_search_info(env)); tail = enif_make_list_cell(env, head, tail); #endif return tail; #else return enif_make_list(env, 0); #endif }
/** * 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; }
static ERL_NIF_TERM reset_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { XML_Parser **parser; assert(argc == 1); if (!enif_get_resource(env, argv[0], PARSER_POINTER, (void **)&parser)) return enif_make_badarg(env); expat_parser *parser_data = XML_GetUserData((XML_Parser)(*parser)); parser_data->result = enif_make_list(env, 0); parser_data->xmlns = enif_make_list(env, 0); parser_data->env = env; assert(XML_TRUE == XML_ParserReset((XML_Parser)(*parser), "UTF-8")); init_parser((XML_Parser)(*parser), parser_data); return OK; };
ERL_NIF_TERM make_empty_object(ErlNifEnv* env, int ret_map) { #if MAP_TYPE_PRESENT if(ret_map) { return enif_make_new_map(env); } #endif return enif_make_tuple1(env, enif_make_list(env, 0)); }
ERL_NIF_TERM PCudaFloatBuffer::toErlTerms(ErlNifEnv *env) { std::vector<double>::iterator iter; ERL_NIF_TERM retval = enif_make_list(env, 0); if (this->data->size() > 0) { for (iter = this->data->end(); iter != this->data->begin();) { --iter; retval = enif_make_list_cell(env, enif_make_double(env, *iter), retval); } } return retval; }
static ERL_NIF_TERM dirty_heap_access_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM res = enif_make_list(env, 0); int i; assert(ERL_NIF_THR_DIRTY_CPU_SCHEDULER == enif_thread_type() || ERL_NIF_THR_DIRTY_IO_SCHEDULER == enif_thread_type()); for (i = 0; i < 1000; i++) res = enif_make_list_cell(env, enif_make_copy(env, argv[0]), res); return res; }
posix_errno_t efile_list_dir(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result) { ERL_NIF_TERM list_head; WIN32_FIND_DATAW data; HANDLE search_handle; WCHAR *search_path; DWORD last_error; ASSERT_PATH_FORMAT(path); search_path = enif_alloc(path->size + 2 * sizeof(WCHAR)); if(search_path == NULL) { return ENOMEM; } sys_memcpy(search_path, path->data, path->size); search_path[PATH_LENGTH(path) + 0] = L'\\'; search_path[PATH_LENGTH(path) + 1] = L'*'; search_path[PATH_LENGTH(path) + 2] = L'\0'; search_handle = FindFirstFileW(search_path, &data); last_error = GetLastError(); enif_free(search_path); if(search_handle == INVALID_HANDLE_VALUE) { return windows_to_posix_errno(last_error); } list_head = enif_make_list(env, 0); do { int name_length = wcslen(data.cFileName); if(!is_ignored_name(name_length, data.cFileName)) { unsigned char *name_bytes; ERL_NIF_TERM name_term; size_t name_size; name_size = name_length * sizeof(WCHAR); name_bytes = enif_make_new_binary(env, name_size, &name_term); sys_memcpy(name_bytes, data.cFileName, name_size); list_head = enif_make_list_cell(env, name_term, list_head); } } while(FindNextFileW(search_handle, &data)); FindClose(search_handle); (*result) = list_head; return 0; }
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 ERL_NIF_TERM run(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { struct regexp *rp = NULL; struct regexp r; ErlNifBinary strbin; ERL_NIF_TERM ret; if (!enif_get_resource(env, argv[1], regexp_type, (void **)&rp)) { ErlNifBinary patternbin; if (enif_inspect_iolist_as_binary(env, argv[1], &patternbin)) { char patternstr[patternbin.size + 1]; xmlRegexpPtr xre; patternstr[patternbin.size] = 0; memcpy(patternstr, patternbin.data, patternbin.size); if ((xre = xmlRegexpCompile((xmlChar *)patternstr)) != NULL) { r.xre = xre; r.string = NULL; rp = &r; } else { return last_error(env, "Bad Pattern"); } } else { return enif_make_badarg(env); } } if (enif_inspect_iolist_as_binary(env, argv[0], &strbin)) { char string[strbin.size + 1]; string[strbin.size] = 0; memcpy(string, strbin.data, strbin.size); switch (xmlRegexpExec(rp->xre, (xmlChar *)string)) { case 1: /* FIXME NYI */ ret = enif_make_tuple2(env, am_match(env), enif_make_list(env, 0)); break; case 0: ret = am_nomatch(env); break; default: ret = last_error(env, NULL); } } else { ret = enif_make_badarg(env); } if (rp == &r) { xmlRegFreeRegexp(r.xre); } return ret; }
ERL_NIF_TERM finish(ErlNifEnv *env, ERL_NIF_TERM *path, ERL_NIF_TERM *step, int length) { int i; ERL_NIF_TERM list = enif_make_list(env, 0); for (i = length - 1; i >= 0; i--) { list = enif_make_list_cell(env, path[i], list); } free(step); free(path); return list; }
static ERL_NIF_TERM to_term(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { /* to_term(Matrix) -> [[first row], [second row], ...,[last row]] */ unsigned i, j; ERL_NIF_TERM res; mx_t mx; mx.p = NULL; if (!enif_get_resource(env, argv[0], resource_type, &mx.vp)) { return enif_make_badarg(env); } res = enif_make_list(env, 0); for (i = mx.p->nrows; i-- > 0; ) { ERL_NIF_TERM row = enif_make_list(env, 0); for (j = mx.p->ncols; j-- > 0; ) { row = enif_make_list_cell(env, enif_make_double(env, POS(mx.p,i,j)), row); } res = enif_make_list_cell(env, row, res); } return res; }
ERL_NIF_TERM vert_virNodeListDevices(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { VERT_RESOURCE *vp = NULL; ErlNifBinary cap = {0}; char **names = NULL; int maxnames = 0; u_int32_t flags = 0; int n = 0; int rv = 0; ERL_NIF_TERM dev = {0}; VERT_GET_RESOURCE(0, vp, VERT_RES_CONNECT); VERT_GET_IOLIST(1, cap); VERT_GET_INT(2, maxnames); VERT_GET_UINT(3, flags); if (cap.size > 0) VERT_BIN_APPEND_NULL(cap); names = calloc(maxnames, sizeof(char *)); if (names == NULL) return error_tuple(env, atom_enomem); rv = virNodeListDevices(vp->res, (cap.size == 0 ? NULL : (char *)cap.data), names, maxnames, flags); if (rv < 0) goto ERR; dev = enif_make_list(env, 0); for (n = 0; n < rv; n++) { dev = enif_make_list_cell(env, enif_make_string(env, names[n], ERL_NIF_LATIN1), dev); } free(names); return enif_make_tuple2(env, atom_ok, dev); ERR: free(names); return verterr(env); }
static ERL_NIF_TERM pull_term(struct make_term_info* mti) { unsigned ix; if (mti->reuse_pull >= mti->reuse_push && mti->reuse_push < MAKE_TERM_REUSE_LEN) { mti->reuse_pull = 0; if (mti->reuse_push == 0) { mti->reuse[0] = enif_make_list(mti->dst_env, 0); } } ix = (mti->reuse_pull++) % MAKE_TERM_REUSE_LEN; //enif_fprintf(stderr, "pull from %u: %T\r\n", ix, mti->reuse[ix]); return mti->reuse[ix]; }
static ERL_NIF_TERM alloc_msgenv(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { PrivData* priv = (PrivData*) enif_priv_data(env); struct make_term_info* mti; ERL_NIF_TERM ret; mti = (struct make_term_info*) enif_alloc_resource(msgenv_resource_type, sizeof(*mti)); mti->caller_env = NULL; mti->dst_env = enif_alloc_env(); mti->reuse_push = 0; mti->reuse_pull = 0; mti->resource_type = priv->rt_arr[0].t; mti->other_term = enif_make_list(mti->dst_env, 0); mti->blob = enif_make_list(mti->dst_env, 0); mti->mtx = enif_mutex_create("nif_SUITE:mtx"); mti->cond = enif_cond_create("nif_SUITE:cond"); mti->send_res = 0xcafebabe; mti->n = 0; ret = enif_make_resource(env, mti); enif_release_resource(mti); return ret; }
static ERL_NIF_TERM list_seq(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM list; int n; if (!enif_get_int(env, argv[0], &n)) { return enif_make_badarg(env); } list = enif_make_list(env, 0); /* NIL */ while (n > 0) { list = enif_make_list_cell(env, enif_make_int(env,n), list); n--; } return list; }
static ERL_NIF_TERM tuple_2_list(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int arity = -1; const ERL_NIF_TERM* ptr; ERL_NIF_TERM list = enif_make_list(env,0); if (argc!=1 || !enif_get_tuple(env,argv[0],&arity,&ptr)) { return enif_make_badarg(env); } while (--arity >= 0) { list = enif_make_list_cell(env,ptr[arity],list); } return list; }