fixes in funcalls

src/MoonSharp.Interpreter.Tests/EndToEnd/SimpleTests.cs

@@ -61,6 +61,39 @@ namespace MoonSharp.Interpreter.Tests
 			Assert.AreEqual(DataType.Void, res.Type);
 		}
 
+		[Test]
+		public void CSharpStaticFunctionCall4()
+		{
+			string script = "return callback()();";
+
+			var callback2 = DynValue.NewCallback(new CallbackFunction((_x, a) => { return DynValue.NewNumber(1234.0); }));
+			var callback = DynValue.NewCallback(new CallbackFunction((_x, a) => { return callback2; }));
+
+			var S = new Script();
+			S.Globals.Set("callback", callback);
+
+			DynValue res = S.DoString(script);
+
+			Assert.AreEqual(DataType.Number, res.Type);
+			Assert.AreEqual(1234.0, res.Number);
+		}
+
+		[Test]
+		public void CSharpStaticFunctionCall3()
+		{
+			string script = "return callback();";
+
+			var callback = DynValue.NewCallback(new CallbackFunction((_x, a) => { return DynValue.NewNumber(1234.0); }));
+
+			var S = new Script();
+			S.Globals.Set("callback", callback);
+
+			DynValue res = S.DoString(script);
+
+			Assert.AreEqual(DataType.Number, res.Type);
+			Assert.AreEqual(1234.0, res.Number);
+		}
+
 		[Test]
 		public void CSharpStaticFunctionCall2()
 		{

src/MoonSharp.Interpreter/Tree/Expressions/FunctionCallExpression.cs

@@ -25,8 +25,17 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 			{
 				case TokenType.Brk_Open_Round:
 					lcontext.Lexer.Next();
-					m_Arguments = ExprList(lcontext);
-					CheckMatch(lcontext, "(", TokenType.Brk_Close_Round);
+					Token t = lcontext.Lexer.Current();
+					if (t.Type == TokenType.Brk_Close_Round)
+					{
+						m_Arguments = new List<Expression>();
+						lcontext.Lexer.Next();
+					}
+					else
+					{
+						m_Arguments = ExprList(lcontext);
+						CheckMatch(lcontext, "(", TokenType.Brk_Close_Round);
+					}
 					break;
 				case TokenType.String:
 				case TokenType.String_Long:

src/MoonSharp.Interpreter/Tree/Lexer/Lexer.cs

@@ -35,16 +35,9 @@ namespace MoonSharp.Interpreter.Tree
 			return T;
 		}
 
-		public Token Next()
+		public void Next()
 		{
-			if (m_Current != null)
-			{
-				Token t = m_Current;
-				m_Current = null;
-				return t;
-			}
-			else
-				return LogAndReadToken();
+			m_Current = LogAndReadToken();
 		}
 
 		private void CursorNext()

src/MoonSharp.Interpreter/Tree/Lexer/LexerBackDoor.cs

@@ -19,7 +19,8 @@ namespace MoonSharp.Interpreter.Tree
 			{
 				while (true)
 				{
-					Token tkn = lexer.Next();
+					Token tkn = lexer.Current();
+					lexer.Next();
 					output.Add(tkn.ToString());
 					if (tkn.Type == TokenType.Eof)
 						break;

src/MoonSharp.Interpreter/Tree/Statements/ChunkStatement.cs

@@ -32,14 +32,12 @@ namespace MoonSharp.Interpreter.Tree.Statements
 
 			m_Block = new CompositeStatement(lcontext);
 
-			Token T = lcontext.Lexer.Current();
+			while (lcontext.Lexer.Current().Type == TokenType.SemiColon)
+				lcontext.Lexer.Next();
 
-			while (T.Type == TokenType.SemiColon)
-				T = lcontext.Lexer.Next();
-
-			if (T.Type != TokenType.Eof)
+			if (lcontext.Lexer.Current().Type != TokenType.Eof)
 			{
-				throw new SyntaxErrorException("<eof> expected near '{0}'", T.Text);
+				throw new SyntaxErrorException("<eof> expected near '{0}'", lcontext.Lexer.Current().Text);
 			}
 
 			m_StackFrame = lcontext.Scope.PopFunction();

src/MoonSharp.Interpreter/Tree/__Expression.cs

@@ -36,7 +36,7 @@ namespace MoonSharp.Interpreter.Tree
 		{
 			List<Expression> exps = new List<Expression>();
 
-			while(true)
+			while (true)
 			{
 				exps.Add(Expr(lcontext));
 
@@ -44,7 +44,7 @@ namespace MoonSharp.Interpreter.Tree
 					break;
 
 				lcontext.Lexer.Next();
-			} 
+			}
 
 			return exps; //+++
 		}
@@ -165,30 +165,35 @@ namespace MoonSharp.Interpreter.Tree
 				{
 					case TokenType.Dot:
 						{
-							Token name = lcontext.Lexer.Next();
+							lcontext.Lexer.Next();
+							Token name = lcontext.Lexer.Current();
 							CheckTokenType(name, TokenType.Name);
 							LiteralExpression le = new LiteralExpression(lcontext, DynValue.NewString(name.Text));
 							lcontext.Lexer.Next();
-							return new IndexExpression(e, le, lcontext);
+							e = new IndexExpression(e, le, lcontext);
 						}
+						break;
 					case TokenType.Brk_Open_Square:
 						{
 							lcontext.Lexer.Next(); // skip bracket
 							Expression index = Expr(lcontext);
 							CheckMatch(lcontext, T.Text, TokenType.Brk_Close_Square);
-							return new IndexExpression(e, index, lcontext);
+							e = new IndexExpression(e, index, lcontext);
 						}
+						break;
 					case TokenType.Colon:
-							thisCallName = lcontext.Lexer.Next();
-							CheckTokenType(thisCallName, TokenType.Name);
-							lcontext.Lexer.Next();
-							goto case TokenType.Brk_Open_Round;
+						lcontext.Lexer.Next();
+						thisCallName = lcontext.Lexer.Current();
+						CheckTokenType(thisCallName, TokenType.Name);
+						lcontext.Lexer.Next();
+						goto case TokenType.Brk_Open_Round;
 					case TokenType.Brk_Open_Round:
 					case TokenType.String:
 					case TokenType.String_Long:
 					case TokenType.Brk_Open_Curly:
-							return new FunctionCallExpression(lcontext, e, thisCallName);
-					default: 
+						e = new FunctionCallExpression(lcontext, e, thisCallName);
+						break;
+					default:
 						return e;
 				}
 			}
@@ -226,10 +231,7 @@ namespace MoonSharp.Interpreter.Tree
 			lcontext.Lexer.Next();
 		}
 
-		private static Expression SingleVar(ScriptLoadingContext lcontext)
-		{
-			throw new NotImplementedException();
-		}
+
 
 	}
 }