rubex 0.1 → 0.1.1

data/lib/rubex/ast/expression/literal/string_lit.rb

@@ -0,0 +1,45 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class StringLit < Base
+          def analyse_for_target_type(target_type, local_scope)
+            if target_type.char_ptr?
+              @type = Rubex::DataType::CStr.new
+            elsif target_type.object?
+              @type = Rubex::DataType::RubyString.new
+              analyse_types local_scope
+            else
+              raise Rubex::TypeError, "Cannot assign #{target_type} to string."
+            end
+          end
+
+          def analyse_types(_local_scope)
+            @type ||= Rubex::DataType::RubyString.new
+            @has_temp = true
+          end
+
+          def generate_evaluation_code(code, _local_scope)
+            if @type.cstr?
+              @c_code = "\"#{@name}\""
+            else
+              code << "#{@c_code} = rb_str_new2(\"#{@name}\");"
+              code.nl
+            end
+          end
+
+          def generate_disposal_code(code)
+            if @type.object?
+              code << "#{@c_code} = 0;"
+              code.nl
+            end
+          end
+
+          def c_code(_local_scope)
+            @c_code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/literal/true.rb

@@ -0,0 +1,29 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class True < Base
+          def analyse_for_target_type(target_type, _local_scope)
+            @type = if target_type.object?
+                      Rubex::DataType::TrueType.new
+                    else
+                      Rubex::DataType::CBoolean.new
+                    end
+          end
+
+          def analyse_types(_local_scope)
+            @type = Rubex::DataType::TrueType.new
+          end
+
+          def c_code(_local_scope)
+            if @type.object?
+              @name
+            else
+              '1'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Rubex
+  module AST
+    module Expression
+      class MethodCall < Base
+        def initialize(invoker, method_name, arg_list)
+          @method_name = method_name
+          @invoker = invoker
+          @arg_list = arg_list
+        end
+
+        def analyse_types(local_scope)
+          if method_not_within_scope? local_scope
+            raise Rubex::NoMethodError, "Cannot call #{@method_name} from this method."
+          end
+          super
+        end
+
+        def generate_evaluation_code code, local_scope
+          @arg_list.each { |a| a.generate_evaluation_code(code, local_scope) }
+        end
+
+        private
+
+        def type_check_arg_types(entry)
+          @arg_list.map!.with_index do |arg, idx|
+            Helpers.to_lhs_type(entry.type.base_type.arg_list[idx], arg)
+          end
+        end
+
+        # Checks if method being called is of the same type of the caller. For
+        # example, only instance methods can call instance methods and only
+        # class methods can call class methods. C functions are accessible from
+        # both instance methods and class methods.
+        #
+        # Since there is no way to determine whether methods outside the scope
+        # of the compiled Rubex file are singletons or not, Rubex will assume
+        # that they belong to the correct scope and will compile a call to those
+        # methods anyway. Error, if any, will be caught only at runtime.
+        def method_not_within_scope?(local_scope)
+          caller_entry = local_scope.find local_scope.name
+          if (caller_entry.singleton? &&  @entry.singleton?) ||
+             (!caller_entry.singleton? && !@entry.singleton?) ||
+             @entry.c_function?
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/method_call/c_function_call.rb

@@ -0,0 +1,40 @@
+module Rubex
+  module AST
+    module Expression
+      class CFunctionCall < MethodCall
+        def analyse_types(local_scope)
+          @entry = local_scope.find(@method_name)
+          super
+          append_self_argument unless @entry.extern?
+          @arg_list.analyse_types local_scope
+          @arg_list.allocate_temps local_scope
+          @arg_list.release_temps local_scope
+          @type = @entry.type.base_type
+          type_check_arg_types @entry
+        end
+
+        def generate_evaluation_code code, local_scope
+          super
+          @c_code = code_for_c_method_call local_scope
+        end
+
+        def c_code(local_scope)
+          @c_code
+        end
+
+        private
+
+        def append_self_argument
+          @arg_list << Expression::Self.new
+        end
+
+        def code_for_c_method_call(local_scope)
+          str = "#{@entry.c_name}("
+          str << @arg_list.map { |a| a.c_code(local_scope) }.join(',')
+          str << ')'
+          str
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/method_call/ruby_method_call.rb

