Files
lyng/lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt
T

622 lines
24 KiB
Kotlin

/*
* Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
*
* 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
*
* http://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.
*
*/
package net.sergeych.lyng
import kotlinx.coroutines.delay
import kotlinx.coroutines.yield
import net.sergeych.lyng.Script.Companion.defaultImportManager
import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.rootLyng
import net.sergeych.lynon.ObjLynonClass
import net.sergeych.mp_tools.globalDefer
import kotlin.math.*
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
class Script(
override val pos: Pos,
private val statements: List<Statement> = emptyList(),
private val moduleSlotPlan: Map<String, Int> = emptyMap(),
private val importBindings: Map<String, ImportBinding> = emptyMap(),
private val importedModules: List<ImportBindingSource.Module> = emptyList(),
// private val catchReturn: Boolean = false,
) : Statement() {
override suspend fun execute(scope: Scope): Obj {
val isModuleScope = scope is ModuleScope
val shouldSeedModule = isModuleScope || scope.thisObj === ObjVoid
val moduleTarget = scope
if (moduleSlotPlan.isNotEmpty() && shouldSeedModule) {
val hasPlanMapping = moduleSlotPlan.keys.any { moduleTarget.getSlotIndexOf(it) != null }
val needsReset = moduleTarget is ModuleScope ||
moduleTarget.slotCount() == 0 ||
moduleTarget.hasSlotPlanConflict(moduleSlotPlan) ||
(!hasPlanMapping && moduleTarget.slotCount() > 0)
if (needsReset) {
val preserved = LinkedHashMap<String, ObjRecord>()
for (name in moduleSlotPlan.keys) {
moduleTarget.getLocalRecordDirect(name)?.let { preserved[name] = it }
}
moduleTarget.applySlotPlanReset(moduleSlotPlan, preserved)
for (name in moduleSlotPlan.keys) {
if (preserved.containsKey(name)) continue
val inherited = findSeedRecord(moduleTarget.parent, name)
if (inherited != null && inherited.value !== ObjUnset) {
moduleTarget.updateSlotFor(name, inherited)
}
}
} else {
moduleTarget.applySlotPlan(moduleSlotPlan)
for (name in moduleSlotPlan.keys) {
val local = moduleTarget.getLocalRecordDirect(name)
if (local != null && local.value !== ObjUnset) {
moduleTarget.updateSlotFor(name, local)
continue
}
val inherited = findSeedRecord(moduleTarget.parent, name)
if (inherited != null && inherited.value !== ObjUnset) {
moduleTarget.updateSlotFor(name, inherited)
}
}
}
}
if (shouldSeedModule) {
seedModuleSlots(moduleTarget)
}
var lastResult: Obj = ObjVoid
for (s in statements) {
lastResult = s.execute(scope)
}
return lastResult
}
private suspend fun seedModuleSlots(scope: Scope) {
if (importBindings.isEmpty() && importedModules.isEmpty()) return
seedImportBindings(scope)
}
private suspend fun seedImportBindings(scope: Scope) {
val provider = scope.currentImportProvider
val importedModules = LinkedHashSet<ModuleScope>()
for (moduleRef in this.importedModules) {
importedModules.add(provider.prepareImport(moduleRef.pos, moduleRef.name, null))
}
if (scope is ModuleScope) {
scope.importedModules = importedModules.toList()
}
for ((name, binding) in importBindings) {
val record = when (val source = binding.source) {
is ImportBindingSource.Module -> {
val module = provider.prepareImport(source.pos, source.name, null)
importedModules.add(module)
module.objects[binding.symbol]?.takeIf { it.visibility.isPublic }
?: scope.raiseSymbolNotFound("symbol ${source.name}.${binding.symbol} not found")
}
ImportBindingSource.Root -> {
provider.rootScope.objects[binding.symbol]?.takeIf { it.visibility.isPublic }
?: scope.raiseSymbolNotFound("symbol ${binding.symbol} not found")
}
ImportBindingSource.Seed -> {
findSeedRecord(scope, binding.symbol)
?: scope.raiseSymbolNotFound("symbol ${binding.symbol} not found")
}
}
if (name == "Exception" && record.value !is ObjClass) {
scope.updateSlotFor(name, ObjRecord(ObjException.Root, isMutable = false))
} else {
scope.updateSlotFor(name, record)
}
}
for (module in importedModules) {
for ((cls, map) in module.extensions) {
for ((symbol, record) in map) {
if (record.visibility.isPublic) {
scope.addExtension(cls, symbol, record)
}
}
}
}
}
private fun findSeedRecord(scope: Scope?, name: String): ObjRecord? {
var s = scope
var hops = 0
while (s != null && hops++ < 1024) {
s.objects[name]?.let { return it }
s.localBindings[name]?.let { return it }
s.getSlotIndexOf(name)?.let { idx ->
val rec = s.getSlotRecord(idx)
if (rec.value !== ObjUnset) return rec
}
s = s.parent
}
return null
}
private fun resolveModuleScope(scope: Scope): ModuleScope? {
var current: Scope? = scope
while (current != null) {
if (current is ModuleScope) return current
current = current.parent
}
return null
}
internal fun debugStatements(): List<Statement> = statements
suspend fun execute() = execute(
defaultImportManager.newStdScope()
)
companion object {
/**
* Create new scope using standard safe set of modules, using [defaultImportManager]. It is
* suspended as first time calls requires compilation of standard library or other
* asynchronous initialization.
*/
suspend fun newScope(pos: Pos = Pos.builtIn) = defaultImportManager.newStdScope(pos)
internal val rootScope: Scope = Scope(null).apply {
ObjException.addExceptionsToContext(this)
addConst("Unset", ObjUnset)
addFn("print") {
for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.toString(this).value)
else print(a.toString(this).value)
}
ObjVoid
}
addFn("println") {
for ((i, a) in args.withIndex()) {
if (i > 0) print(' ' + a.toString(this).value)
else print(a.toString(this).value)
}
println()
ObjVoid
}
addFn("call") {
val callee = args.list.firstOrNull()
?: raiseError("call requires a callable as the first argument")
val rest = if (args.list.size > 1) {
Arguments(args.list.drop(1))
} else {
Arguments.EMPTY
}
callee.callOn(createChildScope(pos, args = rest))
}
addFn("floor") {
val x = args.firstAndOnly()
(if (x is ObjInt) x
else ObjReal(floor(x.toDouble())))
}
addFn("ceil") {
val x = args.firstAndOnly()
(if (x is ObjInt) x
else ObjReal(ceil(x.toDouble())))
}
addFn("round") {
val x = args.firstAndOnly()
(if (x is ObjInt) x
else ObjReal(round(x.toDouble())))
}
addFn("sin") {
ObjReal(sin(args.firstAndOnly().toDouble()))
}
addFn("cos") {
ObjReal(cos(args.firstAndOnly().toDouble()))
}
addFn("tan") {
ObjReal(tan(args.firstAndOnly().toDouble()))
}
addFn("asin") {
ObjReal(asin(args.firstAndOnly().toDouble()))
}
addFn("acos") {
ObjReal(acos(args.firstAndOnly().toDouble()))
}
addFn("atan") {
ObjReal(atan(args.firstAndOnly().toDouble()))
}
addFn("sinh") {
ObjReal(sinh(args.firstAndOnly().toDouble()))
}
addFn("cosh") {
ObjReal(cosh(args.firstAndOnly().toDouble()))
}
addFn("tanh") {
ObjReal(tanh(args.firstAndOnly().toDouble()))
}
addFn("asinh") {
ObjReal(asinh(args.firstAndOnly().toDouble()))
}
addFn("acosh") {
ObjReal(acosh(args.firstAndOnly().toDouble()))
}
addFn("atanh") {
ObjReal(atanh(args.firstAndOnly().toDouble()))
}
addFn("exp") {
ObjReal(exp(args.firstAndOnly().toDouble()))
}
addFn("ln") {
ObjReal(ln(args.firstAndOnly().toDouble()))
}
addFn("log10") {
ObjReal(log10(args.firstAndOnly().toDouble()))
}
addFn("log2") {
ObjReal(log2(args.firstAndOnly().toDouble()))
}
addFn("pow") {
requireExactCount(2)
ObjReal(
(args[0].toDouble()).pow(args[1].toDouble())
)
}
addFn("sqrt") {
ObjReal(
sqrt(args.firstAndOnly().toDouble())
)
}
addFn("abs") {
val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue) else ObjReal(x.toDouble().absoluteValue)
}
addFnDoc(
"clamp",
doc = "Clamps the value within the specified range. If the value is outside the range, it is set to the nearest boundary. Respects inclusive/exclusive range ends.",
params = listOf(ParamDoc("value"), ParamDoc("range")),
moduleName = "lyng.stdlib"
) {
val value = requiredArg<Obj>(0)
val range = requiredArg<ObjRange>(1)
var result = value
if (range.start != null && !range.start.isNull) {
if (result.compareTo(this, range.start) < 0) {
result = range.start
}
}
if (range.end != null && !range.end.isNull) {
val cmp = range.end.compareTo(this, result)
if (range.isEndInclusive) {
if (cmp < 0) result = range.end
} else {
if (cmp <= 0) {
if (range.end is ObjInt) {
result = ObjInt.of(range.end.value - 1)
} else if (range.end is ObjChar) {
result = ObjChar((range.end.value.code - 1).toChar())
} else {
// For types where we can't easily find "previous" value (like Real),
// we just return the exclusive boundary as a fallback.
result = range.end
}
}
}
}
result
}
addVoidFn("assert") {
val cond = requiredArg<ObjBool>(0)
val message = if (args.size > 1)
": " + (args[1] as Statement).execute(this).toString(this).value
else ""
if (!cond.value == true)
raiseError(ObjAssertionFailedException(this, "Assertion failed$message"))
}
addVoidFn("assertEquals") {
val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1)
if (a.compareTo(this, b) != 0)
raiseError(
ObjAssertionFailedException(
this,
"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"
)
)
}
// alias used in tests
addVoidFn("assertEqual") {
val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1)
if (a.compareTo(this, b) != 0)
raiseError(
ObjAssertionFailedException(
this,
"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"
)
)
}
addVoidFn("assertNotEquals") {
val a = requiredArg<Obj>(0)
val b = requiredArg<Obj>(1)
if (a.compareTo(this, b) == 0)
raiseError(
ObjAssertionFailedException(
this,
"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"
)
)
}
addFnDoc(
"assertThrows",
doc = """
Asserts that the provided code block throws an exception, with or without exception:
```lyng
assertThrows { /* ode */ }
assertThrows(IllegalArgumentException) { /* code */ }
```
If an expected exception class is provided,
it checks that the thrown exception is of that class. If no expected class is provided, any exception
will be accepted.
""".trimIndent()
) {
val code: Statement
val expectedClass: ObjClass?
when (args.size) {
1 -> {
code = requiredArg<Statement>(0)
expectedClass = null
}
2 -> {
code = requiredArg<Statement>(1)
expectedClass = requiredArg<ObjClass>(0)
}
else -> raiseIllegalArgument("Expected 1 or 2 arguments, got ${args.size}")
}
val result = try {
code.execute(this)
null
} catch (e: ExecutionError) {
e.errorObject
} catch (_: ScriptError) {
ObjNull
}
if (result == null) raiseError(
ObjAssertionFailedException(
this,
"Expected exception but nothing was thrown"
)
)
expectedClass?.let {
if (!result.isInstanceOf(it)) {
val actual = if (result is ObjException) result.exceptionClass else result.objClass
raiseError("Expected $it, got $actual")
}
}
result
}
addFn("dynamic", callSignature = CallSignature(tailBlockReceiverType = "DelegateContext")) {
ObjDynamic.create(this, requireOnlyArg())
}
val root = this
val mathClass = ObjClass("Math").apply {
addFn("sqrt") {
ObjReal(sqrt(args.firstAndOnly().toDouble()))
}
}
addItem("Math", false, ObjInstance(mathClass).apply {
instanceScope = Scope(root, thisObj = this)
})
addFn("require") {
val condition = requiredArg<ObjBool>(0)
if (!condition.value) {
var message = args.list.getOrNull(1)
if (message is Statement) message = message.execute(this)
raiseIllegalArgument(message?.toString() ?: "requirement not met")
}
ObjVoid
}
addFn("check") {
val condition = requiredArg<ObjBool>(0)
if (!condition.value) {
var message = args.list.getOrNull(1)
if (message is Statement) message = message.execute(this)
raiseIllegalState(message?.toString() ?: "check failed")
}
ObjVoid
}
addFn("traceScope") {
this.trace(args.getOrNull(0)?.toString() ?: "")
ObjVoid
}
addFn("run") {
requireOnlyArg<Statement>().execute(this)
}
addFn("cached") {
val builder = requireOnlyArg<Statement>()
val capturedScope = this
var calculated = false
var cachedValue: Obj = ObjVoid
val thunk = object : Statement() {
override val pos: Pos = Pos.builtIn
override suspend fun execute(scope: Scope): Obj {
if (!calculated) {
cachedValue = builder.execute(capturedScope)
calculated = true
}
return cachedValue
}
}
thunk
}
addFn("lazy") {
val builder = requireOnlyArg<Statement>()
ObjLazyDelegate(builder, this)
}
addVoidFn("delay") {
val a = args.firstAndOnly()
when (a) {
is ObjInt -> delay(a.value)
is ObjReal -> delay((a.value * 1000).roundToLong())
is ObjDuration -> delay(a.duration)
else -> raiseIllegalArgument("Expected Int, Real or Duration, got ${a.inspect(this)}")
}
}
addConst("Object", rootObjectType)
addConst("Real", ObjReal.type)
addConst("String", ObjString.type)
addConst("Int", ObjInt.type)
addConst("Bool", ObjBool.type)
addConst("Char", ObjChar.type)
addConst("List", ObjList.type)
addConst("Set", ObjSet.type)
addConst("Range", ObjRange.type)
addConst("Map", ObjMap.type)
addConst("MapEntry", ObjMapEntry.type)
@Suppress("RemoveRedundantQualifierName")
addConst("Callable", Statement.type)
// interfaces
addConst("Iterable", ObjIterable)
addConst("Collection", ObjCollection)
addConst("Iterator", ObjIterator)
addConst("Array", ObjArray)
addConst("RingBuffer", ObjRingBuffer.type)
addConst("Class", ObjClassType)
addConst("Deferred", ObjDeferred.type)
addConst("CompletableDeferred", ObjCompletableDeferred.type)
addConst("Mutex", ObjMutex.type)
addConst("Flow", ObjFlow.type)
addConst("FlowBuilder", ObjFlowBuilder.type)
addConst("Delegate", ObjDynamic.type)
addConst("DelegateContext", ObjDynamicContext.type)
addConst("Regex", ObjRegex.type)
addConst("RegexMatch", ObjRegexMatch.type)
addConst("MapEntry", ObjMapEntry.type)
addFn("launch") {
val callable = requireOnlyArg<Statement>()
ObjDeferred(globalDefer {
callable.execute(this@addFn)
})
}
addFn("yield") {
yield()
ObjVoid
}
addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) {
// important is: current context contains closure often used in call;
// we'll need it for the producer
ObjFlow(requireOnlyArg<Statement>(), this)
}
val pi = ObjReal(PI)
addConstDoc(
name = "π",
value = pi,
doc = "The mathematical constant pi (π).",
type = type("lyng.Real")
)
getOrCreateNamespace("Math").apply {
addConstDoc(
name = "PI",
value = pi,
doc = "The mathematical constant pi (π) in the Math namespace.",
type = type("lyng.Real")
)
}
}
val defaultImportManager: ImportManager by lazy {
ImportManager(rootScope, SecurityManager.allowAll).apply {
addTextPackages(
rootLyng
)
addPackage("lyng.buffer") {
it.addConstDoc(
name = "Buffer",
value = ObjBuffer.type,
doc = "Immutable sequence of bytes. Use for binary data and IO.",
type = type("lyng.Class")
)
it.addConstDoc(
name = "MutableBuffer",
value = ObjMutableBuffer.type,
doc = "Mutable byte buffer. Supports in-place modifications.",
type = type("lyng.Class")
)
}
addPackage("lyng.serialization") {
it.addConstDoc(
name = "Lynon",
value = ObjLynonClass,
doc = "Lynon serialization utilities: encode/decode data structures to a portable binary/text form.",
type = type("lyng.Class")
)
}
addPackage("lyng.time") {
it.addConstDoc(
name = "Instant",
value = ObjInstant.type,
doc = "Point in time (epoch-based).",
type = type("lyng.Class")
)
it.addConstDoc(
name = "DateTime",
value = ObjDateTime.type,
doc = "Point in time in a specific time zone.",
type = type("lyng.Class")
)
it.addConstDoc(
name = "Duration",
value = ObjDuration.type,
doc = "Time duration with millisecond precision.",
type = type("lyng.Class")
)
it.addVoidFnDoc(
"delay",
doc = "Suspend for the given time. Accepts Duration, Int seconds, or Real seconds."
) {
val a = args.firstAndOnly()
when (a) {
is ObjInt -> delay(a.value * 1000)
is ObjReal -> delay((a.value * 1000).roundToLong())
is ObjDuration -> delay(a.duration)
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
}
}
}
}
}
}
}