Way to wrap C language structure?

[mattn]

Where is function to embed wrapped object that like ruby's Data_Make_Struct. Or way to add trick to wrap it?

Thanks.

[matz]

The following is the code from (undisclosed) socket extension:

#include "mruby/data.h"

static void
sock_free(mrb_state *mrb, void *p)
{
  close((int)p);
}

static const struct mrb_data_type sock_data_type = {
  "socket", sock_free,
};

VALUE
rsock_new_sock(mrb_state *mrb, struct RClass *c, int fd)
{
  return mrb_obj_value(Data_Wrap_Struct(mrb, c, &sock_data_type, (void*)fd));
}

Hope this helps to grab the code structure.

[mattn]

Thank you.

[mattn]

Are you going to add alloc_func?

[matz]

use MRB_SET_INSTANCE_TT(c, t) to specify instance object type. See src/array.c for example.

[mattn]

I'll look into it. thanks.

[halfdan]

Is the Socket extension available anywhere? I don't want to reinvent the wheel..

[masuidrive]

https://github.com/iij/mruby provided extended version mruby. it's included TCPSocket and UNIXSocket.
iij said they will make pull request and send to master.

[halfdan]

@masuidrive, from what I understand, this will not be included in mruby as socket handling is not platform independent. Thanks for the link!

[thomthom]

In the example:

VALUE
rsock_new_sock(mrb_state *mrb, struct RClass *c, int fd)
{
  return mrb_obj_value(Data_Wrap_Struct(mrb, c, &sock_data_type, (void*)fd));
}

So that is mapped to the new method - not initialize?

And what does MRB_SET_INSTANCE_TT(c, t) actually do?

I've written Ruby C Extensions before, for normal ruby, but I'm confused to how to do this for mruby. For normal ruby you have separate functions for allocation and initialization.

For instance, this example from http://silverhammermba.github.io/emberb/c/#data - how does one translate that into mruby?

(I've been looking at the source for mruby and the gems it ship, but I struggle to understand what is going on.)

#include <stdlib.h>

void foo_free(int* data)
{
    free(data);
}

VALUE foo_alloc(VALUE self)
{
    /* allocate */
    int* data = malloc(sizeof(int));

    /* wrap */
    return Data_Wrap_Struct(self, NULL, foo_free, data);
}

VALUE foo_m_initialize(VALUE self, VALUE val)
{
    int* data;
    /* unwrap */
    Data_Get_Struct(self, int, data);

    *data = NUM2INT(val);

    return self;
}

void some_func()
{
    /* ... */

    VALUE cFoo = rb_define_class("Foo", rb_cObject);

    rb_define_alloc_func(cFoo, foo_alloc);
    rb_define_method(cFoo, "initialize", foo_m_initialize, 1);

    /* ... */
}

[thomthom]

Looking at random.c:

static mrb_value
mrb_random_init(mrb_state *mrb, mrb_value self)
{
  mrb_value seed;
  mt_state *t;

  /* avoid memory leaks */
  t = (mt_state*)DATA_PTR(self);
  if (t) {
    mrb_free(mrb, t);
  }
  mrb_data_init(self, NULL, &mt_state_type);

  t = (mt_state *)mrb_malloc(mrb, sizeof(mt_state));
  t->mti = N + 1;

  seed = get_opt(mrb);
  seed = mrb_random_mt_srand(mrb, t, seed);
  if (mrb_nil_p(seed)) {
    t->has_seed = FALSE;
  }
  else {
    mrb_assert(mrb_fixnum_p(seed));
    t->has_seed = TRUE;
    t->seed = mrb_fixnum(seed);
  }

  mrb_data_init(self, t, &mt_state_type);

  return self;
}

This one uses mrb_data_init - is there any description of what this does?
There used to be C API docs on the mruby website - but that changed yesterday as I was going trough it. Where they moved?

[cremno]

So that is mapped to the new method - not initialize?

Neither. It's just an internal function. In mruby all C functions implementing Ruby methods must have the type mrb_value (*)(mrb_state*, mrb_value). The first argument is the VM state and the second one is Ruby's self.

And what does MRB_SET_INSTANCE_TT(c, t) actually do?

To tell mruby that instances of class c (struct RClass*) should have the type t (enum mrb_vtype). So it's a(nother) type system to differentiate mrb_values. Similar to CRuby's T_* macros.

I've written Ruby C Extensions before, for normal ruby, but I'm confused to how to do this for mruby. For normal ruby you have separate functions for allocation and initialization.

You have to do the allocations in #initialize.

This one uses mrb_data_init - is there any description of what this does?

It isn't documented yet. But it's just a shortcut for setting both the data pointer and type. See include/mruby/data.h. Those two macros do the same as in CRuby.

[cremno]

how does one translate that into mruby?

https://gist.github.com/cremno/a75a41bee003077d9a01 (untested and it's an example anyway)

[thomthom]

Thank you so much for your response and code snippet.
I tried it - only made a couple of adjustments - but it works: https://gist.github.com/thomthom/1064f8015c9c0491c39f

Btw, checking DATA_GET_PTR and freeing the memory before allocating in initialize - is that something particular to random.c - or something all mruby classes should do? It's unclear to me why the data pointer would have allocated memory at that point.

[cremno]

In Ruby initialize may be called several times. That isn't really mruby-specific but compared to your original foo example it might look like that. However imagine having to allocate memory in initialize because you want to allocate a variable amount of memory.

A helper function might be useful though :

mrb_int *data = (mrb_int*)DATA_PTR(self);
if (data) foo_free(mrb, data);
mrb_data_init(self, NULL, &foo_data_type);

Would become:

mrb_int *data; // for later?
mrb_data_foobar(self, &foo_data_type);

[furunkel]

It's unfortunate that the DATA_PTR macro (and a lot of other macros) aren't prefixed properly, possibly causing name clashes with the host application.
@matz, maybe it would be a good idea to rename these now (and possibly add a compatibility macro for the next few releases), as mruby is still in a relatively early phase. There is mrb_data_get_ptr BTW, which does the same thing as the macro with an additional
type check.

[matz]

It's inherited from CRuby, but maybe we should rename it to RDATA_PTR() to avoid potential name clash and for consistency.

[furunkel]

Well, let's not inherit cruft from CRuby then ? ;)
RDATA_PTR() would be an improvement, though.

[thomthom]

When should one use MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA); ? Is it needed to use DATA_PTR?

