translator: add function call

translator/src/main/kotlin/org/kotlinnative/translator/FileTranslator.kt

@@ -4,7 +4,6 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.kotlinnative.translator.llvm.LLVMBuilder
 import org.kotlinnative.translator.utils.FunctionDescriptor
-import org.kotlinnative.translator.utils.KtType
 
 class FileTranslator(val state: TranslationState, val file: KtFile) {
 
@@ -22,8 +21,8 @@ class FileTranslator(val state: TranslationState, val file: KtFile) {
                 is KtNamedFunction -> {
                     val function = FunctionCodegen(state, declaration, codeBuilder)
                     state.functions.put(function.name, FunctionDescriptor(
-                            KtType(function.returnType),
+                            function.returnType,
-                            function.args?.map { KtType(it.type) }?.toList() ?: listOf()
+                            function.args?.map { it.type }?.toList() ?: listOf()
                     ))
 
                     function.generate()

translator/src/main/kotlin/org/kotlinnative/translator/FunctionCodegen.kt

@@ -4,18 +4,15 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
 import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.psi.KtBinaryExpression
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.KtBlockExpression
-import org.jetbrains.kotlin.psi.KtConstantExpression
-import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.psiUtil.getNextSiblingIgnoringWhitespaceAndComments
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.kotlinnative.translator.llvm.LLVMBuilder
+import org.kotlinnative.translator.debug.printFunction
-import org.kotlinnative.translator.llvm.LLVMDescriptorGenerate
+import org.kotlinnative.translator.llvm.*
-import org.kotlinnative.translator.llvm.LLVMMapStandardType
-import org.kotlinnative.translator.llvm.LLVMVariable
 import org.kotlinnative.translator.llvm.types.LLVMIntType
+import org.kotlinnative.translator.llvm.types.parseLLVMType
 import org.kotlinnative.translator.utils.FunctionArgument
+import java.util.*
 
 
 class FunctionCodegen(val state: TranslationState, val function: KtNamedFunction, val codeBuilder: LLVMBuilder) {
@@ -44,40 +41,59 @@ class FunctionCodegen(val state: TranslationState, val function: KtNamedFunction
         codeBuilder.addLLVMCode(LLVMDescriptorGenerate(function.fqName.toString(), args, returnType))
     }
 
-
+    private fun expressionWalker(expr: PsiElement?) {
-    private fun expressionWalker(expr: Any?) {
         when (expr) {
-            is KtBlockExpression -> evaluateBlockExpression(expr)
+            is KtBlockExpression -> expressionWalker(expr.firstChild)
-            is PsiElement -> evaluatePsiExpression(expr)
+            is KtProperty -> evaluateLeafPsiElement(expr.firstChild as LeafPsiElement)
-            null -> Unit
+            is PsiElement -> evaluateExpression(expr.firstChild)
+            null -> return
             else -> UnsupportedOperationException()
         }
+
+        expressionWalker(expr?.getNextSiblingIgnoringWhitespaceAndComments())
     }
 
-    private fun evaluateBlockExpression(expr: KtBlockExpression) {
+    private fun evaluateExpression(expr: PsiElement?): LLVMNode? {
-        expressionWalker(expr.firstChild)
-        expressionWalker(expr.getNextSiblingIgnoringWhitespaceAndComments())
-    }
-
-    private fun evaluatePsiExpression(expr: PsiElement) {
-        evaluateExpression(expr.firstChild)
-        evaluatePsiExpression(expr.getNextSiblingIgnoringWhitespaceAndComments() ?: return)
-    }
-
-    private fun evaluateExpression(expr: Any?): LLVMVariable? {
         return when (expr) {
             is KtBinaryExpression -> evaluateBinaryExpression(expr)
+            is KtConstantExpression -> evaluateConstantExpression(expr)
+            is KtCallExpression -> evaluateCallExpression(expr)
             is PsiWhiteSpace -> null
             is PsiElement -> evaluatePsiElement(expr)
-            is KtConstantExpression -> evaluateConstantExpression(expr)
             null -> null
             else -> throw UnsupportedOperationException()
         }
     }
 
-    private fun evaluateBinaryExpression(expr: KtBinaryExpression): LLVMVariable {
+    private fun evaluateCallExpression(expr: KtCallExpression): LLVMNode? {
-        val left = evaluateExpression(expr.firstChild) ?: throw UnsupportedOperationException("Wrong binary exception")
+        val function = expr.firstChild.firstChild
-        val right = evaluateExpression(expr.lastChild) ?: throw UnsupportedOperationException("Wrong binary exception")
+        val descriptor = state.functions[function.text] ?: return null
+        val names = parseArgList(expr
+                .firstChild
+                .getNextSiblingIgnoringWhitespaceAndComments()
+                ?.firstChild)
+
+        return LLVMCall(descriptor.returnType, function.text, descriptor.argTypes.mapIndexed { i: Int, type: String -> LLVMVariable(names[i], parseLLVMType(type)) })
+    }
+
+    private fun parseArgList(argumentList: PsiElement?): List<String> {
+        val args = ArrayList<String>()
+
+        var currentArg = argumentList?.getNextSiblingIgnoringWhitespaceAndComments()
+
+        while (currentArg?.text != ")" && currentArg != null) {
+            args.add(currentArg?.text)
+
+            currentArg = currentArg
+                    ?.getNextSiblingIgnoringWhitespaceAndComments()
+                    ?.getNextSiblingIgnoringWhitespaceAndComments()
+        }
+        return args
+    }
+
+    private fun evaluateBinaryExpression(expr: KtBinaryExpression): LLVMNode {
+        val left = evaluateExpression(expr.firstChild) as LLVMVariable? ?: throw UnsupportedOperationException("Wrong binary exception")
+        val right = evaluateExpression(expr.lastChild) as LLVMVariable? ?: throw UnsupportedOperationException("Wrong binary exception")
         val operator = expr.operationToken
 
         return codeBuilder.addPrimitiveBinaryOperation(operator, left, right)
@@ -100,13 +116,24 @@ class FunctionCodegen(val state: TranslationState, val function: KtNamedFunction
     private fun evaluateLeafPsiElement(element: LeafPsiElement): LLVMVariable? {
         return when (element.elementType) {
             KtTokens.RETURN_KEYWORD -> evaluateReturnInstruction(element)
+            KtTokens.VAL_KEYWORD -> evaluateValExpression(element)
+            KtTokens.VAR_KEYWORD -> evaluateValExpression(element)
             else -> null
         }
     }
 
+    private fun evaluateValExpression(element: LeafPsiElement): LLVMVariable? {
+        val identifier = element.getNextSiblingIgnoringWhitespaceAndComments()
+        val eq = identifier?.getNextSiblingIgnoringWhitespaceAndComments() ?: return null
+
+        val assignExpression = evaluateExpression(eq?.getNextSiblingIgnoringWhitespaceAndComments()) ?: return null
+        codeBuilder.addAssignment(LLVMVariable(identifier!!.text), assignExpression)
+        return null
+    }
+
     private fun evaluateReturnInstruction(element: LeafPsiElement): LLVMVariable? {
-        var next = element.getNextSiblingIgnoringWhitespaceAndComments();
+        var next = element.getNextSiblingIgnoringWhitespaceAndComments()
-        val retVar = evaluateExpression(next)
+        val retVar = evaluateExpression(next) as LLVMVariable
 
         codeBuilder.addLLVMCode("ret i32 ${retVar?.label}")
         return null

translator/src/main/kotlin/org/kotlinnative/translator/TranslationState.kt

@@ -22,7 +22,7 @@ import org.kotlinnative.translator.utils.FunctionDescriptor
 import java.util.*
 
 
-class TranslationState(val sources: List<String>, disposer: Disposable) {
+class TranslationState(sources: List<String>, disposer: Disposable) {
 
     val environment: KotlinCoreEnvironment
     val bindingContext: BindingContext

translator/src/main/kotlin/org/kotlinnative/translator/exceptions/TranslationException.kt

@@ -1,3 +1,3 @@
 package org.kotlinnative.translator.exceptions
 
-class TranslationException : Exception()
+class TranslationException : Exception()

translator/src/main/kotlin/org/kotlinnative/translator/llvm/LLVMBuilder.kt

@@ -33,19 +33,24 @@ class LLVMBuilder {
             KtTokens.PLUS -> "add nsw i32"
             KtTokens.MINUS -> "sub nsw i32"
             KtTokens.MUL -> "mul nsw i32"
-            else -> throw UnsupportedOperationException("Unkbown binary operator")
+            else -> throw UnsupportedOperationException("Unknown binary operator")
         }
 
         llvmCode.appendln("$newVar = $llvmOperator $firstOp, $secondOp")
         return newVar
     }
 
-
     fun clean() {
         llvmCode = StringBuilder()
     }
 
+    fun addAssignment(llvmVariable: LLVMVariable, rhs: LLVMNode) {
+        llvmCode.appendln("%$llvmVariable = $rhs")
+    }
+
     override fun toString(): String {
         return llvmCode.toString()
     }
+
+
 }

translator/src/main/kotlin/org/kotlinnative/translator/llvm/LLVMCall.kt

@@ -0,0 +1,8 @@
+package org.kotlinnative.translator.llvm
+
+class LLVMCall(val returnType: String, val name: String, val arguments: List<LLVMVariable>) : LLVMNode() {
+
+    override fun toString(): String {
+        return "call $returnType $name(${arguments.joinToString { "${it.type} ${it.label}" }})"
+    }
+}

translator/src/main/kotlin/org/kotlinnative/translator/llvm/LLVMExpression.kt

@@ -3,10 +3,12 @@ package org.kotlinnative.translator.llvm
 import org.kotlinnative.translator.llvm.types.LLVMType
 import kotlin.reflect.KFunction0
 
-class LLVMExpression(val variableType: KFunction0<LLVMType>, val llvmCode: String) : LLVMNode() {
+open class LLVMExpression(val variableType: KFunction0<LLVMType>, val llvmCode: String) : LLVMNode() {
+
     fun generateExpression(builder: LLVMBuilder): LLVMVariable {
-        val newVar = builder.getNewVariable(variableType);
+        val newVar = builder.getNewVariable(variableType)
-        builder.addLLVMCode("%$newVar = $llvmCode");
+        builder.addLLVMCode("%$newVar = $llvmCode")
         return newVar
     }
+
 }

translator/src/main/kotlin/org/kotlinnative/translator/llvm/LLVMVariable.kt

@@ -2,9 +2,10 @@ package org.kotlinnative.translator.llvm
 
 import org.kotlinnative.translator.llvm.types.LLVMType
 
-class LLVMVariable(val label: String, val type: LLVMType?) : LLVMNode() {
+class LLVMVariable(val label: String, val type: LLVMType? = null) : LLVMNode() {
 
     override fun toString(): String {
         return label
     }
+
 }

translator/src/main/kotlin/org/kotlinnative/translator/llvm/types/LLVMIntType.kt

@@ -5,9 +5,14 @@ import org.kotlinnative.translator.llvm.LLVMVariable
 
 
 class LLVMIntType() : LLVMType() {
+
     override fun operatorPlus(result: LLVMVariable, firstOp: LLVMVariable, secondOp: LLVMVariable): LLVMExpression {
         //TODO switch by types: int + double = int
         return LLVMExpression(::LLVMIntType, "add nsw i32 $firstOp, $secondOp")
     }
 
+    override fun toString(): String {
+        return "i32"
+    }
+
 }

translator/src/main/kotlin/org/kotlinnative/translator/llvm/types/LLVMType.kt

@@ -1,8 +1,14 @@
 package org.kotlinnative.translator.llvm.types;
 
+import org.kotlinnative.translator.exceptions.TranslationException
 import org.kotlinnative.translator.llvm.LLVMExpression
 import org.kotlinnative.translator.llvm.LLVMVariable
 
 abstract class LLVMType() {
     abstract fun operatorPlus(result: LLVMVariable, firstOp: LLVMVariable, secondOp: LLVMVariable): LLVMExpression;
 }
+
+fun parseLLVMType(type: String): LLVMType = when(type) {
+    "i32" -> LLVMIntType()
+    else -> throw TranslationException()
+}

translator/src/main/kotlin/org/kotlinnative/translator/utils/types.kt

@@ -2,6 +2,4 @@ package org.kotlinnative.translator.utils
 
 data class FunctionArgument(val type: String, val name: String)
 
-data class KtType(val name: String)
+data class FunctionDescriptor(val returnType: String, val argTypes: List<String>)
-
-data class FunctionDescriptor(val returnType: KtType, val argTypes: List<KtType>)