renamed parser rules for clarity. fixed

lib/parser/transform.rb

@@ -6,29 +6,25 @@ module Parser
     rule(:integer => simple(:value)) { Vm::IntegerExpression.new(value.to_i) }
     rule(:name   => simple(:name))  { Vm::NameExpression.new(name.to_s) }
 
-    rule(:arg  => simple(:arg))    { arg  }
-    rule(:args => sequence(:args)) { args }
+    rule(:argument  => simple(:argument))    { argument  }
+    rule(:argument_list => sequence(:argument_list)) { argument_list }
 
-    rule(:funcall => simple(:funcall),
-         :args    => simple(:args))   { Vm::FuncallExpression.new(funcall.name, [args]) }
-
-    rule(:funcall => simple(:funcall),
-         :args    => sequence(:args)) { Vm::FuncallExpression.new(funcall.name, args) }
+    rule(:function_call => simple(:function_call), :argument_list    => sequence(:argument_list)) do
+           Vm::FuncallExpression.new(function_call.name, argument_list) 
+    end
 
     rule(:cond     => simple(:cond),
-         :if_true  => {:body => simple(:if_true)},
-         :if_false => {:body => simple(:if_false)}) { Vm::ConditionalExpression.new(cond, if_true, if_false) }
+         :if_true  => {:block => simple(:if_true)},
+         :if_false => {:block => simple(:if_false)}) { Vm::ConditionalExpression.new(cond, if_true, if_false) }
 
     rule(:param  => simple(:param))    { param  }
     rule(:params => sequence(:params)) { params }
 
-    rule(:func   => simple(:func),
-         :params => simple(:name),
-         :body   => simple(:body)) { Vm::FunctionExpression.new(func.name, [name], body) }
-
-    rule(:func   => simple(:func),
+    rule(:function_definition   => simple(:function_definition),
          :params => sequence(:params),
-         :body   => simple(:body)) { Vm::FunctionExpression.new(func.name, params, body) }
+         :block   => simple(:block)) do
+            Vm::FunctionExpression.new(function_definition.name, params, block) 
+          end
     
     #shortcut to get the ast tree for a given string
     # optional second arguement specifies a rule that will be parsed (mainly for testing)