+plugins {

+ kotlin("jvm") version "2.1.0"

+ kotlin("plugin.serialization") version "2.1.0"

+}

+

+group = "me.any"

+version = "1.0-SNAPSHOT"

+

+repositories {

+ mavenCentral()

+}

+

+dependencies {

+ testImplementation(kotlin("test"))

+ implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.8.0-RC")

+

+}

+

+

+tasks.test {

+ useJUnitPlatform()

+}

+kotlin {

+ jvmToolchain(19)

+} \ No newline at end of file

+kotlin.code.style=official

+#!/bin/sh

+

+#

+# Copyright © 2015-2021 the original authors.

+#

+# Licensed under the Apache License, Version 2.0 (the "License");

+# you may not use this file except in compliance with the License.

+# You may obtain a copy of the License at

+#

+# https://www.apache.org/licenses/LICENSE-2.0

+#

+# Unless required by applicable law or agreed to in writing, software

+# distributed under the License is distributed on an "AS IS" BASIS,

+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+# See the License for the specific language governing permissions and

+# limitations under the License.

+#

+

+##############################################################################

+#

+# Gradle start up script for POSIX generated by Gradle.

+#

+# Important for running:

+#

+# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is

+# noncompliant, but you have some other compliant shell such as ksh or

+# bash, then to run this script, type that shell name before the whole

+# command line, like:

+#

+# ksh Gradle

+#

+# Busybox and similar reduced shells will NOT work, because this script

+# requires all of these POSIX shell features:

+# * functions;

+# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,

+# «${var#prefix}», «${var%suffix}», and «$( cmd )»;

+# * compound commands having a testable exit status, especially «case»;

+# * various built-in commands including «command», «set», and «ulimit».

+#

+# Important for patching:

+#

+# (2) This script targets any POSIX shell, so it avoids extensions provided

+# by Bash, Ksh, etc; in particular arrays are avoided.

+#

+# The "traditional" practice of packing multiple parameters into a

+# space-separated string is a well documented source of bugs and security

+# problems, so this is (mostly) avoided, by progressively accumulating

+# options in "$@", and eventually passing that to Java.

+#

+# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,

+# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;

+# see the in-line comments for details.

+#

+# There are tweaks for specific operating systems such as AIX, CygWin,

+# Darwin, MinGW, and NonStop.

+#

+# (3) This script is generated from the Groovy template

+# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt

+# within the Gradle project.

+#

+# You can find Gradle at https://github.com/gradle/gradle/.

+#

+##############################################################################

+

+# Attempt to set APP_HOME

+

+# Resolve links: $0 may be a link

+app_path=$0

+

+# Need this for daisy-chained symlinks.

+while

+ APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path

+ [ -h "$app_path" ]

+do

+ ls=$( ls -ld "$app_path" )

+ link=${ls#*' -> '}

+ case $link in #(

+ /*) app_path=$link ;; #(

+ *) app_path=$APP_HOME$link ;;

+ esac

+done

+

+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit

+

+APP_NAME="Gradle"

+APP_BASE_NAME=${0##*/}

+

+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'

+

+# Use the maximum available, or set MAX_FD != -1 to use that value.

+MAX_FD=maximum

+

+warn () {

+ echo "$*"

+} >&2

+

+die () {

+ echo

+ echo "$*"

+ echo

+ exit 1

+} >&2

+

+# OS specific support (must be 'true' or 'false').

+cygwin=false

+msys=false

+darwin=false

+nonstop=false

+case "$( uname )" in #(

+ CYGWIN* ) cygwin=true ;; #(

+ Darwin* ) darwin=true ;; #(

+ MSYS* | MINGW* ) msys=true ;; #(

+ NONSTOP* ) nonstop=true ;;

+esac

+

+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

+

+

+# Determine the Java command to use to start the JVM.

+if [ -n "$JAVA_HOME" ] ; then

+ if [ -x "$JAVA_HOME/jre/sh/java" ] ; then

+ # IBM's JDK on AIX uses strange locations for the executables

+ JAVACMD=$JAVA_HOME/jre/sh/java

+ else

+ JAVACMD=$JAVA_HOME/bin/java

+ fi

+ if [ ! -x "$JAVACMD" ] ; then

+ die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME

+

+Please set the JAVA_HOME variable in your environment to match the

+location of your Java installation."

+ fi

+else

+ JAVACMD=java

+ which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

+

+Please set the JAVA_HOME variable in your environment to match the

+location of your Java installation."

+fi

+

+# Increase the maximum file descriptors if we can.

+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then

+ case $MAX_FD in #(

+ max*)

+ MAX_FD=$( ulimit -H -n ) ||

+ warn "Could not query maximum file descriptor limit"

+ esac

+ case $MAX_FD in #(

+ '' | soft) :;; #(

+ *)

+ ulimit -n "$MAX_FD" ||

+ warn "Could not set maximum file descriptor limit to $MAX_FD"

+ esac

+fi

+

+# Collect all arguments for the java command, stacking in reverse order:

+# * args from the command line

+# * the main class name

+# * -classpath

