first call passes

lib/parser/expression.citrus

@@ -0,0 +1,40 @@
+grammar Expression
+  include Keywords
+
+  rule more_args
+    list:(comma basic_expression )*
+  end
+
+  rule argument_list
+    (left_parenthesis basic_expression? more_args? right_parenthesis){
+        [ capture(:basic_expression).value ]
+        }
+  end
+
+  rule call_site
+    (basic_expression "." name_expression  argument_list space?) {
+      Ast::CallSiteExpression.new(capture(:name_expression).to_str ,
+                          capture(:argument_list).value ,
+                          capture(:basic_expression).value )
+    }
+  end
+
+  rule value_expression
+    call_site | basic_expression
+  end
+
+  rule expression
+#    (simple_return | while_do | conditional | operator_expression | call_site ) >> newline
+    (call_site )  newline
+  end
+
+  rule function_definition
+    keyword_def name:function_name  parameter_list  newline expressions_end  newline
+  end
+
+  rule parameter_list
+    left_parenthesis parameter_list:( name:parameter?  (comma name:parameter)* ) right_parenthesis
+  end
+
+  root call_site
+end

lib/parser/expression.rb

@@ -1,18 +0,0 @@
-module Parser
-  module Expression
-    include output
-    
-    rule(:value_expression) { call_site | basic_type }
-
-    rule(:expression) { (simple_return | while_do | conditional | operator_expression | call_site ) >> newline }
-
-    def delimited_expressions( delimit )
-      ( (delimit.absent? >> expression).repeat(1)).as(:expressions) >> delimit
-    end
-
-    rule(:expressions_do)     { delimited_expressions(keyword_do) }
-    rule(:expressions_else)   { delimited_expressions(keyword_else) }
-    rule(:expressions_end)    { delimited_expressions(keyword_end) }
-
-  end
-end

lib/parser/keywords.rb

@@ -1,28 +0,0 @@
-module Parser
-  module Keywords
-    include output
-    
-    rule(:keyword_begin)  {  str('begin').as(:begin) >> space?}
-    rule(:keyword_class)  {  str('class') >> space? }
-    rule(:keyword_def)    {  str('def') >> space? }
-    rule(:keyword_do)     {  str('do').as(:do) >> space?}
-    rule(:keyword_else)   {  str('else').as(:else) >> space? }
-    rule(:keyword_end)    {  str('end').as(:end) >> space? }  
-    rule(:keyword_false)  {  str('false').as(:false) >> space?}
-    rule(:keyword_if)     {  str('if').as(:if)   >> space? }
-    rule(:keyword_rescue) {  str('rescue').as(:rescue) >> space?}
-    rule(:keyword_return) {  str('return').as(:return) >> space?}
-    rule(:keyword_true)   {  str('true').as(:true) >> space?}
-    rule(:keyword_module) {  str('module') >> space? }
-    rule(:keyword_nil)    {  str('nil').as(:nil) >> space?}
-    rule(:keyword_unless) {  str('unless').as(:unless) >> space?}
-    rule(:keyword_until)  {  str('until').as(:until) >> space?}
-    rule(:keyword_while)  {  str('while').as(:while) >> space?}
-    
-    # this rule is just to make sure identifiers can't be keywords. Kind of duplication here, but we need the 
-    # space in above rules, so just make sure to add any here too.
-    rule(:keyword){ str('begin') | str('def') | str('do') | str('else') | str('end') | 
-                    str('false')| str('if')| str('rescue')| str('true')| str('nil') |
-                    str('unless')| str('until')| str('while')}
-  end
-end

lib/parser/salama.rb

@@ -18,6 +18,7 @@ module Parser
 
   Citrus.require "parser/basic"
   Citrus.require "parser/keywords"
+  Citrus.require "parser/expression"
 
 #  class Salama < output::Parser
 #    include BasicTypes