rltk 3.0.0 → 3.0.1

data/lib/rltk/cg/generic_value.rb

@@ -16,23 +16,23 @@ require 'rltk/cg/type'
 #######################
 
 module RLTK::CG
-	
+
 	# GenericValue objects are used to pass parameters into
 	# {ExecutionEngine ExecutionEngines} as well as retreive an evaluated
 	# function's result.  They may contain values of several different types:
-	# 
+	#
 	#  * Integer
 	#  * Float
 	#  * Boolean
 	class GenericValue
 		include BindingClass
-		
+
 		# The Proc object called by the garbage collector to free resources used by LLVM.
 		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_generic_value(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
-		
+
 		# @return [Type] LLVM type of this GenericValue.
 		attr_reader :type
-		
+
 		# Creates a new GenericValue from a given Ruby value.
 		#
 		# @param [FFI::Pointer, Integer, ::Float, Boolean]	ruby_val
@@ -43,50 +43,50 @@ module RLTK::CG
 			case ruby_val
 			when FFI::Pointer
 				[ruby_val, nil]
-				
+
 			when ::Integer
 				type = if type then check_cg_type(type, IntType) else NativeIntType.instance end
-				
+
 				[Bindings.create_generic_value_of_int(type, ruby_val, signed.to_i), type]
-				
+
 			when ::Float
 				type = if type then check_cg_type(type, RealType) else FloatType.instance end
-				
+
 				[Bindings.create_generic_value_of_float(type, ruby_val), type]
-				
+
 			when TrueClass
 				[Bindings.create_generic_value_of_int(Int1Type, 1, 0), Int1Type]
-				
+
 			when FalseClass
 				[Bindings.create_generic_value_of_int(Int1Type, 0, 0), Int1Type]
 			end
-			
+
 			# Define a finalizer to free the memory used by LLVM for this
 			# generic value.
 			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 		end
-		
+
 		# @param [Boolean] signed Treat the GenericValue as a signed integer.
 		#
 		# @return [Integer]
 		def to_i(signed = true)
 			val = Bindings.generic_value_to_int(@ptr, signed.to_i)
-			
+
 			if signed and val >= 2**63 then val - 2**64 else val end
 		end
-		
+
 		# @param [FloatType] type Type of the real value stored in this GenericValue.
 		#
 		# @return [Float]
 		def to_f(type = RLTK::CG::FloatType)
 			Bindings.generic_value_to_float(@type || check_cg_type(type, RLTK::CG::NumberType), @ptr)
 		end
-		
+
 		# @return [Boolean]
 		def to_bool
 			self.to_i(false).to_bool
 		end
-		
+
 		# @return [FFI::Pointer] GenericValue as a pointer.
 		def to_ptr_value
 			Bindings.generic_value_to_pointer(@ptr)

data/lib/rltk/cg/instruction.rb

@@ -16,10 +16,10 @@ require 'rltk/cg/value'
 #######################
 
 module RLTK::CG
-	
+
 	# This class represents LLVM IR instructions.
 	class Instruction < User
-		
+
 		# Many of the C functions for interacting with instructions treat
 		# all instructions as Instruction objects.  However, some Instruction
 		# sub-types can be tested for.  This is a list of those sub-types and
@@ -55,7 +55,7 @@ module RLTK::CG
 			:UIToFP,
 			:Unreachable
 		]
-		
+
 		# Instantiate an Instruction object from a given pointer.  The type
 		# of the instruction is tested and the appropriate sub-type is picked
 		# if possible.  If not, a generic Instruction object is returned.
@@ -65,22 +65,22 @@ module RLTK::CG
 		# @return [Instruction] An Instruction or one of its sub-types.
 		def self.from_ptr(ptr)
 			match = nil
-			
+
 			TESTABLE.each do |el|
 				klass, test =
 				if el.is_a?(Symbol)
 					[RLTK::CG.const_get("#{el}Inst".to_sym), Bindings.get_bname("IsA#{el}Inst")]
-					
+
 				else
 					[RLTK::CG.const_get("#{el.first}Inst".to_sym), Bindings.get_bname("IsA#{el.last}Inst")]
 				end
-				
+
 				match = klass if Bindings.send(test, ptr)
 			end
-			
+
 			if match then match else Intruction end.new(ptr)
 		end
-		
+
 		# You should never instantiate Instruction object directly.  Use the
 		# builder class to add new instructions.
 		#
