rltk 3.0.0 → 3.0.1

data/lib/rltk/cg/type.rb

@@ -16,13 +16,13 @@ require 'filigree/abstract_class'
 # Ruby Language Toolkit
 require 'rltk/cg/bindings'
 require 'rltk/cg/context'
-	
+
 #######################
 # Classes and Modules #
 #######################
 
 module RLTK::CG
-	
+
 	# The Type class and its sub-classes are used to describe the size and
 	# structure of various data objects inside LLVM and how different
 	# operations interact with them.  When instantiating objects of the
@@ -32,7 +32,7 @@ module RLTK::CG
 	class Type
 		include BindingClass
 		include Filigree::AbstractClass
-		
+
 		# Instantiate a Type object from a pointer.  This function is used
 		# internally, and as a library user you should never have to call it.
 		#
@@ -59,13 +59,13 @@ module RLTK::CG
 			when :x86_mmx		then X86MMXType.new
 			end
 		end
-		
+
 		# The default constructor for Type objects.
 		#
 		# @param [Context, nil] context An optional context in which to create the type.
 		def initialize(context = nil)
 			bname = Bindings.get_bname(self.class.short_name)
-			
+
 			@ptr =
 			if context
 				Bindings.send((bname.to_s + '_in_context').to_sym, check_type(context, Context, 'context'))
@@ -73,82 +73,82 @@ module RLTK::CG
 				Bindings.send(bname)
 			end
 		end
-		
+
 		# @return [NativeInt] Alignment of the type.
 		def allignment
 			NativeInt.new(Bindings.align_of(@ptr))
 		end
-		
+
 		# @return [Context] Context in which this type was created.
 		def context
 			Context.new(Bindings.get_type_context(@ptr))
 		end
-		
+
 		# Dump a string representation of the type to stdout.
 		#
 		# @return [void]
 		def dump
 			Bindings.dump_type(@ptr)
 		end
-		
+
 		# @return [Fixnum] Hashed value of the pointer representing this type.
 		def hash
 			@ptr.address.hash
 		end
-		
+
 		# @see Bindings._enum_type_kind_
 		#
 		# @return [Symbol] The *kind* of this type.
 		def kind
 			Bindings.get_type_kind(@ptr)
 		end
-		
+
 		# @return [NativeInt] Size of objects of this type.
 		def size
 			Int64.new(Bindings.size_of(@ptr))
 		end
-		
+
 		# @return [String]  LLVM IR representation of the type
 		def to_s
 			Bindings.print_type_to_string(@ptr)
 		end
 	end
-	
+
 	# All types that are used to represent numbers inherit from this class.
 	#
 	# @abstract
 	class NumberType < Type
 		include Filigree::AbstractClass
-		
+
 		# @return [Value] The corresponding Value sub-class that is used to represent values of this type.
 		def self.value_class
 			begin
 				@value_class ||=
 				RLTK::CG.const_get(self.name.match(/::(.+)Type$/).captures.last.to_sym)
-				
+
 			rescue
 				raise "#{self.name} has no value class."
 			end
 		end
-		
+
 		# @return [Value] The corresponding Value sub-class that is used to represent values of this type.
 		def value_class
 			self.class.value_class
 		end
 	end
-	
+
 	# All types that represent integers of a given width inherit from this class.
 	#
 	# @abstract
 	class BasicIntType < NumberType
 		include Filigree::AbstractClass
-		
+
 		# @return [Integer] Number of bits used to represent an integer type.
 		def width
 			@width ||= Bindings.get_int_type_width(@ptr)
 		end
 	end
-	
+
 	# An integer of an arbitrary width.
 	class IntType < BasicIntType
 		# @param [Integer] width		Width of new integer type.
@@ -167,7 +167,7 @@ module RLTK::CG
 				raise 'The width parameter must be greater then 0.'
 			end
 		end
-		
+
 		# Overrides {NumberType#value_class}.
 		#
 		# @raise [RuntimeError] This function has no meaning in this class.
