rbind 0.0.1

data/lib/rbind/core/rparameter.rb

@@ -0,0 +1,40 @@
+
+module Rbind
+    class RParameter < RAttribute
+        attr_accessor :default_value
+
+        def initialize(name,type,default_value=nil,*flags)
+            super(name,type,*flags)
+            self.default_value = default_value
+        end
+
+        def default_value=(val)
+            @default_value = if val && !val.empty?
+                                 val.chomp.chomp(" ")
+                             else
+                                 nil
+                             end
+        end
+
+        def default_value(val = nil)
+            if val
+                self.default_value = val
+                self
+            else
+                @default_value
+            end
+        end
+
+        def valid_flags
+            [:IO,:O]
+        end
+
+        def generate_signatures
+            c,cs = super
+            if default_value
+                c = "#{c}=#{default_value}"
+            end
+            [c,cs]
+        end
+    end
+end

data/lib/rbind/core/rsetter.rb

@@ -0,0 +1,20 @@
+
+module Rbind
+    class RSetter < ROperation
+        attr_reader :attribute
+
+        def initialize(attr)
+            @attribute = attr
+            para = RParameter.new("value",attr.type)
+            super("set_#{attr.name}",RDataType.new("void"),para)
+        end
+
+        def attribute?
+            true
+        end
+
+        def signature
+            attribute.signature
+        end
+    end
+end

data/lib/rbind/core/rstruct.rb

@@ -0,0 +1,87 @@
+
+module Rbind
+    class RStruct < RNamespace
+        attr_reader :attributes
+
+        def initialize(name,*flags)
+            @attributes = Hash.new
+            super(name,*flags)
+        end
+
+        def basic_type?
+            false
+        end
+
+        def valid_flags
+            super << :Simple << :Map
+        end
+
+        def constructor?
+            ops = Array(operation(name,false))
+            return false unless ops
+            op = ops.find do |op|
+                op.constructor?
+            end
+            !!op
+        end
+
+        def attributes
+            @attributes.values
+        end
+
+        def attribute(name)
+            @attributes[name]
+        end
+
+        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 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))
+                add_operation(RSetter.new(attr)) if attr.write?
+            end
+            self
+        end
+
+        def pretty_print_name
+            "struct #{full_name}#{" Flags: #{flags.join(", ")}" unless flags.empty?}"
+        end
+
+        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
+    end
+end
+
+
+

data/lib/rbind/default_parser.rb

