cgen 0.16.0

data/examples/inherit-example.rb

@@ -0,0 +1,26 @@
+require 'cgen/cshadow'
+
+class Parent
+  include CShadow
+  
+  shadow_attr_accessor :ruby_str => String
+  shadow_attr_accessor :c_int => "int c_int"
+end
+
+class Child < Parent
+  shadow_attr_accessor :obj => Object # VALUE type
+end
+
+Parent.commit
+  # we're done adding attrs and methods, so make.
+
+x = Child.new
+x.ruby_str = "foo"
+x.obj = [1,2,3]
+x.c_int = 3
+
+p x
+# ==> #<Child:0xb7ba96f4 ruby_str="foo", c_int=3, obj=[1, 2, 3]>
+
+CShadow.allow_yaml
+y x

data/examples/inherit-example.txt

@@ -0,0 +1,80 @@
+
+The generated code looks, in part, as follows. Note that CGenerator/CShadow produces quite readable C code. In the Parent.h header file we have:
+
+  typedef struct Parent_Shadow {
+      VALUE self;
+      VALUE ruby_str; // String;
+      int c_int;
+  } Parent_Shadow;
+
+  typedef struct Child_Shadow {
+
+      /* Parent_Shadow members */
+      VALUE self;
+      VALUE ruby_str; // String;
+      int c_int;
+
+      VALUE obj; // Object;
+  } Child_Shadow;
+
+Again, members are duplicated, which would be awful if you wanted to manually maintain the code, but who wants to do that :-)
+
+In the Parent.c file, we have:
+
+  void mark_Parent_Shadow(Parent_Shadow *shadow)
+  {
+      rb_gc_mark((void *)shadow->self);
+      rb_gc_mark((void *)shadow->ruby_str);
+  }
+
+  void mark_Child_Shadow(Child_Shadow *shadow)
+  {
+      rb_gc_mark((void *)shadow->self);
+      rb_gc_mark((void *)shadow->ruby_str);
+      rb_gc_mark((void *)shadow->obj);
+  }
+
+and similarly for the free functions, persistence functions, etc. The #new method generated by CShadow is where rb_obj_call_init() gets called. Note that initialization of shadow attributes is customizable.
+
+  VALUE new_module_Child_singleton_method(int argc, VALUE *argv, VALUE self)
+  {
+      VALUE object;
+      Child_Shadow *shadow;
+
+      object = Data_Make_Struct(self,
+                 Child_Shadow,
+                 mark_Child_Shadow,
+                 free_Child_Shadow,
+                 shadow);
+      shadow->self = object;
+
+      shadow->ruby_str = Qnil;
+      shadow->obj = Qnil;
+
+      rb_obj_call_init(object, argc, argv);
+
+      return object;
+  }
+
+The #ruby_str= method only needs to be defined for Parent, because, of course, Ruby itself handles inheritance of methods. Note the type checking, which is done for the ruby_str member but not for the obj member.
+
+  VALUE ruby__str_equals_module_Parent_method(int argc, VALUE *argv, VALUE self)
+  {
+      VALUE arg;
+      Parent_Shadow *shadow;
+
+      rb_scan_args(argc, argv, "1", &arg);
+
+      if (!NIL_P(arg) &&
+          rb_obj_is_kind_of(arg, module_String) != Qtrue)
+        rb_raise(module_TypeError,
+                 "argument arg declared String but passed %s.",
+                 STR2CSTR(rb_funcall(
+                   rb_funcall(arg, ID_type, 0),
+                   ID_to__s, 0)));
+
+      Data_Get_Struct(self, Parent_Shadow, shadow);
+      shadow->ruby_str = arg;
+      return arg;
+  }
+

data/examples/instance-eval.rb

@@ -0,0 +1,66 @@
+require 'cgen/cshadow'
+
+class A
+  include CShadow
+  
+  define_c_method :instance_eval_proc do
+    c_array_args {
+      required :pr
+      typecheck :pr => Proc
+    }
+    body %{
+      printf("instance_eval_proc\\n");
+    }
+    returns "rb_iterate(my_instance_eval, shadow->self, call_block, pr)"
+  end
+  
+  fn = shadow_library_source_file.define :my_instance_eval
+  fn.instance_eval do
+    arguments "VALUE obj"
+    return_type "VALUE"
+    body %{
+      printf("my_instance_eval\\n");
+    }
+    returns "rb_obj_instance_eval(0, 0, obj)"
+  end
+  
+  fn = shadow_library_source_file.define :call_block
+  fn.instance_eval do
+    arguments "VALUE arg1", "VALUE block"
+    return_type "VALUE"
+    body %{
+      printf("call_block\\n");
+    }
+    returns "rb_funcall(block, #{declare_symbol :call}, 0)"
+  end  
+
+end
+
+Dir.chdir "tmp" do
+  A.commit
+end
+
+a = A.new
+pr = proc { "self is %p" % self }
+
+p a.instance_eval(&pr)
+puts '---'
+p a.instance_eval_proc(pr)
+
+__END__
+
+
+
+static VALUE my_instance_eval(VALUE obj)
+{
+    return rb_obj_instance_eval(0, 0, obj);
+}
+
+static VALUE call_block(VALUE arg1, VALUE block)
+{
+    return rb_funcall(block, ID_call, 0);
+}
+
+//...
+    rb_iterate(my_instance_eval, obj, call_block, pr);
+

