rltk 3.0.0 → 3.0.1

data/lib/rltk/parsers/infix_calc.rb

@@ -15,28 +15,28 @@ require 'rltk/parser'
 #######################
 
 module RLTK
-	
+
 	# The RLTK::Parsers module contains the parsers that are included as part
 	# of the RLKT project.
 	module Parsers
-		
+
 		# A parser for a simple infix calculator.
 		class InfixCalc < Parser
-			
+
 			left :PLS, :SUB
 			right :MUL, :DIV
-			
+
 			production(:e) do
 				clause('NUM') { |n| n }
-				
+
 				clause('LPAREN e RPAREN') { |_, e, _| e }
-				
+
 				clause('e PLS e') { |e0, _, e1| e0 + e1 }
 				clause('e SUB e') { |e0, _, e1| e0 - e1 }
 				clause('e MUL e') { |e0, _, e1| e0 * e1 }
 				clause('e DIV e') { |e0, _, e1| e0 / e1 }
 			end
-			
+
 			finalize
 		end
 	end

data/lib/rltk/parsers/postfix_calc.rb

@@ -16,18 +16,18 @@ require 'rltk/parser'
 
 module RLTK
 	module Parsers
-		
+
 		# A parser for a simple post-fix calculator.
 		class PostfixCalc < Parser
 			production(:e) do
 				clause('NUM') { |n| n }
-				
+
 				clause('e e PLS') { |e0, e1, _| e0 + e1 }
 				clause('e e SUB') { |e0, e1, _| e0 - e1 }
 				clause('e e MUL') { |e0, e1, _| e0 * e1 }
 				clause('e e DIV') { |e0, e1, _| e0 / e1 }
 			end
-			
+
 			finalize
 		end
 	end

data/lib/rltk/parsers/prefix_calc.rb

@@ -16,18 +16,18 @@ require 'rltk/parser'
 
 module RLTK
 	module Parsers
-		
+
 		# A parser for a simple prefix calculator.
 		class PrefixCalc < Parser
 			production(:e) do
 				clause('NUM') { |n| n }
-				
+
 				clause('PLS e e') { |_, e0, e1| e0 + e1 }
 				clause('SUB e e') { |_, e0, e1| e0 - e1 }
 				clause('MUL e e') { |_, e0, e1| e0 * e1 }
 				clause('DIV e e') { |_, e0, e1| e0 / e1 }
 			end
-			
+
 			finalize
 		end
 	end

data/lib/rltk/token.rb

@@ -13,21 +13,21 @@ module RLTK
 	class StreamPosition
 		# @return [Integer]
 		attr_accessor :stream_offset
-		
+
 		# @return [Integer]
 		attr_accessor :line_number
-		
+
 		# @return [Integer]
 		attr_accessor :line_offset
-		
+
 		# @return [Integer]
 		attr_accessor :length
-		
+
 		# @return [String]
 		attr_accessor :file_name
-		
+
 		alias :start :line_offset
-		
+
 		# Instantiates a new StreamPosition object with the values specified.
 		#
 		# @param [Integer]		stream_offset	The position from the beginning of the stream.
@@ -43,19 +43,19 @@ module RLTK
 			@file_name	= file_name
 		end
 	end
-	
+
 	# The Token class is used to represent the output of a RLTK::Lexer and the
 	# input of a RLTK::Parser.
 	class Token
 		# @return [Symbol]
 		attr_reader :type
-		
+
 		# @return [Symbol]
 		attr_reader :value
-		
+
 		# @return [StreamPosition] StreamPosition object associated with this token.
 		attr_reader :position
-		
+
 		# Instantiates a new Token object with the values specified.
 		#
 		# @param [Symbol]				type		A symbol representing the type of this Token.
@@ -64,10 +64,10 @@ module RLTK
 		def initialize(type, value = nil, position = nil)
 			@type	= type
 			@value	= value
-			
+
 			@position	= position
 		end
-		
+
 		# Compares one token to another.  This only tests the token's *type*
 		# and *value* and not the location of the token in its source.
 		#
@@ -77,7 +77,7 @@ module RLTK
 		def ==(other)
 			self.type == other.type and self.value == other.value
 		end
-		
+
 		# @return [String] String representing the tokens *type* and *value*.
 		def to_s
 			if value

data/lib/rltk/version.rb

@@ -1,11 +1,11 @@
-# Author:		Chris Wailes <chris.wailes@gmail.com>
-# Project: 	Ruby Language Toolkit
-# Date:		2012/03/08
-# Description:	This file specifies the version number of RLTK.
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Ruby Language Toolkit
+# Date:        2012/03/08
+# Description: This file specifies the version number of RLTK.
 
 module RLTK
 	# The version number of the RLTK library.
-	VERSION			= '3.0.0'
+	VERSION             = '3.0.1'
 	# The version of LLVM targeted by RLTK.
