rubex 0.1.1 → 0.1.2

data/benchmarks/no_gil/no_gil.rb

@@ -0,0 +1,24 @@
+require 'no_gil.so'
+require 'benchmark'
+
+N = 9999999
+Benchmark.bm do |x|
+  x.report("with") do
+    n = Thread.new { work_with_gil(N) }
+    m = Thread.new { work_with_gil(N) }
+    o = Thread.new { work_with_gil(N) }
+    n.join; m.join; o.join
+  end
+
+  x.report("without") do
+    n = Thread.new { work_without_gil(N) }
+    m = Thread.new { work_without_gil(N) }
+    o = Thread.new { work_without_gil(N) }
+    n.join; m.join; o.join
+  end
+end
+
+# BENCHMARKS
+#        user     system      total        real
+# with  2.730000   0.000000   2.730000 (  2.731592)
+# without  2.990000   0.000000   2.990000 (  1.076090)

data/benchmarks/no_gil/no_gil.rubex

@@ -0,0 +1,22 @@
+cfunc void _work_without_gil(double n) no_gil
+  while n > 0 do
+    n ** 0.5 + 4
+    n -= 1
+  end
+end
+
+def work_without_gil(n)
+  double i = n
+  no_gil
+    _work_without_gil(i)
+  end
+
+  return i
+end
+
+def work_with_gil(double n)
+  while n > 0 do
+    n ** 0.5 + 4
+    n -= 1
+  end
+end

data/bin/rubex

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 require 'rubex'
 if Rubex::Cli.all_tasks.keys.include?(ARGV[0]) || ARGV.empty?
   Rubex::Cli.start

data/examples/c_struct_interface/c_struct_interface.rubex

@@ -45,3 +45,4 @@ class Music attach mp3info
     return data$.mp3info.id
   end
 end
+

data/lib/rubex.rb

@@ -5,6 +5,7 @@ require 'rubex/error'
 require 'rubex/ast'
 require 'rubex/helpers'
 require 'rubex/code_writer'
+require 'rubex/code_supervisor'
 require 'rubex/symbol_table'
 require 'rubex/parser.racc.rb'
 require 'rubex/compiler_config'

data/lib/rubex/ast.rb

@@ -1,7 +1,11 @@
-require 'rubex/helpers'
-require 'rubex/ast/statement'
-Dir['./lib/rubex/ast/statement/**/*.rb'].sort.each { |f| require f }
-require 'rubex/ast/expression'
-Dir['./lib/rubex/ast/expression/**/*.rb'].sort.each { |f| require f }
-require 'rubex/ast/top_statement'
-require 'rubex/ast/node'
+require_relative 'helpers'
+require_relative 'ast/statement'
+require_relative 'ast/expression'
+Dir[File.join(File.dirname(File.dirname(__FILE__)),
+              "rubex", "ast", "statement", "**", "*.rb" )].sort.each { |f| require f }
+Dir[File.join(File.dirname(File.dirname(__FILE__)),
+              "rubex", "ast", "expression", "**", "*.rb" )].sort.each { |f| require f }
+require_relative 'ast/top_statement'
+require_relative 'ast/node'
+Dir[File.join(File.dirname(File.dirname(__FILE__)),
+              "rubex", "ast", "node", "**", "*.rb" )].sort.each { |f| require f }

data/lib/rubex/ast/expression.rb

@@ -14,7 +14,7 @@ module Rubex
 
         # If the typecast exists, the typecast is made the overall type of
         # the expression.
-        def analyse_types local_scope
+        def analyse_types local_scope, extern: false
           if @typecast
             @typecast.analyse_types(local_scope)
             @type = @typecast.type

data/lib/rubex/ast/expression/actual_arg_list.rb

@@ -27,6 +27,13 @@ module Rubex
           end
         end
 
+        def analyse_for_target_type(arg_list, local_scope)
+          @args.each_with_index do |arg, i|
+            arg.analyse_for_target_type arg_list[i].type, local_scope
+            @subexprs << arg
+          end
+        end
+
         def generate_evaluation_code(code, local_scope)
           @args.each { |a| a.generate_evaluation_code(code, local_scope) }
         end

