moved nodes to parser (one more layer) and fixed tests. also adds assignment

lib/crystal.rb

@@ -4,5 +4,4 @@ require "asm/program"
 require "elf/object_writer"
 require 'parser/composed'
 require 'parser/transform'
-require 'vm/nodes'
 

lib/parser/basic_types.rb

@@ -6,9 +6,12 @@ module Parser
     include Parslet
     rule(:space)  { match('\s').repeat(1) }
     rule(:space?) { space.maybe }
+    rule(:eol) { (str("\n") >> space?) | any.absent? }
+    
     rule(:double_quote){ str('"') }
     rule(:minus) { str('-') }
     rule(:plus) { str('+') }
+    rule(:equal_sign) { str('=') >> space?}
     rule(:sign) { plus | minus }
     rule(:dot) { str('.') }
     rule(:digit) { match('[0-9]') }

lib/parser/composed.rb

@@ -25,6 +25,8 @@ module Parser
 
     rule(:function_call) { name.as(:function_call) >> argument_list }
 
+    rule(:assignment) { name.as(:asignee) >> equal_sign >> expression.as(:asigned) >> eol }
+
     rule(:expression) { conditional | function_call | integer | name }
 
     def delimited_expressions( delimit )
@@ -36,7 +38,7 @@ module Parser
         delimited_expressions(keyword_else).as(:if_true) >> 
         delimited_expressions(keyword_end).as(:if_false)
     }
-
+    
     rule(:expressions_else)   { delimited_expressions(keyword_else) }
     rule(:expressions_end)    { delimited_expressions(keyword_end) }
 
@@ -51,6 +53,6 @@ module Parser
         ((name.as(:parmeter) >> (comma >> name.as(:parmeter)).repeat(0)).maybe).as(:parmeter_list) >>
       right_parenthesis
     }
-    rule(:root){ function_definition | expression }
+    rule(:root){ function_definition | expression | assignment }
   end
 end

lib/parser/nodes.rb

@@ -1,7 +1,6 @@
-module Vm
-  
+# ast classes
+module Parser
   class Expression
-    # evey Expression has a eval function that returns a value
     def eval 
       raise "abstract"
     end
@@ -24,9 +23,6 @@ module Vm
     def == other
       compare other , [:value]
     end
-    def eval(context, builder)
-      builder.mov "r0" , value
-    end
   end
 
   class NameExpression < Expression
@@ -37,12 +33,6 @@ module Vm
     def == other
       compare other ,  [:name]
     end
-    def eval(context, builder)
-      param_names = context[:params] || []
-      position    = param_names.index(name)
-      raise "Unknown parameter #{name}" unless position
-      builder.iload position
-    end
   end
 
   class FuncallExpression < Expression
@@ -53,11 +43,6 @@ module Vm
     def == other
       compare other , [:name , :args]
     end
-    def eval(context, builder)
-      args.each { |a| a.eval(context, builder) }
-      types = [builder.int] * (args.length + 1)
-      builder.invokestatic builder.class_builder, name, types
-    end
   end
 
   class ConditionalExpression < Expression
@@ -68,21 +53,17 @@ module Vm
     def == other
       compare other , [:cond, :if_true, :if_false]
     end
-    def eval(context, builder)
-      cond.eval context, builder
-
-      builder.ifeq :else
-
-      if_true.eval context, builder
-      builder.goto :endif
-
-      builder.label :else
-      if_false.eval context, builder
-
-      builder.label :endif
-    end
   end
 
+  class AssignmentExpression < Expression
+    attr_reader  :assignee, :assigned
+    def initialize assignee, assigned
+      @assignee, @assigned = assignee, assigned
+    end
+    def == other
+      compare other , [:assignee, :assigned]
+    end
+  end
   class FunctionExpression < Expression
     attr_reader  :name, :params, :block
     def initialize name, params, block
@@ -91,15 +72,5 @@ module Vm
     def == other
       compare other , [:name, :params, :block]
     end
-    def eval(context, builder)
-      param_names = [params].flatten.map(&:name)
-      context[:params] = param_names
-      types = [builder.int] * (param_names.count + 1)
-
-      builder.public_static_method(self.name, [], *types) do |method|
-        self.block.eval(context, method)
-        method.ireturn
-      end
-    end
   end
 end

lib/parser/transform.rb

@@ -1,10 +1,10 @@
 require 'parslet'
-require 'vm/nodes'
+require_relative 'nodes'
 
 module Parser
   class Transform < Parslet::Transform
-    rule(:integer => simple(:value)) { Vm::IntegerExpression.new(value.to_i) }
-    rule(:name   => simple(:name))  { Vm::NameExpression.new(name.to_s) }
+    rule(:integer => simple(:value)) { IntegerExpression.new(value.to_i) }
+    rule(:name   => simple(:name))  { NameExpression.new(name.to_s) }
 
     rule(:argument  => simple(:argument))    { argument  }
     rule(:argument_list => sequence(:argument_list)) { argument_list }
@@ -12,17 +12,17 @@ module Parser
     # need TWO transform rules, for one/many arguments (see the[] wrapping in the first)
     rule(:function_call => simple(:function_call),
           :argument_list    => simple(:argument))   do
-            Vm::FuncallExpression.new(function_call.name, [argument]) 
+            FuncallExpression.new(function_call.name, [argument]) 
           end
     rule( :function_call => simple(:function_call), 
           :argument_list    => sequence(:argument_list)) do
-           Vm::FuncallExpression.new(function_call.name, argument_list) 
+           FuncallExpression.new(function_call.name, argument_list) 
     end
 
     rule(:conditional     => simple(:conditional),
          :if_true  => {:expressions => sequence(:if_true)},
          :if_false => {:expressions => sequence(:if_false)}) do
-           Vm::ConditionalExpression.new(conditional, if_true, if_false) 
+           ConditionalExpression.new(conditional, if_true, if_false) 
          end
 
     rule(:parmeter  => simple(:parmeter))    { parmeter  }
@@ -32,15 +32,18 @@ module Parser
     rule(:function_definition   => simple(:function_definition),
          :parmeter_list => simple(:parmeter),
          :expressions   => sequence(:expressions)) do
-            Vm::FunctionExpression.new(function_definition.name, [parmeter], expressions) 
+            FunctionExpression.new(function_definition.name, [parmeter], expressions) 
           end
 
     rule(:function_definition   => simple(:function_definition),
          :parmeter_list => sequence(:parmeter_list),
          :expressions   => sequence(:expressions)) do
-            Vm::FunctionExpression.new(function_definition.name, parmeter_list, expressions) 
+            FunctionExpression.new(function_definition.name, parmeter_list, expressions) 
           end
     
+    rule(:asignee => simple(:left) , :asigned => simple(:right) ) do
+      AssignmentExpression.new(left.name, right ) 
+    end
     #shortcut to get the ast tree for a given string
     # optional second arguement specifies a rule that will be parsed (mainly for testing)     
     def self.ast string , rule = :root