示例#1
0
文件: nif_mod.c 项目: hawk/otp
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));
}
示例#2
0
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));
}
示例#3
0
//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], &timestamp));

    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)
                           );
}
示例#4
0
文件: CAN_nif.c 项目: qoocku/erleos
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;
}
示例#5
0
文件: CAN_nif.c 项目: qoocku/erleos
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);
}
示例#6
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)
				)
			);
}
示例#8
0
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));
}
示例#9
0
文件: CAN_nif.c 项目: qoocku/erleos
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;
}
示例#10
0
文件: spidev.c 项目: sivieri/spidev2
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);
	}
}
示例#11
0
文件: i18n_nif.cpp 项目: djui/i18n
/**
 * 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))
            ));
}
示例#12
0
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");
    }
}
示例#13
0
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;
}
示例#14
0
文件: cb.c 项目: muut/cberl
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;
}
示例#15
0
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));
}
示例#16
0
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
}
示例#17
0
/*  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));
}
示例#18
0
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");
    }
  }
}
示例#19
0
文件: i18n_date.cpp 项目: djui/i18n
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);
}
示例#20
0
文件: wpi.c 项目: alepharchives/wpi
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));
    }
}
示例#21
0
文件: wpi.c 项目: alepharchives/wpi
// 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;
    }
}
示例#22
0
文件: wpi.c 项目: alepharchives/wpi
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);
}
示例#23
0
文件: exmagick.c 项目: Xerpa/exmagick
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)));
}
示例#24
0
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);
}
示例#25
0
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);
}
示例#26
0
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);
}
示例#27
0
// 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");
};
示例#28
0
/*-----------------------------------------------------------------------------------------------------------------------*/
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));
}
示例#29
0
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);
    }
}
示例#30
0
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);
}