rubex 0.1 → 0.1.1

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

@@ -0,0 +1,40 @@
+module Rubex
+  module AST
+    module Expression
+      class ActualArgList < Base
+        include Enumerable
+        extend Forwardable
+
+        def_delegators :@args, :empty?, :[], :size, :<<
+        
+        def each(&block)
+          @args.each(&block)
+        end
+
+        def map!(&block)
+          @args.map!(&block)
+        end
+
+        def initialize args
+          @args = args
+          @subexprs = []
+        end
+        
+        def analyse_types(local_scope)
+          @args.each do |arg|
+            arg.analyse_types local_scope
+            @subexprs << arg
+          end
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          @args.each { |a| a.generate_evaluation_code(code, local_scope) }
+        end
+
+        def generate_disposal_code(code)
+          @args.each { |a| a.generate_disposal_code(code) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Rubex
+  module AST
+    module Expression
+      class AnalysedElementRef < Base
+        def initialize(element_ref)
+          @element_ref = element_ref
+          @pos = @element_ref.pos
+          @entry = @element_ref.entry
+          @name = @element_ref.name
+          @subexprs = @element_ref.subexprs
+          @type = @element_ref.type
+        end
+
+        def analyse_types(local_scope)
+          @pos.analyse_types local_scope
+        end
+
+        def c_code(local_scope)
+          code = super
+          code << @c_code
+          code
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Rubex
+  module AST
+    module Expression
+      class CVarElementRef < AnalysedElementRef
+        def analyse_types(local_scope)
+          @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)}]"
+          end
+        end
+
+        def generate_element_ref_code(_expr, code, local_scope)
+          generate_evaluation_code code, local_scope
+        end
+
+        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 << "#{rhs.c_code(local_scope)};"
+            code.nl
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Rubex
+  module AST
+    module Expression
+      class RubyObjectElementRef < AnalysedElementRef
+        def analyse_types(local_scope)
+          super
+          @has_temp = true
+          @pos = @pos.to_ruby_object
+          @pos.allocate_temps local_scope
+          @pos.release_temps local_scope
+          @subexprs << @pos
+        end
+
+        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)});"
+            code.nl
+          end
+        end
+
+        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
+            code.nl
+          end
+        end
+
+        def generate_assignment_code(rhs, code, local_scope)
+          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)});"
+            code.nl
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Rubex
+  module AST
+    module Expression
+      class ArgDeclaration < Base
+        # Keep data_hash attr_reader because this node is coerced into
+        # specialized ArgDecl nodes in the parser.
+        attr_reader :data_hash
+        def initialize(data_hash)
+          @data_hash = data_hash
+        end
+
+        # TODO: Support array of function pointers and array in arguments.
+        def analyse_types(local_scope, extern: false)
+          var, dtype, ident, ptr_level, value = fetch_data
+          name = ident
+          c_name = Rubex::ARG_PREFIX + ident
+          @type = Helpers.determine_dtype(dtype, ptr_level)
+          value&.analyse_types(local_scope)
+          add_arg_to_symbol_table name, c_name, value, extern, local_scope
+          @has_temp = true if @type.object?
+        end
+
+        private
+
+        def add_arg_to_symbol_table(name, c_name, value, extern, local_scope)
+          unless extern
+            @entry = local_scope.add_arg(name: name, c_name: c_name, type: @type, value: value)
+          end
+        end
+
+        def fetch_data
+          var       = @data_hash[:variables][0]
+          dtype     = @data_hash[:dtype]
+          ident     = var[:ident]
+          ptr_level = var[:ptr_level]
+          value     = var[:value]
+
+          [var, dtype, ident, ptr_level, value]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Rubex
+  module AST
+    module Expression
+      # Binary expression Base class.
+      class Binary < Base
+        include Rubex::Helpers::NodeTypeMethods
+        def initialize left, operator, right
+          @left, @operator, @right = left, operator, right
+          @subexprs = []
+        end
+
+        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
+            @has_temp = true
+          end
+          @type = Rubex::Helpers.result_type_for(type_of(@left), type_of(@right))
+          @subexprs << @left
+          @subexprs << @right
+        end
+
+        def generate_evaluation_code code, local_scope
+          generate_and_dispose_subexprs(code, local_scope) do
+            if @has_temp
+              code << "#{@c_code} = rb_funcall(#{@left.c_code(local_scope)}," +
+                "rb_intern(\"#{@operator}\")," +
+                "1, #{@right.c_code(local_scope)});"
+              code.nl
+            else
+              @c_code = "( #{@left.c_code(local_scope)} #{@operator} #{@right.c_code(local_scope)} )"
+            end
+          end
+        end
+
+        def c_code local_scope
+          super + @c_code
+        end
+
+        def == other
+          self.class == other.class && @type  == other.type &&
+          @left == other.left  && @right == other.right &&
+          @operator == other.operator
+        end
+
+        private
+
+        def type_of expr
+          t = expr.type
+          return (t.c_function? ? t.type : t)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Rubex
+  module AST
+    module Expression
+      class BinaryBoolean < 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
+            @type = Rubex::DataType::Boolean.new
+            @has_temp = true
+          else
+            @type = Rubex::DataType::CBoolean.new
+          end
+          @subexprs << @left
+          @subexprs << @right
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Rubex
+  module AST
+    module Expression
+      class BinaryBooleanSpecialOp < BinaryBoolean
+        def generate_evaluation_code(code, local_scope)
+          generate_and_dispose_subexprs(code, local_scope) do
+            if @has_temp
+              code << "#{@c_code} = " + Rubex::C_MACRO_INT2BOOL +
+                "(RTEST(#{@left.c_code(local_scope)}) #{@operator} " \
+                "RTEST(#{@right.c_code(local_scope)}));"
+              code.nl
+            else
+              @c_code = "#{@left.c_code(local_scope)} #{@operator} #{@right.c_code(local_scope)}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Rubex
+  module AST
+    module Expression
+      class BinaryAdd < Binary
+      end
+
+      class BinaryMinus < Binary
+      end
+
+      class BinaryMultiply < Binary
+      end
+
+      class BinaryDivide < Binary
+      end
+
+      class BinaryExpo < Binary
+      end
+
+      class BinaryMod < Binary
+      end
+
+      class BinaryAnd < Binary
+      end
+
+      class BinaryOr < Binary
+      end
+
+      class BinaryXor < Binary
+      end
+
+      class BinaryLShift < Binary
+      end
+
+      class BinaryRShift < Binary
+      end
+
+      class BinaryBoolEq < BinaryBoolean
+      end
+
+      class BinaryBoolNEq < BinaryBoolean
+      end
+
+      class BinaryBoolLt < BinaryBoolean
+      end
+
+      class BinaryBoolLtEq < BinaryBoolean
+      end
+
+      class BinaryBoolGt < BinaryBoolean
+      end
+
+      class BinaryBoolGtEq < BinaryBoolean
+      end
+
+      class BinaryBoolAnd < BinaryBooleanSpecialOp
+      end
+
+      class BinaryBoolOr < BinaryBooleanSpecialOp
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Rubex
+  module AST
+    module Expression
+      class BlockGiven < Base
+        def analyse_types(_local_scope)
+          @type = DataType::CBoolean.new
+        end
+
+        def c_code(_local_scope)
+          'rb_block_given_p()'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Rubex
+  module AST
+    module Expression
+      class CoerceObject < Base
+        attr_reader :expr
+
+        extend Forwardable
+
+        def_delegators :@expr, :generate_evaluation_code, :generate_disposal_code,
+        :generate_assignment_code, :allocate_temp, :allocate_temps,
+        :release_temp, :release_temps, :type
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Rubex
+  module AST
+    module Expression
+      class CommandCall < Base
+        def initialize(expr, command, arg_list)
+          @expr = expr
+          @command = command
+          @arg_list = arg_list
+        end
+
+        def analyse_types(local_scope)
+          @entry = local_scope.find(@command)
+          if @expr.nil? # Case for implicit 'self' when a method in the class itself is being called.
+            @expr = (@entry && !@entry.extern) ? Expression::Self.new : Expression::Empty.new
+          end
+          @expr.analyse_types(local_scope)
+          analyse_command_type local_scope
+          @subexprs = [@expr, @command]
+          super
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          @expr.generate_evaluation_code(code, local_scope)
+          @command.generate_evaluation_code code, local_scope
+          @c_code = @command.c_code(local_scope)
+        end
+
+        def generate_disposal_code(code)
+          @expr.generate_disposal_code code
+          @command.generate_disposal_code code
+        end
+
+        def generate_assignment_code(rhs, code, local_scope)
+          generate_evaluation_code code, local_scope
+          code << "#{c_code(local_scope)} = #{rhs.c_code(local_scope)};"
+          code.nl
+        end
+
+        def c_code(local_scope)
+          code = super
+          code << @c_code
+          code
+        end
+
+        private
+
+        def struct_member_call?
+          ((@expr.type.cptr? && @expr.type.type.struct_or_union?) ||
+           @expr.type.struct_or_union?) 
+        end
+
+        def ruby_method_call?
+          @entry.type.ruby_method?
+        end
+
+        def c_function_call?
+          @entry && @entry.type.base_type.c_function?
+        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
+          else
+            @command = Expression::RubyMethodCall.new @expr, @command, @arg_list
+          end
+          @command.analyse_types local_scope
+          @type = @command.type
+        end
+      end
+    end
+  end
+end