data/examples/ivset.rb

@@ -0,0 +1,55 @@
+class Foo
+  def initialize
+    @a = 1
+    @b = 2
+  end
+
+  def inc_iv
+    [:@a, :@b].each { |iv|
+      eval "#{iv} += 1"
+    }
+  end
+end
+
+require 'cgen/cshadow'
+
+class Bar
+  include CShadow
+  
+  def initialize
+    @a = 1
+    @b = 2
+  end
+  
+  def inc_iv
+    [:@a, :@b].each { |iv|
+      iv = iv
+      set_iv(iv, get_iv(iv) + 1)
+    }
+  end
+  
+  define_method :set_iv do
+    arguments :attr, :value
+    body %{
+      rb_ivar_set(shadow->self, rb_to_id(attr), value);
+    }
+    returns %{shadow->self}
+  end
+  private :set_iv
+  
+  define_method :get_iv do
+    arguments :attr
+    returns %{rb_ivar_get(shadow->self, rb_to_id(attr))}
+  end
+  private :get_iv
+  
+  def inspect
+    "<Bar: a = #{@a}, b = #{@b}>"
+  end
+end
+
+Bar.commit # write to .c files, make, and require
+
+bar = Bar.new
+bar.inc_iv
+p bar

data/examples/marshal-test.rb

@@ -0,0 +1,19 @@
+require 'cgen/cshadow'
+
+class MarshalTest
+  include CShadow
+  
+  shadow_attr_accessor :x => Object
+end
+
+Dir.mkdir "tmp" rescue SystemCallError
+Dir.chdir "tmp"
+
+MarshalTest.commit
+
+mt = MarshalTest.new
+
+mt.x = "foo"
+p mt.x
+
+p Marshal.dump mt