data/lib/rubex/ast/expression/analysed_element_ref/c_var_element_ref.rb

@@ -3,13 +3,16 @@ module Rubex
     module Expression
       class CVarElementRef < AnalysedElementRef
         def analyse_types(local_scope)
+          if @pos.size > 1
+            raise "C array can only accept 1 arg. Not #{@pos.size}"
+          end
           @pos.analyse_types local_scope
           @subexprs << @pos
         end
 
         def generate_evaluation_code(code, local_scope)
           generate_and_dispose_subexprs(code, local_scope) do
-            @c_code = "#{@entry.c_name}[#{@pos.c_code(local_scope)}]"
+            @c_code = "#{@entry.c_name}[#{@pos[0].c_code(local_scope)}]"
           end
         end
 
@@ -19,7 +22,7 @@ module Rubex
 
         def generate_assignment_code(rhs, code, local_scope)
          generate_and_dispose_subexprs(code, local_scope) do
-            code << "#{@entry.c_name}[#{@pos.c_code(local_scope)}] = "
+            code << "#{@entry.c_name}[#{@pos[0].c_code(local_scope)}] = "
             code << "#{rhs.c_code(local_scope)};"
             code.nl
           end

data/lib/rubex/ast/expression/analysed_element_ref/ruby_object_element_ref.rb

@@ -5,7 +5,7 @@ module Rubex
         def analyse_types(local_scope)
           super
           @has_temp = true
-          @pos = @pos.to_ruby_object
+          @pos.map! { |a| a.to_ruby_object }
           @pos.allocate_temps local_scope
           @pos.release_temps local_scope
           @subexprs << @pos
@@ -13,26 +13,43 @@ module Rubex
 
         def generate_evaluation_code(code, local_scope)
           generate_and_dispose_subexprs(code, local_scope) do
-            code << "#{@c_code} = rb_funcall(#{@entry.c_name}, rb_intern(\"[]\"), 1, "
-            code << "#{@pos.c_code(local_scope)});"
+            @pos.each { |a| a.generate_evaluation_code(code, local_scope) }
+            code << "#{@c_code} = rb_funcall(#{@entry.c_name}, rb_intern(\"[]\"), "
+            code << @pos.size.to_s
+            @pos.each do |p|
+              code << ", #{p.c_code(local_scope)}"
+            end
+            code << ", NULL" if @pos.empty?
+            code << ");"
             code.nl
           end
         end
 
+        # Generate code for calls to array_ref inside structs.
         def generate_element_ref_code(expr, code, local_scope)
           generate_and_dispose_subexprs(code, local_scope) do
-            str = "#{@c_code} = rb_funcall(#{expr.c_code(local_scope)}."
-            str << "#{@entry.c_name}, rb_intern(\"[]\"), 1, "
-            str << "#{@pos.c_code(local_scope)});"
-            code << str
+            @pos.each { |a| a.generate_evaluation_code(code, local_scope) }
+            code << "#{@c_code} = rb_funcall(#{expr.c_code(local_scope)}."
+            code << "#{@entry.c_name}, rb_intern(\"[]\"), #{@pos.size}"
+            @pos.each do |p|
+              code << ", #{p.c_code(local_scope)}"
+            end
+            code << ", NULL" if @pos.empty?
+            code << ");"
             code.nl
           end
         end
 
         def generate_assignment_code(rhs, code, local_scope)
+          raise "must specify atleast 1 arg in Object#[]=" if @pos.size < 1
           generate_and_dispose_subexprs(code, local_scope) do
-            code << "rb_funcall(#{@entry.c_name}, rb_intern(\"[]=\"), 2,"
-            code << "#{@pos.c_code(local_scope)}, #{rhs.c_code(local_scope)});"
+            @pos.each { |a| a.generate_evaluation_code(code, local_scope) }
+            code << "rb_funcall(#{@entry.c_name}, rb_intern(\"[]=\"),"
+            code << "#{@pos.size + 1}"
+            @pos.each do |p|
+              code << ", #{p.c_code(local_scope)}"
+            end
+            code << ", #{rhs.c_code(local_scope)});"
             code.nl
           end
         end

