rbind 0.0.26 → 0.0.27

data/lib/rbind/generator_c.rb

@@ -4,15 +4,16 @@ require 'fileutils'
 
 module Rbind
    class GeneratorC
-
        class HelperBase
            attr_accessor :includes
            attr_accessor :name
+           attr_accessor :extern_types
 
-           def initialize(name,root)
+           def initialize(name,root,extern_types=Hash.new)
                @root = root
                @name = name
                @includes = []
+               @extern_types = extern_types
            end
 
            def wrap_includes
@@ -31,7 +32,7 @@ module Rbind
        end
 
        class TypesHelperHDR < HelperBase
-           def initialize(name, root)
+           def initialize(name, root,extern_types)
                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,"-")
@@ -47,6 +48,10 @@ module Rbind
 
            def wrap_types
                str = ""
+               @extern_types.each do |type|
+                   next if type.basic_type?
+                   str += type_wrapper(type)
+               end
                @root.each_type do |type|
                    next if type.basic_type?
                    str += type_wrapper(type)
@@ -56,7 +61,7 @@ module Rbind
        end
 
        class TypesHelper < HelperBase
-           def initialize(name, root)
+           def initialize(name, root,extern_types)
                super
                @type_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_delete.h")).read)
            end
@@ -71,6 +76,10 @@ module Rbind
 
            def wrap_types
                str = ""
+               @extern_types.each do |type|
+                   next if type.basic_type?
+                   str += type_wrapper(type)
+               end
                @root.each_type do |type|
                    next if type.basic_type?
                    str += type_wrapper(type)
@@ -98,7 +107,7 @@ module Rbind
        end
 
        class ConversionsHelperHDR < HelperBase
-           def initialize(name,root)
+           def initialize(name,root,extern_types)
                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)
@@ -114,6 +123,11 @@ module Rbind
 
            def wrap_conversions
                str = ""
+               @extern_types.each do |type|
+                   str += type_typedef(type) if type.typedef?
+                   next if type.basic_type?
+                   str += type_conversion(type)
+               end
                @root.each_type do |type|
                    str += type_typedef(type) if type.typedef?
                    next if type.basic_type?
@@ -124,7 +138,7 @@ module Rbind
        end
 
        class ConversionsHelper < HelperBase
-           def initialize(name,root)
+           def initialize(name,root,extern_types)
                super
                @type_conversion = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","type_conversion.cc")).read,nil,'-')
            end
@@ -135,6 +149,10 @@ module Rbind
 
            def wrap_conversions
                str = ""
+               @extern_types.each do |type|
+                   next if type.basic_type?
+                   str += type_conversion(type)
+               end
                @root.each_type do |type|
                    next if type.basic_type?
                    str += type_conversion(type)
@@ -144,7 +162,7 @@ module Rbind
        end
 
        class OperationsHDRHelper < HelperBase
-           def initialize(name,root)
+           def initialize(name,root,extern_types)
                super
            end
 
@@ -153,7 +171,7 @@ module Rbind
                @root.each_container do |type|
                    str2 = ""
                    type.each_operation do |op|
-                       str2 += "#{op.csignature};\n"
+                       str2 += "RBIND_EXPORTS #{op.csignature};\n"
                    end
                    if !str2.empty?
                        str += "\n\n///methods for #{type.full_name}\n"
@@ -189,6 +207,16 @@ module Rbind
                                      "return toC(&rbind_obj_->#{attribute.name},false);"
                                  end
                              end
+                         elsif __getobj__.is_a?(RCastOperation)
+                             param = if paras.empty?
+                                        "rbind_obj_"
+                                     else
+                                        paras
+                                     end
+                             str = "#{return_type} *__rbind_temp_ = dynamic_cast<#{return_type}*>(#{param});\n"
+                             str += "\tif(!__rbind_temp_)\n"
+                             str += "\t\t throw std::runtime_error(\"Typecast failed, incompatible types\");\n"
+                             str + "\treturn toC(__rbind_temp_,false);"
                          else
                              fct = if !constructor? && (return_type.name != "void" || return_type.ptr?)
                                        # operator+, operator++ etc
@@ -242,7 +270,7 @@ module Rbind
            end
 
 