@@ -88,38 +88,38 @@ module RLTK::CG
 		def initialize(ptr)
 			@ptr = check_type(ptr, FFI::Pointer, 'ptr')
 		end
-		
+
 		# @return [Instruction, nil] Instruction that follows the current one in a {BasicBlock}.
 		def next
 			if (ptr = Bindings.get_next_instruction(@ptr)).null? then nil else Instruction.from_ptr(ptr) end
 		end
-		
+
 		# @return [BasicBlock] BasicBlock that contains this Instruction.
 		def parent
 			if (ptr = Bindings.get_instruction_parent(@ptr)).null? then nil else BasicBlock.new(ptr) end
 		end
-		
+
 		# @return [Instruction, nil] Instruction that precedes the current on in a {BasicBlock}.
 		def previous
 			if (ptr = Bindings.get_previous_instruction(@ptr)).null? then nil else Instruction.from_ptr(ptr) end
 		end
-		
+
 		##########################################
 		# Instruction Testing Method Definitions #
 		##########################################
-		
+
 		selector	= Regexp.new(/LLVMIsA.*Inst/)
 		syms		= Symbol.all_symbols.select { |sym| selector.match(sym.to_s) }
-		
+
 		syms.each do |sym|
 			sym = (Bindings.get_bname(sym).to_s + '?').to_sym
-			
+
 			define_method(sym) do
 				Bindings.send(sym, @ptr)
 			end
 		end
 	end
-	
+
 	# An Instruction representing a function call.
 	#
 	# @LLVMInst call
@@ -132,7 +132,7 @@ module RLTK::CG
 		def calling_convention
 			Bindings.enum_type(:call_conv)[Bindings.get_instruction_call_conv(@ptr)]
 		end
-		
+
 		# Set the calling convention used for this call.
 		#
 		# @see Bindings._enum_call_conv_
@@ -140,15 +140,15 @@ module RLTK::CG
 		# @param [Symbol] conv Calling convention to set.
 		def calling_convention=(conv)
 			Bindings.set_instruction_call_conv(@ptr, Bindings.enum_type(:call_conv)[conv])
-			
+
 			conv
 		end
-		
+
 		# @return [Boolean]
 		def tail_call?
 			Bindings.is_tail_call(@ptr).to_bool
 		end
-		
+
 		# Sets the *tail call* property for this call instruction.
 		#
 		# @param [Boolean]  bool  If this is a tail call or not
@@ -158,7 +158,7 @@ module RLTK::CG
 			Bindings.set_tail_call(@ptr, bool.to_i)
 		end
 	end
-	
+
 	# An Instruction representing a Phi node.
 	#
 	# @see http://en.wikipedia.org/wiki/Static_single_assignment_form
@@ -168,16 +168,16 @@ module RLTK::CG
 		def incoming
 			@incoming_collection ||= IncomingCollection.new(self)
 		end
-		
+
 		# This class is used to access a Phi node's incoming {BasicBlock}/{Value} pairs.
 		class IncomingCollection
 			include Enumerable
-			
+
 			# @param [PhiInst] phi Phi instruction for which this is a proxy.
 			def initialize(phi)
 				@phi = phi
 			end
-			
+
 			# Access the {BasicBlock}/{Value} pair at the given index.
 			#
 			# @param [Integer] index Index of the desired pair.  May be negative.
@@ -185,12 +185,12 @@ module RLTK::CG
 			# @return [Array(BasicBlock, Value)]
 			def [](index)
 				index += self.size if index < 0
-				
+
 				if 0 <= index and index < self.size
 					[self.block(index), self.value(index)]
 				end
 			end
-			
+
 			# Add incoming {BasicBlock}/{Value} pairs to a Phi node.
 			#
 			# @example Adding a single block/value pair:
@@ -214,28 +214,28 @@ module RLTK::CG
 						[(keys = overloaded.keys), overloaded.values_at(*keys)]
 					end
 				end
-				
+
 				vals_ptr = FFI::MemoryPointer.new(:pointer, vals.size)
 				vals_ptr.write_array_of_pointer(vals)
-				
+
 				blks_ptr = FFI::MemoryPointer.new(:pointer, blks.size)
 				blks_ptr.write_array_of_pointer(blks)
-			
+
 				nil.tap { Bindings.add_incoming(@phi, vals_ptr, blks_ptr, vals.length) }
 			end
 			alias :<< :add
-			
+
 			# @param [Integer] index Index of desired incoming {BasicBlock}.
 			#
 			# @return [BasicBlock] Incoming {BasicBlock}.
 			def block(index)
 				index += self.size if index < 0
