RubyToC 1.0.0.4

data/History.txt

@@ -0,0 +1,69 @@
+*** 1.0.0-beta-4 / 2005-07-13
+
++ 1 minor enhancements
+	+ Added gemspec (hastily).
++ 2 bug fixes
+	+ Translates bool type to VALUE since we were using Qtrue/Qfalse.
+	+ Fixed rubygems for non-gem systems.
+
+*** 1.0.0-beta-3 / 2005-06-08
+
++ 16 minor enhancements
+	+ Added ivar and iasgn support. Needs more work.
+	+ Added limited support for self.
+	+ Added pipeline tests for bools, call_arglist, call_attrasgn, fbody.
+	+ Added process_not to RubyToC.
+	+ Added support for float and symbol literals.
+	+ Added support for gasgn, cvasgn, const (class consts, not classes).
+	+ Improved error handling/reporting, esp in RubyToC.
+	+ In TypeChecker.boostrap, pre-registered all base classes.
+	+ Modified process_class test to include a class const.
+	+ Processing :class now adds class constants to the local var scope.
+	+ Processing :const checks both genv and env now.
+	+ Rearchitected all tests into a pipeline test class.
+	+ Rewrite attrasgn into regular calls.
+	+ Rewrite fbody into a regular defn.
+	+ Rewrote :array inside call to :arglist.
+	+ Rewrote :or nodes in process_case to correctly be binary.
++ 1 bug fix:
+	+ Fixed a bug where single line while bodies were missing a semicolon.
+
+*** 1.0.0-beta-2 / 2005-02-15
+
++ 1 minor enhancement
+	+ Added post-condition while/until support and tests.
++ 4 bug fixes
+	+ Fixed bug:1422: Escape newlines to prevent multi-line strings in C.
+	+ Fixed bug:1429: Arrays of strings are not being properly.
+	+ Fixed bug:1447/1448: Readme file's website and added ParseTree dependency.
+
+*** 1.0.0-beta-1 / 2005-02-01
+
++ 1 major enhancements
+	+ Hit 80% non-error conversion threshold for public beta release.
++ 3 minor enhancements
+	+ (Mostly) Filled out functionality in Rewriter and TypeChecker.
+	+ Flushed out what we don't do in RubyToC.
+	+ Wrote a ton of rdoc
+
+*** 1.0.0-a2 / 2004-12-31
+
++ 7 major enhancements
+	+ Alpha 2 released to private group for critique.
+	+ Refactored and split out ParseTree package.
+	+ Gemified dependency on ParseTree.
+	+ Added iter rewriting
+	+ Added post type inference rewriting specific to C library.
+	+ Massive increase to the base we can translate.
+	+ We have stabilized the architecture but still have a ways to go.
++ 2 minor enhancements
+	+ Added propaganda (presentations).
+	+ Much better test coverage, now with ZenTest compliant naming.
++ 2+ bug fixes
+	+ Gem-proofed makefile.
+	+ Tons of little fixes we didn't bother to track.
+
+*** 1.0.0-a1 / 2004-09-24
+
++ 1 major enhancement
+	+ Birthday! Alpha 1 released to private group for critique.

data/Makefile