-           def initialize(name,root)
+           def initialize(name,root,extern_types)
                super
                @operation_wrapper = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","operation_wrapper.cc")).read,nil,"-")
            end
@@ -265,12 +293,16 @@ module Rbind
        end
 
        class CMakeListsHelper < HelperBase
-           def initialize(name,pkg_config=Array.new,libs=Array.new,gems=Array.new)
+           def initialize(name,lib_name,pkg_config=Array.new,libs=Array.new,ruby_path)
                super(name,pkg_config)
                @libs = libs
-               @gems = gems
-               @find_gem = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_gem.txt")).read)
+               @library_name = lib_name
                @find_package = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","find_package.txt")).read)
+               @ruby_path = ruby_path
+           end
+
+           def ruby_path
+               @ruby_path
            end
 
            def find_packages
@@ -279,10 +311,6 @@ module Rbind
                end.join("")
            end
 
-           def find_gems
-               @find_gem.result(@gems.instance_eval("binding")) unless @gems.empty?
-           end
-
            def libs
                str = @root.map do |pkg|
                    "${#{pkg.upcase}_LIBS} ${#{pkg.upcase}_LDFLAGS_OTHER}"
@@ -291,7 +319,7 @@ module Rbind
            end
 
            def library_name
-               name
+               @library_name
            end
        end
 
@@ -299,11 +327,11 @@ module Rbind
        attr_accessor :library_name
        attr_accessor :libs
        attr_accessor :pkg_config
-       attr_accessor :gems
        attr_accessor :generate_cmake
        attr_accessor :output_path
+       attr_accessor :ruby_path
 
-       def initialize(root,library_name)
+       def initialize(root,name,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)
@@ -315,17 +343,17 @@ module Rbind
            @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)
-           @erb_pkg_config = ERB.new(File.open(File.join(File.dirname(__FILE__),"templates","c","rbind.pc.in")).read)
            @includes = Array.new
            @pkg_config= Array.new
-           @gems = Array.new
            @library_name = library_name
+           @name = name
            @generate_cmake = true
            @libs = []
        end
 
-       def generate(path = @output_path)
+       def generate(path = @output_path,ruby_path = @ruby_path)
            @output_path = path
+           @ruby_path = ruby_path
            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")
@@ -334,64 +362,39 @@ module Rbind
            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")
-           rbind_pkgs = Rbind.rbind_pkgs(@pkg_config)
-           gem_paths = @gems.map do |gem|
-               Rbind.gem_path(gem)
-           end
 
-           types_hdr = TypesHelperHDR.new("_#{library_name.upcase}_TYPES_H_",@root)
-           types_hdr.includes = rbind_pkgs.map do |p|
-               "<#{p}/types.h>"
-           end
-           types_hdr.includes += gem_paths.map do |gem|
-               "<#{gem}/types.h>"
-           end
+           # mark all extern types which must be wrapped
+           extern_types = @root.used_extern_types
+
+           types_hdr = TypesHelperHDR.new("_#{library_name.upcase}_TYPES_H_",@root,extern_types)
            file_types_hdr.write @erb_types_hdr.result(types_hdr.binding)
 
-           types = TypesHelper.new("types",@root)
+           types = TypesHelper.new("types",@root,extern_types)
            file_types.write @erb_types.result(types.binding)
 
            consts = ConstsHelper.new("_#{library_name.upcase}_CONSTS_H_",@root)
-           consts.includes = rbind_pkgs.map do |p|
-               "<#{p}/constants.h>"
-           end
-           consts.includes += gem_paths.map do |gem|
-               "<#{gem}/constants.h>"
-           end
            file_consts.write @erb_consts.result(consts.binding)
 
-           conversions_hdr = ConversionsHelperHDR.new("#{library_name.upcase}_CONVERSIONS_H_",@root)
-           conversions_hdr.includes = rbind_pkgs.map do |p|
-               "<#{p}/conversions.hpp>"
-           end
+           conversions_hdr = ConversionsHelperHDR.new("#{library_name.upcase}_CONVERSIONS_H_",@root,extern_types)
            conversions_hdr.includes += includes
-           conversions_hdr.includes += gem_paths.map do |gem|
-               "<#{gem}/conversions.hpp>"
-           end
            file_conversions_hdr.write @erb_conversions_hdr.result(conversions_hdr.binding)
 
