cleanup

Author: murzagalin

src/commonMain/kotlin/com/github/murzagalin/evaluator/Tokenizer.kt

@@ -51,40 +51,32 @@ internal class Tokenizer(
         return when {
             str.startsWith("true") -> PUnit(Token.Operand.Boolean(true), 4)
             str.startsWith("false") -> PUnit(Token.Operand.Boolean(false), 5)
-            str.startsWith("&&") && str.requireOp("&&") -> PUnit(Token.Operator.And, 2)
-            str.startsWith("||") && str.requireOp("||") -> PUnit(Token.Operator.Or, 2)
-            str.startsWith("<=") && str.requireOp("<=") -> PUnit(Token.Operator.LessEqualThan, 2)
-            str.startsWith(">=") && str.requireOp(">=") -> PUnit(Token.Operator.GreaterEqualThan, 2)
-            str.startsWith("==") && str.requireOp("==") -> PUnit(Token.Operator.Equal, 2)
-            str.startsWith("!=") && str.requireOp("!=") -> PUnit(Token.Operator.NotEqual, 2)
+            str.startsWith("&&") -> PUnit(Token.Operator.And, 2)
+            str.startsWith("||") -> PUnit(Token.Operator.Or, 2)
+            str.startsWith("<=") -> PUnit(Token.Operator.LessEqualThan, 2)
+            str.startsWith(">=") -> PUnit(Token.Operator.GreaterEqualThan, 2)
+            str.startsWith("==") -> PUnit(Token.Operator.Equal, 2)
+            str.startsWith("!=") -> PUnit(Token.Operator.NotEqual, 2)
             symbol in digitChars -> str.parseStartingNumber()
             symbol in letterChars -> str.parseVarOrConstOrFunction()
             symbol == argumentsDelimiter -> PUnit(Token.FunctionCall.Delimiter, 1)
-            symbol == '+' && str.requireOp(symbol) -> getPlus(result)
-            symbol == '-' && str.requireOp(symbol) -> getMinus(result)
-            symbol == '%' && str.requireOp(symbol) -> PUnit(Token.Operator.Modulo, 1)
-            symbol == '*' && str.requireOp(symbol) -> PUnit(Token.Operator.Multiplication, 1)
-            symbol == '/' && str.requireOp(symbol) -> PUnit(Token.Operator.Division, 1)
-            symbol == '^' && str.requireOp(symbol) -> PUnit(Token.Operator.Power, 1)
+            symbol == '+' -> getPlus(result)
+            symbol == '-' -> getMinus(result)
+            symbol == '%' -> PUnit(Token.Operator.Modulo, 1)
+            symbol == '*' -> PUnit(Token.Operator.Multiplication, 1)
+            symbol == '/' -> PUnit(Token.Operator.Division, 1)
+            symbol == '^' -> PUnit(Token.Operator.Power, 1)
             symbol == ')' -> PUnit(Token.Bracket.Right, 1)
-            symbol == '(' && str.requireOp(symbol) -> PUnit(Token.Bracket.Left, 1)
-            symbol == '<' && str.requireOp(symbol) -> PUnit(Token.Operator.LessThan, 1)
-            symbol == '>' && str.requireOp(symbol) -> PUnit(Token.Operator.GreaterThan, 1)
-            symbol == '!' && str.requireOp(symbol) -> PUnit(Token.Operator.Not, 1)
-            symbol == '?' && str.requireOp(symbol) -> PUnit(Token.Operator.TernaryIf, 1)
-            symbol == ':' && str.requireOp(symbol) -> PUnit(Token.Operator.TernaryElse, 1)
+            symbol == '(' -> PUnit(Token.Bracket.Left, 1)
+            symbol == '<' -> PUnit(Token.Operator.LessThan, 1)
+            symbol == '>' -> PUnit(Token.Operator.GreaterThan, 1)
+            symbol == '!' -> PUnit(Token.Operator.Not, 1)
+            symbol == '?' -> PUnit(Token.Operator.TernaryIf, 1)
+            symbol == ':' -> PUnit(Token.Operator.TernaryElse, 1)
             else -> null
         }
     }
 
