rbind 0.0.16 → 0.0.17

data/lib/rbind/generator_c.rb

@@ -85,7 +85,7 @@ module Rbind
                @root.each_container do |type|
                    str2 = ""
                    type.each_const(false) do |c|
-                       str2 += "#{c.csignature};\n"
+                       str2 += "#{c.signature};\n"
                    end
                    if !str2.empty?
                         str += "\n\n//constants for #{type.full_name}\n"
@@ -169,7 +169,7 @@ module Rbind
                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"
+                       "#{arg.type.to_single_ptr.signature} #{arg.name}_ = fromC(#{arg.name});\n\t"
                    end.compact.join("")
                end
 

data/lib/rbind/generator_extern.rb

@@ -8,7 +8,7 @@ module Rbind
         attr_accessor :ruby_module_name
         attr_accessor :file_prefix
         def self.normalize_type_name(name)
-            name.gsub('::','.')
+            name.gsub('::','.').gsub(" ","")
         end
 
         def initialize(root)
@@ -26,8 +26,6 @@ module Rbind
             @root.each_type do |t|
                 if t.is_a? RClass
                     file_extern.write "class #{GeneratorExtern.normalize_type_name(t.full_name)} /Extern\n"
-                elsif t.is_a? RStruct
-                    file_extern.write "struct #{GeneratorExtern.normalize_type_name(t.full_name)} /Extern\n"
                 end
             end
 

data/lib/rbind/generator_ruby.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'delegate'
 require 'erb'
+require 'open-uri'
 
 module Rbind
     class GeneratorRuby
@@ -10,13 +11,23 @@ module Rbind
             attr_accessor :ffi_type_map
         end
         self.ruby_default_value_map ||= {"true" => "true","TRUE" => "true", "false" => "false","FALSE" => "false"}
-        self.ffi_type_map ||= {"char *" => "string","unsigned char" => "uchar" ,"const char *" => "string" }
+        self.ffi_type_map ||= {"char *" => "string","unsigned char" => "uchar" ,"const char *" => "string","uint8_t" => "uint8" }
 
 
         def self.keyword?(name)
             %w{__FILE__ __LINE__ alias and begin BEGIN break case class def defined? do else elsif end END ensure false for if in module next nil not or redo rescue retry return self super then true undef unless until when while yield}.include? name
         end
 
