Example #1
0
static VALUE
memory_allocate(VALUE klass)
{
    AbstractMemory* memory;
    VALUE obj;
    obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
    memory->flags = MEM_RD | MEM_WR;

    return obj;
}
Example #2
0
static VALUE
rb_hps_alloc(VALUE klass)
{
  hashpipe_status_t * p;
  VALUE v;
  
  v = Data_Make_Struct(klass, hashpipe_status_t, 0, free, p);
  memset(p, 0, sizeof(hashpipe_status_t));
  return v;
}
Example #3
0
static VALUE allocate(VALUE klass) {
    VALUE obj;
    mysql_client_wrapper * wrapper;
    obj = Data_Make_Struct(klass, mysql_client_wrapper, rb_mysql_client_mark, rb_mysql_client_free, wrapper);
    wrapper->encoding = Qnil;
    wrapper->active = 0;
    wrapper->closed = 1;
    wrapper->client = (MYSQL*)malloc(sizeof(MYSQL));
    return obj;
}
Example #4
0
static VALUE
memptr_allocate(VALUE klass)
{
    Pointer* p;
    VALUE obj = Data_Make_Struct(klass, Pointer, NULL, memptr_release, p);
    p->rbParent = Qnil;
    p->memory.flags = MEM_RD | MEM_WR;

    return obj;
}
Example #5
0
static VALUE rb_gsl_sf_coulomb_wave_FG_e(VALUE obj, VALUE eta, VALUE x,
					 VALUE L_F, VALUE k)

