RubyToC 1.0.0.4 → 1.0.0.5

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

@@ -34,59 +34,25 @@ class TestExtraTypeChecker < Test::Unit::TestCase # ZenTest SKIP
   end
 
   # HACK: this shouldn't be in test code. use augment or something
-  def util_process(klass, meth)
-    sexp = @parser.parse_tree_for_method klass, meth
-    sexp = [sexp] unless meth.nil?
-    result = []
-    sexp.each do | sub_exp|
-      result << @type_checker.process(@rewriter.process(sub_exp))
-    end
-    return result
-  end
-
-  def util_unify_function
-    a = Type.function(Type.unknown, [ Type.unknown ], Type.unknown)
-    b = Type.function(Type.long, [ Type.str ], Type.void)
-    a.unify b
-    act = a.list_type
-    bct = b.list_type
-    return act, bct
-  end
-
-  def test_unify_function_whole
-    act, bct = util_unify_function
-    assert_equal act, bct
-  end
-
-  def test_unify_function_receiver
-    act, bct = util_unify_function
-    assert_equal act.receiver_type.list_type, bct.receiver_type.list_type
-    assert_equal act.receiver_type.list_type.object_id, bct.receiver_type.list_type.object_id
-    assert_equal act, bct
-  end
-
-  def test_unify_function_args
-    act, bct = util_unify_function.map { |x| x.formal_types }
-    assert_equal act.first.list_type, bct.first.list_type
-    assert_equal act.first.list_type.object_id, bct.first.list_type.object_id
-  end
+  def test_process_defn_return_val
+    ignore = util_process(RandomCode, :meth_a)
+    result = util_process(RandomCode, :meth_b).first
 
-  def test_unify_function_return
-    act, bct = util_unify_function
-    assert_equal act.return_type.list_type, bct.return_type.list_type
-    assert_equal act.return_type.list_type.object_id, bct.return_type.list_type.object_id
+    assert_equal(:meth_b, result[1])
+    # FIX: this is the worst API in my codebase - demeter
+    assert_equal(Type.void, result.sexp_type.list_type.return_type)
   end
 
   def test_type_inference_across_args_known
     generic  = util_process(RandomCode, :generic_method).first
-# puts
-# pp @type_checker.functions
+    # puts
+    # pp @type_checker.functions
     specific = util_process(RandomCode, :specific_method).first
-# puts
-# pp @type_checker.functions
+    # puts
+    # pp @type_checker.functions
 
-# pp generic
-# pp specific
+    # pp generic
+    # pp specific
 
     args_g = generic[2]  # FIX FUCK this is horrid
     args_s = specific[2] # FIX FUCK this is horrid
@@ -104,15 +70,15 @@ class TestExtraTypeChecker < Test::Unit::TestCase # ZenTest SKIP
                  args_s[1].sexp_type.list_type.object_id,
                  "#specific_method's x and #generic_method's x are unified")
 
-#     assert_equal(args_g[2].sexp_type.list_type.object_id,
-#                  args_s[2].sexp_type.list_type.object_id,
-#                 "#specific_method's y and #generic_method's y are unified")
+    #     assert_equal(args_g[2].sexp_type.list_type.object_id,
+    #                  args_s[2].sexp_type.list_type.object_id,
+    #                 "#specific_method's y and #generic_method's y are unified")
 
-#     assert_equal(Type.long, args_s[2].sexp_type,
-#                  "#specific_method's y is a Long")
-#     assert_equal(Type.long, args_g[2].sexp_type,
-#                  "#generic_method's y is a Long")
-end
+    #     assert_equal(Type.long, args_s[2].sexp_type,
+    #                  "#specific_method's y is a Long")
+    #     assert_equal(Type.long, args_g[2].sexp_type,
+    #                  "#generic_method's y is a Long")
+  end
 
   def test_type_inference_across_args_unknown
     meth_a = util_process(RandomCode, :meth_a).first
@@ -130,14 +96,46 @@ end
                  "#meth_a and meth_b arguments are unified by object_id")
   end
 
-  def test_process_defn_return_val
-    ignore = util_process(RandomCode, :meth_a)
-    result = util_process(RandomCode, :meth_b).first
+  def test_unify_function_args
+    act, bct = util_unify_function.map { |x| x.formal_types }
+    assert_equal act.first.list_type, bct.first.list_type
+    assert_equal act.first.list_type.object_id, bct.first.list_type.object_id
+  end
 
