rubex 0.1 → 0.1.1

data/lib/rubex/ast/statement/c_array_decl.rb

@@ -0,0 +1,49 @@
+module Rubex
+  module AST
+    module Statement
+      class CArrayDecl < Base
+        attr_reader :type, :array_list, :name, :dimension
+
+        def initialize(type, array_ref, array_list, location)
+          super(location)
+          @name = array_ref.name
+          @array_list = array_list
+          @dimension = array_ref.pos
+          @type = Rubex::TYPE_MAPPINGS[type].new
+        end
+
+        def analyse_statement(local_scope, extern: false)
+          @dimension.analyse_types local_scope
+          create_symbol_table_entry local_scope
+          return if @array_list.nil?
+          analyse_array_list local_scope
+          verify_array_list_types local_scope
+        end
+
+        def generate_code(code, local_scope); end
+
+        def rescan_declarations(local_scope); end
+
+        private
+
+        def analyse_array_list(local_scope)
+          @array_list.each do |expr|
+            expr.analyse_types(local_scope)
+          end
+        end
+
+        def verify_array_list_types(_local_scope)
+          @array_list.all? do |expr|
+            return true if @type >= expr.type
+            raise "Specified type #{@type} but list contains #{expr.type}."
+          end
+        end
+
+        def create_symbol_table_entry(local_scope)
+          local_scope.add_carray(name: @name, c_name: Rubex::ARRAY_PREFIX + @name,
+                                 dimension: @dimension, type: @type, value: @array_list)
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/c_base_type.rb

@@ -0,0 +1,26 @@
+module Rubex
+  module AST
+    module Statement
+      class CBaseType < Base
+        attr_reader :type, :name, :value
+
+        def initialize(type, name, value = nil)
+          @type = type
+          @name = name
+          @value = value
+        end
+
+        def ==(other)
+          self.class == other.class &&
+            type == other.class  &&
+            name == other.name   &&
+            value == other.value
+        end
+
+        def analyse_statement(_local_scope)
+          @type = Rubex::Helpers.determine_dtype @type
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/c_function_decl.rb

@@ -0,0 +1,30 @@
+module Rubex
+  module AST
+    module Statement
+      class CFunctionDecl < Base
+        def initialize(type, return_ptr_level, name, arg_list)
+          @type, @return_ptr_level, @name, @arg_list = type, return_ptr_level,
+          name, arg_list
+        end
+
+        def analyse_statement(local_scope, extern: false)
+          @arg_list&.analyse_statement(local_scope, extern: extern)
+          c_name = extern ? @name : (Rubex::C_FUNC_PREFIX + @name)
+          @entry = local_scope.add_c_method(
+            name: @name,
+            c_name: c_name,
+            return_type: Helpers.determine_dtype(@type, @return_ptr_level),
+            arg_list: @arg_list,
+            scope: nil,
+            extern: extern
+          )
+        end
+
+        def generate_code(code, local_scope)
+          super
+          code << "/* C function #{@name} declared.*/" if @entry.extern?
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/c_ptr_decl.rb

@@ -0,0 +1,52 @@
+module Rubex
+  module AST
+    module Statement
+      class CPtrDecl < Base
+        attr_reader :entry, :type
+
+        def initialize(type, name, value, ptr_level, location)
+          super(location)
+          @name = name
+          @type = type
+          @value = value
+          @ptr_level = ptr_level
+        end
+
+        def analyse_statement(local_scope, extern: false)
+          cptr_cname extern
+          @type = Helpers.determine_dtype @type, @ptr_level
+          if @value
+            @value.analyse_for_target_type(@type, local_scope)
+            @value = Helpers.to_lhs_type(self, @value)
+          end
+
+          @entry = local_scope.declare_var name: @name, c_name: @c_name,
+                                           type: @type, value: @value, extern: extern
+        end
+
+        def rescan_declarations(local_scope)
+          base_type = @entry.type.base_type
+          if base_type.is_a? String
+            type = Helpers.determine_dtype base_type, @ptr_level
+            local_scope[@name].type = type
+          end
+        end
+
+        def generate_code(code, local_scope)
+          if @value
+            @value.generate_evaluation_code code, local_scope
+            code << "#{local_scope.find(@name).c_name} = #{@value.c_code(local_scope)};"
+            code.nl
+            @value.generate_disposal_code code
+          end
+        end
+
+        private
+
+        def cptr_cname(extern)
+          @c_name = extern ? @name : Rubex::POINTER_PREFIX + @name
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/c_ptr_decl/c_ptr_func_decl.rb

