rbind 0.0.16 → 0.0.17

data/lib/rbind/core.rb

@@ -1,7 +1,6 @@
 require 'rbind/logger.rb'
 require 'rbind/core/rbase.rb'
 require 'rbind/core/rdata_type.rb'
-require 'rbind/core/rconst.rb'
 require 'rbind/core/renum.rb'
 require 'rbind/core/rattribute.rb'
 require 'rbind/core/rparameter.rb'
@@ -9,7 +8,11 @@ require 'rbind/core/roperation.rb'
 require 'rbind/core/rgetter.rb'
 require 'rbind/core/rsetter.rb'
 require 'rbind/core/rnamespace.rb'
-require 'rbind/core/rstruct.rb'
 require 'rbind/core/rclass.rb'
-require 'rbind/core/rvector.rb'
-require 'rbind/core/rstring.rb'
+require 'rbind/core/rtemplate_class.rb'
+require 'rbind/core/rreference.rb'
+require 'rbind/core/rpointer.rb'
+require 'rbind/core/rtype_qualifier.rb'
+
+require 'rbind/types/std_vector.rb'
+require 'rbind/types/std_string.rb'

data/lib/rbind/core/rattribute.rb

@@ -2,11 +2,12 @@ module Rbind
     class RAttribute < RBase
         attr_accessor :type
 
-        def initialize(name,type,*flags)
-            super(name,*flags)
+        def initialize(name,type)
+            super(name)
             raise ArgumentError,"no type" unless type
-            raise "wrong name #{name}" if name =~/.*\*.*/
             @type = type
+            @readable = true
+            @writable = false
         end
 
         def ==(other)
@@ -14,32 +15,27 @@ module Rbind
         end
 
         def generate_signatures
-            s = "#{type.signature}#{" " if !type.ptr? && !type.ref?}#{name}"
-            cs= "#{type.csignature}#{" " if !type.ptr? && !type.ref?}#{name}"
-
-            if read_only? && !type.basic_type?
-                s = "const #{s}"
-                cs = "const #{cs}"
+            @type.generate_signatures.map do |s|
+                "#{s} #{name}"
             end
-            [s,cs]
         end
 
-        def valid_flags
-            super << :RW
+        def readable!(value = true)
+            @readable = value
+            self
         end
 
-        def to_ptr
-            a = self.dup
-            a.type = type.to_ptr
-            a
+        def writeable!(value = true)
+            @writeable = value
+            self
         end
 
-        def read_only?
-            !write?
+        def readable?
+            !!@readable
         end
-        
-        def write?
-            flags.include?(:RW) || flags.include?(:IO) || flags.include?(:O)
+
+        def writeable?
+            !!@writeable
         end
     end
 end

data/lib/rbind/core/rbase.rb

@@ -6,11 +6,12 @@ module Rbind
         attr_accessor :auto_alias # set to true if rbind is aliasing the object
         attr_accessor :namespace
         attr_accessor :owner
-        attr_accessor :flags
         attr_accessor :version
         attr_accessor :signature
         attr_accessor :csignature
         attr_accessor :ignore
+        attr_accessor :extern_package_name
+        attr_accessor :doc
 
         class << self
             attr_accessor :cprefix
@@ -18,23 +19,26 @@ module Rbind
             def to_cname(name)
                 name = normalize(name)
                 cn = "#{cprefix}#{name.gsub("::","_")}"
-                cn = cn.gsub("()","_fct")
-                cn = cn.gsub("<=","_smaller_equal")
-                cn = cn.gsub(">=","_greater_equal")
-                cn = cn.gsub("!=","_unequal")
-                cn = cn.gsub("==","_equal")
-                cn = cn.gsub("&=","_and_set")
-                cn = cn.gsub("+=","_add")
-                cn = cn.gsub("-=","_sub")
-                cn = cn.gsub("+","_plus")
-                cn = cn.gsub("-","_minus")
-                cn = cn.gsub("*","_mult")
-                cn = cn.gsub("/","_div")
-                cn = cn.gsub("!","_not")
-                cn = cn.gsub("&","_and")
-                cn = cn.gsub("<","_smaller")
-                cn = cn.gsub(">","_greater")
-                cn.gsub("[]","_array")
+                if cn =~ /operator/
+                    cn = cn.gsub("operator()","operator_fct")
+                    cn = cn.gsub("operator!=","operator_unequal")
+                    cn = cn.gsub("operator==","operator_equal")
+                    cn = cn.gsub("operator&=","operator_and_set")
+                    cn = cn.gsub("operator+=","operator_add")
+                    cn = cn.gsub("operator-=","operator_sub")
+                    cn = cn.gsub("operator+","operator_plus")
+                    cn = cn.gsub("operator-","operator_minus")
+                    cn = cn.gsub("operator*","operator_mult")
+                    cn = cn.gsub("operator/","operator_div")
+                    cn = cn.gsub("operator!","operator_not")
+                    cn = cn.gsub("operator&","operator_and")
+                    cn = cn.gsub("operator[]","operator_array")
+                end
+                cn = cn.gsub("*","_ptr")
+                cn = cn.gsub("&","_ref")
+                cn = cn.gsub("<","_")
+                cn = cn.gsub(">","")
+                cn = cn.gsub(",","__")
             end
 
             def normalize(name)
