feat: Atom parsing

src/lexer/Lexer.kt

@@ -1,9 +1,7 @@
 package lexer
 
-import java.util.LinkedList
-
 class Lexer(private val source: String) {
-    private var tokens: List<Token> = LinkedList()
+    private var tokens: List<Token> = emptyList()
     private val position = LexerPosition(0, 0, -1)
 
     /**
@@ -14,8 +12,8 @@ class Lexer(private val source: String) {
         while (hasNext()) {
             val char: Char = peek()
             tokens += when {
-                char == '(' -> scanSymbol(TokenType.LEFT_PARENTHESES)
-                char == ')' -> scanSymbol(TokenType.RIGHT_PARENTHESES)
+                char == '(' -> scanSymbol(TokenType.LEFT_PARENTHESIS)
+                char == ')' -> scanSymbol(TokenType.RIGHT_PARENTHESIS)
                 char == '.' -> scanSymbol(TokenType.DOT)
                 char == '"' -> scanQuotedString()
                 char == '%' -> { scanComment(); continue }

src/lexer/TokenType.kt

@@ -2,11 +2,10 @@ package lexer
 
 enum class TokenType {
     ALPHANUMERIC,
+    // TODO Replace with SMALL_LETTER, CAPITAL_LETTER, DIGIT, HEX_DIGIT, ... ?
 
-    LEFT_PARENTHESES, RIGHT_PARENTHESES,
+    LEFT_PARENTHESIS, RIGHT_PARENTHESIS,
     DOT,
 
-    // Operators
-
     EOF
 }

src/parser/Parser.kt

@@ -0,0 +1,116 @@
+package parser
+
+import lexer.Token
+import lexer.TokenType
+import prolog.ast.terms.Atom
+import prolog.ast.terms.Term
+
+class Parser(private val tokens: List<Token>) {
+    private var position: Int = 0
+
+    fun parse(): List<Term> {
+        val terms = mutableListOf<Term>()
+
+        // TODO
+        while (hasNext()) {
+            terms.add(parseTerm())
+        }
+
+        return terms
+    }
+
+    /**
+     * Matches the current token with any of the expected types.
+     *
+     * @param types The list of expected token types.
+     * @return True if the current token matches any of the expected types, false otherwise.
+     */
+    private fun match(types: List<TokenType>): Boolean {
+        for (type in types) {
+            if (check(type)) {
+                next()
+                return true
+            }
+        }
+
+        return false
+    }
+
+    /**
+     * Checks if the current token matches the expected type.
+     */
+    private fun check(type: TokenType): Boolean {
+        return hasNext() && peek().type == type
+    }
+
+    private fun hasNext(): Boolean {
+        // Check if the position is within the tokens list
+        // TODO Check for EOF instead?
+        return position < tokens.size
+    }
+
+    private fun peek(): Token {
+        // Peek should only be called if there is a next token
+        if (!hasNext()) {
+            throw Error("Unexpected end of input")
+        }
+
+        return tokens[position]
+    }
+
+    private fun next(): Token {
+        val token = peek()
+        position++
+        return token
+    }
+
+    private fun previous(): Token {
+        // Previous should only be called if there is a previous token
+        if (position == 0) {
+            throw Error("No previous token")
+        }
+
+        return tokens[position - 1]
+    }
+
+    /* * * * * *
+     * Parsers *
+     * * * * * */
+
+    private fun parseTerm(): Term {
+        // TODO Variable
+        // TODO braced term
+        // TODO Integer Term
+        // TODO Float term
+        // TODO Compound term
+        // TODO Binary operator
+        // TODO Unary operator
+        // TODO list term
+        // TODO curly bracketed term
+        return parseAtom()
+    }
+
+    private fun parseAtom(): Atom {
+        // TODO empty list
+        // TODO empty braces
+
+        return Atom(parseLetterDigit())
+
+        // TODO graphic
+        // TODO quoted
+        // TODO double quoted
+        // TODO back quoted
+        // TODO semicolon
+        // TODO cut
+    }
+
+    private fun parseLetterDigit(): String {
+        // Check if the first character is a lowercase letter
+        if (match(listOf(TokenType.ALPHANUMERIC)) && previous().value[0].isLowerCase()) {
+            return previous().value
+        }
+
+        // TODO How to fix?
+        return ""
+    }
+}

src/prolog/ast/terms/Atom.kt

@@ -13,4 +13,12 @@ open class Atom(val name: String) : Goal(), Head, Body, Resolvent {
     override fun toString(): String {
         return name
     }
+
+    override fun equals(other: Any?): Boolean {
+        return (this === other) || (other is Atom && functor == other.functor)
+    }
+
+    override fun hashCode(): Int {
+        return javaClass.hashCode()
+    }
 }

src/prolog/logic/terms.kt

@@ -1,4 +1,4 @@
-package prolog.builtins
+package prolog.logic
 
 import prolog.ast.terms.Atom
 import prolog.ast.terms.Term