rbind 0.0.1

data/lib/rbind.rb

@@ -0,0 +1,5 @@
+require 'rbind/rbind'
+require 'rbind/core'
+require 'rbind/default_parser'
+require 'rbind/generator_c'
+require 'rbind/generator_ruby'

data/lib/rbind/core.rb

@@ -0,0 +1,13 @@
+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'
+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'

data/lib/rbind/core/rattribute.rb

@@ -0,0 +1,45 @@
+module Rbind
+    class RAttribute < RBase
+        attr_accessor :type
+
+        def initialize(name,type,*flags)
+            super(name,*flags)
+            raise ArgumentError,"no type" unless type
+            raise "wrong name #{name}" if name =~/.*\*.*/
+            @type = type
+        end
+
+        def ==(other)
+            type == other.type
+        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}"
+            end
+            [s,cs]
+        end
+
+        def valid_flags
+            super << :RW
+        end
+
+        def to_ptr
+            a = self.dup
+            a.type = type.to_ptr
+            a
+        end
+
+        def read_only?
+            !write?
+        end
+        
+        def write?
+            flags.include?(:RW) || flags.include?(:IO) || flags.include?(:O)
+        end
+    end
+end

data/lib/rbind/core/rbase.rb

@@ -0,0 +1,172 @@
+module Rbind
+    class RBase
+        attr_accessor :name
+        attr_accessor :cname
+        attr_accessor :alias
+        attr_accessor :namespace
+        attr_accessor :owner
+        attr_accessor :flags
+        attr_accessor :version
+        attr_accessor :signature
+        attr_accessor :csignature
+
+        class << self
+            attr_accessor :cprefix
+
+            def to_cname(name)
+                name = normalize(name)
+                cn = "#{cprefix}#{name.gsub("::","_")}"
+                cn = cn.gsub("()","_fct")
+                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.gsub("[]","_array")
+            end
+
+            def normalize(name)
+                name = name.to_s
+                if name.split("/n").size > 1
+                    raise "mulitple lines for a name is not supported: #{name}"
+                end
+                name.gsub(".","::").gsub(" ","")
+            end
+
+            def basename(name)
+                name = normalize(name)
+                if !!(name =~/.*::(.*)$/)
+                    $1
+                else
+                    name
+                end
+            end
+
+            def namespace(name)
+                name = normalize(name)
+                if !!(name =~/(.*)::.*$/)
+                    $1
+                else
+                    nil
+                end
+            end
+        end
+        self.cprefix = "rbind_"
+
+        def pretty_print(pp)
+            pp.text "#{signature}#{" Flags: #{flags.join(", ")}" unless flags.empty?}"
+        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)
+            @version = 1
+            self.flags = flags.flatten
+        end
+
+        def generate_signatures
+            ["#{full_name}","#{cname}"]
+        end
+
+        def signature(sig=nil)
+            return @signature || generate_signatures[0] unless sig
+            @signature = sig
+        end
+
+        def csignature(sig=nil)
+            return @csignature || generate_signatures[1] unless sig
+            @csignature = sig
+        end
+
+        def alias(val=nil)
+            return @alias if !val || val.empty?
+            @alias = val
+            self
+        end
+
+        def alias=(val)
+            self.alias(val)
+            val
+        end
+
+        def cname(name=nil)
+            if name
+                @cname = name
+                self
+            else
+                if @cname
+                    @cname
+                elsif @alias
+                    RBase::to_cname(map_to_namespace(@alias))
+                else
+                    RBase::to_cname(full_name)
+                end
+            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
+            @owner = obj
+        end
+
+        def ignore?
+            !!@ignore
+        end
+
+        def namespace?
+            namespace && namespace.size != 0
+        end
+
+        def full_name
+            map_to_namespace(name)
+        end
+
+        def map_to_namespace(name)
+            if namespace
+                "#{namespace}::#{name}"
+            else
+                name
+            end
+        end
+
+        def binding
+            Kernel.binding
+        end
+    end
+end

data/lib/rbind/core/rclass.rb

