rbind 0.0.22 → 0.0.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1d454d9b534689a66f1be06bc64fe72b14b8721
-  data.tar.gz: 546e600622265fda135f5bba965b4566693ae207
+  metadata.gz: a49ac912bcaf33b590650a1a9764e4055e1324f6
+  data.tar.gz: 2711d7f9cfbbf28b32aa7765914971f9f07f1da6
 SHA512:
-  metadata.gz: cb922be3df7b1180cf0a8ee5672884e918dde3db4755f7f115228887acc08af46626aae629994f254d668bd51e4dd1417e28ee79c03023a513b9ec7c8a46367f
-  data.tar.gz: e338f1e479038179af4316d48cce047d5a62638410a334d4da844cac3179dd8be9d6c26095b75af623ddba025a3d821fb7452cecaa7844d452dc3d6bd94834ce
+  metadata.gz: 2b5964e2a7e3b260879ded95cd659af9c918c16d78e7cd729ad34c720571d68a1eccdc620883ab8d246ef84dce2cea10ccb86eced4d7ee918bc42385967cb3f2
+  data.tar.gz: 8e855c1b6e0599cc5b9a966a794fe2badbdc4d7ba4ba1069d1b13560869c3c67319449ba5264a553014145ca46ec56fdd1b890c4b5ba6557e43aca00ff556086

data/do_install.sh

@@ -0,0 +1 @@
+gem build rbind.gemspec; gem install --no-rdoc --no-ri rbind-0.0.21.gem

data/lib/rbind/clang/clang.rb

@@ -5,6 +5,10 @@ module::Clang
 module Rbind
   extend FFI::Library
   clang_names = ['clang']
+
+  clang_names = Dir.glob("/usr/lib/libclang*")
+  clang_names.flatten!
+
   %w{3.4 3.3 3.2}.each do |llvm_version|
       clang_names << File.join("/", "usr", "lib", "llvm-#{llvm_version}", "lib", "libclang.so")
   end

data/lib/rbind/clang/clang_types.rb

@@ -85,6 +85,8 @@ module Clang
     # extend Structs to support auto dispose
     module Rbind
         class Cursor < FFI::Struct
+            extend ::Rbind::Logger
+
             def null?
                 1 == Rbind::cursor_is_null(self)
             end
@@ -149,13 +151,22 @@ module Clang
                 while !cursor.translation_unit?
                     namespace << cursor.spelling
                     cursor = cursor.semantic_parent
+                    if cursor.invalid_file?
+                        Cursor.log.warn "Cursor #{self} with invalid file"
+                        break
+                    end
                 end
+                namespace = namespace.select{|s| !s.empty?}
                 namespace.reverse.join("::")
             end
 
             def translation_unit?
                 kind == :translation_unit
             end
+
+            def invalid_file?
+                kind == :invalid_file
+            end
             
             def expression
                 num = FFI::MemoryPointer.new(:uint,1)
@@ -198,7 +209,7 @@ module Clang
                 Rbind::get_cursor_type self
             end
 
-            def virtul_base?
+            def virtual_base?
                 1 == Rbind::is_virtual_base(self)
             end
 

data/lib/rbind/clang_parser.rb

@@ -40,13 +40,28 @@ module Rbind
         include Hooks
         extend ::Rbind::Logger
 
+        def self.default_arguments
+            @default_arguments || ["-xc++","-fno-rtti"]
+        end
+
+        def self.default_arguments=(args)
+            if not args.kind_of?(Array)
+                raise ArgumentError, "Clang::default_arguments require Array"
+            end
+            @default_arguments = args
+        end
+
+        def self.reset_default_arguments
+            @default_arguments = []
+        end
+
         def initialize(root=nil)
             super(nil,root)
             add_default_types if !root
             @clang = Clang::Clang.new
         end
 
-        def parse(file_path,args = ["-xc++","-fno-rtti"])
+        def parse(file_path, args = ClangParser.default_arguments)
             tu = @clang.translation_unit(file_path,args)
             process(tu.cursor)
             self
@@ -78,7 +93,8 @@ module Rbind
         end
 
         # if rbind_type is given only pointer/ref or qualifier are applied