-           conversions = ConversionsHelper.new("conversions",@root)
+           conversions = ConversionsHelper.new("conversions",@root,extern_types)
            file_conversions.write @erb_conversions.result(conversions.binding)
 
-           operations_hdr = OperationsHDRHelper.new("_#{library_name.upcase}_OPERATIONS_H_",@root)
+           operations_hdr = OperationsHDRHelper.new("_#{library_name.upcase}_OPERATIONS_H_",@root,extern_types)
            file_operations_hdr.write @erb_operations_hdr.result(operations_hdr.binding)
 
-           operations = OperationsHelper.new("operations",@root)
+           operations = OperationsHelper.new("operations",@root,extern_types)
            file_operations.write @erb_operations.result(operations.binding)
 
            if generate_cmake && !File.exist?(File.join(path,"CMakeLists.txt"))
                file_cmakelists = File.new(File.join(path,"CMakeLists.txt"),"w")
-               cmakelists = CMakeListsHelper.new(@library_name,@pkg_config,@libs,@gems)
+               cmakelists = CMakeListsHelper.new(@name,@library_name,@pkg_config,@libs,@ruby_path)
                file_cmakelists.write @erb_cmakelists.result(cmakelists.binding)
-               if !File.exist?(File.join(path,"rbind.pc.in"))
-                   file_pkg_config = File.new(File.join(path,"rbind.pc.in"),"w")
-                   file_pkg_config.write @erb_pkg_config.result(Kernel.binding)
-               end
-
                src_path = File.join(File.dirname(__FILE__),"templates","c","cmake")
                cmake_path = File.join(path,"cmake")
                FileUtils.mkdir_p(cmake_path) if !File.directory?(cmake_path)
-               FileUtils.copy(File.join(src_path,"FindGem.cmake"),File.join(cmake_path,"FindGem.cmake"))
                FileUtils.copy(File.join(src_path,"FindRuby.cmake"),File.join(cmake_path,"FindRuby.cmake"))
            end
        end

data/lib/rbind/generator_extern.rb

@@ -2,11 +2,13 @@ require 'yaml'
 
 module Rbind
     class GeneratorExtern
-        Config = Struct.new(:ruby_module_name,:file_prefix)
+        Config = Struct.new(:ruby_module_name,:file_prefix,:cpath)
 
         attr_accessor :output_path
         attr_accessor :ruby_module_name
         attr_accessor :file_prefix
+        attr_accessor :cpath
+
         def self.normalize_type_name(name)
             name.gsub('::','.').gsub(" ","")
         end
@@ -19,10 +21,11 @@ module Rbind
             @root = root
         end
 
-        def generate(path = @output_path,ruby_module_name = @ruby_module_name,file_prefix = @file_prefix)
+        def generate(path = @output_path,ruby_module_name = @ruby_module_name,file_prefix = @file_prefix,cpath=@cpath)
             @output_path = path
             @ruby_module_name = ruby_module_name
             @file_prefix = file_prefix
+            @cpath = File.expand_path(cpath)
             FileUtils.mkdir_p(path) if path && !File.directory?(path)
             file_extern = File.new(File.join(path,"extern.rbind"),"w")
             file_config = File.new(File.join(path,"config.rbind"),"w")
@@ -43,6 +46,7 @@ module Rbind
             @root.each_type do |t|
                 if t.is_a? RClass
                     t.each_operation do |op|
+                        next if op.is_a? RCastOperation
                         r = if op.return_type
                                 GeneratorExtern.normalize_type_name(op.return_type.full_name)
                             end
@@ -56,7 +60,7 @@ module Rbind
             end
 
             file_extern.write("\n")
-            file_config.write Config.new(ruby_module_name,file_prefix).to_yaml
+            file_config.write Config.new(ruby_module_name,file_prefix,@cpath).to_yaml
         end
     end
 end

data/lib/rbind/generator_ruby.rb

@@ -170,7 +170,7 @@ module Rbind
                 n.gsub(/^(\w)(.*)/) do 
                     $1.upcase+$2
                 end
-            end.join("")
+            end.join("_")
         end
 
         def self.normalize_basic_type_name_ffi(name)

data/lib/rbind/logger.rb