@@ -175,7 +175,7 @@ module RLTK::CG
 			raise 'The RLKT::CG::IntType class has no value class.'
 		end
 	end
-	
+
 	# A class inherited by singleton integer type classes.
 	#
 	# @abstract
@@ -183,7 +183,7 @@ module RLTK::CG
 		include Filigree::AbstractClass
 		include Singleton
 	end
-	
+
 	# A class inherited by all types representing floats.
 	#
 	# @abstract
@@ -191,7 +191,7 @@ module RLTK::CG
 		include Filigree::AbstractClass
 		include Singleton
 	end
-	
+
 	# A class inherited by non-number singleton type classes.
 	#
 	# @abstract
@@ -199,7 +199,7 @@ module RLTK::CG
 		include Filigree::AbstractClass
 		include Singleton
 	end
-	
+
 	# 1 bit integer type.  Often used to represent Boolean values.
 	class Int1Type  < SimpleIntType; end
 	# 8 bit (1 byte) integer type.
@@ -210,7 +210,7 @@ module RLTK::CG
 	class Int32Type < SimpleIntType; end
 	# 64 bit (8 byte) integer type.
 	class Int64Type < SimpleIntType; end
-	
+
 	# Integer the same size as a native pointer.
 	class IntPtr < SimpleIntType
 		# Create an integer that is the same size as a pointer on the target
@@ -223,26 +223,26 @@ module RLTK::CG
 		def initialize(target_data, addr_space = nil, context = nil)
 			call = 'int_type'
 			args = [target_data]
-			
+
 			if addr_space
 				call += '_for_as'
 				args << addr_space
 			end
-			
+
 			if context
 				call += '_in_context'
 				args << context
 			end
-			
+
 			Bindings.send(call.to_s, *args)
 		end
 	end
-	
+
 	# The native integer type on the current (not the target) platform.
 	NativeIntType = RLTK::CG.const_get("Int#{FFI.type_size(:int) * 8}Type")
-	
+
 	# A 16-bit floating point number type.
-	class HalfType     < RealType; end      
+	class HalfType     < RealType; end
 	# A double precision floating point number type.
 	class DoubleType   < RealType; end
 	# A single precision floating point number type.
@@ -253,29 +253,29 @@ module RLTK::CG
 	class PPCFP128Type < RealType; end
 	# A 80 bit (10 byte) floating point number type for the x86 architecture.
 	class X86FP80Type  < RealType; end
-	
+
 	# A type for x86 MMX instructions.
 	class X86MMXType   < SimpleType; end
-	
+
 	# A type used in representing void pointers and functions that return no values.
 	class VoidType     < SimpleType; end
 	# A type used to represent labels in LLVM IR.
 	class LabelType    < SimpleType; end
-	
+
 	# The common ancestor for array, pointer, and struct types.
 	#
 	# @abstract
 	class AggregateType < Type
 		include Filigree::AbstractClass
 	end
-	
+
 	# {ArrayType} and {PointerType} inherit from this class so they can share
 	# a constructor.
 	#
 	# @abstract
 	class SimpleAggregateType < AggregateType
 		include Filigree::AbstractClass
-		
+
 		# Used to initialize {ArrayType ArrayTypes} and {PointerType PointerTypes}.
 		#
 		# @param [FFI::Pointer, Type] overloaded Pointer to an existing aggregate type or a Type object that
@@ -288,17 +288,17 @@ module RLTK::CG
 			else
 				@element_type	= check_cg_type(overloaded, Type, 'overloaded')
 				bname		= Bindings.get_bname(self.class.short_name)
-				
+
 				Bindings.send(bname, @element_type, size_or_address_space)
 			end
 		end
-		
+
 		# @return [Type] Type of objects stored inside this aggregate.
 		def element_type
 			@element_type ||= Type.from_ptr(Bindings.get_element_type(@ptr))
 		end
 	end
