3 files changed, 268 insertions, 0 deletions
diff --git a/lllars/llltranspiler/src/main/kotlin/Ast.kt b/lllars/llltranspiler/src/main/kotlin/Ast.kt
new file mode 100644
index 0000000..4612dd7
--- /dev/null
+++ b/lllars/llltranspiler/src/main/kotlin/Ast.kt
@@ -0,0 +1,65 @@
+package me.any
+
+import AccessSerializer
+import AddresationSerializer
+import InstructionSerializer
+import kotlinx.serialization.Serializable
+
+@Serializable(with = AccessSerializer::class)
+interface Access
+
+@Serializable
+data class SAccess(val sAddress: Access) : Access
+
+@Serializable
+data class Address(val address: Int) : Access
+
+
+enum class Operation {
+    ADD, SUB, MUL, DIV, AND, OR, XOR
+}
+
+@Serializable(with = AddresationSerializer::class)
+interface Addresation
+
+data class AddressAddresation(val address: Access) : Addresation
+
+
+data class BinaryOperation(
+    val op: Operation,
+    val left: Access,
+    val right: Access
+) : Addresation
+
+interface SysCall
+
+class WriteSysCall : SysCall
+class ReadSysCall : SysCall
+
+enum class BranchPolarity {
+    IFTRUE, IFFALSE
+}
+
+@Serializable(with = InstructionSerializer::class)
+interface Instruction
+
+@Serializable
+data class Comment(val comment: String = "") : Instruction
+
+@Serializable
+data class Write(val target: Int, val source: Addresation) : Instruction
+
+@Serializable
+data class LarsCode(val call: SysCall) : Instruction
+
+@Serializable
+data class Label(val label: String) : Instruction
+
+@Serializable
+data class GoTo(val label: String) : Instruction
+
+@Serializable
+data class Branch(val polarity: BranchPolarity, val address: Address, val label: String) : Instruction
+
+@Serializable
+data class Program(val instructions: List<Instruction>)
+\ No newline at end of file
diff --git a/lllars/llltranspiler/src/main/kotlin/Input.kt b/lllars/llltranspiler/src/main/kotlin/Input.kt
new file mode 100644
index 0000000..338c37d
--- /dev/null
+++ b/lllars/llltranspiler/src/main/kotlin/Input.kt
@@ -0,0 +1,12 @@
+package me.any
+
+
+
+
+const val INPUT = """
+    {
+    "instructions": [{ "comment": " erster kommentar" },{ "comment": " zweite Kommentar" },{ "comment": " dritter Kommentar" },{ "label": "lars" },{ "goto": "lars" },{ "comment": "/sral 0 @lars" },{ "write": { "target": 0, "source": { "access": { "address": 10 } } }},{ "write": { "target": 0, "source": { "binaryOperation": { "a": { "sAddress": { "sAddress": { "address": 10 } } }, "op": "ADD", "b": { "address": 5 } }} }}]
+    
+}
+
+"""
+\ No newline at end of file
diff --git a/lllars/llltranspiler/src/main/kotlin/Main.kt b/lllars/llltranspiler/src/main/kotlin/Main.kt
new file mode 100644
index 0000000..6e247a7
--- /dev/null
+++ b/lllars/llltranspiler/src/main/kotlin/Main.kt
@@ -0,0 +1,191 @@
+import kotlinx.serialization.*
+import kotlinx.serialization.json.*
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+import me.any.*
+
+object AccessSerializer : KSerializer<Access> {
+    override fun deserialize(decoder: Decoder): Access {
+        val jsonDecoder = decoder as JsonDecoder
+        val jsonElement = jsonDecoder.decodeJsonElement() as JsonObject
+        when {
+            "address" in jsonElement.keys -> {
+                return Address(jsonElement["address"]!!.jsonPrimitive.int)
+            }
+
+            "sAddress" in jsonElement.keys -> {
+                return SAccess(
+                    jsonElement["sAddress"]!!.jsonObject["sAddress"]!!.let {
+                        jsonDecoder.json.decodeFromJsonElement<Access>(it)
+                    }
+                )
+            }
+
+            else -> {
+                throw SerializationException("Unknown access")
+            }
+        }
+    }
+
+    override val descriptor: SerialDescriptor
+        get() = PolymorphicSerializer(Access::class).descriptor
+
+    override fun serialize(encoder: Encoder, value: Access) {
+        TODO("Not yet implemented")
+    }
+}
+
+object AddresationSerializer : KSerializer<Addresation> {
+    override val descriptor: SerialDescriptor
+        get() = PolymorphicSerializer(Addresation::class).descriptor
+
+    override fun deserialize(decoder: Decoder): Addresation {
+
+        val jsonDecoder = decoder as JsonDecoder
+        val jsonElement = jsonDecoder.decodeJsonElement() as JsonObject
+        println(jsonElement)
+        when {
+            "access" in jsonElement.keys -> {
+                return AddressAddresation(
+                    jsonElement["access"]!!.let {
+                        jsonDecoder.json.decodeFromJsonElement<Access>(it)
+                    }
+                )
+            }
+
+            "binaryOperation" in jsonElement.keys -> {
+                val binaryOperation = jsonElement["binaryOperation"]!!.jsonObject
+                return BinaryOperation(
+                    Operation.valueOf(binaryOperation["op"]!!.jsonPrimitive.content),
+                    jsonDecoder.json.decodeFromJsonElement<Access>(binaryOperation["a"]!!),
+                    jsonDecoder.json.decodeFromJsonElement<Access>(binaryOperation["b"]!!)
+                )
+            }
+
+
+            else -> {
+                throw SerializationException("Unknown addresation")
+            }
+        }
+    }
+
+    override fun serialize(encoder: Encoder, value: Addresation) {
+        TODO("Not yet implemented")
+    }
+}
+
+object InstructionSerializer : KSerializer<Instruction> {
+    override fun deserialize(decoder: Decoder): Instruction {
+        val jsonDecoder = decoder as JsonDecoder
+        val jsonElement = jsonDecoder.decodeJsonElement() as JsonObject
+        when {
+            "comment" in jsonElement.keys -> {
+                return Comment(jsonElement["comment"]!!.jsonPrimitive.content)
+            }
+
+            "write" in jsonElement.keys -> {
+                val write = jsonElement["write"]!!.jsonObject
+                return Write(
+                    write["target"]!!.jsonPrimitive.int,
+                    jsonDecoder.json.decodeFromJsonElement<Addresation>(write["source"]!!)
+                )
+            }
+
+            "label" in jsonElement.keys -> {
+                return Label(jsonElement["label"]!!.jsonPrimitive.content)
+            }
+
+            "goto" in jsonElement.keys -> {
+                return GoTo(jsonElement["goto"]!!.jsonPrimitive.content)
+            }
+
+            "branch" in jsonElement.keys -> {
+                val branch = jsonElement["branch"]!!.jsonObject
+                return Branch(
+                    BranchPolarity.valueOf(branch["polarity"]!!.jsonPrimitive.content),
+                    jsonDecoder.json.decodeFromJsonElement<Address>(branch["address"]!!),
+                    branch["label"]!!.jsonPrimitive.content
+                )
+            }
+
+            else -> {
+                throw SerializationException("Unknown instruction" + jsonElement.keys)
+            }
+        }
+    }
+
+    override val descriptor: SerialDescriptor
+        get() = PolymorphicSerializer(Instruction::class).descriptor
+
+    override fun serialize(encoder: Encoder, value: Instruction) {
+        TODO("Not yet implemented")
+    }
+}
+
+fun main() {
+    val program = Json.decodeFromString<Program>(INPUT)
+    println(transpileProgram(program))
+}
+
+const val C_RUNTIME = """
+#include <stdio.h>
+
+int main() {
+    void* heap = malloc(1024);
+    %code%
+    return 0;
+}
+"""
+
+fun transpileProgram(program: Program): String {
+    val instructions = program.instructions.joinToString("\n") {
+        when (it) {
+            is Comment -> "// ${it.comment}"
+            is Write -> "heap[${it.target}] = ${transpileAddresation(it.source)};"
+            is Label -> "${it.label}:"
+            is GoTo -> "goto ${it.label};"
+            is Branch -> "if (heap[${transpileAccess(it.address)}] ${if (it.polarity == BranchPolarity.IFFALSE) "!" else ""}= 0) goto ${it.label};"
+            else -> {
+                throw IllegalArgumentException("Unknown instruction")
+            }
+        }
+    }
+
+    return C_RUNTIME.replace("%code%", instructions)
+}
+
+fun transpileAddresation(addresation: Addresation): String {
+    return when (addresation) {
+        is AddressAddresation -> transpileAccess(addresation.address)
+is BinaryOperation -> {
+            val left = transpileAccess(addresation.left)
+            val right = transpileAccess(addresation.right)
+            return when (addresation.op) {
+                Operation.ADD -> "$left + $right"
+                Operation.SUB -> "$left - $right"
+                Operation.MUL -> "$left * $right"
+                Operation.DIV -> "$left / $right"
+                Operation.AND -> "$left & $right"
+                Operation.OR -> "$left | $right"
+                Operation.XOR -> "$left ^ $right"
+            }
+        }
+        else -> {
+            throw IllegalArgumentException("Unknown addresation")
+        }
+    }
+}
+
+fun transpileAddress(address: Address): String {
+    return "&heap[${address.address}]"
+}
+
+fun transpileAccess(access: Access): String {
+    return when (access) {
+        is Address -> transpileAddress(access)
+        is SAccess -> "heap[${transpileAccess(access.sAddress)}]"
+        else -> {
+            throw IllegalArgumentException("Unknown access")
+        }
+    }
+}