-				
+
 				if 0 <= index and index < self.size
 					BasicBlock.new(Bindings.get_incoming_block(@phi, index))
 				end
 			end
-			
+
 			# An iterator for each incoming {BasicBlock}/{Value} pair.
 			#
 			# @yieldparam pair [Array(BasicBlock, Value)]
@@ -243,30 +243,30 @@ module RLTK::CG
 			# @return [Enumerator] Returns an Enumerator if no block is given.
 			def each
 				return to_enum(:each) unless block_given?
-				
+
 				self.size.times { |index| yield self[index] }
-				
+
 				self
 			end
-			
+
 			# @return [Integer] Number of incoming {BasicBlock}/{Value} pairs.
 			def size
 				Bindings.count_incoming(@phi)
 			end
-			
+
 			# @param [Integer] index Index of desired incoming {Value}.
 			#
 			# @return [BasicBlock] Incoming {Value}.
 			def value(index)
 				index += self.size if index < 0
-				
+
 				if 0 <= index and index < self.size
 					Value.new(Bindings.get_incoming_value(@phi, index))
 				end
 			end
 		end
 	end
-	
+
 	# An Instruction representing a conditional jump with multiple cases.
 	#
 	# @LLVMInst switch
@@ -281,238 +281,238 @@ module RLTK::CG
 			Bindings.add_case(@ptr, val, block)
 		end
 	end
-	
+
 	#############################
 	# Empty Instruction Classes #
 	#############################
-	
+
 	# @LLVMInst add
 	class AddInst                 < Instruction; end
-	
+
 	# @LLVMInst addr_space_cast
 	class AddrSpaceCastInst       < Instruction; end
-	
+
 	# @LLVMInst alloca
 	class AllocaInst              < Instruction; end
-	
+
 	# @LLVMInst and
 	class AndInst                 < Instruction; end
-	
+
 	# @LLVMInst ashr
 	class ARightShiftInst         < Instruction; end
-	
+
 	# @LLVMInst alloca
 	class ArrayAllocaInst         < Instruction; end
-	
+
 	class ArrayMallocInst         < Instruction; end
-	
+
 	# @LLVMInst atomicrmw
 	class AtomicRMWInst           < Instruction; end
-	
+
 	# @LLVMInst bitcast
 	class BitCastInst             < Instruction; end
-	
+
 	# @LLVMInst br
 	class BranchInst              < Instruction; end
-	
+
 	# @LLVMInst br
 	class CondBranchInst          < Instruction; end
-	
+
 	# @LLVMInst sdiv
 	class ExactSDivInst           < Instruction; end
-	
+
 	# @LLVMInst extractelement
 	class ExtractElementInst      < Instruction; end
-	
+
 	# @LLVMInst extractvalue
 	class ExtractValueInst        < Instruction; end
-	
+
 	# @LLVMInst fadd
 	class FAddInst                < Instruction; end
-	
+
 	# @LLVMInst fcmp
 	class FCmpInst                < Instruction; end
-	
+
 	# @LLVMInst fdiv
 	class FDivInst                < Instruction; end
-	
+
 	# @LLVMInst fmul
 	class FMulInst                < Instruction; end
-	
+
 	# @LLVMInst fsub
 	class FNegInst                < Instruction; end
-	
+
 	# @LLVMInst fptosi
 	class FPToSIInst              < Instruction; end
-	
+
 	# @LLVMInst fptoui
 	class FPToUIInst              < Instruction; end
-	
+
 	class FPCastInst              < Instruction; end
-	
+
 	# @LLVMInst fpext
 	class FPExtendInst            < Instruction; end
-	
+
 	# @LLVMInst fptrunc
 	class FPTruncInst             < Instruction; end
-	
+
 	class FreeInst                < Instruction; end
-	
+
 	# @LLVMInst frem
 	class FRemInst                < Instruction; end
-	
+
 	# @LLVMInst fsub
 	class FSubInst                < Instruction; end
-	
+
 	# @LLVMInst gep
 	# @see http://llvm.org/docs/GetElementPtr.html
 	class GetElementPtrInst       < Instruction; end
-	
+
 	class GlobalStringInst        < Instruction; end
 	class GlobalStringPtrInst     < Instruction; end
-	
+
 	# @LLVMInst gep
 	# @see http://llvm.org/docs/GetElementPtr.html
 	class InBoundsGEPInst         < Instruction; end
-	
+
 	# @LLVMInst insertelement
 	class InsertElementInst       < Instruction; end
