ikra 0.0.1 → 0.0.2

checksums.yaml

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

data/lib/ast/builder.rb

@@ -3,98 +3,246 @@ 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
+        # Builds an Ikra (Ruby) AST from a Parser RubyGem AST
+        class Builder
+            def self.from_parser_ast(node)
+                return self.new.from_parser_ast(node)
+            end
+
+            def from_parser_ast(node)
+                return RootNode.new(single_child: translate_node(node))
+            end
+
+            protected
 
-                def translate_node(node)
-                    if node == nil
-                        nil
+            def wrap_in_begin(translated_node)
+                if translated_node != nil
+                    if translated_node.is_a?(BeginNode)
+                        # Is already a `BeginNode`
+                        return translated_node
                     else
-                        send("translate_#{node.type.to_s}".to_sym, node)
+                        return BeginNode.new(body_stmts: [translated_node])
                     end
+                else
+                    return nil
                 end
-                
-                def translate_const(node)
-                    # TODO: what is the meaning of the first child?
-                    ConstNode.new(identifier: node.children[1])
-                end
+            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])
+            def translate_node(node)
+                if node == nil
+                    return nil
+                else
+                    if node.is_a?(Array)
+                        # An array of nodes
+                        return node.map do |n|
+                            send("translate_#{n.type.to_s.gsub("-", "_")}".to_sym, n)
+                        end
+                    else
+                        # A single node
+                        return send("translate_#{node.type.to_s.gsub("-", "_")}".to_sym, node)
+                    end
                 end
+            end
+            
+            def translate_array(node)
+                return ArrayNode.new(values: node.children.map do |n| translate_node(n) end)
+            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]
+            def translate_const(node)
+                full_const_string = "#{node.children[1]}"
+                current_const = node
+
+                while current_const.children[0] != nil
+                    # First receiver is enclosing class/module
+                    current_const = current_const.children[0]
+
+                    if current_const.type != :const
+                        raise AssertionError.new("Expected :const")
                     end
-                    
-                    next_node
+
+                    full_const_string = current_const.children[1].to_s + "::" + full_const_string
                 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"
+
+                return ConstNode.new(identifier: full_const_string)
+            end
+
+            def translate_int(node)
+                return IntLiteralNode.new(value: node.children[0])
+            end
+            
+            def translate_float(node)
+                return FloatLiteralNode.new(value: node.children[0])
+            end
+            
+            def translate_bool(node)
+                return BoolLiteralNode.new(value: node.children[0])
+            end
+            
+            def translate_true(node)
+                return BoolLiteralNode.new(value: true)
+            end
+            
+            def translate_false(node)
+                return BoolLiteralNode.new(value: false)
+            end
+
+            def translate_nil(node)
+                return NilLiteralNode.new
+            end
+            
+            def translate_sym(node)
+                return SymbolLiteralNode.new(value: node.children[0])
+            end
+
+            def translate_str(node)
+                return StringLiteralNode.new(value: node.children[0])
+            end
+
+            def translate_hash(node)
+                hash = {}
+
+                node.children.each do |child|
+                    if child.type != :pair
+                        raise NotImplementedError.new("Expected :pair, found #{child.type}")
                     end
+
+                    hash[translate_node(child.children[0])] = translate_node(child.children[1])
                 end
-                
-                def translate_break(node)
-                    BreakNode.new
+
+                return HashNode.new(hash: hash)
+            end
+
+            def translate_and(node)
+                return SendNode.new(receiver: translate_node(node.children[0]),
+                    selector: :"&&",
+                    arguments: [translate_node(node.children[1])])
+            end
+            
+            def translate_or(node)
+                return SendNode.new(receiver: translate_node(node.children[0]),
+                    selector: :"||",
+                    arguments: [translate_node(node.children[1])])
+            end
+            
+            def translate_lvar(node)
+                return LVarReadNode.new(identifier: node.children[0])
+            end
+            
+            def translate_lvasgn(node)
+                return LVarWriteNode.new(identifier: node.children[0], value: translate_node(node.children[1]))
+            end
+            
+            def translate_ivar(node)
+                return IVarReadNode.new(identifier: node.children[0])
+            end
+
+            def translate_if(node)
+                return IfNode.new(condition: translate_node(node.children[0]),
+                    true_body_stmts: wrap_in_begin(translate_node(node.children[1])),
+                    false_body_stmts: wrap_in_begin(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 AssertionError.new("Begin node contains more than one statement")
+                    end
+                    
+                    next_node = next_node.children[0]
                 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)
+                return 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])
+                    
+                    return 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: wrap_in_begin(translate_node(node.children[2])))
+                elsif node.children[0].type == :lvasgn and extract_begin_single_statement(node.children[1]).type == :erange
+                    # Convert exclusive range to inclusive range
+                    range = extract_begin_single_statement(node.children[1])
+                    range_to = translate_node(range.children[1])
+                    range_to_inclusive = SendNode.new(
+                        receiver: range_to,
+                        selector: :-,
+                        arguments: [IntLiteralNode.new(value: 1)])
+
+                    return ForNode.new(iterator_identifier: node.children[0].children[0],
+                        range_from: translate_node(range.children[0]),
+                        range_to: range_to_inclusive,
+                        body_stmts: wrap_in_begin(translate_node(node.children[2])))
+                else
+                    raise NotImplementedError.new("Can only handle simple For loops at the moment")
                 end
