RubyToC 1.0.0.4 → 1.0.0.5

data/History.txt

@@ -1,3 +1,18 @@
+*** 1.0.0-beta-5 / 2006-05-12
+
++ 6 minor enhancements:
+	+ Split RubyToC to RubyToRubyC and RubyToAnsiC.
+	+ Extended Environment to be more flexible for various situations.
+	+ Removed propaganda (bloat) from release.
+	+ Gemified and reorganized things. Support still needs splitting up.
+	+ Flipped a lot of internal naming to use Unique.
+	+ Added ruby_to_c_show (like parse_tree_show).
++ 4(ish) bug fixes:
+	+ Use ivars instead of cvars so inheritance won't bugger the translator.
+	+ Corrected unsupported node lists in pipeline.
+	+ Fixed bugs for splat args, iters, optional args, method name map.
+	+ Fixed many other bugs.
+
 *** 1.0.0-beta-4 / 2005-07-13
 
 + 1 minor enhancements

data/Makefile

@@ -1,9 +1,9 @@
 RUBY?=ruby
 RUBY_FLAGS?=-w -I.:../../ParseTree/dev/lib:../../ParseTree/dev/test:../../RubyInline/dev
-TEST?=
+FILTER?=
 
 all test:
-	$(RUBY) $(RUBY_FLAGS) test_all.rb $(TEST)
+	$(RUBY) $(RUBY_FLAGS) test_all.rb $(FILTER)
 
 docs:
 	rdoc -d -I png --main RubyToC -x test_\* -x something.rb