+        def self.normalize_doc(str)
+            return nil if !str || str.empty?
+            s = str
+            str = str.gsub(/\$\$(.*)\$\$/m) do
+                "![equation](http://latex.codecogs.com/gif.latex?#{URI::encode($1.to_s)})"
+            end
+            str = str.gsub(/^ *#?/,"# ")
+            "#{str.chomp}\n"
+        end
+
         def self.on_normalize_type_name(&block)
             self.on_normalize_type_name = block
         end
@@ -49,7 +60,8 @@ module Rbind
                           normalize_type_name(parameter.default_value)
                       end
                   else
-                      if(parameter.default_value =~ /([\w:]*) *\((.*)\)/)
+                      if(parameter.default_value =~ /([\w:<>]*) *\((.*)\)/)
+                          value = $2
                           t = parameter.owner.owner.type($1,false)
                           ops = Array(parameter.owner.owner.operation($1,false)) if !t
                           t,ops = if t || !ops.empty?
@@ -65,14 +77,14 @@ module Rbind
                                           [nil,nil]
                                       end
                                   end
-                          if ops && !ops.empty?
+                          s = if ops && !ops.empty?
                               if t
-                                "#{normalize_type_name(t.full_name)}::#{normalize_method_name(ops.first.name)}(#{($2)})"
+                                "#{normalize_type_name(t.full_name)}::#{normalize_method_name(ops.first.name)}(#{(value)})"
                               else
-                                "#{normalize_method_name(ops.first.name)}(#{($2)})"
+                                "#{normalize_method_name(ops.first.name)}(#{(value)})"
                               end
                           elsif t
-                              "#{normalize_type_name(t.full_name)}.new(#{($2)})"
+                              "#{normalize_type_name(t.full_name)}.new(#{(value)})"
                           end
                       else
                           parameter.default_value
@@ -87,15 +99,27 @@ module Rbind
 
 
         def self.normalize_type_name(name)
+            name = name.gsub(" ","")
+
+            # map template classes
+            # std::vector<std::string> -> Std::Vector::Std_String
+            if name =~ /([\w:]*)<(.*)>$/
+                return "#{normalize_type_name($1)}::#{normalize_type_name($2).gsub("::","_")}"
+            else
+                name
+            end
+
             # custom normalization
             if @on_normalize_type_name
                 n = @on_normalize_type_name.call(name)
                 return n if n
             end
 
+            # map all uint ... to Fixnum
             if name =~ /^u?int\d*$/ || name =~ /^u?int\d+_t$/
                 return "Fixnum"
             end
+
             name = name.gsub(/^_/,"")
             names = name.split("::").map do |n|
                 n.gsub(/^(\w)(.*)/) do 
@@ -106,7 +130,8 @@ module Rbind
             if n == n.upcase
                 return names.join("::")
             end
-            names.join("::").split("_").map do |n|
+
+            name = names.join("::").split("_").map do |n|
                 n.gsub(/^(\w)(.*)/) do 
                     $1.upcase+$2
                 end
@@ -123,24 +148,10 @@ module Rbind
             end
         end
 
-        # normalize c method to meet ruby conventions
-        # see unit tests
-        def self.normalize_method_name(orig_name)
-            #remove cprefix and replaced _X with #X
-            name = orig_name.to_s.gsub(/\A#{RBase.cprefix}/, "") .gsub(/_((?<!\A)\p{Lu})/u, '#\1')
-            #replaced X with _x
-            name = name.gsub(/(?<!\A)[\p{Lu}\d]/u, '_\0').downcase
-            #replaced _x_ with #x#
-            name = name.to_s.gsub(/[_#]([a-zA-Z\d])[_#]/u, '#\1#')
-            #replaced _x$ with #x
-            name = name.to_s.gsub(/[_#]([a-zA-Z\d])$/u, '#\1')
-            #replaced ## with _
-            name = name.gsub(/##/, '_')
-            #replace #xx with _xx
-            name = name.gsub(/#([a-zA-Z\d]{2})/, '_\1')
-            #remove all remaining #
-            name = name.gsub(/#/, '')
-            #replace operatorX with the correct ruby operator
+        def self.normalize_alias_method_name(orig_name)
+            name = orig_name
+            #replace operatorX with the correct ruby operator when 
+            #there are overloaded operators
             name = if name =~/^operator(.*)/
                         n = $1
                         if n =~ /\(\)/
@@ -165,6 +176,26 @@ module Rbind
                    else
                       name
                    end
+        end
+
+        # normalize c method to meet ruby conventions
+        # see unit tests
+        def self.normalize_method_name(orig_name)
+            #remove cprefix and replaced _X with #X
+            name = orig_name.to_s.gsub(/\A#{RBase.cprefix}/, "") .gsub(/_((?<!\A)\p{Lu})/u, '#\1')
+            #replaced X with _x
+            name = name.gsub(/(?<!\A)[\p{Lu}\d]/u, '_\0').downcase
+            #replaced _x_ with #x#
+            name = name.to_s.gsub(/[_#]([a-zA-Z\d])[_#]/u, '#\1#')
+            #replaced _x$ with #x
+            name = name.to_s.gsub(/[_#]([a-zA-Z\d])$/u, '#\1')
+            #replaced ## with _
+            name = name.gsub(/##/, '_')
+            #replace #xx with _xx
+            name = name.gsub(/#([a-zA-Z\d]{2})/, '_\1')
+            #remove all remaining #
+            name = name.gsub(/#/, '')
+            name = normalize_alias_method_name(name)
             raise "generated empty name for #{orig_name}" if name.empty?
             name
         end
@@ -231,37 +262,46 @@ module Rbind
                     str += "\n#methods for #{t.full_name}\n"
                     if t.cdelete_method
                         str += "attach_function :#{normalize_m t.cdelete_method},"\
-                        ":#{t.cdelete_method},[#{normalize_t t.full_name}],:void\n"
+                        ":#{t.cdelete_method},[#{normalize_t(t.full_name)}],:void\n"
                         str += "attach_function :#{normalize_m t.cdelete_method}_struct,"\
-                        ":#{t.cdelete_method},[#{normalize_t t.full_name}Struct],:void\n"
+                        ":#{t.cdelete_method},[#{normalize_t(t.full_name)}Struct],:void\n"
                     end
                     t.each_operation do |op|
                         return_type = if op.constructor?
                                           "#{normalize_t op.owner.full_name}"
                                       else
                                           if op.return_type.basic_type?
-                                              ":#{normalize_bt op.return_type.csignature}"
+                                              if op.return_type.ptr?
+                                                  ":pointer"
+                                              else
+                                                  ":#{normalize_bt op.return_type.to_raw.csignature}"
+                                              end
                                           else
                                               if op.return_type.extern_package_name
-                                                  normalize_t("::#{op.return_type.extern_package_name}::#{op.return_type.full_name}")
+                                                  normalize_t("::#{op.return_type.extern_package_name}::#{op.return_type.to_raw.full_name}")
                                               else
-                                                  normalize_t op.return_type.full_name
+                                                  normalize_t op.return_type.to_raw.full_name
                                               end
                                           end
                                       end
                         args = op.cparameters.map do |p|
                             if p.type.basic_type?
-                                ":#{normalize_bt p.type.csignature}"
+                                if p.type.ptr?
+                                    ":pointer"
+                                else
+                                    ":#{normalize_bt p.type.to_raw.csignature}"
+                                end
                             else
                                 if p.type.extern_package_name
-                                    normalize_t("::#{p.type.extern_package_name}::#{p.type.full_name}")
+                                    normalize_t("::#{p.type.extern_package_name}::#{p.type.to_raw.full_name}")
                                 else
-                                    normalize_t p.type.full_name
+                                    normalize_t p.type.to_raw.full_name
                                 end
                             end
                         end
                         fct_name = normalize_m op.cname
                         str += "attach_function :#{fct_name},:#{op.cname},[#{args.join(",")}],#{return_type}\n"
+                        str
                     end
                     str+"\n"
                 end
@@ -270,6 +310,37 @@ module Rbind
             end
         end
 
+        class RTypeTemplateHelper < HelperBase
+            def initialize(name, root,compact_namespace = false)
+                @type_template_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rtype_template.rb")).read,nil,"-")
+                super(name,root)
+            end
+
+            def name
+                GeneratorRuby.normalize_type_name(@name)
+            end
+
+            def cname
+                GeneratorRuby.normalize_type_name(@root.cname)
+            end
+
+            def add_doc
+                str = GeneratorRuby::normalize_doc(@root.doc)
+            end
+
+            def add_specializing(root = @root)
+                root.specialize_ruby
+            end
+
+            def result
+                return "" if @root.extern?
+                str = @type_template_wrapper.result(self.binding)
+                str.gsub!("\n","\n    ").gsub!("    \n","\n")
+                "    "+str[0,str.size-4]
+            end
+        end
+
+
         class RTypeHelper < HelperBase
             class OperationHelper < SimpleDelegator
                 def min_number_of_parameters
@@ -283,7 +354,7 @@ module Rbind
 
                 def signature_default_values
                     str = parameters.map do |p|
-                        if p.default_value 
+                        if p.default_value
                             GeneratorRuby.normalize_default_value p
                         else
                             "nil"
@@ -334,6 +405,49 @@ module Rbind
                     GeneratorRuby.normalize_method_name(__getobj__.cname)
                 end
 
+                def add_alias
+                    name = if auto_alias
+                               __getobj__.name
+                           else
+                               __getobj__.alias || __getobj__.name
+                           end
+                    name = GeneratorRuby::normalize_alias_method_name(name)
+                    if name == self.name || !cplusplus_alias?
+                        nil
+                    elsif static?
+                        "    class << self; alias :#{name} :#{self.name}; end\n"
+                    else
+                        "    alias :#{name} :#{self.name}\n"
+                    end
+                end
+
+                def add_specialize_ruby
+                    str = specialize_ruby
+                    "    #{str}\n" if str
+                end
+
+                def generate_param_doc
+                    paras = parameters.map do |p|
+                        n = GeneratorRuby.normalize_arg_name p.name
+                        t = GeneratorRuby.normalize_type_name(p.type.full_name)
+                        "# @param [#{t}] #{n} #{p.doc}"
+                    end
+                    if return_type
+                        t = GeneratorRuby.normalize_type_name(return_type.full_name)
+                        paras << "# @return [#{t}]"
+                    end
+                    paras.join("\n")+"\n"
+                end
+
+                def add_doc
+                    str = GeneratorRuby::normalize_doc(doc)
+                    str = if !parameters.empty? || return_type
+                              str += "#\n" if str
+                              "#{str}#{generate_param_doc}"
+                          end
+                    str.gsub(/^/,"    ") if str
+                end
+
                 def binding
                     Kernel.binding
                 end
@@ -359,6 +473,28 @@ module Rbind
                     end.join("\n")
                 end
 
+                def add_alias
+                    name = GeneratorRuby::normalize_alias_method_name(@root.first.alias || @root.first.name)
+                    if name == self.name || !@root.first.cplusplus_alias?
+                        nil
+                    elsif static?
+                        "    class << self; alias :#{name} :#{self.name}; end\n"
+                    else
+                        "    alias #{name} #{self.name}\n"
+                    end
+                end
+
+                def add_doc
+                    str = @root.map do |op|
+                        s = op.add_doc
+                        s ||= ""
+                        s = s.gsub(/( *#)/) do
+                            "#{$1}  "
+                        end
+                        "    # @overload #{op.name}(#{op.wrap_parameters_signature})\n#{s}"
+                    end.join("    #\n")
+                end
+
                 def binding
                     Kernel.binding
                 end
@@ -367,7 +503,7 @@ module Rbind
             def initialize(name, root,compact_namespace = false)
                 @type_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rtype.rb")).read,nil,"-")
                 @namespace_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rnamespace.rb")).read,nil,"-")
-                @static_method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rstatic_method.rb")).read)
+                @static_method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rstatic_method.rb")).read,nil,"-")
                 @method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","rmethod.rb")).read,nil,'-')
                 @overloaded_method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","roverloaded_method.rb")).read,nil,"-")
                 @overloaded_static_method_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","ruby","roverloaded_static_method.rb")).read,nil,"-")
@@ -389,11 +525,7 @@ module Rbind
             end
 
             def add_specializing(root = @root)
-                str = if @root.respond_to?(:specialize_ruby)
-                          root.specialize_ruby
-                      else
-                          ""
-                      end
+                str = root.specialize_ruby.to_s
                 root.each_type(false) do |t|
                     next if t.basic_type? && !t.is_a?(RNamespace)
                     str += add_specialize(t) if name == GeneratorRuby.normalize_type_name(t.full_name)
@@ -411,10 +543,25 @@ module Rbind
                 end.join("\n")
             end
 
+            def add_constructor_doc
+                ops = Array(@root.operation(@root.name,false))
+                ops = ops.map do |c|
+                    next if c.ignore?
+                    OperationHelper.new(c)
+                end.compact
+                if ops.empty?
+                    nil
+                elsif ops.size == 1
+                    ops.first.add_doc
+                else
+                    OverloadedOperationHelper.new(ops).add_doc
+                end
+            end
+
             def add_consts(root=@root)
                 str = @root.consts.map do |c|
                     next if c.extern? || c.ignore?
-                    "    #{c.name} = #{GeneratorRuby::normalize_type_name(c.value)}\n"
+                    "    #{c.name} = #{GeneratorRuby::normalize_type_name(c.default_value)}\n"
                 end.join
                 return str unless @compact_namespace
 
@@ -478,13 +625,16 @@ module Rbind
 
             def add_types(root = @root)
                 str = ""
-                root.each_type(false) do |t|
+                root.each_type(false,true) do |t|
+                    next if t.ignore? || t.extern?
                     next if t.basic_type? && !t.is_a?(RNamespace)
                     str += if @compact_namespace && name == GeneratorRuby.normalize_type_name(t.full_name)
-                        add_types(t)
-                    else
-                        RTypeHelper.new(t.name,t).result
-                    end
+                               add_types(t)
+                           elsif t.template?
+                               RTypeTemplateHelper.new(t.name,t).result
+                           else
+                               RTypeHelper.new(t.name,t).result
+                           end
                 end
                 str
             end
@@ -493,9 +643,13 @@ module Rbind
                 @root.full_name
             end
 
+            def add_doc
+                GeneratorRuby::normalize_doc(@root.doc)
+            end
+
             def result
                 return "" if @root.extern?
-                str = if @root.is_a? RStruct
+                str = if @root.is_a? RClass
                           @type_wrapper.result(self.binding)
                       else
                           @namespace_wrapper.result(self.binding)

data/lib/rbind/logger.rb

@@ -8,6 +8,9 @@ module Rbind
             o.log = ::Logger.new(STDOUT)
             o.log.level = ::Logger::INFO
             o.log.progname = o.name
+            o.log.formatter = proc do |severity, datetime, progname, msg|
+                "#{progname}: #{msg}\n"
+            end
         end
     end
     extend ::Rbind::Logger