cgen 0.16.6 → 0.16.7

data/History.txt

@@ -1,3 +1,11 @@
+cgen 0.16.7
+
+  - misc refactoring, cleanup, docs, error checking
+  
+  - added BooleanAttribute with tests
+  
+  - improved placement of alloc funcs in library init code
+
 cgen 0.16.6
 
   - optimization: don't generate a mark or free function when an attribute

data/lib/cgen/attribute.rb

@@ -199,7 +199,7 @@ module CShadow
       super
       @class = @match
       
-      ssn = @class.shadow_struct.name
+      ssn = @class.shadow_struct_name
       
       @cvar = @var
       if @class < CShadow
@@ -307,6 +307,18 @@ module CShadow
     end
   end
   
+  class BooleanAttribute < CNativeAttribute
+    @pattern = /\A(bool(?:ean)?)\s+(\w+)\z/
+    def initialize(*args)
+      super
+      @cdecl = @cdecl.sub(@match[1], "int")
+      @reader = "result = shadow->#{@cvar} ? Qtrue : Qfalse"
+      @writer = "shadow->#{@cvar} = RTEST(arg)"   # type conversion
+      @dump = "rb_ary_push(result, shadow->#{@cvar} ? Qtrue : Qfalse)"
+      @load = "tmp = rb_ary_shift(from_array); shadow->#{@cvar} = RTEST(tmp)"
+    end
+  end
+  
   # Does not check for overflow.
   class ShortAttribute < IntAttribute
     @pattern = /\A(short)\s+(\w+)\z/

data/lib/cgen/cgen.rb

@@ -418,7 +418,7 @@ require 'cgen/inherit'
 # way that makes clear that the problem is really with commit.
 module CGenerator
 
-VERSION = '0.16.6'
+VERSION = '0.16.7'
 
 class Accumulator ## should be a mixin? "Cumulative"?
 
@@ -624,7 +624,8 @@ class Library < Template
         rb_define_method!,
         rb_define_module_function!,
         rb_define_global_function!,
-        rb_define_singleton_method!
+        rb_define_singleton_method!,
+        rb_define_alloc_func!
       ## odd, putting an accum inside
       ## a template which is not the parent
   end
@@ -1101,6 +1102,34 @@ class Library < Template
               :rb_define_module_function,
               :rb_define_global_function,
               :rb_define_singleton_method) {RbDefineAccumulator}
+
+  class RbDefineAllocAccumulator < Accumulator
+    def add spec
+      klass = spec[:class]
+      cfile = spec[:cfile]
+      
+      if @pile.find {|s| s[:class] == klass}
+        raise ArgumentError, "Duplicate alloc func definition for #{klass}"
+      end
+
+      klass_c_name =
+        spec[:class_c_name] ||= @parent.declare_class(klass, cfile) ## @parent ?
+      spec[:c_name] ||= "alloc_func_#{klass_c_name}".intern
+      @pile << spec
+      
+      spec[:c_name]
+    end
+    
+    def to_s
+      @pile.collect { |spec|
+        c_name        = spec[:c_name]
+        klass_c_name  = spec[:class_c_name]
+        "rb_define_alloc_func(#{klass_c_name}, #{c_name});"
+      }.join "\n"
+    end
+  end # class RbDefineAllocAccumulator
+  
+  accumulator(:rb_define_alloc_func) {RbDefineAllocAccumulator}
   
   # call-seq:
   #   define_c_method mod, name, subclass
@@ -1465,10 +1494,7 @@ class CFile < CFragment
   alias define_c_class_method define_c_singleton_method
   
   def define_alloc_func klass
