fix root, much tighter now

lib/parser/salama.rb

@@ -3,7 +3,7 @@ require_relative "compound_types"
 require_relative "tokens"
 require_relative "keywords"
 require_relative "control"
-require_relative "expression"
+require_relative "statement"
 require_relative "call_site"
 require_relative "function_definition"
 require_relative "class_definition"
@@ -25,13 +25,13 @@ module Parser
     include Tokens
     include Keywords
     include Control
-    include Expression
+    include Statement
     include CallSite
     include FunctionDefinition
     include Operators
     include ModuleDef
 
     rule(:root_body)    {( class_definition | function_definition  )}
-    rule(:root)         { root_body.repeat.as(:expression_list) }
+    rule(:root)         { root_body.repeat.as(:statement_list) }
   end
 end

test/cases/root/class_method.tst

@@ -1,15 +1,21 @@
 class FooBo
-  Bar.call(35)
+  int main()
+    Bar.call(35)
+  end
 end
 
 -- -- --
-s(:expressions,
+s(:statements,
   s(:class, :FooBo,
     s(:derives, nil),
-    s(:expressions,
+    s(:statements,
-      s(:call,
+      s(:function, :int,
-        s(:name, :call),
+        s(:name, :main),
-        s(:arguments,
+        s(:parameters),
-          s(:int, 35)),
+        s(:statements,
-        s(:receiver,
+          s(:call,
-          s(:module, "Bar"))))))
+            s(:name, :call),
+            s(:arguments,
+              s(:int, 35)),
+            s(:receiver,
+              s(:class_name, :Bar))))))))

test/cases/root/double_root.tst

@@ -1,19 +1,35 @@
-int foo(ref x)
+class Object
-  a = 5
+  int foo(ref x)
+    a = 5
+  end
 end
+class Other < Object
 
-foo( 3 )
+  int foo()
+    foo( 3 )
+  end
+end
 -- -- --
-s(:expressions,
+s(:statements,
-  s(:function, :int,
+  s(:class, :Object,
-    s(:name, :foo),
+    s(:derives, nil),
-    s(:parameters,
+    s(:statements,
-      s(:parameter, :ref, :x)),
+      s(:function, :int,
-    s(:expressions,
+        s(:name, :foo),
-      s(:assign,
+        s(:parameters,
-        s(:name, :a),
+          s(:parameter, :ref, :x)),
-        s(:int, 5)))),
+        s(:statements,
-  s(:call,
+          s(:assignment,
-    s(:name, :foo),
+            s(:name, :a),
-    s(:arguments,
+            s(:int, 5)))))),
-      s(:int, 3))))
+  s(:class, :Other,
+    s(:derives, :Object),
+    s(:statements,
+      s(:function, :int,
+        s(:name, :foo),
+        s(:parameters),
+        s(:statements,
+          s(:call,
+            s(:name, :foo),
+            s(:arguments,
+              s(:int, 3))))))))

test/cases/root/fibo1.tst

@@ -1,56 +1,67 @@
-int fibonaccit(int n)
+class Object
-  a = 0
+  int fibonaccit(int n)
-  b = 1
+    a = 0
-  while( n > 1 )
+    b = 1
-    tmp = a
+    while( n > 1 )
-    a = b
+      tmp = a
-    b = tmp + b
+      a = b
-    puts(b)
+      b = tmp + b
-    n = n - 1
+      puts(b)
+      n = n - 1
+    end
+  end
+
+  int main()
+    fibonaccit( 10 )
   end
 end
-
-fibonaccit( 10 )
 -- -- --
-s(:expressions,
+s(:statements,
-  s(:function, :int,
+  s(:class, :Object,
-    s(:name, :fibonaccit),
+    s(:derives, nil),
-    s(:parameters,
+    s(:statements,
-      s(:parameter, :int, :n)),
+      s(:function, :int,
-    s(:expressions,
+        s(:name, :fibonaccit),
-      s(:assign,
+        s(:parameters,
-        s(:name, :a),
+          s(:parameter, :int, :n)),
-        s(:int, 0)),
+        s(:statements,
-      s(:assign,
+          s(:assignment,
-        s(:name, :b),
-        s(:int, 1)),
-      s(:while,
-        s(:condition,
-          s(:operator, ">",
-            s(:name, :n),
-            s(:int, 1))),
-        s(:expressions,
-          s(:assign,
-            s(:name, :tmp),
-            s(:name, :a)),
-          s(:assign,
             s(:name, :a),
-            s(:name, :b)),
+            s(:int, 0)),
-          s(:assign,
+          s(:assignment,
             s(:name, :b),
-            s(:operator, "+",
+            s(:int, 1)),
-              s(:name, :tmp),
+          s(:while_statement,
-              s(:name, :b))),
+            s(:condition,
+              s(:operator_value, :>,
+                s(:name, :n),
+                s(:int, 1))),
+            s(:statements,
+              s(:assignment,
+                s(:name, :tmp),
+                s(:name, :a)),
+              s(:assignment,
+                s(:name, :a),
+                s(:name, :b)),
+              s(:assignment,
+                s(:name, :b),
+                s(:operator_value, :+,
+                  s(:name, :tmp),
+                  s(:name, :b))),
+              s(:call,
+                s(:name, :puts),
+                s(:arguments,
+                  s(:name, :b))),
+              s(:assignment,
+                s(:name, :n),
+                s(:operator_value, :-,
+                  s(:name, :n),
+                  s(:int, 1))))))),
+      s(:function, :int,
+        s(:name, :main),
+        s(:parameters),
+        s(:statements,
           s(:call,
-            s(:name, :puts),
+            s(:name, :fibonaccit),
             s(:arguments,
-              s(:name, :b))),
+              s(:int, 10))))))))
-          s(:assign,
-            s(:name, :n),
-            s(:operator, "-",
-              s(:name, :n),
-              s(:int, 1))))))),
-  s(:call,
-    s(:name, :fibonaccit),
-    s(:arguments,
-      s(:int, 10))))