@@ -6,7 +6,8 @@ module Rbind
         def self.extend_object(o)
             super
             o.log = ::Logger.new(STDOUT)
-            o.log.level = ::Logger::INFO
+            #o.log.level = ::Logger::INFO
+            o.log.level = ::Logger::WARN
             o.log.progname = o.name
             o.log.formatter = proc do |severity, datetime, progname, msg|
                 "#{progname}: #{msg}\n"

data/lib/rbind/rbind.rb

@@ -8,7 +8,7 @@ module Rbind
         attr_accessor :includes
         attr_accessor :name
         attr_accessor :pkg_config
-        attr_accessor :gems
+        attr_accessor :rbind_pkgs    # extern rbind pkgs
 
         def self.pkg_paths(pkg_name)
             out = IO.popen("pkg-config --cflags-only-I #{pkg_name}")
@@ -19,41 +19,21 @@ module Rbind
             paths
         end
 
-        def self.rbind_pkgs(pkg_names)
-            pkg_names.find_all do |p|
-                !!(p =~ /^rbind_.*/)
-            end
-        end
-
-        def self.gem_path(gem_name)
-            # TODO use gem api
-            out = IO.popen("gem contents #{gem_name}")
-            out.readlines.each do |line|
-                return $1 if line =~ /(.*)extern.rbind/
-            end
-            raise "Cannot find paths for gem #{gem_name}"
-        end
-
-        def self.rbind_pkg_paths(pkg_names)
-            rbind_packages = rbind_pkgs(pkg_names)
-            rbind_paths = rbind_packages.map do |pkg|
-                paths = pkg_paths(pkg)
-                path = paths.find do |p|
-                    File.exist?(File.join(p,pkg,"extern.rbind"))
-                end
-                raise "cannot find extern.rbind for rbind package #{pkg}" unless path
-                File.join(path,pkg)
-            end
+        def self.rbind_pkg_path(name)
+            files = Gem.find_files("#{name}/rbind/extern.rbind")
+            raise "Cannot find paths for rbind package #{name}" if files.empty?
+            File.dirname(files.first)
         end
 
         def initialize(name,parser = DefaultParser.new)
-            @name = name
+            @name = GeneratorRuby.name
             @includes = []
             @pkg_config = []
-            @gems = []
+            @rbind_pkgs= []
             @parser = parser
+
             lib_name = "rbind_#{name.downcase}"
-            @generator_c = GeneratorC.new(@parser,lib_name)
+            @generator_c = GeneratorC.new(@parser,name,lib_name)
             @generator_ruby = GeneratorRuby.new(@parser,name,lib_name)
             @generator_extern = GeneratorExtern.new(@parser)
         end
@@ -90,19 +70,11 @@ module Rbind
         def parse_extern
             # extern package are always paresed with the default parser 
             local_parser = DefaultParser.new(parser)
-            paths = Rbind.rbind_pkg_paths(@pkg_config)
-            paths.each do |pkg|
-                config = YAML.load(File.open(File.join(pkg,"config.rbind")).read)
-                path = File.join(pkg,"extern.rbind")
-                ::Rbind.log.info "parsing extern rbind pkg file #{path}"
-                raise "no module name found" if !config.ruby_module_name || config.ruby_module_name.empty?
-                local_parser.parse(File.open(path).read,config.ruby_module_name)
-            end
-            @gems.each do |gem|
-                path = Rbind.gem_path(gem)
+            @rbind_pkgs.each do |pkg|
+                path = Rbind.rbind_pkg_path(pkg)
                 config = YAML.load(File.open(File.join(path,"config.rbind")).read)
                 path = File.join(path,"extern.rbind")
-                ::Rbind.log.info "parsing extern gem file #{path}"
+                ::Rbind.log.info "parsing extern rbind file #{path}"
                 local_parser.parse(File.open(path).read,config.ruby_module_name)
             end
             self
@@ -127,6 +99,10 @@ module Rbind
             parser.parse parse_headers_dry(*headers)
         end
 
+        def parse_header(header)
+            parser.parse parse_headers_dry(header)
+        end
+
         def build
             ::Rbind.log.info "build c wrappers"
             path = File.join(generator_c.output_path,"build")
