static ERL_NIF_TERM nif_api_version(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { /*ADD_CALL("nif_api_version");*/ return enif_make_tuple2(env, enif_make_int(env, ERL_NIF_MAJOR_VERSION), enif_make_int(env, ERL_NIF_MINOR_VERSION)); }
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)); }
//key, incr, ttl, timestamp static ERL_NIF_TERM update(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int ttl=0, timestamp=0, incr=0, next=0; CHECK(enif_get_string(env, argv[0], keybuff, KEY_MAX_LEN, ERL_NIF_LATIN1)); CHECK(enif_get_int(env, argv[1], &incr)); CHECK(enif_get_int(env, argv[2], &ttl)); CHECK(enif_get_int(env, argv[3], ×tamp)); metronome_item * item = find_in_hash(keybuff, timestamp); item->ttl = ttl; if(item->timestamp + ttl > timestamp) { item->value += incr; next = item->timestamp + ttl - timestamp; } else { item->value = incr; item->timestamp = timestamp; next = ttl; } // return enif_make_tuple3(env, enif_make_atom(env, "ok"), enif_make_int(env, item->value), enif_make_int(env, next) ); }
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; }
static ERL_NIF_TERM _listener (ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { CAN_handle* handle; ErlNifPid pid = { 0 }; // NOTE: breaking opaque type! enif_get_resource(env, argv[0], CAN_handle_type, (void**) &handle); if (handle->threaded) // there is a thread already and some pid! { pid = handle->receiver; } if (!enif_get_local_pid(env, argv[1], &handle->receiver)) // NOTE: use lock if pid type is structural! { handle->threaded = 0; return enif_make_badarg(env); } else { enif_get_uint(env, argv[2], &handle->chunk_size); enif_get_long(env, argv[3], &handle->timeout); if (!handle->threaded) // a thread was not created already { if (enif_thread_create("can_reading_thread", &handle->tid, _reading_thread, handle, 0)) { handle->threaded = 0; return enif_make_int(env, -1004); } } } return pid.pid ? enif_make_pid(env, &pid) : enif_make_int(env, 0); }
// // build result for re2:match // static ERL_NIF_TERM mres(ErlNifEnv* env, const re2::StringPiece& str, const re2::StringPiece& match, const matchoptions::capture_type ct) { switch (ct) { case matchoptions::CT_BINARY: ErlNifBinary bmatch; if(!enif_alloc_binary(match.size(), &bmatch)) return a_err_alloc_binary; memcpy(bmatch.data, match.data(), match.size()); return enif_make_binary(env, &bmatch); default: case matchoptions::CT_INDEX: int l, r; if (match.empty()) { l = -1; r = 0; } else { l = match.data() - str.data(); r = match.size(); } return enif_make_tuple2(env, enif_make_int(env, l), enif_make_int(env, r)); } }
static ERL_NIF_TERM _load(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ UNUSED(argc); ErlNifBinary in,out; struct jpeg_decompress_struct cinfo; struct error_mgr jerr; unsigned int width, height; enif_inspect_binary(env,argv[0],&in); cinfo.err = jpeg_std_error(&jerr.pub); jerr.pub.error_exit = error_exit; if (setjmp(jerr.setjmp_buffer)) { jpeg_destroy_decompress(&cinfo); return -1; } jpeg_create_decompress(&cinfo); jpeg_mem_src(&cinfo, in.data, in.size); jpeg_read_header (&cinfo, TRUE); width = cinfo.image_width; height = cinfo.image_height; enif_alloc_binary(width*height*3,&out); cinfo.do_block_smoothing = TRUE; cinfo.do_fancy_upsampling = TRUE; cinfo.out_color_space = JCS_RGB; jpeg_start_decompress(&cinfo); JSAMPROW rowp[1]; unsigned long location = 0; rowp[0] = (unsigned char*) malloc(cinfo.output_width*cinfo.num_components); unsigned int i = 0; while (cinfo.output_scanline < cinfo.output_height){ jpeg_read_scanlines(&cinfo, rowp, 1); for( i=0; i<cinfo.image_width*cinfo.num_components;i++) out.data[location++] = rowp[0][i]; } free(rowp[0]); jpeg_finish_decompress (&cinfo); jpeg_destroy_decompress (&cinfo); return enif_make_tuple2(env, enif_make_atom(env,"ok"), enif_make_tuple3(env, enif_make_int(env,width), enif_make_int(env,height), enif_make_binary(env, &out) ) ); }
ERL_NIF_TERM geef_library_version(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { int major, minor, rev; git_libgit2_version(&major, &minor, &rev); return enif_make_tuple3(env, enif_make_int(env, major), enif_make_int(env, minor), enif_make_int(env, rev)); }
static ERL_NIF_TERM _receive_can_messages (ErlNifEnv* env, CAN_handle* handle, unsigned int chunk_size, long timeout) { int length = 0, i = 0, chunks = 0; ERL_NIF_TERM *list, result; canmsg_t buffer[sizeof(canmsg_t) * BUFFER_LIMIT]; do { int status = _wait_for_input(handle, timeout); if (status == 0) break; if (status == -1) { result = enif_make_int(env, errno); goto end; } length = read(handle->device, &buffer[chunks], sizeof(canmsg_t) * chunk_size); if (length < 0) break; chunks += length / sizeof(canmsg_t) ; } while (length > 0 && chunks <= BUFFER_LIMIT && chunks < chunk_size); if (chunks > 0) { if (handle->raw) { void* data = enif_make_new_binary(env, chunks * sizeof(canmsg_t), &result); memcpy(data, buffer, chunks * sizeof(canmsg_t)); } else { list = enif_alloc(sizeof(ERL_NIF_TERM) * chunks); // rewrite canmsgs to list of tuples for (i = 0; i < chunks; i++) { canmsg_t* can_msg = buffer + i; ERL_NIF_TERM bin; void* data = enif_make_new_binary(env, can_msg->length, &bin); memcpy(data, can_msg->data, can_msg->length); list[i] = enif_make_tuple3(env, enif_make_int(env, can_msg->id), enif_make_tuple2(env, enif_make_long(env, can_msg->timestamp.tv_sec), enif_make_long(env, can_msg->timestamp.tv_usec)), bin); } result = enif_make_list_from_array(env, list, chunks); enif_free(list); } } else if (length == 0) result = enif_make_int(env, 0); else result = enif_make_int(env, errno); end: return result; }
static ERL_NIF_TERM setup_2(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { unsigned int channel; unsigned long speed; int error; if (argc != 2 || !enif_is_number(env, argv[0]) || !enif_is_number(env, argv[1])) { return enif_make_badarg(env); } if (!enif_get_uint(env, argv[0], &channel)) { return enif_make_badarg(env); } if (!enif_get_ulong(env, argv[1], &speed)) { return enif_make_badarg(env); } if (speed < 500000 || speed > 32000000) { return enif_make_badarg(env); } switch (channel) { case 0: if (state0.fd != 0) { return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "channel already opened", ERL_NIF_LATIN1)); } else { state0.env = env; state0.fd = wiringPiSPISetup(channel, speed); if (state0.fd == 0) { error = errno; return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, error)); } else { return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_int(env, channel)); } } break; case 1: if (state1.fd != 0) { return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "channel already opened", ERL_NIF_LATIN1)); } else { state1.env = env; state1.fd = wiringPiSPISetup(channel, speed); if (state1.fd == 0) { error = errno; return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_int(env, error)); } else { return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_int(env, channel)); } } break; default: return enif_make_badarg(env); } }
/** * Convert an UErrorCode to an atom. */ ERL_NIF_TERM parse_error(ErlNifEnv* env, UErrorCode status, UParseError* e) { return build_error(env, enif_make_tuple3(env, enif_make_atom(env, u_errorName(status)), enif_make_tuple2(env, enif_make_atom(env, "line"), enif_make_int(env, (int) e->line)), enif_make_tuple2(env, enif_make_atom(env, "offset"), enif_make_int(env, (int) e->offset)) )); }
static ERL_NIF_TERM version_directive_to_term(ErlNifEnv *env, yaml_version_directive_t *ver) { if(ver) { return enif_make_tuple2(env, enif_make_int(env, ver->major), enif_make_int(env, ver->minor)); } else { return enif_make_atom(env, "null"); } }
static ERL_NIF_TERM window_event_to_map(ErlNifEnv* env, SDL_Event* event, ERL_NIF_TERM map) { enif_make_map_put(env, map, atom_window_id, enif_make_uint(env, event->window.windowID), &map); enif_make_map_put(env, map, atom_event, window_event_to_atom(event->window.event), &map); enif_make_map_put(env, map, atom_data1, enif_make_int(env, event->window.data1), &map); enif_make_map_put(env, map, atom_data2, enif_make_int(env, event->window.data2), &map); return map; }
ERL_NIF_TERM return_value(ErlNifEnv* env, void * cookie) { struct libcouchbase_callback *cb; cb = (struct libcouchbase_callback *)cookie; ErlNifBinary value_binary; ERL_NIF_TERM term; enif_alloc_binary(cb->size, &value_binary); memcpy(value_binary.data, cb->data, cb->size); term = enif_make_tuple3(env, enif_make_int(env, cb->cas), enif_make_int(env, cb->flag), enif_make_binary(env, &value_binary)); free(cb->data); return term; }
ERL_NIF_TERM pteracuda_nifs_buffer_minmax(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { PCudaContextRef *ctxRef; PCudaBufferRef *bufRef; if (argc !=2 || !enif_get_resource(env, argv[0], pteracuda_context_resource, (void **) &ctxRef) || !enif_get_resource(env, argv[1], pteracuda_buffer_resource, (void **) &bufRef)) { return enif_make_badarg(env); } if (bufRef->buffer->size() == 0) { return enif_make_tuple2(env, ATOM_OK, enif_make_tuple2(env, enif_make_int(env, 0), enif_make_int(env, 0))); } cuCtxSetCurrent(ctxRef->ctx); return enif_make_tuple2(env, ATOM_OK, bufRef->buffer->minmax(env)); }
static ERL_NIF_TERM get_imginfo(ErlNifEnv* env, GDALDatasetH out_ds) { double padfTransform[6]; GDALGetGeoTransform(out_ds, padfTransform); if (padfTransform[2] != 0.0 && padfTransform[4] != 0.0) { return ATOM_ERROR; } return enif_make_tuple6(env, enif_make_double(env, padfTransform[0]), // OriginX enif_make_double(env, padfTransform[3]), // OriginY enif_make_double(env, padfTransform[1]), // PixelXSize enif_make_double(env, padfTransform[5]), // PixelYSize enif_make_int(env, GDALGetRasterXSize(out_ds)), // RasterXSize enif_make_int(env, GDALGetRasterYSize(out_ds)));// RasterYSize }
/* 0: procotol, 1: type, 2: family */ static ERL_NIF_TERM nif_socket(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { int s = -1; int family = 0; int type = 0; int protocol = 0; int flags = 0; if (!enif_get_int(env, argv[0], &family)) return enif_make_badarg(env); if (!enif_get_int(env, argv[1], &type)) return enif_make_badarg(env); if (!enif_get_int(env, argv[2], &protocol)) return enif_make_badarg(env); s = socket(family, type, protocol); if (s < 0) return error_tuple(env, errno); flags = fcntl(s, F_GETFL, 0); if (flags < 0) return error_tuple(env, errno); if (fcntl(s, F_SETFL, flags|O_NONBLOCK) < 0) return error_tuple(env, errno); return enif_make_tuple2(env, atom_ok, enif_make_int(env, s)); }
static ERL_NIF_TERM mruby2erl(ErlNifEnv* env, mrb_state* mrb, mrb_value value) { if (mrb_nil_p(value)) { return enif_make_atom(env, "nil"); } else { switch(value.tt) { case MRB_TT_TRUE: return enif_make_atom(env, "true"); case MRB_TT_FALSE: return enif_make_atom(env, "false"); case MRB_TT_SYMBOL: return enif_make_atom(env, _mrb_symbol(mrb, value)); case MRB_TT_FIXNUM: return enif_make_int(env, _mrb_fixnum(value)); case MRB_TT_FLOAT: return enif_make_double(env, _mrb_float(value)); case MRB_TT_STRING: return make_binary(env, _mrb_string(mrb, value)); case MRB_TT_ARRAY: return make_array(env, mrb, value); case MRB_TT_HASH: return make_hash(env, mrb, value); default : return enif_make_atom(env, "nil"); } } }
static ERL_NIF_TERM do_date_get_field(ErlNifEnv* env, UCalendar* cal, const ERL_NIF_TERM field_atom, UErrorCode& status) { char value[ATOM_LEN]; int parsed_value, amount; UCalendarDateFields field; if (!enif_get_atom(env, field_atom, (char*) value, ATOM_LEN, ERL_NIF_LATIN1)) { status = U_ILLEGAL_ARGUMENT_ERROR; return 0; } parsed_value = parseCalendarDateField(value); if (parsed_value == -1) { status = U_ILLEGAL_ARGUMENT_ERROR; return 0; } field = (UCalendarDateFields) parsed_value; amount = (int) ucal_get(cal, field, &status); if (U_FAILURE(status)) return 0; if (field == UCAL_MONTH) amount++; /* month from 0 */ return enif_make_int(env, amount); }
static ERL_NIF_TERM spi_data_rw_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int channel, len; ErlNifBinary buf; ERL_NIF_TERM atom_fail, err_code; if (!enif_get_int(env, argv[0], &channel) || !enif_inspect_binary(env, argv[1], &buf) || !enif_get_int(env, argv[2], &len)) { return enif_make_badarg(env); } enif_realloc_binary(&buf, len); int result = wiringPiSPIDataRW(channel, buf.data, len); if (result >= 0) { return enif_make_tuple2(env, atom_ok, enif_make_binary(env, &buf)); } else { atom_fail = enif_make_atom(env, "failed_to_read_write_data"); err_code = enif_make_int(env, result); enif_release_binary(&buf); return enif_make_tuple2(env, atom_error, enif_make_tuple2(env, atom_fail, err_code)); } }
// soft PWM static ERL_NIF_TERM soft_pwm_create_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int pin, init_value, range, result; ERL_NIF_TERM atom_fail, err_code; if (!enif_get_int(env, argv[0], &pin) || !enif_get_int(env, argv[1], &init_value) || !enif_get_int(env, argv[2], &range)) { return enif_make_badarg(env); } result = softPwmCreate(pin, init_value, range); if (result) { atom_fail = enif_make_atom(env, "failed_to_init_pwm_pin"); err_code = enif_make_int(env, result); return enif_make_tuple2(env, atom_error, enif_make_tuple2(env, atom_fail, err_code)); } else { return atom_ok; } }
static ERL_NIF_TERM lcd_init_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int num_rows, num_cols, num_bits, rs_pin, e_pin; int d0_pin, d1_pin, d2_pin, d3_pin, d4_pin, d5_pin, d6_pin, d7_pin; int handle; if (!enif_get_int(env, argv[0], &num_rows) || !enif_get_int(env, argv[1], &num_cols) || !enif_get_int(env, argv[2], &num_bits) || !enif_get_int(env, argv[3], &rs_pin) || !enif_get_int(env, argv[4], &e_pin) || !enif_get_int(env, argv[5], &d0_pin) || !enif_get_int(env, argv[6], &d1_pin) || !enif_get_int(env, argv[7], &d2_pin) || !enif_get_int(env, argv[8], &d3_pin) || !enif_get_int(env, argv[9], &d4_pin) || !enif_get_int(env, argv[10], &d5_pin) || !enif_get_int(env, argv[11], &d6_pin) || !enif_get_int(env, argv[12], &d7_pin)) { return enif_make_badarg(env); } handle = lcdInit(num_rows, num_cols, num_bits, rs_pin, e_pin, d0_pin, d1_pin, d2_pin, d3_pin, d4_pin, d5_pin, d6_pin, d7_pin); return enif_make_int(env, handle); }
static ERL_NIF_TERM exmagick_num_pages (ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) { exm_resource_t *resource; Image* image; int num_pages; EXM_INIT; ErlNifResourceType *type = (ErlNifResourceType *) enif_priv_data(env); if (0 == enif_get_resource(env, argv[0], type, (void **) &resource)) { EXM_FAIL(ehandler, "invalid handle"); } if (resource->image == NULL) { EXM_FAIL(ehandler, "image not loaded"); } image = resource->image; num_pages = 1; while((image = image->next)) { ++num_pages; } return(enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_int(env, num_pages))); ehandler: return(enif_make_tuple2(env, enif_make_atom(env, "error"), exmagick_make_utf8str(env, errmsg))); }
static ERL_NIF_TERM set_dtr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ int ret = 0; int port = 0; int state = 0; if (argc < 1) return enif_make_badarg(env); if (!enif_get_int (env, argv[0], &port)) return enif_make_badarg(env); if (!enif_get_int (env, argv[0], &state)) return enif_make_badarg(env); if (port > cur_port || port < 1) return enif_make_badarg(env); if(ports[port - 1] == NULL) return enif_make_string(env, "Port is already closed!", ERL_NIF_LATIN1); if(state) ret = (int) EscapeCommFunction(ports[port - 1], SETDTR); else ret = (int) EscapeCommFunction(ports[port - 1], CLRDTR); return enif_make_int(env, ret); }
static ERL_NIF_TERM write_com(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){ int ret = 0; int port = 0; DWORD dwBytesTransferred; ErlNifBinary bin; if (argc < 2) return enif_make_badarg(env); if (!enif_get_int (env, argv[0], &port)) return enif_make_badarg(env); if (!enif_inspect_binary(env, argv[1], &bin)) return enif_make_badarg(env); if (port > cur_port || port < 1 || bin.size < 1 || bin.size > INT_MAX) return enif_make_badarg(env); if(ports[port - 1] == NULL) return enif_make_string(env, "Port is already closed!", ERL_NIF_LATIN1); if((int) WriteFile(ports[port - 1], bin.data, (DWORD) bin.size, &dwBytesTransferred, NULL)) ret = dwBytesTransferred; else ret = 0; return enif_make_int(env, ret); }
static ERL_NIF_TERM getsockfd(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { int fd; fd = sock_open(AF_INET, SOCK_STREAM, 0); return enif_make_int(env, fd); }
// creates a new simple dataspace and opens it for access ERL_NIF_TERM h5screate_simple(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { hid_t dataspace_id; ERL_NIF_TERM ret; const ERL_NIF_TERM *terms; int rank; // number of dimensions of dataspace hsize_t* dimsf; // array specifiying the size of each dimension int arity; // parse arguments check(argc == 2, "Incorrent number of arguments"); check(enif_get_int(env, argv[0], &rank ), "Can't get rank from argv"); check(enif_get_tuple(env, argv[1], &arity, &terms), "Can't get terms from argv"); // make sure that rank is matching arity check(rank <= 2, "does not support > 2 dimensions"); // allocate array of size rank dimsf = (hsize_t*) malloc(arity * sizeof(hsize_t)); check(!convert_nif_to_hsize_array(env, arity, terms, dimsf), "can't convert dims arr"); // create a new file using default properties dataspace_id = H5Screate_simple(rank, dimsf, NULL); check(dataspace_id > 0, "Failed to create dataspace."); // cleanup free(dimsf); ret = enif_make_int(env, dataspace_id); return enif_make_tuple2(env, ATOM_OK, ret); error: if(dataspace_id) H5Sclose(dataspace_id); if(dimsf) free(dimsf); return error_tuple(env, "Can not create dataspace"); };
/*-----------------------------------------------------------------------------------------------------------------------*/ static ERL_NIF_TERM get_char_field(ErlNifEnv* env, int32_t argc, ERL_NIF_TERM const argv[]) { ERL_NIF_TERM parser_res; ERL_NIF_TERM msg_res; ERL_NIF_TERM group_res; ParserRes* parser = NULL; FIXMsg* msg = NULL; FIXGroup* group = NULL; ERL_NIF_TERM res = get_parser_msg_group(env, argv[0], &parser_res, &msg_res, &group_res, &parser, &msg, &group); if (res != ok_atom) { return res; } int32_t tagNum = 0; if (!enif_get_int(env, argv[1], &tagNum)) { return make_error(env, FIX_FAILED, "Wrong tag num."); } char val; FIXError* error = NULL; pthread_rwlock_rdlock(&parser->lock); FIXErrCode err = fix_msg_get_char(msg, group, tagNum, &val, &error); pthread_rwlock_unlock(&parser->lock); if (err == FIX_FAILED) { ERL_NIF_TERM ret = make_parser_error(env, fix_error_get_code(error), fix_error_get_text(error)); fix_error_free(error); return ret; } return enif_make_tuple2(env, ok_atom, enif_make_int(env, val)); }
static ERL_NIF_TERM call_dirty_nif_exception(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { switch (argc) { case 1: { int arg; if (enif_get_int(env, argv[0], &arg) && arg < 2) { ERL_NIF_TERM args[255]; int i; args[0] = argv[0]; for (i = 1; i < 255; i++) args[i] = enif_make_int(env, i); return enif_schedule_nif(env, "call_dirty_nif_exception", ERL_NIF_DIRTY_JOB_CPU_BOUND, call_dirty_nif_exception, 255, args); } else { return enif_raise_exception(env, argv[0]); } } case 2: { int return_badarg_directly; enif_get_int(env, argv[0], &return_badarg_directly); assert(return_badarg_directly == 1 || return_badarg_directly == 0); if (return_badarg_directly) return enif_make_badarg(env); else { /* ignore return value */ enif_make_badarg(env); return enif_make_atom(env, "ok"); } } default: return enif_schedule_nif(env, "call_dirty_nif_exception", ERL_NIF_DIRTY_JOB_CPU_BOUND, call_dirty_nif_exception, argc-1, argv); } }
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; ERL_NIF_TERM eos = enif_make_int(env, 0); enif_inspect_iolist_as_binary(env, enif_make_list2(env, arg, eos), &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); }