-	
+
 	# @LLVMInst insertvalue
 	class InsertValueInst         < Instruction; end
-	
+
 	# @LLVMInst inttoptr
 	class IntToPtrInst            < Instruction; end
-	
+
 	class IntCastInst             < Instruction; end
-	
+
 	# @LLVMInst icmp
 	class IntCmpInst              < Instruction; end
-	
+
 	# @LLVMInst invoke
 	class InvokeInst              < Instruction; end
-	
+
 	class IsNotNullInst           < Instruction; end
 	class IsNullInstInst          < Instruction; end
-	
+
 	# @LLVMInst shl
 	class LeftShiftInst           < Instruction; end
-	
+
 	# @LLVMInst load
 	class LoadInst                < Instruction; end
-	
+
 	# @LLVMInst lshr
 	class LRightShiftInst         < Instruction; end
-	
+
 	class MallocInst              < Instruction; end
-	
+
 	# @LLVMInst mul
 	class MulInst                 < Instruction; end
-	
+
 	# @LLVMInst sub
 	class NegInst                 < Instruction; end
-	
+
 	class NotInst                 < Instruction; end
-	
+
 	# @LLVMInst add
 	class NSWAddInst              < Instruction; end
-	
+
 	# @LLVMInst mul
 	class NSWMulInst              < Instruction; end
-	
+
 	# @LLVMInst sub
 	class NSWNegInst              < Instruction; end
-	
+
 	# @LLVMInst sub
 	class NSWSubInst              < Instruction; end
-	
+
 	# @LLVMInst add
 	class NUWAddInst              < Instruction; end
-	
+
 	# @LLVMInst mul
 	class NUWMulInst              < Instruction; end
-	
+
 	# @LLVMInst sub
 	class NUWNegInst              < Instruction; end
-	
+
 	# @LLVMInst sub
 	class NUWSubInst              < Instruction; end
-	
+
 	# @LLVMInst or
 	class OrInst                  < Instruction; end
-	
+
 	# @LLVMInst ptrtoint
 	class PtrToIntInst            < Instruction; end
-	
+
 	class PtrCastInst             < Instruction; end
 	class PtrDiffInst             < Instruction; end
-	
+
 	# @LLVMInst ret
 	class ReturnInst              < Instruction; end
-	
+
 	# @LLVMInst ret
 	class ReturnAggregateInst     < Instruction; end
-	
+
 	# @LLVMInst ret
 	class ReturnVoidInst          < Instruction; end
-	
+
 	# @LLVMInst sdiv
 	class SDivInst                < Instruction; end
-	
+
 	# @LLVMInst select
 	class SelectInst              < Instruction; end
-	
+
 	# @LLVMInst shufflevector
 	class ShuffleVectorInst       < Instruction; end
-	
+
 	# @LLVMInst sext
 	class SignExtendInst          < Instruction; end
-	
+
 	# @LLVMInst sext
 	# @LLVMInst bitcast
 	class SignExtendOrBitCastInst < Instruction; end
-	
+
 	# @LLVMInst sitofp
 	class SIToFPInst              < Instruction; end
-	
+
 	# @LLVMInst srem
 	class SRemInst                < Instruction; end
-	
+
 	# @LLVMInst store
 	class StoreInst               < Instruction; end
-	
+
 	# @LLVMInst gep
 	# @see http://llvm.org/docs/GetElementPtr.html
 	class StructGEPInst           < Instruction; end
-	
+
 	# @LLVMInst sub
 	class SubInst                 < Instruction; end
-	
+
 	# @LLVMInst trunc
 	class TruncateInst            < Instruction; end
-	
+
 	# @LLVMInst trunc
 	# @LLVMInst bitcast
 	class TruncateOrBitCastInst   < Instruction; end
-	
+
 	# @LLVMInst udiv
 	class UDivInst                < Instruction; end
-	
+
 	# @LLVMInst uitofp
 	class UIToFPInst              < Instruction; end
-	
+
 	# @LLVMInst unreachable
 	class UnreachableInst         < Instruction; end
-	
+
 	# @LLVMInst urem
 	class URemInst                < Instruction; end
-	
+
 	# @LLVMInst xor
 	class XOrInst                 < Instruction; end
-	
+
 	# @LLVMInst zext
 	class ZeroExtendInst          < Instruction; end
-	
+
 	# @LLVMInst zext
 	# @LLVMInst bitcast
 	class ZeroExtendOrBitCastInst < Instruction; end