@@ -146,33 +122,27 @@ module Rbind
         end
 
         def generate(c_path = "src",ruby_path = "ruby/lib/#{name.downcase}")
-            generate_c c_path
-            generate_extern c_path
+            generate_c c_path,ruby_path
+            generate_extern ruby_path,c_path
             generate_ruby ruby_path
         end
 
         def generate_ruby(path)
             ::Rbind.log.info "generate ruby ffi wrappers"
-            paths = Rbind.rbind_pkg_paths(@pkg_config)
-            modules = paths.map do |pkg|
-                config = YAML.load(File.open(File.join(pkg,"config.rbind")).read)
-                config.file_prefix
-            end
-            @generator_ruby.required_module_names = modules + gems
+            @generator_ruby.required_module_names = rbind_pkgs
             @generator_ruby.generate(path)
         end
 
-        def generate_c(path)
+        def generate_c(path,ruby_path)
             ::Rbind.log.info "generate c wrappers"
             @generator_c.includes += includes
             @generator_c.includes.uniq!
             @generator_c.pkg_config = pkg_config
-            @generator_c.gems = gems
-            @generator_c.generate(path)
+            @generator_c.generate(path,ruby_path)
         end
 
-        def generate_extern(path)
-            @generator_extern.generate(path,@generator_ruby.module_name,@generator_ruby.file_prefix)
+        def generate_extern(path,cpath)
+            @generator_extern.generate(File.join(path,"rbind"),@generator_ruby.module_name,@generator_ruby.file_prefix,cpath)
         end
 
         def use_namespace(name)

data/lib/rbind/templates/c/CMakeLists.txt

@@ -4,7 +4,6 @@ PROJECT(<%= library_name %> CXX)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 include(FindPkgConfig)
 <%= find_packages %>
-<%= find_gems%>
 SET(RBIND_SRC
     "${CMAKE_CURRENT_SOURCE_DIR}/types.cc"
     "${CMAKE_CURRENT_SOURCE_DIR}/operations.cc"
@@ -14,31 +13,19 @@ add_custom_command(OUTPUT ${RBIND_SRC}
        COMMAND ruby "${CMAKE_CURRENT_SOURCE_DIR}/../rbind.rb")
 
 ADD_LIBRARY(<%= library_name %> SHARED ${RBIND_SRC})
-TARGET_LINK_LIBRARIES(<%= library_name %> <%= libs %> ${GEM_LIBRARIES})
-
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/rbind.pc.in ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc @ONLY)
+TARGET_LINK_LIBRARIES(<%= library_name %> <%= libs %>)
 
 set(ROOT_FOLDER ${CMAKE_CURRENT_SOURCE_DIR}/../..)
-if(GEM_INSTALL)
-    # local install
-    install(TARGETS <%= library_name %> LIBRARY DESTINATION ${ROOT_FOLDER}/lib)
-    install(FILES types.h operations.h conversions.hpp DESTINATION ${ROOT_FOLDER}/include)
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION ${ROOT_FOLDER}/include)
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION ${ROOT_FOLDER}/include)
-else()
-    # global install
-    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/<%= library_name %>.pc DESTINATION lib/pkgconfig)
-    install(TARGETS <%= library_name %> LIBRARY DESTINATION lib)
-    install(FILES types.h operations.h conversions.hpp DESTINATION include/${PROJECT_NAME})
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/extern.rbind DESTINATION include/${PROJECT_NAME})
-    install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/config.rbind DESTINATION include/${PROJECT_NAME})
+install(TARGETS <%= library_name %> LIBRARY DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/../<%= ruby_path %>)
 
+# global install
+if(NOT GEM_INSTALL)
     FIND_PACKAGE(Ruby)
     IF(NOT RUBY_INCLUDE_PATH)
         MESSAGE(STATUS "Ruby library not found. Cannot install ruby extensions")
     ELSE(NOT RUBY_INCLUDE_PATH)