data/lib/rubex/ast/expression/binary/binary_boolean.rb

@@ -4,7 +4,7 @@ module Rubex
       class BinaryBoolean < Binary
         def analyse_types(local_scope)
           @left.analyse_types local_scope
-          @right.analyse_types local_scope
+          @right.analyse_for_target_type @left.type, local_scope
           if type_of(@left).object? || type_of(@right).object?
             
             @left = @left.to_ruby_object

data/lib/rubex/ast/expression/binary/binary_expo.rb

@@ -0,0 +1,34 @@
+module Rubex
+  module AST
+    module Expression
+      class BinaryExpo < Binary
+        def analyse_types(local_scope)
+          @left.analyse_types local_scope
+          @right.analyse_types local_scope
+          if type_of(@left).object? || type_of(@right).object?            
+            @left = @left.to_ruby_object
+            @right = @right.to_ruby_object
+            @subexprs << @left
+            @subexprs << @right
+          else
+            @type = Rubex::DataType::F64.new
+          end
+
+        end
+
+        def generate_evaluation_code code, local_scope
+          generate_and_dispose_subexprs(code, local_scope) do
+            if @type.object?
+              code << "#{@c_code} = rb_funcall(#{@left.c_code(local_scope)}," +
+                "rb_intern(\"#{@operator}\")," +
+                "1, #{@right.c_code(local_scope)});"
+              code.nl
+            else
+              @c_code = "( pow(#{@left.c_code(local_scope)}, #{@right.c_code(local_scope)}) )"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/binary/colon2.rb

@@ -0,0 +1,34 @@
+module Rubex
+  module AST
+    module Expression
+      class Colon2 < Base
+        attr_reader :lhs, :rhs
+        
+        def initialize lhs, rhs
+          @lhs = lhs
+          @rhs = rhs
+        end
+
+        def analyse_types local_scope
+          @type = DataType::RubyObject.new
+        end
+
+        def generate_evaluation_code code, local_scope
+          @c_code = recursive_scoping_generation @lhs, @rhs, "rb_const_get(CLASS_OF(#{local_scope.self_name}), rb_intern(\"#{@lhs}\"))"
+        end
+
+        def recursive_scoping_generation lhs, rhs, c_str
+          if rhs.is_a?(Colon2)
+            recursive_scoping_generation rhs.lhs, rhs.rhs, "rb_const_get(#{c_str}, rb_intern(\"#{rhs.lhs}\"))"
+          else
+            "rb_const_get(#{c_str}, rb_intern(\"#{rhs}\"))"
+          end
+        end
+        
+        def c_code local_scope
+          super + @c_code
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/binary/empty_classes.rb

@@ -13,9 +13,6 @@ module Rubex
       class BinaryDivide < Binary
       end
 
-      class BinaryExpo < Binary
-      end
-
       class BinaryMod < Binary
       end
 

data/lib/rubex/ast/expression/command_call.rb

@@ -57,11 +57,35 @@ module Rubex
           @entry && @entry.type.base_type.c_function?
         end
 
+        def raise_call?
+          !@entry && @command == "raise"
+        end
+
+        def yield_call?
+          !@entry && @command == "yield"
+        end
+
+        def print_call?
+          !@entry && @command == "print"
+        end
+
+        def require_call?
+          !@entry && @command == "require"
+        end
+
         def analyse_command_type(local_scope)
           if struct_member_call?
             @command = Expression::StructOrUnionMemberCall.new @expr, @command, @arg_list
           elsif c_function_call?
             @command = Expression::CFunctionCall.new @expr, @command,  @arg_list
+          elsif raise_call?
+            @command = Expression::Raise.new @arg_list
+          elsif yield_call?
+            @command = Expression::Yield.new @arg_list
+          elsif print_call?
+            @command = Expression::Print.new @arg_list
+          elsif require_call?
+            @command = Expression::Require.new @arg_list
           else
             @command = Expression::RubyMethodCall.new @expr, @command, @arg_list
           end