@@ -0,0 +1,253 @@
+
+module Rbind
+    class DefaultParser < RNamespace
+        extend ::Rbind::Logger
+
+        def initialize
+            super("root")
+            self.root = true
+            add_default_types
+            @on_type_not_found
+        end
+
+        def normalize_flags(line_number,flags)
+            flags.map do |flag|
+                if flag =~ /(\w*)(.*)/
+                    DefaultParser.log.info "input line #{line_number}: ignoring flag #{$2}" unless $2.empty?
+                    $1.to_sym
+                else
+                    raise "cannot parse flag #{flag.inspect}"
+                end
+            end
+        end
+
+        def normalize_default_value(value)
+            val = value.gsub(/(.?)std::vector<(.*)>/,'\1vector_\2')
+            if value != val
+                normalize_default_value(val)
+            else
+                val
+            end
+        end
+
+        def add_data_type_name(name)
+            t = RDataType.new(name)
+            add_type t
+            t
+        end
+
+        def add_namespace_name(name)
+            ns = RNamespace.new(name)
+            add_type ns
+            ns
+        end
+
+        def add_struct_name(name)
+            s = RStruct.new(name)
+            add_type s
+            s
+        end
+
+        def add_class_name(name)
+            klass = RClass.new(name)
+            add_type klass
+            klass
+        end
+
+        def on_type_not_found(&block)
+            @on_type_not_found = block
+        end
+
+
+        def find_type(owner,type_name)
+            t = owner.type(type_name,false)
+            return t if t
+            
+            normalized = type_name.split("_")
+            name = normalized.shift
+            while !normalized.empty?
+                name += "::#{normalized.shift}"
+                t = if normalized.empty?
+                        owner.type(name,false)
+                    else
+                        owner.type("#{name}_#{normalized.join("_")}",false)
+                    end
+                return t if t
+            end
+            t = @on_type_not_found.call(owner,type_name) if @on_type_not_found
+            return t if t
+
+            #search again even if we know the type is not there to create a proper error message
+            owner.type(type_name,true)
+        end
+
+        def parameter(line_number,string,owner = self)
+            flags = string.split(" /")
+            array = flags.shift.split(" ")
+            type_name = array.shift
+            para_name = array.shift
+            default = normalize_default_value(array.join(" "))
+            type = find_type(owner,type_name)
+            flags = normalize_flags(line_number,flags)
+            RParameter.new(para_name,type,default,flags)
+        rescue RuntimeError => e
+            raise "input line #{line_number}: #{e}"
+        end
+
+        def attribute(line_number,string,owner=self)
+            flags = string.split(" /")
+            array = flags.shift.split(" ")
+            type_name = array[0]
+            name = array[1]
+            type = find_type(owner,type_name)
+            flags = normalize_flags(line_number,flags)
+            RAttribute.new(name,type,flags)
+        rescue RuntimeError => e
+            raise "input line #{line_number}: #{e}"
+        end
+
+        def parse_class(line_number,string)
+            lines = string.split("\n")
+            a = lines.shift.rstrip.split(" : ")
+            name = a[0].split(" ")[1]
+            parents = a[1]
+            parent_classes = if parents
+                                 parents.split(", ").map do |name|
+                                     type(RBase.normalize(name),true)
+                                 end
+                             end
+            t = RClass.new(name,*parent_classes)
+            t = if t2 = type(t.full_name,false)
+                    if !t2.is_a?(RClass) || (!t2.parent_classes.empty? && t2.parent_classes != t.parent_classes)
+                        raise "Cannot add class #{t.full_name}. A different type #{t2} is already registered"
+                    else
+                        t2.parent_classes = t.instance_variable_get(:@parent_classes)
+                        t2
+                    end
+                else
+                    add_type(t)
+                    t
+                end
+            line_counter = 1
+            lines.each do |line|
+                a = attribute(line_counter+line_number,line,t)
+                t.add_attribute(a)
+                line_counter += 1
+            end
+            [t,line_counter]
+        rescue RuntimeError  => e
+            raise "input line #{line_number}: #{e}"
+        end
+
+        def parse_struct(line_number,string)
+            a = string.split("\n")
+            first_line = a.shift
+            flags = first_line.split(" /")
+            name = flags.shift.split(" ")[1]
+            flags = normalize_flags(line_number,flags)
+            klass = RStruct.new(name,flags)
+            add_type(klass)
+            line_counter = 1
+            a.each do |line|
+                a = attribute(line_counter+line_number,line,klass)
+                klass.add_attribute(a)
+                line_counter += 1
+            end
+            [klass,line_counter]
+        rescue RuntimeError  => e
+            raise "input line #{line_number}: #{e}"
+        end
+
+        def parse_const(line_number,string)
+            raise "multi line const are not supported: #{string}" if string.split("\n").size > 1
+            a = string.split(" ")
+            raise "not a constant: #{string}" unless a.shift == "const"
+            name = a.shift
+            value = a.join(" ")
+            c = RConst.new(name,value)
+            add_const(c)
+            [c,1]
+        end
+
+        def parse_operation(line_number,string)
+            a = string.split("\n")
+            line = a.shift
+            flags = line.split(" /")
+            line = flags.shift
+            elements = line.split(" ")
+            name = elements.shift
+            return_type_name = elements.shift
+            if return_type_name == "()"
+                name += return_type_name
+                return_type_name = elements.shift
+            end
+            alias_name = elements.shift
+            alias_name = if alias_name
+                             raise "#{line_number}: cannot parse #{string}" unless alias_name =~/^=.*/
+                             alias_name.gsub("=","")
+                         end
+
+            ns = RBase.namespace(name)
+            owner = type(ns,true)
+            if return_type_name == "explicit"
+                flags << return_type_name
+                return_type_name = nil
+            end
+            return_type = if return_type_name && !return_type_name.empty?
+                              find_type(owner,return_type_name)
+                          end
+            line_counter = 1
+            args = a.map do |line|
+                p = parameter(line_number+line_counter,line,owner)
+                line_counter += 1
+                p
+            end
+            op = ::Rbind::ROperation.new(name,return_type,*args)
+            op.alias = alias_name if alias_name && !alias_name.empty?
+            op.flags = normalize_flags(line_number,flags)
+            type(op.namespace,true).add_operation(op)
+            [op,line_counter]
+        end
+
+        def parse(string)
+            a = split(string)
+            a.pop #remove number at the end of the file
+            line_number = 1
+            a.each do |block|
+                begin
+                first = block.split(" ",2)[0]
+                obj,lines = if first == "const"
+                                parse_const(line_number,block)
+                            elsif first == "class"
+                                parse_class(line_number,block)
+                            elsif first == "struct"
+                                parse_struct(line_number,block)
+                            else
+                                parse_operation(line_number,block)
+                            end
+                line_number+=lines
+                rescue RuntimeError => e
+                    puts "Parsing Error: #{e}"
+                    puts "Line #{line_number}:"
+                    puts "--------------------------------------------------"
+                    puts block
+                    puts "--------------------------------------------------"
+                    Kernel.raise
+                    break
+                end
+            end
+        end
+
+        def split(string)
+            array = []
+            string.each_line do |line|
+                if !line.empty? && line[0] != " "
+                    array << line
+                else
+                    array[array.size-1] = array.last + line
+                end
+            end
+            array
+        end
+    end
+end

