static ERL_NIF_TERM ex_slp_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { char *lang; char *ret_code; int isasync; unsigned int term_len; SLPHandle *hslp; SLPEXP SLPError SLPAPI error; if (enif_get_atom_length(env, argv[0], &term_len, ERL_NIF_LATIN1) < 0) { return enif_make_badarg(env); } if (enif_get_atom(env, argv[0], lang, term_len, ERL_NIF_LATIN1) < 0) { return enif_make_badarg(env); } if ( ! enif_get_int(env, argv[1], &isasync)) return enif_make_badarg(env); hslp = enif_alloc_resource(NIF_SLP_HANDLE, sizeof(SLPHandle)); if (hslp == NULL) return enif_make_badarg(env); //error = SLPOpen(lang, isasync > 0 ? SLP_TRUE : SLP_FALSE, hslp); error = SLPOpen(lang, isasync > 0 ? SLP_TRUE : SLP_FALSE, hslp); ERL_NIF_TERM term = enif_make_resource(env, hslp); enif_release_resource(hslp); return enif_make_tuple2(env, enif_make_int(env, error), term); }
static ERL_NIF_TERM exmagick_init_handle (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM result; EXM_INIT; ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env); exm_resource_t *resource = enif_alloc_resource(type, sizeof(exm_resource_t)); if (resource == NULL) { EXM_FAIL(ehandler, "enif_alloc_resource"); } /* initializes exception to default values (badly named function) */ GetExceptionInfo(&resource->e_info); resource->image = NULL; resource->i_info = CloneImageInfo(0); if (resource->i_info == NULL) { EXM_FAIL(ehandler, "CloneImageInfo"); } result = enif_make_resource(env, (void *) resource); enif_release_resource(resource); return(enif_make_tuple2(env, enif_make_atom(env, "ok"), result)); ehandler: if (resource != NULL) { if (resource->i_info != NULL) { DestroyImageInfo(resource->i_info); } enif_release_resource(resource); } return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg))); }
/* Get a collator */ ERL_NIF_TERM get_collator(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM out; char locale[LOCALE_LEN]; UErrorCode status = U_ZERO_ERROR; UCollator* col; cloner* res; unsigned int index; if ((argc != 2) && (argc != 1)) return enif_make_badarg(env); if (!enif_get_atom(env, argv[0], (char*) locale, LOCALE_LEN, ERL_NIF_LATIN1)) { return enif_make_badarg(env); } col = ucol_open((char *) locale, &status); CHECK(env, status); res = (cloner*) enif_alloc_resource(collator_type, sizeof(cloner)); if (collator_open(col, res)) { enif_release_resource(res); return enif_make_badarg(env); } CHECK_DEST(env, status, enif_release_resource(res); );
/* {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 _open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { CAN_handle* handle; ERL_NIF_TERM result; char dev_path[512]; if (!enif_get_string(env, argv[0], dev_path, 512, ERL_NIF_LATIN1)) return enif_make_int(env, -2000); handle = enif_alloc_resource(CAN_handle_type, sizeof(CAN_handle)); memset(handle, 0, sizeof(CAN_handle)); handle->device = open((const char*)dev_path, O_RDWR | O_SYNC); if (!enif_get_int(env, argv[1], &handle->raw)) return enif_make_int(env, -2001); handle->threaded = 0; if (handle->device >= 0) { int len = strlen(dev_path); result = enif_make_resource(env, handle); handle->devpath = enif_alloc(len); memcpy(handle->devpath, dev_path, len); handle->devpath_bin = enif_make_resource_binary(env, handle, handle->devpath, len); } else { result = enif_make_int(env, errno); } enif_release_resource(handle); return result; }
/* 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); }
ctx_t* init_ctx() { int status; ctx_t *ctx = static_cast<ctx_t*>(enif_alloc_resource(res_type, sizeof(*ctx))); if (ctx == NULL) { goto done; } ctx->queue = async_queue_create(); ctx->topts = enif_thread_opts_create(const_cast<char*>("snappy_thread_opts")); status = enif_thread_create(const_cast<char*>("worker"), &ctx->tid, worker, ctx, ctx->topts); if (status != 0) { enif_release_resource(ctx); ctx = NULL; goto done; } done: return ctx; }
ERL_NIF_TERM _hh_from_binary(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary source; if (!enif_inspect_binary(env, argv[0], &source)) { return enif_make_badarg(env); } hdr_histogram_t* target = NULL; int success = hdr_decode(source.data, source.size, &target); if (success != 0) { return make_error(env, "bad_hdr_binary"); } ErlNifResourceType* ctx_type = get_hh_ctx_type(env); hh_ctx_t* ctx = (hh_ctx_t*)enif_alloc_resource(ctx_type, sizeof(hh_ctx_t)); ctx->data = (hdr_histogram_t*)target; ctx->highest_trackable_value = target->highest_trackable_value; ctx->significant_figures = target->significant_figures; ERL_NIF_TERM result = enif_make_resource(env, ctx); enif_release_resource(ctx); return enif_make_tuple2(env, ATOM_OK, result); }
static ERL_NIF_TERM compile(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary patternbin; if (enif_inspect_iolist_as_binary(env, argv[0], &patternbin)) { ERL_NIF_TERM ret; xmlRegexpPtr xre; char *patternstr = enif_alloc(patternbin.size + 1); patternstr[patternbin.size] = 0; memcpy(patternstr, patternbin.data, patternbin.size); if ((xre = xmlRegexpCompile((xmlChar *)patternstr)) != NULL) { struct regexp *r; r = enif_alloc_resource(regexp_type, sizeof(struct regexp)); memset(r, 0, sizeof(*r)); r->xre = xre; r->string = patternstr; /* transfer ownership to calling process */ ret = enif_make_tuple2(env, am_ok(env), enif_make_resource(env, r)); enif_release_resource(r); } else { enif_free(patternstr); ret = last_error(env, "Bad Pattern"); } return ret; } return enif_make_badarg(env); }
static ERL_NIF_TERM new_parser(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { XML_Parser parser; expat_parser *parser_data = (expat_parser *)enif_alloc(sizeof(expat_parser)); ERL_NIF_TERM parser_resource; // this is the variant from esl/exml:208d5e17e547b303b310627e3e525b57b2843e83 /*parser = XML_ParserCreate_MM("UTF-8", &ms, "\n");*/ // this makes the tests pass, but according to expat documentation it turns namespace support off /*parser = XML_ParserCreate_MM("UTF-8", &ms, NULL);*/ // this is a try to preserve namespace support but make the tests pass; // this is the character defined as a macro in xmlwf sources for namespace-enabled parser /*XML_Char namespaceSeparator = '\001';*/ /*parser = XML_ParserCreate_MM("UTF-8", &ms, &namespaceSeparator);*/ parser = XML_ParserCreate_MM("UTF-8", &ms, ":"); parser_data->env = env; parser_data->xmlns = (ERL_NIF_TERM)NULL; init_parser(parser, parser_data); XML_Parser *xml_parser = (XML_Parser *)enif_alloc_resource(PARSER_POINTER, sizeof(XML_Parser)); *xml_parser = parser; parser_resource = enif_make_resource(env, (void *)xml_parser); enif_release_resource(xml_parser); return enif_make_tuple(env, 2, OK, parser_resource); };
static void generate_keypair_from_seed(brine_task_s *task) { ErlNifEnv *env = task->env; ERL_NIF_TERM result; brine_keypair_s *keypair = (brine_keypair_s *) enif_alloc_resource(brine_keypair_resource, sizeof(brine_keypair_s)); ErlNifBinary seed; if (!keypair) { result = BRINE_ERROR_NO_MEMORY; } else { if (!enif_inspect_binary(env, task->options.generate.seed, &seed)) { result = BRINE_ATOM_ERROR; } else { if (!brine_init_keypair_from_seed(keypair, seed.data, seed.size)) { result = BRINE_ATOM_ERROR; } else { result = enif_make_tuple2(env, enif_make_copy(env, BRINE_ATOM_OK), make_keypair_record(env, keypair)); } } enif_release_resource(keypair); } enif_send(NULL, &task->owner, task->env, enif_make_tuple2(env, task->ref, result)); }
static ERL_NIF_TERM do_prepare(ErlNifEnv *env, esqlite_connection *conn, const ERL_NIF_TERM arg) { ErlNifBinary bin; esqlite_statement *stmt; ERL_NIF_TERM esqlite_stmt; const char *tail; int rc; enif_inspect_iolist_as_binary(env, arg, &bin); stmt = enif_alloc_resource(esqlite_statement_type, sizeof(esqlite_statement)); if(!stmt) return make_error_tuple(env, "no_memory"); rc = sqlite3_prepare_v2(conn->db, (char *) bin.data, bin.size, &(stmt->statement), &tail); if(rc != SQLITE_OK) return make_sqlite3_error_tuple(env, rc, conn->db); enif_keep_resource(conn); stmt->connection = conn; esqlite_stmt = enif_make_resource(env, stmt); enif_release_resource(stmt); return make_ok_tuple(env, esqlite_stmt); }
static ERL_NIF_TERM open_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ks_returner_t *ret; ks_handle_t *handle; ERL_NIF_TERM term; ret = new_returner(env); handle = (ks_handle_t *)(enif_alloc_resource(kstat_handle, sizeof(ks_handle_t))); handle->ks_id = -1; list_create(&handle->instances_list, sizeof (ks_instance_t), offsetof(ks_instance_t, ks_next)); term = enif_make_resource(env, handle); enif_release_resource(handle); while ((handle->ks_ctl = kstat_open()) == NULL) { if (errno == EAGAIN) { (void) poll(NULL, 0, 200); } else { return EKSTAT_RETURN(EKSTAT_ERROR("kstat_open failed")); } } return EKSTAT_RETURN(EKSTAT_OK(term)); }
static Encoder* enc_new(ErlNifEnv* env) { jiffy_st* st = (jiffy_st*) enif_priv_data(env); Encoder* e = enif_alloc_resource(st->res_enc, sizeof(Encoder)); e->atoms = st; e->bytes_per_iter = DEFAULT_BYTES_PER_ITER; e->uescape = 0; e->pretty = 0; e->use_nil = 0; e->shiftcnt = 0; e->count = 0; e->iolen = 0; e->iosize = 0; e->curr = &(e->bin); if(!enif_alloc_binary(BIN_INC_SIZE, e->curr)) { e->curr = NULL; enif_release_resource(e); return NULL; } 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 e; }
static ERL_NIF_TERM wrap_pointer(ErlNifEnv* env,ErlNifResourceType* type,void* ptr) { void** resource = (void**) enif_alloc_resource(env,type,sizeof(void*)); *resource = ptr; ERL_NIF_TERM term = enif_make_resource(env,resource); enif_release_resource(env,(void*)resource); return term; }
static ERL_NIF_TERM nif_open(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { ErlNifBinary dev; SRLY_STATE *sp = NULL; if (!enif_inspect_iolist_as_binary(env, argv[0], (ErlNifBinary *)&dev)) return enif_make_badarg(env); sp = enif_alloc_resource(SRLY_STATE_RESOURCE, sizeof(SRLY_STATE)); if (sp == NULL) return error_tuple(env, ENOMEM); if (!enif_realloc_binary(&dev, dev.size+1)) return enif_make_badarg(env); dev.data[dev.size-1] = '\0'; sp->fd = open((char *)dev.data, O_RDWR|O_NOCTTY|O_NONBLOCK); if (sp->fd < 0 || isatty(sp->fd) != 1) { int err = errno; enif_release_resource(sp); return error_tuple(env, err); } return enif_make_tuple2(env, atom_ok, enif_make_resource(env, sp)); }
static ERL_NIF_TERM create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { Example* res; ERL_NIF_TERM ret; unsigned int id; Tracker* tracker; if(argc != 1) { return enif_make_badarg(env); } if(!enif_get_uint(env, argv[0], &id)) { return enif_make_badarg(env); } res = enif_alloc_resource(RES_TYPE, sizeof(Example)); if(res == NULL) return enif_make_badarg(env); ret = enif_make_resource(env, res); enif_release_resource(res); res->id = id; tracker = (Tracker*) enif_priv_data(env); tracker->count += 1; return enif_make_tuple2(env, atom_ok, ret); }
ERL_NIF_TERM _hi_open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { uint32_t iterator_type = 0; if (argc != 1 || !enif_get_uint(env, argv[0], &iterator_type)) { return enif_make_badarg(env); } if (iterator_type != HDR_ITER_REC && iterator_type != HDR_ITER_LIN && iterator_type != HDR_ITER_LOG && iterator_type != HDR_ITER_PCT) { return make_error(env, "bad_iterator_type"); } ErlNifResourceType* ctx_type = get_hi_ctx_type(env); hi_ctx_t* ctx = (hi_ctx_t*)enif_alloc_resource(ctx_type, sizeof(hi_ctx_t)); ctx->type = iterator_type; ctx->opts = NULL; ctx->iter = NULL; ERL_NIF_TERM result = enif_make_resource(env, ctx); enif_release_resource(ctx); return enif_make_tuple2(env, ATOM_OK, result); }
/* * Start the processing thread */ static ERL_NIF_TERM esqlite_start(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { esqlite_connection *conn; ERL_NIF_TERM db_conn; /* Initialize the resource */ conn = enif_alloc_resource(esqlite_connection_type, sizeof(esqlite_connection)); if(!conn) return make_error_tuple(env, "no_memory"); conn->db = NULL; /* Create command queue */ conn->commands = queue_create(); if(!conn->commands) { enif_release_resource(conn); return make_error_tuple(env, "command_queue_create_failed"); } /* Start command processing thread */ conn->opts = enif_thread_opts_create("esqldb_thread_opts"); if(enif_thread_create("esqlite_connection", &conn->tid, esqlite_connection_run, conn, conn->opts) != 0) { enif_release_resource(conn); return make_error_tuple(env, "thread_create_failed"); } db_conn = enif_make_resource(env, conn); enif_release_resource(conn); return make_ok_tuple(env, db_conn); }
static ERL_NIF_TERM newstate(ErlNifEnv *env, ErlNifEnv *hold_env) { ERL_NIF_TERM ret; lua_State *L; elua_t *res; L = luaL_newstate(); if(L==NULL) { return enif_make_tuple2(env, atom_error, enif_make_string(env, STR_NOT_ENOUGHT_MEMORY, ERL_NIF_LATIN1)); } luaL_openlibs(L); res = enif_alloc_resource(RES_SYNC, sizeof(elua_t)); if(res == NULL) return enif_make_badarg(env); //printf("alloc res 0x%x\n" ,(unsigned int)res); ret = enif_make_resource(env, res); enif_release_resource(res); res->L = L; return enif_make_tuple2(env, atom_ok, ret); }
/* OGRSFDriverH CPL_DLL OGRGetDriver( int ); {ok, Driver} = lgeo_ogr:get_driver(0), */ static ERL_NIF_TERM get_driver(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int driver_idx; ERL_NIF_TERM eterm; if (argc != 1) { return enif_make_badarg(env); } if (!enif_get_int(env, argv[0], &driver_idx)) { return enif_make_badarg(env); } OGRSFDriverH drv = OGRGetDriver(driver_idx); if (!drv) { return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Driver not found", ERL_NIF_LATIN1)); } OGRSFDriverH **driver = \ enif_alloc_resource(OGR_D_RESOURCE, sizeof(OGRSFDriverH*)); *driver = drv; eterm = enif_make_resource(env, driver); enif_release_resource(driver); return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm); }
static Matrix* alloc_matrix(ErlNifEnv* env, unsigned nrows, unsigned ncols) { Matrix* mx = enif_alloc_resource(resource_type, sizeof(Matrix)); mx->nrows = nrows; mx->ncols = ncols; mx->data = enif_alloc(nrows*ncols*sizeof(double)); return mx; }
static ERL_NIF_TERM make_term_resource(struct make_term_info* mti, int n) { void* resource = enif_alloc_resource(mti->resource_type, 10); ERL_NIF_TERM term; fill(resource, 10, n); term = enif_make_resource(mti->dst_env, resource); enif_release_resource(resource); return term; }
static ERL_NIF_TERM cqueue_new(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { cqueue_handle* handle = (cqueue_handle*)enif_alloc_resource(cqueue_RESOURCE, sizeof(cqueue_handle)); handle->queue = new CQueue(schedulers); ERL_NIF_TERM result = enif_make_resource(env, handle); enif_release_resource(handle); return enif_make_tuple2(env, enif_make_atom(env, "ok"), result); }
static ERL_NIF_TERM recombine_solutions(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ // long diff; // struct timespec start, end; // clock_gettime(CLOCK_MONOTONIC, &start); ERL_NIF_TERM terms[2]; ErlNifResourceType* sol_type; Solution *sols[2], *new_sols[2]; // arrays of two pointers of type Solution* unsigned int i; unsigned int len; CHECK(env, argc == 2) sol_type = (ErlNifResourceType*) enif_priv_data(env); CHECK(env, sol_type) // read parent solutions for (i=0; i<2; i++){ CHECK(env, enif_get_resource(env, argv[i], sol_type, (void**) &sols[i])) } #ifdef DEBUG print_solution(sols[0],"Genotype1"); print_solution(sols[1],"Genotype2"); #endif // allocate 2 child solution structures len = sols[0]->len; for (i=0; i<2; i++){ new_sols[i] = (Solution*) enif_alloc_resource(sol_type, sizeof(Solution)); CHECK(env, new_sols[i]) terms[i] = enif_make_resource(env, new_sols[i]); CHECK(env,terms[i]) enif_release_resource(new_sols[i]); new_sols[i]->len = len; new_sols[i]->genotype = (double*) malloc(sizeof(double)*len); } recombine(sols, new_sols); #ifdef DEBUG print_solution(new_sols[0],"RecombinedGenotype1"); print_solution(new_sols[1],"RecombinedGenotype2"); #endif // clock_gettime(CLOCK_MONOTONIC, &end); // diff = CLOCKS_PER_SEC * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec; // printf("reco=%llu\n", (long long unsigned int) diff); return enif_make_tuple2(env, terms[0], terms[1]); }
static ERL_NIF_TERM to_geom(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM eterm; GEOSGeometry **geom = enif_alloc_resource(GEOSGEOM_RESOURCE, sizeof(GEOSGeometry*)); *geom = eterm_to_geom(env, argv); eterm = enif_make_resource(env, geom); enif_release_resource(geom); return eterm; }
static ERL_NIF_TERM hd512_init(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM result; ErlNifResourceType* ctx_type = (ErlNifResourceType*)enif_priv_data(env); Context* ctx = (Context*)enif_alloc_resource(ctx_type, sizeof(Context)); context_init(ctx, H512, sizeof H512, PADDED_SIZE_5XX); result = enif_make_resource(env, ctx); enif_release_resource(ctx); return result; }
ERL_NIF_TERM pteracuda_nifs_new_string_buffer(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { PCudaBufferRef *ref = (PCudaBufferRef *) enif_alloc_resource(pteracuda_buffer_resource, sizeof(PCudaBufferRef)); if (!ref) { return OOM_ERROR; } ref->buffer = new PCudaStringBuffer(); ref->destroyed = false; ERL_NIF_TERM res = enif_make_resource(env, ref); enif_release_resource(ref); return enif_make_tuple2(env, ATOM_OK, res); }
ERL_NIF_TERM open_calendar(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { ERL_NIF_TERM out; ErlNifBinary tz; cloner* res; UCalendar* cal; UCalendarType type = UCAL_DEFAULT; UErrorCode status = U_ZERO_ERROR; char type_atom[ATOM_LEN], locale[LOCALE_LEN]; tz.size = 0; tz.data = 0; switch (argc) { case 3: if (!enif_get_atom(env, argv[2], (char*) type_atom, ATOM_LEN, ERL_NIF_LATIN1)) return enif_make_badarg(env); type = parserCalendarType((const char *) type_atom); case 2: if (!enif_inspect_binary(env, argv[1], &tz)) return enif_make_badarg(env); case 1: if (!enif_get_atom(env, argv[0], (char*) locale, LOCALE_LEN, ERL_NIF_LATIN1)) return enif_make_badarg(env); break; default: return enif_make_badarg(env); } /* get a calendar type */ cal = ucal_open( (const UChar *) tz.data, (int32_t) tz.size, (const char *) locale, type, &status); CHECK(env, status); res = (cloner*) enif_alloc_resource(calendar_type, sizeof(cloner)); if (calendar_open(cal, res)) { enif_release_resource(res); return enif_make_badarg(env); } out = enif_make_resource(env, res); enif_release_resource(res); /* resource now only owned by "Erlang" */ return out; }
/* OGRDataSourceH CPL_DLL OGROpen(const char *, int, OGRSFDriverH *) CPL_WARN_UNUSED_RESULT; {ok, DataSource} = lgeo_ogr:open("test/polygon.shp"). {ok, DataSource} = lgeo_ogr:open("test/polygon.shp", 1). */ static ERL_NIF_TERM open(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int update = 0; // read-only (default) OGRDataSourceH datasource; ERL_NIF_TERM eterm; /* OGRSFDriverH *pahDriver; ERL_NIF_TERM eterm1, eterm2; */ unsigned len; if (argc > 0 && !enif_get_list_length(env, argv[0], &len)) { return enif_make_badarg(env); } char * filename = enif_alloc(sizeof(char)*(len+1)); if(!enif_get_string(env, argv[0], filename, len+1, ERL_NIF_LATIN1)) { return enif_make_badarg(env); } if (argc == 2 && !enif_get_int(env, argv[1], &update)) { return enif_make_badarg(env); } datasource = OGROpen(filename, update, NULL); //datasource = OGROpen(filename, upadate, pahDriver); enif_free(filename); if(datasource == NULL) { return enif_make_atom(env, "undefined"); } OGRDataSourceH **hDS = \ enif_alloc_resource(OGR_DS_RESOURCE, sizeof(OGRDataSourceH*)); *hDS = datasource; /* OGRSFDriverH **hDriver = \ enif_alloc_resource(OGR_D_RESOURCE, sizeof(OGRSFDriverH*)); *hDriver = *pahDriver; */ eterm = enif_make_resource(env, hDS); enif_release_resource(hDS); return enif_make_tuple2(env, enif_make_atom(env, "ok"), eterm); /* eterm2 = enif_make_resource(env, hDriver); enif_release_resource(hDriver); return enif_make_tuple2(env, eterm1, eterm1); */ }