@@ -0,0 +1,25 @@
+module Rubex
+  module AST
+    module Statement
+      class CPtrFuncDecl < CPtrDecl
+        def initialize(type, name, value, ptr_level, location)
+          super
+        end
+
+        def analyse_statement(local_scope, extern: false)
+          cptr_cname extern
+          ident = @type[:ident]
+          ident[:arg_list].analyse_statement(local_scope)
+          @type = DataType::CFunction.new(
+            @name,
+            @c_name,
+            ident[:arg_list],
+            Helpers.determine_dtype(@type[:dtype], ident[:return_ptr_level]),
+            nil
+          )
+          super
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/c_struct_or_union_def.rb

@@ -0,0 +1,49 @@
+module Rubex
+  module AST
+    module Statement
+      class CStructOrUnionDef < Base
+        attr_reader :name, :declarations, :type, :kind, :entry, :scope
+
+        def initialize(kind, name, declarations, location)
+          super(location)
+          @declarations = declarations
+          if /struct/.match kind
+            @kind = :struct
+          elsif /union/.match kind
+            @kind = :union
+          end
+          @name = name
+        end
+
+        def analyse_statement(outer_scope, extern: false)
+          @scope = Rubex::SymbolTable::Scope::StructOrUnion.new(
+            @name, outer_scope
+          )
+          c_name = if extern
+                     @kind.to_s + " " + @name
+                   else
+                     Rubex::TYPE_PREFIX + @scope.klass_name + "_" + @name
+                   end
+          @type = Rubex::DataType::CStructOrUnion.new(@kind, @name, c_name,
+                                                      @scope)
+
+          @declarations.each do |decl|
+            decl.analyse_statement @scope, extern: extern
+          end
+          Rubex::CUSTOM_TYPES[@name] = @type
+          @entry = outer_scope.declare_sue(name: @name, c_name: c_name,
+                                           type: @type, extern: extern)
+        end
+
+        def generate_code(code, local_scope = nil); end
+
+        def rescan_declarations(_local_scope)
+          @declarations.each do |decl|
+            decl.respond_to?(:rescan_declarations) &&
+              decl.rescan_declarations(@scope)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Rubex
+  module AST
+    module Statement
+      class Expression < Base
+        def initialize(expr, location)
+          super(location)
+          @expr = expr
+        end
+
+        def analyse_statement(local_scope)
+          @expr.analyse_types local_scope
+          @expr.allocate_temps local_scope
+          @expr.release_temps local_scope
+        end
+
+        def generate_code(code, local_scope)
+          super
+          @expr.generate_evaluation_code code, local_scope
+          code << @expr.c_code(local_scope) + ';'
+          code.nl
+          @expr.generate_disposal_code code
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/for.rb

@@ -0,0 +1,73 @@
+module Rubex
+  module AST
+    module Statement
+      class For < Base
+        def initialize(left_expr, left_op, middle, right_op, right_expr, statements, location)
+          super(location)
+          @left_expr = left_expr
+          @left_op = left_op
+          @middle = middle
+          @right_op = right_op
+          @right_expr = right_expr
+          @statements = statements
+        end
+
+        def analyse_statement(local_scope)
+          @left_expr.analyse_types local_scope
+          @right_expr.analyse_types local_scope
+
+          [@left_expr, @right_expr].each do |e|
+            e.allocate_temps local_scope
+          end
+          [@left_expr, @right_expr].each do |e|
+            e.release_temps local_scope
+          end
+
+          @middle = local_scope[@middle] # middle will not be an expr.
+          @statements.each do |stat|
+            stat.analyse_statement local_scope
+          end
+        end
+
+        def generate_code(code, local_scope)
+          code << for_loop_header(code, local_scope)
+          code.block do
+            @statements.each do |stat|
+              stat.generate_code code, local_scope
+            end
+          end
+          @left_expr.generate_disposal_code code
+          @right_expr.generate_disposal_code code
+        end
+
+        private
+
+        def for_loop_header(code, local_scope)
+          @left_expr.generate_evaluation_code code, local_scope
+          @right_expr.generate_evaluation_code code, local_scope
+          for_stmt = ''
+          for_stmt << "for (#{@middle.c_name} = #{@left_expr.c_code(local_scope)}"
+
+          if @left_op == '<'
+            for_stmt << ' + 1'
+          elsif @left_op == '>'
+            for_stmt << ' - 1'
+          end
+
+          for_stmt << "; #{@middle.c_name} #{@right_op} #{@right_expr.c_code(local_scope)}; "
+          for_stmt << (@middle.c_name).to_s
+
+          if ['>', '>='].include? @right_op
+            for_stmt << '--'
+          elsif ['<', '<='].include? @right_op
+            for_stmt << '++'
+          end
+
+          for_stmt << ')'
+
+          for_stmt
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/forward_decl.rb

