ikra 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 86447e8ed8423243fd4a85d47c6f6193d401456d
+  data.tar.gz: ead0343c4c707bb0ea133943085e6e5ca24f3372
+SHA512:
+  metadata.gz: e9cbfc562bb7529053e755e07763a431b57d802535fa2b5deed201828a07a326bc1ecce7597898d333f1dd9c7a14bbb1eed5bcbf052524f0c6a2bfc8e376fc79
+  data.tar.gz: 4c66b35a3ec55cc68e9f22fe1a7db78bd3e209491fb774f47d0dbccf4bada876966d164a47901cb03e0cb9763489399f60600b0a992265f6a080a4e91615be85

data/lib/ast/builder.rb

@@ -0,0 +1,100 @@
+require_relative "nodes"
+
+module Ikra
+    module AST
+
+        # Builds an Ikra AST from a Parser RubyGem AST
+        module Builder
+            class << self
+                def from_parser_ast(node)
+                    RootNode.new(child: translate_node(node))
+                end
+
+                def translate_node(node)
+                    if node == nil
+                        nil
+                    else
+                        send("translate_#{node.type.to_s}".to_sym, node)
+                    end
+                end
+                
+                def translate_const(node)
+                    # TODO: what is the meaning of the first child?
+                    ConstNode.new(identifier: node.children[1])
+                end
+
+                def translate_int(node)
+                    IntNode.new(value: node.children[0])
+                end
+                
+                def translate_float(node)
+                    FloatNode.new(value: node.children[0])
+                end
+                
+                def translate_bool(node)
+                    BoolNode.new(value: node.children[0])
+                end
+                
+                def translate_lvar(node)
+                    LVarReadNode.new(identifier: node.children[0])
+                end
+                
+                def translate_lvasgn(node)
+                    LVarWriteNode.new(identifier: node.children[0], value: translate_node(node.children[1]))
+                end
+                
+                def translate_ivar(node)
+                    IVarReadNode.new(identifier: node.children[0])
+                end
+
+                def translate_if(node)
+                    IfNode.new(condition: translate_node(node.children[0]),
+                        true_body_stmts: translate_node(node.children[1]),
+                        false_body_stmts: translate_node(node.children[2]))
+                end
+                
+                def extract_begin_single_statement(node, should_return = false)
+                    next_node = node
+                    while next_node.type == :begin
+                        if next_node.children.size != 1
+                            raise "Begin node contains more than one statement"
+                        end
+                        
+                        next_node = next_node.children[0]
+                    end
+                    
+                    next_node
+                end
+                
+                def translate_for(node)
+                    if node.children[0].type == :lvasgn and extract_begin_single_statement(node.children[1]).type == :irange
+                        range = extract_begin_single_statement(node.children[1])
+                        
+                        ForNode.new(iterator_identifier: node.children[0].children[0],
+                            range_from: translate_node(range.children[0]),
+                            range_to: translate_node(range.children[1]),
+                            body_stmts: translate_node(node.children[2]))
+                    else
+                        raise "Can only handle simple For loops at the moment"
+                    end
+                end
+                
+                def translate_break(node)
+                    BreakNode.new
+                end
+                
+                def translate_send(node)
+                    SendNode.new(receiver: translate_node(node.children[0]),
+                        selector: node.children[1],
+                        arguments: node.children[2..-1].map do |arg|
+                            translate_node(arg) end)
+                end
+                
+                def translate_begin(node)
+                    BeginNode.new(body_stmts: node.children.map do |stmt|
+                        translate_node(stmt) end)
+                end
+            end
+        end
+    end
+end

data/lib/ast/lexical_variables_enumerator.rb

@@ -0,0 +1,34 @@
+require "set"
+require_relative "nodes"
+require_relative "visitor"
+
+module Ikra
+    module AST
+
+        # Visitor for determining the names all lexical variables that are accessed by a block (or method??)
+        # TODO: does a method have access to lexical variables?
+        class LexicalVariablesEnumerator < Visitor
+            attr_reader :lexical_variables
+
+            def initialize(lexical_var_names)
+                @lexical_var_names = lexical_var_names
+                @lexical_variables = Set.new
+            end
+
+            def add_lvar_access(identifier)
+                if @lexical_var_names.include?(identifier)
+                    @lexical_variables.add(identifier)
+                end
+            end
+
+            def visit_lvar_read_node(node)
+                add_lvar_access(node.identifier)
+            end
+
+            def visit_lvar_write_node(node)
+                add_lvar_access(node.identifier)
+                super(node)
+            end
+        end
+    end
+end