@@ -45,37 +49,36 @@ module Rbind
                 name.gsub(".","::").gsub(" ","")
             end
 
-            def basename(name)
+            def split_name(name)
                 name = normalize(name)
-                if !!(name =~/.*::(.*)$/)
-                    $1
+                # check for template
+                if(name =~/([\w:]*)(<.*)$/)
+                    result = split_name($1)
+                    [result[0],result[1]+$2]
+                elsif(name =~/(.*)::(.*)$/)
+                    [$1,$2]
                 else
-                    name
+                    [nil,name]
                 end
             end
 
             def namespace(name)
-                name = normalize(name)
-                if !!(name =~/(.*)::.*$/)
-                    $1
-                else
-                    nil
-                end
+                split_name(name)[0]
+            end
+
+            def basename(name)
+                split_name(name)[1]
             end
         end
         self.cprefix = "rbind_"
 
         def pretty_print(pp)
-            pp.text "#{signature}#{" Flags: #{flags.join(", ")}" unless flags.empty?}"
+            pp.text "#{signature}"
         end
 
-        def initialize(name,*flags)
-            name = RBase::normalize(name)
-            raise ArgumentError, "no name" unless name && name.size > 0
-            @name = RBase::basename(name)
-            @namespace = RBase::namespace(name)
+        def initialize(name)
+            rename(name)
             @version = 1
-            self.flags = flags.flatten
         end
 
         def generate_signatures
@@ -86,6 +89,11 @@ module Rbind
             !!@ignore
         end
 
+        # returns true if this object is defined in another extern package
+        def extern?
+            extern_package_name && !extern_package_name.empty?
+        end
+
         def signature(sig=nil)
             return @signature || generate_signatures[0] unless sig
             @signature = sig
@@ -122,43 +130,26 @@ module Rbind
             end
         end
 
-        def flags=(*flags)
-            flags.flatten!
-            validate_flags(flags)
-            @flags = flags
-        end
-
-        def add_flag(*flags)
-            @flags += flags
-            self
-        end
-
-        def valid_flags
-            []
-        end
-
-        def validate_flags(flags,valid_flags = self.valid_flags)
-            valid_flags.flatten!
-            flags.each do |flag|
-                if !valid_flags.include?(flag)
-                    raise "flag #{flag} is not supported for #{self.class.name}. Supported flags are #{valid_flags}"
-                end
-            end
-        end
-
         def owner=(obj)
-            if obj.respond_to?(:root?) && !obj.root?
-                @namespace = obj.full_name
-            else
-                @namespace = nil
-            end
+            raise ArgumentError,"Cannot at self as owner" if obj.object_id == self.object_id
             @owner = obj
+            @namespace = nil
         end
 
         def ignore?
             !!@ignore
         end
 
+        def namespace
+            if @namespace
+                @namespace
+            elsif @owner.respond_to?(:root?) && !@owner.root?
+                @owner.full_name
+            else
+                nil
+            end
+        end
+
         def namespace?
             namespace && namespace.size != 0
         end
@@ -167,6 +158,10 @@ module Rbind
             map_to_namespace(name)
         end
 
+        def to_s
+            signature
+        end
+
         def map_to_namespace(name)
             if namespace
                 "#{namespace}::#{name}"
@@ -175,8 +170,47 @@ module Rbind
             end
         end
 
+        def rename(name)
+            old_name = self.name
+            name = RBase::normalize(name)
+            raise ArgumentError, "no name" unless name && name.size > 0
+            @name = RBase::basename(name)
+            @namespace = RBase::namespace(name)
+            if @owner
+                @owner.delete_type old_name
+                @owner.add_type(self)
+            end
+        end
+
+        def delete!
+            if @owner
+                @owner.delete_type self.name
+            else
+                raise "#{self} has no owner."
+            end
+        end
+
         def binding
             Kernel.binding
         end
+
+        def doc(&block)
+            if block
+                @doc = block
+            elsif @doc.is_a? Proc
+                @doc.call
+            else
+                @doc
+            end
+        end
+
+        # specialize
+        def specialize_ruby(&block)
+            if block
+                @specialize_ruby = block
+            elsif @specialize_ruby
+                @specialize_ruby.call
+            end
+        end
     end
 end

data/lib/rbind/core/rcallback.rb

@@ -0,0 +1,15 @@
+
+module Rbind
+    class RCallback < RDataType
+        attr_reader :fct
+
+        def initialize(name,return_type,*args)
+            @fct = ROperation.new(name,return_type,*args)
+            super(name)
+        end
+
+        def callback?
+            true
+        end
+    end
+end

data/lib/rbind/core/rclass.rb

@@ -1,10 +1,13 @@
 
 module Rbind
