rltk3 3.0.2

data/test/cg/tc_value.rb

@@ -0,0 +1,151 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2012/05/09
+# Description:	This file contains unit tests for the RLTK::CG::Value class and
+#			its subclasses.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cg/llvm'
+require 'rltk/cg/module'
+require 'rltk/cg/execution_engine'
+require 'rltk/cg/type'
+require 'rltk/cg/value'
+
+class ValueTester < Minitest::Test
+	def setup
+		RLTK::CG::LLVM.init(:X86)
+
+		@mod = RLTK::CG::Module.new('Testing Module')
+		@jit = RLTK::CG::JITCompiler.new(@mod)
+	end
+
+	def test_array_values
+		fun = @mod.functions.add('array_function_tester', RLTK::CG::NativeIntType,
+		                         [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+
+			blocks.append do
+				ptr = alloca(RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2))
+
+				array = load(ptr)
+				array = insert_value(array, fun.params[0], 0)
+				array = insert_value(array, fun.params[1], 1)
+
+				ret(add(extract_value(array, 0), extract_value(array, 1)))
+			end
+		end
+
+		assert_equal(5, @jit.run_function(fun, 2, 3).to_i)
+	end
+
+	def test_constant_array_from_array
+		array = RLTK::CG::ConstantArray.new(RLTK::CG::NativeIntType, [RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)])
+
+		assert_instance_of(RLTK::CG::ConstantArray, array)
+		assert_equal(2, array.length)
+	end
+
+	def test_constant_array_from_size
+		array = RLTK::CG::ConstantArray.new(RLTK::CG::NativeIntType, 2) { |i| RLTK::CG::NativeInt.new(i) }
+
+		assert_instance_of(RLTK::CG::ConstantArray, array)
+		assert_equal(2, array.length)
+	end
+
+	def test_constant_vector_elements
+		fun = @mod.functions.add('constant_vector_elements_tester', RLTK::CG::NativeIntType,
+		                         [RLTK::CG::NativeIntType, RLTK::CG::NativeIntType]) do |fun|
+
+			blocks.append do
+				ptr = alloca(RLTK::CG::VectorType.new(RLTK::CG::NativeIntType, 2))
+
+				vector = load(ptr)
+				vector = insert_element(vector, fun.params[0], RLTK::CG::NativeInt.new(0))
+				vector = insert_element(vector, fun.params[1], RLTK::CG::NativeInt.new(1))
+
+				ret(add(extract_element(vector, RLTK::CG::NativeInt.new(0)), extract_element(vector, RLTK::CG::NativeInt.new(1))))
+			end
+		end
+
+		assert_equal(5, @jit.run_function(fun, 2, 3).to_i)
+	end
+
+	def test_constant_vector_from_array
+		vector = RLTK::CG::ConstantVector.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)])
+
+		assert_instance_of(RLTK::CG::ConstantVector, vector)
+		assert_equal(2, vector.size)
+	end
+
+	def test_constant_vector_from_size
+		vector = RLTK::CG::ConstantVector.new(2) { |i| RLTK::CG::NativeInt.new(i) }
+
+		assert_instance_of(RLTK::CG::ConstantVector, vector)
+		assert_equal(2, vector.size)
+	end
+
+	def test_constant_vector_shuffle
+		fun = @mod.functions.add('constant_vector_shuffle_tester', RLTK::CG::NativeIntType, Array.new(4, RLTK::CG::NativeIntType)) do |fun|
+			blocks.append do
+				vec_type = RLTK::CG::VectorType.new(RLTK::CG::NativeIntType, 2)
+
+				v0 = load(alloca(vec_type))
+				v0 = insert_element(v0, fun.params[0], RLTK::CG::NativeInt.new(0))
+				v0 = insert_element(v0, fun.params[1], RLTK::CG::NativeInt.new(1))
+
+				v1 = load(alloca(vec_type))
+				v1 = insert_element(v1, fun.params[2], RLTK::CG::NativeInt.new(0))
+				v1 = insert_element(v1, fun.params[3], RLTK::CG::NativeInt.new(1))
+
+				v2 = shuffle_vector(v0, v1, RLTK::CG::ConstantVector.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(3)]))
+
+				ret(add(extract_element(v2, RLTK::CG::NativeInt.new(0)), extract_element(v2, RLTK::CG::NativeInt.new(1))))
+			end
+		end
+
+		assert_equal(5, @jit.run_function(fun, 1, 2, 3, 4).to_i)
+	end
+
+	def test_constant_struct_from_size_packed
+		struct = RLTK::CG::ConstantStruct.new(2, true) { |i| RLTK::CG::NativeInt.new(i) }
+
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+
+	def test_constant_struct_from_size_unpacked
+		struct = RLTK::CG::ConstantStruct.new(2, false) { |i| RLTK::CG::NativeInt.new(i) }
+
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+
+	def test_constant_struct_from_values_packed
+		struct = RLTK::CG::ConstantStruct.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)], true)
+
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+
+	def test_constant_struct_from_values_unpacked
+		struct = RLTK::CG::ConstantStruct.new([RLTK::CG::NativeInt.new(0), RLTK::CG::NativeInt.new(1)], false)
+
+		assert_instance_of(RLTK::CG::ConstantStruct, struct)
+		assert_equal(2, struct.operands.size)
+	end
+
+	def test_equality
+		v0 = RLTK::CG::NativeInt.new(0)
+		v1 = RLTK::CG::NativeInt.new(1)
+		v2 = RLTK::CG::NativeInt.new(v0.ptr)
+
+		assert_equal(v0, v2)
+		refute_equal(v0, v1)
+	end
+end

