RubyToC 1.0.0.4 → 1.0.0.5

data/test/test_ruby_to_ruby_c.rb

@@ -0,0 +1,27 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING = true
+
+require 'test/unit'
+require 'ruby_to_ruby_c'
+require 'r2ctestcase'
+
+# TODO: maybe make this a subclass of TestRubyToAnsiC??? might be a bad idea
+class TestRubyToRubyC < R2CTestCase
+
+  def setup
+    @ruby_to_c = RubyToRubyC.new
+    @ruby_to_c.env.extend
+    @processor = @ruby_to_c
+  end
+
+  def test_translator
+    Object.class_eval "class Suck; end"
+    input = [:class, :Suck, :Object,
+      [:defn, :something, [:scope, [:block, [:args], [:fcall, :"whaaa\?"]]]],
+      [:defn, :foo, [:scope, [:block, [:args], [:vcall, :something]]]]]
+    expected = "// class Suck\n\nVALUE\nsomething() {\nrb_funcall(self, rb_intern(\"whaaa?\"), 0);\n}\n\nVALUE\nfoo() {\nrb_funcall(self, rb_intern(\"something\"), 0);\n}"
+    assert_equal expected, RubyToRubyC.translator.process(input)
+  end
+
+end

data/{test_support.rb → test/test_support.rb}

@@ -335,8 +335,15 @@ class TestEnvironment < Test::Unit::TestCase
   end
 
   def test_add
-    assert_equal 42, @env.add('var', 42)
-    assert_equal 42, @env.lookup('var')
+    assert_equal 42, @env.add(:var, 42)
+    assert_equal 42, @env.lookup(:var)
+  end
+
+  def test_add_depth
+    @env.scope do
+      assert_equal 42, @env.add(:var, 42, 1)
+    end
+    assert_equal 42, @env.lookup(:var)
   end
 
   def test_add_raises_on_illegal
@@ -345,28 +352,41 @@ class TestEnvironment < Test::Unit::TestCase
     end
 
     assert_raises RuntimeError do
-      @env.add 1, 'foo'
+      @env.add 1, :foo
     end
   end
 
   def test_add_segmented
     @env.scope do
-      @env.add 'var', 42
-      assert_equal 42, @env.lookup('var')
+      @env.add :var, 42
+      assert_equal 42, @env.lookup(:var)
     end
 
     assert_raises NameError do
-      @env.lookup('var')
+      @env.lookup(:var)
     end
   end
 
   def test_current
-    @env.add 'var', 42
+    @env.add :var, 42
     
-    expected = { 'var' => 42 }
+    expected = { :var => 42 }
     assert_equal expected, @env.current
   end
 
+  def test_all
+    @env.scope do
+      @env.add :x, 42
+      @env.scope do
+        @env.add :y, 24
+        @env.add :x, 15
+        expected = { :x => 15, :y => 24 }
+
+        assert_equal expected, @env.all
+      end
+    end
+  end
+  
   def test_depth
     assert_equal 1, @env.depth
 
@@ -394,48 +414,65 @@ class TestEnvironment < Test::Unit::TestCase
   end
 
   def test_lookup
-    @env.add 'var', 1
-    assert_equal 1, @env.lookup('var')
+    @env.add :var, 1
+    assert_equal 1, @env.lookup(:var)
   end
 
   def test_lookup_raises
     assert_raises NameError do
-      @env.lookup('var')
+      @env.lookup(:var)
     end
   end
 
   def test_lookup_extended
-    @env.add 'var', 1
-    assert_equal 1, @env.lookup('var')
+    @env.add :var, 1
+    assert_equal 1, @env.lookup(:var)
 
     @env.scope do
-      assert_equal 1, @env.lookup('var')
+      assert_equal 1, @env.lookup(:var)
     end
   end
 
   def test_scope
-    @env.add 'var', 1
-    assert_equal 1, @env.lookup('var')
+    @env.add :var, 1
+    assert_equal 1, @env.lookup(:var)
 
     @env.scope do
-      @env.add 'var', 2
-      assert_equal 2, @env.lookup('var')
+      @env.add :var, 2
+      assert_equal 2, @env.lookup(:var)
+    end
+
+    assert_equal 1, @env.lookup(:var)
+  end
+
+  def test_scope_raise
+    @env.add :a, 2
+
+    begin
+      @env.scope do
+        @env.add :a, 1
+        @env.add :b, 2
+        raise "woo"
+      end
+    rescue
+      # should replicate baddies
     end
 