-    private fun String.requireOp(str: String): Boolean {
-        require(length > str.length) { "Malformed expression. '$str' requires operand after it" }
-
-        return true
-    }
-
-    private fun String.requireOp(c: Char) = requireOp(c.toString())
-
     private fun getPlus(result: List<Token>) = PUnit(
         if (supposedToBeUnaryOperator(result)) Token.Operator.UnaryPlus else Token.Operator.Plus,
         1

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

@@ -3,17 +3,16 @@ package com.github.murzagalin.evaluator.ast
 import com.github.murzagalin.evaluator.Token
 
 /*
-expression -> ternary_if
-ternary_if -> logic_or ( "?" ternary_if ":" ternary_if )?
-logic_or   -> logic_and ( ( "or" | "||" ) logic_and )*
-logic_and  -> equality ( ( "and" | "&&" ) equality )*
+expression -> logic_or ( "?" expression ":" expression )?
+logic_or   -> logic_and ( "||" logic_and )*
+logic_and  -> equality ( "&&" equality )*
 equality   -> comparison ( ( "!=" | "==" ) comparison )*
 comparison -> sum ( ( ">" | ">=" | "<" | "<=" ) sum )*
 sum        -> factor ( ( "-" | "+" ) factor )*
 factor     -> unary ( ( "/" | "*" | "%") unary )*
 unary      -> ( "!" | "-" | "+" ) unary | exponent
-exponent   -> identifier ( "^" unary )*
-identifier -> function | variable | number | boolean
+exponent   -> terminal ( "^" unary )*
+terminal -> function | variable | number | boolean
 
 function   -> name "(" ( arguments )* ")"
 arguments  -> expression ( ',' expression )*
@@ -44,21 +43,20 @@ internal class Parser {
 
     fun parse(tokens: List<Token>): Expression {
         ix = 0
-        return expression(tokens)
-    }
+        val expression = expression(tokens)
+        require(ix == tokens.size) { "malformed expression" }
 
-    fun expression(tokens: List<Token>): Expression {
-        return ternaryIf(tokens)
+        return expression
     }
 
-    private fun ternaryIf(tokens: List<Token>): Expression {
+    private fun expression(tokens: List<Token>): Expression {
         val first = logicOr(tokens)
 
         if (ix < tokens.size && tokens[ix] is Token.Operator.TernaryIf) {
             ix++
-            val second = ternaryIf(tokens)
+            val second = expression(tokens)
             require(tokens[ix++] is Token.Operator.TernaryElse) { "':' expected in ternary-if-else expression" }
-            val third = ternaryIf(tokens)
+            val third = expression(tokens)
 
             return Expression.Ternary(Token.Operator.TernaryIfElse, first, second, third)
         }
@@ -149,17 +147,17 @@ internal class Parser {
     }
 
     private fun exponent(tokens: List<Token>): Expression {
-        var identifier = identifier(tokens)
+        var terminal = terminal(tokens)
 
         if (ix < tokens.size && tokens[ix] is Token.Operator.Power) {
             ix++
-            identifier = Expression.Binary(Token.Operator.Power, identifier, unary(tokens))
+            terminal = Expression.Binary(Token.Operator.Power, terminal, unary(tokens))
         }
 
-        return identifier
+        return terminal
     }
 
-    private fun identifier(tokens: List<Token>): Expression {
+    private fun terminal(tokens: List<Token>): Expression {
         require(tokens.size > ix) { "Expression expected" }
 
         return when (val token = tokens[ix++]) {
@@ -173,7 +171,7 @@ internal class Parser {
                 }
                 require(tokens[ix++] is Token.Bracket.Right) { "expected ')' after a function call" }
 
-                return Expression.FunctionCall(token, arguments)
+                Expression.FunctionCall(token, arguments)
             }
             is Token.Bracket.Left -> {
                 val result = expression(tokens)