-    class RClass < RStruct
+    class RClass < RNamespace
         attr_reader :parent_classes
+        attr_reader :attributes
+        ParentClass = Struct.new(:type,:accessor)
 
         def initialize(name,*parent_classes)
             @parent_classes  = Hash.new
+            @attributes = Hash.new
             parent_classes.flatten!
             parent_classes.each do |p|
                 add_parent(p)
@@ -12,10 +15,39 @@ module Rbind
             super(name)
         end
 
+        def basic_type?
+            false
+        end
+
+        def constructor?
+            ops = Array(operation(name,false))
+            return false unless ops
+            op = ops.find do |op|
+                op.constructor?
+            end
+            !!op
+        end
+
+        def add_attribute(attr)
+            if attr.namespace?
+                type(attr.namespace).add_attribute(attr)
+            else
+                if @attributes.has_key? attr.name
+                    raise "#An attribute with the name #{attr.name} already exists"
+                end
+                attr.owner = self
+                @attributes[attr.name] = attr
+                # add getter and setter methods to the object
+                add_operation(RGetter.new(attr)) if attr.readable?
+                add_operation(RSetter.new(attr)) if attr.writeable?
+            end
+            self
+        end
+
         def attributes
             attribs = @attributes.values
             parent_classes.each do |k|
-                others = k.attributes
+                others = k.type.attributes
                 others.delete_if do |other|
                     attribs.inclue? other
                 end
@@ -32,7 +64,7 @@ module Rbind
             attrib = @attributes[name]
             attrib ||= begin
                            p = parent_classes.find do |k|
-                               k.attribute(name)
+                               k.type.attribute(name)
                            end
                            a = p.attribute(name).dup if p
                            a.owner = self if a
@@ -44,7 +76,7 @@ module Rbind
             # temporarily add all base class operations
             own_ops = @operations.dup
             parent_classes.each do |k|
-                k.operations.each do |other_ops|
+                k.type.operations.each do |other_ops|
                     next if other_ops.empty?
                     ops = if @operations.has_key?(other_ops.first.name)
                             @operations[other_ops.first.name]
@@ -81,7 +113,7 @@ module Rbind
         def used_namespaces
             namespaces = super.clone
             parent_classes.each do |k|
-                namespaces.merge k.used_namespaces
+                namespaces += k.type.used_namespaces
             end
             namespaces
         end
@@ -93,7 +125,7 @@ module Rbind
                       []
                   end
             parent_classes.each do |k|
-                other_ops = Array(k.operation(name,false))
+                other_ops = Array(k.type.operation(name,false))
                 other_ops.delete_if do |other_op|
                     ops.include? other_op
                 end
@@ -108,19 +140,27 @@ module Rbind
             end
         end
 
-        def parent_classes
-            @parent_classes.values
+        def cdelete_method
+            if @cdelete_method
+                @cdelete_method
+            else
+                if cname =~ /^#{RBase.cprefix}(.*)/
+                    "#{RBase.cprefix}delete_#{$1}"
+                else
+                    "#{RBase.cprefix}delete_#{name}"
+                end
+            end
         end
 
-        def parent_class(name)
-            @parent_classes[name]
+        def empty?
+            super && parent_classes.empty? && attributes.empty?
         end
 
         def pretty_print_name
-            str = "class #{full_name}"
+            str = "#{"template " if template?}class #{full_name}"
             unless parent_classes.empty?
                 parents = parent_classes.map do |p|
-                    p.full_name
+                    p.type.full_name
                 end
                 str += " : " +  parents.join(", ")
             end
@@ -129,24 +169,47 @@ module Rbind
 
         def pretty_print(pp)
             super
+            unless attributes.empty?
+                pp.nest(2) do
+                    pp.breakable
+                    pp.text "Attributes:"
+                    pp.nest(2) do
+                        attributes.each do |a|
+                            pp.breakable
+                            pp.pp(a)
+                        end
+                    end
+                end
+            end
         end
 
-        def add_parent(klass)
+        def add_parent(klass,accessor=:public)
+            klass,accessor = if klass.is_a?(ParentClass)
+                                 [klass.type,klass.accessor]
+                             else
+                                 [klass,accessor]
+                             end
             if @parent_classes.has_key? klass.name
                 raise ArgumentError,"#A parent class with the name #{klass.name} already exists"
             end
             if klass.full_name == full_name || klass == self
                 raise ArgumentError,"class #{klass.full_name} cannot be parent of its self"
             end
-            # we have to disable the type check for the parent class 
+            # we have to disable the type check for the parent class
             # otherwise derived types cannot be parsed
             klass.check_type = false
-            @parent_classes[klass.name] = klass
+            @parent_classes[klass.name] = ParentClass.new(klass,accessor)
             self
         end
 
         def parent_class(name)
-            @parent_class[name]
+            @parent_class[name].type
+        end
+
+        def parent_classes(accessor = :public)
+            @parent_classes.values.find_all do |k|
+                k.accessor = accessor
+            end
         end
     end
 end