[matz]

Whenever you create RData object. To use RDATA_PTR, you have to get RData object first.

[thomthom]

Thanks for confirming.
One more question: DATA_GET_PTR vs DATA_PTR? What is their different usage?

[cremno]

DATA_PTR doesn't check if the type of its mrb_value argument is MRB_TT_DATA and if the DATA_TYPE is a specific mrb_data_type. That's what DATA_GET_PTR does and on failure it raises a TypeError. It's mruby's version of TypedData_Get_Struct.

[thomthom]

I see - so DATA_GET_PTR is to be preferred over DATA_GET_PTR? Or are there reasons to use DATA_PTR? Performance?

[cremno]

Well, if Foo#initialize is called for the first time you can't check for a specific mrb_data_type because it hasn't been set yet (normally Foo.allocate would have done that). So if you know that the type of a mrb_value variable is MRB_TT_DATA and either the data object has the correct data type or you don't care about it then use the DATA_PTR macro.

  // mrb_type(self) == MRB_TT_DATA because of MRB_SET_INSTANCE_TT(klass, MRB_TT_DATA)
  mrb_int *data = DATA_PTR(self);  // DATA_TYPE(self) == NULL; can't and don't need to care
  if (data) foo_free(mrb, data);
  mrb_data_init(self, NULL, &foo_data_type);  // DATA_TYPE(self) = &foo_data_type
  mrb_int val;
  mrb_get_args(mrb, "i", &val);
  data = mrb_malloc(mrb, sizeof *data);
  *data = val;
  DATA_PTR(self) = data;  // don't need to care (correct data type)

If you're writing a method that expects a data object with a specific data type, then you need to use DATA_GET_PTR otherwise some other kind of object (array, string, etc.) may be treated as data object. You don't want that.

There's also DATA_CHECK_GET_PTR however it returns a null pointer instead of raising an error. A use case is the implementation of relational operators like == that shouldn't raise any errors.

Take a look at the source code of the mruby-time gem if you haven't yet. You really don't have to (fully) understand it but it's a decent example how the data API should be used. Maybe somebody else knows a better (simpler) example.

[thomthom]

Thank you very much. I think that going back to mruby-time gem now with this info will make it easier to understand. I will probably make my own "hello world" example for my own testing - I can post back that if you want.