@@ -42,6 +42,11 @@ demos: FORCE
 interp: FORCE
 	for rf in demo/*.rb; do f=$$(basename $$rf .rb); echo $$f; ./interp.rb demo/$$f; done
 
+sort:
+	for f in *.rb; do grep "def " $f > x; sort x > y; echo $f; echo; diff x y; done
+	for f in test_*.rb; do grep "def.test_" $f > x; sort x > y; echo $f; echo; diff x y; done
+	rm x y
+
 clean:
 	rm -f *~ trouble.* diff.txt demo/*~
 	rm -rf ~/.ruby_inline

data/Manifest.txt

@@ -2,97 +2,27 @@ History.txt
 Makefile
 Manifest.txt
 README.txt
+Rakefile
+bin/ruby_to_c_show
+bin/ruby_to_c_validate
 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
+lib/rewriter.rb
+lib/ruby_to_ansi_c.rb
+lib/ruby_to_ruby_c.rb
+lib/support.rb
+lib/type_checker.rb
+lib/typed_sexp_processor.rb
+test/r2ctestcase.rb
+test/test_all.rb
+test/test_extras.rb
+test/test_rewriter.rb
+test/test_ruby_to_ansi_c.rb
+test/test_ruby_to_ruby_c.rb
+test/test_support.rb
+test/test_type_checker.rb
+test/test_typed_sexp_processor.rb

data/README.txt

@@ -17,7 +17,8 @@ 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.
+	RubyToRubyC   - converts a ruby (subset) sexp to ruby interals C.
+	RubyToAnsiC   - converts a ruby (subset) sexp to ANSI C.
 
 and the following tools:
 

data/Rakefile

@@ -0,0 +1,52 @@
+# -*- ruby -*-
+
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+require 'rubygems'
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs.push(*%w( test ../../ParseTree/dev/lib ../../ParseTree/dev/test ../../RubyInline/dev ))
+  t.pattern = 'test/test_*.rb'
+  t.verbose = true
+end
+
+R2C_VERSION = $1 if File.read('./lib/ruby_to_ansi_c.rb') =~ /VERSION = '([^']+)'/
+
+spec = Gem::Specification.new do |s|
+  s.name = 'RubyToC'
+  s.version = R2C_VERSION.sub(/-beta-/, '.')
+  s.summary = "Ruby (subset) to C translator."
+
+  paragraphs = File.read("README.txt").split(/\n\n+/)
+  s.description = paragraphs[2]
+  puts s.description
+
+  s.add_dependency('ParseTree')
+  s.files = IO.readlines("Manifest.txt").reject { |o| o =~ /propaganda/ }.map {|f| f.chomp }
+
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.test_suite_file = "test/test_all.rb"
+
+  s.author = "Ryan Davis"
+  s.email = "ryand-ruby@zenspider.com"
+  s.homepage = "http://rubyforge.org/projects/ruby2c/"
+  s.rubyforge_project = "ruby2c"
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+task :sort do
+  sh 'for f in lib/*.rb; do grep "^ *def " $f | grep -v "def self" > x; sort x > y; echo; echo $f; echo; diff x y; done; true'
+  sh 'for f in test/test_*.rb; do grep "def.test_" $f > x; sort x > y; echo; echo $f; echo; diff x y; done; true'
+  sh 'rm x y'
+end
+
+

data/bin/ruby_to_c_show

@@ -0,0 +1,97 @@
+#!/usr/local/bin/ruby -ws
+
+$: << "../../ParseTree/dev/lib"
+
+require 'pp'
+require 'parse_tree'
+require 'ruby_to_ansi_c'
+
+if defined? $h then
+  puts "Usage:"
+  puts "  #{File.basename $0} [options]"
+  puts "    -h display this help"
+  puts "    -r display rewriter output only"
+  puts "    -t display typecherker output only"
+  puts "    -R display r2c rewriter output only"
+  puts "    -f fast mode, read from stdin and build class/method around it"
+  puts "    -c <class> class to process"
+  puts "    -q quick mode, use regular inspect instead of pp"
+  puts "    -p print mode, just print instead of p or pp"
+  exit 0
+end
+
+def discover_new_classes_from
+  old_classes = []
+  ObjectSpace.each_object(Module) do |klass|
+    old_classes << klass
+  end
+
+  yield
+
+  new_classes = []
+  ObjectSpace.each_object(Module) do |klass|
+    new_classes << klass
+  end
+
+  new_classes -= old_classes
+  new_classes = [ eval($c) ] if defined? $c
+  new_classes
+end
+
+$f = false unless defined? $f
+
+new_classes = discover_new_classes_from do
+  ARGV.unshift "-" if ARGV.empty?
+  ARGV.each do |name|
+    if name == "-" then
+      code = $stdin.read
+      code = "class Example; def example; #{code}; end; end" if $f
+      eval code unless code.nil?
+    else
+      require name
+    end
+  end
+end
+
+parser = ParseTree.new(false)
+translator = RubyToAnsiC.translator
+
+$r ||= false
+$t ||= false
+$R ||= false
+
+if $r or $t or $R then
+  t = translator.processors
+  
+  t.pop # r2c
+  if $r then
+    t.pop # r2c rewriter
+    t.pop # typechecker
+  end
+  if $t then
+    t.pop # r2c rewriter
+  end
+  if $R then
+    # nothing else to do
+  end
+end
+
+new_classes.each do |klass|
+  sexp = parser.parse_tree klass
+  sexp.each do |exp|
+    result = translator.process(exp)
+
+    if defined? $q then
+      p result
+      next
+    end
+
+    if defined? $p then
+      puts result
+      next
+    end
+
+    pp result
+  end
+end
+

data/{rewriter.rb → lib/rewriter.rb}

@@ -157,6 +157,16 @@ class Rewriter < SexpProcessor
       raise "Unknown :defn format: #{name.inspect} #{args.inspect} #{body.inspect}"
     end
 
+    if Array === args.last and args.last.first == :block then
+      cond = args.pop
+      cond.shift # take off :block
+      new_code =  cond.map do |t, var, val|
+        s(:if, s(:call, s(:lvar, var), :nil?), s(:lasgn, var, val), nil)
+      end
+      body[1].insert 1, *new_code
+    end
+
+
     return s(:defn, name, args, body)
   end
 
@@ -167,7 +177,7 @@ class Rewriter < SexpProcessor
   def process_fcall(exp)
     name = exp.shift
     args = process exp.shift
-    args[0] = :arglist
+    args[0] = :arglist unless args.nil? # for :fcall with block (:iter)
 
     return s(:call, nil, name, args)
   end
@@ -192,9 +202,7 @@ class Rewriter < SexpProcessor
     var  = process exp.shift
     body = process exp.shift
 
-    if var.nil? then
-      var = s(:lvar, :temp_var1) # HACK Use Unique
-    end
+    var = s(:dasgn_curr, Unique.next) if var.nil?
 
     assert_type call, :call
 
@@ -248,9 +256,14 @@ class Rewriter < SexpProcessor
         body.find_and_replace_all(:dvar, :lvar)
         result = s(:block, var, body)
       else
-        raise "unknown iter method #{method_name}"
+        # HACK we butchered call up top
+        result = s(:iter, s(:call, lhs, method_name, call.shift), var, body)
       end
     else
+      if var.nil? then
+        var = s(:lvar, Unique.next)
+      end
+
       s(:iter, call, var, body)
     end
   end
@@ -354,3 +367,4 @@ class R2CRewriter < SexpProcessor
   end
 end
 
+

data/{ruby_to_c.rb → lib/ruby_to_ansi_c.rb}

@@ -10,15 +10,30 @@ require 'rewriter'
 require 'pp'
 
 ##
-# Maps a sexp type to a C counterpart.
+# The whole point of this project! RubyToC is an actually very simple
+# SexpProcessor that does the final conversion from Sexp to C code.
+# This class has more unsupported nodes than any other (on
+# purpose--we'd like TypeChecker and friends to be as generally useful
+# as possible), and as a result, supports a very small subset of ruby.
+#
+# NOT SUPPORTED: (keep in sync w/ initialize)
+# 
+# :begin, :block_arg, :case, :dstr, :rescue, :self, :super, :when
+
+class RubyToAnsiC < SexpProcessor
 
-module TypeMap
+  VERSION = '1.0.0-beta-5'
+
+  # TODO: remove me
+  def no(exp) # :nodoc:
+    raise "no: #{caller[0].split[1]} #{exp.inspect}"
+  end
 
   ##
   # Returns a textual version of a C type that corresponds to a sexp
   # type.
 
-  def c_type(typ)
+  def self.c_type(typ)
     base_type = 
       case typ.type.contents # HACK this is breaking demeter
       when :float then
@@ -30,13 +45,13 @@ module TypeMap
       when :symbol then
         "symbol"
       when :bool then # TODO: subject to change
-        "VALUE"
+        "bool"
       when :void then
         "void"
       when :homo then
         "void *" # HACK
       when :value, :unknown then
-        "VALUE"
+        "void *" # HACK
 # HACK: uncomment this and fix the above when you want to have good tests
 #      when :unknown then
 #        raise "You should not have unknown types by now!"
@@ -44,37 +59,11 @@ module TypeMap
         raise "Bug! Unknown type #{typ.inspect} in c_type"
       end
 
-    base_type += "_array" if typ.list?
+    base_type += " *" if typ.list? unless typ.unknown?
 
     base_type
   end
 
-  module_function :c_type # if $TESTING
-
-end
-
-##
-# The whole point of this project! RubyToC is an actually very simple
-# SexpProcessor that does the final conversion from Sexp to C code.
-# This class has more unsupported nodes than any other (on
-# purpose--we'd like TypeChecker and friends to be as generally useful
-# as possible), and as a result, supports a very small subset of ruby.
-#
-# NOT SUPPORTED: (keep in sync w/ initialize)
-# 
-# :begin, :block_arg, :case, :dstr, :rescue, :self, :super, :when
-
-class RubyToC < SexpProcessor
-
-  VERSION = '1.0.0-beta-4'
-
-  # TODO: remove me
-  def no(exp) # :nodoc:
-    raise "no: #{caller[0].split[1]} #{exp.inspect}"
-  end
-
-  include TypeMap
-
   ##
   # Provides access to the variable scope.
 
@@ -96,8 +85,6 @@ class RubyToC < SexpProcessor
 #include <ruby.h>
 #define RB_COMPARE(x, y) (x) == (y) ? 0 : (x) < (y) ? -1 : 1
 typedef char * str;
-typedef struct { unsigned long length; long * contents; } long_array;
-typedef struct { unsigned long length; str * contents; } str_array;
 #define case_equal_long(x, y) ((x) == (y))
 // END METARUBY PREAMBLE
 " + self.prototypes.join('')
@@ -107,13 +94,13 @@ typedef struct { unsigned long length; str * contents; } str_array;
   # Lazy initializer for the composite RubytoC translator chain.
 
   def self.translator
-    unless defined? @@translator then
-      @@translator = CompositeSexpProcessor.new
-      @@translator << Rewriter.new
-      @@translator << TypeChecker.new
-      @@translator << R2CRewriter.new
-      @@translator << RubyToC.new
-      @@translator.on_error_in(:defn) do |processor, exp, err|
+    unless defined? @translator then
+      @translator = CompositeSexpProcessor.new
+      @translator << Rewriter.new
+      @translator << TypeChecker.new
+      @translator << R2CRewriter.new
+      @translator << RubyToAnsiC.new
+      @translator.on_error_in(:defn) do |processor, exp, err|
         result = processor.expected.new
         case result
         when Array then
@@ -126,7 +113,7 @@ typedef struct { unsigned long length; str * contents; } str_array;
         result
       end
     end
-    @@translator
+    @translator
   end
 
   ##
@@ -174,7 +161,8 @@ typedef struct { unsigned long length; str * contents; } str_array;
     super
     @env = Environment.new
     self.auto_shift_type = true
-    self.unsupported = [ :begin, :block_arg, :case, :dstr, :rescue, :self, :super, :when, ]
+    self.unsupported = [:alias, :alloca, :argscat, :argspush, :attrasgn, :attrset, :back_ref, :begin, :block_arg, :block_pass, :bmethod, :break, :case, :cdecl, :cfunc, :colon2, :colon3, :cref, :cvasgn, :cvdecl, :dasgn, :defined, :defs, :dmethod, :dot2, :dot3, :dregx, :dregx_once, :dstr, :dsym, :dxstr, :ensure, :evstr, :fbody, :fcall, :flip2, :flip3, :for, :gasgn, :ifunc, :last, :masgn, :match, :match2, :match3, :memo, :method, :module, :newline, :next, :nth_ref, :op_asgn1, :op_asgn2, :op_asgn_and, :opt_n, :postexe, :redo, :resbody, :rescue, :retry, :sclass, :self, :splat, :super, :svalue, :to_ary, :undef, :until, :valias, :vcall, :when, :xstr, :yield, :zarray, :zsuper]
+
     self.strict = true
     self.expected = String
 
@@ -191,6 +179,13 @@ typedef struct { unsigned long length; str * contents; } str_array;
     return "#{lhs} && #{rhs}"
   end
 
+  ##
+  # Arglist is used by call arg lists.
+
+  def process_arglist(exp)
+    return process_array(exp)
+  end
+
   ##
   # Argument List including variable types.
 
@@ -208,19 +203,12 @@ typedef struct { unsigned long length; str * contents; } str_array;
 #       p TypeMap.methods.sort
 #       p c_type(arg.sexp_type)
 
-      args << "#{c_type(arg.sexp_type)} #{arg.first}"
+      args << "#{self.class.c_type(arg.sexp_type)} #{arg.first}"
     end
 
     return "(#{args.join ', '})"
   end
 
-  ##
-  # Arglist is used by call arg lists.
-
-  def process_arglist(exp)
-		return process_array(exp)
-  end
-
   ##
   # Array is used as call arg lists and as initializers for variables.
 
@@ -232,7 +220,7 @@ typedef struct { unsigned long length; str * contents; } str_array;
     end
 
     s = code.join ', '
-    s = "[]" if s.empty?
+    s = "rb_ary_new()" if s.empty? # HACK
 
     return s
   end
@@ -284,17 +272,13 @@ typedef struct { unsigned long length; str * contents; } str_array;
       args = process exp.shift
       return "#{receiver} == #{args}" # equal? == address equality
     when :[]
-      if receiver_type.list? then
-        args = process exp.shift
-        return "#{receiver}.contents[#{args}]"
-      else
-        # FIX: not sure about this one... hope for the best.
-        args = process exp.shift
-        return "#{receiver}[#{args}]"
-      end
+      args = process exp.shift
+      return "#{receiver}[#{args}]"
+    when :nil?
+      exp.clear
+      return receiver.to_s
     else
       args = process exp.shift
-      name = "NIL_P" if name == :nil?
 
       if receiver.nil? and args.nil? then
         args = ""
@@ -364,14 +348,21 @@ typedef struct { unsigned long length; str * contents; } str_array;
   ##
   # Function definition
 
-  def process_defn(exp)
+  METHOD_MAP = { 
+    :| => "or",
+    :& => "and",
+    :^ => "xor",
+  }
 
+  def process_defn(exp)
     name = exp.shift
+    name = METHOD_MAP[name] if METHOD_MAP.has_key? name
+    name = name.to_s.sub(/(.*)\?$/, 'is_\1').intern
     args = process exp.shift
     body = process exp.shift
     function_type = exp.sexp_type
 
-    ret_type = c_type function_type.list_type.return_type
+    ret_type = self.class.c_type function_type.list_type.return_type
 
     @prototypes << "#{ret_type} #{name}#{args};\n"
     "#{ret_type}\n#{name}#{args} #{body}"
@@ -405,10 +396,10 @@ typedef struct { unsigned long length; str * contents; } str_array;
   end
 
   ##
-  # False. Pretty straightforward. Currently we output ruby Qfalse
+  # False. Pretty straightforward.
 
   def process_false(exp)
-         return "Qfalse"
+         return "0"
   end
 
   ##
@@ -489,8 +480,10 @@ typedef struct { unsigned long length; str * contents; } str_array;
 
   def process_iter(exp)
     out = []
+    # Only support enums in C-land
+    raise UnsupportedNodeError if exp[0][1].nil? # HACK ugly
     @env.scope do
-      enum = exp[0][1][1] # HACK ugly
+      enum = exp[0][1][1] # HACK ugly t(:iter, t(:call, lhs <-- get lhs
       call = process exp.shift
       var  = process(exp.shift).intern # semi-HACK-y
       body = process exp.shift
@@ -500,8 +493,8 @@ typedef struct { unsigned long length; str * contents; } str_array;
       body.gsub!(/\n\n+/, "\n")
 
       out << "unsigned long #{index};"
-      out << "for (#{index} = 0; #{index} < #{enum}.length; ++#{index}) {"
-      out << "#{c_type @env.lookup(var)} #{var} = #{enum}.contents[#{index}];"
+      out << "for (#{index} = 0; #{enum}[#{index}] != NULL; ++#{index}) {"
+      out << "#{self.class.c_type @env.lookup(var)} #{var} = #{enum}[#{index}];"
       out << body
       out << "}"
     end
@@ -534,7 +527,7 @@ typedef struct { unsigned long length; str * contents; } str_array;
 
     exp_type = exp.sexp_type
     @env.add var.to_sym, exp_type
-    var_type = c_type exp_type
+    var_type = self.class.c_type exp_type
 
     if exp_type.list? then
       assert_type args, :array
@@ -543,13 +536,12 @@ typedef struct { unsigned long length; str * contents; } str_array;
 
       # HACK: until we figure out properly what to do w/ zarray
       # before we know what its type is, we will default to long.
-      array_type = args.sexp_types.empty? ? 'long' : c_type(args.sexp_types.first)
+      array_type = args.sexp_types.empty? ? 'void *' : self.class.c_type(args.sexp_types.first)
 
-      args.shift
-      out << "#{var}.length = #{arg_count};\n"
-      out << "#{var}.contents = (#{array_type}*) malloc(sizeof(#{array_type}) * #{var}.length);\n"
+      args.shift # :arglist
+      out << "#{var} = (#{array_type}) malloc(sizeof(#{array_type}) * #{args.length});\n"
       args.each_with_index do |o,i|
-        out << "#{var}.contents[#{i}] = #{process o};\n"
+        out << "#{var}[#{i}] = #{process o};\n"
       end
     else
       out << "#{var} = #{process args}"
@@ -574,7 +566,7 @@ typedef struct { unsigned long length; str * contents; } str_array;
     when Type.long, Type.float then
       return value.to_s
     when Type.symbol then
-      return ":" + value.to_s
+      return value.to_s.inspect
     else
       raise "Bug! no: Unknown literal #{value}:#{value.class}"
     end
@@ -594,7 +586,7 @@ typedef struct { unsigned long length; str * contents; } str_array;
   # Nil, currently ruby nil, not C NULL (0).
 
   def process_nil(exp)
-    return "Qnil"
+    return "NULL"
   end
 
   ##
@@ -642,7 +634,7 @@ typedef struct { unsigned long length; str * contents; } str_array;
     @env.scope do
       body = process exp.shift unless exp.empty?
       @env.current.sort_by { |v,t| v.to_s }.each do |var, var_type|
-        var_type = c_type var_type
+        var_type = self.class.c_type var_type
         declarations << "#{var_type} #{var};\n"
       end
     end
@@ -658,10 +650,10 @@ typedef struct { unsigned long length; str * contents; } str_array;
   end
 
   ##
-  # Truth... what is truth? In this case, Qtrue.
+  # Truth... what is truth?
 
   def process_true(exp)
-    return "Qtrue"
+    return "1"
   end
 
   ##
@@ -676,5 +668,4 @@ typedef struct { unsigned long length; str * contents; } str_array;
     code = "{\n#{body.strip}\n} while (#{cond})" unless is_precondition
     return code
   end
-
 end