rbind 0.0.26 → 0.0.27

data/lib/rbind/clang/clang_types.rb

@@ -1,338 +0,0 @@
-module Clang
-
-    class Clang
-        @@index = Hash.new
-        attr_reader :units
-
-        def initialize
-            ObjectSpace.define_finalizer(self, Clang.method(:finalize))
-            @index = Rbind::create_index(1, 1)
-            @@index[self.object_id] = @index
-            @units = []
-        end
-
-        def translation_unit(file,args)
-            raise ArgumentError,"File #{file} does not exist!" unless File.exist?(file)
-            @pargs = args.map do |a|
-                FFI::MemoryPointer.from_string(a)
-            end
-            @cargs = FFI::MemoryPointer.new(:pointer, @pargs.size)
-            @cargs.write_array_of_pointer(@pargs)
-            tu = Rbind::parse_translation_unit(@index,file,@cargs,@pargs.size,nil,0,1)
-            # auto release if Clang goes out of scope
-            # this cannot be encapsulate into the obj because
-            # each cursor can return a pointer to the unit
-            @units << TranslationUnitImplStruct.new(FFI::AutoPointer.new(tu.__obj_ptr__.pointer,TranslationUnitImplStruct.method(:release)))
-            tu
-        end
-
-        # dispose index
-        def self.finalize(id)
-            Rbind::dispose_index(@@index[id])
-            @@index.delete(id)
-        end
-    end
-
-    # A single translation unit, which resides in an index.
-    class TranslationUnitImplStruct < FFI::Struct
-        layout :dummy, :char
-
-        # do not call this for each instance !
-        # class Clang is taking care of this
-        def self.release(pointer)
-            Rbind::dispose_translation_unit(pointer) unless pointer.null?
-        rescue => e
-            puts e
-        end
-    end
-
-    class TranslationUnitImpl
-        extend FFI::DataConverter
-        native_type FFI::Type::POINTER
-
-        def self.to_native(obj,context)
-            if obj.is_a? TranslationUnitImpl
-                obj.__obj_ptr__
-            else
-                raise TypeError, "expected kind of #{name}, was #{obj.class}"
-            end
-        end
-
-        def self.from_native(ptr,context)
-            TranslationUnitImpl.new(ptr)
-        end
-
-        attr_reader :__obj_ptr__
-        def initialize(ptr)
-            @__obj_ptr__ = if ptr.is_a? TranslationUnitImplStruct
-                               ptr
-                           else
-                               TranslationUnitImplStruct.new(ptr)
-                           end
-        end
-
-        def cursor
-            cu = Rbind::get_translation_unit_cursor(self)
-            cu.instance_variable_set(:@__translation_unit__,self)
-            cu
-        end
-  
-        def spelling
-            Rbind::get_translation_unit_spelling(self).to_s
-        end
-    end
-
-    # extend Structs to support auto dispose
-    module Rbind
-        class Cursor < FFI::Struct
-            extend ::Rbind::Logger
-
-            def null?
-                1 == Rbind::cursor_is_null(self)
-            end
-
-            def location
-                line = FFI::MemoryPointer.new(:uint,1)
-                col = FFI::MemoryPointer.new(:uint,1)
-                location = Rbind::get_cursor_location(self)
-                fstr = String.new
-                Rbind::get_presumed_location(location,fstr,line,col)
-                result = [fstr.to_s,line.get_uint(0),col.get_uint(0)]
-                result
-            end
-
-            def location_int
-                Rbind::get_cursor_location(self)[:int_data]
-            end
-
-            def referenced
-                Rbind::get_cursor_referenced self
-            end
-
-            def file_name
-                location[0]
-            end
-
-            def line
-                location[1]
-            end
-
-            def column
-                location[2]
-            end
-
-            def private?
-                cxx_access_specifier == :x_private
-            end
-
-            def public?
-                cxx_access_specifier == :x_public
-            end
-
-            def protected?
-                cxx_access_specifier == :x_protected
-            end
-
-            def cxx_access_specifier
-                Rbind::get_cxx_access_specifier self
-            end
-
-            def extent
-                Rbind::get_cursor_extent self
-            end
-
-            def semantic_parent
-                Rbind::get_cursor_semantic_parent self
-            end
-            
-            def namespace
-                namespace = []
-                cursor = semantic_parent
-                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)
-                tokens = FFI::MemoryPointer.new(:pointer,1)
-                tu = translation_unit
-                Rbind::tokenize(tu,extent,tokens,num)
-                ptr = FFI::Pointer.new(Token,tokens.read_pointer)
-                result = 0.upto(num.read_uint-1).map do |i|
-                    Rbind::get_token_spelling(tu,ptr[i])
-                end
-                Rbind::dispose_tokens(tu,ptr,num.get_uint(0))
-                result
-            end
-
-            def result_type
-                Rbind::get_cursor_result_type self
-            end
-
-            def kind_spelling
-                Rbind::get_cursor_kind_spelling(self).to_s
-            end
-
-            def spelling
-                Rbind::get_cursor_spelling(self).to_s
-            end
-
-            def display_name
-                Rbind::get_cursor_display_name(self).to_s
-            end
-
-            def kind
-                Rbind::get_cursor_kind(self)
-            end
-
-            def translation_unit
-                Rbind::cursor_get_translation_unit(self)
-            end
-
-            def type
-                Rbind::get_cursor_type self
-            end
-
-            def virtual_base?
-                1 == Rbind::is_virtual_base(self)
-            end
-
-            def specialized_template
-                Rbind::get_specialized_cursor_template self
-            end
-
-            def template_kind
-                Rbind::get_template_cursor_kind self
-            end
-
-            def complete?
-                !incomplete?
-            end
-
-            def incomplete?
-                definition.null?
-            end
-
-            def definition
-                Rbind::get_cursor_definition self
-            end
-
-            def static?
-                1 == Rbind::cxx_method_is_static(self)
-            end
-
-            def virtual?
-                1 == Rbind::cxx_method_is_virtual(self)
-            end
-
-            def visit_children(recurse=false,*reg_filters,&block)
-                if reg_filters.empty?
-                    reg_filters << Regexp.new("#{File.dirname(translation_unit.spelling)}")
-                end
-                p = proc do |cur,parent,data|
-                  #  puts "#{cur.kind} #{cur.spelling} #{cur.template_kind} #{cur.specialized_template.kind} #{cur.location}"
-                    if(reg_filters.find{|reg| cur.file_name =~ reg})
-                        block.call(cur,parent)
-                        if recurse
-                            :recurse
-                        else
-                            :continue
-                        end
-                    else
-                        :continue
-                    end
-                end
-                Rbind::visit_children(self,p,FFI::Pointer.new(0))
-            end
-        end
-
-        class String < FFI::Struct
-            @@pointer = Hash.new
-
-            def self.finalize(id)
-                Rbind::dispose_string(@@pointer[id])
-                @@pointer.delete(id)
-            rescue => e
-                puts e
-            end
-
-            def initialize(*args)
-                super
-                # we cannot use auto pointer because string is returned as value
-                ObjectSpace.define_finalizer(self, String.method(:finalize))
-                @@pointer[self.object_id] = pointer
-            end
-
-            def to_s
-                Rbind.get_c_string self
-            end
-        end
-
-        class Token < FFI::Struct
-            def self.release(pointer)
-            end
-
-            def spelling(translation_unit)
-                Rbind::get_token_spelling(translation_unit,self).to_s
-            end
-        end
-
-        class Type < FFI::Struct
-            def null?
-                kind == :invalid
-            end
-
-            def declaration
-                Rbind::get_type_declaration self
-            end
-
-            def const_qualified?
-                1 == Rbind::is_const_qualified_type(self)
-            end
-
-            def canonical_type
-                Rbind::get_canonical_type self
-            end
-
-            def result_type
-                Rbind::get_result_type self
-            end
-
-            def pointee_type
-                Rbind::get_pointee_type self
-            end
-
-            def pod?
-                1 == Rbind::is_pod_type(self)
-            end
-
-            def array_size
-                Rbind::get_array_size self
-            end
-
-            def array_element_type
-                Rbind::get_array_element_type self
-            end
-
-            def kind
-                self[:kind]
-            end
-        end
-    end
-end