koi-reference-compiler 0.0.1

data/test/compiler/unit/node_extensions/control_flow/if_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class IfTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  test "should compile If" do
+    tree = If.new("if( 1 == 1 )\n arg = 1\n end", 0, [
+      Expression.new("1 == 1", 4, [
+        ComparativeExpression.new("1 == 1", 4, [
+          IntegerLiteral.new("1", 4),
+          EqualityOperator.new("==", 6),
+          IntegerLiteral.new("1", 9)
+        ])
+      ]),
+      Block.new("arg = 1\n", 13,[
+        Statement.new("arg = 1", 13, [
+          Assignment.new("arg = 1", 14, [
+            Identifier.new("arg", 14),
+            AssignmentOperator.new("=", 18),
+            Expression.new("1", 20, [
+              IntegerLiteral.new("1", 20)
+            ])
+          ])
+        ])
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      PUSH_INT, 1,
+      EQUAL,
+      JUMP_UNLESS, 6,
+      PUSH_INT, 1,
+      SET_LOCAL, :arg
+    ], bytecode
+  end
+  
+end

data/test/compiler/unit/node_extensions/control_flow/unless_test.rb

@@ -0,0 +1,40 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class UnlessTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  test "should compile Unless" do
+    input = "unless( 1 == 1 )\n arg = 1\n end"
+    tree = Unless.new("unless( 1 == 1 )\n arg = 1\n end", 0, [
+      Expression.new("1 == 1", 8, [
+        ComparativeExpression.new("1 == 1", 8, [
+          IntegerLiteral.new("1", 8),
+          EqualityOperator.new("==", 10),
+          IntegerLiteral.new("1", 13)
+        ])
+      ]),
+      Block.new("arg = 1\n", 17,[
+        Statement.new("arg = 1", 17, [
+          Assignment.new("arg = 1", 18, [
+            Identifier.new("arg", 18),
+            AssignmentOperator.new("=", 22),
+            Expression.new("1", 24, [
+              IntegerLiteral.new("1", 24)
+            ])
+          ])
+        ])
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      PUSH_INT, 1,
+      EQUAL,
+      JUMP_IF, 6,
+      PUSH_INT, 1,
+      SET_LOCAL, :arg
+    ], bytecode
+  end
+  
+end

data/test/compiler/unit/node_extensions/expressions/additive_expression_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class AdditiveExpressionTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  test "should compile AdditiveExpression" do
+    tree = AdditiveExpression.new("1 + 2", 0, [
+      IntegerLiteral.new("1", 0),
+      AdditionOperator.new("+", 2),
+      IntegerLiteral.new("2", 4)
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      PUSH_INT, 2, 
+      ADD
+    ], bytecode
+  end
+  
+end

data/test/compiler/unit/node_extensions/expressions/comparative_expression_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class ComparativeExpressionTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  test "should compile ComparativeExpression" do
+    tree = ComparativeExpression.new("1 == 2", 0, [
+      IntegerLiteral.new("1", 0),
+      EqualityOperator.new("==", 2),
+      IntegerLiteral.new("2", 5)
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      PUSH_INT, 2, 
+      EQUAL
+    ], bytecode
+  end
+  
+end

data/test/compiler/unit/node_extensions/expressions/expression_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class ExpressionTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  test "should compile Expression" do
+    tree = Expression.new("1", 0, [
+      IntegerLiteral.new("1", 0)
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1
+    ], bytecode
+  end
+  
+end

data/test/compiler/unit/node_extensions/expressions/multitive_expression_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class MultitiveExpressionTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  test "should compile MultitiveExpression" do
+    tree = ComparativeExpression.new("1 * 2", 0, [
+      IntegerLiteral.new("1", 0),
+      MultiplicationOperator.new("*", 2),
+      IntegerLiteral.new("2", 4)
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      PUSH_INT, 2, 
+      MULTIPLY
+    ], bytecode
+  end
+  
+end

data/test/compiler/unit/node_extensions/functions/function_call_test.rb

@@ -0,0 +1,296 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', '..', 'test_helper.rb'))
+
+class FunctionCallTest < Test::Unit::TestCase
+
+  include KoiReferenceCompiler
+  
+  ##################
+  # call()
+  
+  test "should compile FunctionCall for call() built-in" do
+    tree = FunctionCall.new("call( test, 1 )", 0, [
+      Identifier.new("call", 0),
+      Expression.new("test", 6, [
+        Identifier.new("test", 6)
+      ]),
+      Expression.new("1", 12, [
+        IntegerLiteral.new("1", 12)
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      GET_LOCAL, :test,
+      CALL
+    ], bytecode
+  end
+  
+  test "should raise CompileError if call() is passed only 1 argument" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("call( test )", 0, [
+        Identifier.new("call", 0),
+        Expression.new("test", 6, [
+          Identifier.new("test", 6)
+        ])
+      ])
+      tree.compile
+    end
+  end
+  
+  test "should raise CompileError if call() is not passed any arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("call()", 0, [
+        Identifier.new("call", 0)
+      ])
+      tree.compile
+    end
+  end
+  
+  ##################
+  # print()
+  
+  test "should compile FunctionCall for print() built-in" do
+    tree = FunctionCall.new("print( test )", 0, [
+      Identifier.new("print", 0),
+      Expression.new("test", 7, [
+        Identifier.new("test", 7)
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      GET_LOCAL, :test,
+      PRINT
+    ], bytecode
+  end
+  
+  test "should raise CompileError if print() is not passed any arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("print()", 0, [
+        Identifier.new("print", 0)
+      ])
+      tree.compile
+    end
+  end
+  
+  test "should raise CompileError if print() is passed 2 arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("print( test, 1 )", 0, [
+        Identifier.new("print", 0),
+        Expression.new("test", 7, [
+          Identifier.new("test", 7)
+        ]),
+        Expression.new("1", 13, [
+          IntegerLiteral.new("1", 13)
+        ])
+      ])
+      tree.compile
+    end
+  end
+  
+  ##################
+  # gets()  
+  
+  test "should compile FunctionCall for gets() built-in" do
+    tree = FunctionCall.new("gets()", 0, [
+      Identifier.new("gets", 0)
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      GETS
+    ], bytecode
+  end
+  
+  test "should raise CompileError if gets() is passed 1 argument" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("gets( test )", 0, [
+        Identifier.new("gets", 0),
+        Expression.new("test", 6, [
+          Identifier.new("test", 6)
+        ])
+      ])
+      tree.compile
+    end
+  end
+  
+  test "should raise CompileError if gets() is passed 2 arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("gets( test, 1 )", 0, [
+        Identifier.new("gets", 0),
+        Expression.new("test", 7, [
+          Identifier.new("test", 7)
+        ]),
+        Expression.new("1", 13, [
+          IntegerLiteral.new("1", 13)
+        ])
+      ])
+      tree.compile
+    end
+  end
+  
+  ##################
+  # tailcall()
+  
+  test "should compile FunctionCall for tailcall() built-in" do
+    tree = FunctionCall.new("tailcall( test, 1 )", 0, [
+      Identifier.new("tailcall", 0),
+      Expression.new("test", 10, [
+        Identifier.new("test", 10)
+      ]),
+      Expression.new("1", 16, [
+        IntegerLiteral.new("1", 16)
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      PUSH_INT, 1,
+      GET_LOCAL, :test,
+      TAILCALL
+    ], bytecode
+  end
+  
+  test "should raise CompileError if tailcall() is not passed any arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("tailcall()", 0, [
+        Identifier.new("tailcall", 0)
+      ])
+      tree.compile
+    end
+  end
+  
+  ##################
+  # return()
+  
+  test "should compile FunctionCall for return() built-in" do
+    tree = FunctionCall.new("return( test )", 0, [
+      Identifier.new("return", 0),
+      Expression.new("test", 8, [
+        Identifier.new("test", 8)
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      GET_LOCAL, :test,
+      RETURN
+    ], bytecode
+  end
+  
+  test "should compile FunctionCall for return() built-in with no arguments" do
+    tree = FunctionCall.new("return()", 0, [
+      Identifier.new("return", 0)
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      RETURN
+    ], bytecode
+  end
+  
+  test "should raise CompileError if return() is passed 2 arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("return( test, 1 )", 0, [
+        Identifier.new("return", 0),
+        Expression.new("test", 7, [
+          Identifier.new("test", 7)
+        ]),
+        Expression.new("1", 13, [
+          IntegerLiteral.new("1", 13)
+        ])
+      ])
+      tree.compile
+    end
+  end
+  
+  ##################
+  # to_string()
+  
+  test "should compile FunctionCall for to_string() built-in" do
+    tree = FunctionCall.new("to_string( test )", 0, [
+      Identifier.new("to_string", 0),
+      Expression.new("test", 11, [
+        Identifier.new("test", 11)
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      GET_LOCAL, :test,
+      TO_STRING
+    ], bytecode
+  end
+  
+  test "should raise CompileError if to_string() is not passed any arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("to_string()", 0, [
+        Identifier.new("to_string", 0)
+      ])
+      tree.compile
+    end
+  end
+  
+  test "should raise CompileError if to_string() is passed 2 arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("to_string( test, 1 )", 0, [
+        Identifier.new("to_string", 0),
+        Expression.new("test", 7, [
+          Identifier.new("test", 7)
+        ]),
+        Expression.new("1", 13, [
+          IntegerLiteral.new("1", 13)
+        ])
+      ])
+      tree.compile
+    end
+  end
+
+  ##################
+  # type_of()
+
+  test "should compile FunctionCall for type_of() built-in" do
+    tree = FunctionCall.new("type_of( test )", 0, [
+      Identifier.new("type_of", 0),
+      Expression.new("test", 9, [
+        Identifier.new("test", 9)
+      ])
+    ])
+    bytecode = tree.compile
+    assert_equal [
+      GET_LOCAL, :test,
+      TYPEOF
+    ], bytecode
+  end
+  
+  test "should raise CompileError if type_of() is not passed any arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("type_of()", 0, [
+        Identifier.new("type_of", 0)
+      ])
+      tree.compile
+    end
+  end
+  
+  test "should raise CompileError if type_of() is passed 2 arguments" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("type_of( test, 1 )", 0, [
+        Identifier.new("type_of", 0),
+        Expression.new("test", 7, [
+          Identifier.new("test", 7)
+        ]),
+        Expression.new("1", 13, [
+          IntegerLiteral.new("1", 13)
+        ])
+      ])
+      tree.compile
+    end
+  end
+  
+  ##################
+  # unknown!
+  
+  test "should raise CompileError if function name is not defined" do
+    assert_raises CompileError do
+      tree = FunctionCall.new("fooey()", 0, [
+        Identifier.new("fooey", 0)
+      ])
+      tree.compile
+    end
+  end
+  
+end