-	
+
 	# A Type describing an array that holds objects of a single given type.
 	class ArrayType < SimpleAggregateType
 		# @return [Integer] Number of elements in this array type.
@@ -307,7 +307,7 @@ module RLTK::CG
 		end
 		alias :length :size
 	end
-	
+
 	# A Type describing a pointer to another type.
 	class PointerType < SimpleAggregateType
 		# @return [Integer] Address space of this pointer.
@@ -315,7 +315,7 @@ module RLTK::CG
 			@address_space ||= Bindings.get_pointer_address_space(@ptr)
 		end
 	end
-	
+
 	# A type used to represent vector operations (SIMD).  This is NOT an
 	# aggregate type.
 	class VectorType < Type
@@ -331,28 +331,28 @@ module RLTK::CG
 			else
 				@element_type	= check_cg_type(overloaded, Type, 'overloaded')
 				bname		= Bindings.get_bname(self.class.short_name)
-				
+
 				Bindings.send(bname, @element_type, size)
 			end
 		end
-		
+
 		# @return [Type] Type of object stored inside this vector.
 		def element_type
 			@element_type ||= Type.from_ptr(Bindings.get_element_type(@ptr))
 		end
-		
+
 		# @return [Integer] Number of objects in this vector type.
 		def size
 			Bindings.get_vector_size(@ptr)
 		end
 		alias :length :size
 	end
-	
+
 	# A type representing the return an argument types for a function.
 	class FunctionType < Type
 		# @return [Array<Type>] Types of this function type's arguments.
 		attr_reader :arg_types
-		
+
 		# Create a new function type from a pointer or description of the
 		# return type and argument types.
 		#
@@ -367,36 +367,36 @@ module RLTK::CG
 			else
 				@return_type	= check_cg_type(overloaded, Type, 'return_type')
 				@arg_types	= check_cg_array_type(arg_types, Type, 'arg_types').freeze
-				
+
 				arg_types_ptr = FFI::MemoryPointer.new(:pointer, @arg_types.length)
 				arg_types_ptr.write_array_of_pointer(@arg_types)
-				
+
 				Bindings.function_type(@return_type, arg_types_ptr, @arg_types.length, varargs.to_i)
 			end
 		end
-		
+
 		# @return [Array<Type>] Types of this function type's arguments.
 		def argument_types
 			@arg_types ||=
 			begin
 				num_elements = Bindings.count_param_types(@ptr)
-				
+
 				ret_ptr = FFI::MemoryPointer.new(:pointer)
 				Bindings.get_param_types(@ptr, ret_ptr)
-				
+
 				types_ptr = ret_ptr.get_pointer(0)
-				
+
 				types_ptr.get_array_of_pointer(0, num_elements).map { |ptr| Type.from_ptr(ptr) }
 			end
 		end
 		alias :arg_types :argument_types
-		
+
 		# @return [Type] The return type of this function type.
 		def return_type
 			@return_type ||= Type.from_ptr(Bindings.get_return_type(@ptr))
 		end
 	end
-	
+
 	# A type for representing an arbitrary collection of types.
 	class StructType < AggregateType
 		# Create a new struct type.
@@ -413,43 +413,43 @@ module RLTK::CG
 			else
 				# Check the types of the elements of the overloaded parameter.
 				@element_types = check_cg_array_type(overloaded, Type, 'overloaded')
-				
+
 				el_types_ptr = FFI::MemoryPointer.new(:pointer, @element_types.length)
 				el_types_ptr.write_array_of_pointer(@element_types)
-			
+
 				if name
 					@name = check_type(name, String, 'name')
-			
+
 					Bindings.struct_create_named(Context.global, @name).tap do |ptr|
 						Bindings.struct_set_body(ptr, el_types_ptr, @element_types.length, packed.to_i) unless @element_types.empty?
 					end
-			
+
 				elsif context
 					check_type(context, Context, 'context')