data/test/cg/ts_cg.rb

@@ -0,0 +1,23 @@
+# Author:      Chris Wailes <chris.wailes@gmail.com>
+# Project:     Ruby Language Toolkit
+# Date:        2012/05/04
+# Description: This file contains test suit for the RLTK LLVM bindigns.  It
+#              requires the individual tests from their respective files.
+
+############
+# Requires #
+############
+
+# Ruby Language Toolkit
+require 'cg/tc_llvm'
+require 'cg/tc_module'
+
+require 'cg/tc_basic_block'
+require 'cg/tc_control_flow'
+require 'cg/tc_function'
+require 'cg/tc_generic_value'
+require 'cg/tc_instruction'
+require 'cg/tc_math'
+require 'cg/tc_transforms'
+require 'cg/tc_type'
+require 'cg/tc_value'

data/test/tc_ast.rb

@@ -0,0 +1,332 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2011/04/06
+# Description:	This file contains unit tests for the RLTK::ASTNode class.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/ast'
+
+#######################
+# Classes and Modules #
+#######################
+
+class ASTNodeTester < Minitest::Test
+	class ANode < RLTK::ASTNode
+		child :left, ANode
+		child :right, ANode
+	end
+
+	class BNode < ANode; end
+	class CNode < ANode; end
+
+	class DNode < RLTK::ASTNode; end
+
+	class ENode < RLTK::ASTNode
+		value :str, String
+	end
+
+	class FNode < ENode
+		child :c, [ENode]
+	end
+
+	class SNode < RLTK::ASTNode
+		value :string, String
+
+		child :left, SNode
+		child :right, SNode
+	end
+
+	class VNode < RLTK::ASTNode
+		value :a, Integer
+		value :b, Integer
+	end
+
+	class ONode < RLTK::ASTNode
+		value :a, Integer
+		value :b, Integer, true
+		value :c, Integer
+	end
+
+	class ValuesFirstNode < RLTK::ASTNode
+		child :b, ValuesFirstNode
+		value :a, Integer
+	end
+
+	class ChildrenFirstNode < RLTK::ASTNode
+		order :children
+
+		value :b, Integer
+		child :a, ChildrenFirstNode
+	end
+
+	class DefOrderNode < RLTK::ASTNode
+		order :def
+
+		value :a, Integer
+		child :b, DefOrderNode
+		value :c, Float
+	end
+
+	class CustomOrderNode < RLTK::ASTNode
+		custom_order :a, :b, :c, :d
+
+		child :b, CustomOrderNode
+		child :d, CustomOrderNode
+
+		value :a, Integer
+		value :c, String
+	end
+
+	def setup
+		@leaf0 = CNode.new
+		@tree0 = ANode.new(BNode.new(@leaf0), BNode.new)
+
+		@tree1 = ANode.new(BNode.new(CNode.new), BNode.new)
+		@tree2 = ANode.new(BNode.new, BNode.new(CNode.new))
+		@tree3 = ANode.new(CNode.new(BNode.new), CNode.new)
+
+		@tree4 =	SNode.new('F',
+					SNode.new('B',
+						SNode.new('A'),
+						SNode.new('D',
+							SNode.new('C'),
+							SNode.new('E')
+						),
+					),
+					SNode.new('G',
+						nil,
+						SNode.new('I',
+							SNode.new('H')
+						)
+					)
+				)
+
+		@tree5 = FNode.new('one',
+				[FNode.new('two',
+					[ENode.new('three')]),
+				ENode.new('four')])
+
+		@tree6 = FNode.new('one',
+				[FNode.new('two',
+					[ENode.new('three')]),
+				ENode.new('four')])
+
+		@tree7 = FNode.new('one!',
+				[FNode.new('two!',
+					[ENode.new('three!')]),
+				ENode.new('four!')])
+
+		@bc_proc = Proc.new do |n|
+			case n
+			when BNode then	CNode.new(n.left, n.right)
+			when CNode then	BNode.new(n.left, n.right)
+			else				n
+			end
+		end
+	end
+
+	def test_children
+		node = ANode.new
+
+		assert_equal(node.children, [nil, nil])
+
+		node.children = (expected_children = [BNode.new, CNode.new])
+
+		assert_equal(node.children, expected_children)
+
+		node.children = (expected_children = {:left => CNode.new, :right => BNode.new})
+
+		assert_equal(node.children(Hash), expected_children)
+	end
+
+	def test_copy
+		new_tree = @tree5.copy
+
+		assert_equal(@tree5, new_tree)
+	end
+
+	def test_dump
+		tree0_string = @tree0.dump
+
+		reloaded_tree = Marshal.load(tree0_string)
+
+		assert_equal(@tree0, reloaded_tree)
+	end
+
+	def test_each
+		# Test pre-order
+		nodes	= []
+		expected	= ['F', 'B', 'A', 'D', 'C', 'E', 'G', 'I', 'H']
+		@tree4.each(:pre) { |n| nodes << n.string }
+
+		assert_equal(expected, nodes)
+
+		# Test post-order
+		nodes	= []
+		expected	= ['A', 'C', 'E', 'D', 'B', 'H', 'I', 'G', 'F']
+		@tree4.each(:post) { |n| nodes << n.string }
+
+		assert_equal(expected, nodes)
+
+		# Test level-order
+		nodes	= []
+		expected	= ['F', 'B', 'G', 'A', 'D', 'I', 'C', 'E', 'H']
+		@tree4.each(:level) { |n| nodes << n.string }
+
+		assert_equal(expected, nodes)
+
+		# Test iteration with array children.
+
+		res	= ''
+		@tree5.each(:pre) { |node| res += ' ' + node.str }
+		assert_equal(res, ' one two three four')
+
+		res	= ''
+		@tree5.each(:post) { |node| res += ' ' + node.str }
+		assert_equal(res, ' three two four one')
+
+		res	= ''
+		@tree5.each(:level) { |node| res += ' ' + node.str }
+		assert_equal(res, ' one two four three')
+	end
+
+	def test_equal
+		assert_equal(@tree0, @tree1)
+		refute_equal(@tree0, @tree2)
+	end
+
+	def test_initialize
+		assert_raises(AbstractClassError) { RLTK::ASTNode.new }
+
+		node = ENode.new { self.str = 'hello world' }
+		assert_equal('hello world', node.str)
+	end
+
+	def test_map
+		mapped_tree = @tree1.map(&@bc_proc)
+
+		assert_equal(@tree0, @tree1)
+		assert_equal(@tree3, mapped_tree)
+
+		mapped_tree = @tree5.map do |c|
+			c.str += '!'
+
+			c
+		end
+
+		assert_equal(@tree6, @tree5)
+		assert_equal(@tree7, mapped_tree)
+	end
+
+	def test_map!
+		tree1_clone = @tree1.clone
+		tree1_clone.map!(&@bc_proc)
+
+		refute_equal(@tree1, tree1_clone)
+		assert_equal(@tree3, tree1_clone)
+
+		replace_node = BNode.new
+		replace_node = replace_node.map!(&@bc_proc)
+
+		assert_equal(CNode.new, replace_node)
+
+		@tree5.map! do |c|
+			c.str += '!'
+
+			c
+		end
+
+		refute_equal(@tree6, @tree5)
+		assert_equal(@tree7, @tree5)
+	end
+
+	def test_notes
+		node = ANode.new
+
+		assert_nil(node[:a])
+		assert_equal(node[:a] = :b, :b)
+		assert_equal(node.note?(:a), true)
+		assert_equal(node.note?(:b), false)
+		assert_equal(node.delete_note(:a), :b)
+		assert_nil(node[:a])
+	end
+
+	def test_omit
+		onode = ONode.new(1, 3)
+
+		assert_equal(1, onode.a)
+		assert_nil(onode.b)
+		assert_equal(3, onode.c)
+	end
+
+	def test_one_definition_rule
+		asserter = self
+
+		Class.new(ANode) do
+			asserter.assert_raises(ArgumentError) { child :left, ANode }
+		end
+
+		Class.new(ENode) do
+			asserter.assert_raises(ArgumentError) { value :str, String }
+		end
+	end
+
+	def test_ordering
+		vfn = ValuesFirstNode.new(42, ValuesFirstNode.new)
+
+		a, b = vfn.destructure(2)
+
+		assert_equal(42, a)
+		assert_instance_of(ValuesFirstNode, b)
+
+		cfn = ChildrenFirstNode.new(ChildrenFirstNode.new, 42)
+
+		a, b = cfn.destructure(2)
+
+		assert_instance_of(ChildrenFirstNode, a)
+		assert_equal(42, b)
+
+		dfn = DefOrderNode.new(4, DefOrderNode.new, 2.0)
+
+		a, b, c = dfn.destructure(3)
+
+		assert_equal(4, a)
+		assert_instance_of(DefOrderNode, b)
+		assert_equal(2.0, c)
+
+		con = CustomOrderNode.new(42, CustomOrderNode.new, 'foo')
+
+		a, b, c, d = con.destructure(4)
+
+		assert_equal(42, a)
+		assert_instance_of(CustomOrderNode, b)
+		assert_equal('foo', c)
+		assert_nil(d)
+	end
+
+	def test_root
+		assert_same(@tree0, @tree0.root)
+		assert_same(@tree0, @leaf0.root)
+	end
+
+	def test_value
+		node = VNode.new
+
+		assert_equal(node.values, [nil, nil])
+
+		node.values = (expected_values = [42, 1984])
+
+		assert_equal(node.values, expected_values)
+
+		node.values = (expected_values = {:a => 1984, :b => 42})
+
+		assert_equal(node.values(Hash), expected_values)
+	end
+end