+# * -D...appname settings

+# * --module-path (only if needed)

+# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.

+

+# For Cygwin or MSYS, switch paths to Windows format before running java

+if "$cygwin" || "$msys" ; then

+ APP_HOME=$( cygpath --path --mixed "$APP_HOME" )

+ CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

+

+ JAVACMD=$( cygpath --unix "$JAVACMD" )

+

+ # Now convert the arguments - kludge to limit ourselves to /bin/sh

+ for arg do

+ if

+ case $arg in #(

+ -*) false ;; # don't mess with options #(

+ /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath

+ [ -e "$t" ] ;; #(

+ *) false ;;

+ esac

+ then

+ arg=$( cygpath --path --ignore --mixed "$arg" )

+ fi

+ # Roll the args list around exactly as many times as the number of

+ # args, so each arg winds up back in the position where it started, but

+ # possibly modified.

+ #

+ # NB: a `for` loop captures its iteration list before it begins, so

+ # changing the positional parameters here affects neither the number of

+ # iterations, nor the values presented in `arg`.

+ shift # remove old arg

+ set -- "$@" "$arg" # push replacement arg

+ done

+fi

+

+# Collect all arguments for the java command;

+# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of

+# shell script including quotes and variable substitutions, so put them in

+# double quotes to make sure that they get re-expanded; and

+# * put everything else in single quotes, so that it's not re-expanded.

+

+set -- \

+ "-Dorg.gradle.appname=$APP_BASE_NAME" \

+ -classpath "$CLASSPATH" \

+ org.gradle.wrapper.GradleWrapperMain \

+ "$@"

+

+# Use "xargs" to parse quoted args.

+#

+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.

+#

+# In Bash we could simply go:

+#

+# readarray ARGS < <( xargs -n1 <<<"$var" ) &&

+# set -- "${ARGS[@]}" "$@"

+#

+# but POSIX shell has neither arrays nor command substitution, so instead we

+# post-process each arg (as a line of input to sed) to backslash-escape any

+# character that might be a shell metacharacter, then use eval to reverse

+# that process (while maintaining the separation between arguments), and wrap

+# the whole thing up as a single "set" statement.

+#

+# This will of course break if any of these variables contains a newline or

+# an unmatched quote.

+#

+

+eval "set -- $(

+ printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |

+ xargs -n1 |

+ sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |

+ tr '\n' ' '

+ )" '"$@"'

+

+exec "$JAVACMD" "$@"

+@rem

+@rem Copyright 2015 the original author or authors.

+@rem

+@rem Licensed under the Apache License, Version 2.0 (the "License");

+@rem you may not use this file except in compliance with the License.

+@rem You may obtain a copy of the License at

+@rem

+@rem https://www.apache.org/licenses/LICENSE-2.0

+@rem

+@rem Unless required by applicable law or agreed to in writing, software

+@rem distributed under the License is distributed on an "AS IS" BASIS,

+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+@rem See the License for the specific language governing permissions and

+@rem limitations under the License.

+@rem

+

+@if "%DEBUG%" == "" @echo off

+@rem ##########################################################################

+@rem

+@rem Gradle startup script for Windows

+@rem

+@rem ##########################################################################

+

+@rem Set local scope for the variables with windows NT shell

+if "%OS%"=="Windows_NT" setlocal

+

+set DIRNAME=%~dp0

+if "%DIRNAME%" == "" set DIRNAME=.

+set APP_BASE_NAME=%~n0

+set APP_HOME=%DIRNAME%

+

+@rem Resolve any "." and ".." in APP_HOME to make it shorter.

+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi

+

+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.

+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"

+

+@rem Find java.exe

+if defined JAVA_HOME goto findJavaFromJavaHome

+

+set JAVA_EXE=java.exe

+%JAVA_EXE% -version >NUL 2>&1

+if "%ERRORLEVEL%" == "0" goto execute

+

+echo.

+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.

+echo.

+echo Please set the JAVA_HOME variable in your environment to match the

+echo location of your Java installation.

+

+goto fail

+

+:findJavaFromJavaHome

+set JAVA_HOME=%JAVA_HOME:"=%

+set JAVA_EXE=%JAVA_HOME%/bin/java.exe

+

+if exist "%JAVA_EXE%" goto execute

+

+echo.

+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%

+echo.

+echo Please set the JAVA_HOME variable in your environment to match the

+echo location of your Java installation.

+

+goto fail

+

+:execute

+@rem Setup the command line

+

+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar

+

+

+@rem Execute Gradle

+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*

+

+:end

+@rem End local scope for the variables with windows NT shell

+if "%ERRORLEVEL%"=="0" goto mainEnd

+

+:fail

+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of

+rem the _cmd.exe /c_ return code!

+if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1

+exit /b 1

+

+:mainEnd

+if "%OS%"=="Windows_NT" endlocal

+

+:omega

+plugins {

+ id("org.gradle.toolchains.foojay-resolver-convention") version "0.5.0"

+}

+rootProject.name = "llltranspiler"

+

+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

+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

+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")

+ }

+ }

+}