@@ -0,0 +1,83 @@
+module Rubex
+  module AST
+    module Expression
+      class RubyMethodCall < MethodCall        
+        def analyse_types(local_scope)
+          @entry = local_scope.find(@method_name)
+          add_as_ruby_method_to_symtab(local_scope) unless @entry
+          super
+          @arg_list.analyse_types local_scope
+          @type = Rubex::DataType::RubyObject.new
+          @arg_list.map! { |a| a.to_ruby_object }
+          @arg_list.allocate_temps local_scope
+          @arg_list.release_temps local_scope
+          prepare_arg_list(local_scope) if !@entry.extern? && !@arg_list.empty?
+          @has_temp = true
+        end
+
+        def generate_evaluation_code code, local_scope
+          super
+          code_for_ruby_method_call code, local_scope
+        end
+
+        def c_code(local_scope)
+          @c_code
+        end
+
+        private
+
+        def add_as_ruby_method_to_symtab(local_scope)
+          @entry = local_scope.add_ruby_method(
+            name: @method_name,
+            c_name: @method_name,
+            extern: true,
+            arg_list: @arg_list,
+            scope: nil
+          )
+        end
+
+        def prepare_arg_list(local_scope)
+          @arg_list_var = @entry.c_name + Rubex::ACTUAL_ARGS_SUFFIX
+          args_size = @entry.type.arg_list&.size || 0
+          local_scope.add_carray(name: @arg_list_var, c_name: @arg_list_var,
+                                 dimension: Literal::Int.new(args_size.to_s),
+                                 type: @type)
+        end
+
+        def code_for_ruby_method_call(code, local_scope)
+          str = "#{@c_code} = "
+          if @entry.extern?
+            str << "rb_funcall(#{@invoker.c_code(local_scope)}, "
+            str << "rb_intern(\"#{@method_name}\"), "
+            str << @arg_list.size.to_s
+            @arg_list.each do |arg|
+              str << " ,#{arg.c_code(local_scope)}"
+            end
+            str << ', NULL' if @arg_list.empty?
+            str << ");\n"
+          else
+            str << populate_method_args_into_value_array(local_scope)
+            str << actual_ruby_method_call(local_scope)
+          end
+          code << str
+        end
+
+        def actual_ruby_method_call(local_scope)
+          str = "#{@entry.c_name}(#{@arg_list.size}, #{@arg_list_var || 'NULL'},"
+          str << "#{local_scope.self_name});"
+        end
+
+        def populate_method_args_into_value_array(local_scope)
+          str = ''
+          @arg_list.each_with_index do |arg, idx|
+            str = "#{@arg_list_var}[#{idx}] = "
+            str << arg.c_code(local_scope).to_s
+            str << ";\n"
+          end
+
+          str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+module Rubex
+  module AST
+    module Expression
+      # Singular name node with no sub expressions.
+      class Name < Base
+        def initialize(name)
+          @name = name
+        end
+
+        # Used when the node is a LHS of an assign statement.
+        def analyse_declaration(_rhs, local_scope)
+          @entry = local_scope.find @name
+          unless @entry
+            local_scope.add_ruby_obj(name: @name, c_name: Rubex::VAR_PREFIX + @name, value: @rhs)
+            @entry = local_scope[@name]
+          end
+          @type = @entry.type
+        end
+
+        def analyse_for_target_type(target_type, local_scope)
+          @entry = local_scope.find @name
+
+          if @entry&.type&.c_function? && target_type.c_function_ptr?
+            @type = @entry.type
+          else
+            analyse_types local_scope
+          end
+        end
+
+        # Analyse a Name node. This can either be a variable name or a method call
+        #   without parenthesis. Code in this method that creates a RubyMethodCall
+        #   node primarily exists because in Ruby methods without arguments can
+        #   be called without parentheses. These names can potentially be Ruby
+        #   methods that are not visible to Rubex, but are present in the Ruby
+        #   run time. For example, a program like this:
+        #
+        #     def foo
+        #       bar
+        #      #^^^ this is a name node
+        #     end
+        def analyse_types(local_scope)
+          @entry = local_scope.find @name
+          unless @entry
+            if ruby_constant?
+              analyse_as_ruby_constant local_scope
+            else
+              add_as_ruby_method_to_scope local_scope
+            end
+          end
+          analyse_as_ruby_method(local_scope) if @entry.type.ruby_method?
+          assign_type_based_on_whether_wrapped_type
+          if @name.is_a?(Expression::Base)
+            @name.allocate_temps local_scope
+            @name.release_temps local_scope
+          end
+          super
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          if @name.respond_to? :generate_evaluation_code
+            @name.generate_evaluation_code code, local_scope
+          end
+        end
+
+        def generate_disposal_code(code)
+          if @name.respond_to? :generate_disposal_code
+            @name.generate_disposal_code code
+          end
+        end
+
+        def generate_assignment_code(rhs, code, local_scope)
+          code << "#{c_code(local_scope)} = #{rhs.c_code(local_scope)};"
+          code.nl
+          rhs.generate_disposal_code code
+        end
+
+        def c_code(local_scope)          
+          code = super
+          code <<
+            if @name.is_a?(Rubex::AST::Expression::Base)
+              @name.c_code(local_scope)
+            else
+              @entry.c_name
+            end
+          code
+        end
+
+        private
+
+        def ruby_constant?
+          @name[0].match(/[A-Z]/)
+        end
+
+        def analyse_as_ruby_constant(local_scope)
+          @name = Expression::RubyConstant.new @name
+          @name.analyse_types local_scope
+          @entry = @name.entry
+        end
+
+        def add_as_ruby_method_to_scope(local_scope)
+          @entry = local_scope.add_ruby_method(
+            name: @name,
+            c_name: @name,
+            extern: true,
+            scope: nil,
+            arg_list: Expression::ActualArgList.new([])
+          )
+        end
+
+        def analyse_as_ruby_method(local_scope)
+          @name = Rubex::AST::Expression::RubyMethodCall.new(
+            Expression::Self.new, @name, Expression::ActualArgList.new([])
+          )
+          @name.analyse_types local_scope
+        end
+
+        def assign_type_based_on_whether_wrapped_type
+          if @entry.type.alias_type? || @entry.type.ruby_method? || @entry.type.c_function?
+            @type = @entry.type.type
+          else
+            @type = @entry.type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Rubex
+  module AST
+    module Expression
+      class RubyConstant < Base
+        def initialize(name)
+          @name = name
+        end
+
+        def analyse_types(_local_scope)
+          @type = Rubex::DataType::RubyConstant.new @name
+          c_name = Rubex::DEFAULT_CLASS_MAPPINGS[@name]
+          @entry = Rubex::SymbolTable::Entry.new @name, c_name, @type, nil
+        end
+
+        def c_code(local_scope)
+          if @entry.c_name # built-in constant.
+            @entry.c_name
+          else
+            "rb_const_get(CLASS_OF(#{local_scope.self_name}), rb_intern(\"#{@entry.name}\"))"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Rubex
+  module AST
+    module Expression
+      class RubyArrayElementRef < RubyObjectElementRef
+        def analyse_types(local_scope)
+          @has_temp = true
+          @pos.analyse_types local_scope
+          @subexprs << @pos
+        end
+        
+        def generate_evaluation_code(code, local_scope)
+          generate_and_dispose_subexprs(code, local_scope) do
+            code << "#{@c_code} = RARRAY_AREF(#{@entry.c_name}, #{@pos.c_code(local_scope)});"
+            code.nl
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Rubex
+  module AST
+    module Expression
+      class RubyHashElementRef < RubyObjectElementRef
+        def generate_evaluation_code(code, local_scope)
+          generate_and_dispose_subexprs(code, local_scope) do
+            code << "#{@c_code} = rb_hash_aref(#{@entry.c_name}, #{@pos.c_code(local_scope)});"
+            code.nl
+          end
+        end
+
+        def generate_assignment_code(rhs, code, local_scope)
+          generate_and_dispose_subexprs(code, local_scope) do
+            code << "rb_hash_aset(#{@entry.c_name}, #{@pos.c_code(local_scope)},"
+            code << "#{rhs.c_code(local_scope)});"
+            code.nl
+          end
+        end
+      end
+    end
+  end
+end