-	LLVM_TARGET_VERSION	= '3.4'
+	LLVM_TARGET_VERSION = '3.4'
 end

data/test/cg/tc_basic_block.rb

@@ -18,64 +18,64 @@ require 'rltk/cg/module'
 class BasicBlockTester < Minitest::Test
 	def setup
 		RLTK::CG::LLVM.init(:X86)
-		
+
 		@mod = RLTK::CG::Module.new('Testing Module')
 	end
-	
+
 	def test_basic_block
 		fun = @mod.functions.add('basic_block_tester', RLTK::CG::VoidType, [])
 		bb0 = fun.blocks.append
 		bb1 = fun.blocks.append
-		
+
 		assert_equal(fun, bb0.parent)
 		assert_equal(fun, bb1.parent)
-		
+
 		assert_equal(bb1, bb0.next)
 		assert_equal(bb0, bb1.previous)
-		
+
 		bb0.build { br(bb1) }
 		bb1.build { ret_void }
-		
+
 		assert_equal(bb0.instructions.first, bb0.instructions.last)
 		assert_equal(bb1.instructions.first, bb1.instructions.last)
 	end
-	
+
 	def test_basic_block_collection
 		fun = @mod.functions.add('basic_block_collection_tester', RLTK::CG::VoidType, [])
 		bb0 = fun.blocks.append
-		
+
 		assert_instance_of(RLTK::CG::BasicBlock, bb0)
-		
+
 		assert_equal(1, fun.blocks.size)
 		assert_equal(fun.blocks.first, fun.blocks.last)
 		assert_equal(fun.blocks.first, fun.blocks.entry)
-		
+
 		bb1 = fun.blocks.append
-		
+
 		assert_equal(2, fun.blocks.size)
 		assert_equal(bb0, fun.blocks.first)
 		assert_equal(bb1, fun.blocks.last)
-		
+
 		[fun.blocks.each.to_a, fun.blocks.to_a].each do |blocks|
 			assert_equal(2, blocks.size)
 			assert_equal(bb0, blocks[0])
 			assert_equal(bb1, blocks[1])
 		end
 	end
-	
+
 	def test_basic_block_enumeration
 		fun = @mod.functions.add('basic_block_enumeration_tester', RLTK::CG::DoubleType, [RLTK::CG::DoubleType])
 		bb0 = fun.blocks.append
-		
+
 		[bb0.instructions.each.to_a, bb0.instructions.to_a].each do |insts|
 			assert_equal(0, insts.size)
 		end
-		
+
 		bb0.build { ret(fadd(fun.params[0], RLTK::CG::Double.new(1.0))) }
-		
+
 		[bb0.instructions.each.to_a, bb0.instructions.to_a].each do |insts|
 			assert_equal(2, insts.size)
-			
+
 			assert_equal(bb0.instructions.first, insts[0])
 			assert_equal(bb0.instructions.last,  insts[1])
 		end

data/test/cg/tc_control_flow.rb

@@ -20,171 +20,171 @@ require 'rltk/cg/type'
 class ControlFlowTester < Minitest::Test
 	def setup
 		RLTK::CG::LLVM.init(:X86)
-		
+
 		@mod = RLTK::CG::Module.new('Testing Module')
 		@jit = RLTK::CG::JITCompiler.new(@mod)
 	end
-	
+
 	##############
 	# Call Tests #
 	##############
-	
+
 	def test_external_call
 		extern = @mod.functions.add('abs', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType])
-		
+
 		fun = @mod.functions.add('external_call_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType]) do |fun|
 			blocks.append { ret call(extern, fun.params[0]) }
 		end
-		
+
 		assert_equal(10, @jit.run_function(fun, -10).to_i)
 	end
-	
+
 	def test_external_string_call
 		global = @mod.globals.add(RLTK::CG::ArrayType.new(RLTK::CG::Int8Type, 5), "path")
 		global.linkage = :internal
 		global.initializer = RLTK::CG::ConstantString.new('PATH')
-		
+
 		external = @mod.functions.add('getenv', RLTK::CG::PointerType.new(RLTK::CG::Int8Type), [RLTK::CG::PointerType.new(RLTK::CG::Int8Type)])
-		
+
 		fun = @mod.functions.add('external_string_call_tester', RLTK::CG::PointerType.new(RLTK::CG::Int8Type), []) do
 			blocks.append do
 				param = gep(global, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(0)])
-				
+
 				ret call(external, param)
 			end
 		end
-		
+
 		assert_equal(ENV['PATH'], @jit.run_function(fun).ptr.read_pointer.read_string)
 	end
-	
+
 	def test_nested_call
 		fun0 = @mod.functions.add('simple_call_tester0', RLTK::CG::NativeIntType, []) do
 			blocks.append { ret RLTK::CG::NativeInt.new(1) }
 		end