data/examples/matrix.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'cgen/cshadow'
+
+class MyMatrix
+  include CShadow
+
+  shadow_attr_reader :rows => "int rows", :cols => "int cols"
+  shadow_attr :matrix => "double *matrix"
+
+  define_c_method(:initialize) {
+    c_array_args {
+      required :rows, :cols
+      typecheck :rows => Fixnum, :cols => Fixnum
+    }
+    declare :size => "int size"
+    body %{
+      shadow->rows = FIX2INT(rows);
+      shadow->cols = FIX2INT(cols);
+      
+      if (shadow->rows <= 0)
+        rb_raise(#{declare_class ArgumentError}, "Rows must be positive.");
+      if (shadow->cols <= 0)
+        rb_raise(#{declare_class ArgumentError}, "Cols must be positive.");
+      
+      size = shadow->rows * shadow->cols;
+      shadow->matrix = ALLOC_N(double, size);
+      memset(shadow->matrix, 0, size * sizeof(double));
+    }
+  }
+  
+  define_c_method(:[]) {
+    arguments :i, :j
+    declare :ii => "int ii", :jj => "int jj"
+    body %{
+      ii = NUM2INT(i);
+      jj = NUM2INT(j);
+
+      if (ii < 0 || ii >= shadow->rows)
+        rb_raise(#{declare_class IndexError},
+                 "Row index %d out of range [0, %d]",
+                 ii, shadow->rows - 1);
+
+      if (jj < 0 || jj >= shadow->cols)
+        rb_raise(#{declare_class IndexError},
+                 "Column index %d out of range [0, %d]",
+                 jj, shadow->cols - 1);
+    }
+    returns "rb_float_new(shadow->matrix[ii * shadow->cols + jj])"
+  }
+
+  define_c_method(:[]=) {
+    arguments :i, :j, :x
+    declare :ii => "int ii", :jj => "int jj", :xx => "double xx"
+    body %{
+      ii = NUM2INT(i);
+      jj = NUM2INT(j);
+      xx = NUM2DBL(x);
+
+      if (ii < 0 || ii >= shadow->rows)
+        rb_raise(#{declare_class IndexError},
+                 "Row index %d out of range 0..%d",
+                 ii, shadow->rows - 1);
+
+      if (jj < 0 || jj >= shadow->cols)
+        rb_raise(#{declare_class IndexError},
+                 "Column index %d out of range 0..%d",
+                 jj, shadow->cols - 1);
+
+      shadow->matrix[ii * shadow->cols + jj] = xx;
+    }
+    returns "x"
+  }
+end
+
+require 'ftools'
+dir = File.join("tmp", RUBY_VERSION)
+File.mkpath dir
+Dir.chdir dir
+
+MyMatrix.commit
+
+m = MyMatrix.new 5, 2
+m[3,1] = 8.2e+13
+puts m[3,1]
+puts m[3,0]
+begin
+  puts m[3,2]
+rescue IndexError
+  puts "Caught an IndexError: m[3,2] is out of range."
+end

data/examples/modular-def.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+# This example shows how to factor out definitions into a module. The
+# only additional library code needed is the following:
+
+module ModuleMethodSaver
+  def method_missing(meth, *args, &block)
+    @saved ||= []
+    @saved << [meth, args, block]
+  end
+  
+  def included(m)
+    if @saved
+      @saved.each do |meth, args, block|
+        m.send(meth, *args, &block)
+      end
+    end
+  end
+end
+
+
+require 'cgen/cshadow'
+
+module ComplexStuff
+  extend ModuleMethodSaver
+
+  shadow_attr_accessor :re => "double re", :im => "double im"
+
+  def initialize re, im
+    self.re = re
+    self.im = im
+  end
+
+  define_c_method(:abs) {
+    include "<math.h>"
+    returns "rb_float_new(sqrt(pow(shadow->re, 2) + pow(shadow->im, 2)))"
+  }
+
+  define_c_method(:mul!) {
+    arguments :other
+    declare :other_shadow => "MyComplex_Shadow *other_shadow"
+    declare :new_re => "double new_re", :new_im => "double new_im"
+    body %{
+      switch (TYPE(other)) {
+        case T_FIXNUM:  shadow->re *= FIX2INT(other);
+                        shadow->im *= FIX2INT(other); break;
+        case T_FLOAT:   shadow->re *= NUM2DBL(other);
+                        shadow->im *= NUM2DBL(other); break;
+        default:
+          if (rb_obj_is_kind_of(other, #{declare_class MyComplex}) ==
+              Qtrue) {
+            Data_Get_Struct(other, MyComplex_Shadow, other_shadow);
+            new_re = shadow->re * other_shadow->re -
+                     shadow->im * other_shadow->im;
+            new_im = shadow->re * other_shadow->im +
+                     shadow->im * other_shadow->re;
+            shadow->re = new_re;
+            shadow->im = new_im;
+          }
+          else
+            rb_raise(#{declare_class ArgumentError},
+                     "Argument to mul! is not numeric.");
+      }
+    }
+    returns "self"
+  }
+end
+
+class MyComplex < Numeric
+  include CShadow
+  include ComplexStuff
+end
+
+require 'ftools'
+dir = File.join("tmp", RUBY_VERSION)
+File.mkpath dir
+Dir.chdir dir
+
+MyComplex.commit
+
+z = MyComplex.new 5, 1.3
+puts z.abs
+z.mul! 10
+p [z.re, z.im]
+w = MyComplex.new 7.9, -1.2
+z.mul! w
+p [z.re, z.im]

data/examples/objattr.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require 'cgen/cshadow'
+
+SAME_LIBRARY = true
+
+class A
+  include CShadow
+  shadow_attr_accessor :obj => Object, :sym => Symbol
+end
+
+class B
+  include CShadow
+  
+  if SAME_LIBRARY
+    shadow_library A                # in the same lib as A
+    shadow_library_file 'B'         # but in a different file
+  else  
+    # different lib, but connected with a '#include'
+    shadow_library_include_file.include '../A/A.h'
+  end
+  
+  shadow_attr_accessor :a => [A]
+
+  def initialize
+    self.a = A.new
+    self.a.sym = :something
+  end
+end
+
+require 'ftools'
+dir = File.join("tmp", RUBY_VERSION)
+File.mkpath dir
+Dir.chdir dir
+
+A.commit
+unless SAME_LIBRARY
+  B.commit
+end
+
+p B.new.a.sym
+
+A.shadow_library.make 'distclean'
+unless SAME_LIBRARY
+  B.shadow_library.make 'distclean'
+end