-    assert_equal 1, @env.lookup('var')
+    expected = { :a => 2 }
+    assert_equal expected, @env.all
   end
 
   def test_unextend
     @env.extend
 
-    @env.add 'var', 1
+    @env.add :var, 1
 
-    assert_equal 1, @env.lookup('var')
+    assert_equal 1, @env.lookup(:var)
 
     @env.unextend
 
     assert_raises NameError do
-      @env.lookup 'var'
+      @env.lookup :var
     end
   end
 
@@ -448,63 +485,63 @@ class TestFunctionTable < Test::Unit::TestCase
   end
 
   def test_add_function
-    type = @function_table.add_function 'func', Type.long
+    type = @function_table.add_function :func, Type.long
 
     assert_equal Type.long, type
-    assert_equal Type.long, @function_table['func']
+    assert_equal Type.long, @function_table[:func]
   end
 
   def test_cheat
-    @function_table.add_function 'func', Type.long
-    @function_table.add_function 'func', Type.str
+    @function_table.add_function :func, Type.long
+    @function_table.add_function :func, Type.str
 
-    assert_equal [Type.long, Type.str], @function_table.cheat('func')
+    assert_equal [Type.long, Type.str], @function_table.cheat(:func)
   end
 
   def test_has_key?
-    @function_table.add_function 'func', Type.long
+    @function_table.add_function :func, Type.long
 
-    assert_equal true, @function_table.has_key?('func')
+    assert_equal true, @function_table.has_key?(:func)
     assert_equal false, @function_table.has_key?('no such func')
   end
 
   def test_index
-    @function_table.add_function 'func', Type.long
+    @function_table.add_function :func, Type.long
 
-    assert_equal Type.long, @function_table['func']
+    assert_equal Type.long, @function_table[:func]
 
-    @function_table.add_function 'func', Type.str
+    @function_table.add_function :func, Type.str
 
-    assert_equal Type.long, @function_table['func']
+    assert_equal Type.long, @function_table[:func]
   end
 
   def test_unify_one_type
-    @function_table.add_function 'func', Type.unknown
+    @function_table.add_function :func, Type.unknown
 
-    @function_table.unify 'func', Type.long do
+    @function_table.unify :func, Type.long do
       flunk "Block should not have been called"
     end
 
-    assert_equal Type.long, @function_table['func']
+    assert_equal Type.long, @function_table[:func]
   end
 
   def test_unify_two_type
-    @function_table.add_function 'func', Type.unknown
-    @function_table.add_function 'func', Type.str
+    @function_table.add_function :func, Type.unknown
+    @function_table.add_function :func, Type.str
 
-    @function_table.unify 'func', Type.long do
+    @function_table.unify :func, Type.long do
       flunk "Block should not have been called"
     end
 
-    assert_equal Type.long, @function_table['func']
+    assert_equal Type.long, @function_table[:func]
   end
 
   def test_unify_block_called_no_type
-    @function_table.add_function 'func', Type.str
+    @function_table.add_function :func, Type.str
 
     test_var = false
 
-    @function_table.unify 'func', Type.long do
+    @function_table.unify :func, Type.long do
       test_var = true
     end
 
@@ -514,7 +551,7 @@ class TestFunctionTable < Test::Unit::TestCase
   def test_unify_block_called_no_unify
     test_var = false
 
-    @function_table.unify 'func', Type.long do
+    @function_table.unify :func, Type.long do
       test_var = true
     end
 

data/{test_type_checker.rb → test/test_type_checker.rb}

@@ -50,6 +50,33 @@ class TestTypeChecker < R2CTestCase
                  @type_checker.functions[:>])
   end
 
+  def test_defn_call_unify
+    # pre-registered function, presumibly through another :call elsewhere
+    add_fake_function :specific, Type.unknown, Type.unknown, Type.unknown
+
+    # now in specific, unify with a long
+# puts "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+# pp @type_checker.functions
+    s = @type_checker.process(s(:defn, :specific,
+                                s(:args, :x),
+                                s(:scope,
+                                  s(:block,
+                                    s(:lasgn, :x, s(:lit, 2))))))
+# pp @type_checker.functions
+    s_type = @type_checker.functions[:specific]
+
+# p s_type
+
+    assert_equal(Type.long,
+                 s_type.list_type.formal_types[0])
+# HACK    flunk "eric hasn't finished writing me yet. guilt. guilt. guilt."
+  end
+
+  def test_env
+    @type_checker.env.add :blah, Type.long
+    assert_equal Type.long, @type_checker.env.lookup(:blah) 
+  end
+
   def test_functions
     # bootstrap populates functions
     assert @type_checker.functions.has_key?(:puts)