-                
-                def translate_begin(node)
-                    BeginNode.new(body_stmts: node.children.map do |stmt|
-                        translate_node(stmt) end)
+            end
+            
+            def translate_while(node)
+                return WhileNode.new(
+                    condition: translate_node(node.children[0]),
+                    body_stmts: wrap_in_begin(translate_node(node.children[1])))
+            end
+            
+            def translate_while_post(node)
+                return WhilePostNode.new(
+                    condition: translate_node(node.children[0]),
+                    body_stmts: wrap_in_begin(translate_node(node.children[1])))
+            end
+            
+            def translate_until(node)
+                return UntilNode.new(
+                    condition: (SendNode.new(receiver: translate_node(node.children[0]),
+                        selector: :^,
+                        arguments: [BoolLiteralNode.new(value: true)])),
+                    body_stmts: wrap_in_begin(translate_node(node.children[1])))
+            end
+            
+            def translate_until_post(node)
+                return UntilPostNode.new(
+                    condition: (SendNode.new(receiver: translate_node(node.children[0]),
+                        selector: :^,
+                        arguments: [BoolLiteralNode.new(value: true)])),
+                    body_stmts: wrap_in_begin(translate_node(node.children[1])))
+            end
+
+            def translate_break(node)
+                return BreakNode.new
+            end
+            
+            def translate_return(node)
+                return ReturnNode.new(value: translate_node(node.children[0]))
+            end
+
+            def translate_send(node)
+                receiver = nil
+
+                if node.children[0] == nil
+                    # Implicit receiver
+                    # TODO: Assuming Object for now, but this is not always correct
+                    receiver = ConstNode.new(identifier: :Object)
+                else
+                    receiver = translate_node(node.children[0])
                 end
+
+                return SendNode.new(receiver: receiver,
+                    selector: node.children[1],
+                    arguments: node.children[2..-1].map do |arg|
+                        translate_node(arg) end)
+            end
+            
+            def translate_begin(node)
+                return BeginNode.new(body_stmts: node.children.map do |stmt|
+                    translate_node(stmt) end)
+            end
+            
+            def translate_kwbegin(node)
+                return BeginNode.new(body_stmts: node.children.map do |stmt|
+                    translate_node(stmt) end)
             end
         end
     end
-end
+end

data/lib/ast/host_section_builder.rb

@@ -0,0 +1,38 @@
+module Ikra
+    module AST
+        class HostSectionBuilder < Builder
+
+            protected
+
+            def translate_block(node)
+                if node.children[0].type != :send
+                    raise AssertionError.new("Unknown AST construct: Send node expected")
+                end
+
+                send_node = node.children[0]
+                built_block_node = BlockDefNode.new(
+                    body: translate_node(node.children[2]),
+                    parameters: translate_node(node.children[1]),
+                    ruby_block: nil)
+
+                if send_node.children[0] == nil && send_node.children[1] == :proc
+                    # Defining a stand-alone block
+                    return built_block_node
+                else
+                    # Block should be part of a message send
+                    built_send_node = translate_node(send_node)
+                    built_send_node.block_argument = built_block_node
+                    return built_send_node
+                end
+            end
+
+            def translate_args(node)
+                return translate_node(node.children)
+            end
+
+            def translate_arg(node)
+                return node.children.first
+            end
+        end
+    end
+end

data/lib/ast/interpreter.rb

@@ -0,0 +1,67 @@
+module Ikra
+    module AST
+        # Executes this AST in the Ruby interpreter. Not possible for all nodes.
+        class Interpreter < Visitor
+            def self.interpret(node)
+                return node.accept(self.new)
+            end
+
+            def visit_int_node(node)
+                return node.value
+            end
+
+            def visit_float_node(node)
+                return node.value
+            end
+
+            def visit_bool_node(node)
+                return node.value
+            end
+
+            def visit_nil_node(node)
+                return nil
+            end
+
+            def visit_symbol_node(node)
+                return node.value
+            end
+
+            def visit_string_node(node)
+                return node.value
+            end
+
+            def visit_array_node(node)
+                return node.values.map do |value|
+                    value.accept(self)
+                end
+            end
+
+            def visit_const_node(node)
+                return node.find_behavior_node.binding.eval(node.identifier)
+            end
+
+            def visit_hash_node(node)
+                result = {}
+
+                node.hash.each do |key, value|
+                    result[key.accept(self)] = value.accept(self)
+                end
+
+                return result
+            end
+
+            def visit_send_node(node)
+                receiver = node.receiver.accept(self)
+                arguments = node.arguments.map do |arg| arg.accept(self) end
+
+                if node.block_argument == nil
+                    return receiver.send(node.selector, *arguments)
+                else
+                    # TODO: Implement
+                    block = receiver.block_argument.accept(self)
+                    return receiver.send(node.selector, *arguments, &block)
+                end
+            end
+        end
+    end
+end

data/lib/ast/lexical_variables_enumerator.rb

@@ -5,8 +5,8 @@ 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?
+        # Visitor for determining the names all lexical variables that are accessed by a block (or method??). Lexical variables that are in scope are determined when translating the Ruby code and passed to this visitor.
+        # TODO(matthias): Does a method have access to lexical variables?
         class LexicalVariablesEnumerator < Visitor
             attr_reader :lexical_variables
 
@@ -15,6 +15,7 @@ module Ikra
                 @lexical_variables = Set.new
             end
 
+            # Register usage of lexical variable
             def add_lvar_access(identifier)
                 if @lexical_var_names.include?(identifier)
                     @lexical_variables.add(identifier)