rltk 3.0.0 → 3.0.1

data/lib/rltk/cg/context.rb

@@ -15,31 +15,31 @@ require 'rltk/cg/bindings'
 #######################
 
 module RLTK::CG
-	
+
 	# Bindings for LLVM contexts.
 	class Context
 		include BindingClass
-		
+
 		# The Proc object called by the garbage collector to free resources used by LLVM.
 		CLASS_FINALIZER = Proc.new { |id| Bindings.context_dispose(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
-		
+
 		#################
 		# Class Methods #
 		#################
-		
+
 		# @return [Context] A global context.
 		def self.global
 			self.new(Bindings.get_global_context())
 		end
-		
+
 		####################
 		# Instance Methods #
 		####################
-		
+
 		# @param [FFI::Pointer, nil] ptr Pointer representing a context.  If nil, a new context is created.
 		def initialize(ptr = nil)
 			@ptr = ptr || Bindings.context_create()
-			
+
 			# Define a finalizer to free the memory used by LLVM for this
 			# context.
 			ObjectSpace.define_finalizer(self, CLASS_FINALIZER)

data/lib/rltk/cg/contractor.rb

@@ -19,18 +19,18 @@ require 'rltk/cg/builder'
 #######################
 
 module RLTK::CG
-	
+
 	class Contractor < Builder
-		
+
 		include Filigree::Visitor
-		
+
 		####################
 		# Instance Methods #
 		####################
-		
+
 		# Alias out the RLTK::Visitor.visit method.
 		alias :wrapped_visit :visit
-		
+
 		# Visit an object in the context of this builder.  See the
 		# Filigree::Visitor's visit method for more details about the basic
 		# behaviour of this method.  The special options for this method are:
@@ -42,9 +42,9 @@ module RLTK::CG
 		# @return [Object]
 		def visit(object, at: nil, rcb: false)
 			target at if at
-			
+
 			result = wrapped_visit(object)
-			
+
 			if rcb then [result, current_block] else result end
 		end
 	end

data/lib/rltk/cg/execution_engine.rb

@@ -21,7 +21,7 @@ require 'rltk/cg/target'
 #######################
 
 module RLTK::CG
-	
+
 	# The ExecutionEngine class and its subclasses execute code from the
 	# provided module, as well as providing a {PassManager} and
 	# {FunctionPassManager} for optimizing modules.
@@ -30,13 +30,13 @@ module RLTK::CG
 	class ExecutionEngine
 		include Filigree::AbstractClass
 		include BindingClass
-		
+
 		# The Proc object called by the garbage collector to free resources used by LLVM.
 		CLASS_FINALIZER = Proc.new { |id| Bindings.dispose_execution_engine(ptr) if ptr = ObjectSpace._id2ref(id).ptr }
-		
+
 		# @return [Module]
 		attr_reader :module
-		
+
 		# Create a new execution engine.
 		#
 		# @param [Module]	mod		Module to be executed.
@@ -45,35 +45,35 @@ module RLTK::CG
 		# @raise [RuntimeError] An error is raised if something went horribly wrong inside LLVM during the creation of this engine.
 		def initialize(mod, &block)
 			check_type(mod, Module, 'mod')
-			
+
 			block = Proc.new { |ptr, error| Bindings.create_execution_engine_for_module(ptr, mod, error) } if block == nil
-			
+
 			ptr    = FFI::MemoryPointer.new(:pointer)
 			error  = FFI::MemoryPointer.new(:pointer)
 			status = block.call(ptr, error)
-			
+
 			if status.zero?
 				@ptr    = ptr.read_pointer
 				@module = mod
-				
+
 				# Associate this engine with the provided module.
 				@module.engine = self
-				
+
 				# Define a finalizer to free the memory used by LLVM for
 				# this execution engine.
 				ObjectSpace.define_finalizer(self, CLASS_FINALIZER)
 			else
 				errorp  = error.read_pointer
 				message = errorp.null? ? 'Unknown' : errorp.read_string
-		
+
 				error.autorelease = false
-		
+
 				Bindings.dispose_message(error)
-		
+
 				raise "Error creating execution engine: #{message}"
 			end
 		end
-		
+
 		# Builds a pointer to a global value.
 		#
 		# @param [GlobalValue] global Value you want a pointer to.
@@ -82,7 +82,7 @@ module RLTK::CG
 		def pointer_to_global(global)
 			Bindings.get_pointer_to_global(@ptr, global)
 		end
-		
+
 		# Execute a function in the engine's module with the given arguments.
 		# The arguments may be either GnericValue objects or any object that
 		# can be turned into a GenericValue.
@@ -96,14 +96,14 @@ module RLTK::CG
 			fun.params.zip(args).map do |param, arg|
 				if arg.is_a?(GenericValue) then arg else GenericValue.new(arg) end
 			end
-			
+
 			args_ptr = FFI::MemoryPointer.new(:pointer, args.length)
 			args_ptr.write_array_of_pointer(new_args)
-			
+
 			GenericValue.new(Bindings.run_function(@ptr, fun, args.length, args_ptr))
 		end
 		alias :run :run_function
-		
+
 		# Execute a function in the engine's module with the given arguments
 		# as the main function of a program.
 		#
@@ -115,24 +115,24 @@ module RLTK::CG
 			# Prepare the ARGV parameter.
 			argv = FFI::MemoryPointer.new(:pointer, argc)
 			argv.write_array_of_pointer(args.map { |str| FFI::MemoryPointer.from_string(str) })
-			
+
 			# Prepare the ENV parameter.
 			env = FFI::MemoryPointer.new(:pointer, ENV.size)
 			env.write_array_of_pointer(ENV.to_a.map { |pair| FFI::MemoryPointer.from_string(pair[0] + '=' + pair[1]) })
-			
+
 			GenericValue.new(Bindings.run_function_as_main(@ptr, fun, args.length, argv, env))
 		end
 		alias :run_main :run_function_as_main
-		
+
 		# @return [TargetData] Information about the target architecture for this execution engine.
 		def target_data
 			TargetData.new(Bindings.get_execution_engine_target_data(@ptr))
 		end
 	end
-	
+
 	# An execution engine that interprets the given code.
 	class Interpreter < ExecutionEngine
-		
+
 		# Create a new interpreter.
 		#
 		# @param [Module] mod Module to be executed.
@@ -142,10 +142,10 @@ module RLTK::CG
 			end
 		end
 	end
-	
+
 	# An execution engine that compiles the given code when needed.
 	class JITCompiler < ExecutionEngine
-		
+
 		# Create a new just-in-time compiler.
 		#
 		# @param [Module]	mod		Module to be executed.
@@ -156,10 +156,10 @@ module RLTK::CG
 			end
 		end
 	end
-	
+
 	# Options for initializing a {MCJITCompiler}.
 	class MCJITCompilerOptions < RLTK::CG::Bindings::MCJITCompilerOptions
-		
+
 		# Create an object representing MCJIT compiler options.
 		#
 		# @param [Integer]                        opt_level              Optimization level
@@ -168,16 +168,16 @@ module RLTK::CG
 		# @param [Boolean]                        enable_fast_i_sel      Turn on fast instruction selection
 		def initialize(opt_level = 0, code_model = :jit_default, no_frame_pointer_elim = false,
 		               enable_fast_i_sel = true)
-		     
+
 			Bindings.initialize_mcjit_compiler_options(self.to_ptr, self.class.size)
-			
+
 			super(opt_level, code_model, no_frame_pointer_elim.to_i, enable_fast_i_sel.to_i, nil)
 		end
 	end
-	
+
 	# The new LLVM JIT execution engine.
 	class MCJITCompiler < ExecutionEngine
-		
+
 		# Create a new MC just-in-time-compiler.
 		#
 		# @see http://llvm.org/docs/MCJITDesignAndImplementation.html

data/lib/rltk/cg/function.rb

@@ -17,12 +17,12 @@ require 'rltk/cg/value'
 #######################
 
 module RLTK::CG
-	
+
 	# An LLVM IR function.
 	class Function < GlobalValue
 		# @return [FunctionType] FunctionType object describing this function's type.
 		attr_reader :type
-		
+
 		# Define a new function in a given module.  You can also use the
 		# {Module::FunctionCollection#add} method to add functions to
 		# modules.
@@ -38,31 +38,31 @@ module RLTK::CG
 			case overloaded
 			when FFI::Pointer
 				overloaded
-			
+
 			when RLTK::CG::Module
 				@type = if type_info.first.is_a?(FunctionType) then type_info.first else FunctionType.new(*type_info) end
-				
+
 				Bindings.add_function(overloaded, name.to_s, @type)
-				
+
 			else
 				raise 'The first argument to Function.new must be either a pointer or an instance of RLTK::CG::Module.'
 			end
-			
+
 			self.instance_exec(self, &block) if block
 		end
-		
+
 		# @return [FunctionAttrCollection] Proxy object for inspecting function attributes.
 		def attributes
 			@attributes ||= FunctionAttrCollection.new(self)
 		end
 		alias :attrs :attributes
-		
+
 		# @return [BasicBlockCollection] Proxy object for inspecting a function's basic blocks.
 		def basic_blocks
 			@basic_blocks ||= BasicBlockCollection.new(self)
 		end
 		alias :blocks :basic_blocks
-		
+
 		# Get a function's calling convention.
 		#
 		# @see Bindings._enum_call_conv_
@@ -71,7 +71,7 @@ module RLTK::CG
 		def calling_convention
 			Bindings.enum_type(:call_conv)[Bindings.get_function_call_conv(@ptr)]
 		end
-		
+
 		# Set a function's calling convention.
 		#
 		# @see Bindings._enum_call_conv_
@@ -79,45 +79,45 @@ module RLTK::CG
 		# @param [Symbol] conv Calling convention to set.
 		def calling_convention=(conv)
 			Bindings.set_function_call_conv(@ptr, Bindings.enum_type(:call_conv)[conv])
-			
+
 			conv
 		end
-		
+
 		# @return [ParameterCollection] Proxy object for inspecting a function's parameters.
 		def parameters
 			@parameters ||= ParameterCollection.new(self)
 		end
 		alias :params :parameters
-		
+
 		# Verify that the function is valid LLVM IR.
 		#
 		# @return [nil, String] Human-readable description of any invalid constructs if invalid.
 		def verify
 			do_verification(:return_status)
 		end
-		
+
 		# Verify that the function is valid LLVM IR and abort the process if it isn't.
 		#
 		# @return [nil]
 		def verify!
 			do_verification(:abort_process)
 		end
-		
+
 		# Helper function for {#verify} and {#verify!}
 		def do_verification(action)
 			Bindings.verify_function(@ptr, action).to_bool
 		end
 		private :do_verification
-		
+
 		# This class is used to access a function's {BasicBlock BasicBlocks}
 		class BasicBlockCollection
 			include Enumerable
-			
+
 			# @param [Function] fun Function for which this is a proxy.
 			def initialize(fun)
 				@fun = fun
 			end
-			
+
 			# Add a {BasicBlock} to the end of this function.
 			#
 			# @note The first argument to any proc passed to this function
@@ -133,7 +133,7 @@ module RLTK::CG
 			def append(name = '', builder = nil, context = nil, *block_args, &block)
 				BasicBlock.new(@fun, name, builder, context, *block_args, &block)
 			end
-			
+
 			# An iterator for each block inside this collection.
 			#
 			# @yieldparam block [BasicBlock]
@@ -141,41 +141,41 @@ module RLTK::CG
 			# @return [Enumerator] Returns an Enumerator if no block is given.
 			def each
 				return to_enum :each unless block_given?
-				
+
 				ptr = Bindings.get_first_basic_block(@fun)
-				
+
 				self.size.times do |i|
 					yield BasicBlock.new(ptr)
 					ptr = Bindings.get_next_basic_block(ptr)
 				end
 			end
-			
+
 			# @return [BasicBlock, nil] The function's entry block if it has been added.
 			def entry
 				if (ptr = Bindings.get_entry_basic_block(@fun)) then BasicBlock.new(ptr) else nil end
 			end
-			
+
 			# @return [BasicBlock, nil] The function's first block if one has been added.
 			def first
 				if (ptr = Bindings.get_first_basic_block(@fun)) then BasicBlock.new(ptr) else nil end
 			end
-			
+
 			# @return [BasicBlock, nil] The function's last block if one has been added.
 			def last
 				if (ptr = Bindings.get_last_basic_block(@fun)) then BasicBlock.new(ptr) else nil end
 			end
-			
+
 			# @return [Integer] Number of basic blocks that comprise this function.
 			def size
 				Bindings.count_basic_blocks(@fun)
 			end
 		end
-		
+
 		# This class is used to access a function's attributes.
 		class FunctionAttrCollection < AttrCollection
 			@@add_method = :add_function_attr
 			@@del_method = :remove_function_attr
-			
+
 			# Set a target-dependent function attribute.
 			#
 			# @param [String]  attribute  Attribute name
@@ -186,17 +186,17 @@ module RLTK::CG
 				Bindings.add_target_dependent_function_attr(@value, attribute, value)
 			end
 		end
-		
-		
+
+
 		# This class is used to access a function's parameters.
 		class ParameterCollection
 			include Enumerable
-			
+
 			# @param [Function] fun Function for which this is a proxy.
 			def initialize(fun)
 				@fun = fun
 			end
-			
+
 			# Access the parameter at the given index.
 			#
 			# @param [Integer] index Index of the desired parameter.  May be negative.
@@ -204,12 +204,12 @@ module RLTK::CG
 			# @return [Value] Value object representing the parameter.
 			def [](index)
 				index += self.size if index < 0
-				
+
 				if 0 <= index and index < self.size
 					Value.new(Bindings.get_param(@fun, index))
 				end
 			end
-			
+
 			# An iterator for each parameter inside this collection.
 			#
 			# @yieldparam val [Value]
@@ -217,17 +217,17 @@ 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 function parameters.
 			def size
 				Bindings.count_params(@fun)
 			end
-			
+
 			# @return [Array<Value>] Array of Value objects representing the function parameters.
 			def to_a
 				self.size.times.to_a.inject([]) { |params, index| params << self[index] }