{
  gsl_sf_result *F, *Fp, *G, *Gp;
  VALUE vF, vFp, vG, vGp;
  double exp_G, exp_F;
  int status;
  Need_Float(eta); Need_Float(x); Need_Float(L_F);
  CHECK_FIXNUM(k);
  vF = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, F);
  vFp = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, Fp);
  vG = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, G);
  vGp = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, Gp);
  status = gsl_sf_coulomb_wave_FG_e(NUM2DBL(eta), NUM2DBL(x), NUM2DBL(L_F),
				    FIX2INT(k), F, Fp, G, Gp, &exp_F, &exp_G);
  return rb_ary_new3(7, vF, vFp, vG, vGp,
		     rb_float_new(exp_F), rb_float_new(exp_G), INT2FIX(status));
}
Example #6
0
static VALUE rb_gsl_sf_multiply_e(VALUE obj, VALUE x, VALUE y)
{
  gsl_sf_result *r;
  VALUE v;
  int status;
  Need_Float(x); Need_Float(y);
  v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r);
  status = gsl_sf_multiply_e(NUM2DBL(x), NUM2DBL(y), r);
  return v;
}
Example #7
0
static VALUE rb_gsl_sf_lnchoose_e(VALUE obj, VALUE n, VALUE m)
{
  gsl_sf_result *rslt = NULL;
  VALUE v;
  int status;
  CHECK_FIXNUM(n); CHECK_FIXNUM(m);
  v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt);
  status = gsl_sf_lnchoose_e(FIX2INT(n), FIX2INT(m), rslt);
  return v;
}
static VALUE
symbol_allocate(VALUE klass)
{
    LibrarySymbol* sym;
    VALUE obj = Data_Make_Struct(klass, LibrarySymbol, NULL, -1, sym);
    sym->name = Qnil;
    sym->library = Qnil;
    sym->base.rbParent = Qnil;

    return obj;
}
Example #9
0
VALUE
rb_ldap_entry_new (LDAP * ldap, LDAPMessage * msg)
{
  VALUE val;
  RB_LDAPENTRY_DATA *edata;
  val = Data_Make_Struct (rb_cLDAP_Entry, RB_LDAPENTRY_DATA,
			  0, rb_ldap_entry_free, edata);
  edata->ldap = ldap;
  edata->msg = msg;
  return val;
}
Example #10
0
File: artist.c Project: Voxar/spot
static VALUE
rb_ds_artist_alloc (VALUE klass)
{
	rb_ds_artist *artist;
	VALUE obj;

	obj = Data_Make_Struct(klass, rb_ds_artist,
	                       NULL, NULL, artist);

	return obj;
}
Example #11
0
static VALUE
rb_ds_playlist_alloc (VALUE klass)
{
	rb_ds_playlist *pls;
	VALUE obj;

	obj = Data_Make_Struct(klass, rb_ds_playlist, NULL,
	                       rb_ds_playlist_free, pls);

	return obj;
}
Example #12
0
File: Type.c Project: Flameeyes/ffi
static VALUE
type_allocate(VALUE klass)
{
    Type* type;
    VALUE obj = Data_Make_Struct(klass, Type, NULL, -1, type);

    type->nativeType = -1;
    type->ffiType = &ffi_type_void;
    
    return obj;
}
Example #13
0
static VALUE num_alloc(VALUE klass) {
  decNumber self_struct, *self_ptr;
  decContext context;
  VALUE self;
  self_ptr = &self_struct;
  self = Data_Make_Struct(klass, decNumber, 0, free, self_ptr);
  decContextDefault(&context, DEC_INIT_BASE);

  (*self_ptr).bits = DECNAN;
  return self;
}
Example #14
0
static VALUE rb_gsl_sf_pow_int_e(VALUE obj, VALUE x, VALUE n)
{
  gsl_sf_result *rslt = NULL;
  VALUE v;
  int status;
  Need_Float(x);
  CHECK_FIXNUM(n);
  v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt);
  status = gsl_sf_pow_int_e(NUM2DBL(x), FIX2INT(n), rslt);
  return v;
}
Example #15
0
static VALUE rb_gsl_sf_lngamma_sgn_e(VALUE obj, VALUE x)
{
  gsl_sf_result *rslt = NULL;
  VALUE v;
  int status;
  double sgn;
  Need_Float(x);
  v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt);
  status = gsl_sf_lngamma_sgn_e(NUM2DBL(x), rslt, &sgn);
  return rb_ary_new3(2, v, rb_float_new(sgn));
}
Example #16
0
static VALUE static_gedcom_date_new( int    argc,
                                     VALUE *argv,
                                     VALUE  klass )
{
  char *s_date;
  int   i_type;
  int   rc;
  VALUE date;
  VALUE type;
  VALUE new_date;
  gedDATEVALUE_t parsed_date;
  gedDATEVALUE_t *temp;

  if( rb_scan_args( argc, argv, "11", &date, &type ) == 1 )
  {
    i_type = gctDEFAULT;
  }
  else
  {
    i_type = FIX2INT( type );
  }
    
  s_date = STR2CSTR( date );

  rc = parseGEDCOMDate( s_date, &parsed_date, i_type );

  if( rc != 0 )
  {
    VALUE err_msg;

    err_msg = rb_str_new2( "format error at '" );

    if( parsed_date.date1.flags & gfNONSTANDARD )
      rb_str_cat( err_msg, parsed_date.date1.data.phrase, strlen( parsed_date.date1.data.phrase ) );
    else
      rb_str_cat( err_msg, parsed_date.date2.data.phrase, strlen( parsed_date.date2.data.phrase ) );

    rb_str_cat( err_msg, "'", 1 );

    if( rb_block_given_p() )
    {
      rb_yield( err_msg );
    }
    else
    {
      rb_raise( eDateFormatException, STR2CSTR( err_msg ) );
    }
  }

  new_date = Data_Make_Struct( klass, gedDATEVALUE_t, 0, 0, temp );
  memcpy( temp, &parsed_date, sizeof( parsed_date ) );

  return new_date;
}
Example #17
0
static rb_context_t *
cont_new(VALUE klass)
{
    rb_context_t *cont;
    volatile VALUE contval;

    contval = Data_Make_Struct(klass, rb_context_t, cont_mark, cont_free, cont);
    cont->self = contval;
    cont_init(cont);
    return cont;
}
Example #18
0
static VALUE
rb_ds_session_alloc (VALUE klass)
{
	rb_ds_session *session;
	VALUE obj;

	obj = Data_Make_Struct(klass, rb_ds_session, NULL,
	                       rb_ds_session_free, session);

	return obj;
}
Example #19
0
static VALUE rb_gsl_sf_lnchoose_e(VALUE obj, VALUE n, VALUE m)
{
  gsl_sf_result *rslt = NULL;
  VALUE v;
  // local variable "status" declared and set, but never used
  //int status;
  CHECK_FIXNUM(n); CHECK_FIXNUM(m);
  v = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, rslt);
  /*status =*/ gsl_sf_lnchoose_e(FIX2INT(n), FIX2INT(m), rslt);
  return v;
}
Example #20
0
static VALUE solver_alloc(VALUE klass)
{
    csolver *cslv;
    VALUE rslv;

    rslv = Data_Make_Struct(klass, csolver, NULL, solver_free, cslv);
    cslv->solver = wrap_solver_new();
    cslv->result = NOT_SOLVED_YET;

    return rslv;
}
static VALUE
sbr_allocate(VALUE klass)
{
    StructByReference* sbr;

    VALUE obj = Data_Make_Struct(klass, StructByReference, sbr_mark, -1, sbr);

    sbr->rbStructClass = Qnil;

    return obj;
}
Example #22
0
static ThreadData*
thread_data_init(void)
{
    ThreadData* td;
    VALUE obj;

    obj = Data_Make_Struct(rb_cObject, ThreadData, NULL, -1, td);
    rb_thread_local_aset(rb_thread_current(), id_thread_data, obj);

    return td;
}
Example #23
0
static VALUE
memory_allocate(VALUE klass)
{
    AbstractMemory* memory;
    VALUE obj;
    obj = Data_Make_Struct(klass, AbstractMemory, NULL, -1, memory);
    memory->ops = &rbffi_AbstractMemoryOps;
    memory->access = MEM_RD | MEM_WR;

    return obj;
}
Example #24
0
static VALUE
pg_typemap_s_allocate( VALUE klass )
{
	VALUE self;
	t_typemap *this;

	self = Data_Make_Struct( klass, t_typemap, NULL, -1, this );
	this->funcs = pg_typemap_funcs;

	return self;
}
Example #25
0
static VALUE allocate(VALUE klass) {
  VALUE obj;
  tinytds_client_wrapper *cwrap;
  obj = Data_Make_Struct(klass, tinytds_client_wrapper, rb_tinytds_client_mark, rb_tinytds_client_free, cwrap);
  cwrap->closed = 1;
  cwrap->charset = Qnil;
  cwrap->userdata = malloc(sizeof(tinytds_client_userdata));
  cwrap->userdata->closed = 1;
  rb_tinytds_client_reset_userdata(cwrap->userdata);
  return obj;
}
Example #26
0
File: Struct.c Project: mjaric/ffi
static VALUE
struct_allocate(VALUE klass)
{
    Struct* s;
    VALUE obj = Data_Make_Struct(klass, Struct, struct_mark, struct_free, s);
    
    s->rbPointer = Qnil;
    s->rbLayout = Qnil;

    return obj;
}
Example #27
0
static VALUE
struct_field_allocate(VALUE klass)
{
    StructField* field;
    VALUE obj;

    obj = Data_Make_Struct(klass, StructField, struct_field_mark, -1, field);
    field->rbType = Qnil;
    field->rbName = Qnil;

    return obj;
}
Example #28
0
static VALUE allocate(VALUE klass)
{
  MYSQL * client;

  return Data_Make_Struct(
      klass,
      MYSQL,
      NULL,
      rb_mysql_client_free,
      client
  );
}
Example #29
0
static VALUE
pg_composite_decoder_allocate( VALUE klass )
{
	t_pg_composite_coder *this;
	VALUE self = Data_Make_Struct( klass, t_pg_composite_coder, NULL, -1, this );
	pg_coder_init_decoder( self );
	this->elem = NULL;
	this->needs_quotation = 1;
	this->delimiter = ',';
	rb_iv_set( self, "@elements_type", Qnil );
	return self;
}
Example #30
0
File: Struct.c Project: mjaric/ffi
static VALUE
inline_array_allocate(VALUE klass)
{
    InlineArray* array;
    VALUE obj;

    obj = Data_Make_Struct(klass, InlineArray, inline_array_mark, -1, array);
    array->rbField = Qnil;
    array->rbMemory = Qnil;

    return obj;
}