-        def to_rbind_type(parent,cursor,rbind_type=nil,type_getter = :type,canonical = true)
+        def to_rbind_type(parent,cursor,rbind_type=nil,type_getter = :type,canonical = true, use_fallback = true)
+            ClangParser.log.debug "Parent: #{parent} --> cursor: #{cursor.expression}, spelling #{cursor.spelling}"
             clang_type = cursor.send(type_getter)
             return nil if clang_type.null?
             clang_type = clang_type.canonical_type if canonical
@@ -110,8 +126,13 @@ module Rbind
                            end
                     t = parent.type(name,!canonical)
                 end
-            # try again without canonical
-            return to_rbind_type(parent,cursor,rbind_type,type_getter,false) if !t
+
+            # try again without canonical when type could not be found or type is template
+            if use_fallback
+                if !t || t.template?
+                    return to_rbind_type(parent,cursor,rbind_type,type_getter,false, false)
+                end
+            end
 
             # add pointer level
             1.upto(level) do
@@ -133,74 +154,85 @@ module Rbind
         end
 
         # entry call to parse a file
-        def process(cursor,parent = self)
-            access = :public
+        def process(cursor, parent = self, access = :public)
             last_obj = nil
             cursor.visit_children(false) do |cu,cu_parent|
-                # puts "----->#{cu.kind} #{cu.spelling} #{cu.type.kind} #{cu.specialized_template.kind}"
-                last_obj = case cu.kind
-                           when :namespace
-                               process_namespace(cu,parent)
-                           when :enum_decl
-                               process_enum(cu,parent) if access == :public
-                           when :union_decl
-                               #        puts "got union declaration #{cu.spelling}"
-                           when :struct_decl
-                               if access == :public
-                                   process_class(cu,parent)
-                               end
-                           when :class_decl
-                               if access == :public
-                                   access = :private
-                                   klass = process_class(cu,parent)
-                                   access = :public
-                                   klass
-                               end
-                           when :function_decl
-                               process_function(cu,parent) if access == :public
-                           when :macro_expansion # CV_WRAP ...
-                               #           puts "got macro #{cu.spelling} #{cu.location}"
-                           when :function_template
-                               #        puts "got template fuction #{cu.spelling} #{cu.location}"
-                           when :class_template
-                               process_class_template(cu,parent)
-                           when :template_type_parameter
-                               #   if !cu.spelling.empty?
-                               #       parent.add_type(RTemplateParameter.new(cu.spelling))
-                               #   else
-                               #       ClangParser.log.info "no template parameter name"
-                               #   end
-                           when :x_access_specifier
-                               access = normalize_accessor(cu.cxx_access_specifier)
-                           when :x_base_specifier
-                               local_access = normalize_accessor(cu.cxx_access_specifier)
-                               p = parent.type(RBase.normalize(cu.spelling),false)
-                               ClangParser.log.info "auto add parent class #{cu.spelling}" unless p
-                               p ||= parent.add_type(RClass.new(RBase.normalize(cu.spelling)))
-                               parent.add_parent p,local_access
-                           when :field_decl
-                               process_field(cu,parent) if cu.public? || access == :public
-                           when :constructor
-                               if access == :public
-                                   f = process_function(cu,parent)
-                                   f.return_type = nil if f
-                                   f
-                               end
-                           when :x_method
-                               process_function(cu,parent) if access == :public
-                           when :typedef_decl
-                               # rename object if parent has no name
-                               if last_obj && last_obj.name =~ /no_name/
-                                   ClangParser.log.info "rename #{last_obj.name} to #{cu.spelling}"
-                                   last_obj.rename(cu.spelling)
-                                   last_obj
+                ClangParser.log.debug "process ----->#{cu.kind} #{cu.spelling} #{cu.type.kind} #{cu.specialized_template.kind} ---> expr: #{cu.expression.join('|')} -- public: #{cu.public?} access: #{access}"
+                begin
+                    last_obj = case cu.kind
+                               when :namespace
+                                   process_namespace(cu,parent)
+                               when :enum_decl
+                                   process_enum(cu,parent) if access == :public
+                               when :union_decl
+                                   #        puts "got union declaration #{cu.spelling}"
+                               when :struct_decl
+                                   process_class(cu,parent,:public) if access == :public
+                               when :class_decl
+                                   process_class(cu,parent, :private) if access == :public
+                               when :function_decl
+                                   process_function(cu,parent) if access == :public
+                               when :macro_expansion # CV_WRAP ...
+                                   #           puts "got macro #{cu.spelling} #{cu.location}"
+                               when :function_template
+                                   #        puts "got template fuction #{cu.spelling} #{cu.location}"
+                               when :class_template
+                                   process_class_template(cu,parent, access) if access == :public
+                               when :template_type_parameter
+                                      if !cu.spelling.empty?
+                                          parent.add_type(RTemplateParameter.new(cu.spelling))
+                                      else
+                                          ClangParser.log.info "no template parameter name"
+                                      end
+                               when :x_access_specifier
+                                   access = normalize_accessor(cu.cxx_access_specifier)
+                               when :x_base_specifier
+                                   if access == :public
+                                       next
+                                   end
+                                   local_access = normalize_accessor(cu.cxx_access_specifier)
+                                   klass_name = cu.spelling
+                                   if cu.spelling =~ /\s?([^\s]+$)/
+                                       klass_name = $1
+                                   end
+                                   ClangParser.log.info "auto add parent class #{klass_name} if needed"
+                                   p = parent.type(RClass.new(RBase.normalize(klass_name)), true)
+                                   parent.add_parent p,local_access
+                               when :field_decl
+                                   process_field(cu,parent) if access == :public
+                               when :constructor
+                                   if access == :public
+                                       f = process_function(cu,parent)
+                                       f.return_type = nil if f
+                                       f
+                                   end
+                               when :x_method
+                                   process_function(cu,parent) if access == :public
+                               when :typedef_decl
+                                   if access != :public
+                                       next
+                                   end
+                                   # rename object if parent has no name
+                                   if last_obj && last_obj.respond_to?(:name) && last_obj.name =~ /no_name/
+                                       ClangParser.log.info "rename #{last_obj.name} to #{cu.spelling}"
+                                       last_obj.rename(cu.spelling)
+                                       last_obj
+                                   else
+                                       process_typedef(cu, parent)
+                                   end
+                               when :var_decl
+                                   process_variable(cu,parent) if access == :public
+                               when :unexposed_decl
+                                   process(cu) if access == :public
+                               else
+                                   #puts "skip: #{cu.spelling}"
                                end
