commit

main.uzlang

@@ -1,3 +1,11 @@
-ozgaruvchi x -> 5;
-ozgaruvchi y -> 10;
-chiqar x + y;
+ozgaruvchi x -> 10;
+ozgaruvchi y -> 20;
+
+chiqar "Hello, UzLang!";
+
+f qoshish(a | b) {
+    qaytar a + b;
+}
+
+ozgaruvchi son -> qoshish(x | y);
+chiqar son;

src/Main.kt

@@ -19,9 +19,13 @@ fun main() {
         token = lexer.getNextToken()
     }
 
+    println("Tokens: $tokens") // Debug print
+
     val parser = Parser(tokens)
     val program = parser.parse()
 
+    println("Parsed program: $program") // Debug print
+
     val interpreter = Interpreter(program)
     interpreter.interpret()
-}
+}

src/interpreter/Interpreter.kt

@@ -5,35 +5,77 @@ import ast.Number
 
 class Interpreter(private val program: Program) {
     private val variables = mutableMapOf<String, Int>()
+    private val functions = mutableMapOf<String, (List<Int>) -> Int>()
+    private var returnValue: Int? = null
+
+    init {
+        // Define built-in functions here if necessary
+        functions["qoshish"] = { args -> args[0] + args[1] }
+    }
 
     fun interpret() {
-        for (statement in program.statements) {
-            execute(statement)
-        }
+        program.statements.forEach { executeStatement(it) }
     }
 
-    private fun execute(statement: Statement) {
+    private fun executeStatement(statement: Statement) {
         when (statement) {
             is VariableDeclaration -> {
-                val value = evaluate(statement.value)
+                val value = evaluateExpression(statement.value)
                 variables[statement.name] = value
             }
             is PrintStatement -> {
-                val value = evaluate(statement.expression)
+                val value = evaluateExpression(statement.expression)
                 println(value)
             }
+            is IfStatement -> {
+                val condition = evaluateExpression(statement.condition)
+                if (condition != 0) {
+                    executeBlock(statement.ifBranch)
+                } else if (statement.elseBranch != null) {
+                    executeBlock(statement.elseBranch)
+                }
+            }
+            is FunctionDefinition -> {
+                functions[statement.name] = { args ->
+                    // Create a new scope for function execution
+                    val previousVariables = variables.toMap()
+                    statement.parameters.forEachIndexed { index, param ->
+                        variables[param] = args[index]
+                    }
+                    executeBlock(statement.body)
+                    // Capture the return value
+                    val result = returnValue ?: 0
+                    returnValue = null
+                    // Restore previous variable scope
+                    variables.clear()
+                    variables.putAll(previousVariables)
+                    // Return value (if any)
+                    result
+                }
+            }
+            is ReturnStatement -> {
+                returnValue = evaluateExpression(statement.expression)
+            }
+            else -> throw IllegalArgumentException("Unknown statement type: $statement")
+        }
+    }
 
-            is IfStatement -> TODO()
+    private fun executeBlock(block: Block) {
+        block.statements.forEach {
+            executeStatement(it)
+            if (returnValue != null) {
+                return
+            }
         }
     }
 
-    private fun evaluate(expression: Expression): Int {
+    private fun evaluateExpression(expression: Expression): Int {
         return when (expression) {
             is Number -> expression.value
-            is Variable -> variables[expression.name] ?: throw IllegalArgumentException("Undefined variable: ${expression.name}")
+            is Variable -> variables[expression.name] ?: throw IllegalArgumentException("Unknown variable: ${expression.name}")
             is BinaryOperation -> {
-                val left = evaluate(expression.left)
-                val right = evaluate(expression.right)
+                val left = evaluateExpression(expression.left)
+                val right = evaluateExpression(expression.right)
                 when (expression.operator) {
                     "+" -> left + right
                     "-" -> left - right
@@ -42,8 +84,19 @@ class Interpreter(private val program: Program) {
                     else -> throw IllegalArgumentException("Unknown operator: ${expression.operator}")
                 }
             }
-
-            is Number -> TODO()
+            is FunctionCall -> {
+                val function = functions[expression.functionName] ?: throw IllegalArgumentException("Unknown function: ${expression.functionName}")
+                val arguments = expression.arguments.map { evaluateExpression(it) }
+                function(arguments)
+            }
+            is ListExpression -> {
+                expression.elements.size
+            }
+            is StringLiteral -> {
+                println(expression.value)
+                0
+            }
+            else -> throw IllegalArgumentException("Unknown expression type: $expression")
         }
     }
-}
+}