Kotlite 和 Kotlite 解释器

val immutableVar = "Hello"
var mutableVar = 42

val immutableVar = "Hello"
var mutableVar = 42

val int: Int = 42
val long: Long = 100L
val double: Double = 3.14
val string: String = "Hello"
val boolean: Boolean = true
val char: Char = 'A'

val int: Int = 42
val long: Long = 100L
val double: Double = 3.14
val string: String = "Hello"
val boolean: Boolean = true
val char: Char = 'A'

fun greet(name: String): String {
    return "Hello, $name!"
}

fun add(a: Int, b: Int): Int = a + b

fun greet(name: String): String {
    return "Hello, $name!"
}

fun add(a: Int, b: Int): Int = a + b

val sum: (Int, Int) -> Int = { a, b -> a + b }
val numbers = listOf(1, 2, 3)
val doubled = numbers.map { it * 2 }

val sum: (Int, Int) -> Int = { a, b -> a + b }
val numbers = listOf(1, 2, 3)
val doubled = numbers.map { it * 2 }

class Person(val name: String, var age: Int) {
    fun greet() {
        println("Hello, my name is $name")
    }
}

object Singleton {
    const val CONSTANT = 42
}

// 类声明支持有限
// 主要用于内置类型和标准库

fun <T> printList(list: List<T>) {
    list.forEach { println(it) }
}

class Box<T>(val item: T)

// 泛型在标准库中可用
val list: List<String> = listOf("a", "b", "c")
val map: Map<String, Int> = mapOf("one" to 1, "two" to 2)

fun String.repeat(count: Int): String {
    return this.repeat(count)
}

// 扩展函数在标准库中可用
"Hello".uppercase()
listOf(1, 2, 3).map { it * 2 }

suspend fun fetchData(): String {
    delay(1000)
    return "Data"
}

fun main() {
    runBlocking {
        println(fetchData())
    }
}

// 不支持协程

val max = if (a > b) a else b

val max = if (a > b) a else b

val result = when (x) {
    0 -> "Zero"
    1 -> "One"
    else -> "Other"
}

val result = when (x) {
    0 -> "Zero"
    1 -> "One"
    else -> "Other"
}

for (i in 0 until 10) { println(i) }
for (item in list) { println(item) }
while (condition) { /* ... */ }
do { /* ... */ } while (condition)

for (i in 0 until 10) { println(i) }
for (item in list) { println(item) }
while (condition) { /* ... */ }
do { /* ... */ } while (condition)

val list = mutableListOf(1, 2, 3)
val map = mutableMapOf("a" to 1, "b" to 2)
val set = mutableSetOf(1, 2, 3)

val list = mutableListOf(1, 2, 3)
val map = mutableMapOf("a" to 1, "b" to 2)
val set = mutableSetOf(1, 2, 3)

val nullable: String? = null
val length = nullable?.length ?: 0

val nullable: String? = null
val length = nullable?.length ?: 0

try {
    // 可能抛出异常的代码
} catch (e: Exception) {
    // 处理异常
} finally {
    // 清理代码
}

try {
    // 可能抛出异常的代码
} catch (e: Exception) {
    // 处理异常
} finally {
    // 清理代码
}

dependencies {
    implementation("io.github.sunny-chung:kotlite-interpreter:<version>")
    implementation("io.github.sunny-chung:kotlite-stdlib:<version>")
    // ...
}

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                api("io.github.sunny-chung:kotlite-interpreter:<version>")
                api("io.github.sunny-chung:kotlite-stdlib:<version>")
                // ...
            }
        }
        // ...

val env = ExecutionEnvironment(
    classRegistrationFilter = {
        it != "MutableList"
    },
    functionRegistrationFilter = {
        !(it.receiverType ?: "").contains("MutableList") &&
            !it.returnType.contains("MutableList")
    },
).apply {
    install(AllStdLibModules())
}

assertFailsWith<SemanticException> {
    KotliteInterpreter(
        filename = "<Test>",
        code = """
            val a = mutableListOf(1, 2, 3)
        """.trimIndent(),
        executionEnvironment = env
    )
}

val env = ExecutionEnvironment().apply {
    install(TextLibModule())
    install(CollectionsLibModule())
    install(ByteLibModule())
}

var hostVar: Int = 0

val env = ExecutionEnvironment().apply {
    registerFunction(CustomFunctionDefinition(
        receiverType = "String",
        functionName = "size",
        returnType = "Int",
        parameterTypes = listOf(CustomFunctionParameter("factor", "Int")),
        executable = { interpreter, receiver, args, typeArgs ->
            IntValue((receiver as StringValue).value.length * (args[0] as IntValue).value, interpreter.symbolTable()).also {
                hostVar = it.value
            }
        },
        position = SourcePosition("MyBridge", 1, 1),
    ))
}

var hostScopeVariable = 0

val env = ExecutionEnvironment().apply {
    registerExtensionProperty(ExtensionProperty(
        declaredName = "f",
        receiver = "String",
        type = "Int",
        getter = { interpreter, subject, typeArgs ->
            IntValue(hostScopeVariable, interpreter.symbolTable())
        },
        setter = { interpreter, subject, value, typeArgs ->
            hostScopeVariable += (value as IntValue).value
        }
    ))
}

