renamed parser rules for clarity. fixed

lib/parser/composed.rb

@@ -1,5 +1,6 @@
 require_relative "basic_types"
 require_relative "tokens"
+require_relative "keywords"
 
 module Parser
   
@@ -9,39 +10,36 @@ module Parser
   class Composed < Parslet::Parser
     include BasicTypes
     include Tokens
+    include Keywords
     
-    rule(:args) {
+    rule(:argument_list) {
       left_parenthesis >>
-      ((expression.as(:arg) >> (comma >> expression.as(:arg)).repeat(0)).maybe).as(:args) >>
+      ((expression.as(:argument) >> (comma >> expression.as(:argument)).repeat(0)).maybe).as(:argument_list) >>
       right_parenthesis
     }
 
-    rule(:funcall) { name.as(:funcall) >> args }
+    rule(:function_call) { name.as(:function_call) >> argument_list }
 
-    rule(:expression) { cond | funcall | integer | name }
+    rule(:expression) { cond | function_call | integer | name }
 
     rule(:cond) {
-      if_kw >> left_parenthesis >> expression.as(:cond) >> right_parenthesis >>
-        body.as(:if_true) >>
-        else_kw >>
-        body.as(:if_false)
+      keyword_if >> left_parenthesis >> expression.as(:cond) >> right_parenthesis >>
+        block.as(:if_true) >>
+        keyword_else >>
+        block.as(:if_false)
     }
 
-    rule(:body)    { left_brace >> expression.as(:body) >> right_brace }
-    rule(:if_kw)   { str('if')   >> space? }
-    rule(:else_kw) { str('else') >> space? }
+    rule(:block)    { left_brace >> expression.as(:block) >> right_brace }
 
-    rule(:func) {
-      func_kw >> name.as(:func) >> params >> body
+    rule(:function_definition) {
+      keyword_def >> name.as(:function_definition) >> params >> block
     }
 
-    rule(:func_kw) { str('function') >> space? }
-
     rule(:params) {
       left_parenthesis >>
         ((name.as(:param) >> (comma >> name.as(:param)).repeat(0)).maybe).as(:params) >>
       right_parenthesis
     }
-    rule(:root){ func.repeat(0) >> expression | expression | args }
+    rule(:root){ function_definition.repeat(0) >> expression | expression | argument_list }
   end
 end

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)     

lib/vm/nodes.rb

@@ -64,9 +64,9 @@ module Vm
   end
 
   class FunctionExpression < Expression
-    attr_reader  :name, :params, :body
-    def initialize name, params, body
-      @name, @params, @body = name, params, body
+    attr_reader  :name, :params, :block
+    def initialize name, params, block
+      @name, @params, @block = name, params, block
     end
     def eval(context, builder)
       param_names = [params].flatten.map(&:name)
@@ -74,7 +74,7 @@ module Vm
       types = [builder.int] * (param_names.count + 1)
 
       builder.public_static_method(self.name, [], *types) do |method|
-        self.body.eval(context, method)
+        self.block.eval(context, method)
         method.ireturn
       end
     end