-                           when :var_decl
-                               process_variable(cu,parent) if access == :public
-                           else
-                               #puts "skip: #{cu.spelling}"
-                           end
-                raise ClangParserError.new("jjj",cu) if last_obj.is_a? Fixnum
+                    rescue Exception => e
+                        ClangParser.log.debug "Parsing failed -- skipping"
+                    end
+                    raise ClangParserError.new("jjj",cu) if last_obj.is_a? Fixnum
+
+
             end
         end
 
@@ -262,7 +294,7 @@ module Rbind
             a
         end
 
-        def process_class_template(cursor,parent)
+        def process_class_template(cursor,parent,access)
             class_name = cursor.spelling
             ClangParser.log.info "processing class template #{parent}::#{class_name}"
 
@@ -275,11 +307,11 @@ module Rbind
                         ClangParser.log.info " reopening existing class template #{klass}"
                         klass
                     end
-            process(cursor,klass)
+            process(cursor,klass, access)
             klass
         end
 
-        def process_class(cursor,parent)
+        def process_class(cursor,parent,access)
             class_name = cursor.spelling
             class_name = if class_name.empty?
                              "no_name_class"
@@ -306,13 +338,13 @@ module Rbind
                             ClangParser.log.info " skipping template #{name}"
                             nil
                         else
-                            ClangParser.log.warn " skipping non empty clas #{name}"
+                            ClangParser.log.warn " skipping non empty class #{name}"
                             #raise "Cannot reopening existing class #{klass} which is non-empty!"
                             nil
                         end
                     end
             #klass.extern_package_name = nil
-            process(cursor,klass) if klass
+            process(cursor,klass,access) if klass
             klass
         end
 
@@ -339,8 +371,10 @@ module Rbind
             # to prevent name clashes
             expression = cursor.expression.join()
             args.each_with_index do |arg,idx|
