RubyToC 1.0.0.4

data/typed_sexp_processor.rb

@@ -0,0 +1,88 @@
+
+begin require 'rubygems' rescue LoadError end
+require 'sexp_processor'
+require 'support'
+
+$TESTING = false unless defined? $TESTING
+
+class TypedSexp < Sexp
+
+  def initialize(*args)
+    # TODO: should probably be Type.unknown
+    @sexp_type = Type === args.last ? args.pop : nil
+    super(*args)
+  end
+
+  def sexp_type
+    unless array_type? then
+      @sexp_type
+    else
+      types = self.sexp_types.flatten.uniq
+
+      if types.size > 1 then
+        Type.hetero
+      else
+        Type.homo
+      end
+    end
+  end
+
+  def _set_sexp_type(o)
+    @sexp_type = o
+  end
+
+  def sexp_type=(o)
+    raise "You shouldn't call this on an #{first}" if array_type?
+    raise "You shouldn't call this a second time, ever" unless
+      @sexp_type.nil? or @sexp_type == Type.unknown
+    _set_sexp_type(o)
+  end
+
+  def sexp_types
+    raise "You shouldn't call this if not an #{@@array_types.join(' or ')}, was #{first} (#{self.inspect})" unless array_type?
+    self.grep(Sexp).map { |x| x.sexp_type }
+  end
+
+  def ==(obj)
+    case obj
+    when TypedSexp
+      super && sexp_type == obj.sexp_type
+    else
+      false
+    end
+  end
+
+  def to_a
+    result = super
+    if defined?(@sexp_type) and not @sexp_type.nil? then
+      result += [ @sexp_type ]
+    end
+    result
+  end
+
+  def inspect
+    sexp_str = self.map {|x|x.inspect}.join(', ')
+    sexp_type_str = (sexp_str.empty? ? "" : ", ") + "#{array_type? ? sexp_types.inspect : sexp_type}" unless sexp_type.nil?
+    return "t(#{sexp_str}#{sexp_type_str})"
+  end
+
+  def pretty_print(q)
+    q.group(1, 't(', ')') do
+      q.seplist(self) {|v| q.pp v }
+      unless @sexp_type.nil? then
+        q.text ", " unless self.empty?
+        q.pp @sexp_type
+      end
+    end
+  end
+
+  def to_s
+    inspect
+  end
+
+end
+
+def t(*args) # stupid shortcut to make indentation much cleaner
+  TypedSexp.new(*args)
+end
+

