CSC/ECE 517 Spring 2014/ch1 1w1h jg

Ruby libraries to load objects of other languages at run time

Ruby is a dynamic, reflective, object-oriented, general-purpose programming language. It is easy to extend Ruby with new features by writing code in Ruby. But every now and then extending ruby with low-level languages, such asC/C++/Java is also necessary.

Currently, various kinds of languages codes could be invoked from within ruby. The extension for C/C++ and Java are focused here.

Ruby C/C++ extensions<ref>http://java.ociweb.com/mark/NFJS/RubyCExtensions.pdf</ref>

By extending Ruby with C. The C libraries could be used directly in Ruby applications. Ruby could call C codes in three ways: interpreter API, RubyInline, SWIG.

interpreter API

Ruby interpreter is implemented in C, its API can be used and no special API added for interacting with C like Java’s JNI is needed.

The files needed include:

• extconf.rb

Used to generate Makefile

Platform-specific Makefiles for compiling C extensions to Ruby is needed to be generated firstly.

A simple sample is like below:

create a file containing the following, named extconf.rb by convention

require 'mkmf'
extension_name = 'name'
dir_config(extension_name)
create_makefile(extension_name)

And use by running

ruby extconf.rb
make

Then generates

.so under UNIX/Linux
.so under Windows when building with Cygwin
.bundle under Mac OS X

• C File

C codes to be invoked from Ruby

An example Hello.c is shown below

#include <ruby.h>
#include <stdio.h>
// These C functions will be associated with
// methods of a Ruby class on the next page.
static VALUE hello(VALUE self, VALUE arg) {
 char* name = RSTRING(arg)->ptr;
 printf("Hello %s!\n", name);
 return Qnil;
}
static VALUE goodbye(VALUE class) {
 printf("Later dude!\n");
 return Qnil;
}
// This is called when the Ruby interpreter loads this C extension.
// The part after "Init_" is the name of the C extension specified
// in extconf.rb, not the name of the C source file.
void Init_hello() {
 // Create a Ruby module.
 VALUE myModule = rb_define_module("MyModule");
 // Create a Ruby class in this module.
 // rb_cObject is defined in ruby.h
 VALUE myClass =
 rb_define_class_under(myModule, "MyClass", rb_cObject);
 // Add an instance method to the Ruby class.
 int arg_count = 1;
 rb_define_method(myClass, "hello", hello, arg_count);
 // Add a class method to the Ruby class.
 arg_count = 0;
 rb_define_module_function(myClass, "goodbye", goodbye, arg_count);
}

• Ruby File

Ruby code that invokes C code

An example client.rb is shown as below

require 'hello'
include MyModule # so MyClass doesn't need MyModule:: prefix
obj = MyClass.new # MyClass is defined in C
obj.hello('Mark') # calling an object method
MyClass.goodbye # calling a class method

Finally we could build and run

ruby extconf.rb
make
ruby client.rb

Then the output will display as

Hello Mark!
Later dude!