data/lib/ast/method_definition.rb

@@ -0,0 +1,37 @@
+require "set"
+require_relative "../scope"
+
+module Ikra
+    module AST
+        class MethodDefinition
+            attr_accessor :type                         # receiver type
+            attr_accessor :selector
+            attr_accessor :ast
+            attr_accessor :return_type
+            attr_accessor :callers                      # method definitions calling this method
+            attr_accessor :symbol_table
+            attr_accessor :binding                      # needed for resolving constants
+            attr_accessor :local_variables              # local variables defined in the method (name -> type)
+            attr_accessor :lexical_variables            # lexical variables (defined outside; name -> type)
+            attr_accessor :accessed_lexical_variables   # accessed lexical variables, only these variables are transferred to the GPU. TODO: Do we still need this? This is now determined in symbolic.rb
+            attr_accessor :parameter_variables          # parameters of the method/block (name -> type)
+
+            def initialize(type:, selector:, parameter_variables:, return_type:, ast:)
+                @type = type
+                @selector = selector
+                @parameter_variables = parameter_variables
+                @return_type = return_type
+                @ast = ast
+                @callers = Set.new
+                @symbol_table = Scope.new
+                @local_variables = {}
+                @lexical_variables = {}             # optional
+                @accessed_lexical_variables = {}    # optional
+            end
+
+            def parameter_names
+                type.method_parameters(selector)
+            end
+        end
+    end
+end

data/lib/ast/nodes.rb

@@ -0,0 +1,208 @@
+module Ikra
+    module AST
+        class Node
+            attr_accessor :parent
+
+            def is_begin_node?
+                false
+            end
+
+            def replace(another_node)
+                parent.replace_child(self, another_node)
+            end
+
+            def replace_child(node, another_node)
+                instance_variables.each do |inst_var|
+                    if instance_variable_get(inst_var) == node
+                        instance_variable_set(inst_var, another_node)
+                        another_node.parent = self
+                    end
+                end
+            end
+
+            def class_owner
+                @parent.class_owner
+            end
+        end
+        
+        class RootNode < Node
+            attr_reader :child
+            attr_accessor :class_owner          # @return [Class] The class where this method is defined
+
+            def initialize(child:)
+                @child = child
+                child.parent = self
+            end
+        end
+
+        class ConstNode < Node
+            attr_reader :identifier
+
+            def initialize(identifier:)
+                @identifier = identifier
+            end
+        end
+
+        class LVarReadNode < Node
+            attr_reader :identifier
+            
+            def initialize(identifier:)
+                @identifier = identifier
+            end
+        end
+        
+        class LVarWriteNode < Node
+            attr_reader :identifier
+            attr_reader :value
+            
+            def initialize(identifier:, value:)
+                @identifier = identifier
+                @value = value
+
+                value.parent = self
+            end
+        end
+        
+        class IVarReadNode < Node
+            attr_reader :identifier
+
+            def initialize(identifier:)
+                @identifier = identifier
+            end
+        end
+
+        class IntNode < Node
+            attr_reader :value
+            
+            def initialize(value:)
+                @value = value
+            end
+        end
+        
+        class FloatNode < Node
+            attr_reader :value
+            
+            def initialize(value:)
+                @value = value
+            end
+        end
+        
+        class BoolNode < Node
+            attr_reader :value
+            
+            def initialize(value:)
+                @value = value
+            end
+        end
+        
+        class ForNode < Node
+            attr_reader :iterator_identifier
+            attr_reader :range_from
+            attr_reader :range_to
+            attr_reader :body_stmts
+            
+            def initialize(iterator_identifier:, range_from:, range_to:, body_stmts: BeginNode.new)
+                @iterator_identifier = iterator_identifier
+                @range_from = range_from
+                @range_to = range_to
+                @body_stmts = body_stmts
+
+                range_from.parent = self
+                range_to.parent = self
+                body_stmts.parent = self
+            end
+        end
+        
+        class BreakNode < Node
+        
+        end
+        
+        class IfNode < Node
+            attr_reader :condition
+            attr_reader :true_body_stmts
+            attr_reader :false_body_stmts
+            
+            def initialize(condition:, true_body_stmts:, false_body_stmts: nil)
+                @condition = condition
+                @true_body_stmts = true_body_stmts
+                @false_body_stmts = false_body_stmts
+
+                condition.parent = self
+                true_body_stmts.parent = self
+
+                if false_body_stmts != nil
+                    false_body_stmts.parent = self
+                end
+            end
+        end
+        
+        class BeginNode < Node
+            attr_reader :body_stmts
+            
+            def initialize(body_stmts: [])
+                @body_stmts = body_stmts
+
+                body_stmts.each do |stmt|
+                    stmt.parent = self
+                end
+            end
+            
+            def replace_child(node, another_node)
+                @body_stmts = @body_stmts.map do |stmt|
+                    if node == stmt
+                        another_node.parent = self
+                        another_node
+                    else
+                        stmt
+                    end
+                end
+            end
+
+            def is_begin_node?
+                true
+            end
+        end
+        
+        class SendNode < Node
+            attr_reader :receiver
+            attr_reader :selector
+            attr_reader :arguments
+            
+            def initialize(receiver:, selector:, arguments: [])
+                @receiver = receiver
+                @selector = selector
+                @arguments = arguments
+
+                receiver.parent = self
+                arguments.each do |arg|
+                    arg.parent = self
+                end
+            end
+
+            def replace_child(node, another_node)
+                if @receiver == node
+                    @receiver = another_node
+                end
+
+                @arguments = @arguments.map do |arg|
+                    if node == arg
+                        another_node.parent = self
+                        another_node
+                    else
+                        arg
+                    end
+                end
+            end
+        end
+
+        class ReturnNode < Node
+            attr_reader :value
+
+            def initialize(value:)
+                @value = value
+
+                value.parent = self
+            end
+        end
+    end
+end

