Вызов функции из объекта или массива

Author: aNNiMON

src/com/annimon/ownlang/parser/Parser.java

@@ -85,7 +85,7 @@ private Statement statement() {
             return functionDefine();
         }
         if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.LPAREN)) {
-            return new FunctionStatement(function());
+            return new FunctionStatement(function(qualifiedName()));
         }
         return assignmentStatement();
     }
@@ -191,11 +191,10 @@ private FunctionDefineStatement functionDefine() {
         return new FunctionDefineStatement(name, argNames, body);
     }
 
-    private FunctionalExpression function() {
+    private FunctionalExpression function(Expression qualifiedNameExpr) {
         // function(arg1, arg2, ...)
-        final String name = consume(TokenType.WORD).getText();
         consume(TokenType.LPAREN);
-        final FunctionalExpression function = new FunctionalExpression(name);
+        final FunctionalExpression function = new FunctionalExpression(qualifiedNameExpr);
         while (!match(TokenType.RPAREN)) {
             function.addArgument(expression());
             match(TokenType.COMMA);
@@ -542,26 +541,39 @@ private Expression primary() {
     }
 
     private Expression variable() {
-        final Token current = get(0);
-        if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.LBRACKET)) {
-            return element();
-        }
         if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.LPAREN)) {
-            return function();
+            return function(new ValueExpression(consume(TokenType.WORD).getText()));
         }
-        if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.DOT)) {
-            return object();
+        final Expression qualifiedNameExpr = qualifiedName();
+        if (qualifiedNameExpr != null) {
+            // variable(args) || arr["key"](args) || obj.key(args)
+            if (lookMatch(0, TokenType.LPAREN)) {
+                return function(qualifiedNameExpr);
+            }
+            return qualifiedNameExpr;
         }
+        
         if (lookMatch(0, TokenType.LBRACKET)) {
             return array();
         }
         if (lookMatch(0, TokenType.LBRACE)) {
             return map();
         }
+        return value();
+    }
+    
+    private Expression qualifiedName() {
+        final Token current = get(0);
+        if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.LBRACKET)) {
+            return element();
+        }
+        if (lookMatch(0, TokenType.WORD) && lookMatch(1, TokenType.DOT)) {
+            return object();
+        }
         if (match(TokenType.WORD)) {
             return new VariableExpression(current.getText());
         }
-        return value();
+        return null;
     }
 
     private Expression value() {

src/com/annimon/ownlang/parser/ast/FunctionalExpression.java

@@ -1,11 +1,7 @@
 package com.annimon.ownlang.parser.ast;
 
-import com.annimon.ownlang.lib.Function;
-import com.annimon.ownlang.lib.FunctionValue;
-import com.annimon.ownlang.lib.Functions;
-import com.annimon.ownlang.lib.Types;
-import com.annimon.ownlang.lib.Value;
-import com.annimon.ownlang.lib.Variables;
+import com.annimon.ownlang.exceptions.VariableDoesNotExistsException;
+import com.annimon.ownlang.lib.*;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -15,19 +11,14 @@
  */
 public final class FunctionalExpression implements Expression {
 
-    public final String name;
+    public final Expression functionExpr;
     public final List<Expression> arguments;
 
-    public FunctionalExpression(String name) {
-        this.name = name;
+    public FunctionalExpression(Expression functionExpr) {
+        this.functionExpr = functionExpr;
         arguments = new ArrayList<>();
     }
 
-    public FunctionalExpression(String name, List<Expression> arguments) {
-        this.name = name;
-        this.arguments = arguments;
-    }
-    
     public void addArgument(Expression arg) {
         arguments.add(arg);
     }
@@ -39,18 +30,30 @@ public Value eval() {
         for (int i = 0; i < size; i++) {
             values[i] = arguments.get(i).eval();
         }
-        return getFunction(name).execute(values);
+        return consumeFunction(functionExpr).execute(values);
+    }
+    
+    private Function consumeFunction(Expression expr) {
+        try {
+            final Value value = expr.eval();
+            if (value.type() == Types.FUNCTION) {
+                return ((FunctionValue) value).getValue();
+            }
+            return getFunction(value.asString());
+        } catch (VariableDoesNotExistsException ex) {
+            return getFunction(ex.getVariable());
+        }
     }
 
     private Function getFunction(String key) {
         if (Functions.isExists(key)) return Functions.get(key);
         if (Variables.isExists(key)) {
-            final Value value = Variables.get(key);
-            if (value.type() == Types.FUNCTION) {
-                return ((FunctionValue)value).getValue();
+            final Value variable = Variables.get(key);
+            if (variable.type() == Types.FUNCTION) {
+                return ((FunctionValue)variable).getValue();
             }
         }
-        throw new RuntimeException("Unknown function " + key);
+        throw new UnknownFunctionException(key);
     }
 
     @Override
@@ -60,6 +63,6 @@ public void accept(Visitor visitor) {
 
     @Override
     public String toString() {
-        return name + "(" + arguments.toString() + ")";
+        return functionExpr + "(" + arguments.toString() + ")";
     }
 }

src/com/annimon/ownlang/parser/visitors/AbstractVisitor.java

@@ -104,6 +104,7 @@ public void visit(FunctionStatement s) {
 
     @Override
     public void visit(FunctionalExpression s) {
+        s.functionExpr.accept(this);
         for (Expression argument : s.arguments) {
             argument.accept(this);
         }