@@ -57,27 +84,10 @@ class TestTypeChecker < R2CTestCase
                  @type_checker.functions[:>])
   end
 
-  def test_env
-    @type_checker.env.add :blah, Type.long
-    assert_equal Type.long, @type_checker.env.lookup(:blah) 
- end
-
   def test_genv
     assert_equal Type.file, @type_checker.genv.lookup(:$stderr)
   end
 
-  def test_translate
-    result = @type_checker.translate DumbClass, :empty
-    expect = t(:defn,
-               :empty,
-               t(:args),
-               t(:scope,
-                 t(:block,
-                   t(:nil, Type.value), Type.unknown), Type.void),
-               Type.function(Type.unknown, [], Type.void))
-    assert_equal(expect, result)
-  end
-
   def test_process_args
     @type_checker.env.extend
 
@@ -97,6 +107,18 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
+  def test_process_array_multiple
+    add_fake_var :arg1, Type.long
+    add_fake_var :arg2, Type.str
+
+    input =  t(:array, t(:lvar, :arg1), t(:lvar, :arg2))
+    output = t(:array,
+               t(:lvar, :arg1, Type.long),
+               t(:lvar, :arg2, Type.str))
+
+    assert_equal output, @type_checker.process(input)
+  end
+
   def test_process_array_single
     add_fake_var :arg1, Type.long
 
@@ -110,14 +132,62 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, result
   end
 
-  def test_process_array_multiple
-    add_fake_var :arg1, Type.long
-    add_fake_var :arg2, Type.str
+  def test_process_block
+    input  = t(:block, t(:return, t(:nil)))
+    # FIX: should this really be void for return?
+    output = t(:block,
+               t(:return,
+                 t(:nil, Type.value),
+                 Type.void),
+               Type.unknown)
 
-    input =  t(:array, t(:lvar, :arg1), t(:lvar, :arg2))
-    output = t(:array,
-               t(:lvar, :arg1, Type.long),
-               t(:lvar, :arg2, Type.str))
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_block_multiple
+    input  = t(:block,
+               t(:str, :foo),
+               t(:return, t(:nil)))
+    output = t(:block,
+               t(:str, :foo, Type.str),
+               t(:return,
+                 t(:nil, Type.value),
+                 Type.void),
+               Type.unknown)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_case_equal_long
+    add_fake_var :number, Type.unknown
+
+    input  = t(:call,
+               t(:lit, 1),
+               :===,
+               t(:arglist, t(:lvar, :number)))
+    output = t(:call,
+               t(:lit, 1, Type.long),
+               :case_equal_long,
+               t(:arglist,
+                 t(:lvar, :number, Type.long)),
+               Type.bool)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
+  def test_process_call_case_equal_string
+    add_fake_var :string, Type.unknown
+
+    input  = t(:call,
+               t(:str, 'foo'),
+               :===,
+               t(:arglist, t(:lvar, :string)))
+    output = t(:call,
+               t(:str, 'foo', Type.str),
+               :case_equal_str,
+               t(:arglist,
+                 t(:lvar, :string, Type.str)),
+               Type.bool)
 
     assert_equal output, @type_checker.process(input)
   end
@@ -269,63 +339,6 @@ class TestTypeChecker < R2CTestCase
                  @type_checker.functions[:unify_3_outer].list_type.formal_types[0])
   end
 