-        STRING(REGEX REPLACE ".*lib(32|64)?/?" "lib/" RUBY_LIBRARY_INSTALL_DIR ${RUBY_RUBY_LIB_PATH})
-        INSTALL(DIRECTORY ${ROOT_FOLDER}/lib/ DESTINATION ${RUBY_LIBRARY_INSTALL_DIR}
-            FILES_MATCHING PATTERN "*.rb")
+        STRING(REGEX REPLACE ".*lib(32|64)?/?" "lib/" RUBY_LIBRARY_INSTALL_DIR ${RUBY_RUBY_LIB_DIR})
+        INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../lib/ DESTINATION ${RUBY_LIBRARY_INSTALL_DIR}
+            FILES_MATCHING PATTERN "*.rb" PATTERN "*.rbind" PATTERN "*.so" PATTERN "*.dylib")
     ENDIF(NOT RUBY_INCLUDE_PATH)
-endif()
+ENDIF(NOT GEM_INSTALL)

data/lib/rbind/templates/c/cmake/FindRuby.cmake

@@ -77,6 +77,8 @@ IF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
 
   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubyhdrdir']"
       OUTPUT_VARIABLE RUBY_HDR_DIR)
+  EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['rubyarchhdrdir']"
+      OUTPUT_VARIABLE RUBY_ARCH_HDR_DIR)
 
   EXECUTE_PROCESS(COMMAND ${RUBY_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['libdir']"
       OUTPUT_VARIABLE RUBY_POSSIBLE_LIB_DIR)
@@ -114,6 +116,7 @@ IF(RUBY_EXECUTABLE  AND NOT  RUBY_MAJOR_VERSION)
    SET(RUBY_VERSION_PATCH    ${RUBY_VERSION_PATCH}    CACHE PATH "The Ruby patch version" FORCE)
    SET(RUBY_ARCH_DIR         ${RUBY_ARCH_DIR}         CACHE PATH "The Ruby arch dir" FORCE)
    SET(RUBY_HDR_DIR          ${RUBY_HDR_DIR}          CACHE PATH "The Ruby header dir (1.9)" FORCE)
+   SET(RUBY_ARCH_HDR_DIR     ${RUBY_ARCH_HDR_DIR}     CACHE PATH "The Ruby header dir for architecture-specific files (1.9)" FORCE)
    SET(RUBY_POSSIBLE_LIB_DIR ${RUBY_POSSIBLE_LIB_DIR} CACHE PATH "The Ruby lib dir" FORCE)
    SET(RUBY_RUBY_LIB_DIR     ${RUBY_RUBY_LIB_DIR}     CACHE PATH "The Ruby ruby-lib dir" FORCE)
    SET(RUBY_SITEARCH_DIR     ${RUBY_SITEARCH_DIR}     CACHE PATH "The Ruby site arch dir" FORCE)
@@ -178,27 +181,26 @@ FIND_PATH(RUBY_INCLUDE_DIR
    NAMES ruby.h
    HINTS
    ${RUBY_HDR_DIR}
-   ${RUBY_ARCH_DIR}
-   /usr/lib/ruby/${_RUBY_VERSION_SHORT}/i586-linux-gnu/ )
-
-SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIR} )
+   ${RUBY_ARCH_DIR})
+set(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIR})
 
 # if ruby > 1.8 is required or if ruby > 1.8 was found, search for the config.h dir
 IF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
-   message(STATUS "lookign for config.h")
+   message(STATUS "FindRuby: looking for config.h")
    FIND_PATH(RUBY_CONFIG_INCLUDE_DIR
      NAMES ruby/config.h  config.h
      HINTS 
      ${RUBY_HDR_DIR}/${RUBY_ARCH}
+     ${RUBY_ARCH_HDR_DIR}
      ${RUBY_ARCH_DIR} 
      )
 
-   SET(RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIRS} ${RUBY_CONFIG_INCLUDE_DIR} )
+   list(APPEND RUBY_INCLUDE_DIRS ${RUBY_INCLUDE_DIRS} ${RUBY_CONFIG_INCLUDE_DIR})
 ENDIF( ${Ruby_FIND_VERSION_SHORT_NODOT} GREATER 18  OR  ${_RUBY_VERSION_SHORT_NODOT} GREATER 18  OR  RUBY_HDR_DIR)
 
 
 # Determine the list of possible names for the ruby library
-SET(_RUBY_POSSIBLE_LIB_NAMES ruby ruby-static ruby${_RUBY_VERSION_SHORT} ${RUBY_RUBY_LIBRARY})
+SET(_RUBY_POSSIBLE_LIB_NAMES ruby${_RUBY_VERSION_SHORT} ${RUBY_RUBY_LIBRARY} ruby ruby-static)
 
 IF(WIN32)
    SET( _RUBY_MSVC_RUNTIME "" )