data/lib/rubex/ast/{statement → expression/command_call}/print.rb

@@ -1,13 +1,12 @@
 module Rubex
   module AST
-    module Statement
+    module Expression
       class Print < Base
-        def initialize(expressions, location)
-          super(location)
+        def initialize(expressions)
           @expressions = expressions
         end
 
-        def analyse_statement(local_scope)
+        def analyse_types(local_scope)
           @expressions.each do |expr|
             expr.analyse_types local_scope
             expr.allocate_temps local_scope
@@ -15,7 +14,7 @@ module Rubex
           end
         end
 
-        def generate_code(code, local_scope)
+        def generate_evaluation_code(code, local_scope)
           super
           @expressions.each do |expr|
             expr.generate_evaluation_code code, local_scope

data/lib/rubex/ast/{statement → expression/command_call}/raise.rb

@@ -1,44 +1,49 @@
 module Rubex
   module AST
-    module Statement
-      class Raise < Base
+    module Expression
+      class Raise < CommandCall
         def initialize(args)
           @args = args
         end
 
-        def analyse_statement(local_scope)
+        def analyse_types(local_scope)
           @args.analyse_types local_scope
           @args.allocate_temps local_scope
-          @args.release_temps local_scope
           unless @args.empty? || @args[0].is_a?(AST::Expression::Name) ||
                  @args[0].is_a?(AST::Expression::Literal::StringLit)
             raise Rubex::TypeMismatchError, "Wrong argument list #{@args.inspect} for raise."
           end
+          @subexprs = [@args]
+          @args.release_temps local_scope
         end
 
-        def generate_code(code, local_scope)
-          @args.generate_evaluation_code code, local_scope
-          str = ''
-          str << 'rb_raise('
+        def generate_evaluation_code(code, local_scope)
+          generate_and_dispose_subexprs(code, local_scope) do
+            @c_code = ''
+            @c_code << 'rb_raise('
 
-          if @args[0].is_a?(AST::Expression::Name)
-            str << @args[0].c_code(local_scope) + ','
-            args = @args[1..-1]
-          else
-            str << Rubex::DEFAULT_CLASS_MAPPINGS['RuntimeError'] + ','
-            args = @args
-          end
+            if @args[0].is_a?(AST::Expression::Name)
+              @c_code << @args[0].c_code(local_scope) + ','
+              args = @args[1..-1]
+            else
+              @c_code << Rubex::DEFAULT_CLASS_MAPPINGS['RuntimeError'] + ','
+              args = @args
+            end
 
-          unless args.empty?
-            str << "\"#{prepare_format_string(args)}\" ,"
-            str << args.map { |arg| (inspected_expr(arg, local_scope)).to_s }.join(',')
-          else
-            str << '""'
+            unless args.empty?
+              @c_code << "\"#{prepare_format_string(args)}\" ,"
+              @c_code << args.map { |arg| (inspected_expr(arg, local_scope)).to_s }.join(',')
+            else
+              @c_code << '""'
+            end
+            @c_code << ');'
           end
-          str << ');'
-          code << str
-          code.nl
-          @args.generate_disposal_code code
+        end
+
+        def generate_disposal_code(code); end
+
+        def c_code(_local_scope)
+          super + @c_code
         end
 
         private

data/lib/rubex/ast/expression/command_call/require.rb

@@ -0,0 +1,27 @@
+module Rubex
+  module AST
+    module Expression
+      class Require < Base
+        def initialize args
+          @args = args
+        end
+
+        def analyse_types(local_scope)
+          raise "require can only support single string argument." if @args.size > 1
+          if !@args[0].is_a?(Expression::Literal::StringLit)
+            raise "Argument to require must be a string literal. not #{@args[0].class}."
+          end
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          string = @args[0].instance_variable_get(:@name)          
+          @c_code = "rb_funcall(rb_cObject, rb_intern(\"require\"), 1, rb_str_new2(\"#{string}\"))"
+        end
+
+        def c_code(_local_scope)
+          @c_code
+        end
+      end
+    end
+  end
+end