cgen 0.16.0

data/examples/ctest.rb

@@ -0,0 +1,34 @@
+require 'cshadow.rb'
+
+class Test
+  include CShadow
+
+  define_class_method :foo do
+    body %{
+      typedef struct Bar {
+        struct Foo *foo;
+      } Bar;
+      typedef struct Foo {
+        int x;
+      } Foo;
+      
+      Bar bar;
+      char s[20], buf[100];
+      
+      bar.foo->x;
+      
+      {int *x = 0; printf("%d", *x);}
+      
+      sscanf("foo bar", "%s", s);
+      while (gets(buf))
+        printf("%s\n", s);
+    }
+  end
+end
+
+Dir.mkdir "tmp" rescue SystemCallError
+Dir.chdir "tmp"
+
+Test.commit
+
+Test.foo

data/examples/ctest2.rb

@@ -0,0 +1,32 @@
+require 'cshadow.rb'
+require 'misc/irb-session'
+
+class Dummy
+  def initialize value
+    @value = value
+  end
+end
+
+class Test2
+  include CShadow
+  
+  shadow_attr_accessor :ary => Dummy
+  attr_accessor :x
+  
+  def initialize
+    self.ary = Dummy.new 1
+    self.x = Dummy.new 2
+  end
+end
+
+Dir.mkdir "tmp" rescue SystemCallError
+Dir.chdir "tmp"
+
+Test2.commit
+
+t = Test2.new
+GC.start
+
+$z = GC.reachability_paths t.x
+
+IRB.start_session([])

data/examples/ctest3.rb