data/lib/ast/printer.rb

@@ -0,0 +1,99 @@
+module Ikra
+    module AST
+        class Node
+            def to_s
+                "[Node]"
+            end
+        end
+
+        class RootNode
+            def to_s
+                "[RootNode: #{child.to_s}]"
+            end
+        end
+
+        class ConstNode
+            def to_s
+                "[ConstNode: #{identifier.to_s}]"
+            end
+        end
+
+        class LVarReadNode
+            def to_s
+                "[LVarReadNode: #{identifier.to_s}]"
+            end
+        end
+
+        class LVarWriteNode
+            def to_s
+                "[LVarWriteNode: #{identifier.to_s} := #{value.to_s}]"
+            end
+        end
+
+        class IntNode
+            def to_s
+                "<#{value.to_s}>"
+            end
+        end
+
+        class FloatNode
+            def to_s
+                "<#{value.to_s}>"
+            end
+        end
+
+        class BoolNode
+            def to_s
+                "<#{value.to_s}>"
+            end
+        end
+
+        class ForNode
+            def to_s
+                "[ForNode: #{iterator_identifier.to_s} := #{range_from.to_s}...#{range_to.to_s}, #{body_stmts.to_s}]"
+            end
+        end
+
+        class BreakNode
+            def to_s
+                "[BreakNode]"
+            end
+        end
+
+        class IfNode
+            def to_s
+                if false_body_stmts != nil
+                    "[IfNode: #{condition.to_s}, #{true_body_stmts.to_s}, #{false_body_stmts.to_s}]"
+                else
+                    "[IfNode: #{condition.to_s}, #{true_body_stmts.to_s}]"
+                end
+            end
+        end
+
+        class BeginNode
+            def to_s
+                stmts = body_stmts.map do |stmt|
+                    stmt.to_s
+                end.join(";\n")
+
+                "[BeginNode: {#{stmts}}]"
+            end
+        end
+
+        class SendNode
+            def to_s
+                args = arguments.map do |arg|
+                    arg.to_s
+                end.join("; ")
+
+                "[SendNode: #{receiver.to_s}.#{selector.to_s}(#{args})]"
+            end
+        end
+
+        class ReturnNode
+            def to_s
+                "[ReturnNode: #{value.to_s}]"
+            end
+        end
+    end
+end