From 635a60c3a88babe9efb17363f59f65e976a4f638 Mon Sep 17 00:00:00 2001 From: Nobuyoshi Nakada Date: Tue, 9 Dec 2025 01:03:14 +0900 Subject: [PATCH] Use typed data APIs --- ext/cool.io/buffer.c | 53 +++++++++++++++++++++---------------- ext/cool.io/cool.io.h | 3 +++ ext/cool.io/iowatcher.c | 2 +- ext/cool.io/loop.c | 42 +++++++++++++++++++---------- ext/cool.io/stat_watcher.c | 8 +++--- ext/cool.io/timer_watcher.c | 10 +++---- ext/cool.io/watcher.c | 47 ++++++++++++++++++++------------ ext/cool.io/watcher.h | 16 +++++------ 8 files changed, 109 insertions(+), 72 deletions(-) diff --git a/ext/cool.io/buffer.c b/ext/cool.io/buffer.c index 0b0a28d..0aa11e8 100644 --- a/ext/cool.io/buffer.c +++ b/ext/cool.io/buffer.c @@ -47,8 +47,8 @@ static VALUE mCoolio = Qnil; static VALUE cCoolio_Buffer = Qnil; static VALUE Coolio_Buffer_allocate(VALUE klass); -static void Coolio_Buffer_mark(struct buffer *); -static void Coolio_Buffer_free(struct buffer *); +static void Coolio_Buffer_mark(void *); +static void Coolio_Buffer_free(void *); static VALUE Coolio_Buffer_default_node_size(VALUE klass); static VALUE Coolio_Buffer_set_default_node_size(VALUE klass, VALUE size); @@ -64,7 +64,7 @@ static VALUE Coolio_Buffer_to_str(VALUE self); static VALUE Coolio_Buffer_read_from(VALUE self, VALUE io); static VALUE Coolio_Buffer_write_to(VALUE self, VALUE io); -static struct buffer *buffer_new(void); +static struct buffer *buffer_init(struct buffer *); static void buffer_clear(struct buffer * buf); static void buffer_free(struct buffer * buf); static void buffer_free_pool(struct buffer * buf); @@ -86,8 +86,6 @@ static int buffer_write_to(struct buffer * buf, int fd); void Init_coolio_buffer() { - VALUE cCoolio_IO; - mCoolio = rb_define_module("Coolio"); cCoolio_Buffer = rb_define_class_under(mCoolio, "Buffer", rb_cObject); rb_define_alloc_func(cCoolio_Buffer, Coolio_Buffer_allocate); @@ -114,21 +112,33 @@ Init_coolio_buffer() rb_define_const(cCoolio_Buffer, "MAX_SIZE", INT2NUM(MAX_BUFFER_SIZE)); } +static const rb_data_type_t Coolio_Buffer_type = { + "Coolio::Buffer", + { + Coolio_Buffer_mark, + Coolio_Buffer_free, + } +}; + static VALUE Coolio_Buffer_allocate(VALUE klass) { - return Data_Wrap_Struct(klass, Coolio_Buffer_mark, Coolio_Buffer_free, buffer_new()); + struct buffer *buf; + VALUE buffer = TypedData_Make_Struct(klass, struct buffer, &Coolio_Buffer_type, buf); + + buffer_init(buf); + return buffer; } static void -Coolio_Buffer_mark(struct buffer * buf) +Coolio_Buffer_mark(void *buf) { /* Naively discard the memory pool whenever Ruby garbage collects */ buffer_free_pool(buf); } static void -Coolio_Buffer_free(struct buffer * buf) +Coolio_Buffer_free(void * buf) { buffer_free(buf); } @@ -188,7 +198,7 @@ Coolio_Buffer_initialize(int argc, VALUE * argv, VALUE self) struct buffer *buf; if (rb_scan_args(argc, argv, "01", &node_size_obj) == 1) { - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); /* * Make sure we're not changing the buffer size after data @@ -212,7 +222,7 @@ static VALUE Coolio_Buffer_clear(VALUE self) { struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); buffer_clear(buf); @@ -229,7 +239,7 @@ static VALUE Coolio_Buffer_size(VALUE self) { struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); return INT2NUM(buf->size); } @@ -244,7 +254,7 @@ static VALUE Coolio_Buffer_empty(VALUE self) { struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); return buf->size > 0 ? Qfalse : Qtrue; } @@ -259,7 +269,7 @@ static VALUE Coolio_Buffer_append(VALUE self, VALUE data) { struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); /* Is this needed? Never seen anyone else do it... */ data = rb_convert_type(data, T_STRING, "String", "to_str"); @@ -278,7 +288,7 @@ static VALUE Coolio_Buffer_prepend(VALUE self, VALUE data) { struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); data = rb_convert_type(data, T_STRING, "String", "to_str"); buffer_prepend(buf, RSTRING_PTR(data), RSTRING_LEN(data)); @@ -304,7 +314,7 @@ Coolio_Buffer_read(int argc, VALUE * argv, VALUE self) int length; struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); if (rb_scan_args(argc, argv, "01", &length_obj) == 1) { length = NUM2INT(length_obj); @@ -340,7 +350,7 @@ Coolio_Buffer_read_frame(VALUE self, VALUE data, VALUE mark) char mark_c = (char) NUM2INT(mark); struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); if (buffer_read_frame(buf, data, mark_c)) { return Qtrue; @@ -361,7 +371,7 @@ Coolio_Buffer_to_str(VALUE self) VALUE str; struct buffer *buf; - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); str = rb_str_new(0, buf->size); buffer_copy(buf, RSTRING_PTR(str), buf->size); @@ -388,7 +398,7 @@ Coolio_Buffer_read_from(VALUE self, VALUE io) OpenFile *fptr; #endif - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); io = rb_convert_type(io, T_FILE, "IO", "to_io"); GetOpenFile(io, fptr); rb_io_set_nonblock(fptr); @@ -419,7 +429,7 @@ Coolio_Buffer_write_to(VALUE self, VALUE io) OpenFile *fptr; #endif - Data_Get_Struct(self, struct buffer, buf); + TypedData_Get_Struct(self, struct buffer, &Coolio_Buffer_type, buf); io = rb_convert_type(io, T_FILE, "IO", "to_io"); GetOpenFile(io, fptr); rb_io_set_nonblock(fptr); @@ -438,11 +448,8 @@ Coolio_Buffer_write_to(VALUE self, VALUE io) /* Create a new buffer */ static struct buffer * -buffer_new(void) +buffer_init(struct buffer *buf) { - struct buffer *buf; - - buf = (struct buffer *) xmalloc(sizeof(struct buffer)); buf->head = buf->tail = buf->pool_head = buf->pool_tail = 0; buf->size = 0; buf->node_size = default_node_size; diff --git a/ext/cool.io/cool.io.h b/ext/cool.io/cool.io.h index 025e15d..4510858 100644 --- a/ext/cool.io/cool.io.h +++ b/ext/cool.io/cool.io.h @@ -68,4 +68,7 @@ void Init_coolio_timer_watcher(); void Init_coolio_stat_watcher(); void Init_coolio_utils(); +struct Coolio_Loop *Coolio_Loop_ptr(VALUE loop); +struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher); + #endif diff --git a/ext/cool.io/iowatcher.c b/ext/cool.io/iowatcher.c index f723cfa..86280df 100644 --- a/ext/cool.io/iowatcher.c +++ b/ext/cool.io/iowatcher.c @@ -82,7 +82,7 @@ static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self) else rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str); - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); io = rb_convert_type(io, T_FILE, "IO", "to_io"); watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback; diff --git a/ext/cool.io/loop.c b/ext/cool.io/loop.c index 7761f4b..7bd1bbc 100644 --- a/ext/cool.io/loop.c +++ b/ext/cool.io/loop.c @@ -14,8 +14,7 @@ static VALUE mCoolio = Qnil; static VALUE cCoolio_Loop = Qnil; static VALUE Coolio_Loop_allocate(VALUE klass); -static void Coolio_Loop_mark(struct Coolio_Loop *loop); -static void Coolio_Loop_free(struct Coolio_Loop *loop); +static void Coolio_Loop_free(void *data); static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags); static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self); @@ -47,9 +46,26 @@ void Init_coolio_loop() rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0); } +static const rb_data_type_t Coolio_Loop_type = { + "Coolio::Loop", + { + NULL, + Coolio_Loop_free, + }, +}; + +struct Coolio_Loop *Coolio_Loop_ptr(VALUE self) +{ + struct Coolio_Loop *loop; + + TypedData_Get_Struct(self, struct Coolio_Loop, &Coolio_Loop_type, loop); + return loop; +} + static VALUE Coolio_Loop_allocate(VALUE klass) { - struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop)); + struct Coolio_Loop *loop; + VALUE obj = TypedData_Make_Struct(klass, struct Coolio_Loop, &Coolio_Loop_type, loop); loop->ev_loop = 0; ev_init(&loop->timer, Coolio_Loop_timeout_callback); @@ -58,15 +74,13 @@ static VALUE Coolio_Loop_allocate(VALUE klass) loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE; loop->eventbuf = (struct Coolio_Event *)xmalloc(sizeof(struct Coolio_Event) * DEFAULT_EVENTBUF_SIZE); - return Data_Wrap_Struct(klass, Coolio_Loop_mark, Coolio_Loop_free, loop); + return obj; } -static void Coolio_Loop_mark(struct Coolio_Loop *loop) +static void Coolio_Loop_free(void *data) { -} + struct Coolio_Loop *loop = data; -static void Coolio_Loop_free(struct Coolio_Loop *loop) -{ if(!loop->ev_loop) return; @@ -80,7 +94,7 @@ static void Coolio_Loop_free(struct Coolio_Loop *loop) static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags) { struct Coolio_Loop *loop_data; - Data_Get_Struct(self, struct Coolio_Loop, loop_data); + loop_data = Coolio_Loop_ptr(self); if(loop_data->ev_loop) rb_raise(rb_eRuntimeError, "loop already initialized"); @@ -98,8 +112,8 @@ void Coolio_Loop_process_event(VALUE watcher, int revents) /* The Global VM lock isn't held right now, but hopefully * we can still do this safely */ - Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); - Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); + watcher_data = Coolio_Watcher_ptr(watcher); + loop_data = Coolio_Loop_ptr(watcher_data->loop); /* Well, what better place to explain how this all works than * where the most wonky and convoluted stuff is going on! @@ -184,7 +198,7 @@ static VALUE Coolio_Loop_run_once(int argc, VALUE *argv, VALUE self) rb_raise(rb_eArgError, "time interval must be positive"); } - Data_Get_Struct(self, struct Coolio_Loop, loop_data); + loop_data = Coolio_Loop_ptr(self); assert(loop_data->ev_loop && !loop_data->events_received); @@ -222,7 +236,7 @@ static VALUE Coolio_Loop_run_nonblock(VALUE self) struct Coolio_Loop *loop_data; VALUE nevents; - Data_Get_Struct(self, struct Coolio_Loop, loop_data); + loop_data = Coolio_Loop_ptr(self); assert(loop_data->ev_loop && !loop_data->events_received); @@ -247,7 +261,7 @@ static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data) if(loop_data->eventbuf[i].watcher == Qnil) continue; - Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(loop_data->eventbuf[i].watcher); watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents); } } diff --git a/ext/cool.io/stat_watcher.c b/ext/cool.io/stat_watcher.c index 28221e7..12aa088 100644 --- a/ext/cool.io/stat_watcher.c +++ b/ext/cool.io/stat_watcher.c @@ -89,7 +89,7 @@ static VALUE Coolio_StatWatcher_initialize(int argc, VALUE *argv, VALUE self) path = rb_String(path); rb_iv_set(self, "@path", path); - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); watcher_data->dispatch_callback = Coolio_StatWatcher_dispatch_callback; ev_stat_init( @@ -119,8 +119,8 @@ static VALUE Coolio_StatWatcher_attach(VALUE self, VALUE loop) if(!rb_obj_is_kind_of(loop, cCoolio_Loop)) rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop))); - Data_Get_Struct(loop, struct Coolio_Loop, loop_data); - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + loop_data = Coolio_Loop_ptr(loop); + watcher_data = Coolio_Watcher_ptr(self); if(watcher_data->loop != Qnil) Coolio_StatWatcher_detach(self); @@ -206,7 +206,7 @@ static void Coolio_StatWatcher_libev_callback(struct ev_loop *ev_loop, struct ev static void Coolio_StatWatcher_dispatch_callback(VALUE self, int revents) { struct Coolio_Watcher *watcher_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); VALUE previous_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.prev); VALUE current_statdata = Coolio_StatInfo_build(&watcher_data->event_types.ev_stat.attr); diff --git a/ext/cool.io/timer_watcher.c b/ext/cool.io/timer_watcher.c index fc5a12f..fcea310 100644 --- a/ext/cool.io/timer_watcher.c +++ b/ext/cool.io/timer_watcher.c @@ -68,7 +68,7 @@ static VALUE Coolio_TimerWatcher_initialize(int argc, VALUE *argv, VALUE self) rb_iv_set(self, "@interval", interval); rb_iv_set(self, "@repeating", repeating); - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); watcher_data->dispatch_callback = Coolio_TimerWatcher_dispatch_callback; ev_timer_init( @@ -98,8 +98,8 @@ static VALUE Coolio_TimerWatcher_attach(VALUE self, VALUE loop) if(!rb_obj_is_kind_of(loop, cCoolio_Loop)) rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop))); - Data_Get_Struct(loop, struct Coolio_Loop, loop_data); - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + loop_data = Coolio_Loop_ptr(loop); + watcher_data = Coolio_Watcher_ptr(self); if(watcher_data->loop != Qnil) Coolio_TimerWatcher_detach(self); @@ -180,12 +180,12 @@ static VALUE Coolio_TimerWatcher_reset(VALUE self) struct Coolio_Watcher *watcher_data; struct Coolio_Loop *loop_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); if(watcher_data->loop == Qnil) rb_raise(rb_eRuntimeError, "not attached to a loop"); - Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); + loop_data = Coolio_Loop_ptr(watcher_data->loop); ev_timer_again(loop_data->ev_loop, &watcher_data->event_types.ev_timer); diff --git a/ext/cool.io/watcher.c b/ext/cool.io/watcher.c index 249a055..2eeda89 100644 --- a/ext/cool.io/watcher.c +++ b/ext/cool.io/watcher.c @@ -13,8 +13,7 @@ static VALUE mCoolio = Qnil; static VALUE cCoolio_Watcher = Qnil; static VALUE Coolio_Watcher_allocate(VALUE klass); -static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher); -static void Coolio_Watcher_free(struct Coolio_Watcher *watcher); +static void Coolio_Watcher_mark(void *data); static VALUE Coolio_Watcher_initialize(VALUE self); static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop); @@ -53,27 +52,41 @@ void Init_coolio_watcher() rb_define_method(cCoolio_Watcher, "enabled?", Coolio_Watcher_enabled, 0); } +static const rb_data_type_t Coolio_Watcher_type = { + "Coolio::Watcher", + { + Coolio_Watcher_mark, + RUBY_DEFAULT_FREE, + }, +}; + +struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher) +{ + struct Coolio_Watcher *watcher_data; + + TypedData_Get_Struct(watcher, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data); + return watcher_data; +} + static VALUE Coolio_Watcher_allocate(VALUE klass) { - struct Coolio_Watcher *watcher_data = (struct Coolio_Watcher *)xmalloc(sizeof(struct Coolio_Watcher)); + struct Coolio_Watcher *watcher_data; + VALUE watcher = TypedData_Make_Struct(klass, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data); watcher_data->loop = Qnil; watcher_data->enabled = 0; - return Data_Wrap_Struct(klass, Coolio_Watcher_mark, Coolio_Watcher_free, watcher_data); + return watcher; } -static void Coolio_Watcher_mark(struct Coolio_Watcher *watcher_data) +static void Coolio_Watcher_mark(void *data) { + struct Coolio_Watcher *watcher_data = data; + if(watcher_data->loop != Qnil) rb_gc_mark(watcher_data->loop); } -static void Coolio_Watcher_free(struct Coolio_Watcher *watcher_data) -{ - xfree(watcher_data); -} - static VALUE Coolio_Watcher_initialize(VALUE self) { rb_raise(rb_eRuntimeError, "watcher base class should not be initialized directly"); @@ -91,7 +104,7 @@ static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop) VALUE loop_watchers, active_watchers; struct Coolio_Watcher *watcher_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); watcher_data->enabled = 1; loop_watchers = rb_iv_get(loop, "@watchers"); @@ -132,7 +145,7 @@ static VALUE Coolio_Watcher_detach(VALUE self) VALUE loop_watchers; int i; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); if(watcher_data->loop == Qnil) rb_raise(rb_eRuntimeError, "not attached to a loop"); @@ -155,7 +168,7 @@ static VALUE Coolio_Watcher_detach(VALUE self) watcher_data->enabled = 0; - Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); + loop_data = Coolio_Loop_ptr(watcher_data->loop); /* Iterate through the events in the loop's event buffer. If there * are any pending events from this watcher, mark them NULL. The @@ -182,7 +195,7 @@ static VALUE Coolio_Watcher_detach(VALUE self) static VALUE Coolio_Watcher_enable(VALUE self) { struct Coolio_Watcher *watcher_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); if(watcher_data->enabled) rb_raise(rb_eRuntimeError, "already enabled"); @@ -208,7 +221,7 @@ static VALUE Coolio_Watcher_enable(VALUE self) static VALUE Coolio_Watcher_disable(VALUE self) { struct Coolio_Watcher *watcher_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); if(!watcher_data->enabled) rb_raise(rb_eRuntimeError, "already disabled"); @@ -234,7 +247,7 @@ static VALUE Coolio_Watcher_evloop(VALUE self) { struct Coolio_Watcher *watcher_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); return watcher_data->loop; } @@ -258,7 +271,7 @@ static VALUE Coolio_Watcher_attached(VALUE self) static VALUE Coolio_Watcher_enabled(VALUE self) { struct Coolio_Watcher *watcher_data; - Data_Get_Struct(self, struct Coolio_Watcher, watcher_data); + watcher_data = Coolio_Watcher_ptr(self); return watcher_data->enabled ? Qtrue : Qfalse; } diff --git a/ext/cool.io/watcher.h b/ext/cool.io/watcher.h index 89d3514..225e44c 100644 --- a/ext/cool.io/watcher.h +++ b/ext/cool.io/watcher.h @@ -14,8 +14,8 @@ if(!rb_obj_is_kind_of(loop, cCoolio_Loop)) \ rb_raise(rb_eArgError, "expected loop to be an instance of Coolio::Loop, not %s", RSTRING_PTR(rb_inspect(loop))); \ \ - Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \ - Data_Get_Struct(loop, struct Coolio_Loop, loop_data); \ + watcher_data = Coolio_Watcher_ptr(watcher); \ + loop_data = Coolio_Loop_ptr(loop); \ \ if(watcher_data->loop != Qnil) \ detach_func(watcher); \ @@ -28,12 +28,12 @@ struct Coolio_Watcher *watcher_data; \ struct Coolio_Loop *loop_data; \ \ - Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \ + watcher_data = Coolio_Watcher_ptr(watcher); \ \ if(watcher_data->loop == Qnil) \ rb_raise(rb_eRuntimeError, "not attached to a loop"); \ \ - Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \ + loop_data = Coolio_Loop_ptr(watcher_data->loop); \ \ ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type); \ rb_call_super(0, 0) @@ -42,14 +42,14 @@ struct Coolio_Watcher *watcher_data; \ struct Coolio_Loop *loop_data; \ \ - Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \ + watcher_data = Coolio_Watcher_ptr(watcher); \ \ if(watcher_data->loop == Qnil) \ rb_raise(rb_eRuntimeError, "not attached to a loop"); \ \ rb_call_super(0, 0); \ \ - Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \ + loop_data = Coolio_Loop_ptr(watcher_data->loop); \ \ ev_##watcher_type##_start(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type) @@ -57,14 +57,14 @@ struct Coolio_Watcher *watcher_data; \ struct Coolio_Loop *loop_data; \ \ - Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data); \ + watcher_data = Coolio_Watcher_ptr(watcher); \ \ if(watcher_data->loop == Qnil) \ rb_raise(rb_eRuntimeError, "not attached to a loop"); \ \ rb_call_super(0, 0); \ \ - Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data); \ + loop_data = Coolio_Loop_ptr(watcher_data->loop); \ \ ev_##watcher_type##_stop(loop_data->ev_loop, &watcher_data->event_types.ev_##watcher_type)