@@ -0,0 +1,149 @@
+
+module Rbind
+    class RClass < RStruct
+        attr_accessor :parent_classes
+
+        def initialize(name,*parent_classes)
+            @parent_classes  = Hash.new
+            parent_classes.flatten!
+            parent_classes.each do |p|
+                add_parent(p)
+            end
+            super(name)
+        end
+
+        def attributes
+            attribs = @attributes.values
+            parent_classes.each do |k|
+                others = k.attributes
+                others.delete_if do |other|
+                    attribs.inclue? other
+                end
+                others = others.map(&:dup)
+                others.each do |other|
+                    other.owner = self
+                end
+                attribs += others
+            end
+            attribs
+        end
+
+        def attribute(name)
+            attrib = @attributes[name]
+            attrib ||= begin
+                           p = parent_classes.find do |k|
+                               k.attribute(name)
+                           end
+                           a = p.attribute(name).dup if p
+                           a.owner = self if a
+                           a
+                       end
+        end
+
+        def operations
+            # temporarily add all base class operations
+            own_ops = @operations.dup
+            parent_classes.each do |k|
+                k.operations.each do |other_ops|
+                    next if other_ops.empty?
+                    ops = if @operations.has_key?(other_ops.first.name)
+                            @operations[other_ops.first.name]
+                          else
+                              []
+                          end
+                    other_ops.delete_if do |other_op|
+                        next true if !other_op
+                        op = ops.find do |o|
+                            o == other_op
+                        end
+                        next false if !op
+                        next true if op.base_class == self
+                        next true if op.base_class == other_op.base_class
+                        # ambiguous name look up due to multi
+                        # inheritance
+                        op.ambiguous_name = true
+                        other_op.ambiguous_name = true
+                        false
+                    end
+                    other_ops = other_ops.map(&:dup)
+                    other_ops.each do |other|
+                        old = other.alias
+                        add_operation other
+                    end
+                end
+            end
+            # copy embedded arrays other wise they might get modified outside
+            result = @operations.values.map(&:dup)
+            @operations = own_ops
+            result
+        end
+
+        def used_namespaces
+            namespaces = super.clone
+            parent_classes.each do |k|
+                namespaces.merge k.used_namespaces
+            end
+            namespaces
+        end
+
+        def operation(name,raise_=true)
+            ops = if @operations.has_key? name
+                      @operations[name].dup
+                  else
+                      []
+                  end
+            parent_classes.each do |k|
+                other_ops = Array(k.operation(name,false))
+                other_ops.delete_if do |other_op|
+                    ops.include? other_op
+                end
+                ops += other_ops
+            end
+            if(ops.size == 1)
+                ops.first
+            elsif ops.empty?
+                raise "#{full_name} has no operation called #{name}." if raise_
+            else
+                ops
+            end
+        end
+
+        def parent_classes
+            @parent_classes.values
+        end
+
+        def parent_class(name)
+            @parent_classes[name]
+        end
+
+        def pretty_print_name
+            str = "class #{full_name}"
+            unless parent_classes.empty?
+                parents = parent_classes.map do |p|
+                    p.full_name
+                end
+                str += " : " +  parents.join(", ")
+            end
+            str
+        end
+
+        def pretty_print(pp)
+            super
+        end
+
+        def add_parent(klass)
+            if @parent_classes.has_key? klass.name
+                raise ArgumentError,"#A parent class with the name #{klass.name} already exists"
+            end
+            # 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
+            self
+        end
+
+        def parent_class(name)
+            @parent_class[name]
+        end
+    end
+end

data/lib/rbind/core/rconst.rb

@@ -0,0 +1,35 @@
+
+module Rbind
+    class RConst < RDataType
+        attr_accessor :value
+
+        def initialize(name,value,*flags)
+            super(name,*flags)
+            @value = value
+        end
+
+        def generate_signatures
+            ["#{full_name} = #{value}","const int #{cname} = #{map_value_to_namespace(value)}"]
+        end
+
+        def map_value_to_namespace(value)
+            a = value.split(" ")
+            a = a.map do |str|
+                if str =~/^[a-zA-Z]/
+                    RBase.to_cname("#{namespace}::#{str}")
+                else
+                    str
+                end
+            end
+            a.join(" ")
+        end
+
+        def basic_type?
+            false
+        end
+
+        def pretty_print(pp)
+            pp.text "#{signature}#{" Flags: #{flags.join(", ")}" unless flags.empty?}"
+        end
+    end
+end

data/lib/rbind/core/rdata_type.rb

@@ -0,0 +1,93 @@
+
+module Rbind
+    class RDataType < RBase
+        attr_accessor :ptr,:ref
+        attr_accessor :typedef
+        attr_accessor :invalid_value
+        attr_accessor :cdelete_method;
+        attr_accessor :check_type;
+
+        def initialize(name,*flags)
+            super
+            @invalid_value = 0
+            @type_check = true
+        end
+
+        def ==(other)
+            other.name == name && other.ptr == ptr
+        end
+
+        def generate_signatures
+            if ref?
+                ["#{full_name} &","#{cname} &"]
+            elsif ptr?
+                ["#{full_name} *","#{cname} *"]
+            else
+                super
+            end
+        end
+
+        def check_type?
+            @check_type
+        end
+
+        def cname(value=nil)
+            if !value
+                if basic_type? && !@cname
+                    name
+                else
+                    super
+                end
+            else
+                super
+                self
+            end
+        end
+
+        def typedef(value=nil)
+            return @typedef unless value
+            @typedef = value
+            self
+        end
+
+        def typedef?
+            !!@typedef
+        end
+
+        def basic_type?
+            true
+        end
+
+        def container?
+            false
+        end
+
+        def to_value
+            owner.type(name)
+        end
+
+        def to_ptr
+            return self if ptr? && !ref?
+            t = self.dup
+            t.ref = false
+            t.ptr = true
+            t
+        end
+
+        def delete!
+            if @owner
+                @owner.delete_type self.name
+            else 
+                raise "#{self} has no owner."
+            end
+        end
+
+        def ptr?
+            !!ptr
+        end
+
+        def ref?
+            !!ref
+        end
+    end
+end