data/test/tc_cfg.rb

@@ -0,0 +1,164 @@
+# Author:		Chris Wailes <chris.wailes@gmail.com>
+# Project: 	Ruby Language Toolkit
+# Date:		2011/04/06
+# Description:	This file contains unit tests for the RLTK::CFG class.
+
+############
+# Requires #
+############
+
+# Gems
+require 'minitest/autorun'
+
+# Ruby Language Toolkit
+require 'rltk/cfg'
+
+#######################
+# Classes and Modules #
+#######################
+
+class CFGTester < Minitest::Test
+	def setup
+		@grammar = RLTK::CFG.new
+
+		@grammar.production(:s) do
+			clause('A G D')
+			clause('A a C')
+			clause('B a D')
+			clause('B G C')
+		end
+
+		@grammar.production(:a, 'b')
+		@grammar.production(:b, 'G')
+	end
+
+	def test_callback
+		grammar = RLTK::CFG.new
+
+		call_count = 0
+		grammar.callback do |type, which, p|
+			refute_nil(p)
+			assert_equal(type, :optional)
+
+			case call_count
+			when 0 then assert_equal(:empty, which)
+			when 1 then assert_equal(:nonempty, which)
+			end
+
+			call_count += 1
+		end
+
+		grammar.production(:a, 'A?') { |a| a }
+		assert_equal(2, call_count)
+
+		call_count = 0
+		grammar.callback do |type, which, p|
+			refute_nil(p)
+
+			case call_count
+			when 0
+				assert_equal(:elp, type)
+				assert_equal(:empty, which)
+
+			when 1
+				assert_equal(:elp, type)
+				assert_equal(:nonempty, which)
+
+			when 2
+				assert_equal(:nelp, type)
+				assert_equal(:single, which)
+
+			when 3
+				assert_equal(:nelp, type)
+				assert_equal(:multiple, which)
+			end
+
+			call_count += 1
+		end
+
+		grammar.production(:a, 'A*') { |a| a }
+		assert_equal(4, call_count)
+
+		call_count = 0
+		grammar.callback do |type, which, p|
+			refute_nil(p)
+			assert_equal(type, :nelp)
+
+			case call_count
+			when 0 then assert_equal(:single, which)
+			when 1 then assert_equal(:multiple, which)
+			end
+
+			call_count += 1
+		end
+
+		grammar.production(:a, 'A+') { |a| a }
+		assert_equal(2, call_count)
+	end
+
+	def test_first_set
+		@grammar.first_set(:s).each do |sym|
+			assert_includes([:A, :B], sym)
+		end
+
+		assert_equal([:G], @grammar.first_set(:b))
+		assert_equal([:G], @grammar.first_set(:a))
+	end
+
+	def test_follow_set
+		assert_equal(@grammar.follow_set(:s), [:EOS])
+
+		@grammar.follow_set(:a).each do |sym|
+			assert([:C, :D].include?(sym))
+		end
+
+		@grammar.follow_set(:b).each do |sym|
+			assert([:C, :D].include?(sym))
+		end
+	end
+
+	def test_is_nonterminal
+		assert(RLTK::CFG::is_nonterminal?(:lowercase))
+		assert(!RLTK::CFG::is_nonterminal?(:UPERCASE))
+	end
+
+	def test_is_terminal
+		assert(!RLTK::CFG::is_terminal?(:lowercase))
+		assert(RLTK::CFG::is_terminal?(:UPERCASE))
+	end
+
+	def test_item
+		i0 = RLTK::CFG::Item.new(0, 0, :a, [:b, :C, :D, :e])
+		i1 = i0.copy
+
+		assert_equal(i0, i1)
+		assert(!i0.at_end?)
+		assert_equal(:b, i0.next_symbol)
+
+		i0.advance
+
+		refute_equal(i0, i1)
+		assert(!i0.at_end?)
+		assert_equal(:C, i0.next_symbol)
+
+		i0.advance
+		assert(!i0.at_end?)
+		assert_equal(:D, i0.next_symbol)
+
+		i0.advance
+		assert(!i0.at_end?)
+		assert_equal(:e, i0.next_symbol)
+
+		i0.advance
+		assert(i0.at_end?)
+		assert_nil(i0.next_symbol)
+	end
+
+	def test_production
+		p0 = RLTK::CFG::Production.new(0, :a, [:b, :C, :D, :e])
+		p1 = p0.copy
+
+		assert_equal(p0, p1)
+		assert_equal(:D, p0.last_terminal)
+	end
+end