@@ -225,7 +227,10 @@ IF(WIN32)
                "msvcrt-ruby${RUBY_NODOT_VERSION}-static" )
 ENDIF(WIN32)
 
-FIND_LIBRARY(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_POSSIBLE_LIB_DIR} )
+FIND_LIBRARY(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_POSSIBLE_LIB_DIR} NO_DEFAULT_PATH)
+if(NOT RUBY_LIBRARY)
+    FIND_LIBRARY(RUBY_LIBRARY NAMES ${_RUBY_POSSIBLE_LIB_NAMES} HINTS ${RUBY_POSSIBLE_LIB_DIR})
+endif()
 
 INCLUDE(FindPackageHandleStandardArgs)
 SET(_RUBY_REQUIRED_VARS RUBY_EXECUTABLE RUBY_INCLUDE_DIR RUBY_LIBRARY)
@@ -236,7 +241,9 @@ ENDIF(_RUBY_VERSION_SHORT_NODOT GREATER 18)
 IF(_RUBY_DEBUG_OUTPUT)
    MESSAGE(STATUS "--------FindRuby.cmake debug------------")
    MESSAGE(STATUS "_RUBY_POSSIBLE_EXECUTABLE_NAMES: ${_RUBY_POSSIBLE_EXECUTABLE_NAMES}")
+   MESSAGE(STATUS "RUBY_POSSIBLE_LIB_DIR: ${RUBY_POSSIBLE_LIB_DIR}")
    MESSAGE(STATUS "_RUBY_POSSIBLE_LIB_NAMES: ${_RUBY_POSSIBLE_LIB_NAMES}")
+   MESSAGE(STATUS "RUBY_LIBRARY: ${RUBY_LIBRARY}")
    MESSAGE(STATUS "RUBY_ARCH_DIR: ${RUBY_ARCH_DIR}")
    MESSAGE(STATUS "RUBY_HDR_DIR: ${RUBY_HDR_DIR}")
    MESSAGE(STATUS "RUBY_POSSIBLE_LIB_DIR: ${RUBY_POSSIBLE_LIB_DIR}")

data/lib/rbind/templates/c/operations.cc

@@ -1,6 +1,6 @@
 
 #include "conversions.hpp"
-#include "operations.h" 
+#include "operations.h"
 <%= wrap_includes %>
 
 char last_error_message[255] = {0};

data/lib/rbind/templates/c/operations.h

@@ -1,5 +1,8 @@
 #ifndef <%= name %>
 #define <%= name %>
+
+#include "types.h"
+
 <%= wrap_includes %>
 
 #ifdef __cplusplus
@@ -8,9 +11,9 @@ extern "C"
 #endif
 
 // general rbind functions 
-const char* rbindGetLastError();
-bool rbindHasError();
-void rbindClearError();
+RBIND_EXPORTS const char* rbindGetLastError();
+RBIND_EXPORTS bool rbindHasError();
+RBIND_EXPORTS void rbindClearError();
 
 <%= wrap_operations %>
 

data/lib/rbind/templates/c/type_wrapper.h

@@ -8,5 +8,5 @@ typedef struct <%= cname %>
     bool bowner;            // true if struct is the owner of the object
 }<%= cname %>;
 
-void <%= cdelete_method %>(<%= cname %> *ptr);
+RBIND_EXPORTS void <%= cdelete_method %>(<%= cname %> *ptr);
 

data/lib/rbind/templates/c/types.h

@@ -1,7 +1,16 @@
 #ifndef <%= name %>
 #define <%= name %>
 
+#if (defined WIN32 || defined _WIN32 || defined WINCE || defined __CYGWIN__) && defined CVAPI_EXPORTS
+#  define RBIND_EXPORTS __declspec(dllexport)
+#elif defined __GNUC__ && __GNUC__ >= 4
+#  define RBIND_EXPORTS __attribute__ ((visibility ("default")))
+#else
+#  define RBIND_EXPORTS
+#endif
+
 #include <cstddef>
+
 <%= wrap_includes %>
 
 #ifdef __cplusplus