-  def test_defn_call_unify
-
-    # pre-registered function, presumibly through another :call elsewhere
-    add_fake_function :specific, Type.unknown, Type.unknown, Type.unknown
-
-    # now in specific, unify with a long
-# puts "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
-# pp @type_checker.functions
-    s = @type_checker.process(s(:defn, :specific,
-                                s(:args, :x),
-                                s(:scope,
-                                  s(:block,
-                                    s(:lasgn, :x, s(:lit, 2))))))
-# pp @type_checker.functions
-    s_type = @type_checker.functions[:specific]
-
-# p s_type
-
-    assert_equal(Type.long,
-                 s_type.list_type.formal_types[0])
-# HACK    flunk "eric hasn't finished writing me yet. guilt. guilt. guilt."
-  end
-
-  def test_process_call_case_equal_long
-    add_fake_var :number, Type.unknown
-
-    input  = t(:call,
-               t(:lit, 1),
-               :===,
-               t(:arglist, t(:lvar, :number)))
-    output = t(:call,
-               t(:lit, 1, Type.long),
-               :case_equal_long,
-               t(:arglist,
-                 t(:lvar, :number, Type.long)),
-               Type.bool)
-
-    assert_equal output, @type_checker.process(input)
-  end
-
-  def test_process_call_case_equal_string
-    add_fake_var :string, Type.unknown
-
-    input  = t(:call,
-               t(:str, 'foo'),
-               :===,
-               t(:arglist, t(:lvar, :string)))
-    output = t(:call,
-               t(:str, 'foo', Type.str),
-               :case_equal_str,
-               t(:arglist,
-                 t(:lvar, :string, Type.str)),
-               Type.bool)
-
-    assert_equal output, @type_checker.process(input)
-  end
-
   # HACK: putting class X above w/ some consts
   def test_process_class
     input = s(:class, :X, :Object,
@@ -370,32 +383,6 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
-  def test_process_block
-    input  = t(:block, t(:return, t(:nil)))
-    # FIX: should this really be void for return?
-    output = t(:block,
-               t(:return,
-                 t(:nil, Type.value),
-                 Type.void),
-               Type.unknown)
-
-    assert_equal output, @type_checker.process(input)
-  end
-
-  def test_process_block_multiple
-    input  = t(:block,
-               t(:str, :foo),
-               t(:return, t(:nil)))
-    output = t(:block,
-               t(:str, :foo, Type.str),
-               t(:return,
-                 t(:nil, Type.value),
-                 Type.void),
-               Type.unknown)
-
-    assert_equal output, @type_checker.process(input)
-  end
-
   def test_process_dasgn_curr
     @type_checker.env.extend
     input  = t(:dasgn_curr, :x)
@@ -450,7 +437,7 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
-  def test_gasgn
+  def test_process_gasgn
     input = s(:gasgn, :$blah, s(:lit, 42))
     expected = t(:gasgn, :$blah, t(:lit, 42, Type.long), Type.long)
 
@@ -606,6 +593,13 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
+  def test_process_lit_float
+    input  = t(:lit, 1.0)
+    output = t(:lit, 1.0, Type.float)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
   def test_process_lit_long
     input  = t(:lit, 1)
     output = t(:lit, 1, Type.long)
@@ -620,13 +614,6 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
-  def test_process_lit_float
-    input  = t(:lit, 1.0)
-    output = t(:lit, 1.0, Type.float)
-
-    assert_equal output, @type_checker.process(input)
-  end
-
   def test_process_lvar
     add_fake_var :arg, Type.long
     input  = t(:lvar, :arg)
@@ -669,21 +656,6 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
-# HACK is this test valid? I don't think so
-#  def test_process_return_empty
-#    input  = t(:return)
-#    output = t(:return, t(:nil, Type.value), Type.void)
-#
-#    assert_equal output, @type_checker.process(input)
-#  end
-
-  def test_process_str
-    input  = t(:str, "foo")
-    output = t(:str, "foo", Type.str)
-
-    assert_equal output, @type_checker.process(input)
-  end
-
   def test_process_scope
     input  = t(:scope,
                t(:block,
@@ -706,6 +678,13 @@ class TestTypeChecker < R2CTestCase
     assert_equal output, @type_checker.process(input)
   end
 
+  def test_process_str
+    input  = t(:str, "foo")
+    output = t(:str, "foo", Type.str)
+
+    assert_equal output, @type_checker.process(input)
+  end
+
   def test_process_true
     input =  t(:true)
     output = t(:true, Type.bool)
@@ -745,6 +724,18 @@ class TestTypeChecker < R2CTestCase
     assert_equal expected, @type_checker.process(input)
   end
 
+  def test_translate
+    result = @type_checker.translate DumbClass, :empty
+    expect = t(:defn,
+               :empty,
+               t(:args),
+               t(:scope,
+                 t(:block,
+                   t(:nil, Type.value), Type.unknown), Type.void),
+               Type.function(Type.unknown, [], Type.void))
+    assert_equal(expect, result)
+  end
+
   def add_fake_function(name, reciever_type, return_type, *arg_types)
     @type_checker.functions.add_function(name,
                                          Type.function(reciever_type, arg_types, return_type))