-    klass_c_name = declare_class klass, self # cfile
-    c_name = "alloc_func_#{klass_c_name}"
-    library.init_library_function.body \
-      %{rb_define_alloc_func(#{klass_c_name}, #{c_name})}
+    c_name = rb_define_alloc_func :class => klass, :cfile => self
     define c_name, Function
   end
   

data/lib/cgen/cshadow.rb

@@ -268,13 +268,7 @@ module CShadow
         classes = Library.sort_class_tree(@classes_to_commit)
         
         classes.each do |cl|
-          # make sure the following have been defined by now
-          cl.shadow_struct
-          cl.new_method; cl._alloc_method
-          cl.check_inherited_functions
-          if cl == cl.base_class
-            cl._dump_data_method; cl._load_data_method
-          end
+          cl.fill_in_defs
         end
       end
 
@@ -468,8 +462,9 @@ module CShadow
       if defined? @shadow_library_file
         if file
           raise RuntimeError,
-                "Class #{self} is already associated" +
-                " with file #{@shadow_library_file}."
+                "Cannot assign class #{self} to file #{file.inspect}; class" +
+                " is already associated" +
+                " with file #{@shadow_library_file[0].name}."
         end
         @shadow_library_file
       elsif file
@@ -522,9 +517,9 @@ module CShadow
       sf = shadow_library_source_file
       m = sf.define_c_method self, name, subclass
       m.scope :extern
-      m.declare :shadow => "#{shadow_struct.name} *shadow"
+      m.declare :shadow => "#{shadow_struct_name} *shadow"
       m.setup :shadow =>
-        "Data_Get_Struct(self, #{shadow_struct.name}, shadow)"
+        "Data_Get_Struct(self, #{shadow_struct_name}, shadow)"
       m.instance_eval(&block) if block
       m
     end
@@ -562,7 +557,7 @@ module CShadow
     def define_inheritable_c_function name,
           subclass = CGenerator::Function, &block
       sf = shadow_library_source_file
-      m = sf.define_c_function "#{name}_#{shadow_struct.name}", subclass
+      m = sf.define_c_function "#{name}_#{shadow_struct_name}", subclass
       c_function_templates[name] = m
       m.scope :extern
       m.instance_eval(&block) if block
@@ -571,7 +566,18 @@ module CShadow
     
     #== Internal methods ==#
 
-    def c_function_templates;         @c_function_templates ||= {};         end
+    def fill_in_defs
+      shadow_struct
+      new_method; _alloc_method
+
+      check_inherited_functions
+
+      if self == base_class
+        _dump_data_method; _load_data_method
+      end
+    end
+
+    def c_function_templates; @c_function_templates ||= {}; end
     # Note that {} nondeterministic, so these should only be used to
     # check existence or get value, not to iterate.
     
@@ -581,15 +587,17 @@ module CShadow
           superclass.find_super_function(sym))
     end
     
-    # Construct the name used for the shadow struct.
+    # Construct the name used for the shadow struct. Attempts to preserve
+    # the full class path.
     def shadow_struct_name
-      name.gsub(/_/, '__').gsub(/::/, '_o_') + CShadow::SHADOW_SUFFIX
-      # To preserve differences.
+      @shadow_struct_name ||=
+        name.gsub(/_/, '__').gsub(/::/, '_o_') + CShadow::SHADOW_SUFFIX
     end
     
     # Return the object for managing the shadow struct.
     def shadow_struct
       unless defined?(@shadow_struct) and @shadow_struct
+        raise if @inherited_shadow_struct
         sf = shadow_library_source_file
         ssn = shadow_struct_name
         @shadow_struct = sf.declare_extern_struct(ssn)
@@ -599,7 +607,7 @@ module CShadow
           sss = superclass.shadow_struct
           shadow_struct.inherit\
             sss.inherit!,
-            "/* #{superclass.shadow_struct.name} members */",
+            "/* #{superclass.shadow_struct_name} members */",
             sss.declare!, " "
 
           unless superclass.shadow_library_source_file ==
@@ -616,7 +624,7 @@ module CShadow
     def new_method
       unless defined?(@new_method) and @new_method
         sf = shadow_library_source_file
-        ssn = shadow_struct.name
+        ssn = shadow_struct_name
         mark_name = refer_to_function :mark
         free_name = refer_to_function :free
         @new_method = sf.define_c_singleton_method self,
@@ -647,20 +655,35 @@ module CShadow
       @new_method
     end
     
+    # Set of function names (symbols) that have been referenced in the
+    # implementation of this class. The names are like :free or :mark,
+    # rather than :free_in_class_C, to give a common identity to all free
+    # functions.
     def referenced_functions
       @referenced_functions ||= {}
     end
     
+    # Generate a string which, by convention, names the function for
+    # instances of this particular class. Also, keeps track of
+    # referenced_functions.
     def refer_to_function sym
       referenced_functions[sym] = true
-      "#{sym}_#{shadow_struct.name}"
+      "#{sym}_#{shadow_struct_name}"
+    end
+    
+    def inherited_function
+      @inherited_function ||= {}
     end
     
+    # For each function referenced in this class, but not defined, resolve
+    # the reference by defining a macro to evaluate to the first
+    # implementation found by ascending the class tree.
     def check_inherited_functions
       syms = referenced_functions.keys.sort_by{|k|k.to_s}
       syms.reject {|sym| c_function_templates[sym]}.each do |sym|
-        fname = "#{sym}_#{shadow_struct.name}"
+        fname = "#{sym}_#{shadow_struct_name}"
         pf = find_super_function(sym)
+        inherited_function[sym] = true
         pf_str = pf ? pf.name : (sym == :free ? -1 : 0)
           # -1 means free the struct; See README.EXT
         shadow_library_source_file.declare fname.intern =>
@@ -671,8 +694,9 @@ module CShadow
     # Return the object for managing the mark function of the class.
     def mark_function
       unless defined?(@mark_function) and @mark_function
+        raise if inherited_function[:mark]
         sf = shadow_library_source_file
-        ssn = shadow_struct.name
+        ssn = shadow_struct_name
         @mark_function = define_inheritable_c_function(:mark, MarkFunction) do
           arguments "#{ssn} *shadow"
           return_type "void"
@@ -687,8 +711,9 @@ module CShadow
     # Return the object for managing the free function of the class.
     def free_function
       unless defined?(@free_function) and @free_function
+        raise if inherited_function[:free]
         sf = shadow_library_source_file
-        ssn = shadow_struct.name
+        ssn = shadow_struct_name
         @free_function = define_inheritable_c_function(:free, FreeFunction) do
           arguments "#{ssn} *shadow"
           return_type "void"
@@ -706,8 +731,8 @@ module CShadow
       return nil unless persistent?
       unless defined?(@_dump_data_method) and @_dump_data_method
         @_dump_data_method = define_c_method(:_dump_data, AttrMethod) {
-          declare :result   => "VALUE   result"
-          setup   :result   => "result  = rb_ary_new()"
+          declare :result   => "VALUE result"
+          setup   :result   => "result = rb_ary_new()"
           body pre_code!, attr_code!, post_code!
           returns "result"
         }
@@ -743,7 +768,7 @@ module CShadow
       return nil unless persistent?
       unless defined?(@_alloc_method) and @_alloc_method
         sf = shadow_library_source_file
-        ssn = shadow_struct.name
+        ssn = shadow_struct_name
         mark_name = refer_to_function :mark
         free_name = refer_to_function :free
         @_alloc_method = sf.define_alloc_func(self)
@@ -857,7 +882,7 @@ module CShadow
       end
 
       source_file = shadow_library_source_file
-      ssn = shadow_struct.name
+      ssn = shadow_struct_name
       @shadow_attrs ||= []
       
       meths = nil
@@ -901,17 +926,15 @@ module CShadow
 
         new_method.attr_code attr.init if attr.init
 
-        m = attr.mark
-        mark_function.mark m if m
-        f = attr.free
-        free_function.free f if f
+        m = attr.mark and mark_function.mark m
+        f = attr.free and free_function.free f
 
         if persistent?
           if attr_persists
             _dump_data_method.attr_code attr.dump
             _load_data_method.attr_code attr.load
           else
-            _load_data_method.attr_code attr.init if attr.init
+            i = attr.init and _load_data_method.attr_code i
           end
         end
 

data/test/test-attribute.rb

@@ -154,7 +154,8 @@ class ShadowObjectAttributeTest < AttributeTest
     n = ObjectSpace.each_object(c) {}
     make_things c, 10
     GC.start
-    assert_equal(n+1, ObjectSpace.each_object(c) {})
+    n2 = ObjectSpace.each_object(c) {}
+    assert_send( [[n, n+1], :include?, n2] )
   end
 
   def test_marshal_uninitialized
@@ -258,6 +259,48 @@ class IntAttributeTest < AttributeTest
   end
 end
 
+class BooleanAttributeTest < AttributeTest
+  class BooleanAttributeSample < AttributeSample
+    shadow_attr_accessor :x => "boolean x"
+  end
+
+  def test__initial
+    @ias = BooleanAttributeSample.new
+    assert_equal(false, @ias.x)
+  end
+
+  def test_accessor
+    @ias = BooleanAttributeSample.new
+    @ias.x = true
+    assert_equal(true, @ias.x)
+    @ias.x = false
+    assert_equal(false, @ias.x)
+    @ias.x = nil
+    assert_equal(false, @ias.x)
+  end
+
+  def test_conversion
+    @ias = BooleanAttributeSample.new
+    @ias.x = 5
+    assert_equal(true, @ias.x)
+    @ias.x = {:foo => "bar"}
+    assert_equal(true, @ias.x)
+  end
+
+  def test_marshal
+    @ias = BooleanAttributeSample.new
+    @ias.x = true
+    s = Marshal.dump @ias
+    t = Marshal.load s
+    assert_equal(@ias.x, t.x)
+
+    @ias.x = false
+    s = Marshal.dump @ias
+    t = Marshal.load s
+    assert_equal(@ias.x, t.x)
+  end
+end
+
 class LongAttributeTest < AttributeTest
   class LongAttributeSample < AttributeSample
     shadow_attr_accessor :x => "long x"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cgen
 version: !ruby/object:Gem::Version 
-  hash: 83
+  hash: 81
   prerelease: false
   segments: 
   - 0
   - 16
-  - 6
-  version: 0.16.6
+  - 7
+  version: 0.16.7
 platform: ruby
 authors: 
 - Joel VanderWerf
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-08 00:00:00 -07:00
+date: 2010-08-11 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -124,6 +124,6 @@ signing_key:
 specification_version: 3
 summary: C code generator
 test_files: 
-- test/test-attribute.rb
 - test/test-cgen.rb
+- test/test-attribute.rb
 - test/test-cshadow.rb