@@ -0,0 +1,179 @@
+require 'cshadow.rb'
+
+class Object
+  def insteval_proc pr
+    instance_eval &pr
+  end
+end
+
+class TestSuper
+  def foo arg
+    p "foo #{arg}"
+  end
+  
+  class << self
+    def class_meth
+      puts "Class method!"
+    end
+  end
+end
+
+class Test < TestSuper
+  include CShadow
+
+#  shadow_library.declare :typedefs =>  %{
+#      typedef struct zap *T1;
+#      typedef int *T2;
+#      struct zap {
+#        double z;
+#      };
+#  }
+  
+#  shadow_library_include_file.declare :foo => "extern int foo"
+#  shadow_library.declare :foo => "int foo"
+  
+  shadow_attr_accessor :ary => Array
+  
+  def initialize
+    self.ary = []
+  end
+#  protected :zap
+  
+  shadow_library.include "<assert.h>"
+  shadow_library.include "<math.h>"
+  
+  define_method :bar do
+    body %{
+      rb_funcall(RBASIC(shadow->self)->klass, #{declare_symbol :class_meth}, 0);
+    }
+  end
+  
+  define_class_method :foo do
+    arguments :from_array
+    body %{
+      enum zap {zow, zim=3, zug=zow+zim, zwip} zzz;
+      typedef struct {
+        short s;
+        unsigned a : 4;
+        enum zap b : 4;
+//        enum zap c : 15;
+//        unsigned d : 1;
+        unsigned e : 5;
+        unsigned f : 3;
+      } bitfld;
+      struct {
+        struct {} v0;
+        struct {} v1;
+        struct {} v2;
+        int x;
+      } z;
+      int zz = 123;
+      VALUE pi;
+      
+      inline VALUE fn(VALUE v) { 
+        printf("The value is %d.\\n", NUM2LONG(v));
+      }
+      
+      VALUE fnie(VALUE arg, VALUE my_proc) {
+        rb_funcall(my_proc, #{declare_symbol :call}, 0);
+      }
+      
+typedef void (*Flow)(void *);  // evaluates one variable
+typedef struct {
+  unsigned    d_tick    : 16; // last discrete tick at which flow computed
+  unsigned    rk_level  :  3; // last rk level at which flow was computed
+  unsigned    algebraic :  1; // should compute flow when inputs change?
+  unsigned    nested    :  1; // to catch circular evaluation
+  Flow        flow;           // cached flow function of current state
+  double      value_0;        // value during discrete step
+  double      value_1;        // value at steps of Runge-Kutta
+  double      value_2;
+  double      value_3;
+} ContVar;
+
+typedef struct T_o_ContState_Shadow {
+    
+    /* RedShift_o_Component_o_ContState_Shadow members */
+    long self;
+    long foo;
+  
+    struct {} begin_vars __attribute__ ((aligned (8)));
+     
+    ContVar x;
+} T_o_ContState_Shadow;
+
+T_o_ContState_Shadow shadow;
+
+      printf("sizeof(z) = %d\\n", sizeof(z));
+      printf("sizeof(ContVar) = %d\\n", sizeof(ContVar));
+      printf("sizeof(T_o_ContState_Shadow) = %d\\n", sizeof(T_o_ContState_Shadow));
+      
+      printf("&shadow.x - &shadow.begin_vars = %d\\n",
+      (void *)&(shadow.x) - (void *)&(shadow.begin_vars));
+      
+      return Qnil;
+      
+      printf("sizeof(z) = %d\n", sizeof(z));
+      return Qnil;
+      
+#if 1
+      rb_funcall(Qnil, #{declare_symbol :insteval_proc},
+                 1, RARRAY(from_array)->ptr[0]);
+#else
+//#      rb_obj_instance_eval(1, &RARRAY(from_array)->ptr[0], Qnil);
+      rb_iterate(rb_obj_instance_eval, INT2NUM(15), &fnie, RARRAY(from_array)->ptr[0]);
+#endif
+
+      return Qnil;
+      
+//      printf("Result = %f\\n", pow(1.0,5));
+      
+//      return Qnil;
+      
+      fn(RARRAY(from_array)->ptr[2]);
+      printf("Len = %d\\n", RARRAY(from_array)->len);
+            
+      goto skip;            
+      assert(1==0);
+skip:
+      pi = rb_const_get(#{declare_module :Math}, #{declare_symbol :PI});
+      
+      printf("Math::PI = %f", NUM2DBL(pi));
+      
+      printf("\\n%d, %d, %d, %d.\\n", zow, zim, zug, zwip);
+
+      printf("\\nSize is: %d\\n", sizeof(bitfld));
+      
+      switch (zz) {
+        case 1: 0;
+      }
+      
+      while (zz-- > 0) {
+        int xx = zz;
+        printf("%d\n", xx);
+      }
+    }
+  end
+end
+
+Dir.mkdir "tmp" rescue SystemCallError
+Dir.chdir "tmp"
+
+Test.commit
+
+Test.new.bar
+exit
+
+#p Test.new
+
+#num = 2**31-1
+#puts "original num = #{num}"
+
+class MyArray < Array; end
+ma = MyArray.new << 0 << 1 << 2 << 3
+
+result = Test.foo([proc { puts "bar" }])
+#puts "result num = #{num}"
+
+#marshalled_num = Marshal.load(Marshal.dump(num))
+#puts "marshalled num = #{marshalled_num}"

data/examples/ctest4.rb

@@ -0,0 +1,18 @@
+require 'cgen/cshadow.rb'
+
+class Test
+  include CShadow
+  
+  define_c_class_method :foo do
+    body %{
+      printf("Ok!\n");
+    }
+  end
+end
+
+Dir.mkdir "tmp" rescue SystemCallError
+Dir.chdir "tmp"
+
+Test.commit
+
+Test.foo

data/examples/ctest5.rb

@@ -0,0 +1,27 @@
+require 'cgen/cshadow.rb'
+
+class Test
+  include CShadow
+
+  shadow_attr_accessor :sym  => Symbol
+
+  define_c_method :foo do
+    body %{
+      shadow->sym = ID2SYM(rb_intern("some_symbol"));
+    }
+  end
+  free_function.body %{
+    printf("Freeing a Test instance.\\n");
+  }
+end
+
+Dir.mkdir "tmp" rescue SystemCallError
+Dir.chdir "tmp"
+
+Test.commit
+
+t = Test.new
+t.foo
+p t.sym
+t.sym = :qwerty
+p t.sym

data/examples/example-ruby-talk-30April2004.rb

@@ -0,0 +1,65 @@
+  require 'cgen/cshadow'
+
+  class MyClass
+    include CShadow
+    shadow_attr_accessor :my_c_string => "char *my_string"
+    shadow_attr_accessor :my_ruby_string => String
+    shadow_attr_accessor :my_ruby_object => Object
+
+    def initialize
+      # Must use 'self.varname = value', or else ruby will assign to
+      # local var
+      self.my_c_string = "default string"
+        # stored as null-terminated char *
+
+      self.my_ruby_string = "default string"
+        # stored as ruby VALUE string, after checking type is String
+
+      self.my_ruby_object = "default string"
+        # stored as ruby VALUE string, no type checking
+    end
+
+    def inspect
+      "<#{self.class}: %p, %p, %p>" %
+        [my_c_string, my_ruby_string, my_ruby_object]
+    end
+
+    # easy way to add a method written in C
+    define_c_method :foo do
+
+      c_array_args { # interface to rb_scan_args
+        required :x
+        optional :y
+        rest :stuff
+        block :block
+        typecheck :x => Numeric
+        default :y => "INT2NUM(NUM2INT(x) + 1)"
+      }
+
+      declare :result   => "VALUE   result"
+
+      body %{
+        result = rb_funcall(block, #{declare_symbol :call}, 4,
+                            shadow->my_ruby_string,
+                            x, y, stuff);
+      }
+      # note use of shadow var to access shadow attrs
+
+      returns "result"
+    end
+  end
+
+  MyClass.commit # write C lib, compile, load
+
+  my_obj = MyClass.new
+  p my_obj
+  # ==> <MyClass: "default string", "default string", "default string">
+
+  block = proc do |str, x, y, stuff|
+    "%s, %p, %p, %p" % [str, x, y, stuff]
+  end
+
+  p my_obj.foo(1, &block)
+  # ==> "default string, 1, 2, []"
+  p my_obj.foo(5, 0, "stuff", "more stuff", &block) 
+  # ==> "default string, 5, 0, [\"stuff\", \"more stuff\"]"

data/examples/fixed-array.rb

@@ -0,0 +1,221 @@
+#!/usr/bin/env ruby
+
+require "cgen/cshadow"
+
+=begin
+
+This file contains an assortment of classes of shadow objects that are useful in building up complex data structures.
+
+==class (({FixedArray}))
+
+(({FixedArray})) is a factory class for generating fixed-size arrays of C variables or Ruby objects. There are several reasons for implementing (({FixedArray})) as a standalone object instead of as an attribute. First, defining [] and []= for one array attribute might conflict with another definition of those methods in the same object. Second, it can include Enumerable and add additional methods in subclasses. Third, the factory approach can handle different Ruby and C types more easily, with length and item_type stored as Ruby class attributes. Finally, an array attribute cannot easily return itself as a value to Ruby code. It is better if the array ((*is*)) the object.
+
+For efficiency and easy access from C code, an attribute that refers to a (({FixedArray})) can be a (({ShadowAttribute})) rather than an (({ObjectAttribute})). (See ((<attribute.rb>)).)
+
+If the (({item_type})) is a class which includes (({CShadow})), then the array itself uses (({ShadowAttribute}))s for efficiency. Ruby code doesn't need to be aware of this, but C code does: the entries are not of type (({VALUE})) but of type determined by calling (({#shadow_struct_name})).
+
+Each different (({length})) and (({item_type})) results in a new anonymous subclass of (({FixedArray})), defined in its own library (because of the commit problem).
+
+=end
+
+if true # if this ever is useful, put it in attribute.rb
+
+  # Fixed length array, embedded within shadow struct.
+  # For use, see examples/fixed-array.rb.
+  #
+  # Currently, this attr type accepts declarations of
+  # the form
+  #  shadow_attr :var => "<type> <name>[<len>]"
+  # and
+  #  shadow_attr :var => "<type> * <name>[<len>]"
+  # with any arrangement of spaces around the "*",
+  # where <type> is a standard C type (int, double,
+  # char) or a type defined by typedef.
+  # 
+  # Support for VALUE and shadow struct types is less
+  # useful, but may later be added for completeness.
+  #
+  # The host object must define reader/writer methods.
+  #
+  class FixedArrayAttribute < CShadow::CNativeAttribute
+    @pattern = /\A(\w+\s*\*?)\s*(\w+)\[(\d+)\]\z/
+    
+    attr_reader :length
+
+    def initialize(*args)
+      super
+      @length = @match[3].to_i
+      
+      case @ctype
+      when /\AVALUE /
+        raise NotImplementedError
+      when /#{CShadow::SHADOW_SUFFIX}\s*\*/
+        raise NotImplementedError
+      when /\*/
+        @free = %{
+          {
+            int i;
+            for (i = 0; i < #{@length}; i++)
+              free(shadow->#{@cvar}[i])
+          }
+        }
+      else
+        # Not a pointer. Nothing to do.
+      end
+    end
+
+  end
+
+end
+
+class FixedArray
+  include Enumerable
+  
+  # length and item_type are hard-coded in the subclass definitions.
+  def length;    type.length;    end
+  def item_type; type.item_type; end
+
+  @subs = {}
+  
+  class << self
+    def length;    @length;    end
+    def item_type; @item_type; end
+    
+    def to_s ### necessary?
+      name
+    end
+    
+    def new length, item_type = Object
+      if self == FixedArray
+        c = @subs[[length, item_type]] ||= make_subclass(length, item_type)
+        c.new
+      else
+        super() ### superclass.new ... ???
+      end
+    end
+
+    def make_subclass length, item_type
+      c = Class.new(FixedArray)
+      
+      def c.name
+        "FixedArray_#{@length}_#{@item_type}"
+      end
+
+      c.class_eval %q{ ### why doesn't block work?
+        @length = length
+        @item_type = item_type
+        
+        include CShadow
+        shadow_library "foo_#@length_#@item_type"
+        
+        unless length > 0
+          raise ArgumentError, "\nLength must be positive."
+        end
+        
+        case item_type
+        when Class
+          raise NotImplementedError ## for now. These cases aren't so useful.
+          if item_type.included_modules.include? CShadow
+            shadow_attr :array =>
+              "#{item_type.shadow_struct_name} *array[#{length}]"
+          else
+            shadow_attr :array => "VALUE array[#{length}]"
+          end
+        when String
+          unless item_type =~ /\A\w+\s*\*?\z/
+            raise TypeError, "\n"
+          end
+          shadow_attr :array => "#{item_type} array[#{length}]"
+        end
+        
+        define_method(:[]) {
+          arguments :index
+          declare :i => "int i"
+          body %{
+            i = NUM2INT(index);
+            if (i < 0 || i >= sizeof(shadow->array))
+              rb_raise(#{declare_class IndexError},
+                       "Index %d out of range [0, %d]",
+                       i, sizeof(shadow->array) - 1);
+          }
+          case item_type
+          when "int";     returns "INT2FIX(shadow->array[i])"
+          when "double";  returns "rb_float_new(shadow->array[i])"
+          else            raise NotImplementedError
+          end
+        }
+
+        define_method(:[]=) {
+          arguments :index, :value
+          declare :i => "int i"
+          body %{
+            i = NUM2INT(index);
+            if (i < 0 || i >= sizeof(shadow->array))
+              rb_raise(#{declare_class IndexError},
+                       "Index %d out of range [0, %d]",
+                       i, sizeof(shadow->array) - 1);
+          }
+          case item_type
+          when "int";     body "shadow->array[i] = NUM2INT(value)"
+          when "double";  body "shadow->array[i] = NUM2DBL(value)"
+          else            raise NotImplementedError
+          end
+          returns "value"
+        }
+      }
+      
+      begin
+        Dir.mkdir "FixedArray"
+      rescue SystemCallError
+      end
+      Dir.chdir "FixedArray"
+
+      c.commit
+      
+      Dir.chdir ".."
+      
+      return c
+    end
+    private :make_subclass
+  end
+  
+  # conversion to array and back
+  
+  def each
+  
+  end
+end
+
+def FixedArray length, item_type = Object
+  FixedArray.new length, item_type
+end
+
+
+if $0 == __FILE__
+
+  require "cgen/cshadow"
+
+  require 'runit/testcase'
+  require 'runit/cui/testrunner'
+  require 'runit/testsuite'
+
+  begin
+    Dir.mkdir "tmp"
+  rescue SystemCallError
+  end
+  Dir.chdir "tmp"
+
+  class FixedArrayTest < RUNIT::TestCase
+    
+    Fai = FixedArray 10, "int"
+    Fad = FixedArray 10, "double"
+    
+    def test__initial
+      assert_equal(0, Fai[0])
+      assert_equal(0, Fad[0])
+    end
+  end
+  
+  RUNIT::CUI::TestRunner.run(FixedArrayTest.suite)
+
+end