@@ -0,0 +1,31 @@
+module Rubex
+  module AST
+    module Statement
+      class ForwardDecl < Base
+        def initialize(kind, name, location)
+          super(location)
+          @name = name
+          if /struct/.match kind
+            @kind = :struct
+          elsif /union/.match kind
+            @kind = :union
+          end
+          Rubex::CUSTOM_TYPES[@name] = @name
+        end
+
+        def analyse_statement(local_scope, extern: false)
+          @c_name = Rubex::TYPE_PREFIX + local_scope.klass_name + '_' + @name
+          @type = Rubex::DataType::TypeDef.new("#{@kind} #{@name}", @c_name, @type)
+          local_scope.declare_type type: @type, extern: extern
+        end
+
+        def rescan_declarations(_local_scope)
+          @type = Rubex::DataType::TypeDef.new("#{@kind} #{@name}", @c_name,
+                                               Rubex::CUSTOM_TYPES[@name])
+        end
+
+        def generate_code(code, local_scope); end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/if_block.rb

@@ -0,0 +1,64 @@
+require_relative 'if_block/helper'
+module Rubex
+  module AST
+    module Statement
+      class IfBlock < Base
+        attr_reader :expr, :statements, :if_tail
+        include Rubex::AST::Statement::IfBlock::Helper
+
+        def initialize(expr, statements, if_tail, location)
+          super(location)
+          @expr = expr
+          @statements = statements
+          @if_tail = if_tail
+        end
+
+        def analyse_statement(local_scope)
+          @tail_exprs = if_tail_exprs # FIME: gets current expr too. make descriptive.
+          @tail_exprs.each do |tail|
+            tail.analyse_types local_scope
+            tail.allocate_temps local_scope
+          end
+
+          @tail_exprs.each do |tail|
+            tail.release_temps local_scope
+          end
+          super
+        end
+
+        def if_tail_exprs
+          tail_exprs = []
+          temp = self
+          while temp.respond_to?(:if_tail) &&
+                !temp.is_a?(Rubex::AST::Statement::IfBlock::Else)
+            tail_exprs << temp.expr
+            temp = temp.if_tail
+          end
+
+          tail_exprs
+        end
+
+        def generate_code(code, local_scope)
+          @tail_exprs.each do |tail|
+            tail.generate_evaluation_code(code, local_scope)
+          end
+          generate_code_for_statement 'if', code, local_scope, self
+
+          tail = @if_tail
+          while tail
+            if tail.is_a?(Elsif)
+              generate_code_for_statement 'else if', code, local_scope, tail
+            elsif tail.is_a?(Else)
+              generate_code_for_statement 'else', code, local_scope, tail
+            end
+            tail = tail.if_tail
+          end
+
+          @tail_exprs.each do |tail|
+            tail.generate_disposal_code code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/if_block/else.rb

@@ -0,0 +1,30 @@
+require_relative 'helper'
+module Rubex
+  module AST
+    module Statement
+      class IfBlock < Base
+        class Else < Base
+          attr_reader :statements
+          include Rubex::AST::Statement::IfBlock::Helper
+
+          def initialize(statements, location)
+            super(location)
+            @statements = statements
+          end
+
+          def analyse_statement(local_scope)
+            @statements.each do |stat|
+              stat.analyse_statement local_scope
+            end
+          end
+
+          def generate_code(code, local_scope); end
+
+          def if_tail
+            nil
+          end
+        end
+      end
+    end
+  end
+end