@@ -0,0 +1,49 @@
+RUBY?=ruby
+RUBY_FLAGS?=-w -I.:../../ParseTree/dev/lib:../../ParseTree/dev/test:../../RubyInline/dev
+TEST?=
+
+all test:
+	$(RUBY) $(RUBY_FLAGS) test_all.rb $(TEST)
+
+docs:
+	rdoc -d -I png --main RubyToC -x test_\* -x something.rb
+
+VAL=./validate.sh
+FILE?=../../ZenTest/dev/TestOrderedHash.rb
+
+valx:
+	$(VAL)    $(FILE) > x
+
+val:
+	$(VAL) -q $(FILE) | head -20
+
+valno:
+	$(VAL)    $(FILE) | grep no:
+
+valstat:
+	BAD=$$(wc -l rb.bad.txt | perl -pe 's/\s*(\d+)\s+.*/$$1/'); GOOD=$$(wc -l rb.good.txt | perl -pe 's/\s*(\d+)\s+.*/$$1/'); echo "1 - $$BAD / ($$GOOD + $$BAD)" | bc -l
+
+valoccur:
+	egrep "ERROR|no:" rb.err.txt | perl -pe 's/ in .*//; s/(translating \S+):/$$1/; s/(is not an Array \w+):.*/$$1/; s/.* (is not a supported node type)/blah $$1/; s/(Unable to unify).*/$$1/; s/(Unknown literal) \S+/$$1/;' | occur 
+
+trouble: trouble.o
+	@exit 0
+
+trouble.o: trouble.c
+	gcc -I/usr/local/lib/ruby/1.8/powerpc-darwin/ -c trouble.c -o trouble.o
+
+trouble.c: zcomparable.rb translate.rb ruby_to_c.rb type_checker.rb
+	$(RUBY) $(RUBY_FLAGS) translate.rb zcomparable.rb > trouble.c
+
+FORCE:
+demos: FORCE
+	for rf in demo/*.rb; do f=$$(basename $$rf .rb); echo $$f; ./translate.rb demo/$$f > demo/$$f.c && gcc -Iinc -o demo/$$f demo/$$f.c; done
+
+interp: FORCE
+	for rf in demo/*.rb; do f=$$(basename $$rf .rb); echo $$f; ./interp.rb demo/$$f; done
+
+clean:
+	rm -f *~ trouble.* diff.txt demo/*~
+	rm -rf ~/.ruby_inline
+	for rf in demo/*.rb; do f=$$(basename $$rf .rb); rm -f demo/$$f.c demo/$$f; done
+

data/Manifest.txt

@@ -0,0 +1,98 @@
+History.txt
+Makefile
+Manifest.txt
+README.txt
+demo/char.rb
+demo/factorial.rb
+demo/hello.rb
+demo/misc.rb
+demo/newarray.rb
+demo/strcat.rb
+propaganda/Ruby2C.key/.typeAttributes.dict
+propaganda/Ruby2C.key/Contents/PkgInfo
+propaganda/Ruby2C.key/pasted.pdf
+propaganda/Ruby2C.key/pasted1.pdf
+propaganda/Ruby2C.key/pasted10.pdf
+propaganda/Ruby2C.key/pasted2.pdf
+propaganda/Ruby2C.key/pasted3.pdf
+propaganda/Ruby2C.key/pasted4.pdf
+propaganda/Ruby2C.key/pasted5.pdf
+propaganda/Ruby2C.key/pasted6.pdf
+propaganda/Ruby2C.key/pasted7.pdf
+propaganda/Ruby2C.key/pasted8.pdf
+propaganda/Ruby2C.key/pasted9.pdf
+propaganda/Ruby2C.key/presentation.apxl
+propaganda/Ruby2C.key/thumbs/.rjsf
+propaganda/Ruby2C.key/thumbs/mt0.tiff
+propaganda/Ruby2C.key/thumbs/mt1.tiff
+propaganda/Ruby2C.key/thumbs/mt10.tiff
+propaganda/Ruby2C.key/thumbs/mt11.tiff
+propaganda/Ruby2C.key/thumbs/mt12.tiff
+propaganda/Ruby2C.key/thumbs/mt13.tiff
+propaganda/Ruby2C.key/thumbs/mt14.tiff
+propaganda/Ruby2C.key/thumbs/mt15.tiff
+propaganda/Ruby2C.key/thumbs/mt2.tiff
+propaganda/Ruby2C.key/thumbs/mt3.tiff
+propaganda/Ruby2C.key/thumbs/mt4.tiff
+propaganda/Ruby2C.key/thumbs/mt5.tiff
+propaganda/Ruby2C.key/thumbs/mt6.tiff
+propaganda/Ruby2C.key/thumbs/mt7.tiff
+propaganda/Ruby2C.key/thumbs/mt8.tiff
+propaganda/Ruby2C.key/thumbs/mt9.tiff
+propaganda/Ruby2C.key/thumbs/st0.tiff
+propaganda/Ruby2C.key/thumbs/st1.tiff
+propaganda/Ruby2C.key/thumbs/st10.tiff
+propaganda/Ruby2C.key/thumbs/st11.tiff
+propaganda/Ruby2C.key/thumbs/st13.tiff
+propaganda/Ruby2C.key/thumbs/st131.tiff
+propaganda/Ruby2C.key/thumbs/st15.tiff
+propaganda/Ruby2C.key/thumbs/st16.tiff
+propaganda/Ruby2C.key/thumbs/st161.tiff
+propaganda/Ruby2C.key/thumbs/st17.tiff
+propaganda/Ruby2C.key/thumbs/st18.tiff
+propaganda/Ruby2C.key/thumbs/st19.tiff
+propaganda/Ruby2C.key/thumbs/st2.tiff
+propaganda/Ruby2C.key/thumbs/st20.tiff
+propaganda/Ruby2C.key/thumbs/st201.tiff
+propaganda/Ruby2C.key/thumbs/st21.tiff
+propaganda/Ruby2C.key/thumbs/st22.tiff
+propaganda/Ruby2C.key/thumbs/st23.tiff
+propaganda/Ruby2C.key/thumbs/st231.tiff
+propaganda/Ruby2C.key/thumbs/st24.tiff
+propaganda/Ruby2C.key/thumbs/st25.tiff
+propaganda/Ruby2C.key/thumbs/st3.tiff
+propaganda/Ruby2C.key/thumbs/st31.tiff
+propaganda/Ruby2C.key/thumbs/st4.tiff
+propaganda/Ruby2C.key/thumbs/st5.tiff
+propaganda/Ruby2C.key/thumbs/st7.tiff
+propaganda/Ruby2C.key/thumbs/st8.tiff
+propaganda/Ruby2C.key/thumbs/st9.tiff
+propaganda/Ruby2C.key/tile_paper_blue.jpg
+propaganda/Ruby2C.key/tile_paper_gray.jpg
+propaganda/Ruby2C.key/tile_paper_green.jpg
+propaganda/Ruby2C.key/tile_paper_purple.jpg
+propaganda/Ruby2C.key/tile_paper_red.jpg
+propaganda/Ruby2C.key/tile_paper_yellow.jpg
+propaganda/Ruby2C.key/tiny/.jrsf
+propaganda/Ruby2C.key/tiny/tile_paper_blue.jpg
+propaganda/Ruby2C.pdf
+propaganda/class diagram.graffle
+propaganda/processors.graffle
+propaganda/ruby2c architecture.graffle
+rewrite.rb
+rewriter.rb
+ruby_to_c.rb
+support.rb
+test_all.rb
+test_extras.rb
+test_rewriter.rb
+test_ruby_to_c.rb
+test_support.rb
+test_type_checker.rb
+test_typed_sexp_processor.rb
+translate.rb
+type.rb
+type_checker.rb
+typed_sexp_processor.rb
+validate.sh
+zcomparable.rb

data/README.txt

@@ -0,0 +1,75 @@
+ruby_to_c
+    http://rubyforge.org/projects/ruby2c/
+    ryand-ruby@zenspider.com
+    ruby2c@zenspider.com - mailing list
+
+DESCRIPTION:
+
+ruby_to_c translates a static ruby subset to C. Hopefully it works.
+
+NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE
+
+                   THIS IS BETA SOFTWARE!
+
+NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE ! NOTE
+
+RubyToC has the following modules:
+
+	Rewriter      - massages the sexp into a more consistent form.
+	TypeChecker   - type inferencer for the above sexps.
+	RubyToC       - converts a ruby (subset) sexp to C.
+
+and the following tools:
+
+	translate.rb  - Translates a given file to C.
+
+FEATURES/PROBLEMS:
+  
++ This is a preview release! BETA BETA BETA! Do NOT use this!
++ Please contact me or Eric (drbrain of segment7 dot net) if you:
+	+ have any feedback!
+	+ have any changes!
+	+ want to work on this!
+
+SYNOPSYS:
+
+  ./translate.rb blah.rb > blah.c; gcc -c -I /rubylib/1.8/platform blah.c
+
+TODO:
+
++ Numerous, but we are trying to get them in here... sorry...
++ Want to move to a gem directory structure (lib/ test/ bin/ etc)
+
+REQUIREMENTS:
+
++ ParseTree - http://rubyforge.org/projects/parsetree/
++ RubyInline - http://rubyforge.org/projects/rubyinline/
+
+INSTALL:
+
++ Um. Please don't install this crap yet...
+
+LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2001-2002 Ryan Davis, Zen Spider Software
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/demo/char.rb

@@ -0,0 +1,13 @@
+
+class CharDemo
+  def chardemo
+    s = "hello"
+    c = s[2]
+    return c
+  end
+
+  def main
+    chardemo
+    return 0
+  end
+end

data/demo/factorial.rb

@@ -0,0 +1,11 @@
+class F
+  def factorial(n)
+    f = 1
+    n.downto(2) { |x| f *= x }
+    return f
+  end
+
+  def main # horrid but funny hack
+    return factorial(5)
+  end
+end

data/demo/hello.rb

@@ -0,0 +1,11 @@
+
+class Hello
+  def hello
+    puts "hello world"
+  end
+
+  def main # silly hack
+    hello
+    return 0
+  end
+end

data/demo/misc.rb

@@ -0,0 +1,25 @@
+
+class Misc
+  def assert(cond, n)
+    if (!cond) then
+      puts("-- SymTab fatal error ")
+      case (n)
+      when 3 
+        puts("-- too many nodes in graph")
+      when 4
+        puts("-- too many sets")
+      when 6
+        puts("-- too many symbols")
+      when 7
+        puts("-- too many character classes")
+      end
+      # puts("Stack Trace = #{caller.join "\n"}")
+      exit(n)
+    end
+  end
+
+  def main
+    assert(1 == 1, 3)
+    return 0
+  end
+end

data/demo/newarray.rb

@@ -0,0 +1,11 @@
+
+class NewArray
+  def newarray
+    a = [1, 2, 3]
+    return a[0]
+  end
+
+  def main
+    return newarray
+  end
+end

data/demo/strcat.rb

@@ -0,0 +1,12 @@
+class Blah
+  def blah
+    a = "this"
+    b = a + "that"
+    puts(b)
+  end
+
+  def main
+    blah
+    return 0
+  end
+end

data/rewrite.rb

@@ -0,0 +1,32 @@
+#!/usr/local/bin/ruby -w
+
+require 'pp'
+require 'rewriter'
+
+old_classes = []
+ObjectSpace.each_object(Class) do |klass|
+  old_classes << klass
+end
+
+ARGV.each do |name|
+  require name
+end
+
+new_classes = []
+ObjectSpace.each_object(Class) do |klass|
+  new_classes << klass
+end
+
+new_classes -= old_classes
+
+parser = ParseTree.new
+rewriter = Rewriter.new
+
+new_classes.each do |klass|
+  sexp = parser.parse_tree klass
+  sexp.each do |exp|
+    exp = rewriter.process(exp)
+    pp exp
+  end
+end
+

data/rewriter.rb

@@ -0,0 +1,356 @@
+
+begin require 'rubygems' rescue LoadError end
+require 'parse_tree'
+require 'typed_sexp_processor'
+
+class Sexp
+  # add arglist because we introduce the new array type in this file
+  @@array_types << :arglist
+end
+
+##
+# Rewriter (probably should be renamed) is a first-pass filter that
+# normalizes some of ruby's ASTs to make them more processable later
+# in the pipeline. It only has processors for what it is interested
+# in, so real the individual methods for a better understanding of
+# what it does.
+
+class Rewriter < SexpProcessor
+
+  def initialize # :nodoc:
+    super
+    self.auto_shift_type = true
+    self.unsupported = [ :cfunc, ]
+    # self.debug[:defn] = /method/ # coolest debugging feature ever
+  end
+
+  ##
+  # Rewrites :attrasgn nodes to the unified :call format:
+  #
+  # [:attrasgn, lhs, :name=, args],
+  #
+  # becomes:
+  #
+  # [:call, lhs, :name=, args]
+
+  def process_attrasgn(exp)
+    lhs = process exp.shift
+    name = exp.shift
+    args = process exp.shift
+    args[0] = :arglist unless args.nil?
+
+    s(:call, lhs, name, args)
+  end
+
+  ##
+  # Rewrites :call nodes to the unified :call format:
+  # [:call, lhs, :name, args]
+
+  def process_call(exp)
+    lhs = process exp.shift
+    name = exp.shift
+    args = process exp.shift
+    args[0] = :arglist unless args.nil?
+
+    s(:call, lhs, name, args)
+  end
+
+  ##
+  # Rewrites :case/:when nodes as nested :if nodes.
+
+  def process_case(exp)
+    result = s()
+    var = process exp.shift
+    else_stmt = process exp.pop
+
+    new_exp = result
+    
+    until exp.empty? do
+      c = exp.shift
+      # start a new scope and move to it
+      new_exp << s(:if)
+      new_exp = new_exp.last
+
+      assert_type c, :when
+      ignored_type, vars, stmts = process(c)
+
+      vars = vars.map { |v| s(:call,
+                              var.deep_clone,
+                              :===,
+                              s(:arglist, process(v)))}
+      if vars.size > 1 then
+
+        # building from the bottom up, so everything is bizarro-sexp
+        # BIZARRO-SEXP NO LIKE OR!
+        or_sexp = vars.inject(s(:or, *vars.slice!(-2,2))) do |lhs, rhs|
+          s(:or, rhs, lhs)
+        end
+
+        new_exp << or_sexp
+      else
+        new_exp << vars.first
+      end
+      new_exp << stmts
+    end
+    new_exp << else_stmt
+
+    result.first
+  end
+
+  ##
+  # Rewrites :defn nodes to pull the functions arguments to the top:
+  #
+  # Input:
+  #
+  #   [:defn, name, [:scope, [:block, [:args, ...]]]]
+  #   [:defn, name, [:fbody, [:scope, [:block, [:args, ...]]]]]
+  #   [:defn, name, [:ivar, name]]
+  #   [:defn, name, [:attrset, name]]
+  #
+  # Output:
+  #
+  #   [:defn, name, args, body]
+
+  def process_defn(exp)
+    name = exp.shift
+    args = s(:args)
+    body = process exp.shift
+
+    case body.first
+    when :scope, :fbody then
+      body = body[1] if body.first == :fbody
+      args = body.last[1]
+      assert_type args, :args
+      assert_type body, :scope
+      assert_type body[1], :block
+      body.last.delete_at 1
+    when :bmethod then
+      # BEFORE: [:defn, :bmethod_added, [:bmethod, [:dasgn_curr, :x], ...]]
+      # AFTER:  [:defn, :bmethod_added, [:args, :x], [:scope, [:block, ...]]]
+      body.shift # :bmethod
+      # [:dasgn_curr, :x],
+      # [:call, [:dvar, :x], :+, [:arglist, [:lit, 1]]]]]
+      dasgn = body.shift
+      assert_type dasgn, :dasgn_curr
+      dasgn.shift # type
+      args.push(*dasgn)
+      body.find_and_replace_all(:dvar, :lvar)
+      if body.first.first == :block then
+        body = s(:scope, body.shift)
+      else
+        body = s(:scope, s(:block, body.shift)) # single statement
+      end
+    when :dmethod
+      # BEFORE: [:defn, :dmethod_added, [:dmethod, :bmethod_maker, ...]]
+      # AFTER:  [:defn, :dmethod_added, ...]
+      body = body[2][1][2] # UGH! FIX
+      args = body[1]
+      body.delete_at 1
+      body = s(:scope, body)
+    when :ivar then
+      body = s(:scope, s(:block, s(:return, body)))
+    when :attrset then
+      argname = body.last
+      args << :arg
+      body = s(:scope, s(:block, s(:return, s(:iasgn, argname, s(:lvar, :arg)))))
+    else
+      raise "Unknown :defn format: #{name.inspect} #{args.inspect} #{body.inspect}"
+    end
+
+    return s(:defn, name, args, body)
+  end
+
+  ##
+  # Rewrites :fcall nodes to the unified :call format:
+  # [:call, lhs, :name, args]
+
+  def process_fcall(exp)
+    name = exp.shift
+    args = process exp.shift
+    args[0] = :arglist
+
+    return s(:call, nil, name, args)
+  end
+
+  ##
+  # I'm not really sure what this is for, other than to guarantee that
+  # there are 4 elements in the sexp.
+
+  def process_if(exp)
+    cond = process exp.shift
+    t = process(exp.shift) || nil # FIX: nil is bad, we need to switch to dummy
+    f = process(exp.shift) || nil
+    return s(:if, cond, t, f)
+  end
+
+  ##
+  # Rewrites specific :iter nodes into while loops:
+  # [DOC]
+
+  def process_iter(exp)
+    call = process exp.shift
+    var  = process exp.shift
+    body = process exp.shift
+
+    if var.nil? then
+      var = s(:lvar, :temp_var1) # HACK Use Unique
+    end
+
+    assert_type call, :call
+
+    if call[2] != :each then # TODO: fix call[n] (api)
+      call.shift # :call
+      lhs = call.shift
+      method_name = call.shift
+
+      case method_name
+      when :downto then
+        var.shift # 
+        start_value = lhs
+        finish_value = call.pop.pop # not sure about this
+        var_name = var.shift
+        body.find_and_replace_all(:dvar, :lvar)
+        result = s(:dummy,
+                   s(:lasgn, var_name, start_value),
+                   s(:while,
+                     s(:call, s(:lvar, var_name), :>=,
+                       s(:arglist, finish_value)),
+                     s(:block,
+                       body,
+                       s(:lasgn, var_name,
+                         s(:call, s(:lvar, var_name), :-,
+                           s(:arglist, s(:lit, 1))))), true))
+      when :upto then
+        # REFACTOR: completely duped from above and direction changed
+        var.shift # 
+        start_value = lhs
+        finish_value = call.pop.pop # not sure about this
+        var_name = var.shift
+        body.find_and_replace_all(:dvar, :lvar)
+        result = s(:dummy,
+                   s(:lasgn, var_name, start_value),
+                   s(:while,
+                     s(:call, s(:lvar, var_name), :<=,
+                       s(:arglist, finish_value)),
+                     s(:block,
+                       body,
+                       s(:lasgn, var_name,
+                         s(:call, s(:lvar, var_name), :+,
+                           s(:arglist, s(:lit, 1))))), true))
+      when :define_method then
+        # BEFORE: [:iter, [:call, nil, :define_method, [:array, [:lit, :bmethod_added]]], [:dasgn_curr, :x], [:call, [:dvar, :x], :+, [:array, [:lit, 1]]]]
+        # we want to get it rewritten for the scope/block context, so:
+        #   - throw call away
+        #   - rewrite to args
+        #   - plop body into a scope
+        # AFTER:  [:block, [:args, :x], [:call, [:lvar, :x], :+, [:arglist, [:lit, 1]]]]
+        var.find_and_replace_all(:dasgn_curr, :args)
+        body.find_and_replace_all(:dvar, :lvar)
+        result = s(:block, var, body)
+      else
+        raise "unknown iter method #{method_name}"
+      end
+    else
+      s(:iter, call, var, body)
+    end
+  end
+
+  ##
+  # Rewrites self into lvars
+
+  def process_self(exp)
+    s(:lvar, :self)
+  end
+
+  ##
+  # Rewrites until nodes into while nodes.
+
+  def process_until(exp)
+    cond = process s(:not, exp.shift)
+    body = process exp.shift
+    raise "boo" if exp.empty?
+    is_precondition = exp.shift
+    s(:while, cond, body, is_precondition)
+  end
+
+  ##
+  # Rewrites :vcall nodes to the unified :call format:
+  # [:call, lhs, :name, args]
+
+  def process_vcall(exp)
+    name = exp.shift
+
+    s(:call, nil, name, nil) # TODO: never has any args?
+  end
+
+  ##
+  # Rewrites :when nodes so :case can digest it into if/else structure
+  # [:when, [args], body]
+
+  def process_when(exp)
+    vars = exp.shift
+    assert_type vars, :array
+    vars.shift # nuke vars type
+    stmts = process(exp)
+    return s(:when, vars, stmts.first)
+  end
+
+  ##
+  # Rewrites :zarray nodes to :array with no args.
+
+  def process_zarray(exp)
+    return s(:array)
+  end
+
+end
+
+##
+# R2CRewriter (should probably move this out to its own file) does
+# rewritings that are language specific to C.
+
+class R2CRewriter < SexpProcessor
+
+  ##
+  # REWRITES maps a function signature to a proc responsible for
+  # generating the appropriate sexp for that rewriting.
+
+  REWRITES = {
+    [Type.str, :+, Type.str] => proc { |l,n,r|
+      t(:call, nil, :strcat, r.unshift(r.shift, l), Type.str)
+    },
+    [Type.file, :puts, Type.str] => proc { |l,n,r|
+      t(:call, nil, :fputs, r.push(l))
+    },
+  }
+
+  def initialize # :nodoc:
+    super
+    self.auto_shift_type = true
+    self.expected = TypedSexp
+  end
+
+  ##
+  # Rewrites function calls by looking them up in the REWRITES map. If
+  # a match exists, it invokes the block passing in the lhs, rhs, and
+  # function name. If one does not exist, it simply repacks the sexp
+  # and sends it along.
+
+  def process_call(exp)
+    lhs = process exp.shift
+    name = exp.shift
+    rhs = process exp.shift
+
+    lhs_type = lhs.sexp_type rescue nil
+    type_signature = [lhs_type, name]
+    type_signature += rhs[1..-1].map { |sexp| sexp.sexp_type } unless rhs.nil?
+
+    result = if REWRITES.has_key? type_signature then
+               REWRITES[type_signature].call(lhs, name, rhs)
+             else
+               t(:call, lhs, name, rhs, exp.sexp_type)
+             end
+
+    return result
+  end
+end
+