-		
+
 		fun1 = @mod.functions.add('simple_call_tester1', RLTK::CG::NativeIntType, []) do
 			blocks.append { ret call(fun0) }
 		end
-		
+
 		assert_equal(1, @jit.run_function(fun1).to_i)
 	end
-	
+
 	def test_recursive_call
 		fun = @mod.functions.add('recursive_call_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType]) do |fun|
 			entry	= blocks.append
 			recurse	= blocks.append
 			exit		= blocks.append
-			
+
 			entry.build do
 				cond(icmp(:uge, fun.params[0], RLTK::CG::NativeInt.new(5)), exit, recurse)
 			end
-			
+
 			result =
 			recurse.build do
 				call(fun, add(fun.params[0], RLTK::CG::NativeInt.new(1))).tap { br exit }
 			end
-			
+
 			exit.build do
 				ret(phi(RLTK::CG::NativeIntType, {entry => fun.params[0], recurse => result}))
 			end
 		end
-		
+
 		assert_equal(5, @jit.run_function(fun, 1).to_i)
 		assert_equal(6, @jit.run_function(fun, 6).to_i)
 	end
-	
+
 	##############
 	# Jump Tests #
 	##############
-	
+
 	def test_cond_jump
 		fun = @mod.functions.add('direct_jump_tester', RLTK::CG::NativeIntType, []) do |fun|
 			entry = blocks.append
-			
+
 			bb0 = blocks.append { ret RLTK::CG::NativeInt.new(1) }
 			bb1 = blocks.append { ret RLTK::CG::NativeInt.new(0) }
-			
+
 			entry.build do
 				cond(icmp(:eq, RLTK::CG::NativeInt.new(1), RLTK::CG::NativeInt.new(2)), bb0, bb1)
 			end
 		end
-		
+
 		assert_equal(0, @jit.run_function(fun).to_i)
 	end
-	
+
 	def test_direct_jump
 		fun = @mod.functions.add('direct_jump_tester', RLTK::CG::NativeIntType, []) do |fun|
 			entry = blocks.append
-			
+
 			bb0 = blocks.append { ret(RLTK::CG::NativeInt.new(1)) }
 			bb1 = blocks.append { ret(RLTK::CG::NativeInt.new(0)) }
-			
+
 			entry.build { br bb1 }
 		end
-		
+
 		assert_equal(0, @jit.run_function(fun).to_i)
 	end
-	
+
 	def test_switched_jump
 		fun = @mod.functions.add('direct_jump_tester', RLTK::CG::NativeIntType, []) do |fun|
 			entry = blocks.append
-			
+
 			bb0 = blocks.append { ret RLTK::CG::NativeInt.new(1) }
 			bb1 = blocks.append { ret RLTK::CG::NativeInt.new(0) }
-			
+
 			entry.build do
 				switch(RLTK::CG::NativeInt.new(1), bb0, {RLTK::CG::NativeInt.new(1) => bb1})
 			end
 		end
-		
+
 		assert_equal(0, @jit.run_function(fun).to_i)
 	end
-	
+
 	##############
 	# Misc Tests #
 	##############
-	
+
 	def test_select
 		fun = @mod.functions.add('select_tester', RLTK::CG::Int1Type, [RLTK::CG::NativeIntType]) do |fun|
 			blocks.append do
 				ret select(fun.params[0], RLTK::CG::Int1.new(0), RLTK::CG::Int1.new(1))
 			end
 		end
-		
+
 		assert_equal(0, @jit.run_function(fun, 1).to_i(false))
 		assert_equal(1, @jit.run_function(fun, 0).to_i(false))
 	end
-	
+
 	#############
 	# Phi Tests #
 	#############
-	
+
 	def test_phi
 		fun = @mod.functions.add('phi_tester', RLTK::CG::NativeIntType, [RLTK::CG::NativeIntType]) do |fun|
 			entry	= blocks.append('entry')
 			block0	= blocks.append('block0')
 			block1	= blocks.append('block1')
 			exit		= blocks.append('exit')
-		
+
 			entry.build do
 				cond(icmp(:eq, fun.params[0], RLTK::CG::NativeInt.new(0)), block0, block1)
 			end
-		
+
 			result0 =
 			block0.build do
 				add(fun.params[0], RLTK::CG::NativeInt.new(1)).tap { br(exit) }
 			end
-		
+
 			result1 =
 			block1.build do
 				sub(fun.params[0], RLTK::CG::NativeInt.new(1)).tap { br(exit) }
 			end
-		
+
 			exit.build do
 				ret(phi(RLTK::CG::NativeIntType, {block0 => result0, block1 => result1}))
 			end
 		end
-		
+
 		assert_equal(1, @jit.run_function(fun, 0).to_i)
 		assert_equal(0, @jit.run_function(fun, 1).to_i)
 	end