-    assert_equal(:meth_b, result[1])
-    # FIX: this is the worst API in my codebase - demeter
-    assert_equal(Type.void, result.sexp_type.list_type.return_type)
+  def test_unify_function_receiver
+    act, bct = util_unify_function
+    assert_equal act.receiver_type.list_type, bct.receiver_type.list_type
+    assert_equal act.receiver_type.list_type.object_id, bct.receiver_type.list_type.object_id
+    assert_equal act, bct
   end
 
-end
+  def test_unify_function_return
+    act, bct = util_unify_function
+    assert_equal act.return_type.list_type, bct.return_type.list_type
+    assert_equal act.return_type.list_type.object_id, bct.return_type.list_type.object_id
+  end
 
+  def test_unify_function_whole
+    act, bct = util_unify_function
+    assert_equal act, bct
+  end
+
+  def util_process(klass, meth)
+    sexp = @parser.parse_tree_for_method klass, meth
+    sexp = [sexp] unless meth.nil?
+    result = []
+    sexp.each do | sub_exp|
+      result << @type_checker.process(@rewriter.process(sub_exp))
+    end
+    return result
+  end
+
+  def util_unify_function
+    a = Type.function(Type.unknown, [ Type.unknown ], Type.unknown)
+    b = Type.function(Type.long, [ Type.str ], Type.void)
+    a.unify b
+    act = a.list_type
+    bct = b.list_type
+    return act, bct
+  end
+end

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

@@ -22,40 +22,6 @@ class TestRewriter < R2CTestCase
     assert_equal expect, @rewrite.process(input)
   end
 