data/validate.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+# set -xv
+
+trap "exit 1" 1 2 3 15
+
+DIRS="-I../../metaruby/dev/tests/builtin:../../metaruby/dev/tests:../../ParseTree/dev/test:../../ParseTree/dev/lib"
+for d in $(ls -d ../../*/dev | grep -v ruby_to_c); do
+    DIRS="-I$d $DIRS"
+done
+
+if [ -z "$1" ]; then
+    if [ -f rb.bad.txt ]; then
+	mv rb.bad.txt rb.files.txt
+    else
+	find ../../*/dev /usr/local/lib/ruby/1.8/ -name \*.rb | grep -v tk | xargs egrep -l "^(class|module)" > rb.files.txt
+    fi
+
+    total_count=$(wc -l rb.files.txt | awk '{print $1}')
+    curr_count=0
+    good_count=0
+    for f in $(cat rb.files.txt); do
+	curr_count=$(($curr_count + 1))
+	if ruby $DIRS ./translate.rb $f &> /tmp/r2c.$$ < /dev/null; then
+	    echo $f >> rb.good.txt
+	    status=pass
+	    good_count=$(($good_count + 1))
+	else
+	    echo $f >> rb.bad.txt	
+	    cat /tmp/r2c.$$ >> rb.err.txt
+	    status=fail
+	fi
+	fname=`basename $f`
+	pct=$(echo "$good_count / $curr_count * 100.0" | bc -l)
+	printf "%4d/%4d (%6.2f%%): %s %s\n" $curr_count $total_count $pct $status $fname
+    done
+else
+    if [ "$1" == "-q" ]; then
+	ruby $DIRS ./translate.rb "$2" 2>&1 | egrep "(ERROR|no:)" | 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 
+    else
+	ruby $DIRS ./translate.rb "$1"
+    fi
+fi

data/zcomparable.rb

@@ -0,0 +1,300 @@
+
+class ZComparable
+
+# int
+# rb_cmpint(val, a, b)
+#     VALUE val, a, b;
+# {
+#     if (NIL_P(val)) {
+# 	zrb_cmperr(a, b);
+#     }
+#     if (FIXNUM_P(val)) return FIX2INT(val);
+#     if (TYPE(val) == T_BIGNUM) {
+# 	if (RBIGNUM(val)->sign) return 1;
+# 	return -1;
+#     }
+#     if (RTEST(rb_funcall(val, '>', 1, INT2FIX(0)))) return 1;
+#     if (RTEST(rb_funcall(val, '<', 1, INT2FIX(0)))) return -1;
+#     return 0;
+# }
+
+def zrb_cmpint(val, a, b)
+  return val.to_i
+end
+
+# void
+# rb_cmperr(x, y)
+#     VALUE x, y;
+# {
+#     const char *classname;
+#
+#     if (SPECIAL_CONST_P(y)) {
+# 	y = rb_inspect(y);
+# 	classname = StringValuePtr(y);
+#     }
+#     else {
+# 	classname = rb_obj_classname(y);
+#     }
+#     rb_raise(rb_eArgError, "comparison of %s with %s failed",
+# 	     rb_obj_classname(x), classname);
+# }
+
+def zrb_cmperr(x, y)
+  $stderr.puts("comparison of " + x.class.to_s + " with " + y.class.to_s + " failed")
+  exit 1
+#  raise ArgumentError, "comparison of #{x.class} with #{y.class} failed"
+end
+
+# #define cmperr() (rb_cmperr(x, y), Qnil)
+
+# static VALUE
+# cmp_eq(a)
+#     VALUE *a;
+# {
+#     VALUE c = rb_funcall(a[0], cmp, 1, a[1]);
+
+#     if (NIL_P(c)) return Qnil;
+#     if (rb_cmpint(c, a[0], a[1]) == 0) return Qtrue;
+#     return Qfalse;
+# }
+
+def zcmp_eq(a, b)
+  c = a <=> b
+  return false if c.nil?
+  return c.to_i == 0
+end
+
+# static VALUE
+# cmp_failed()
+# {
+#     return Qnil;
+# }
+
+# TODO RETIRE me
+def zcmp_failed
+  return nil
+end
+
+# /*
+#  *  call-seq:
+#  *     obj == other    => true or false
+#  *  
+#  *  Compares two objects based on the receiver's <code><=></code>
+#  *  method, returning true if it returns 0. Also returns true if
+#  *  _obj_ and _other_ are the same object.
+#  */
+
+# static VALUE
+# cmp_equal(x, y)
+#     VALUE x, y;
+# {
+#     VALUE a[2];
+#
+#     if (x == y) return Qtrue;
+#
+#     a[0] = x; a[1] = y;
+#     return rb_rescue(cmp_eq, (VALUE)a, cmp_failed, 0);
+# }
+
+def zcmp_equal(x, y)
+
+  if x.equal? y then
+    return true
+  else
+    return zcmp_eq(x, y) # HACK rescue false
+  end
+
+end
+
+# /*
+#  *  call-seq:
+#  *     obj > other    => true or false
+#  *  
+#  *  Compares two objects based on the receiver's <code><=></code>
+#  *  method, returning true if it returns 1.
+#  */
+
+# static VALUE
+# cmp_gt(x, y)
+#     VALUE x, y;
+# {
+#     VALUE c = rb_funcall(x, cmp, 1, y);
+
+#     if (NIL_P(c)) return cmperr();
+#     if (rb_cmpint(c, x, y) > 0) return Qtrue;
+#     return Qfalse;
+# }
+
+def zcmp_gt(x, y)
+  c = x <=> y
+
+  zrb_cmperr(x, y) if c.nil?
+
+  return c.to_i > 0
+end
+
+# /*
+#  *  call-seq:
+#  *     obj >= other    => true or false
+#  *  
+#  *  Compares two objects based on the receiver's <code><=></code>
+#  *  method, returning true if it returns 0 or 1.
+#  */
+
+# static VALUE
+# cmp_ge(x, y)
+#     VALUE x, y;
+# {
+#     VALUE c = rb_funcall(x, cmp, 1, y);
+
+#     if (NIL_P(c)) return cmperr();
+#     if (rb_cmpint(c, x, y) >= 0) return Qtrue;
+#     return Qfalse;
+# }
+
+def zcmp_ge(x, y)
+  c = x <=> y
+
+  zrb_cmperr(x, y) if c.nil?
+
+  return c.to_i >= 0
+end
+
+# /*
+#  *  call-seq:
+#  *     obj < other    => true or false
+#  *  
+#  *  Compares two objects based on the receiver's <code><=></code>
+#  *  method, returning true if it returns -1.
+#  */
+
+# static VALUE
+# cmp_lt(x, y)
+#     VALUE x, y;
+# {
+#     VALUE c = rb_funcall(x, cmp, 1, y);
+#
+#     if (NIL_P(c)) return cmperr();
+#     if (rb_cmpint(c, x, y) < 0) return Qtrue;
+#     return Qfalse;
+# }
+
+def zcmp_lt(x, y)
+  c = x <=> y
+
+  zrb_cmperr(x, y) if c.nil?
+
+  return c.to_i < 0
+end
+
+# /*
+#  *  call-seq:
+#  *     obj <= other    => true or false
+#  *  
+#  *  Compares two objects based on the receiver's <code><=></code>
+#  *  method, returning true if it returns -1 or 0.
+#  */
+
+# static VALUE
+# cmp_le(x, y)
+#     VALUE x, y;
+# {
+#     VALUE c = rb_funcall(x, cmp, 1, y);
+
+#     if (NIL_P(c)) return cmperr();
+#     if (rb_cmpint(c, x, y) <= 0) return Qtrue;
+#     return Qfalse;
+# }
+
+def zcmp_le(x, y)
+  c = x <=> y
+
+  zrb_cmperr(x, y) if c.nil?
+
+  return c.to_i <= 0
+end
+
+# /*
+#  *  call-seq:
+#  *     obj.between?(min, max)    => true or false
+#  *  
+#  *  Returns <code>false</code> if <i>obj</i> <code><=></code>
+#  *  <i>min</i> is less than zero or if <i>anObject</i> <code><=></code>
+#  *  <i>max</i> is greater than zero, <code>true</code> otherwise.
+#  *     
+#  *     3.between?(1, 5)               #=> true
+#  *     6.between?(1, 5)               #=> false
+#  *     'cat'.between?('ant', 'dog')   #=> true
+#  *     'gnu'.between?('ant', 'dog')   #=> false
+#  *     
+#  */
+
+# static VALUE
+# cmp_between(x, min, max)
+#     VALUE x, min, max;
+# {
+#     if (RTEST(cmp_lt(x, min))) return Qfalse;
+#     if (RTEST(cmp_gt(x, max))) return Qfalse;
+#     return Qtrue;
+# }
+
+def zcmp_between(x, min, max)
+
+  return false if zcmp_lt(x, min)
+  return false if zcmp_gt(x, max)
+  return true
+
+end
+
+# /*
+#  *  The <code>Comparable</code> mixin is used by classes whose objects
+#  *  may be ordered. The class must define the <code><=></code> operator,
+#  *  which compares the receiver against another object, returning -1, 0,
+#  *  or +1 depending on whether the receiver is less than, equal to, or
+#  *  greater than the other object. <code>Comparable</code> uses
+#  *  <code><=></code> to implement the conventional comparison operators
+#  *  (<code><</code>, <code><=</code>, <code>==</code>, <code>>=</code>,
+#  *  and <code>></code>) and the method <code>between?</code>.
+#  *     
+#  *     class SizeMatters
+#  *       include Comparable
+#  *       attr :str
+#  *       def <=>(anOther)
+#  *         str.size <=> anOther.str.size
+#  *       end
+#  *       def initialize(str)
+#  *         @str = str
+#  *       end
+#  *       def inspect
+#  *         @str
+#  *       end
+#  *     end
+#  *     
+#  *     s1 = SizeMatters.new("Z")
+#  *     s2 = SizeMatters.new("YY")
+#  *     s3 = SizeMatters.new("XXX")
+#  *     s4 = SizeMatters.new("WWWW")
+#  *     s5 = SizeMatters.new("VVVVV")
+#  *     
+#  *     s1 < s2                       #=> true
+#  *     s4.between?(s1, s3)           #=> false
+#  *     s4.between?(s3, s5)           #=> true
+#  *     [ s3, s2, s5, s4, s1 ].sort   #=> [Z, YY, XXX, WWWW, VVVVV]
+#  *     
+#  */
+
+# void
+# Init_Comparable()
+# {
+#     rb_mComparable = rb_define_module("Comparable");
+#     rb_define_method(rb_mComparable, "==", cmp_equal, 1);
+#     rb_define_method(rb_mComparable, ">", cmp_gt, 1);
+#     rb_define_method(rb_mComparable, ">=", cmp_ge, 1);
+#     rb_define_method(rb_mComparable, "<", cmp_lt, 1);
+#     rb_define_method(rb_mComparable, "<=", cmp_le, 1);
+#     rb_define_method(rb_mComparable, "between?", cmp_between, 2);
+
+#     cmp = rb_intern("<=>");
+# }
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10.1
+specification_version: 1
+name: RubyToC
+version: !ruby/object:Gem::Version 
+  version: 1.0.0.4
+date: 2005-07-13
+summary: Ruby (subset) to C translator.
+require_paths: 
+  - "."
+email: ryand-ruby@zenspider.com
+homepage: http://rubyforge.org/projects/ruby2c/
+rubyforge_project: ruby2c
+description: ruby_to_c translates a static ruby subset to C. Hopefully it works.
+autorequire: ruby_to_c
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Ryan Davis
+files: 
+  - 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
+  - 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
+test_files: 
+  - test_all.rb
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: ParseTree
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">"
+          - !ruby/object:Gem::Version 
+            version: 0.0.0
+      version: