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_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_iter))) { continue; } else { return enif_make_badarg(env); } } return encode_iter(env, 3, tmp_argv); }
ERL_NIF_TERM nif_thread_cast(ErlNifEnv* env, void (*f)(nif_thread_arg*), int a, ...) { va_list ap; int i; nif_thread_arg* args = (nif_thread_arg*)enif_alloc(a * sizeof(nif_thread_arg)); va_start(ap, a); for (i = 0; i < a; i++) args[i] = va_arg(ap, void*); va_end(ap); nif_thread_message* msg = nif_thread_message_alloc(f, args, NULL); return nif_thread_send((nif_thread_state*)enif_priv_data(env), msg); }
static ERL_NIF_TERM nif_scheduler_join(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { state_ptr state = (state_ptr) enif_priv_data(env); if(state->initilised == 0 ) { return enif_make_tuple2(env, enif_make_atom(env, "state_error"), enif_make_atom(env, "scheduler_not_inited")); } SchedulerDriverStatus status = scheduler_join( state->scheduler_state ); return get_return_value_from_status(env, status); }
static ERL_NIF_TERM nif_scheduler_reconcileTasks(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { unsigned int length ; state_ptr state = (state_ptr) enif_priv_data(env); if(state->initilised == 0 ) { return enif_make_tuple2(env, enif_make_atom(env, "state_error"), enif_make_atom(env, "scheduler_not_inited")); } if(!enif_is_list(env, argv[0])) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "task_status_array")); }; if(!enif_get_list_length(env, argv[0], &length)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "task_status_array")); } ErlNifBinary binary_arr[length]; if(!inspect_array_of_binary_objects(env, argv[0], &binary_arr )) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "task_status_array")); } BinaryNifArray binaryNifArrayHolder ; binaryNifArrayHolder.length = length; binaryNifArrayHolder.obj = &binary_arr[0]; SchedulerDriverStatus status = scheduler_reconcileTasks( state->scheduler_state, &binaryNifArrayHolder); return get_return_value_from_status(env, status); }
/** * Stop */ static ERL_NIF_TERM leo_mcerl_nif_stop(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { lcu_cache* cache; ErlNifResourceType* pert; if (argc < 1) { 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); } lcu_cache_destroy(cache); return atom_ok; }
ERL_NIF_TERM nif_thread_call(ErlNifEnv* env, ERL_NIF_TERM (*f)(ErlNifEnv*, nif_thread_arg*), int a, ...) { va_list ap; int i; nif_thread_arg* args = (nif_thread_arg*)enif_alloc(a * sizeof(nif_thread_arg)); va_start(ap, a); for (i = 0; i < a; i++) args[i] = va_arg(ap, void*); va_end(ap); ErlNifPid* pid = (ErlNifPid*)enif_alloc(sizeof(ErlNifPid)); nif_thread_message* msg = nif_thread_message_alloc((void*)f, args, enif_self(env, pid)); return nif_thread_send((nif_thread_state*)enif_priv_data(env), msg); }
static ERL_NIF_TERM mutate_solution(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ // struct timespec start, end; // long diff; // clock_gettime(CLOCK_MONOTONIC, &start); ERL_NIF_TERM term; ErlNifResourceType* sol_type; Solution *sol, *mut_sol; // unsigned int i; double range, rate; CHECK(env, argc == 3) sol_type = (ErlNifResourceType*) enif_priv_data(env); CHECK(env, sol_type) CHECK(env, enif_get_resource(env, argv[0], sol_type, (void**) &sol)) CHECK(env, enif_get_double(env, argv[1], &range)) CHECK(env, enif_get_double(env, argv[2], &rate)) mut_sol = (Solution*) enif_alloc_resource(sol_type, sizeof(Solution)); CHECK(env, mut_sol) term = enif_make_resource(env, mut_sol); CHECK(env,term) enif_release_resource(mut_sol); mut_sol->len = sol->len; mut_sol->genotype = (double*) malloc(sizeof(double)*sol->len); mutate(sol, mut_sol, range, rate); #ifdef DEBUG print_solution(sol, "Genotype"); print_solution(mut_sol, "MutatedGenotype"); #endif // clock_gettime(CLOCK_MONOTONIC, &end); // diff = CLOCKS_PER_SEC * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec; // printf("mut=%llu\n", (long long unsigned int) diff); return term; }
/** * Retrieve total of objects */ static ERL_NIF_TERM leo_mcerl_nif_items(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { lcu_cache* cache; ErlNifResourceType* pert; ErlNifUInt64 len; if (argc < 1) { 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); } len = (ErlNifUInt64)lcu_cache_item_size(cache); return enif_make_tuple2(env, atom_ok, enif_make_uint64(env, len)); }
static ERL_NIF_TERM get(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { PRIVDATA *data = NULL; int k = 0; int nelem = 0; data = (PRIVDATA *)enif_priv_data(env); nelem = NELEM(data); if (!enif_get_int(env, argv[0], &k)) return enif_make_badarg(env); if ( (k < 0) || (k >= nelem)) return error_tuple(env, "out_of_bounds"); return enif_make_int(env, VAL(data, k)); }
static ERL_NIF_TERM exmagick_crop (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { Image* cropped_image; RectangleInfo rect; 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 (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } /* build rectangle */ if (0 == enif_get_long(env, argv[1], &rect.x)) { EXM_FAIL(ehandler, "x0: bad argument"); } if (0 == enif_get_long(env, argv[2], &rect.y)) { EXM_FAIL(ehandler, "y0: bad argument"); } if (0 == enif_get_ulong(env, argv[3], &rect.width)) { EXM_FAIL(ehandler, "width: bad argument"); } if (0 == enif_get_ulong(env, argv[4], &rect.height)) { EXM_FAIL(ehandler, "height: bad argument"); } /* actually crops image */ cropped_image = CropImage(resource->image, &rect, &resource->e_info); if (cropped_image == NULL) { CatchException(&resource->e_info); EXM_FAIL(ehandler, resource->e_info.reason); } DestroyImage(resource->image); resource->image = cropped_image; 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_scheduler_sendFrameworkMessage(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ ErlNifBinary executorId_binary; ErlNifBinary slaveId_binary; char data[MAXBUFLEN]; state_ptr state = (state_ptr) enif_priv_data(env); if(state->initilised == 0 ) { return enif_make_tuple2(env, enif_make_atom(env, "state_error"), enif_make_atom(env, "scheduler_not_inited")); } if (!enif_inspect_binary(env, argv[0], &executorId_binary)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "executor_id")); } if (!enif_inspect_binary(env, argv[1], &slaveId_binary)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "slave_id")); } //REVIEW : buffer length if(!enif_get_string(env, argv[2], data , MAXBUFLEN, ERL_NIF_LATIN1 )) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "data")); } SchedulerDriverStatus status = scheduler_sendFrameworkMessage( state->scheduler_state , &executorId_binary, &slaveId_binary, data); return get_return_value_from_status(env, status); }
ERL_NIF_TERM exmagick_get_attr (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { char atom[EXM_MAX_ATOM_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"); } if (0 == enif_get_atom(env, argv[1], atom, EXM_MAX_ATOM_SIZE, ERL_NIF_LATIN1)) { EXM_FAIL(ehandler, "invalid attribute"); } if (strcmp("adjoin", atom) == 0) { if (resource->i_info->adjoin == 0) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "false"))); } else if (resource->i_info->adjoin == 1) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_atom(env, "true"))); } } if (strcmp("rows", atom) == 0) { if (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_long(env, resource->image->rows))); } } if (strcmp("columns", atom) == 0) { if (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_long(env, resource->image->columns))); } } if (strcmp("density", atom) == 0) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), exmagick_make_utf8str(env, resource->i_info->density))); } else if (strcmp("magick", atom) == 0) { return(enif_make_tuple2(env, enif_make_atom(env, "ok"), exmagick_make_utf8str(env, resource->image->magick))); } ehandler: return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg))); }
// c_soc:op_alloc(ParentKey, Tuple, Arity) => ok static ERL_NIF_TERM op_alloc(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { soc::State* st = (soc::State*) enif_priv_data(env); int parentKey; int parentKeyInt; ERL_NIF_TERM* tuple; ERL_NIF_TERM* tupleInt; int tupleArity; int tupleArityInt; int arity; int arityInt; if (enif_get_int(env, argv[0], &parentKey) == 0) { printf("[op_alloc] error: failed to get parentKey\n"); return -1; } parentKeyInt = enif_make_copy(st->GetEnv(), parentKey); if (enif_get_tuple(env, argv[1], &tupleArity, &tuple) == 0) { printf("[op_alloc] error: failed to get tuple\n"); return -1; } (*tupleInt) = enif_make_copy(st->GetEnv(), (*tuple)); tupleArityInt = enif_make_copy(st->GetEnv(), tupleArity); if (enif_get_int(env, argv[2], &arity) == 0) { printf("[op_alloc] error: failed to initialize arity\n"); return -1; } arityInt = enif_make_copy(st->GetEnv(), arity); printf("operation start\n"); soc::Operation* op = new soc::Operation(parentKeyInt, tupleInt, tupleArityInt, arityInt); int currentIndex = st->Insert(op); int currentIndexExt = enif_make_copy(env, currentIndex); printf("operation index: %d end\n", currentIndexExt); return enif_make_int(env, currentIndexExt); }
int enc_init(Encoder* e, ErlNifEnv* env, ERL_NIF_TERM opts, ErlNifBinary* bin) { ERL_NIF_TERM val; e->env = env; e->atoms = enif_priv_data(env); e->uescape = 0; e->pretty = 0; e->shiftcnt = 0; e->count = 0; if(!enif_is_list(env, opts)) { return 0; } 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_force_utf8) == 0) { // Ignore, handled in Erlang } else { return 0; } } e->iolen = 0; e->iolist = enif_make_list(env, 0); e->curr = bin; if(!enif_alloc_binary(BIN_INC_SIZE, e->curr)) { return 0; } memset(e->curr->data, 0, e->curr->size); e->p = (char*) e->curr->data; e->u = (unsigned char*) e->curr->data; e->i = 0; return 1; }
static ERL_NIF_TERM exmagick_set_attr (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary utf8; char atom[EXM_MAX_ATOM_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"); } if (0 == enif_get_atom(env, argv[1], atom, EXM_MAX_ATOM_SIZE, ERL_NIF_LATIN1)) { EXM_FAIL(ehandler, "argv[1]: bad argument"); } if (strcmp("adjoin", atom) == 0) { if (0 == exmagick_get_boolean_u(env, argv[2], &resource->i_info->adjoin)) { EXM_FAIL(ehandler, "argv[2]: bad argument"); } } if (strcmp("magick", atom) == 0) { if (0 == exmagick_get_utf8str(env, argv[2], &utf8)) { EXM_FAIL(ehandler, "argv[2]: bad argument"); } exmagick_utf8strcpy(resource->image->magick, &utf8, MaxTextExtent); } if (strcmp("density", atom) == 0) { if (0 == exmagick_get_utf8str(env, argv[2], &utf8)) { EXM_FAIL(ehandler, "argv[2]: bad argument"); } MagickFree(resource->i_info->density); resource->i_info->density=exmagick_utf8strdup(&utf8); if (resource->i_info->density == NULL) { EXM_FAIL(ehandler, "could not set density"); } } 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 make_blob(ErlNifEnv* caller_env, ErlNifEnv* dst_env, ERL_NIF_TERM other_term) { PrivData* priv = (PrivData*) enif_priv_data(caller_env); ERL_NIF_TERM term, list; int n = 0; struct make_term_info mti; mti.caller_env = caller_env; mti.dst_env = dst_env; mti.reuse_push = 0; mti.reuse_pull = 0; mti.resource_type = priv->rt_arr[0].t; mti.other_term = other_term; list = enif_make_list(dst_env, 0); while (make_term_n(&mti, n++, &term)) { list = enif_make_list_cell(dst_env, term, list); } return list; }
/** * Retrieve an object from LRU-Storage */ static ERL_NIF_TERM leo_mcerl_nif_get(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { lcu_cache* cache; String key; String val; ErlNifResourceType* pert; ErlNifBinary keybin; ErlNifBinary bin; 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_get(cache, key, &val); if (val.str == NULL) { return atom_not_found; } if (!enif_alloc_binary(val.len, &bin)) { return enif_make_badarg(env); } memcpy(bin.data, val.str, val.len); return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &bin)); }
static ERL_NIF_TERM nif_scheduler_stop(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int failover; state_ptr state = (state_ptr) enif_priv_data(env); if(state->initilised == 0 ) { return enif_make_tuple2(env, enif_make_atom(env, "state_error"), enif_make_atom(env, "sheduler_not_inited")); } if(!enif_get_int( env, argv[0], &failover)) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "failover")); } if(failover < 0 || failover > 1) { return enif_make_tuple3(env, enif_make_atom(env, "argument_error"), enif_make_atom(env, "invalid_or_corrupted_parameter"), enif_make_atom(env, "failover")); } SchedulerDriverStatus status = scheduler_stop( state->scheduler_state, failover ); if(status == 4){ // driver_stopped return enif_make_tuple2(env, enif_make_atom(env, "ok"), get_atom_from_status(env, status)); }else{ return enif_make_tuple2(env, enif_make_atom(env, "error"), get_atom_from_status(env, status)); } }
/* 1: password, 2: dictpath */ static ERL_NIF_TERM nif_check(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { PRIV *priv = NULL; ErlNifBinary passwd; ErlNifBinary path; char *err = NULL; priv = (PRIV *)enif_priv_data(env); if (!enif_inspect_iolist_as_binary(env, argv[0], &passwd)) return enif_make_badarg(env); if (!enif_inspect_iolist_as_binary(env, argv[1], &path)) return enif_make_badarg(env); /* NULL terminate strings */ if (!enif_realloc_binary(&passwd, passwd.size+1)) return atom_enomem; if (!enif_realloc_binary(&path, path.size+1)) return atom_enomem; /* passwd.size is now equal to old passwd.size+1 */ passwd.data[passwd.size-1] = '\0'; path.data[path.size-1] = '\0'; enif_mutex_lock(priv->lock); err = (char *)FascistCheck((char *)passwd.data, (char *)path.data); enif_mutex_unlock(priv->lock); (void)memset(passwd.data, '\0', passwd.size); enif_release_binary(&passwd); enif_release_binary(&path); return ( (err == NULL) ? atom_ok : error_tuple(env, err)); }
static ERL_NIF_TERM create_solution(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ // struct timespec start, end; // long diff; // clock_gettime(CLOCK_MONOTONIC, &start); ERL_NIF_TERM term; ErlNifResourceType* sol_type; Solution* sol; unsigned int len; unsigned int i; CHECK(env, argc == 1) CHECK(env, enif_get_uint(env, argv[0], &len)) sol_type = (ErlNifResourceType*) enif_priv_data(env); CHECK(env, sol_type) sol = (Solution*) enif_alloc_resource(sol_type, sizeof(Solution)); CHECK(env, sol) term = enif_make_resource(env, sol); CHECK(env,term) enif_release_resource(sol); sol->len = len; sol->genotype = (double*) malloc(sizeof(double)*len); for (i=0;i<len;i++){ sol->genotype[i] = randdouble(-50.0, 50.0); } // clock_gettime(CLOCK_MONOTONIC, &end); // diff = CLOCKS_PER_SEC * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec; // printf("create=%llu\n", (long long unsigned int) diff); return term; }
Decoder* dec_new(ErlNifEnv* env) { jiffy_st* st = (jiffy_st*) enif_priv_data(env); Decoder* d = enif_alloc_resource(st->res_dec, sizeof(Decoder)); int i; if(d == NULL) { return NULL; } d->atoms = st; d->bytes_per_red = DEFAULT_BYTES_PER_REDUCTION; d->is_partial = 0; d->return_maps = 0; d->return_trailer = 0; d->dedupe_keys = 0; d->null_term = d->atoms->atom_null; d->p = NULL; d->u = NULL; d->len = -1; d->i = -1; d->st_data = (char*) enif_alloc(STACK_SIZE_INC * sizeof(char)); d->st_size = STACK_SIZE_INC; d->st_top = 0; for(i = 0; i < d->st_size; i++) { d->st_data[i] = st_invalid; } d->st_data[0] = st_value; d->st_top++; return d; }
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; }
/** * Initialize */ static ERL_NIF_TERM leo_mcerl_nif_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifUInt64 max_size; ERL_NIF_TERM term; ErlNifResourceType* pert; lcu_cache* cache; if (argc < 1) { return enif_make_badarg(env); } if (!enif_get_uint64(env, argv[0], &max_size)) { return enif_make_badarg(env); } pert = (ErlNifResourceType*)enif_priv_data(env); cache = enif_alloc_resource(pert, sizeof(lcu_cache)); lcu_cache_init(cache, auto_eject_on, max_size, 2, 256, 1024 * 1024 * 8); term = enif_make_resource(env, cache); enif_release_resource(cache); return enif_make_tuple2(env, atom_ok, term); }
static ERL_NIF_TERM do_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { char deviceName[MAXBUFLEN]; long latency; ERL_NIF_TERM streamTerm; PortMidiStream **streamAlloc; PmError result; ErlNifResourceType* streamType = (ErlNifResourceType*)enif_priv_data(env); streamAlloc = (PortMidiStream**)enif_alloc_resource(streamType, sizeof(PortMidiStream*)); enif_get_string(env, argv[0], deviceName, MAXBUFLEN, ERL_NIF_LATIN1); enif_get_long(env, argv[1], &latency); if((result = findDevice(streamAlloc, deviceName, OUTPUT, latency)) != pmNoError) { ERL_NIF_TERM reason = enif_make_atom(env, makePmErrorAtom(result)); return enif_make_tuple2(env, enif_make_atom(env, "error"), reason); } streamTerm = enif_make_resource(env, streamAlloc); enif_keep_resource(streamAlloc); return enif_make_tuple2(env, enif_make_atom(env, "ok"), streamTerm); }
ERL_NIF_TERM less_json_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { couch_ejson_ctx_t ctx; int result; ErlNifBinary key1Bin, key2Bin; char *keys; if (!enif_inspect_iolist_as_binary(env, argv[0], &key1Bin)) { return enif_make_badarg(env); } if (!enif_inspect_iolist_as_binary(env, argv[1], &key2Bin)) { return enif_make_badarg(env); } keys = (char *) enif_alloc(key1Bin.size + key2Bin.size + 2); if (keys == NULL) { return enif_make_tuple2(env, ATOM_ERROR, enif_make_atom(env, "Failed to allocate memory")); } memcpy(keys, key1Bin.data, key1Bin.size); keys[key1Bin.size] = '\0'; memcpy(keys + key1Bin.size + 1, key2Bin.data, key2Bin.size); keys[key1Bin.size + 1 + key2Bin.size] = '\0'; ctx.env = env; ctx.error = 0; ctx.errorMsg = NULL; ctx.coll = NULL; ctx.globalCtx = (couch_ejson_global_ctx_t *) enif_priv_data(env); result = less_json(keys, keys + key1Bin.size + 1, &ctx); release_coll(&ctx); enif_free(keys); return make_return_term(&ctx, result); }
// c_soc:op_update(Index, Term) => {ripe, Frame} | ok | error static ERL_NIF_TERM op_update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { soc::State* st = (soc::State*) enif_priv_data(env); int index; if(enif_get_int(env, argv[0], &index) == 0) { printf("[op_alloc] error: failed to initialize index\n"); return -1; } printf("update start \n"); const soc::Operation* op = st->Update(index, &argv[1]); soc::Frame* frame = op->GetFrame(); printf("update end\n"); if (frame->IsRipe()) { printf("frame->IsRipe()\n"); ERL_NIF_TERM values = enif_make_list_from_array(env, frame->GetValues(), frame->GetLimit()); return enif_make_tuple2(env, enif_make_atom(env, "ripe"), values); } else { return enif_make_atom(env, "ok"); } }
// c_soc:op_lookup(Index) => op static ERL_NIF_TERM op_lookup(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { soc::State* st = (soc::State*) enif_priv_data(env); int index; if (enif_get_int(env, argv[0], &index) == 0) { printf("[op_alloc] error: failed to initialize index\n"); return -1; } const soc::Operation* op; printf("loc / msg lookup index %d start\n", index); try { op = st->Lookup(index); } catch (std::out_of_range exn) { printf("Exception: index %d out of range\n", index); } ERL_NIF_TERM loc = enif_make_tuple2(env, enif_make_int(env, index), enif_make_int(env, op->GetParentKey())); ERL_NIF_TERM ext_msg; ERL_NIF_TERM int_msg; try { ext_msg = enif_make_tuple_from_array(st->GetEnv(), op->GetTuple(), op->TupleArity()); int_msg = enif_make_copy(env, ext_msg); } catch (...) { printf("ERROR: ..."); } printf("loc / msg lookup success\n"); return enif_make_tuple2(env, loc, int_msg); }
static ERL_NIF_TERM exmagick_image_thumb (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { long width, height; Image* thumb; 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 (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } if (0 == enif_get_long(env, argv[1], &width)) { EXM_FAIL(ehandler, "width: bad argument"); } if (0 == enif_get_long(env, argv[2], &height)) { EXM_FAIL(ehandler, "height: bad argument"); } thumb = ThumbnailImage(resource->image, width, height, &resource->e_info); if (thumb == NULL) { CatchException(&resource->e_info); EXM_FAIL(ehandler, resource->e_info.reason); } DestroyImage(resource->image); resource->image = thumb; 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))); }
/** * Insert an object into LRU-Storage */ static ERL_NIF_TERM leo_mcerl_nif_put(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { lcu_cache* cache; String key; String val; ErlNifResourceType* pert; ErlNifBinary keybin; ErlNifBinary bin; bool ret; if (argc < 3) { 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); } if (!enif_inspect_binary(env, argv[2], &bin)) { return enif_make_badarg(env); } key.str = keybin.data; key.len = keybin.size; val.str = bin.data; val.len = bin.size; ret = lcu_cache_put(cache, key, val); return ret ? atom_ok : enif_make_tuple2(env, atom_error, atom_oom); }
static ERL_NIF_TERM nif_scheduler_abort(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { state_ptr state = (state_ptr) enif_priv_data(env); if(state->initilised == 0 ) { return enif_make_tuple2(env, enif_make_atom(env, "state_error"), enif_make_atom(env, "scheduler_not_inited")); } SchedulerDriverStatus status = scheduler_abort( state->scheduler_state ); if(status == 3){ // DRIVER_ABORTED return enif_make_tuple2(env, enif_make_atom(env, "ok"), get_atom_from_status(env, status)); }else{ return enif_make_tuple2(env, enif_make_atom(env, "error"), get_atom_from_status(env, status)); } }