-  def test_process_defn_block
-    input =  [:defn, :meth, [:scope, [:block, [:args], [:return, [:nil]]]]]
-    output = [:defn, :meth, [:args], [:scope, [:block, [:return, [:nil]]]]]
-
-    assert_equal output, @rewrite.process(input)
-  end
-
-  def test_process_defn_ivar
-    input =  [:defn, :name, [:ivar, :@name]]
-    output = [:defn, :name, [:args], [:scope, [:block, [:return, [:ivar, :@name]]]]]
-
-    assert_equal output, @rewrite.process(input)
-  end
-
-  def test_process_defn_attrset
-    input =  [:defn, :meth, [:attrset, :@name]]
-    output = [:defn, :meth, [:args, :arg], [:scope, [:block, [:return, [:iasgn, :@name, [:lvar, :arg]]]]]]
-
-    assert_equal output, @rewrite.process(input)
-  end
-
-  def test_process_fcall
-    input  = [:fcall, :puts, [:array, [:lit, 1]]]
-    expect = [:call, nil, :puts, [:arglist, [:lit, 1]]]
-    assert_equal expect, @rewrite.process(input)
-  end
-
-  def test_process_vcall_2
-    input =  [:vcall, :method]
-    output = [:call, nil, :method, nil]
-
-    assert_equal output, @rewrite.process(input)
-  end
-
   def test_process_case
     input = [:case,
       [:lvar, :var],
@@ -123,6 +89,33 @@ class TestRewriter < R2CTestCase
     assert_equal expected, @rewrite.process(input)
   end
 
+  def test_process_defn_attrset
+    input =  [:defn, :meth, [:attrset, :@name]]
+    output = [:defn, :meth, [:args, :arg], [:scope, [:block, [:return, [:iasgn, :@name, [:lvar, :arg]]]]]]
+
+    assert_equal output, @rewrite.process(input)
+  end
+
+  def test_process_defn_block
+    input =  [:defn, :meth, [:scope, [:block, [:args], [:return, [:nil]]]]]
+    output = [:defn, :meth, [:args], [:scope, [:block, [:return, [:nil]]]]]
+
+    assert_equal output, @rewrite.process(input)
+  end
+
+  def test_process_defn_ivar
+    input =  [:defn, :name, [:ivar, :@name]]
+    output = [:defn, :name, [:args], [:scope, [:block, [:return, [:ivar, :@name]]]]]
+
+    assert_equal output, @rewrite.process(input)
+  end
+
+  def test_process_fcall
+    input  = [:fcall, :puts, [:array, [:lit, 1]]]
+    expect = [:call, nil, :puts, [:arglist, [:lit, 1]]]
+    assert_equal expect, @rewrite.process(input)
+  end
+
   def test_process_iter
     input = [:iter,
         [:call, [:lit, 3], :downto, [:array, [:lit, 1]]],
@@ -152,7 +145,7 @@ class TestRewriter < R2CTestCase
     assert_equal expected, @rewrite.process(input)
   end
 
-  def test_iter_downto_nested
+  def test_process_iter_downto_nested
     input    = [:block,
                  [:iter,
                    [:call, [:lvar, :n], :downto, [:array, [:lit, 0]]],
@@ -186,7 +179,7 @@ class TestRewriter < R2CTestCase
     assert_equal expected, @rewrite.process(input)
   end
 
-  def test_iter_upto_nested
+  def test_process_iter_upto_nested
     input    = [:block,
                  [:iter,
                    [:call, [:lvar, :n], :upto, [:array, [:lit, 0]]],
@@ -244,6 +237,13 @@ class TestRewriter < R2CTestCase
     assert_equal output, @rewrite.process(input)
   end
 
+  def test_process_vcall_2
+    input =  [:vcall, :method]
+    output = [:call, nil, :method, nil]
+
+    assert_equal output, @rewrite.process(input)
+  end
+
   def test_process_when
     input = [:when, [:array, [:lit, 1]], [:str, "1"]]
 
@@ -260,7 +260,7 @@ class TestR2CRewriter < R2CTestCase
     @rewrite = R2CRewriter.new
   end
 
-  def test_process_call_rewritten
+  def xtest_process_call_rewritten
 
     input = t(:call,
               t(:str, "this", Type.str),
@@ -278,7 +278,7 @@ class TestR2CRewriter < R2CTestCase
     assert_equal expected, @rewrite.process(input)
   end
 
-  def test_process_call_same
+  def xtest_process_call_same
 
     input = t(:call,
               t(:lit, 1, Type.long),

data/{test_ruby_to_c.rb → test/test_ruby_to_ansi_c.rb}

@@ -3,67 +3,55 @@
 $TESTING = true
 
 require 'test/unit'
-require 'ruby_to_c'
+require 'ruby_to_ansi_c'
 require 'r2ctestcase'
 
-class TestTypeMap < Test::Unit::TestCase
+class TestRubyToAnsiC < R2CTestCase
 
-  def test_c_type_long
-    assert_equal "long", TypeMap.c_type(Type.long)
+  def setup
+    @ruby_to_c = RubyToAnsiC.new
+    @ruby_to_c.env.extend
+    @processor = @ruby_to_c
   end
 
-  def test_c_type_long_list
-    assert_equal "long_array", TypeMap.c_type(Type.long_list)
+  def test_c_type_bool
+    assert_equal "bool", @ruby_to_c.class.c_type(Type.bool)
   end
 
-  def test_c_type_str
-    assert_equal "str", TypeMap.c_type(Type.str)
+  def test_c_type_float
+    assert_equal "double", @ruby_to_c.class.c_type(Type.float)
   end
 
-  def test_c_type_str_list
-    assert_equal "str_array", TypeMap.c_type(Type.str_list)
+  def test_c_type_long
+    assert_equal "long", @ruby_to_c.class.c_type(Type.long)
   end
 
-  def test_c_type_bool
-    assert_equal "VALUE", TypeMap.c_type(Type.bool)
+  def test_c_type_long_list
+    assert_equal "long *", @ruby_to_c.class.c_type(Type.long_list)
   end
 
-  def test_c_type_void
-    assert_equal "void", TypeMap.c_type(Type.void)
+  def test_c_type_str
+    assert_equal "str", @ruby_to_c.class.c_type(Type.str)
   end
 
-  def test_c_type_float
-    assert_equal "double", TypeMap.c_type(Type.float)
+  def test_c_type_str_list
+    assert_equal "str *", @ruby_to_c.class.c_type(Type.str_list)
   end
 
   def test_c_type_symbol
-    assert_equal "symbol", TypeMap.c_type(Type.symbol)
-  end
-
-  def test_c_type_value
-    assert_equal "VALUE", TypeMap.c_type(Type.value)
+    assert_equal "symbol", @ruby_to_c.class.c_type(Type.symbol)
   end
 
   def test_c_type_unknown
-    assert_equal "VALUE", TypeMap.c_type(Type.unknown)
+    assert_equal "void *", @ruby_to_c.class.c_type(Type.unknown)
   end
-end
-
-class TestRubyToC < R2CTestCase
 
-  def setup
-    @ruby_to_c = RubyToC.new
-    @ruby_to_c.env.extend
-    @processor = @ruby_to_c
+  def test_c_type_value
+    assert_equal "void *", @ruby_to_c.class.c_type(Type.value)
   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\n// ERROR: NoMethodError: undefined method `[]=' for nil:NilClass\n\nvoid\nfoo() {\nsomething();\n}"
-    assert_equal expected, RubyToC.translator.process(input)
+  def test_c_type_void
+    assert_equal "void", @ruby_to_c.class.c_type(Type.void)
   end
 
   def test_env
@@ -71,17 +59,6 @@ class TestRubyToC < R2CTestCase
     assert_kind_of Environment, @ruby_to_c.env
   end
 
-  def test_prototypes
-    assert_equal [], @ruby_to_c.prototypes
-    @ruby_to_c.process t(:defn,
-                         :empty,
-                         t(:args),
-                         t(:scope),
-                         Type.function([], Type.void))
-
-    assert_equal "void empty();\n", @ruby_to_c.prototypes.first
-  end
-
   def test_process_and
     input  = t(:and, t(:lit, 1, Type.long), t(:lit, 2, Type.long))
     output = "1 && 2"
@@ -89,6 +66,13 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
+  def test_process_args_empty
+    input =  t(:args)
+    output = "()"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
   def test_process_args_normal
     input =  t(:args,
                t(:foo, Type.long),
@@ -98,16 +82,18 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_args_empty
-    input =  t(:args)
-    output = "()"
+  def test_process_array_empty
+    input  = t(:array)
+    output = "rb_ary_new()"
 
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_array_empty
-    input  = t(:array)
-    output = "[]"
+  def test_process_array_multiple
+    input  = t(:array,
+               t(:lvar, :arg1, Type.long),
+               t(:lvar, :arg2, Type.long))
+    output = "arg1, arg2"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -120,11 +106,18 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_array_multiple
-    input  = t(:array,
-               t(:lvar, :arg1, Type.long),
-               t(:lvar, :arg2, Type.long))
-    output = "arg1, arg2"
+  def test_process_block
+    input  = t(:block, t(:return, t(:nil)))
+    output = "return NULL;\n"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_block_multiple
+    input  = t(:block,
+               t(:str, "foo"),
+               t(:return, t(:nil)))
+    output = "\"foo\";\nreturn NULL;\n"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -153,23 +146,12 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_call_rhs
-    input  = t(:call,
-               nil,
-               :name,
-               t(:array,
-                 t(:str, "foo")))
-    output = "name(\"foo\")"
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
   def test_process_call_nil?
     input  = t(:call,
                t(:lvar, :arg, Type.long),
                :nil?,
                nil)
-    output = "NIL_P(arg)"
+    output = "arg"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -188,18 +170,13 @@ class TestRubyToC < R2CTestCase
     end
   end
 
-  def test_process_block
-    input  = t(:block, t(:return, t(:nil)))
-    output = "return Qnil;\n"
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
-  def test_process_block_multiple
-    input  = t(:block,
-               t(:str, "foo"),
-               t(:return, t(:nil)))
-    output = "\"foo\";\nreturn Qnil;\n"
+  def test_process_call_rhs
+    input  = t(:call,
+               nil,
+               :name,
+               t(:array,
+                 t(:str, "foo")))
+    output = "name(\"foo\")"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -241,17 +218,6 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def disabled_test_dstr
-    input  = t(:dstr,
-               "var is ",
-               t(:lvar, :var),
-               t(:str, ". So there."))
-    output = "sprintf stuff goes here"
-
-    flunk "Way too hard right now"
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
   def test_process_dvar
     input  = t(:dvar, :dvar, Type.long)
     output = "dvar"
@@ -261,7 +227,7 @@ class TestRubyToC < R2CTestCase
 
   def test_process_false
     input =  t(:false)
-    output = "Qfalse"
+    output = "0"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -296,19 +262,6 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_if_else
-    input  = t(:if,
-               t(:call,
-                 t(:lit, 1, Type.long),
-                 :==,
-                 t(:array, t(:lit, 2, Type.long))),
-               t(:str, "not equal"),
-               t(:str, "equal"))
-    output = "if (1 == 2) {\n\"not equal\";\n} else {\n\"equal\";\n}"
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
   def test_process_if_block
     input  = t(:if,
                t(:call,
@@ -324,29 +277,15 @@ class TestRubyToC < R2CTestCase
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_iter
-    var_type = Type.long_list
-    input  = t(:iter,
-               t(:call,
-                 t(:lvar, :array, var_type),
-                 :each,
-                 nil),
-               t(:dasgn_curr, :x, Type.long),
+  def test_process_if_else
+    input  = t(:if,
                t(:call,
-                 nil,
-                 :puts,
-                 t(:array,
-                   t(:call,
-                     t(:dvar,
-                       :x,
-                       Type.long),
-                     :to_s,
-                     nil))))
-    output = "unsigned long index_x;
-for (index_x = 0; index_x < array.length; ++index_x) {
-long x = array.contents[index_x];
-puts(to_s(x));
-}"
+                 t(:lit, 1, Type.long),
+                 :==,
+                 t(:array, t(:lit, 2, Type.long))),
+               t(:str, "not equal"),
+               t(:str, "equal"))
+    output = "if (1 == 2) {\n\"not equal\";\n} else {\n\"equal\";\n}"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -366,21 +305,6 @@ puts(to_s(x));
     assert_equal output, @ruby_to_c.process(input)
   end
 
-  def test_process_lasgn_array
-    input  = t(:lasgn,
-               :var,
-               t(:array,
-                 t(:str, "foo", Type.str),
-                 t(:str, "bar", Type.str)),
-               Type.str_list)
-    output = "var.length = 2;
-var.contents = (str*) malloc(sizeof(str) * var.length);
-var.contents[0] = \"foo\";
-var.contents[1] = \"bar\""
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
   def test_process_lit_float
     input  = t(:lit, 1.0, Type.float)
     output = "1.0"
@@ -397,7 +321,7 @@ var.contents[1] = \"bar\""
 
   def test_process_lit_sym
     input  = t(:lit, :sym, Type.symbol)
-    output = ":sym"
+    output = "\"sym\""
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -411,14 +335,14 @@ var.contents[1] = \"bar\""
 
   def test_process_nil
     input  = t(:nil)
-    output = "Qnil"
+    output = "NULL"
 
     assert_equal output, @ruby_to_c.process(input)
   end
 
   def test_process_not
     input  = t(:not, t(:true, Type.bool), Type.bool)
-    output = "!(Qtrue)"
+    output = "!(1)"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -432,29 +356,7 @@ var.contents[1] = \"bar\""
 
   def test_process_return
     input =  t(:return, t(:nil))
-    output = "return Qnil"
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
-  def test_process_str
-    input  = t(:str, "foo", Type.str)
-    output = "\"foo\""
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
-  def test_process_str_multi
-    input  = t(:str, "foo
-bar", Type.str)
-    output = "\"foo\\nbar\""
-
-    assert_equal output, @ruby_to_c.process(input)
-  end
-
-  def test_process_str_backslashed
-    input  = t(:str, "foo\nbar", Type.str)
-    output = "\"foo\\nbar\""
+    output = "return NULL"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -463,7 +365,7 @@ bar", Type.str)
     input =  t(:scope,
                t(:block,
                  t(:return, t(:nil))))
-    output = "{\nreturn Qnil;\n}"
+    output = "{\nreturn NULL;\n}"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -481,14 +383,36 @@ bar", Type.str)
                            t(:str, "declare me"),
                            Type.str),
                          t(:return, t(:nil))))
-    output = "{\nstr arg;\narg = \"declare me\";\nreturn Qnil;\n}"
+    output = "{\nstr arg;\narg = \"declare me\";\nreturn NULL;\n}"
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_str
+    input  = t(:str, "foo", Type.str)
+    output = "\"foo\""
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_str_backslashed
+    input  = t(:str, "foo\nbar", Type.str)
+    output = "\"foo\\nbar\""
+
+    assert_equal output, @ruby_to_c.process(input)
+  end
+
+  def test_process_str_multi
+    input  = t(:str, "foo
+bar", Type.str)
+    output = "\"foo\\nbar\""
 
     assert_equal output, @ruby_to_c.process(input)
   end
 
   def test_process_true
     input =  t(:true)
-    output = "Qtrue"
+    output = "1"
 
     assert_equal output, @ruby_to_c.process(input)
   end
@@ -530,4 +454,35 @@ bar", Type.str)
 
     assert_equal expected, @ruby_to_c.process(input)
   end
+
+  def test_prototypes
+    assert_equal [], @ruby_to_c.prototypes
+    @ruby_to_c.process t(:defn,
+                         :empty,
+                         t(:args),
+                         t(:scope),
+                         Type.function([], Type.void))
+
+    assert_equal "void empty();\n", @ruby_to_c.prototypes.first
+  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\nvoid\nsomething() {\nwhaaa?();\n}\n\nvoid\nfoo() {\nsomething();\n}"
+    assert_equal expected, RubyToAnsiC.translator.process(input)
+  end
+
+  def disabled_test_dstr
+    input  = t(:dstr,
+               "var is ",
+               t(:lvar, :var),
+               t(:str, ". So there."))
+    output = "sprintf stuff goes here"
+
+    flunk "Way too hard right now"
+    assert_equal output, @ruby_to_c.process(input)
+  end
 end