rltk 3.0.0 → 3.0.1

data/test/cg/tc_transforms.rb

@@ -21,46 +21,46 @@ require 'rltk/cg/value'
 class TransformTester < 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_gdce
 		fn0 = @mod.functions.add('fn0', RLTK::CG::VoidType, []) do |fun|
 			fun.linkage = :internal
-			
+
 			blocks.append do
 				ret_void
 			end
 		end
-		
+
 		fn1 = @mod.functions.add('fn1', RLTK::CG::VoidType, []) do |fun|
 			fun.linkage = :internal
-			
+
 			blocks.append do
 				ret_void
 			end
 		end
-		
+
 		main = @mod.functions.add('main', RLTK::CG::VoidType, []) do
 			blocks.append do
 				call(fn0)
 				ret_void
 			end
 		end
-		
+
 		funs = @mod.functions.to_a
-		
+
 		assert(funs.include?(fn0))
 		assert(funs.include?(fn1))
 		assert(funs.include?(main))
-		
+
 		@mod.pass_manager << :GDCE
 		assert(@mod.pass_manager.run)
-		
+
 		funs = @mod.functions.to_a
-		
+
 		assert( funs.include?(fn0))
 		assert(!funs.include?(fn1))
 		assert( funs.include?(main))

data/test/cg/tc_type.rb

@@ -19,48 +19,48 @@ class TypeTester < Minitest::Test
 		@pointee = RLTK::CG::NativeIntType.instance
 		@pointer = RLTK::CG::PointerType.new(@pointee)
 	end
-	
+
 	def test_deferrent_element_type_stuct_type
 		type = RLTK::CG::StructType.new([], 'test_struct')
 		type.element_types = [RLTK::CG::NativeIntType, RLTK::CG::FloatType]
-		
+
 		assert_equal(2, type.element_types.size)
 		assert_equal(RLTK::CG::NativeIntType.instance, type.element_types[0])
 		assert_equal(RLTK::CG::FloatType.instance, type.element_types[1])
-		
+
 	end
-	
+
 	def test_element_type
 		assert_equal(@pointee, @pointer.element_type)
 	end
-	
+
 	def test_equality
 		assert_equal(RLTK::CG::NativeIntType, RLTK::CG::NativeIntType)
 		refute_equal(RLTK::CG::NativeIntType, RLTK::CG::FloatType)
-		
+
 		at0 = RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2)
 		at1 = RLTK::CG::ArrayType.new(RLTK::CG::NativeIntType, 2)
 		at2 = RLTK::CG::ArrayType.new(RLTK::CG::FloatType, 2)
-		
+
 		assert_equal(at0, at1)
 		refute_equal(at0, at2)
 	end
-	
+
 	def test_kind
 		assert_equal(:pointer, @pointer.kind)
 		assert_equal(:integer, @pointee.kind)
 	end
-	
+
 	def test_named_struct_type
 		type = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType], 'test_struct')
-		
+
 		assert_instance_of(RLTK::CG::StructType, type)
 		assert_equal('test_struct', type.name)
 	end
-	
+
 	def test_simple_struct_type
 		type = RLTK::CG::StructType.new([RLTK::CG::NativeIntType, RLTK::CG::FloatType])
-		
+
 		assert_instance_of(RLTK::CG::StructType, type)
 		assert_equal(2, type.element_types.size)
 		assert_equal(RLTK::CG::NativeIntType.instance, type.element_types[0])

data/test/cg/tc_value.rb

@@ -21,130 +21,130 @@ 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

data/test/cg/ts_cg.rb

@@ -1,8 +1,8 @@
-# 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.
+# 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 #

data/test/tc_ast.rb

@@ -27,35 +27,71 @@ class ASTNodeTester < Minitest::Test
 	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'),
@@ -71,22 +107,22 @@ class ASTNodeTester < Minitest::Test
 						)
 					)
 				)
-		
+
 		@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)
@@ -95,125 +131,125 @@ class ASTNodeTester < Minitest::Test
 			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)
-		
+
 		mapped_tree = @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)
@@ -221,35 +257,76 @@ class ASTNodeTester < Minitest::Test
 		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