-			
+
 					Bindings.struct_type_in_context(context, el_types_ptr, @element_types.length, is_packed.to_i)
-			
+
 				else
 					Bindings.struct_type(el_types_ptr, @element_types.length, packed.to_i)
 				end
 			end
 		end
-		
+
 		# @return [Array<Type>] Array of the types in this struct type.
 		def element_types
 			@element_types ||=
 			begin
 				num_elements = Bindings.count_struct_element_types(@ptr)
-				
+
 				ret_ptr = FFI::MemoryPointer.new(:pointer)
 				Bindings.get_struct_element_types(@ptr, ret_ptr)
-				
+
 				types_ptr = ret_ptr.get_pointer(0)
-				
+
 				types_ptr.get_array_of_pointer(0, num_elements).map { |ptr| Type.from_ptr(ptr) }
 			end
 		end
-		
+
 		# Set the types in the body of this struct type.
 		#
 		# @param [Array<Type>]	el_types	Array of types in the struct.
@@ -458,13 +458,13 @@ module RLTK::CG
 		# @return [void]
 		def element_types=(el_types, packed = false)
 			@element_types = check_cg_array_type(el_types, Type, 'el_types')
-			
+
 			el_types_ptr = FFI::MemoryPointer.new(:pointer, @element_types.length)
 			el_types_ptr.write_array_of_pointer(@element_types)
-			
+
 			Bindings.struct_set_body(@ptr, el_types_ptr, @element_types.length, packed.to_i)
 		end
-		
+
 		# @return [String] Name of the struct type in LLVM IR.
 		def name
 			@name ||= Bindings.get_struct_name(@ptr)
@@ -494,8 +494,8 @@ end
 # @return [Type] The object *o* or an instance of the class passed in parameter *o*.
 def check_cg_type(o, type = RLTK::CG::Type, blame = 'type', strict = false)
 	if o.is_a?(Class)
-		type_ok = if strict then o == type else o.subclass_of?(type) end 
-		
+		type_ok = if strict then o == type else o.subclass_of?(type) end
+
 		if type_ok
 			if o.includes_module?(Singleton)
 				o.instance
@@ -503,7 +503,7 @@ def check_cg_type(o, type = RLTK::CG::Type, blame = 'type', strict = false)
 				raise ArgumentError, "The #{o.name} class (passed as parameter #{blame}) must be instantiated directly."
 			end
 		else
-			raise ArgumentError, "The #{o.name} class (passed as parameter #{blame} does not inherit from the #{type.name} class." 
+			raise ArgumentError, "The #{o.name} class (passed as parameter #{blame} does not inherit from the #{type.name} class."
 		end
 	else
 		check_type(o, type, blame, strict)
@@ -512,7 +512,7 @@ end
 
 # This helper function checks to make sure that an array of objects are all
 # sub-classses of {RLTK::CG::Type Type} or instances of a sub-class of Type.
-# If a class is present in the *array* parameter it is expected to be a 
+# If a class is present in the *array* parameter it is expected to be a
 # singleton class and will be instantiated via the *instance* method.
 #
 # @param [Array<Type, Class>]	array	Array of objects to type check for code generation type.
@@ -530,7 +530,7 @@ def check_cg_array_type(array, type = RLTK::CG::Type, blame = 'el_types', strict
 	array.map do |o|
 		if o.is_a?(Class)
 			type_ok = if strict then o == type else o.subclass_of?(type) end
-			
+
 			if type_ok
 				if o.includes_module?(Singleton)
 					o.instance
@@ -540,10 +540,10 @@ def check_cg_array_type(array, type = RLTK::CG::Type, blame = 'el_types', strict
 			else
 				raise ArgumentError, "The #{o.name} class (passed in parameter #{blame}) does not inherit from the #{type.name} class."
 			end
-			
+
 		else
 			type_ok = if strict then o.instance_of(type) else o.is_a?(type) end
-			
+
 			if type_ok
 				o
 			else