val interpreter = KotliteInterpreter(
    filename = "MyScript",
    code = """
        val s = "abcde"
        s.f = 10
        val a = s.f // 10
        s.f = 15
        val b = s.f // 25
    """.trimIndent(),
    executionEnvironment = env,
)
interpreter.eval()

var property = 10

val env = ExecutionEnvironment().apply {
    registerGlobalProperty(GlobalProperty(
        position = SourcePosition("MyScript", 1, 1),
        declaredName = "x",
        type = "Int",
        isMutable = true,
        getter = { interpreter -> IntValue(property, interpreter.symbolTable()) },
        setter = { interpreter, value -> property = (value as IntValue).value },
    ))
    registerGlobalProperty(GlobalProperty(
        position = SourcePosition("Math", 1, 1),
        declaredName = "myPi",
        type = "Double",
        isMutable = false,
        getter = { interpreter -> DoubleValue(3.14, interpreter.symbolTable()) },
    ))
}

{ interpreter: Interpreter, receiver: RuntimeValue?, args: List<RuntimeValue>, typeArgs: Map<String, DataType> ->
    // ...
}

pluginManagement {
    repositories {
        mavenCentral()
        // ...
    }
}

plugins {
    kotlin("multiplatform")
    id("io.github.sunny-chung.kotlite-stdlib-processor-plugin") version "<version>"
}

// ...

kotlin {
    sourceSets {
        val commonMain by getting {
            dependencies {
                // ...
            }
            kotlin.srcDir(tasks.named("kotliteStdlibHeaderProcess").map { it.outputs })
        }

// ...

kotliteStdLibHeaderProcessor {
    inputDir = "src/kotlinheader/"
    outputDir = "build/generated/common/"
    outputPackage = "com.sunnychung.lib.multiplatform.kotlite.stdlib"
    configs = mapOf(
        "Regex" to KotliteModuleConfig(
            imports = listOf(
                "com.sunnychung.lib.multiplatform.kotlite.stdlib.regex.RegexClass",
                "com.sunnychung.lib.multiplatform.kotlite.stdlib.regex.RegexValue",
            )
        ),
    )
}

fun RegexValue(value: Regex, symbolTable: SymbolTable) : DelegatedValue<Regex>
    = DelegatedValue<Regex>(value, "Regex", RegexClass.clazz, symbolTable = symbolTable)

object RegexClass {
     val clazz = ProvidedClassDefinition(
         fullQualifiedName = "Regex",
         typeParameters = emptyList(),
         isInstanceCreationAllowed = true,
         primaryConstructorParameters = listOf(CustomFunctionParameter("value", "String")),
         constructInstance = { interpreter, callArguments, callPosition ->
             RegexValue(Regex((callArguments[0] as StringValue).value), interpreter.symbolTable())
         },
         position = SourcePosition("Regex", 1, 1),
     )
}

fun String.matches(regex: Regex): Boolean
fun String.replace(regex: Regex, replacement: String): String
fun String.replaceFirst(regex: Regex, replacement: String): String
fun String.toRegex(): Regex

val <T> List<T>.size: Int
    get()
val <T> List<T>.lastIndex: Int
    get()

Unresolved directive in Creating Library Modules.adoc - include::../../stdlib/src/commonMain/kotlin/com/sunnychung/lib/multiplatform/kotlite/stdlib/RegexLibModule.kt[]

val env = ExecutionEnvironment().apply {
    registerClass(CustomClass.clazz)
    registerFunction(CustomFunctionDefinition(
        position = SourcePosition.NONE,
        receiverType = "CustomClass",
        functionName = "toString",
        returnType = "String",
        parameterTypes = emptyList(),
        executable = { interpreter, receiver, args, typeArgs ->
            StringValue((receiver as DelegatedValue<*>).value.toString(), interpreter.symbolTable())
        }
    ))
}

fun KInstant.toString(): String

val simpleTypeNode: ASTNode = Parser(Lexer("(anything)", "Double")).type()

val complexTypeNode: ASTNode = Parser(Lexer("(anything)", "Map<String, MutableList<Pair<Int, Double>>>")).type()

val genericTypeNode: ASTNode = Parser(Lexer("(anything)", "Map<K, V>")).type()

val functionTypeNode: ASTNode = Parser(Lexer("(anything)", "Int.(T) -> Unit")).type()

val expressionNode: ASTNode = Parser(Lexer("(anything)", "(1 + 2 * 3) / 4")).expression()

val executionEnvironment = ExecutionEnvironment()
SemanticAnalyzer(
    rootNode = expressionNode,
    executionEnvironment = executionEnvironment,
).analyze()
val result = Interpreter(
    rootNode = expressionNode,
    executionEnvironment = executionEnvironment,
).eval() as IntValue
val intResult: Int = result.value // 1

val console = StringBuilder()
val env = ExecutionEnvironment().apply {
    install(object : IOLibModule() {
        override fun outputToConsole(output: String) {
            console.append(output)
        }
    })
}

val console = StringBuilder()
val env = ExecutionEnvironment().apply {
    install(AllStdLibModules(outputToConsoleFunction = {
        console.append(it)
    }))
}

fun equals(Any?)
fun hashCode()
fun toString()