Files
lyng/lyng/src/commonMain/kotlin/Common.kt
T
sergeych d9d7cafec8 +added console spport for lyngio
+added console support to lyng/jlyng CLI
+added unicode escapes
+created tetris console sample
2026-03-19 01:09:32 +03:00

268 lines
9.2 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
import com.github.ajalt.clikt.core.CliktCommand
import com.github.ajalt.clikt.core.Context
import com.github.ajalt.clikt.core.main
import com.github.ajalt.clikt.core.subcommands
import com.github.ajalt.clikt.parameters.arguments.argument
import com.github.ajalt.clikt.parameters.arguments.multiple
import com.github.ajalt.clikt.parameters.arguments.optional
import com.github.ajalt.clikt.parameters.options.flag
import com.github.ajalt.clikt.parameters.options.option
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.LyngVersion
import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source
import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.obj.*
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.mp_tools.globalDefer
import okio.FileSystem
import okio.Path.Companion.toPath
import okio.SYSTEM
import okio.buffer
import okio.use
// common code
expect fun exit(code: Int)
expect class ShellCommandExecutor {
fun executeCommand(command: String): CommandResult
companion object {
fun create(): ShellCommandExecutor
}
}
data class CommandResult(
val exitCode: Int,
val output: String,
val error: String
)
val baseScopeDefer = globalDefer {
Script.newScope().apply {
addFn("exit") {
exit(requireOnlyArg<ObjInt>().toInt())
ObjVoid
}
// Install lyng.io.fs module with full access by default for the CLI tool's Scope.
// Scripts still need to `import lyng.io.fs` to use Path API.
createFs(PermitAllAccessPolicy, this)
// Install console access by default for interactive CLI scripts.
// Scripts still need to `import lyng.io.console` to use it.
createConsoleModule(PermitAllConsoleAccessPolicy, this)
}
}
fun runMain(args: Array<String>) {
// Fast paths for legacy/positional script execution that should work without requiring explicit options
if (args.isNotEmpty()) {
// Support: jyng -- -file.lyng <args>
if (args.size >= 2 && args[0] == "--") {
executeFileWithArgs(args[1], args.drop(2))
return
}
// Support: jyng script.lyng <args> (when first token is not an option and not a subcommand name)
if (!args[0].startsWith('-') && args[0] != "fmt") {
executeFileWithArgs(args[0], args.drop(1))
return
}
}
// Delegate all other parsing and dispatching to Clikt with proper subcommands.
Lyng { runBlocking { it() } }
.subcommands(Fmt())
.main(args)
}
private class Fmt : CliktCommand(name = "fmt") {
private val checkOnly by option("--check", help = "Check only; print files that would change").flag()
private val inPlace by option("-i", "--in-place", help = "Write changes back to files").flag()
private val enableSpacing by option("--spacing", help = "Apply spacing normalization").flag()
private val enableWrapping by option("--wrap", "--wrapping", help = "Enable line wrapping").flag()
private val files by argument(help = "One or more .lyng files to format").multiple()
override fun help(context: Context): String = "Format Lyng source files"
override fun run() {
// Validate inputs
if (files.isEmpty()) {
println("Error: no files specified. See --help for usage.")
exit(1)
}
if (checkOnly && inPlace) {
println("Error: --check and --in-place cannot be used together")
exit(1)
}
val cfg = net.sergeych.lyng.format.LyngFormatConfig(
applySpacing = enableSpacing,
applyWrapping = enableWrapping,
)
var anyChanged = false
val multiFile = files.size > 1
for (path in files) {
val p = path.toPath()
val original = FileSystem.SYSTEM.source(p).use { it.buffer().use { bs -> bs.readUtf8() } }
val formatted = net.sergeych.lyng.format.LyngFormatter.format(original, cfg)
val changed = formatted != original
if (checkOnly) {
if (changed) {
println(path)
anyChanged = true
}
} else if (inPlace) {
// Write back regardless, but only touch file if content differs
if (changed) {
FileSystem.SYSTEM.write(p) { writeUtf8(formatted) }
}
} else {
// Default: stdout output
if (multiFile) {
println("--- $path ---")
}
println(formatted)
}
}
if (checkOnly) {
exit(if (anyChanged) 2 else 0)
}
}
}
private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
override val printHelpOnEmptyArgs = true
val version by option("-v", "--version", help = "Print version and exit").flag()
val benchmark by option("--benchmark", help = "Run JVM microbenchmarks and exit").flag()
val script by argument(help = "one or more scripts to execute").optional()
val execute: String? by option(
"-x", "--execute", help = """
execute string <text>, the rest of command line is passed to Lyng as ARGV
""".trimIndent()
)
val args by argument(help = "arguments for script").multiple()
override fun help(context: Context): String =
"""
The Lyng script language runtime, language version is $LyngVersion.
Please refer form more information to the project site:
https://gitea.sergeych.net/SergeychWorks/lyng
""".trimIndent()
override fun run() {
// If a subcommand (like `fmt`) was invoked, do nothing in the root command.
// This prevents the root from printing help before the subcommand runs.
if (currentContext.invokedSubcommand != null) return
runBlocking {
val baseScope = baseScopeDefer.await()
when {
version -> {
println("Lyng language version ${LyngVersion}")
}
execute != null -> {
val objargs = mutableListOf<String>()
script?.let { objargs += it }
objargs += args
baseScope.addConst(
"ARGV", ObjList(
objargs.map { ObjString(it) }.toMutableList()
)
)
launcher {
// there is no script name, it is a first argument instead:
processErrors {
val script = Compiler.compileWithResolution(
Source("<eval>", execute!!),
baseScope.currentImportProvider,
seedScope = baseScope
)
script.execute(baseScope)
}
}
}
else -> {
if (script == null) {
println("Error: no script specified.\n")
echoFormattedHelp()
} else {
baseScope.addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
launcher { executeFile(script!!) }
}
}
}
}
}
}
fun executeFileWithArgs(fileName: String, args: List<String>) {
runBlocking {
baseScopeDefer.await().addConst("ARGV", ObjList(args.map { ObjString(it) }.toMutableList()))
executeFile(fileName)
}
}
suspend fun executeFile(fileName: String) {
var text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource ->
fileSource.buffer().use { bs ->
bs.readUtf8()
}
}
if( text.startsWith("#!") ) {
// skip shebang
val pos = text.indexOf('\n')
text = text.substring(pos + 1)
}
processErrors {
val scope = baseScopeDefer.await()
val script = Compiler.compileWithResolution(
Source(fileName, text),
scope.currentImportProvider,
seedScope = scope
)
script.execute(scope)
}
}
suspend fun processErrors(block: suspend () -> Unit) {
try {
block()
}
catch (e: ScriptError) {
println("\nError executing the script:\n$e\n")
}
}