Improved lexical analysis

1 files changed, 46 insertions, 21 deletions

diff --git a/src/runMain/kotlin/Syntax.kt b/src/runMain/kotlin/Syntax.kt
index 8ba809c..54a0ebe 100644
--- a/src/runMain/kotlin/Syntax.kt
+++ b/src/runMain/kotlin/Syntax.kt
@@ -10,26 +10,11 @@ class Syntax {
             removePadding(statement)
             mergeStrings(statement)
             mergeTokens(statement)
+            checkFirst(statement)
             statement.forEach { println("${it.content} ${it.type}") }
             statement.forEachIndexed { j, token ->
-                if (statement.count { it.content == "(" } != statement.count { it.content == ")" })
-                    throw SyntaxError("Bracket", "Brackets are not even", token.lineNumber)
-
-                when (token.type) {
-                    Keyword -> allowNext(statement, j, listOf(Bracket))
-                    Function -> allowNext(statement, j, listOf(Bracket))
-                    Constant -> allowNext(statement, j, listOf(Comparison, Arithmetic, Logical, Bracket))
-                    Assignment -> allowNext(statement, j, listOf(Constant, Function, Variable))
-                    Arithmetic -> allowNext(statement, j, listOf(Constant, Function, Variable))
-                    Comparison -> allowNext(statement, j, listOf(Constant, Function, Variable))
-                    Logical -> allowNext(statement, j, listOf(Constant, Function, Variable))
-                    Variable -> allowNext(statement, j, listOf(Assignment, Bracket, Arithmetic, Logical, Comparison))
-                    Punctuation -> allowNext(statement, j, listOf(Constant))
-                    Bracket -> allowNext(statement, j, listOf(Constant, Keyword, Logical, Assignment, Variable))
-                    Classifier -> Unit
-                    Empty -> Unit
-                    Skip -> throw UnknownType(token.content)
-                }
+                checkBrackets(statement, token)
+                checkNext(statement, token, j)
             }
         }
         return true
@@ -77,19 +62,59 @@ class Syntax {
     }
 
     /**
+     * Specifies which token types are allowed at the beginning of a statement
+     */
+    private fun checkFirst(statement: MutableList<Token>) {
+        val token = statement[0]
+        if (token.type !in listOf(Keyword, Function, Variable))
+            throw SyntaxError(token.type.toString().toLowerCase(), token.content, token.lineNumber)
+    }
+
+    /**
+     * Checks whether the count of brackets is equal
+     */
+    private fun checkBrackets(statement: MutableList<Token>, token: Token) {
+        if (statement.count { it.type == OpenedBracket } != statement.count { it.type == ClosedBracket })
+            throw SyntaxError("Bracket", "Brackets are not even", token.lineNumber)
+    }
+
+    /**
+     * Specifies and checks the tokens which are allowed to follow after [token]
+     */
+    private fun checkNext(statement: MutableList<Token>, token: Token, index: Int) {
+        when (token.type) {
+            Keyword -> allowNext(statement, index, listOf(OpenedBracket))
+            Function -> allowNext(statement, index, listOf(OpenedBracket))
+            Constant -> allowNext(statement, index, listOf(Comparison, Arithmetic, Logical, ClosedBracket, StatementEnd))
+            Assignment -> allowNext(statement, index, listOf(Constant, Function, Variable))
+            Arithmetic -> allowNext(statement, index, listOf(Constant, Function, Variable))
+            Comparison -> allowNext(statement, index, listOf(Constant, Function, Variable))
+            Logical -> allowNext(statement, index, listOf(Constant, Function, Variable))
+            Variable -> allowNext(statement, index, listOf(Assignment, ClosedBracket, Arithmetic, Logical, Comparison))
+            Punctuation -> allowNext(statement, index, listOf(Constant))
+            OpenedBracket -> allowNext(statement, index, listOf(Constant, Variable, ClosedBracket))
+            ClosedBracket -> allowNext(statement, index, listOf(Arithmetic, Comparison, Logical, OpenedBracket, StatementEnd))
+            Classifier -> Unit
+            Empty -> Unit
+            StatementEnd -> Unit
+            Skip -> throw UnknownType(token.content)
+        }
+    }
+
+    /**
      * Throws [SyntaxError] if the next token is not in [allowed]
      */
-    private fun allowNext(statement: MutableList<Token>, index: kotlin.Int, allowed: List<TokenType>) {
+    private fun allowNext(statement: MutableList<Token>, index: Int, allowed: List<TokenType>) {
         if (statement.size > index + 1 && nextNonEmpty(statement, index).type !in allowed) {
             val token = nextNonEmpty(statement, index)
-            throw SyntaxError(token.type.toString(), token.content, token.lineNumber)
+            throw SyntaxError(token.type.toString().toLowerCase(), token.content, token.lineNumber)
         }
     }
 
     /**
      * Finds the next non empty token by [index]
      */
-    private fun nextNonEmpty(statement: MutableList<Token>, index: kotlin.Int): Token {
+    private fun nextNonEmpty(statement: MutableList<Token>, index: Int): Token {
         var i = index + 1
         while (statement[i].type == Empty) i++
         return statement[i]