// ctest.c           
#include <stdio.h>

int testfort(int *); // Equivalent to int testfort_(int*);

int main() {
  int i = 10;
  int j;

  j = testfort(&i); // NOT equivalent to testfort_(&i) unless we omit bind(c)
  printf("hi %d\n", j);

  return 0;
}
              

The C program calling Fortran functions usually appends an underscore to function names, but when using bind(c, name="..."), this underscore is no longer used. The function prototype works with or without the underscore; (i.e. int testfort_(int *); has the same result.)

gcc -c ctest.c    # Compile C driver into ctest.o
gfortran -c ftest.f08    # Compile F function into ftest.o
gcc -o c_calls_f ctest.o ftest.o -lgfortran # Link together into ./c_calls_f
              

[cameron@ghast-l test_bindc]$ ./c_calls_f
hi 20
              

Testing this function yields our nonsensical output, verifying that C/Fortran are communicating.

require './testmodule.so'
include TestModule
called_by_ruby()
              

The Ruby driver is blissfully simple: Simply require the shared object file generated from your C compiler, load the module defined using ruby.h constructs, and call the method in question.

$ rake rebuild # Depends on Ruby/C/Fortran "Bridge" build script
$ gcc -shared -o testmodule.so ctest.o -lruby # links into testmodule.so
              

Use your handy-dandy build script to take care of remembering the many compiler options required; See the build script section above for tips on getting everything set up for compilation. Then use your C compiler to link the C file into the shared object expected by Ruby against Ruby libraries.

[cameron@ghast-l test_cext]$ pry
[1] pry(main)> require './testmodule.so'
=> true
[2] pry(main)> include TestModule
=> Object
[3] pry(main)> called_by_ruby
Hello, Ruby. (From C)
=> false
[4] pry(main)> called_by_ruby()
Hello, Ruby. (From C)
=> false
              

The easiest way to determine whether your C extension is working is to boot up Pry (or, heaven forbid, irb) and walk through the steps manually.

#include <stdio.h>
#include "ruby.h"

int sieve_of_eratosthenes(int *, int *);
VALUE SieveModule = Qnil;

VALUE method_invoke_sieve(VALUE self, VALUE iterations) {
  int output [iterations], ii;
  VALUE result;
  int c_iterations = NUM2INT(iterations);
  if (c_iterations) {
    sieve_of_eratosthenes(&c_iterations, output);
  }

  result = rb_ary_new();
  for(ii=0; ii<c_iterations; ii++) {
    int prime = ii + 1;
    rb_ary_push(result, INT2FIX(output[prime]));
  }
  return result;
}

void Init_sievemodule() {
  SieveModule = rb_define_module("SieveModule");
  rb_define_method(SieveModule, "invoke_sieve", method_invoke_sieve, 1);
}
              

This C interface is somewhat more complicated than the previous examples, since now we're juggling datatypes and conversion specifications for three languages at once. This program exposes a Ruby module and method that accepts data from Ruby and converts it into a form usable by C. We then push the data inside C datatypes to the Fortran function, which handles the conversion.

As mentioned before, in order to return an array from a Fortran procedure to C, you must use subroutines instead of functions. After this, the array data is loaded into a Ruby array using the functions in "ruby.h"

require './sievemodule.so'
include SieveModule


iterations = 1000
result = invoke_sieve(iterations)


puts "Primes under #{iterations}:"
result.each_with_index do |item, ii|;
  if result[ii] == 1 # Then value is a prime; Print it out.
    print ii + 2
    print " "
  else 
    # Value is composite.
  end
end
puts "\n"
              

Ruby script is as simple as ever, with a little snippet added to print out prime numbers. (Remember that what's getting passed back is an array of 1 and 0 integers indicating prime status rather than a list of prime numbers or a list of bools.)

[cameron@ghast-l test_bindfcr]$ rake rebuild
[cameron@ghast-l test_bindfcr]$ gcc -shared -o sievemodule.so ctest.o sieve_e.o -lgfortran -lm -lruby
[cameron@ghast-l test_bindfcr]$ ruby rtest.rb 
Primes under 1000:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997
              

This time, link everything into a shared object suitable for loading into Ruby. Don't forget to include Fortran, Ruby and any other relevant libraries.