data/lib/rbind/generator_c.rb

@@ -0,0 +1,352 @@
+require 'erb'
+require 'delegate'
+require 'fileutils'
+
+module Rbind
+   class GeneratorC
+
+       class HelperBase
+           attr_accessor :includes
+           attr_accessor :name
+
+           def initialize(name,root)
+               @root = root
+               @name = name
+               @includes = []
+           end
+
+           def wrap_includes
+               includes.map do |i|
+                   if i =~ /<.*>/
+                       "#include #{i}"
+                   else
+                       "#include \"#{i}\""
+                   end
+               end.join("\n")
+           end
+
+           def binding
+               Kernel.binding
+           end
+       end
+
+       class TypesHelperHDR < HelperBase
+           def initialize(name, root)
+               raise "wrong type #{root}" unless root.is_a? RDataType
+               super
+               @type_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_wrapper.h")).read,nil,"-")
+           end
+
+           def cdelete_method
+               @root.cdelete_method
+           end
+
+           def type_wrapper(t)
+               @type_wrapper.result(t.binding)
+           end
+
+           def wrap_types
+               str = ""
+               @root.each_type do |type|
+                   next if type.basic_type?
+                   str += type_wrapper(type)
+               end
+               str
+           end
+       end
+
+       class TypesHelper < HelperBase
+           def initialize(name, root)
+               super
+               @type_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_delete.h")).read)
+           end
+
+           def cdelete_method
+               @root.cdelete_method
+           end
+
+           def type_wrapper(t)
+               @type_wrapper.result(t.binding)
+           end
+
+           def wrap_types
+               str = ""
+               @root.each_type do |type|
+                   next if type.basic_type?
+                   str += type_wrapper(type)
+               end
+               str
+           end
+       end
+
+       class ConstsHelper < HelperBase
+           def wrap_consts
+               str = ""
+               @root.each_type do |type|
+                   next if !type.container?
+                   next if type.consts.empty?
+                   str += "\n\n//constants for #{type.full_name}\n"
+                   str += type.consts.map do |c|
+                       "#{c.csignature};\n"
+                   end.join
+                   str
+               end
+               str
+           end
+       end
+
+       class ConversionsHelperHDR < HelperBase
+           def initialize(name,root)
+               super
+               @type_conversion = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_conversion.hpp")).read,nil,'-')
+               @type_typedef = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_typedef.h")).read)
+           end
+
+           def type_conversion(t)
+               @type_conversion.result(t.binding)
+           end
+
+           def type_typedef(t)
+               @type_typedef.result(t.binding)
+           end
+
+           def wrap_conversions
+               str = ""
+               @root.each_type do |type|
+                   str += type_typedef(type) if type.typedef?
+                   next if type.basic_type?
+                   str += type_conversion(type)
+               end
+               str
+           end
+       end
+
+       class ConversionsHelper < HelperBase
+           def initialize(name,root)
+               super
+               @type_conversion = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_conversion.cc")).read,nil,'-')
+           end
+
+           def type_conversion(t)
+               @type_conversion.result(t.binding)
+           end
+
+           def check_type?
+               type_check?
+           end
+
+           def wrap_conversions
+               str = ""
+               @root.each_type do |type|
+                   next if type.basic_type?
+                   str += type_conversion(type)
+               end
+               str
+           end
+       end
+
+       class OperationsHDRHelper < HelperBase
+           def initialize(name,root)
+               super
+           end
+
+           def wrap_operations
+               str = ""
+               @root.each_type do |type|
+                   next unless type.respond_to? :operations
+                   str2 = type.operations.map do |ops|
+                       ops.map do |op|
+                           "#{op.csignature};"
+                       end.join("\n")
+                   end.join("\n")
+                   if !str2.empty?
+                       str += "\n\n///methods for #{type.full_name}\n"
+                       str += str2
+                   end
+               end
+               str
+           end
+       end
+
+       class OperationsHelper < HelperBase
+           class OperationHelper < SimpleDelegator
+               def wrap_parameters
+                   cparameters.map do |arg|
+                       next if arg.type.basic_type?
+                       "#{"const " if arg.read_only?}#{arg.type.full_name} *#{arg.name}_ = fromC(#{arg.name});\n\t"
+                   end.compact.join("")
+               end
+
+               def wrap_call
+                   paras = parameters.map do |arg|
+                       "#{"*" if (!arg.type.ptr? && !arg.type.basic_type?)}#{arg.name}#{"_" if !arg.type.basic_type?}"
+                   end.join(", ")
+                   fct = if attribute?
+                             if return_type.name == "void" && !return_type.ptr?
+                                 "rbind_obj_->#{attribute.name} = #{paras};"
+                             else
+                                 if return_type.basic_type?
+                                     "return rbind_obj_->#{attribute.name};"
+                                 elsif return_type.ptr?
+                                     "return toC(rbind_obj_->#{attribute.name},false);"
+                                 else
+                                     "return toC(&rbind_obj_->#{attribute.name},false);"
+                                 end
+                             end
+                         else
+                             fct = if !constructor? && (return_type.name != "void" || return_type.ptr?)
+                                       if operator? && parameters.size == 1
+                                           if return_type.basic_type?
+                                               "return *rbind_obj_ #{operator} #{paras};"
+                                           else
+                                               "return toC(new #{return_type.full_name}(*rbind_obj_ #{operator} #{paras}));"
+                                           end
+                                       elsif return_type.basic_type?
+                                           "return #{full_name}(#{paras});"
+                                       elsif return_type.ptr?
+                                           "return toC(#{full_name}(#{paras}));"
+                                       else
+                                           "return toC(new #{return_type.full_name}(#{full_name}(#{paras})));"
+                                       end
+                                   else
+                                       if constructor?
+                                           "return toC(new #{namespace}(#{paras}));"
+                                       else
+                                           if operator?
+                                               "*rbind_obj_ #{operator} #{paras};"
+                                           else
+                                               "#{full_name}(#{paras});"
+                                           end
+                                       end
+                                   end
+                             #convert call to member call 
+                             if instance_method?
+                                 #add base class name space
+                                 if((inherit? && !abstract?) || ambiguous_name?)
+                                     fct.gsub(full_name,"rbind_obj_->#{base_class.name}::#{name}")
+                                 else
+                                     fct.gsub(full_name,"rbind_obj_->#{name}")
+                                 end
+                             else
+                                 fct
+                             end
+                         end
+               end
+
+               def binding
+                   Kernel.binding
+               end
+           end
+
+
+           def initialize(name,root)
+               super
+               @operation_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","operation_wrapper.cc")).read,nil,"-")
+           end
+
+           def operation_wrapper(op)
+               raise unless op
+               op2 = OperationHelper.new(op)
+               @operation_wrapper.result(op2.binding)
+           end
+
+           def wrap_operations
+               str = ""
+               @root.each_type do |type|
+                   next unless type.respond_to? :operations
+                   str += type.operations.map do |ops|
+                       ops.map do |op|
+                           operation_wrapper(op)
+                       end.join("\n")
+                   end.join("\n")
+               end
+               str
+           end
+       end
+
+       class CMakeListsHelper < HelperBase
+           def initialize(name,pkg_config=Array.new)
+               super
+               @find_package = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_package.txt")).read)
+           end
+
+           def find_packages
+               @root.map do |pkg|
+                    @find_package.result(pkg.instance_eval("binding"))
+               end.join("")
+           end
+
+           def libs
+               @root.map do |pkg|
+                   "${#{pkg.upcase}_LIBS} ${#{pkg.upcase}_LDFLAGS}"
+               end.join(" ")
+           end
+
+           def library_name
+               name
+           end
+       end
+
+       attr_accessor :includes
+       attr_accessor :library_name
+       attr_accessor :pkg_config
+       attr_accessor :generate_cmake
+
+       def initialize(root,library_name)
+           raise "wrong type #{root}" unless root.is_a? RNamespace
+           @root = root
+           @erb_types_hdr = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","types.h")).read)
+           @erb_types = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","types.cc")).read)
+           @erb_consts = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","consts.h")).read)
+           @erb_operations = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","operations.cc")).read)
+           @erb_operations_hdr = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","operations.h")).read)
+           @erb_conversions = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","conversions.cc")).read)
+           @erb_conversions_hdr = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","conversions.hpp")).read)
+           @erb_cmakelists = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","CMakeLists.txt")).read)
+           @erb_find_package = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_package.txt")).read)
+           @includes = Array.new
+           @pkgconfig= Array.new
+           @library_name = library_name
+           @generate_cmake = true
+       end
+
+       def generate(path = nil)
+           FileUtils.mkdir_p(path) if path && !File.directory?(path)
+           file_types_hdr = File.new(File.join(path,"types.h"),"w")
+           file_types = File.new(File.join(path,"types.cc"),"w")
+           file_consts = File.new(File.join(path,"constants.h"),"w")
+           file_operations = File.new(File.join(path,"operations.cc"),"w")
+           file_operations_hdr = File.new(File.join(path,"operations.h"),"w")
+           file_conversions = File.new(File.join(path,"conversions.cc"),"w")
+           file_conversions_hdr = File.new(File.join(path,"conversions.hpp"),"w")
+           file_cmakelists = File.new(File.join(path,"CMakeLists.txt"),"w")
+
+           types_hdr = TypesHelperHDR.new("_RBIND_TYPES_H_",@root)
+           file_types_hdr.write @erb_types_hdr.result(types_hdr.binding)
+
+           types = TypesHelper.new("types",@root)
+           file_types.write @erb_types.result(types.binding)
+
+           consts = ConstsHelper.new("_RBIND_CONSTS_H_",@root)
+           file_consts.write @erb_consts.result(consts.binding)
+
+           conversions_hdr = ConversionsHelperHDR.new("_RBIND_CONVERSIONS_H_",@root)
+           conversions_hdr.includes += includes
+           file_conversions_hdr.write @erb_conversions_hdr.result(conversions_hdr.binding)
+
+           conversions = ConversionsHelper.new("conversions",@root)
+           file_conversions.write @erb_conversions.result(conversions.binding)
+
+           operations_hdr = OperationsHDRHelper.new("_RBIND_OPERATIONS_H_",@root)
+           file_operations_hdr.write @erb_operations_hdr.result(operations_hdr.binding)
+
+           operations = OperationsHelper.new("operations",@root)
+           file_operations.write @erb_operations.result(operations.binding)
+
+           if generate_cmake
+               cmakelists = CMakeListsHelper.new(@library_name,@pkg_config)
+               file_cmakelists.write @erb_cmakelists.result(cmakelists.binding)
+           end
+       end
+   end
+end