-                if(!arg.default_value && (expression =~ /#{arg.name}=(\w*)/))
-                    arg.default_value = $1
+                if(!arg.default_value && (expression =~ /#{arg.name}(=\w*)?[,)]/))
+                    if $1 and !$1.empty?
+                        arg.default_value = $1.sub("=","")
+                    end
                 end
                 arg.name = if(arg.name == "no_name_arg")
                                arg.name + idx.to_s
@@ -368,6 +402,7 @@ module Rbind
 
         # type_getter is also used for :result_type
         def process_parameter(cursor,parent,type_getter = :type)
+            ClangParser.log.debug "process_parameter: spelling: '#{cursor.spelling}' type: '#{cursor.type}' kind '#{cursor.type.kind} parent #{parent}"
             para_name = cursor.spelling
             para_name = if para_name.empty?
                             "no_name_arg"
@@ -380,6 +415,7 @@ module Rbind
             name_space = []
 
             cursor.visit_children do |cu,_|
+                ClangParser.log.info "process parameter: cursor kind: #{cu.kind} #{cu.expression}"
                 case cu.kind
                 when :integer_literal
                     exp = cu.expression
@@ -412,6 +448,14 @@ module Rbind
                     name_space << cu.spelling
                 when :type_ref
                     type_cursor = cu
+                when :compound_stmt
+                when :parm_decl
+                when :member_ref
+                when :constant_array
+                    exp = cu.expression
+                    exp.pop
+                    default_value = exp.gsub("{","[")
+                    default_value = default_value.gsub("}","]")
                 end
             end
             type = if template_name.empty?
@@ -447,5 +491,33 @@ module Rbind
         rescue RuntimeError => e
             raise ClangParserError.new(e.to_s,cursor)
         end
+
+        def process_typedef(cu, parent)
+            ClangParser.log.debug "process_typedef: #{cu}: expression: #{cu.expression} parent: #{parent}"
+            exp = cu.expression.join(" ")
+
+            # Remove typedef label and extract orig type and alias
+            orig_and_alias = exp.sub("typedef","")
+            orig_and_alias = orig_and_alias.sub(";","").strip
+            orig_type = nil
+            alias_type = nil
+
+            if orig_and_alias =~ /(.*)\s+([^\s]+)/
+                orig_type = $1
+                alias_type = $2
+            else
+                raise RuntimeError,"Cannot parse typedef expression #{exp}"
+            end
+
+            begin
+                t = parent.type(orig_type)
+                ClangParser.log.debug "process_typedef: orig: '#{orig_type}' alias: #{alias_type}"
+                parent.add_type_alias(t, alias_type)
+            rescue RuntimeError => e
+                ClangParser.log.warn "Cannot process typedef expression for orig: '#{orig_type}' alias: '#{alias_type}' : #{e}"
+            end
+            parent
+        end
+
     end
 end

data/lib/rbind/core.rb

@@ -17,3 +17,4 @@ require 'rbind/core/rtype_qualifier.rb'
 
 require 'rbind/types/std_vector.rb'
 require 'rbind/types/std_string.rb'
+require 'rbind/types/std_map.rb'

data/lib/rbind/core/rbase.rb

@@ -20,25 +20,17 @@ module Rbind
                 name = normalize(name)
                 cn = "#{cprefix}#{name.gsub("::","_")}"
                 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")
+                    # Use alias instead of operator symbol for name
+                    RNamespace.default_operator_alias.each do |op, alias_name|
+                        cn = cn.gsub("operator#{op}","operator_#{alias_name}")
+                    end
                 end
                 cn = cn.gsub("*","_ptr")
                 cn = cn.gsub("&","_ref")
                 cn = cn.gsub("<","_")
                 cn = cn.gsub(">","")
                 cn = cn.gsub(",","__")
+                cn
             end
 
             def normalize(name)

data/lib/rbind/core/rclass.rb

@@ -84,7 +84,7 @@ module Rbind
                               []
                           end
                     other_ops.delete_if do |other_op|
-                        next true if !other_op
+                        next true if !other_op || other_op.constructor?
                         op = ops.find do |o|
                             o == other_op
                         end

data/lib/rbind/core/rdata_type.rb

@@ -26,7 +26,7 @@ module Rbind
         def cname(value=nil)
             if !value
                 if basic_type? && !@cname
-                    name
+                    full_name
                 else
                     super
                 end

data/lib/rbind/core/renum.rb

@@ -9,7 +9,7 @@ module Rbind
         end
 
         def generate_signatures
-            ["#{full_name} = #{values}","const #{cname} = #{values}"]
+            ["#{full_name}","#{cname}"]
         end
 
         def basic_type?