ruby2c 1.0.0.6

data.tar.gz.sig

@@ -0,0 +1 @@
+��D�H�_CVy��!��&���BD�^?R"��^��T��6�W��LY����>�dR�^c����|�#�`���{���S����Q
�ɏ�~���a���i���W��(�q%[�n��J�i�@��>��v|%/>c����5a����w!A�x�zn���̦#��Ԯ3�!M�������oL�G �D�/MPԞ�r���n�0�.:��S���])>���,@Y`�U�:~�t���Ð��f#���@��љ*��

data/.autotest

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  l = %w(ruby_parser RubyInline sexp_processor minitest)
+  t = %w(ParseTree sexp_processor)
+
+  at.libs << ':' << l.map { |d| "../../#{d}/dev/lib"  }.join(":")
+  at.libs << ':' << t.map { |d| "../../#{d}/dev/test" }.join(":")
+
+  at.extra_files << "../../ParseTree/dev/test/pt_testcase.rb"
+
+  at.add_mapping(/(pt_|r2c)testcase/) do |f, _|
+    at.files_matching(/\/test_.*rb$/)
+  end
+
+  at.extra_class_map["TestCRewriter"] = "test/test_crewriter.rb"
+
+  at.testlib = "minitest/autorun"
+end

data/History.txt

@@ -0,0 +1,173 @@
+=== 1.0.0.6 / 2009-06-23
+
+1 major enhancement:
+
+  * Switched from ParseTree to ruby_parser for 1.9 compatibility. woo.
+    * All translate/process methods are gone since we can't reflect at runtime.
+
+43 minor enhancements:
+
+  * Added IterRewriter for finding free variables in iter nodes.
+  * Added dxstr.
+  * Added lots of new and missing tests
+  * Added not, array, lit_long_negative, lit_range[23], lit_regexp{_n,_once}, lit_sym{,_splat}
+  * Added pct_w tests
+  * Added process_defx to ruby_to_ansi_c.rb
+  * Added test data for array_pct_W, array_pct_W_dstr, attrasgn_index_equals, attrasgn_index_equals_space, and attrset.
+  * Added tests for "and". PONG to eric
+  * Added to_ary and masgn for TypeChecker.
+  * Added xstr support.
+  * Added yield(*ary)
+  * Cleaned up rewriter.rb and made changes for pt_testcase.rb
+  * Cleaned up some free_vars processing code.
+  * Converted everything to new enhanced PTTC test scheme.
+  * Enhanced with_scope to allow for static arrays.
+  * Extended Environment to separately store both types and values.
+  * Extern methods to support rb_iterate, including #each and #each_with_index.
+  * Free var static declarations for C layers.
+  * Merged IterRewriter into CRewriter and make typed.
+  * Migrated as much out of rewriter as possible.
+  * Modernized via hoe.
+  * Moved to full PTTC + UnifiedRuby.
+  * Pulled dstr up from ZenObfuscator.
+  * Pulled up tests, process_args, with_scope, and process_scope from obfuscator
+  * Pushed unique.rb up to PT
+  * Removed Environment methods that pushed up to ruby_parser.
+  * Removed Sexp#sexp_type
+  * Removed accessor, accessor_equals since they don't exist in PTTC.
+  * Removed bin/*
+  * Removed dead test
+  * Removed redundant defn_lvar_boundary, but added call to lvar_def_boundary.
+  * Renamed blocks to extra_methods in ruby_to_ruby_c.
+  * Renamed environment.rb to r2cenvironment.rb (incl tests)
+  * Renamed iter_functions to extra_methods in crewriter.
+  * Reordered so RubyToRubyC was always after RubyToAnsiC.
+  * Some optimizations cleaning up Type#method_missing. Drops test time ~30%.
+  * Split rewriter.rb to crewriter.rb (and renamed class to CRewriter).
+  * Split up and deleted support.rb (and tests).
+  * Switched from makefile to rakefile.
+  * Switched to minitest
+  * Test or node.
+  * Track and trigger changes on pt_testcase.rb and r2ctestcase.rb
+  * Used Hoe#add_include_dirs to clean up rakefile.
+
+* 12 bug fixes:
+
+  * Fix types in iter rewriting.
+  * Fix yield([42, 24])
+  * Fixed 1.9-isms.
+  * Fixed all rubygems loaders.
+  * Fixed dependencies on all tests.
+  * Fixed for new (incompatible?) Environment supplied by SexpProcessor
+  * Fixed incompatibility with new inline changes.
+  * Fixed requires on ruby_parser
+  * Fixed ruby2c to work with autotest.
+  * Fixed tests in r2ctestcase for all layers except the C layers.
+  * Fixed zentest dependency in rakefile
+  * Fixes for RAD, mostly renaming environment.rb to r2cenvironment.rb at this stage.
+
+=== 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:
+
+    * 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/Manifest.txt

@@ -0,0 +1,35 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+demo/char.rb
+demo/factorial.rb
+demo/hello.rb
+demo/misc.rb
+demo/newarray.rb
+demo/strcat.rb
+lib/crewriter.rb
+lib/function_table.rb
+lib/function_type.rb
+lib/handle.rb
+lib/r2cenvironment.rb
+lib/rewriter.rb
+lib/ruby_to_ansi_c.rb
+lib/ruby_to_ruby_c.rb
+lib/type.rb
+lib/type_checker.rb
+lib/typed_sexp.rb
+test/r2ctestcase.rb
+test/test_crewriter.rb
+test/test_extras.rb
+test/test_function_table.rb
+test/test_function_type.rb
+test/test_handle.rb
+test/test_r2cenvironment.rb
+test/test_rewriter.rb
+test/test_ruby_to_ansi_c.rb
+test/test_ruby_to_ruby_c.rb
+test/test_type.rb
+test/test_type_checker.rb
+test/test_typed_sexp.rb

data/README.txt

@@ -0,0 +1,76 @@
+= RubyToC
+
+* 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.
+* RubyToRubyC   - converts a ruby (subset) sexp to ruby interals C.
+* RubyToAnsiC   - converts a ruby (subset) sexp to ANSI 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:
+
+* ruby_parser - http://rubyforge.org/projects/parsetree/
+
+== INSTALL:
+
+* sudo gem install RubyToC
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2001-2008 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/Rakefile

@@ -0,0 +1,21 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.add_include_dirs("../../ParseTree/dev/test",
+                     "../../ruby_parser/dev/lib",
+                     "../../sexp_processor/dev/lib",
+                     "../../sexp_processor/dev/test",
+                     "lib")
+
+Hoe.plugin :seattlerb
+
+Hoe.spec "ruby2c" do
+  developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
+  developer 'Eric Hodel', 'drbrain@segment7.net'
+
+  extra_deps  << "ruby_parser"
+end
+
+# vim: syntax=ruby

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/lib/crewriter.rb

@@ -0,0 +1,199 @@
+# -*- ruby -*-
+
+begin require 'rubygems'; rescue LoadError; end
+require 'type'
+require 'sexp_processor'
+require 'r2cenvironment'
+
+##
+# CRewriter (should probably move this out to its own file) does
+# rewritings that are language specific to C.
+
+class CRewriter < 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))
+    },
+  }
+
+  attr_reader :env
+  attr_reader :extra_methods
+
+  def initialize # :nodoc:
+    super
+    self.auto_shift_type = true
+    self.expected = TypedSexp
+    @env = ::R2CEnvironment.new
+    @extra_methods = []
+  end
+
+  def free # REFACTOR: this is a violation of responsibility, should be in Env
+    parent = @env.env[0..-2]
+    bound_in_parent = parent.map { |h| h.keys }.flatten
+
+    env = @env.all
+
+    free = env.select { |k, (t, v)| bound_in_parent.include? k or not v }
+    vars = free.map { |k, (t, v)| [k, t] }
+    return vars
+  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
+
+  def process_class(exp)
+    klassname = exp.shift
+    superklassname = exp.shift
+
+    methods = []
+
+    until exp.empty? do
+      methods << process(exp.shift)
+    end
+
+    @extra_methods.reverse_each do |defx| methods.unshift defx end
+    @extra_methods.clear
+
+    result = t(:class, klassname, superklassname, Type.zclass)
+    result.push(*methods)
+
+    return result
+  end
+
+  ##
+  # TODO register statics
+
+  def process_iter(exp)
+    iter_method_name = Unique.next
+
+    value_var_name = Unique.next
+    value_var_type = Type.unknown
+
+    memo_var_name = Unique.next
+
+    call = process exp.shift
+    vars = process exp.shift
+    body = nil
+
+    free_vars = @env.scope do
+      body = process exp.shift
+      self.free.map { |name, type| [name, :"static_#{Unique.next}", type] }
+    end
+
+    var_names = var_names_in vars
+
+    frees = t(:array, Type.void)
+    statics = t(:array, Type.void)
+    defx_body_block = t(:block)
+
+    # set statics first so block vars can update statics
+    free_vars.each do |name, static_name, type| # free vars go on both sides
+      frees << t(:lvar, name, type)
+      statics << t(:lvar, static_name, type)
+      defx_body_block << t(:lasgn, name,
+                           t(:lvar, static_name, type),
+                           type)
+    end
+
+    if var_names.length == 1 then # expand block args to lasgn
+      value_var_type = var_names.first.last
+
+      defx_body_block << t(:lasgn, var_names.first.first,
+                           t(:lvar, value_var_name, var_names.first.last),
+                           var_names.first.last)
+
+    else # expand block args to masgn
+      value_var_type = Type.value
+      dyn_vars = t(:array)
+
+      var_names.each do |name, type|
+        dyn_vars << t(:lasgn, name, nil, type)
+      end
+
+      defx_body_block << t(:masgn,
+                           dyn_vars,
+                           t(:to_ary, t(:lvar, value_var_name, Type.value)))
+    end
+
+    defx_body_block << body
+
+    free_vars.each do |name, static_name, type|
+      defx_body_block << t(:lasgn, static_name, t(:lvar, name, type), type)
+      @extra_methods << t(:static, "static VALUE #{static_name};", Type.fucked)
+    end
+
+    defx_body_block << t(:return, t(:nil, Type.value))
+
+    defx = t(:defx,
+             iter_method_name,
+             t(:args,
+               t(value_var_name, value_var_type),
+               t(memo_var_name, Type.value)),
+             t(:scope, defx_body_block),
+             Type.void)
+
+    @extra_methods << defx
+
+    args = t(:args, frees, statics, Type.void)
+
+    return t(:iter, call, args, iter_method_name)
+  end
+
+  def process_lasgn(exp)
+    name = exp.shift
+    value = process(exp.shift)
+
+    @env.add name, exp.sexp_type
+    @env.set_val name, true
+
+    return t(:lasgn, name, value, exp.sexp_type)
+  end
+
+  def process_lvar(exp)
+    name = exp.shift
+
+    @env.add name, Type.value
+    @env.lookup name rescue @env.set_val name, false
+
+    return t(:lvar, name, exp.sexp_type)
+  end
+
+  def var_names_in(exp)
+    return [[exp.last, exp.sexp_type]] if exp.length == 2 and not Sexp === exp.last
+
+    var_names = []
+    exp.each_of_type :dasgn_curr do |sexp|
+      var_names << [sexp.sexp_body.first, sexp.sexp_type]
+    end
+    return var_names
+  end
+end