function calls

Author: murzagalin

src/commonMain/kotlin/com/github/murzagalin/evaluator/ast/Expression.kt

@@ -21,6 +21,11 @@ sealed class Expression {
         val thirdExpression: Expression
     ) : Expression()
 
+    data class FunctionCall(
+        val token: Token.FunctionCall,
+        val arguments: List<Expression>
+    ) : Expression()
+
     data class Terminal(
         val token: Token.Operand
     ) : Expression()

src/commonMain/kotlin/com/github/murzagalin/evaluator/ast/Parser.kt

@@ -5,24 +5,24 @@ import com.github.murzagalin.evaluator.Token
 
 /* the parser uses these rules
 
-* expression -> ternary_if
-* ternary_if -> logic_or ( "?" ternary_if ":" ternary_if )?
-* logic_or   -> logic_and ( ( "or" | "||" ) logic_and )*
-* logic_and  -> equality ( ( "and" | "&&" ) equality )*
-* equality   -> comparison ( ( "!=" | "==" ) comparison )*
-* comparison -> sum ( ( ">" | ">=" | "<" | "<=" ) sum )*
-* sum        -> factor ( ( "-" | "+" ) factor )*
-* factor     -> unary ( ( "/" | "*" | "%") unary )*
-* unary      -> ( "!" | "-" | "+" ) unary | exponent
-* exponent   -> identifier ( "^" unary )*
-- identifier -> function | variable | number | boolean
+expression -> ternary_if
+ternary_if -> logic_or ( "?" ternary_if ":" ternary_if )?
+logic_or   -> logic_and ( ( "or" | "||" ) logic_and )*
+logic_and  -> equality ( ( "and" | "&&" ) equality )*
+equality   -> comparison ( ( "!=" | "==" ) comparison )*
+comparison -> sum ( ( ">" | ">=" | "<" | "<=" ) sum )*
+sum        -> factor ( ( "-" | "+" ) factor )*
+factor     -> unary ( ( "/" | "*" | "%") unary )*
+unary      -> ( "!" | "-" | "+" ) unary | exponent
+exponent   -> identifier ( "^" unary )*
+identifier -> function | variable | number | boolean
 
 function   -> name "(" ( arguments )* ")"
 arguments  -> expression ( ',' expression )*
-* variable   -> name
-* name       -> CHAR ( CHAR | DIGIT )*
-* boolean    -> "true" | "false" | "TRUE" | "FALSE"
-* number     -> DIGIT ( DIGIT )*
+variable   -> name
+name       -> CHAR ( CHAR | DIGIT )*
+boolean    -> "true" | "false" | "TRUE" | "FALSE"
+number     -> DIGIT ( DIGIT )*
 */
 
 class Parser {
@@ -166,6 +166,17 @@ class Parser {
 
         return when (val token = tokens[ix++]) {
             is Token.Operand -> Expression.Terminal(token)
+            is Token.FunctionCall -> {
+                require(tokens[ix++] is Token.Bracket.Left) { "'(' expected after function call" }
+                val arguments = mutableListOf<Expression>()
+                while (tokens[ix] !is Token.Bracket.Right) {
+                    arguments += expression(tokens)
+                    if (tokens[ix] is Token.FunctionCall.Delimiter) ix++
+                }
+                require(tokens[ix] is Token.Bracket.Right) { "expected ')' after a function call" }
+
+                return Expression.FunctionCall(token, arguments)
+            }
             is Token.Bracket.Left -> {
                 val result = expression(tokens)
                 require(tokens[ix++] is Token.Bracket.Right) { "')' expected after expression" }

src/commonTest/kotlin/com/github/murzagalin/evaluator/ast/ParserFunctionsTest.kt

@@ -0,0 +1,81 @@
+package com.github.murzagalin.evaluator.ast
+
+import com.github.murzagalin.evaluator.DefaultFunctions
+import com.github.murzagalin.evaluator.Token
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class ParserFunctionsTest {
+
+    private val subject = Parser()
+
+    @Test
+    fun parse_function_call_without_arguments() {
+        val functionCall = Token.FunctionCall(0, DefaultFunctions.ABS)
+        val expression = listOf(
+            functionCall,
+            Token.Bracket.Left,
+            Token.Bracket.Right
+        )
+
+        assertEquals(
+            Expression.FunctionCall(
+                functionCall,
+                emptyList()
+            ),
+            subject.parse(expression)
+        )
+    }
+
+    @Test
+    fun parse_function_call_with_one_argument() {
+        val functionCall = Token.FunctionCall(1, DefaultFunctions.MIN)
+        val expression = listOf(
+            functionCall,
+            Token.Bracket.Left,
+            Token.Operand.Number(1),
+            Token.Bracket.Right
+        )
+
+        assertEquals(
+            Expression.FunctionCall(
+                functionCall,
+                listOf(Expression.Terminal(Token.Operand.Number(1)))
+            ),
+            subject.parse(expression)
+        )
+    }
+
+    @Test
+    fun parse_function_call_with_several_argument() {
+        val functionCall = Token.FunctionCall(3, DefaultFunctions.MIN)
+        val expression = listOf(
+            functionCall,
+            Token.Bracket.Left,
+            Token.Operand.Number(1),
+            Token.FunctionCall.Delimiter,
+            Token.Operand.Number(2),
+            Token.Operator.Plus,
+            Token.Operand.Number(3),
+            Token.FunctionCall.Delimiter,
+            Token.Operand.Number(4),
+            Token.Bracket.Right
+        )
+
+        assertEquals(
+            Expression.FunctionCall(
+                functionCall,
+                listOf(
+                    Expression.Terminal(Token.Operand.Number(1)),
+                    Expression.Binary(
+                        Token.Operator.Plus,
+                        Expression.Terminal(Token.Operand.Number(2)),
+                        Expression.Terminal(Token.Operand.Number(3))
+                    ),
+                    Expression.Terminal(Token.Operand.Number(4)),
+                )
+            ),
+            subject.parse(expression)
+        )
+    }
+}