rubex 0.1 → 0.1.1

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

@@ -0,0 +1,38 @@
+module Rubex
+  module AST
+    module Expression
+      class StructOrUnionMemberCall < CommandCall
+        def analyse_types(local_scope)
+          scope = @expr.type.base_type.scope
+
+          if @command.is_a? String
+            @command = Expression::Name.new @command
+            @command.analyse_types scope
+          elsif @command.is_a? Rubex::AST::Expression::ElementRef
+            @command = Expression::ElementRefMemberCall.new @expr, @command, @arg_list
+            @command.analyse_types local_scope, scope
+          end
+          @has_temp = @command.has_temp
+          @type = @command.type
+          @subexprs = [@expr, @command]
+        end
+
+        def generate_evaluation_code code, local_scope
+          @expr.generate_evaluation_code code, local_scope
+          @command.generate_evaluation_code code, local_scope
+          @c_code =
+            if @command.has_temp
+              @command.c_code(local_scope)
+            else
+              op = @expr.type.cptr? ? '->' : '.'
+              "#{@expr.c_code(local_scope)}#{op}#{@command.c_code(local_scope)}"
+            end
+        end
+
+        def c_code(_local_scope)
+          @c_code
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Rubex
+  module AST
+    module Expression
+      class ElementRef < Base
+        # Readers needed for accessing elements due to delegator classes.
+        attr_reader :entry, :pos, :name, :subexprs
+        extend Forwardable
+        def_delegators :@element_ref, :generate_disposal_code, :generate_evaluation_code,
+        :analyse_statement, :generate_element_ref_code,
+        :generate_assignment_code, :has_temp, :c_code,
+        :allocate_temps, :release_temps, :to_ruby_object,
+        :from_ruby_object
+
+        def initialize(name, pos)
+          @name = name
+          @pos = pos
+          @subexprs = []
+        end
+
+        def analyse_types(local_scope, struct_scope = nil)
+          @entry = struct_scope.nil? ? local_scope.find(@name) : struct_scope[@name]
+          @type = @entry.type.object? ? @entry.type : @entry.type.type
+          @element_ref = proper_analysed_type
+          @element_ref.analyse_types local_scope
+          super(local_scope)
+        end
+
+        private
+
+        def proper_analysed_type
+          if ruby_object_c_array?
+            CVarElementRef.new(self)
+          else
+            if ruby_array?
+              RubyArrayElementRef.new(self)
+            elsif ruby_hash?
+              RubyHashElementRef.new(self)
+            elsif generic_ruby_object?
+              RubyObjectElementRef.new(self)
+            else
+              CVarElementRef.new(self)
+            end
+          end
+        end
+
+        def ruby_array?
+          @type.ruby_array?
+        end
+
+        def ruby_hash?
+          @type.ruby_hash?
+        end
+
+        def generic_ruby_object?
+          @type.object?
+        end
+
+        def ruby_object_c_array?
+          @entry.type.cptr? && @entry.type.type.object?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Rubex
+  module AST
+    module Expression
+      # Internal node that denotes empty expression for a statement for example
+      #   the `return` for a C function with return type `void`.
+      class Empty < Base
+        def analyse_types(_local_scope)
+          @type = DataType::Void.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Rubex
+  module AST
+    module Expression
+      # internal node for converting from ruby object.
+      class FromRubyObject < CoerceObject
+        # expr - Expression to convert
+        # from_node - LHS expression. Of type Rubex::AST::Expression
+        def initialize(expr, from_node)
+          @expr = expr
+          @type = @expr.type
+          @from_node = from_node
+        end
+
+        def c_code(local_scope)
+          @from_node.type.from_ruby_object(@expr.c_code(local_scope)).to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# Function argument is a function pointer.
+module Rubex
+  module AST
+    module Expression
+      class FuncPtrArgDeclaration < ArgDeclaration
+        def analyse_types(local_scope, extern: false)
+          var, dtype, ident, ptr_level, value = fetch_data
+          cfunc_return_type = Helpers.determine_dtype(dtype, ident[:return_ptr_level])
+          arg_list = ident[:arg_list].analyse_statement(local_scope)
+          ptr_level = '*' if ptr_level.empty?
+          name = ident[:name]
+          c_name = Rubex::ARG_PREFIX + ident[:name]
+          @type = Helpers.determine_dtype(
+            DataType::CFunction.new(name, c_name, arg_list, cfunc_return_type, nil), ptr_level
+          )
+          add_arg_to_symbol_table name, c_name, value, extern, local_scope
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Rubex
+  module AST
+    module Expression
+      # Function argument is the argument of a function pointer.
+      class FuncPtrInternalArgDeclaration < ArgDeclaration
+        def analyse_types(_local_scope, extern: false)
+          var, dtype, ident, ptr_level, value = fetch_data
+          @type = Helpers.determine_dtype(dtype, ptr_level)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class Base < Rubex::AST::Expression::Base
+          def initialize(name)
+            @name = name
+          end
+
+          def c_code(local_scope)
+            code = super
+            code << @name
+          end
+
+          def c_name
+            @name
+          end
+
+          def literal?
+            true
+          end
+
+          def ==(other)
+            self.class == other.class && @name == other.name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class ArrayLit < Base
+          include Enumerable
+
+          attr_accessor :c_array
+
+          def each(&block)
+            @array_list.each(&block)
+          end
+
+          def initialize(array_list)
+            @array_list = array_list
+            @subexprs = []
+          end
+
+          def analyse_types(local_scope)
+            @has_temp = true
+            @type = DataType::RubyObject.new
+            @array_list.map! do |e|
+              e.analyse_types local_scope
+              e = e.to_ruby_object
+              @subexprs << e
+              e
+            end
+          end
+
+          def generate_evaluation_code(code, local_scope)
+            code << "#{@c_code} = rb_ary_new2(#{@array_list.size});"
+            code.nl
+            @array_list.each do |e|
+              code << "rb_ary_push(#{@c_code}, #{e.c_code(local_scope)});"
+              code.nl
+            end
+          end
+
+          def generate_disposal_code(code)
+            code << "#{@c_code} = 0;"
+            code.nl
+          end
+
+          def c_code(_local_scope)
+            @c_code
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class CNull < Base
+          def initialize(name)
+            # Rubex treats NULL's dtype as void*
+            super
+            @type = Rubex::DataType::CPtr.new(Rubex::DataType::Void.new)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class Char < Base
+          def analyse_for_target_type(target_type, local_scope)
+            if target_type.char?
+              @type = Rubex::DataType::Char.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
+          end
+
+          def generate_evaluation_code(_code, _local_scope)
+            @c_code = if @type.char?
+                        @name
+                      else
+                        "rb_str_new2(\"#{@name[1]}\")"
+                      end
+          end
+
+          def c_code(_local_scope)
+            @c_code
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class Double < Base
+          def initialize(name)
+            super
+            @type = Rubex::DataType::F64.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,45 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class HashLit < Base
+          def initialize(key_val_pairs)
+            @key_val_pairs = key_val_pairs
+          end
+
+          def analyse_types(local_scope)
+            @has_temp = true
+            @type = Rubex::DataType::RubyObject.new
+            @key_val_pairs.map! do |k, v|
+              k.analyse_for_target_type(@type, local_scope)
+              v.analyse_for_target_type(@type, local_scope)
+              [k.to_ruby_object, v.to_ruby_object]
+            end
+            @subexprs = @key_val_pairs.to_a.flatten
+          end
+
+          def generate_evaluation_code(code, local_scope)
+            code << "#{@c_code} = rb_hash_new();"
+            code.nl
+            @key_val_pairs.each do |k, v|
+              k.generate_evaluation_code(code, local_scope)
+              v.generate_evaluation_code(code, local_scope)
+
+              code << "rb_hash_aset(#{@c_code}, #{k.c_code(local_scope)}, "
+              code << "#{v.c_code(local_scope)});"
+              code.nl
+
+              k.generate_disposal_code code
+              v.generate_disposal_code code
+              code.nl
+            end
+          end
+
+          def c_code(_local_scope)
+            @c_code
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class Int < Base
+          def initialize(name)
+            super
+            @type = Rubex::DataType::Int.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class Nil < Base
+          def initialize(name)
+            super
+            @type = Rubex::DataType::NilType.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Rubex
+  module AST
+    module Expression
+      module Literal
+        class RubySymbol < Base
+          def initialize(name)
+            super(name[1..-1])
+            @type = Rubex::DataType::RubySymbol.new
+          end
+
+          def generate_evaluation_code(_code, _local_scope)
+            @c_code = "ID2SYM(rb_intern(\"#{@name}\"))"
+          end
+
+          def c_code(_local_scope)
+            @c_code
+          end
+        end
+      end
+    end
+  end
+end