Compare commits

...
43 Commits
Author SHA1 Message Date
sergeych caad7d8ab9 stdlib inference bug fixed 2026-04-03 11:04:16 +03:00
sergeych 88b0bb2147 Add TCP server example and refactor script execution flow 2026-04-02 22:55:29 +03:00
sergeych 38646c6257 Update platform support matrix with detailed statuses and legend 2026-04-02 20:41:54 +03:00
sergeych f61ac35580 added networking to the CLI 2026-04-02 20:27:13 +03:00
sergeych 9bee0aed5b Merge branch 'inference-bug'
# Conflicts:
#	lyngio/src/commonMain/kotlin/net/sergeych/lyng/io/http/LyngHttpModule.kt
2026-04-02 20:06:11 +03:00
sergeych cd7e001f41 Refactor KMP networking backends 2026-04-02 20:04:25 +03:00
sergeych 62520f6203 Add downloads page and navigation link to site 2026-04-02 19:27:19 +03:00
sergeych d0aaa2c256 fix tetris code: declaration now in place 2026-04-02 19:25:17 +03:00
sergeych 5346d15a9f Add KMP networking backends 2026-04-02 19:23:46 +03:00
sergeych 7578128689 some order to outdated and special docs 2026-04-02 19:10:48 +03:00
sergeych 71243b6bde Stabilize browser unicode script test 2026-04-02 17:10:58 +03:00
sergeych 7b65ff9d0e Fix inference regression and green tests 2026-04-02 16:48:14 +03:00
sergeych d409a4bb8b Add verified Ktor-backed networking modules to lyngio 2026-04-02 16:19:14 +03:00
sergeych f168e9f6ed version bump 2026-04-02 13:01:51 +03:00
sergeych a051280e0c fix in site search and more tests on evalSession cancellation 2026-04-02 03:02:46 +03:00
sergeych fc01016a74 Added EvalSession way of controlling all coroutines started from a script 2026-04-02 02:05:14 +03:00
sergeych 446c8d9a6e minor additions 2026-04-01 02:51:00 +03:00
sergeych c140567e0c made last changes KMP compliant 2026-04-01 02:51:00 +03:00
sergeych 311cf6ee44 Add Lyng deferred cancellation support 2026-03-31 22:50:46 +03:00
sergeych 3e338f3d53 Fix sqrt type inference and add regression coverage 2026-03-31 22:26:58 +03:00
sergeych c097464750 - fixed CLI -x mode
- fixed a wrong error message when global symbol is not found
2026-03-31 20:52:31 +03:00
sergeych 6e9333844e support for Decimal.isInfitite and isNan 2026-03-31 19:13:45 +03:00
sergeych a976702caf support for Real.isInfitite and isNan 2026-03-31 19:08:11 +03:00
sergeych 850efedb72 Handle non-finite real/decimal arithmetic 2026-03-31 16:57:18 +03:00
sergeych f845213332 fixed Decima/Complex interop bug 2026-03-30 09:25:29 +03:00
sergeych cdd48ec871 Improved instance method resolution logic and added test for Decimal overloading. 2026-03-30 08:53:07 +03:00
sergeych 286ec30422 Added Decimal support for complex number 2026-03-30 08:20:55 +03:00
sergeych 8a560f5417 fixed interpolation bug 2026-03-29 12:35:10 +03:00
sergeych 966b6a31ae extended inference of fun return type 2026-03-29 03:57:02 +03:00
sergeych c3c0a3292b fixed Decimal conversion bug 2026-03-29 03:35:53 +03:00
sergeych aa9565b40b fixed Decimal (and other such classes ) comparison 2026-03-29 01:29:48 +03:00
sergeych 05d7432b37 fixes on Decimals and bound kotlin classes 2026-03-29 01:20:20 +03:00
sergeych c7c333b71a fixed some issues with Decimals 2026-03-29 00:39:48 +03:00
sergeych e55d9c835a another snapshot release, configs for matrix operations 2026-03-28 23:28:28 +03:00
sergeych 83d8c8b71f Added Vectors and Matrics operations, slicing, docs. 2026-03-28 22:25:40 +03:00
sergeych a72991d1b7 debug stuff cleanup and simplify 2026-03-28 17:50:53 +03:00
sergeych cd007050a8 added complext number support 2026-03-28 17:44:43 +03:00
sergeych 418b1ae2b6 Fix captured bound global writes in nested bytecode blocks 2026-03-28 00:47:08 +03:00
sergeych b0fb65a036 Fix bound property captures and property slot resolution 2026-03-28 00:00:59 +03:00
sergeych 86e8b2e2bc site upgrades 2026-03-27 22:36:23 +03:00
sergeych a98fe51983 version bump 2026-03-27 21:49:53 +03:00
sergeych f8d36beae1 Merge branch 'bigdecimals' 2026-03-27 21:32:25 +03:00
sergeych 5ab074ba9e readme updated 2026-03-27 21:30:21 +03:00
153 changed files with 11746 additions and 660 deletions

No files matched your search

+1
View File
@@ -27,3 +27,4 @@ debug.log
/compile_jvm_output.txt /compile_jvm_output.txt
/compile_metadata_output.txt /compile_metadata_output.txt
test_output*.txt test_output*.txt
/site/src/version-template/lyng-version.js
+24 -15
View File
@@ -93,21 +93,25 @@ import net.sergeych.lyng.*
// we need a coroutine to start, as Lyng // we need a coroutine to start, as Lyng
// is a coroutine based language, async topdown // is a coroutine based language, async topdown
runBlocking { runBlocking {
assert(5 == eval(""" 3*3 - 4 """).toInt()) val session = EvalSession()
eval(""" println("Hello, Lyng!") """) assert(5 == session.eval(""" 3*3 - 4 """).toInt())
session.eval(""" println("Hello, Lyng!") """)
} }
``` ```
### Exchanging information ### Exchanging information
Script is executed over some `Scope`. Create instance, The preferred host runtime is `EvalSession`. It owns the script scope and any coroutines
add your specific vars and functions to it, and call: started with `launch { ... }`. Create a session, grab its scope when you need low-level
binding APIs, then execute scripts through the session:
```kotlin ```kotlin
import net.sergeych.lyng.* import net.sergeych.lyng.*
runBlocking {
val session = EvalSession()
val scope = session.getScope().apply {
// simple function // simple function
val scope = Script.newScope().apply {
addFn("sumOf") { addFn("sumOf") {
var sum = 0.0 var sum = 0.0
for (a in args) sum += a.toDouble() for (a in args) sum += a.toDouble()
@@ -125,10 +129,13 @@ val scope = Script.newScope().apply {
doSomeWork(args[0]).toObj() doSomeWork(args[0]).toObj()
} }
} }
// adding constant:
scope.eval("sumOf(1,2,3)") // <- 6 // execute through the session:
session.eval("sumOf(1,2,3)") // <- 6
}
``` ```
Note that the scope stores all changes in it so you can make calls on a single scope to preserve state between calls. Note that the session reuses one scope, so state persists across `session.eval(...)` calls.
Use raw `Scope.eval(...)` only when you intentionally want low-level control without session-owned coroutine lifecycle.
## IntelliJ IDEA plugin: Lightweight autocompletion (experimental) ## IntelliJ IDEA plugin: Lightweight autocompletion (experimental)
@@ -221,17 +228,15 @@ All of this is documented in the [language site](https://lynglang.com) and local
- [x] site with integrated interpreter to give a try - [x] site with integrated interpreter to give a try
- [x] kotlin part public API good docs, integration focused - [x] kotlin part public API good docs, integration focused
- [ ] type specifications - [x] type specifications
- [x] Textmate Bundle - [x] Textmate Bundle
- [x] IDEA plugin - [x] IDEA plugin
- [ ] source docs and maybe lyng.md to a standard - [x] source docs and maybe lyng.md to a standard
- [ ] metadata first class access from lyng
- [x] aggressive optimizations - [x] aggressive optimizations
- [ ] compile to JVM bytecode optimization
## After 1.5 "Ideal scripting" ## After 1.5 "Ideal scripting"
Estimated summer 2026 * __we are here now ;)__
- propose your feature! - propose your feature!
@@ -239,8 +244,12 @@ Estimated summer 2026
@-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project. @-links are for contacting authors on [project home](https://gitea.sergeych.net/SergeychWorks/lyng): this simplest s to open issue for the person you need to convey any information about this project.
__Sergey Chernov__ @sergeych: Initial idea and architecture, language concept, design, implementation. <img src="https://www.gravatar.com/avatar/7e3a56ff8a090fc9ffbd1909dea94904?s=32&d=identicon" alt="Sergey Chernov" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Sergey Chernov</b> @sergeych, real.sergeych@gmail.com: Initial idea and architecture, language concept, design, implementation.
<br/>
<img src="https://www.gravatar.com/avatar/53a90bca30c85a81db8f0c0d8dea43a1?s=32&d=identicon" alt="Yulia Nezhinskaya" width="32" height="32" style="vertical-align: middle; margin-right: 0.5em;" /> <b>Yulia Nezhinskaya</b> @AlterEgoJuliaN, neleka88@gmail.com: System analysis, math and feature design.
__Yulia Nezhinskaya__ @AlterEgoJuliaN: System analysis, math and features design.
[parallelism]: docs/parallelism.md [parallelism]: docs/parallelism.md
File renamed without changes.
File renamed without changes.
File renamed without changes.
-7
View File
@@ -1,7 +0,0 @@
# Bytecode Migration Plan (Archived)
Status: completed.
Historical reference:
- `notes/archive/bytecode_migration_plan.md` (full plan)
- `notes/archive/bytecode_migration_plan_completed.md` (summary)
+7
View File
@@ -4,6 +4,13 @@ It's an interface if the [Collection] that provides indexing access, like `array
Array therefore implements [Iterable] too. Well known implementations of `Array` are Array therefore implements [Iterable] too. Well known implementations of `Array` are
[List] and [ImmutableList]. [List] and [ImmutableList].
The language-level bracket syntax supports one or more selectors:
- `value[i]`
- `value[i, j]`
Concrete array-like types decide what selectors they accept. Built-in list-like arrays use one selector at a time; custom types such as matrices may interpret multiple selectors.
Array adds the following methods: Array adds the following methods:
## Binary search ## Binary search
+82
View File
@@ -0,0 +1,82 @@
# Complex Numbers (`lyng.complex`)
`lyng.complex` adds a pure-Lyng `Complex` type backed by `Real` components.
Import it when you want ordinary complex arithmetic:
```lyng
import lyng.complex
```
## Construction
Use any of these:
```lyng
import lyng.complex
val a = Complex(1.0, 2.0)
val b = complex(1.0, 2.0)
val c = 2.i
val d = 3.re
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
```
Convenience extensions:
- `Int.re`, `Real.re`: embed a real value into the complex plane
- `Int.i`, `Real.i`: create a pure imaginary value
- `cis(angle)`: shorthand for `cos(angle) + i sin(angle)`
## Core Operations
`Complex` supports:
- `+`
- `-`
- `*`
- `/`
- unary `-`
- `conjugate`
- `magnitude`
- `phase`
Mixed arithmetic with `Int` and `Real` is enabled through `lyng.operators`, so both sides work naturally:
```lyng
import lyng.complex
assertEquals(Complex(1.0, 2.0), 1 + 2.i)
assertEquals(Complex(1.5, 2.0), 1.5 + 2.i)
assertEquals(Complex(2.0, 2.0), 2.i + 2)
```
Mixed equality with built-in numeric types is intentionally not promised yet. Keep equality checks in the `Complex` domain for now.
## Transcendental Functions
For now, use member-style calls:
```lyng
import lyng.complex
val z = 1 + π.i
val w = z.exp()
val s = z.sin()
val r = z.sqrt()
```
This is deliberate. Lyng already has built-in top-level real-valued functions such as `exp(x)` and `sin(x)`, and imported modules do not currently replace those root bindings. So plain `exp(z)` is not yet the right extension mechanism for complex math.
## Design Scope
This module intentionally uses `Complex` with `Real` parts, not `Complex<T>`.
Reasons:
- the existing math runtime is `Real`-centric
- the operator interop registry works with concrete runtime classes
- transcendental functions (`exp`, `sin`, `ln`, `sqrt`) are defined over the `Real` math backend here
If Lyng later gets a more general numeric-trait or callable-overload registry, a generic algebraic `Complex<T>` can be revisited on firmer ground.
+84 -9
View File
@@ -8,9 +8,9 @@ Import it when you need decimal arithmetic that should not inherit `Real`'s bina
import lyng.decimal import lyng.decimal
``` ```
## What `BigDecimal` Is For ## What `Decimal` Is For
Use `BigDecimal` when values are fundamentally decimal: Use `Decimal` when values are fundamentally decimal:
- money - money
- human-entered quantities - human-entered quantities
@@ -38,8 +38,8 @@ assertEquals("2.2", c.toStringExpanded())
The three forms mean different things: The three forms mean different things:
- `1.d`: convert `Int -> BigDecimal` - `1.d`: convert `Int -> Decimal`
- `2.2.d`: convert `Real -> BigDecimal` - `2.2.d`: convert `Real -> Decimal`
- `"2.2".d`: parse exact decimal text - `"2.2".d`: parse exact decimal text
That distinction is intentional. That distinction is intentional.
@@ -67,16 +67,36 @@ The explicit factory methods are:
```lyng ```lyng
import lyng.decimal import lyng.decimal
BigDecimal.fromInt(10) Decimal.fromInt(10)
BigDecimal.fromReal(2.5) Decimal.fromReal(2.5)
BigDecimal.fromString("12.34") Decimal.fromString("12.34")
``` ```
These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code. These are equivalent to the conversion-property forms, but sometimes clearer in APIs or generated code.
## From Kotlin
If you already have an ionspin `BigDecimal` on the host side, the simplest supported way to create a Lyng `Decimal` is:
```kotlin
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.asFacade
import net.sergeych.lyng.newDecimal
val scope = EvalSession().getScope()
val decimal = scope.asFacade().newDecimal(BigDecimal.parseStringWithMode("12.34"))
```
Notes:
- `newDecimal(...)` loads `lyng.decimal` if needed
- it returns a real Lyng `Decimal` object instance
- this is the preferred Kotlin-side construction path when you already hold a host `BigDecimal`
## Core Operations ## Core Operations
`BigDecimal` supports: `Decimal` supports:
- `+` - `+`
- `-` - `-`
@@ -115,7 +135,7 @@ assert(2 == 2.d)
assert(3 > 2.d) assert(3 > 2.d)
``` ```
Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + BigDecimal` and `Real + BigDecimal`. Without this registration mechanism, only the cases directly implemented on the left-hand class would work. The bridge fills the gap for expressions such as `Int + Decimal` and `Real + Decimal`.
See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that. See [OperatorInterop.md](OperatorInterop.md) for the generic mechanism behind that.
@@ -146,6 +166,17 @@ assertEquals(2.9, "2.9".d.toReal())
Use `toReal()` only when you are willing to return to binary floating-point semantics. Use `toReal()` only when you are willing to return to binary floating-point semantics.
## Non-Finite Checks
`Decimal` values are always finite, so these helpers exist for API symmetry with `Real` and always return `false`:
```lyng
import lyng.decimal
assertEquals(false, "2.9".d.isInfinite())
assertEquals(false, "2.9".d.isNaN())
```
## Division Context ## Division Context
Division is the operation where precision and rounding matter most. Division is the operation where precision and rounding matter most.
@@ -223,6 +254,50 @@ assertEquals("-0.12", withDecimalContext(2, DecimalRounding.HalfTowardsZero) { (
## Recommended Usage Rules ## Recommended Usage Rules
## Decimal With Stdlib Math Functions
Core math helpers such as `abs`, `floor`, `ceil`, `round`, `sin`, `exp`, `ln`, `sqrt`, `log10`, `log2`, and `pow`
now also accept `Decimal`.
Current behavior is intentionally split:
- exact decimal implementation:
- `abs(x)`
- `floor(x)`
- `ceil(x)`
- `round(x)`
- `pow(x, y)` when `x` is `Decimal` and `y` is an integral exponent
- temporary bridge through `Real`:
- `sin`, `cos`, `tan`
- `asin`, `acos`, `atan`
- `sinh`, `cosh`, `tanh`
- `asinh`, `acosh`, `atanh`
- `exp`, `ln`, `log10`, `log2`
- `sqrt`
- `pow` for the remaining non-integral decimal exponent cases
The temporary bridge is:
```lyng
Decimal -> Real -> host math -> Decimal
```
This is a compatibility step, not the long-term design. Native decimal implementations will replace these bridge-based
paths over time.
Examples:
```lyng
import lyng.decimal
assertEquals("2.5", (abs("-2.5".d) as Decimal).toStringExpanded())
assertEquals("2", (floor("2.9".d) as Decimal).toStringExpanded())
// Temporary Real bridge:
assertEquals((exp(1.25) as Real).d.toStringExpanded(), (exp("1.25".d) as Decimal).toStringExpanded())
assertEquals((sqrt(2.0) as Real).d.toStringExpanded(), (sqrt("2".d) as Decimal).toStringExpanded())
```
If you care about exact decimal source text: If you care about exact decimal source text:
```lyng ```lyng
+7
View File
@@ -30,6 +30,13 @@ There is a shortcut for the last:
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too. __Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
The language also allows multi-selector indexing syntax such as `value[i, j]`, but `List` itself uses a single selector only:
- `list[index]` for one element
- `list[range]` for a slice copy
Multi-selector indexing is intended for custom indexers such as `Matrix`.
## Concatenation ## Concatenation
You can concatenate lists or iterable objects: You can concatenate lists or iterable objects:
+192
View File
@@ -0,0 +1,192 @@
# Matrix (`lyng.matrix`)
`lyng.matrix` adds dense immutable `Matrix` and `Vector` types for linear algebra.
Import it when you need matrix or vector arithmetic:
```lyng
import lyng.matrix
```
## Construction
Create vectors from a flat list and matrices from nested row lists:
```lyng
import lyng.matrix
val v: Vector = vector([1, 2, 3])
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals([1.0, 2.0, 3.0], v.toList())
assertEquals([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], m.toList())
```
Factory methods are also available:
```lyng
import lyng.matrix
val z: Vector = Vector.zeros(3)
val i: Matrix = Matrix.identity(3)
val m: Matrix = Matrix.zeros(2, 4)
```
All elements are standard double-precision numeric values internally.
## Shapes
Matrices may have any rectangular geometry:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(2, a.rows)
assertEquals(3, a.cols)
assertEquals([2, 3], a.shape)
assertEquals(false, a.isSquare)
```
Vectors expose:
- `size`
- `length` as an alias of `size`
## Matrix Operations
Supported matrix operations:
- `+` and `-` for element-wise matrix arithmetic
- `*` for matrix-matrix product
- `*` and `/` by a scalar
- `transpose()`
- `trace()`
- `rank()`
- `determinant()`
- `inverse()`
- `solve(rhs)` for `Vector` or `Matrix` right-hand sides
Example:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
assertEquals([[1.0, 4.0], [2.0, 5.0], [3.0, 6.0]], a.transpose().toList())
```
Inverse and solve:
```lyng
import lyng.matrix
val a: Matrix = matrix([[4, 7], [2, 6]])
val rhs: Vector = vector([1, 0])
val inv: Matrix = a.inverse()
val x: Vector = a.solve(rhs)
assert(abs(a.determinant() - 10.0) < 1e-9)
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
assert(abs(x.get(0) - 0.6) < 1e-9)
```
## Vector Operations
Supported vector operations:
- `+` and `-`
- scalar `*` and `/`
- `dot(other)`
- `norm()`
- `normalize()`
- `cross(other)` for 3D vectors
- `outer(other)` producing a matrix
```lyng
import lyng.matrix
val a: Vector = vector([1, 2, 3])
val b: Vector = vector([2, 0, 0])
assertEquals(2.0, a.dot(b))
assertEquals([0.2672612419124244, 0.5345224838248488, 0.8017837257372732], a.normalize().toList())
```
## Indexing and Slicing
`Matrix` supports both method-style indexing and bracket syntax.
Scalar access:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(6.0, m.get(1, 2))
assertEquals(6.0, m[1, 2])
```
Bracket indexing accepts two selectors: `[row, col]`.
Each selector may be either:
- an `Int`
- a `Range`
Examples:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
assertEquals(7.0, m[1, 2])
val columnSlice: Matrix = m[0..2, 2]
val topLeft: Matrix = m[0..1, 0..1]
val tail: Matrix = m[1.., 1..]
assertEquals([[3.0], [7.0], [11.0]], columnSlice.toList())
assertEquals([[1.0, 2.0], [5.0, 6.0]], topLeft.toList())
assertEquals([[6.0, 7.0, 8.0], [10.0, 11.0, 12.0]], tail.toList())
```
Shape rules:
- `m[Int, Int]` returns a `Real`
- `m[Range, Int]` returns an `Nx1` `Matrix`
- `m[Int, Range]` returns a `1xM` `Matrix`
- `m[Range, Range]` returns a submatrix
Open-ended ranges are supported:
- `m[..1, ..1]`
- `m[1.., 1..]`
- `m[.., 2]`
Stepped ranges are not supported in matrix slicing.
Slices currently return new matrices, not views.
## Rows and Columns
If you want plain lists instead of a sliced matrix:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals([4.0, 5.0, 6.0], a.row(1))
assertEquals([2.0, 5.0], a.column(1))
```
## Backend Notes
The matrix module uses a platform-specific backend where available and falls back to pure Kotlin where needed.
The public Lyng API stays the same across platforms.
+18 -2
View File
@@ -1183,8 +1183,24 @@ collection's sugar won't work with it:
assertEquals("buzz", x[0]) assertEquals("buzz", x[0])
>>> void >>> void
If you want dynamic to function like an array, create a [feature Multiple selectors are packed into one list index object:
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
val x = dynamic {
get {
if( it == [1, 2] ) "hit"
else null
}
}
assertEquals("hit", x[1, 2])
>>> void
So:
- `x[i]` passes `i`
- `x[i, j]` passes `[i, j]`
- `x[i, j, k]` passes `[i, j, k]`
This is the same rule used by Kotlin-backed `getAt` / `putAt` indexers in embedding.
# Theory # Theory
+5 -5
View File
@@ -160,15 +160,15 @@ import lyng.decimal
3 > 2.d 3 > 2.d
``` ```
work naturally even though `Int` and `Real` themselves were not edited to know `BigDecimal`. work naturally even though `Int` and `Real` themselves were not edited to know `Decimal`.
The shape is: The shape is:
- `leftClass = Int` or `Real` - `leftClass = Int` or `Real`
- `rightClass = BigDecimal` - `rightClass = Decimal`
- `commonClass = BigDecimal` - `commonClass = Decimal`
- convert built-ins into `BigDecimal` - convert built-ins into `Decimal`
- leave `BigDecimal` values unchanged - leave `Decimal` values unchanged
## Step-By-Step Pattern For Your Own Type ## Step-By-Step Pattern For Your Own Type
+2
View File
@@ -19,6 +19,8 @@ you can use it's class to ensure type:
|-----------------|-------------------------------------------------------------|------| |-----------------|-------------------------------------------------------------|------|
| `.roundToInt()` | round to nearest int like round(x) | Int | | `.roundToInt()` | round to nearest int like round(x) | Int |
| `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int | | `.toInt()` | convert integer part of real to `Int` dropping decimal part | Int |
| `.isInfinite()` | true when the value is `Infinity` or `-Infinity` | Bool |
| `.isNaN()` | true when the value is `NaN` | Bool |
| `.clamp(range)` | clamp value within range boundaries | Real | | `.clamp(range)` | clamp value within range boundaries | Real |
| | | | | | | |
| | | | | | | |
+8 -1
View File
@@ -1,5 +1,7 @@
# Lyng Language Reference for AI Agents (Current Compiler State) # Lyng Language Reference for AI Agents (Current Compiler State)
[//]: # (excludeFromIndex)
Purpose: dense, implementation-first reference for generating valid Lyng code. Purpose: dense, implementation-first reference for generating valid Lyng code.
Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,Token,Compiler,Script,TypeDecl}.kt`, `lynglib/stdlib/lyng/root.lyng`, tests in `lynglib/src/commonTest` and `lynglib/src/jvmTest`. Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,Token,Compiler,Script,TypeDecl}.kt`, `lynglib/stdlib/lyng/root.lyng`, tests in `lynglib/src/commonTest` and `lynglib/src/jvmTest`.
@@ -82,11 +84,16 @@ Primary sources used: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/{Parser,T
- Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`. - Type/containment: `is`, `!is`, `in`, `!in`, `as`, `as?`.
- Null-safe family: - Null-safe family:
- member access: `?.` - member access: `?.`
- safe index: `?[i]` - safe index: `?[i]`, `?[i, j]`
- safe invoke: `?(...)` - safe invoke: `?(...)`
- safe block invoke: `?{ ... }` - safe block invoke: `?{ ... }`
- elvis: `?:` and `??`. - elvis: `?:` and `??`.
- Increment/decrement: prefix and postfix `++`, `--`. - Increment/decrement: prefix and postfix `++`, `--`.
- Indexing syntax:
- single selector: `a[i]`
- multiple selectors: `a[i, j, k]`
- language-level indexing with multiple selectors is passed to `getAt`/`putAt` as one list-like index object, not as multiple method arguments.
- example: `m[0..2, 2]`.
## 5. Declarations ## 5. Declarations
- Variables: - Variables:
+2
View File
@@ -1,5 +1,7 @@
# AI notes: avoid Kotlin/Wasm invalid IR with suspend lambdas # AI notes: avoid Kotlin/Wasm invalid IR with suspend lambdas
[//]: # (excludeFromIndex)
## Do ## Do
- Prefer explicit `object : Statement()` with `override suspend fun execute(...)` when building compiler statements. - Prefer explicit `object : Statement()` with `override suspend fun execute(...)` when building compiler statements.
- Keep `Statement` objects non-lambda, especially in compiler hot paths like parsing/var declarations. - Keep `Statement` objects non-lambda, especially in compiler hot paths like parsing/var declarations.
+21 -2
View File
@@ -1,5 +1,7 @@
# Lyng Stdlib Reference for AI Agents (Compact) # Lyng Stdlib Reference for AI Agents (Compact)
[//]: # (excludeFromIndex)
Purpose: fast overview of what is available by default and what must be imported. Purpose: fast overview of what is available by default and what must be imported.
Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/stdlib/lyng/root.lyng`, `lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/observable_lyng.kt`. Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/stdlib/lyng/root.lyng`, `lynglib/src/commonMain/kotlin/net/sergeych/lyng/stdlib_included/observable_lyng.kt`.
@@ -14,7 +16,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`. - Assertions/tests: `assert`, `assertEquals`/`assertEqual`, `assertNotEquals`, `assertThrows`.
- Preconditions: `require`, `check`. - Preconditions: `require`, `check`.
- Async/concurrency: `launch`, `yield`, `flow`, `delay`. - Async/concurrency: `launch`, `yield`, `flow`, `delay`.
- `Deferred.cancel()` cancels an active task.
- `Deferred.await()` throws `CancellationException` if that task was cancelled.
- Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`. - Math: `floor`, `ceil`, `round`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`, `exp`, `ln`, `log10`, `log2`, `pow`, `sqrt`, `abs`, `clamp`.
- These helpers also accept `lyng.decimal.Decimal`.
- Exact Decimal path today: `abs`, `floor`, `ceil`, `round`, and `pow` with integral exponent.
- Temporary Decimal path for the rest: convert `Decimal -> Real`, compute, then convert back to `Decimal`.
- Treat that bridge as temporary; prefer native Decimal implementations when they become available.
## 3. Core Global Constants/Types ## 3. Core Global Constants/Types
- Values: `Unset`, `π`. - Values: `Unset`, `π`.
@@ -22,13 +30,14 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
- Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`. - Collections/types: `Iterable`, `Iterator`, `Collection`, `Array`, `List`, `ImmutableList`, `Set`, `ImmutableSet`, `Map`, `ImmutableMap`, `MapEntry`, `Range`, `RingBuffer`.
- Random: singleton `Random` and class `SeededRandom`. - Random: singleton `Random` and class `SeededRandom`.
- Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`. - Async types: `Deferred`, `CompletableDeferred`, `Mutex`, `Flow`, `FlowBuilder`.
- Async exception: `CancellationException`.
- Delegation types: `Delegate`, `DelegateContext`. - Delegation types: `Delegate`, `DelegateContext`.
- Regex types: `Regex`, `RegexMatch`. - Regex types: `Regex`, `RegexMatch`.
- Also present: `Math.PI` namespace constant. - Also present: `Math.PI` namespace constant.
## 4. `lyng.stdlib` Module Surface (from `root.lyng`) ## 4. `lyng.stdlib` Module Surface (from `root.lyng`)
### 4.1 Extern class declarations ### 4.1 Extern class declarations
- Exceptions/delegation base: `Exception`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`. - Exceptions/delegation base: `Exception`, `CancellationException`, `IllegalArgumentException`, `NotImplementedException`, `Delegate`.
- Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`. - Collections and iterables: `Iterable<T>`, `Iterator<T>`, `Collection<T>`, `Array<T>`, `List<T>`, `ImmutableList<T>`, `Set<T>`, `ImmutableSet<T>`, `Map<K,V>`, `ImmutableMap<K,V>`, `MapEntry<K,V>`, `RingBuffer<T>`.
- Host iterator bridge: `KotlinIterator<T>`. - Host iterator bridge: `KotlinIterator<T>`.
- Random APIs: `extern object Random`, `extern class SeededRandom`. - Random APIs: `extern object Random`, `extern class SeededRandom`.
@@ -56,6 +65,13 @@ Sources: `lynglib/src/commonMain/kotlin/net/sergeych/lyng/Script.kt`, `lynglib/s
## 5. Additional Built-in Modules (import explicitly) ## 5. Additional Built-in Modules (import explicitly)
- `import lyng.observable` - `import lyng.observable`
- `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`. - `Observable`, `Subscription`, `ObservableList`, `ListChange` and change subtypes, `ChangeRejectionException`.
- `import lyng.decimal`
- `Decimal`, `DecimalContext`, `DecimalRounding`, `withDecimalContext(...)`.
- Kotlin host helper: `ScopeFacade.newDecimal(BigDecimal)` wraps an ionspin host decimal as a Lyng `Decimal`.
- `import lyng.complex`
- `Complex`, `complex(re, im)`, `cis(angle)`, and numeric embedding extensions such as `2.i` / `3.re`.
- `import lyng.matrix`
- `Matrix`, `Vector`, `matrix(rows)`, `vector(values)`, dense linear algebra, inversion, solving, and matrix slicing with `m[row, col]`.
- `import lyng.buffer` - `import lyng.buffer`
- `Buffer`, `MutableBuffer`. - `Buffer`, `MutableBuffer`.
- `import lyng.serialization` - `import lyng.serialization`
@@ -68,8 +84,11 @@ Requires installing `lyngio` into the import manager from host code.
- `import lyng.io.fs` (filesystem `Path` API) - `import lyng.io.fs` (filesystem `Path` API)
- `import lyng.io.process` (process execution API) - `import lyng.io.process` (process execution API)
- `import lyng.io.console` (console capabilities, geometry, ANSI/output, events) - `import lyng.io.console` (console capabilities, geometry, ANSI/output, events)
- `import lyng.io.http` (HTTP/HTTPS client API)
- `import lyng.io.ws` (WebSocket client API; currently supported on JVM, capability-gated elsewhere)
- `import lyng.io.net` (TCP/UDP transport API; currently supported on JVM, capability-gated elsewhere)
## 7. AI Generation Tips ## 7. AI Generation Tips
- Assume `lyng.stdlib` APIs exist in regular script contexts. - Assume `lyng.stdlib` APIs exist in regular script contexts.
- For platform-sensitive code (`fs`, `process`, `console`), gate assumptions and mention required module install. - For platform-sensitive code (`fs`, `process`, `console`, `http`, `ws`, `net`), gate assumptions and mention required module install.
- Prefer extension-method style (`items.filter { ... }`) and standard scope helpers (`let`/`also`/`apply`/`run`). - Prefer extension-method style (`items.filter { ... }`) and standard scope helpers (`let`/`also`/`apply`/`run`).
+11
View File
@@ -0,0 +1,11 @@
# Some resources to download
## Lync CLI tool
- [lyng-linuxX64.zip](/distributables/lyng-linuxX64.zip) CLI tool for linuxX64: nodependencies, small monolith executable binary.
## IDE plugins
- [lyng-textmate.zip](../../lyng/distributables/lyng-textmate.zip) Texmate-compatible bundle with syntax coloring (could be outdated)
- [lyng-idea-0.0.5-SNAPSHOT.zip](/distributables/lyng-idea-0.0.5-SNAPSHOT.zip) - plugin for IntelliJ-compatible IDE
+158 -27
View File
@@ -1,5 +1,7 @@
# Embedding Lyng in your Kotlin project # Embedding Lyng in your Kotlin project
[//]: # (topMenu)
Lyng is a tiny, embeddable, Kotlin‑first scripting language. This page shows, step by step, how to: Lyng is a tiny, embeddable, Kotlin‑first scripting language. This page shows, step by step, how to:
- add Lyng to your build - add Lyng to your build
@@ -36,21 +38,60 @@ dependencies {
If you use Kotlin Multiplatform, add the dependency in the `commonMain` source set (and platform‑specific sets if you need platform APIs). If you use Kotlin Multiplatform, add the dependency in the `commonMain` source set (and platform‑specific sets if you need platform APIs).
### 2) Create a runtime (Scope) and execute scripts ### 2) Preferred runtime: `EvalSession`
The easiest way to get a ready‑to‑use scope with standard packages is via `Script.newScope()`. For host applications, prefer `EvalSession` as the main way to run scripts.
It owns one reusable Lyng scope, serializes `eval(...)` calls, and governs coroutines started from Lyng `launch { ... }`.
Main entrypoints:
- `session.eval(code)` / `session.eval(source)`
- `session.getScope()` when you need low-level binding APIs
- `session.cancel()` to cancel active session-owned coroutines
- `session.join()` to wait for active session-owned coroutines
```kotlin
fun main() = kotlinx.coroutines.runBlocking {
val session = EvalSession()
// Evaluate a one‑liner
val result = session.eval("1 + 2 * 3")
println("Lyng result: $result") // ObjReal/ObjInt etc.
// Optional lifecycle management
session.join()
}
```
The session creates its underlying scope lazily. If you need raw low-level APIs, get the scope explicitly:
```kotlin
val session = EvalSession()
val scope = session.getScope()
```
Use `cancel()` / `join()` to govern async work started by scripts:
```kotlin
val session = EvalSession()
session.eval("""launch { delay(1000); println("done") }""")
session.cancel()
session.join()
```
### 2.1) Low-level runtime: `Scope`
Use `Scope` directly when you intentionally want lower-level control.
```kotlin ```kotlin
fun main() = kotlinx.coroutines.runBlocking { fun main() = kotlinx.coroutines.runBlocking {
val scope = Script.newScope() // suspends on first init val scope = Script.newScope() // suspends on first init
// Evaluate a one‑liner
val result = scope.eval("1 + 2 * 3") val result = scope.eval("1 + 2 * 3")
println("Lyng result: $result") // ObjReal/ObjInt etc. println("Lyng result: $result")
} }
``` ```
You can also pre‑compile a script and execute it multiple times: You can also pre‑compile a script and execute it multiple times on the same scope:
```kotlin ```kotlin
val script = Compiler.compile(""" val script = Compiler.compile("""
@@ -63,7 +104,8 @@ val run1 = script.execute(scope)
val run2 = script.execute(scope) val run2 = script.execute(scope)
``` ```
`Scope.eval("...")` is a shortcut that compiles and executes on the given scope. `Scope.eval("...")` is the low-level shortcut that compiles and executes on the given scope.
For most embedding use cases, prefer `session.eval("...")`.
### 3) Preferred: bind extern globals from Kotlin ### 3) Preferred: bind extern globals from Kotlin
@@ -85,6 +127,8 @@ import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjString import net.sergeych.lyng.obj.ObjString
val session = EvalSession()
val scope = session.getScope()
val im = Script.defaultImportManager.copy() val im = Script.defaultImportManager.copy()
im.addPackage("my.api") { module -> im.addPackage("my.api") { module ->
module.eval(""" module.eval("""
@@ -149,6 +193,9 @@ binder.bindGlobalFunRaw("echoRaw") { _, args ->
Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3. Use this when you intentionally want raw `Scope` APIs. For most module APIs, prefer section 3.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
// A function returning value // A function returning value
scope.addFn<ObjInt>("inc") { scope.addFn<ObjInt>("inc") {
val x = args.firstAndOnly() as ObjInt val x = args.firstAndOnly() as ObjInt
@@ -167,7 +214,7 @@ scope.addVoidFn("log") {
// } // }
// Call them from Lyng // Call them from Lyng
scope.eval("val y = inc(41); log('Answer:', y)") session.eval("val y = inc(41); log('Answer:', y)")
``` ```
You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`. You can register multiple names (aliases) at once: `addFn<ObjInt>("inc", "increment") { ... }`.
@@ -183,11 +230,79 @@ Scope-backed Kotlin lambdas receive a `ScopeFacade` (not a full `Scope`). For mi
If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly. If you truly need the full `Scope` (e.g., for low-level interop), use `requireScope()` explicitly.
### 4.5) Indexers from Kotlin: `getAt` and `putAt`
Lyng bracket syntax is dispatched through `getAt` and `putAt`.
That means:
- `x[i]` calls `getAt(index)`
- `x[i] = value` calls `putAt(index, value)` or `setAt(index, value)`
- field-like `x["name"]` also uses the same index path unless you expose a real field/property
For Kotlin-backed classes, bind indexers as ordinary methods named `getAt` and `putAt`:
```kotlin
moduleScope.eval("""
extern class Grid {
override fun getAt(index: List<Int>): Int
override fun putAt(index: List<Int>, value: Int): void
}
""".trimIndent())
moduleScope.bind("Grid") {
init { _ -> data = IntArray(4) }
addFun("getAt") {
val index = args.requiredArg<ObjList>(0)
val row = (index.list[0] as ObjInt).value.toInt()
val col = (index.list[1] as ObjInt).value.toInt()
val data = (thisObj as ObjInstance).data as IntArray
ObjInt.of(data[row * 2 + col].toLong())
}
addFun("putAt") {
val index = args.requiredArg<ObjList>(0)
val value = args.requiredArg<ObjInt>(1).value.toInt()
val row = (index.list[0] as ObjInt).value.toInt()
val col = (index.list[1] as ObjInt).value.toInt()
val data = (thisObj as ObjInstance).data as IntArray
data[row * 2 + col] = value
ObjVoid
}
}
```
Usage from Lyng:
```lyng
val g = Grid()
g[0, 1] = 42
assertEquals(42, g[0, 1])
```
Important rule: multiple selectors inside brackets are packed into one index object.
So:
- `x[i]` passes `i`
- `x[i, j]` passes a `List` containing `[i, j]`
- `x[i, j, k]` passes `[i, j, k]`
This applies equally to:
- Kotlin-backed classes
- Lyng classes overriding `getAt`
- `dynamic { get { ... } set { ... } }`
If you want multi-axis slicing semantics, decode that list yourself in `getAt`.
### 5) Add Kotlin‑backed fields ### 5) Add Kotlin‑backed fields
If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances. If you need a simple field (with a value) instead of a computed property, use `createField`. This adds a field to the class that will be present in all its instances.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
val myClass = ObjClass("MyClass") val myClass = ObjClass("MyClass")
// Add a read-only field (constant) // Add a read-only field (constant)
@@ -215,6 +330,8 @@ println(instance.count) // -> 5
Properties in Lyng are pure accessors (getters and setters) and do not have automatic backing fields. You can add them to a class using `addProperty`. Properties in Lyng are pure accessors (getters and setters) and do not have automatic backing fields. You can add them to a class using `addProperty`.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
val myClass = ObjClass("MyClass") val myClass = ObjClass("MyClass")
var internalValue: Long = 10 var internalValue: Long = 10
@@ -381,8 +498,9 @@ For Kotlin code that needs dynamic access to Lyng variables, functions, or membe
It provides explicit, cached handles and predictable lookup rules. It provides explicit, cached handles and predictable lookup rules.
```kotlin ```kotlin
val scope = Script.newScope() val session = EvalSession()
scope.eval(""" val scope = session.getScope()
session.eval("""
val x = 40 val x = 40
fun add(a, b) = a + b fun add(a, b) = a + b
class Box { var value = 1 } class Box { var value = 1 }
@@ -397,7 +515,7 @@ val x = resolver.resolveVal("x").get(scope)
val sum = (resolver as BridgeCallByName).callByName(scope, "add", Arguments(ObjInt(1), ObjInt(2))) val sum = (resolver as BridgeCallByName).callByName(scope, "add", Arguments(ObjInt(1), ObjInt(2)))
// Member access // Member access
val box = scope.eval("Box()") val box = session.eval("Box()")
val valueHandle = resolver.resolveMemberVar(box, "value") val valueHandle = resolver.resolveMemberVar(box, "value")
valueHandle.set(scope, ObjInt(10)) valueHandle.set(scope, ObjInt(10))
val value = valueHandle.get(scope) val value = valueHandle.get(scope)
@@ -408,12 +526,14 @@ val value = valueHandle.get(scope)
The simplest approach: evaluate an expression that yields the value and convert it. The simplest approach: evaluate an expression that yields the value and convert it.
```kotlin ```kotlin
val kotlinAnswer = scope.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int) val session = EvalSession()
val scope = session.getScope()
val kotlinAnswer = session.eval("(1 + 2) * 3").toKotlin(scope) // -> 9 (Int)
// After scripts manipulate your vars: // After scripts manipulate your vars:
scope.addOrUpdateItem("name", ObjString("Lyng")) scope.addOrUpdateItem("name", ObjString("Lyng"))
scope.eval("name = name + ' rocks!'") session.eval("name = name + ' rocks!'")
val kotlinName = scope.eval("name").toKotlin(scope) // -> "Lyng rocks!" val kotlinName = session.eval("name").toKotlin(scope) // -> "Lyng rocks!"
``` ```
Advanced: you can also grab a variable record directly via `scope.get(name)` and work with its `Obj` value, but evaluating `"name"` is often clearer and enforces Lyng semantics consistently. Advanced: you can also grab a variable record directly via `scope.get(name)` and work with its `Obj` value, but evaluating `"name"` is often clearer and enforces Lyng semantics consistently.
@@ -426,16 +546,20 @@ There are two convenient patterns.
```kotlin ```kotlin
// Suppose Lyng defines: fun add(a, b) = a + b // Suppose Lyng defines: fun add(a, b) = a + b
scope.eval("fun add(a, b) = a + b") val session = EvalSession()
val scope = session.getScope()
session.eval("fun add(a, b) = a + b")
val sum = scope.eval("add(20, 22)").toKotlin(scope) // -> 42 val sum = session.eval("add(20, 22)").toKotlin(scope) // -> 42
``` ```
2) Call a Lyng function by name via a prepared call scope: 2) Call a Lyng function by name via a prepared call scope:
```kotlin ```kotlin
// Ensure the function exists in the scope // Ensure the function exists in the scope
scope.eval("fun add(a, b) = a + b") val session = EvalSession()
val scope = session.getScope()
session.eval("fun add(a, b) = a + b")
// Look up the function object // Look up the function object
val addFn = scope.get("add")!!.value as Statement val addFn = scope.get("add")!!.value as Statement
@@ -466,7 +590,8 @@ Register a Kotlin‑built package:
import net.sergeych.lyng.bridge.* import net.sergeych.lyng.bridge.*
import net.sergeych.lyng.obj.ObjInt import net.sergeych.lyng.obj.ObjInt
val scope = Script.newScope() val session = EvalSession()
val scope = session.getScope()
// Access the import manager behind this scope // Access the import manager behind this scope
val im: ImportManager = scope.importManager val im: ImportManager = scope.importManager
@@ -497,12 +622,12 @@ im.addPackage("my.tools") { module: ModuleScope ->
} }
// Use it from Lyng // Use it from Lyng
scope.eval(""" session.eval("""
import my.tools.* import my.tools.*
val v = triple(14) val v = triple(14)
status = "busy" status = "busy"
""") """)
val v = scope.eval("v").toKotlin(scope) // -> 42 val v = session.eval("v").toKotlin(scope) // -> 42
``` ```
Register a package from Lyng source text: Register a package from Lyng source text:
@@ -516,24 +641,27 @@ val pkgText = """
scope.importManager.addTextPackages(pkgText) scope.importManager.addTextPackages(pkgText)
scope.eval(""" session.eval("""
import math.extra.* import math.extra.*
val s = sqr(12) val s = sqr(12)
""") """)
val s = scope.eval("s").toKotlin(scope) // -> 144 val s = session.eval("s").toKotlin(scope) // -> 144
``` ```
You can also register from parsed `Source` instances via `addSourcePackages(source)`. You can also register from parsed `Source` instances via `addSourcePackages(source)`.
### 10) Executing from files, security, and isolation ### 10) Executing from files, security, and isolation
- To run code from a file, read it and pass to `scope.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`. - To run code from a file, read it and pass to `session.eval(text)` or compile with `Compiler.compile(Source(fileName, text))`.
- `ImportManager` takes an optional `SecurityManager` if you need to restrict what packages or operations are available. By default, `Script.defaultImportManager` allows everything suitable for embedded use; clamp it down in sandboxed environments. - `ImportManager` takes an optional `SecurityManager` if you need to restrict what packages or operations are available. By default, `Script.defaultImportManager` allows everything suitable for embedded use; clamp it down in sandboxed environments.
- For isolation, create fresh modules/scopes via `Scope.new()` or `Script.newScope()` when you need a clean environment per request. - For isolation, prefer a fresh `EvalSession()` per request. Use `Scope.new()` / `Script.newScope()` when you specifically need low-level raw scopes or modules.
```kotlin ```kotlin
// Fresh module based on the default manager, without the standard prelude // Preferred per-request runtime:
val isolated = net.sergeych.lyng.Scope.new() val isolatedSession = EvalSession()
// Low-level fresh module based on the default manager, without the standard prelude:
val isolatedScope = net.sergeych.lyng.Scope.new()
``` ```
### 11) Tips and troubleshooting ### 11) Tips and troubleshooting
@@ -568,8 +696,11 @@ To simplify handling these objects from Kotlin, several extension methods are pr
You can serialize Lyng exception objects using `Lynon` to transmit them across boundaries and then rethrow them. You can serialize Lyng exception objects using `Lynon` to transmit them across boundaries and then rethrow them.
```kotlin ```kotlin
val session = EvalSession()
val scope = session.getScope()
try { try {
scope.eval("throw MyUserException(404, \"Not Found\")") session.eval("throw MyUserException(404, \"Not Found\")")
} catch (e: ExecutionError) { } catch (e: ExecutionError) {
// 1. Serialize the Lyng exception object // 1. Serialize the Lyng exception object
val encoded: UByteArray = lynonEncodeAny(scope, e.errorObject) val encoded: UByteArray = lynonEncodeAny(scope, e.errorObject)
+4 -3
View File
@@ -122,7 +122,8 @@ data class TestJson2(
@Test @Test
fun deserializeMapWithJsonTest() = runTest { fun deserializeMapWithJsonTest() = runTest {
val x = eval(""" val session = EvalSession()
val x = session.eval("""
import lyng.serialization import lyng.serialization
{ value: 1, inner: { "foo": 1, "bar": 2 }} { value: 1, inner: { "foo": 1, "bar": 2 }}
""".trimIndent()).decodeSerializable<TestJson2>() """.trimIndent()).decodeSerializable<TestJson2>()
@@ -143,7 +144,8 @@ data class TestJson3(
) )
@Test @Test
fun deserializeAnyMapWithJsonTest() = runTest { fun deserializeAnyMapWithJsonTest() = runTest {
val x = eval(""" val session = EvalSession()
val x = session.eval("""
import lyng.serialization import lyng.serialization
{ value: 12, inner: { "foo": 1, "bar": "two" }} { value: 12, inner: { "foo": 1, "bar": "two" }}
""".trimIndent()).decodeSerializable<TestJson3>() """.trimIndent()).decodeSerializable<TestJson3>()
@@ -175,4 +177,3 @@ on [Instant](time.md), see `Instant.truncateTo...` functions.
(3) (3)
: Map keys must be strings, map values may be any objects serializable to Json. : Map keys must be strings, map values may be any objects serializable to Json.
+3 -2
View File
@@ -9,12 +9,13 @@
#### Install in host #### Install in host
```kotlin ```kotlin
import net.sergeych.lyng.Script import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.io.console.createConsoleModule import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
suspend fun initScope() { suspend fun initScope() {
val scope = Script.newScope() val session = EvalSession()
val scope = session.getScope()
createConsoleModule(PermitAllConsoleAccessPolicy, scope) createConsoleModule(PermitAllConsoleAccessPolicy, scope)
} }
``` ```
+10 -6
View File
@@ -39,23 +39,27 @@ This brings in:
--- ---
#### Install the module into a Lyng Scope #### Install the module into a Lyng session
The filesystem module is not installed automatically. You must explicitly register it in the scope’s `ImportManager` using the installer. You can customize access control via `FsAccessPolicy`. The filesystem module is not installed automatically. The preferred host runtime is `EvalSession`: create the session, get its underlying scope, install the module there, and execute scripts through the session. You can customize access control via `FsAccessPolicy`.
Kotlin (host) bootstrap example: Kotlin (host) bootstrap example:
```kotlin ```kotlin
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
val scope: Scope = Scope.new() suspend fun bootstrapFs() {
val session = EvalSession()
val scope: Scope = session.getScope()
val installed: Boolean = createFs(PermitAllAccessPolicy, scope) val installed: Boolean = createFs(PermitAllAccessPolicy, scope)
// installed == true on first registration in this ImportManager, false on repeats // installed == true on first registration in this ImportManager, false on repeats
// In scripts (or via scope.eval), import the module to use its symbols: // In scripts (or via session.eval), import the module to use its symbols:
scope.eval("import lyng.io.fs") session.eval("import lyng.io.fs")
}
``` ```
You can install with a custom policy too (see Access policy below). You can install with a custom policy too (see Access policy below).
@@ -185,7 +189,7 @@ val denyWrites = object : FsAccessPolicy {
} }
createFs(denyWrites, scope) createFs(denyWrites, scope)
scope.eval("import lyng.io.fs") session.eval("import lyng.io.fs")
``` ```
Composite operations like `copy` and `move` are checked as a set of primitives (e.g., `OpenRead(src)` + `Delete(dst)` if overwriting + `CreateFile(dst)` + `OpenWrite(dst)`). Composite operations like `copy` and `move` are checked as a set of primitives (e.g., `OpenRead(src)` + `Delete(dst)` if overwriting + `CreateFile(dst)` + `OpenWrite(dst)`).
+179
View File
@@ -0,0 +1,179 @@
### lyng.io.http — HTTP/HTTPS client for Lyng scripts
This module provides a compact HTTP client API for Lyng scripts. It is implemented in `lyngio` and backed by Ktor on supported runtimes.
> **Note:** `lyngio` is a separate library module. It must be explicitly added as a dependency to your host application and initialized in your Lyng scopes.
---
#### Add the library to your project (Gradle)
If you use this repository as a multi-module project, add a dependency on `:lyngio`:
```kotlin
dependencies {
implementation("net.sergeych:lyngio:0.0.1-SNAPSHOT")
}
```
For external projects, ensure you also use the Lyng Maven repository described in `lyng.io.fs`.
---
#### Install the module into a Lyng session
The HTTP module is not installed automatically. Install it into the session scope and provide a policy.
Kotlin (host) bootstrap example:
```kotlin
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope
import net.sergeych.lyng.io.http.createHttpModule
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
suspend fun bootstrapHttp() {
val session = EvalSession()
val scope: Scope = session.getScope()
createHttpModule(PermitAllHttpAccessPolicy, scope)
session.eval("import lyng.io.http")
}
```
---
#### Using from Lyng scripts
Simple GET:
import lyng.io.http
val r = Http.get(HTTP_TEST_URL + "/hello")
[r.status, r.text()]
>>> [200,hello from test]
Headers and response header access:
import lyng.io.http
val r = Http.get(HTTP_TEST_URL + "/headers")
[r.headers["X-Reply"], r.headers.getAll("X-Reply").size, r.text()]
>>> [one,2,header demo]
Programmatic request object:
import lyng.io.http
val q = HttpRequest()
q.method = "POST"
q.url = HTTP_TEST_URL + "/echo"
q.headers = Map("Content-Type" => "text/plain")
q.bodyText = "ping"
val r = Http.request(q)
r.text()
>>> "POST:ping"
HTTPS GET:
import lyng.io.http
val r = Http.get(HTTPS_TEST_URL + "/hello")
[r.status, r.text()]
>>> [200,hello from test]
---
#### API reference
##### `Http` (static methods)
- `isSupported(): Bool` — Whether HTTP client support is available on the current runtime.
- `request(req: HttpRequest): HttpResponse` — Execute a request described by a mutable request object.
- `get(url: String, headers...): HttpResponse` — Convenience GET request.
- `post(url: String, bodyText: String = "", contentType: String? = null, headers...): HttpResponse` — Convenience text POST request.
- `postBytes(url: String, body: Buffer, contentType: String? = null, headers...): HttpResponse` — Convenience binary POST request.
For convenience methods, `headers...` accepts:
- `MapEntry`, e.g. `"Accept" => "text/plain"`
- 2-item lists, e.g. `["Accept", "text/plain"]`
##### `HttpRequest`
- `method: String`
- `url: String`
- `headers: Map<String, String>`
- `bodyText: String?`
- `bodyBytes: Buffer?`
- `timeoutMillis: Int?`
Only one of `bodyText` and `bodyBytes` should be set.
##### `HttpResponse`
- `status: Int`
- `statusText: String`
- `headers: HttpHeaders`
- `text(): String`
- `bytes(): Buffer`
Response body decoding is cached inside the response object.
##### `HttpHeaders`
`HttpHeaders` behaves like `Map<String, String>` for the first value of each header name and additionally exposes:
- `get(name: String): String?`
- `getAll(name: String): List<String>`
- `names(): List<String>`
Header lookup is case-insensitive.
---
#### Security policy
The module uses `HttpAccessPolicy` to authorize requests before they are sent.
- `HttpAccessPolicy` — interface for custom policies
- `PermitAllHttpAccessPolicy` — allows all requests
- `HttpAccessOp.Request(method, url)` — operation checked by the policy
Example restricted policy in Kotlin:
```kotlin
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import net.sergeych.lyngio.http.security.HttpAccessOp
import net.sergeych.lyngio.http.security.HttpAccessPolicy
val allowLocalOnly = object : HttpAccessPolicy {
override suspend fun check(op: HttpAccessOp, ctx: AccessContext): AccessDecision =
when (op) {
is HttpAccessOp.Request ->
if (
op.url.startsWith("http://127.0.0.1:") ||
op.url.startsWith("https://127.0.0.1:") ||
op.url.startsWith("http://localhost:") ||
op.url.startsWith("https://localhost:")
)
AccessDecision(Decision.Allow)
else
AccessDecision(Decision.Deny, "only local HTTP/HTTPS requests are allowed")
}
}
```
---
#### Platform support
- **JVM:** supported
- **Android:** supported via the Ktor CIO client backend
- **JS:** supported via the Ktor JS client backend
- **Linux native:** supported via the Ktor Curl client backend
- **Windows native:** supported via the Ktor WinHttp client backend
- **Apple native:** supported via the Ktor Darwin client backend
- **Other targets:** may report unsupported; use `Http.isSupported()` before relying on it
+169
View File
@@ -0,0 +1,169 @@
### lyng.io.net — TCP and UDP sockets for Lyng scripts
This module provides minimal raw transport networking for Lyng scripts. It is implemented in `lyngio` and backed by Ktor sockets on the JVM and Linux Native, and by Node networking APIs on JS/Node runtimes.
> **Note:** `lyngio` is a separate library module. It must be explicitly added as a dependency to your host application and initialized in your Lyng scopes.
---
#### Install the module into a Lyng session
Kotlin (host) bootstrap example:
```kotlin
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope
import net.sergeych.lyng.io.net.createNetModule
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
suspend fun bootstrapNet() {
val session = EvalSession()
val scope: Scope = session.getScope()
createNetModule(PermitAllNetAccessPolicy, scope)
session.eval("import lyng.io.net")
}
```
---
#### Using from Lyng scripts
Capability checks and address resolution:
import lyng.io.net
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
[Net.isSupported(), a.toString(), a.resolved, a.ipVersion == IpVersion.IPV4]
>>> [true,127.0.0.1:4040,true,true]
TCP client connect, write, read, and close:
import lyng.buffer
import lyng.io.net
val socket = Net.tcpConnect("127.0.0.1", NET_TEST_TCP_PORT)
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
socket.close()
reply
>>> "reply:ping"
Lyng TCP server socket operations with `tcpListen()` and `accept()`:
import lyng.buffer
import lyng.io.net
val server = Net.tcpListen(0, "127.0.0.1")
val port = server.localAddress().port
val accepted = launch {
val client = server.accept()
val line = (client.read(4) as Buffer).decodeUtf8()
client.writeUtf8("echo:" + line)
client.flush()
client.close()
server.close()
line
}
val socket = Net.tcpConnect("127.0.0.1", port)
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
socket.close()
[accepted.await(), reply]
>>> [ping,echo:ping]
UDP bind, send, receive, and inspect sender address:
import lyng.buffer
import lyng.io.net
val server = Net.udpBind(0, "127.0.0.1")
val client = Net.udpBind(0, "127.0.0.1")
client.send(Buffer("ping"), "127.0.0.1", server.localAddress().port)
val d = server.receive()
client.close()
server.close()
[d.data.decodeUtf8(), d.address.port > 0]
>>> [ping,true]
---
#### API reference
##### `Net` (static methods)
- `isSupported(): Bool` — Whether any raw networking support is available.
- `isTcpAvailable(): Bool` — Whether outbound TCP sockets are available.
- `isTcpServerAvailable(): Bool` — Whether listening TCP server sockets are available.
- `isUdpAvailable(): Bool` — Whether UDP datagram sockets are available.
- `resolve(host: String, port: Int): List<SocketAddress>` — Resolve a host and port into concrete addresses.
- `tcpConnect(host: String, port: Int, timeoutMillis: Int? = null, noDelay: Bool = true): TcpSocket` — Open an outbound TCP socket.
- `tcpListen(port: Int, host: String? = null, backlog: Int = 128, reuseAddress: Bool = true): TcpServer` — Start a listening TCP server socket.
- `udpBind(port: Int = 0, host: String? = null, reuseAddress: Bool = true): UdpSocket` — Bind a UDP socket.
##### `SocketAddress`
- `host: String`
- `port: Int`
- `ipVersion: IpVersion`
- `resolved: Bool`
- `toString(): String`
##### `TcpSocket`
- `isOpen(): Bool`
- `localAddress(): SocketAddress`
- `remoteAddress(): SocketAddress`
- `read(maxBytes: Int = 65536): Buffer?`
- `readLine(): String?`
- `write(data: Buffer): void`
- `writeUtf8(text: String): void`
- `flush(): void`
- `close(): void`
##### `TcpServer`
- `isOpen(): Bool`
- `localAddress(): SocketAddress`
- `accept(): TcpSocket`
- `close(): void`
##### `UdpSocket`
- `isOpen(): Bool`
- `localAddress(): SocketAddress`
- `receive(maxBytes: Int = 65536): Datagram?`
- `send(data: Buffer, host: String, port: Int): void`
- `close(): void`
##### `Datagram`
- `data: Buffer`
- `address: SocketAddress`
---
#### Security policy
The module uses `NetAccessPolicy` to authorize network operations before they are executed.
- `NetAccessPolicy` — interface for custom policies
- `PermitAllNetAccessPolicy` — allows all network operations
- `NetAccessOp.Resolve(host, port)`
- `NetAccessOp.TcpConnect(host, port)`
- `NetAccessOp.TcpListen(host, port, backlog)`
- `NetAccessOp.UdpBind(host, port)`
---
#### Platform support
- **JVM:** supported
- **Android:** supported via the Ktor CIO and Ktor sockets backends
- **JS/Node:** supported for `resolve`, TCP client/server, and UDP
- **JS/browser:** unsupported; capability checks report unavailable
- **Linux Native:** supported via Ktor sockets
- **Apple Native:** enabled via the shared native Ktor sockets backend; compile-verified, runtime not yet host-verified
- **Other native targets:** currently report unsupported; use capability checks before relying on raw sockets
+9 -7
View File
@@ -20,24 +20,26 @@ For external projects, ensure you have the appropriate Maven repository configur
--- ---
#### Install the module into a Lyng Scope #### Install the module into a Lyng session
The process module is not installed automatically. You must explicitly register it in the scope’s `ImportManager` using `createProcessModule`. You can customize access control via `ProcessAccessPolicy`. The process module is not installed automatically. The preferred host runtime is `EvalSession`: create the session, get its underlying scope, install the module there, and execute scripts through the session. You can customize access control via `ProcessAccessPolicy`.
Kotlin (host) bootstrap example: Kotlin (host) bootstrap example:
```kotlin ```kotlin
import net.sergeych.lyng.Scope import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.io.process.createProcessModule import net.sergeych.lyng.io.process.createProcessModule
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
// ... inside a suspend function or runBlocking suspend fun bootstrapProcess() {
val scope: Scope = Script.newScope() val session = EvalSession()
val scope: Scope = session.getScope()
createProcessModule(PermitAllProcessAccessPolicy, scope) createProcessModule(PermitAllProcessAccessPolicy, scope)
// In scripts (or via scope.eval), import the module: // In scripts (or via session.eval), import the module:
scope.eval("import lyng.io.process") session.eval("import lyng.io.process")
}
``` ```
--- ---
+148
View File
@@ -0,0 +1,148 @@
### lyng.io.ws — WebSocket client for Lyng scripts
This module provides a compact WebSocket client API for Lyng scripts. It is implemented in `lyngio` and currently backed by Ktor WebSockets on the JVM.
> **Note:** `lyngio` is a separate library module. It must be explicitly added as a dependency to your host application and initialized in your Lyng scopes.
---
#### Install the module into a Lyng session
Kotlin (host) bootstrap example:
```kotlin
import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.Scope
import net.sergeych.lyng.io.ws.createWsModule
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
suspend fun bootstrapWs() {
val session = EvalSession()
val scope: Scope = session.getScope()
createWsModule(PermitAllWsAccessPolicy, scope)
session.eval("import lyng.io.ws")
}
```
---
#### Using from Lyng scripts
Simple text message exchange:
import lyng.io.ws
val ws = Ws.connect(WS_TEST_URL)
ws.sendText("ping")
val m: WsMessage = ws.receive()
ws.close()
[ws.url() == WS_TEST_URL, m.isText, m.text]
>>> [true,true,echo:ping]
Binary message exchange:
import lyng.buffer
import lyng.io.ws
val ws = Ws.connect(WS_TEST_BINARY_URL)
ws.sendBytes(Buffer(9, 8, 7))
val m: WsMessage = ws.receive()
ws.close()
[m.isText, (m.data as Buffer).hex]
>>> [false,010203090807]
Secure websocket (`wss`) exchange:
import lyng.io.ws
val ws = Ws.connect(WSS_TEST_URL)
ws.sendText("ping")
val m: WsMessage = ws.receive()
ws.close()
[ws.url() == WSS_TEST_URL, m.text]
>>> [true,secure:ping]
---
#### API reference
##### `Ws` (static methods)
- `isSupported(): Bool` — Whether WebSocket client support is available on the current runtime.
- `connect(url: String, headers...): WsSession` — Open a client websocket session.
`headers...` accepts:
- `MapEntry`, e.g. `"Authorization" => "Bearer x"`
- 2-item lists, e.g. `["Authorization", "Bearer x"]`
##### `WsSession`
- `isOpen(): Bool`
- `url(): String`
- `sendText(text: String): void`
- `sendBytes(data: Buffer): void`
- `receive(): WsMessage?`
- `close(code: Int = 1000, reason: String = ""): void`
`receive()` returns `null` after a clean close.
##### `WsMessage`
- `isText: Bool`
- `text: String?`
- `data: Buffer?`
Text messages populate `text`; binary messages populate `data`.
---
#### Security policy
The module uses `WsAccessPolicy` to authorize websocket operations.
- `WsAccessPolicy` — interface for custom policies
- `PermitAllWsAccessPolicy` — allows all websocket operations
- `WsAccessOp.Connect(url)`
- `WsAccessOp.Send(url, bytes, isText)`
- `WsAccessOp.Receive(url)`
Example restricted policy in Kotlin:
```kotlin
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import net.sergeych.lyngio.ws.security.WsAccessOp
import net.sergeych.lyngio.ws.security.WsAccessPolicy
val allowLocalOnly = object : WsAccessPolicy {
override suspend fun check(op: WsAccessOp, ctx: AccessContext): AccessDecision =
when (op) {
is WsAccessOp.Connect ->
if (
op.url.startsWith("ws://127.0.0.1:") ||
op.url.startsWith("wss://127.0.0.1:") ||
op.url.startsWith("ws://localhost:") ||
op.url.startsWith("wss://localhost:")
)
AccessDecision(Decision.Allow)
else
AccessDecision(Decision.Deny, "only local ws/wss connections are allowed")
else -> AccessDecision(Decision.Allow)
}
}
```
---
#### Platform support
- **JVM:** supported
- **Android:** supported via the Ktor CIO websocket client backend
- **JS:** supported via the Ktor JS websocket client backend
- **Linux native:** supported via the Ktor Curl websocket client backend
- **Windows native:** supported via the Ktor WinHttp websocket client backend
- **Apple native:** supported via the Ktor Darwin websocket client backend
- **Other targets:** may report unsupported; use `Ws.isSupported()` before relying on websocket client access
+43 -11
View File
@@ -13,6 +13,9 @@
- **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing. - **[lyng.io.fs](lyng.io.fs.md):** Async filesystem access. Provides the `Path` class for file/directory operations, streaming, and globbing.
- **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information. - **[lyng.io.process](lyng.io.process.md):** External process execution and shell commands. Provides `Process`, `RunningProcess`, and `Platform` information.
- **[lyng.io.console](lyng.io.console.md):** Rich console/TTY access. Provides `Console` capability detection, geometry, output, and iterable events. - **[lyng.io.console](lyng.io.console.md):** Rich console/TTY access. Provides `Console` capability detection, geometry, output, and iterable events.
- **[lyng.io.http](lyng.io.http.md):** HTTP/HTTPS client access. Provides `Http`, `HttpRequest`, `HttpResponse`, and `HttpHeaders`.
- **[lyng.io.ws](lyng.io.ws.md):** WebSocket client access. Provides `Ws`, `WsSession`, and `WsMessage`.
- **[lyng.io.net](lyng.io.net.md):** Transport networking. Provides `Net`, `TcpSocket`, `TcpServer`, `UdpSocket`, and `SocketAddress`.
--- ---
@@ -37,31 +40,47 @@ dependencies {
To use `lyngio` modules in your scripts, you must install them into your Lyng scope and provide a security policy. To use `lyngio` modules in your scripts, you must install them into your Lyng scope and provide a security policy.
```kotlin ```kotlin
import net.sergeych.lyng.Script import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.io.process.createProcessModule import net.sergeych.lyng.io.process.createProcessModule
import net.sergeych.lyng.io.console.createConsoleModule import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyng.io.http.createHttpModule
import net.sergeych.lyng.io.net.createNetModule
import net.sergeych.lyng.io.ws.createWsModule
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy import net.sergeych.lyngio.process.security.PermitAllProcessAccessPolicy
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
suspend fun runMyScript() { suspend fun runMyScript() {
val scope = Script.newScope() val session = EvalSession()
val scope = session.getScope()
// Install modules with policies // Install modules with policies
createFs(PermitAllAccessPolicy, scope) createFs(PermitAllAccessPolicy, scope)
createProcessModule(PermitAllProcessAccessPolicy, scope) createProcessModule(PermitAllProcessAccessPolicy, scope)
createConsoleModule(PermitAllConsoleAccessPolicy, scope) createConsoleModule(PermitAllConsoleAccessPolicy, scope)
createHttpModule(PermitAllHttpAccessPolicy, scope)
createNetModule(PermitAllNetAccessPolicy, scope)
createWsModule(PermitAllWsAccessPolicy, scope)
// Now scripts can import them // Now scripts can import them
scope.eval(""" session.eval("""
import lyng.io.fs import lyng.io.fs
import lyng.io.process import lyng.io.process
import lyng.io.console import lyng.io.console
import lyng.io.http
import lyng.io.net
import lyng.io.ws
println("Working dir: " + Path(".").readUtf8()) println("Working dir: " + Path(".").readUtf8())
println("OS: " + Platform.details().name) println("OS: " + Platform.details().name)
println("TTY: " + Console.isTty()) println("TTY: " + Console.isTty())
println("HTTP available: " + Http.isSupported())
println("TCP available: " + Net.isTcpAvailable())
println("WS available: " + Ws.isSupported())
""") """)
} }
``` ```
@@ -75,21 +94,34 @@ suspend fun runMyScript() {
- **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory). - **Filesystem Security:** Implement `FsAccessPolicy` to restrict access to specific paths or operations (e.g., read-only access to a sandbox directory).
- **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely. - **Process Security:** Implement `ProcessAccessPolicy` to restrict which executables can be run or to disable shell execution entirely.
- **Console Security:** Implement `ConsoleAccessPolicy` to control output writes, event reads, and raw mode switching. - **Console Security:** Implement `ConsoleAccessPolicy` to control output writes, event reads, and raw mode switching.
- **HTTP Security:** Implement `HttpAccessPolicy` to restrict which requests scripts may send.
- **Transport Security:** Implement `NetAccessPolicy` to restrict DNS resolution and TCP/UDP socket operations.
- **WebSocket Security:** Implement `WsAccessPolicy` to restrict websocket connects and message flow.
For more details, see the specific module documentation: For more details, see the specific module documentation:
- [Filesystem Security Details](lyng.io.fs.md#access-policy-security) - [Filesystem Security Details](lyng.io.fs.md#access-policy-security)
- [Process Security Details](lyng.io.process.md#security-policy) - [Process Security Details](lyng.io.process.md#security-policy)
- [Console Module Details](lyng.io.console.md) - [Console Module Details](lyng.io.console.md)
- [HTTP Module Details](lyng.io.http.md)
- [Transport Networking Details](lyng.io.net.md)
- [WebSocket Module Details](lyng.io.ws.md)
--- ---
#### Platform Support Overview #### Platform Support Overview
| Platform | lyng.io.fs | lyng.io.process | lyng.io.console | | Platform | lyng.io.fs | lyng.io.process | lyng.io.console | lyng.io.http | lyng.io.ws | lyng.io.net |
| :--- | :---: | :---: | :---: | | :--- | :---: | :---: | :---: | :---: | :---: | :---: |
| **JVM** | ✅ | ✅ | ✅ (baseline) | | **JVM** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| **Native (Linux/macOS)** | ✅ | ✅ | 🚧 | | **Linux Native** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| **Native (Windows)** | ✅ | 🚧 (Planned) | 🚧 | | **Apple Native** | ✅ | ✅ | ✅ | ✅ | ✅ | ⚠️ |
| **Android** | ✅ | ❌ | ❌ | | **Windows Native** | ✅ | ❌ | ✅ | ✅ | ✅ | ❌ |
| **NodeJS** | ✅ | ❌ | ❌ | | **Android** | ✅ | ❌ | ⚠️ | ✅ | ✅ | ✅ |
| **Browser / Wasm** | ✅ (In-memory) | ❌ | ❌ | | **JS / Node** | ✅ | ❌ | ⚠️ | ✅ | ✅ | ✅ |
| **JS / Browser** | ✅ (in-memory) | ❌ | ⚠️ | ✅ | ✅ | ❌ |
| **Wasm** | ✅ (in-memory) | ❌ | ⚠️ | ❌ | ❌ | ❌ |
Legend:
- `✅` supported
- `⚠️` available but environment-dependent or not fully host-verified yet
- `❌` unsupported
+73 -3
View File
@@ -60,8 +60,13 @@ but:
## Round and range ## Round and range
The following functions return its argument if it is `Int`, The following functions return the argument unchanged if it is `Int`.
or transformed `Real` otherwise.
For `Decimal`:
- `floor(x)`, `ceil(x)`, and `round(x)` currently use exact decimal operations
- the result stays `Decimal`
For `Real`, the result is a transformed `Real`.
| name | description | | name | description |
|----------------|--------------------------------------------------------| |----------------|--------------------------------------------------------|
@@ -72,6 +77,14 @@ or transformed `Real` otherwise.
## Lyng math functions ## Lyng math functions
Decimal note:
- all scalar math helpers accept `Decimal`
- `abs(x)` stays exact for `Decimal`
- `pow(x, y)` is exact for `Decimal` when `y` is an integral exponent
- the remaining `Decimal` cases currently use a temporary bridge:
`Decimal -> Real -> host math -> Decimal`
- this is temporary; native decimal implementations are planned
| name | meaning | | name | meaning |
|-----------|------------------------------------------------------| |-----------|------------------------------------------------------|
| sin(x) | sine | | sin(x) | sine |
@@ -91,7 +104,7 @@ or transformed `Real` otherwise.
| log10(x) | $log_{10}(x)$ | | log10(x) | $log_{10}(x)$ |
| pow(x, y) | ${x^y}$ | | pow(x, y) | ${x^y}$ |
| sqrt(x) | $ \sqrt {x}$ | | sqrt(x) | $ \sqrt {x}$ |
| abs(x) | absolute value of x. Int if x is Int, Real otherwise | | abs(x) | absolute value of x. Int if x is Int, Decimal if x is Decimal, Real otherwise |
| clamp(x, range) | limit x to be inside range boundaries | | clamp(x, range) | limit x to be inside range boundaries |
For example: For example:
@@ -104,12 +117,69 @@ For example:
assert( abs(-1) is Int) assert( abs(-1) is Int)
assert( abs(-2.21) == 2.21 ) assert( abs(-2.21) == 2.21 )
import lyng.decimal
// Decimal-aware math works too. Some functions are exact, some still bridge through Real temporarily:
assert( (abs("-2.5".d) as Decimal).toStringExpanded() == "2.5" )
assert( (floor("2.9".d) as Decimal).toStringExpanded() == "2" )
assert( sin("0.5".d) is Decimal )
// clamp() limits value to the range: // clamp() limits value to the range:
assert( clamp(15, 0..10) == 10 ) assert( clamp(15, 0..10) == 10 )
assert( clamp(-5, 0..10) == 0 ) assert( clamp(-5, 0..10) == 0 )
assert( 5.clamp(0..10) == 5 ) assert( 5.clamp(0..10) == 5 )
>>> void >>> void
## Linear algebra: `lyng.matrix`
For vectors and dense matrices, import `lyng.matrix`:
```lyng
import lyng.matrix
```
It provides:
- `Vector`
- `Matrix`
- `vector(values)`
- `matrix(rows)`
Core operations include:
- matrix addition and subtraction
- matrix-matrix multiplication
- matrix-vector multiplication
- transpose
- determinant
- inverse
- linear solve
- vector dot, norm, normalize, cross, outer product
Example:
```lyng
import lyng.matrix
val a: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
val b: Matrix = matrix([[7, 8], [9, 10], [11, 12]])
val product: Matrix = a * b
assertEquals([[58.0, 64.0], [139.0, 154.0]], product.toList())
```
Matrices also support two-axis bracket indexing and slicing:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assertEquals(6.0, m[1, 2])
val sub: Matrix = m[0..1, 1..2]
assertEquals([[2.0, 3.0], [5.0, 6.0]], sub.toList())
```
See [Matrix](Matrix.md) for the full API.
## Random values ## Random values
Lyng stdlib provides a global random singleton and deterministic seeded generators: Lyng stdlib provides a global random singleton and deterministic seeded generators:
+16 -1
View File
@@ -32,10 +32,25 @@ Depending on the platform, these coroutines may be executed on different CPU and
assert(xIsCalled) assert(xIsCalled)
>>> void >>> void
This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion and retrieve possible result. This example shows how to launch a coroutine with `launch` which returns [Deferred] instance, the latter have ways to await for the coroutine completion, cancel it if it is no longer needed, and retrieve possible result.
Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result. Launch has the only argument which should be a callable (lambda usually) that is run in parallel (or cooperatively in parallel), and return anything as the result.
If you no longer need the result, cancel the deferred. Awaiting a cancelled deferred throws `CancellationException`:
var reached = false
val work = launch {
delay(100)
reached = true
"ok"
}
work.cancel()
assertThrows(CancellationException) { work.await() }
assert(work.isCancelled)
assert(!work.isActive)
assert(!reached)
>>> void
## Synchronization: Mutex ## Synchronization: Mutex
Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result: Suppose we have a resource, that could be used concurrently, a counter in our case. If we won't protect it, concurrent usage cause RC, Race Condition, providing wrong result:
+4 -3
View File
@@ -114,10 +114,12 @@ When running end‑to‑end “book” workloads or heavier benches, you can ena
Flags are mutable at runtime, e.g.: Flags are mutable at runtime, e.g.:
```kotlin ```kotlin
runTest {
PerfFlags.ARG_BUILDER = false PerfFlags.ARG_BUILDER = false
val r1 = (Scope().eval(script) as ObjInt).value val r1 = (EvalSession(Scope()).eval(script) as ObjInt).value
PerfFlags.ARG_BUILDER = true PerfFlags.ARG_BUILDER = true
val r2 = (Scope().eval(script) as ObjInt).value val r2 = (EvalSession(Scope()).eval(script) as ObjInt).value
}
``` ```
Reset flags at the end of a test to avoid impacting other tests. Reset flags at the end of a test to avoid impacting other tests.
@@ -619,4 +621,3 @@ Reproduce
Notes Notes
- Negative caches are installed only after a real miss throws (cache‑after‑miss), preserving error semantics and invalidation on `layoutVersion` changes. - Negative caches are installed only after a real miss throws (cache‑after‑miss), preserving error semantics and invalidation on `layoutVersion` changes.
- IndexRef PIC augments the existing direct path and uses move‑to‑front promotion; it is keyed on `(classId, layoutVersion)` like other PICs. - IndexRef PIC augments the existing direct path and uses move‑to‑front promotion; it is keyed on `(classId, layoutVersion)` like other PICs.
+28
View File
@@ -375,6 +375,18 @@ It is rather simple, like everywhere else:
See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed. See [math](math.md) for more on it. Notice using Greek as identifier, all languages are allowed.
For linear algebra, import `lyng.matrix`:
import lyng.matrix
val a: Matrix = matrix([[1, 2], [3, 4]])
val i: Matrix = Matrix.identity(2)
val sum: Matrix = a + i
assertEquals([[2.0, 2.0], [3.0, 5.0]], sum.toList())
>>> void
See [Matrix](Matrix.md) for vectors, matrix multiplication, inversion, and slicing such as `m[0..2, 1]`.
Logical operation could be used the same Logical operation could be used the same
var x = 10 var x = 10
@@ -811,6 +823,14 @@ Lists can contain any type of objects, lists too:
Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md). Notice usage of indexing. You can use negative indexes to offset from the end of the list; see more in [Lists](List.md).
In general, bracket indexing may contain more than one selector:
value[i]
value[i, j]
For built-in lists, strings, maps, and buffers, the selector is usually a single value such as an `Int`, `Range`, or `Regex`.
For types with custom indexers, multiple selectors are packed into one list-like index object and passed to `getAt` / `putAt`.
When you want to "flatten" it to single array, you can use splat syntax: When you want to "flatten" it to single array, you can use splat syntax:
[1, ...[2,3], 4] [1, ...[2,3], 4]
@@ -1699,6 +1719,14 @@ Open-ended ranges could be used to get start and end too:
assertEquals( "pult", "catapult"[ 4.. ]) assertEquals( "pult", "catapult"[ 4.. ])
>>> void >>> void
The same bracket syntax is also used by imported numeric modules such as `lyng.matrix`, where indexing can be multi-axis:
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6]])
assertEquals(6.0, m[1, 2])
>>> void
### String operations ### String operations
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
+48 -1
View File
@@ -5,12 +5,59 @@ For a programmer-focused migration summary, see `docs/whats_new_1_5.md`.
## Language Features ## Language Features
### Matrix and Vector Module (`lyng.matrix`)
Lyng now ships a dense linear algebra module with immutable double-precision `Matrix` and `Vector` types.
It provides:
- `matrix([[...]])` and `vector([...])`
- matrix multiplication
- matrix inversion
- determinant, trace, rank
- solving `A * x = b`
- vector operations such as `dot`, `normalize`, `cross`, and `outer`
```lyng
import lyng.matrix
val a: Matrix = matrix([[4, 7], [2, 6]])
val inv: Matrix = a.inverse()
assert(abs(inv.get(0, 0) - 0.6) < 1e-9)
```
Matrices also support Lyng-style slicing:
```lyng
import lyng.matrix
val m: Matrix = matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
assertEquals(6.0, m[1, 2])
val column: Matrix = m[0..2, 2]
val tail: Matrix = m[1.., 1..]
assertEquals([[3.0], [6.0], [9.0]], column.toList())
assertEquals([[5.0, 6.0], [8.0, 9.0]], tail.toList())
```
See [Matrix](Matrix.md).
### Multiple Selectors in Bracket Indexing
Bracket indexing now accepts more than one selector:
```lyng
value[i]
value[i, j]
value[i, j, k]
```
For custom indexers, multiple selectors are packed into one list-like index object and dispatched through `getAt` / `putAt`.
This is the rule used by `lyng.matrix` and by embedding APIs for Kotlin-backed indexers.
### Decimal Arithmetic Module (`lyng.decimal`) ### Decimal Arithmetic Module (`lyng.decimal`)
Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case. Lyng now ships a first-class decimal module built as a regular extension library rather than a deep core special case.
It provides: It provides:
- `BigDecimal` - `Decimal`
- convenient `.d` conversions from `Int`, `Real`, and `String` - convenient `.d` conversions from `Int`, `Real`, and `String`
- mixed arithmetic with `Int` and `Real` - mixed arithmetic with `Int` and `Real`
- local division precision and rounding control via `withDecimalContext(...)` - local division precision and rounding control via `withDecimalContext(...)`
+23
View File
@@ -0,0 +1,23 @@
#!/env/bin lyng
import lyng.io.http
// Step 1: download the main lynglang.com page.
val home = Http.get("https://lynglang.com").text()
// Step 2: find the version-script reference in the page HTML.
val jsRef = "src=\"([^\"]*lyng-version\\.js)\"".re.find(home)
require(jsRef != null, "lyng-version.js reference not found on the homepage")
// Step 3: extract the referenced script path from the first regex capture.
val versionJsPath = jsRef[1]
// Step 4: download the script that exposes `window.LYNG_VERSION`.
val versionJs = Http.get("https://lynglang.com/" + versionJsPath).text()
// Step 5: pull the actual version string from the JavaScript source.
val versionMatch = "LYNG_VERSION\\s*=\\s*\"([^\"]+)\"".re.find(versionJs)
require(versionMatch != null, "LYNG_VERSION assignment not found")
// Step 6: print the discovered version for the user.
println("Lynglang.com version: " + ((versionMatch as RegexMatch)[1]))
+76
View File
@@ -0,0 +1,76 @@
fun calculateDepth(
T: Real,
m: Real,
d: Real,
rho: Real = 1.2,
c: Real = 340.0,
g: Real = 9.81,
Cd: Real = 0.5,
eps: Real = 1e-3,
maxIter: Int = 100
): Real? {
// Площадь миделя
val r = d / 2.0
val A = π * r * r
// Коэффициент сопротивления
val k = 0.5 * Cd * rho * A
// Предельная скорость
val vTerm = sqrt(m * g / k)
// Функция времени падения с высоты h
fun tFall(h: Real): Real {
// Для численной стабильности при больших h используем логарифмическую форму
val arg = exp(g * h / (vTerm * vTerm))
// arcosh(x) = ln(x + sqrt(x^2 - 1))
val arcosh = ln(arg + sqrt(arg * arg - 1.0))
return vTerm / g * arcosh
}
// Полное расчётное время
fun Tcalc(h: Real): Real = tFall(h) + h / c
// Находим интервал, содержащий корень
// Нижняя граница: глубина не может быть отрицательной
var lo = 0.0
// Верхняя граница: сначала попробуем оценку по свободному падению (без звука)
var hi = 0.5 * g * T * T // максимальная глубина, если бы не было сопротивления и звука
// Уточним hi, чтобы Tcalc(hi) было заведомо больше T
while (Tcalc(hi) < T && hi < 1e4) {
hi *= 2.0
}
// Проверка, что hi достаточно велико
if (Tcalc(hi) < T) return null // слишком большая глубина, не укладываемся в разумное
// Бисекция
var iter = 0
var h = (lo + hi) / 2.0
while (iter < maxIter && (hi - lo) > eps) {
val f = Tcalc(h) - T
if (abs(f) < eps) break
if (f > 0) {
hi = h
} else {
lo = h
}
h = (lo + hi) / 2.0
iter++
}
return h
}
// Пример: T=12 секунд
val T = 26.0
val m = 1.0 // кг
val d = 0.1 // м
val depth = calculateDepth(T, m, d)
if (depth != null) {
println("Глубина: %.2f м"(depth))
// Для проверки выведем теоретическое время при найденной глубине
// (можно добавить функцию для самопроверки)
} else {
println("Расчёт не сошёлся")
}
+21
View File
@@ -0,0 +1,21 @@
import lyng.buffer
import lyng.io.net
val server = Net.tcpListen(0, "127.0.0.1")
val port = server.localAddress().port
val accepted = launch {
val client = server.accept()
val line = (client.read(4) as Buffer).decodeUtf8()
client.writeUtf8("echo:" + line)
client.flush()
client.close()
server.close()
line
}
val socket = Net.tcpConnect("127.0.0.1", port)
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
socket.close()
println("${accepted.await()}: $reply")
+1 -2
View File
@@ -49,6 +49,7 @@ val UNICODE_BOTTOM_RIGHT = "┘"
val UNICODE_HORIZONTAL = "──" val UNICODE_HORIZONTAL = "──"
val UNICODE_VERTICAL = "│" val UNICODE_VERTICAL = "│"
val UNICODE_DOT = "· " val UNICODE_DOT = "· "
val PIECES: List<Piece> = []
type Cell = List<Int> type Cell = List<Int>
type Rotation = List<Cell> type Rotation = List<Cell>
@@ -468,8 +469,6 @@ fun rot(a: Cell, b: Cell, c: Cell, d: Cell): Rotation {
r r
} }
val PIECES: List<Piece> = []
val iRots: Rotations = [] val iRots: Rotations = []
iRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(3,1))) iRots.add(rot(cell(0,1), cell(1,1), cell(2,1), cell(3,1)))
iRots.add(rot(cell(2,0), cell(2,1), cell(2,2), cell(2,3))) iRots.add(rot(cell(2,0), cell(2,1), cell(2,2), cell(2,3)))
+1 -4
View File
@@ -27,9 +27,6 @@ kotlin.mpp.enableCInteropCommonization=true
android.useAndroidX=true android.useAndroidX=true
android.nonTransitiveRClass=true android.nonTransitiveRClass=true
# other
kotlin.native.cacheKind.linuxX64=none
# Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform. # Workaround: Ensure Gradle uses a JDK with `jlink` available for AGP's JDK image transform.
# On this environment, the system JDK 21 installation lacks `jlink`, causing # On this environment, the system JDK 21 installation lacks `jlink`, causing
# :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`. # :lynglib:androidJdkImage to fail. Point Gradle to a JDK that includes `jlink`.
@@ -37,6 +34,6 @@ kotlin.native.cacheKind.linuxX64=none
#org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9 #org.gradle.java.home=/home/sergeych/.jdks/corretto-21.0.9
android.experimental.lint.migrateToK2=false android.experimental.lint.migrateToK2=false
android.lint.useK2Uast=false android.lint.useK2Uast=false
kotlin.mpp.applyDefaultHierarchyTemplate=true kotlin.mpp.applyDefaultHierarchyTemplate=false
org.gradle.parallel=true org.gradle.parallel=true
+14 -1
View File
@@ -2,16 +2,19 @@
agp = "8.5.2" agp = "8.5.2"
clikt = "5.0.3" clikt = "5.0.3"
mordant = "3.0.2" mordant = "3.0.2"
kotlin = "2.3.0" kotlin = "2.3.20"
android-minSdk = "24" android-minSdk = "24"
android-compileSdk = "34" android-compileSdk = "34"
kotlinx-coroutines = "1.10.2" kotlinx-coroutines = "1.10.2"
kotlinx-datetime = "0.6.1" kotlinx-datetime = "0.6.1"
mp_bintools = "0.3.2" mp_bintools = "0.3.2"
ionspin-bignum = "0.3.10" ionspin-bignum = "0.3.10"
multik = "0.3.0"
firebaseCrashlyticsBuildtools = "3.0.3" firebaseCrashlyticsBuildtools = "3.0.3"
okioVersion = "3.10.2" okioVersion = "3.10.2"
compiler = "3.2.0-alpha11" compiler = "3.2.0-alpha11"
ktor = "3.3.1"
slf4j = "2.0.17"
[libraries] [libraries]
clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" } clikt = { module = "com.github.ajalt.clikt:clikt", version.ref = "clikt" }
@@ -24,11 +27,21 @@ kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-c
kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" } kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" } mp_bintools = { module = "net.sergeych:mp_bintools", version.ref = "mp_bintools" }
ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" } ionspin-bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "ionspin-bignum" }
multik-default = { module = "org.jetbrains.kotlinx:multik-default", version.ref = "multik" }
firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" } firebase-crashlytics-buildtools = { group = "com.google.firebase", name = "firebase-crashlytics-buildtools", version.ref = "firebaseCrashlyticsBuildtools" }
okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" } okio = { module = "com.squareup.okio:okio", version.ref = "okioVersion" }
okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" } okio-fakefilesystem = { module = "com.squareup.okio:okio-fakefilesystem", version.ref = "okioVersion" }
okio-nodefilesystem = { module = "com.squareup.okio:okio-nodefilesystem", version.ref = "okioVersion" } okio-nodefilesystem = { module = "com.squareup.okio:okio-nodefilesystem", version.ref = "okioVersion" }
compiler = { group = "androidx.databinding", name = "compiler", version.ref = "compiler" } compiler = { group = "androidx.databinding", name = "compiler", version.ref = "compiler" }
ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktor" }
ktor-client-cio = { module = "io.ktor:ktor-client-cio", version.ref = "ktor" }
ktor-client-curl = { module = "io.ktor:ktor-client-curl", version.ref = "ktor" }
ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" }
ktor-client-js = { module = "io.ktor:ktor-client-js", version.ref = "ktor" }
ktor-client-winhttp = { module = "io.ktor:ktor-client-winhttp", version.ref = "ktor" }
ktor-client-websockets = { module = "io.ktor:ktor-client-websockets", version.ref = "ktor" }
ktor-network = { module = "io.ktor:ktor-network", version.ref = "ktor" }
slf4j-nop = { module = "org.slf4j:slf4j-nop", version.ref = "slf4j" }
[plugins] [plugins]
androidLibrary = { id = "com.android.library", version.ref = "agp" } androidLibrary = { id = "com.android.library", version.ref = "agp" }
@@ -23,6 +23,8 @@ import com.intellij.execution.ui.ConsoleViewContentType
import com.intellij.openapi.actionSystem.AnAction import com.intellij.openapi.actionSystem.AnAction
import com.intellij.openapi.actionSystem.AnActionEvent import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.actionSystem.CommonDataKeys import com.intellij.openapi.actionSystem.CommonDataKeys
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.fileEditor.FileDocumentManager
import com.intellij.openapi.project.Project import com.intellij.openapi.project.Project
import com.intellij.openapi.wm.ToolWindow import com.intellij.openapi.wm.ToolWindow
import com.intellij.openapi.wm.ToolWindowAnchor import com.intellij.openapi.wm.ToolWindowAnchor
@@ -36,9 +38,10 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch import kotlinx.coroutines.launch
import net.sergeych.lyng.idea.LyngIcons import net.sergeych.lyng.idea.LyngIcons
import java.io.File
class RunLyngScriptAction : AnAction(LyngIcons.FILE) { class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob()) private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
private fun getPsiFile(e: AnActionEvent): PsiFile? { private fun getPsiFile(e: AnActionEvent): PsiFile? {
val project = e.project ?: return null val project = e.project ?: return null
@@ -48,36 +51,99 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
} }
} }
private fun getRunnableFile(e: AnActionEvent): PsiFile? {
val psiFile = getPsiFile(e) ?: return null
val virtualFile = psiFile.virtualFile ?: return null
if (!virtualFile.isInLocalFileSystem) return null
if (!psiFile.name.endsWith(".lyng")) return null
return psiFile
}
override fun update(e: AnActionEvent) { override fun update(e: AnActionEvent) {
val psiFile = getPsiFile(e) val psiFile = getRunnableFile(e)
val isLyng = psiFile?.name?.endsWith(".lyng") == true val isRunnable = psiFile != null
e.presentation.isEnabledAndVisible = isLyng e.presentation.isEnabledAndVisible = isRunnable
if (isLyng) { if (isRunnable) {
e.presentation.isEnabled = false e.presentation.text = "Run '${psiFile.name}'"
e.presentation.text = "Run '${psiFile.name}' (disabled)" e.presentation.description = "Run the current Lyng script using the Lyng CLI"
e.presentation.description = "Running scripts from the IDE is disabled; use the CLI."
} else { } else {
e.presentation.text = "Run Lyng Script" e.presentation.text = "Run Lyng Script"
e.presentation.description = "Run the current Lyng script"
} }
} }
override fun actionPerformed(e: AnActionEvent) { override fun actionPerformed(e: AnActionEvent) {
val project = e.project ?: return val project = e.project ?: return
val psiFile = getPsiFile(e) ?: return val psiFile = getRunnableFile(e) ?: return
val fileName = psiFile.name val virtualFile = psiFile.virtualFile ?: return
FileDocumentManager.getInstance().getDocument(virtualFile)?.let { document ->
FileDocumentManager.getInstance().saveDocument(document)
}
val filePath = virtualFile.path
val workingDir = virtualFile.parent?.path ?: project.basePath ?: File(filePath).parent
val (console, toolWindow) = getConsoleAndToolWindow(project) val (console, toolWindow) = getConsoleAndToolWindow(project)
console.clear() console.clear()
toolWindow.show { toolWindow.show {
scope.launch { scope.launch {
console.print("--- Run is disabled ---\n", ConsoleViewContentType.SYSTEM_OUTPUT) val command = startLyngProcess(filePath, workingDir)
console.print("Lyng now runs in bytecode-only mode; the IDE no longer evaluates scripts.\n", ConsoleViewContentType.NORMAL_OUTPUT) if (command == null) {
console.print("Use the CLI to run scripts, e.g. `lyng run $fileName`.\n", ConsoleViewContentType.NORMAL_OUTPUT) printToConsole(console, "Unable to start Lyng CLI.\n", ConsoleViewContentType.ERROR_OUTPUT)
printToConsole(console, "Tried commands: lyng, jlyng.\n", ConsoleViewContentType.ERROR_OUTPUT)
printToConsole(console, "Install `lyng` or `jlyng` and make sure it is available on PATH.\n", ConsoleViewContentType.NORMAL_OUTPUT)
return@launch
}
printToConsole(
console,
"Running ${command.commandLine} in ${command.workingDir}\n",
ConsoleViewContentType.SYSTEM_OUTPUT
)
streamProcess(command.process, console)
val exitCode = command.process.waitFor()
val outputType = if (exitCode == 0) ConsoleViewContentType.SYSTEM_OUTPUT else ConsoleViewContentType.ERROR_OUTPUT
printToConsole(console, "\nProcess finished with exit code $exitCode\n", outputType)
} }
} }
} }
private suspend fun streamProcess(process: Process, console: ConsoleView) {
val stdout = scope.launch {
process.inputStream.bufferedReader().useLines { lines ->
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.NORMAL_OUTPUT) }
}
}
val stderr = scope.launch {
process.errorStream.bufferedReader().useLines { lines ->
lines.forEach { printToConsole(console, "$it\n", ConsoleViewContentType.ERROR_OUTPUT) }
}
}
stdout.join()
stderr.join()
}
private fun printToConsole(console: ConsoleView, text: String, type: ConsoleViewContentType) {
ApplicationManager.getApplication().invokeLater {
console.print(text, type)
}
}
private fun startLyngProcess(filePath: String, workingDir: String?): StartedProcess? {
val candidates = listOf("lyng", "jlyng")
for (candidate in candidates) {
try {
val process = ProcessBuilder(candidate, filePath)
.directory(workingDir?.let(::File))
.start()
return StartedProcess(process, "$candidate $filePath", workingDir ?: File(filePath).parent.orEmpty())
} catch (_: java.io.IOException) {
// Try the next candidate when the command is not available.
}
}
return null
}
private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> { private fun getConsoleAndToolWindow(project: Project): Pair<ConsoleView, ToolWindow> {
val toolWindowManager = ToolWindowManager.getInstance(project) val toolWindowManager = ToolWindowManager.getInstance(project)
var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN) var toolWindow = toolWindowManager.getToolWindow(ToolWindowId.RUN)
@@ -106,4 +172,10 @@ class RunLyngScriptAction : AnAction(LyngIcons.FILE) {
contentManager.setSelectedContent(content) contentManager.setSelectedContent(content)
return console to actualToolWindow return console to actualToolWindow
} }
private data class StartedProcess(
val process: Process,
val commandLine: String,
val workingDir: String
)
} }
+13 -8
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -34,11 +34,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets in this module // Suppress Beta warning for expect/actual classes across all targets in this module
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
jvm { jvm {
binaries { binaries {
@@ -75,19 +77,22 @@ kotlin {
implementation(libs.okio.fakefilesystem) implementation(libs.okio.fakefilesystem)
} }
} }
val nativeMain by creating {
dependsOn(commonMain)
}
val jvmMain by getting {
dependencies {
implementation(libs.slf4j.nop)
}
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
implementation(kotlin("test")) implementation(kotlin("test"))
implementation(kotlin("test-junit")) implementation(kotlin("test-junit"))
} }
} }
// val nativeMain by getting {
// dependencies {
// implementation(kotlin("stdlib-common"))
// }
// }
val linuxX64Main by getting { val linuxX64Main by getting {
dependsOn(nativeMain)
} }
} }
} }
+24 -14
View File
@@ -27,16 +27,22 @@ import com.github.ajalt.clikt.parameters.arguments.optional
import com.github.ajalt.clikt.parameters.options.flag import com.github.ajalt.clikt.parameters.options.flag
import com.github.ajalt.clikt.parameters.options.option import com.github.ajalt.clikt.parameters.options.option
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.Compiler import net.sergeych.lyng.EvalSession
import net.sergeych.lyng.LyngVersion import net.sergeych.lyng.LyngVersion
import net.sergeych.lyng.Script import net.sergeych.lyng.Script
import net.sergeych.lyng.ScriptError import net.sergeych.lyng.ScriptError
import net.sergeych.lyng.Source import net.sergeych.lyng.Source
import net.sergeych.lyng.io.console.createConsoleModule import net.sergeych.lyng.io.console.createConsoleModule
import net.sergeych.lyng.io.fs.createFs import net.sergeych.lyng.io.fs.createFs
import net.sergeych.lyng.io.http.createHttpModule
import net.sergeych.lyng.io.net.createNetModule
import net.sergeych.lyng.io.ws.createWsModule
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy import net.sergeych.lyngio.console.security.PermitAllConsoleAccessPolicy
import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy import net.sergeych.lyngio.fs.security.PermitAllAccessPolicy
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
import net.sergeych.mp_tools.globalDefer import net.sergeych.mp_tools.globalDefer
import okio.FileSystem import okio.FileSystem
import okio.Path.Companion.toPath import okio.Path.Companion.toPath
@@ -74,6 +80,11 @@ val baseScopeDefer = globalDefer {
// Install console access by default for interactive CLI scripts. // Install console access by default for interactive CLI scripts.
// Scripts still need to `import lyng.io.console` to use it. // Scripts still need to `import lyng.io.console` to use it.
createConsoleModule(PermitAllConsoleAccessPolicy, this) createConsoleModule(PermitAllConsoleAccessPolicy, this)
// Install network-oriented lyngio modules for CLI scripts.
// Scripts still need to import the modules they use explicitly.
createHttpModule(PermitAllHttpAccessPolicy, this)
createWsModule(PermitAllWsAccessPolicy, this)
createNetModule(PermitAllNetAccessPolicy, this)
} }
} }
@@ -158,6 +169,7 @@ private class Fmt : CliktCommand(name = "fmt") {
private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() { private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand() {
override val invokeWithoutSubcommand = true
override val printHelpOnEmptyArgs = true override val printHelpOnEmptyArgs = true
val version by option("-v", "--version", help = "Print version and exit").flag() val version by option("-v", "--version", help = "Print version and exit").flag()
@@ -204,12 +216,7 @@ private class Lyng(val launcher: (suspend () -> Unit) -> Unit) : CliktCommand()
launcher { launcher {
// there is no script name, it is a first argument instead: // there is no script name, it is a first argument instead:
processErrors { processErrors {
val script = Compiler.compileWithResolution( executeSource(Source("<eval>", execute!!))
Source("<eval>", execute!!),
baseScope.currentImportProvider,
seedScope = baseScope
)
script.execute(baseScope)
} }
} }
} }
@@ -235,6 +242,15 @@ fun executeFileWithArgs(fileName: String, args: List<String>) {
} }
} }
suspend fun executeSource(source: Source) {
val session = EvalSession(baseScopeDefer.await())
try {
session.eval(source)
} finally {
session.cancelAndJoin()
}
}
suspend fun executeFile(fileName: String) { suspend fun executeFile(fileName: String) {
var text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource -> var text = FileSystem.SYSTEM.source(fileName.toPath()).use { fileSource ->
fileSource.buffer().use { bs -> fileSource.buffer().use { bs ->
@@ -247,13 +263,7 @@ suspend fun executeFile(fileName: String) {
text = text.substring(pos + 1) text = text.substring(pos + 1)
} }
processErrors { processErrors {
val scope = baseScopeDefer.await() executeSource(Source(fileName, text))
val script = Compiler.compileWithResolution(
Source(fileName, text),
scope.currentImportProvider,
seedScope = scope
)
script.execute(scope)
} }
} }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -131,4 +131,18 @@ class CliFmtJvmTest {
Files.deleteIfExists(tmp) Files.deleteIfExists(tmp)
} }
} }
@Test
fun inlineExecuteWithDashXStillWorksAndPassesArgv() {
val r = runCli(
"-x",
"""println("INLINE"); println(ARGV[0]); println(ARGV[1])""",
"one",
"two"
)
assertTrue("Expected inline execution output", r.out.contains("INLINE"))
assertTrue("Expected ARGV to include first trailing arg", r.out.contains("one"))
assertTrue("Expected ARGV to include second trailing arg", r.out.contains("two"))
assertTrue("Did not expect CLI exit()", r.exitCode == null)
}
} }
@@ -0,0 +1,141 @@
/*
* 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_cli
import com.sun.net.httpserver.HttpExchange
import com.sun.net.httpserver.HttpServer
import net.sergeych.jvmExitImpl
import net.sergeych.runMain
import org.junit.After
import org.junit.Assert.assertNull
import org.junit.Assert.assertTrue
import org.junit.Before
import org.junit.Test
import java.io.ByteArrayOutputStream
import java.io.PrintStream
import java.net.InetSocketAddress
class CliNetworkJvmTest {
private val originalOut: PrintStream = System.out
private val originalErr: PrintStream = System.err
private class TestExit(val code: Int) : RuntimeException()
@Before
fun setUp() {
jvmExitImpl = { code -> throw TestExit(code) }
}
@After
fun tearDown() {
System.setOut(originalOut)
System.setErr(originalErr)
jvmExitImpl = { code -> kotlin.system.exitProcess(code) }
}
private data class CliResult(val out: String, val err: String, val exitCode: Int?)
private fun runCli(vararg args: String): CliResult {
val outBuf = ByteArrayOutputStream()
val errBuf = ByteArrayOutputStream()
System.setOut(PrintStream(outBuf, true, Charsets.UTF_8))
System.setErr(PrintStream(errBuf, true, Charsets.UTF_8))
var exitCode: Int? = null
try {
runMain(arrayOf(*args))
} catch (e: TestExit) {
exitCode = e.code
} finally {
System.out.flush()
System.err.flush()
}
return CliResult(outBuf.toString("UTF-8"), errBuf.toString("UTF-8"), exitCode)
}
@Test
fun cliHasAllNetworkingModulesInstalled() {
val server = newServer()
try {
val script = """
import lyng.io.http
import lyng.io.ws
import lyng.io.net
assert(Http.isSupported())
println("ws=" + Ws.isSupported())
println("net=" + Net.isSupported())
val home = Http.get("http://127.0.0.1:${server.address.port}/").text()
val jsRef = "src=\"([^\"]*lyng-version\\.js)\"".re.find(home)
require(jsRef != null, "lyng-version.js reference not found")
val versionJsPath = (jsRef as RegexMatch)[1]
val versionJs = Http.get("http://127.0.0.1:${server.address.port}/" + versionJsPath).text()
val versionMatch = "LYNG_VERSION\\s*=\\s*\"([^\"]+)\"".re.find(versionJs)
require(versionMatch != null, "LYNG_VERSION assignment not found")
println("version=" + ((versionMatch as RegexMatch)[1]))
""".trimIndent()
val result = runCli("-x", script)
assertNull(result.exitCode)
assertTrue(result.err, result.err.isBlank())
assertTrue(result.out, result.out.contains("ws="))
assertTrue(result.out, result.out.contains("net="))
assertTrue(result.out, result.out.contains("version=9.9.9-test"))
} finally {
server.stop(0)
}
}
private fun newServer(): HttpServer {
val server = HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
server.createContext("/") { exchange ->
when (exchange.requestURI.path) {
"/" -> writeResponse(
exchange,
200,
"""
<!doctype html>
<html>
<head>
<script src="lyng-version.js"></script>
</head>
<body>
<span id="lyng-version-ribbon"></span>
</body>
</html>
""".trimIndent()
)
"/lyng-version.js" -> writeResponse(exchange, 200, """window.LYNG_VERSION = "9.9.9-test";""")
else -> writeResponse(exchange, 404, "missing")
}
}
server.start()
return server
}
private fun writeResponse(exchange: HttpExchange, status: Int, body: String) {
val bytes = body.toByteArray()
exchange.sendResponseHeaders(status, bytes.size.toLong())
exchange.responseBody.use { out ->
out.write(bytes)
}
}
}
@@ -31,11 +31,12 @@ class FsIntegrationJvmTest {
val dir = createTempDirectory("lyng_cli_fs_test_") val dir = createTempDirectory("lyng_cli_fs_test_")
try { try {
val file = dir.resolve("hello.txt") val file = dir.resolve("hello.txt")
val filePath = file.toString().replace("\\", "\\\\")
// Drive the operation via Lyng code to validate bindings end-to-end // Drive the operation via Lyng code to validate bindings end-to-end
scope.eval( scope.eval(
""" """
import lyng.io.fs import lyng.io.fs
val p = Path("${'$'}{file}") val p = Path("${filePath}")
p.writeUtf8("hello from cli test") p.writeUtf8("hello from cli test")
assertEquals(true, p.exists()) assertEquals(true, p.exists())
assertEquals("hello from cli test", p.readUtf8()) assertEquals("hello from cli test", p.readUtf8())
+78 -14
View File
@@ -44,7 +44,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -62,11 +61,13 @@ kotlin {
// Keep expect/actual warning suppressed consistently with other modules // Keep expect/actual warning suppressed consistently with other modules
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -79,13 +80,58 @@ kotlin {
api(libs.okio) api(libs.okio)
api(libs.kotlinx.coroutines.core) api(libs.kotlinx.coroutines.core)
api(libs.mordant.core) api(libs.mordant.core)
api(libs.ktor.client.core)
implementation(libs.ktor.client.websockets)
}
}
val nativeMain by creating {
dependsOn(commonMain)
dependencies {
implementation(libs.ktor.network)
}
}
val darwinMain by creating {
dependsOn(nativeMain)
dependencies {
implementation(libs.ktor.client.darwin)
}
}
val iosMain by creating {
dependsOn(darwinMain)
}
val linuxMain by creating {
dependsOn(nativeMain)
dependencies {
implementation(libs.ktor.client.curl)
}
}
val macosMain by creating {
dependsOn(darwinMain)
}
val mingwMain by creating {
dependsOn(nativeMain)
dependencies {
implementation(libs.ktor.client.winhttp)
} }
} }
val commonTest by getting { val commonTest by getting {
dependencies { dependencies {
implementation(libs.kotlin.test) implementation(libs.kotlin.test)
implementation(libs.kotlinx.coroutines.test)
} }
} }
val linuxTest by creating {
dependsOn(commonTest)
}
val iosX64Main by getting { dependsOn(iosMain) }
val iosArm64Main by getting { dependsOn(iosMain) }
val iosSimulatorArm64Main by getting { dependsOn(iosMain) }
val macosArm64Main by getting { dependsOn(macosMain) }
val mingwX64Main by getting { dependsOn(mingwMain) }
val linuxX64Main by getting { dependsOn(linuxMain) }
val linuxArm64Main by getting { dependsOn(linuxMain) }
val linuxX64Test by getting { dependsOn(linuxTest) }
val linuxArm64Test by getting { dependsOn(linuxTest) }
// JS: use runtime detection in jsMain to select Node vs Browser implementation // JS: use runtime detection in jsMain to select Node vs Browser implementation
val jsMain by getting { val jsMain by getting {
@@ -93,6 +139,13 @@ kotlin {
api(libs.okio) api(libs.okio)
implementation(libs.okio.fakefilesystem) implementation(libs.okio.fakefilesystem)
implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}") implementation("com.squareup.okio:okio-nodefilesystem:${libs.versions.okioVersion.get()}")
implementation(libs.ktor.client.js)
}
}
val androidMain by getting {
dependencies {
implementation(libs.ktor.client.cio)
implementation(libs.ktor.network)
} }
} }
val jvmMain by getting { val jvmMain by getting {
@@ -100,6 +153,8 @@ kotlin {
implementation(libs.mordant.jvm.jna) implementation(libs.mordant.jvm.jna)
implementation("org.jline:jline-reader:3.29.0") implementation("org.jline:jline-reader:3.29.0")
implementation("org.jline:jline-terminal:3.29.0") implementation("org.jline:jline-terminal:3.29.0")
implementation(libs.ktor.client.cio)
implementation(libs.ktor.network)
} }
} }
// // For Wasm we use in-memory VFS for now // // For Wasm we use in-memory VFS for now
@@ -112,10 +167,10 @@ kotlin {
} }
} }
abstract class GenerateLyngioConsoleDecls : DefaultTask() { abstract class GenerateLyngioDecls : DefaultTask() {
@get:InputFile @get:InputDirectory
@get:PathSensitive(PathSensitivity.RELATIVE) @get:PathSensitive(PathSensitivity.RELATIVE)
abstract val sourceFile: RegularFileProperty abstract val sourceDir: DirectoryProperty
@get:OutputDirectory @get:OutputDirectory
abstract val outputDir: DirectoryProperty abstract val outputDir: DirectoryProperty
@@ -125,9 +180,9 @@ abstract class GenerateLyngioConsoleDecls : DefaultTask() {
val targetPkg = "net.sergeych.lyngio.stdlib_included" val targetPkg = "net.sergeych.lyngio.stdlib_included"
val pkgPath = targetPkg.replace('.', '/') val pkgPath = targetPkg.replace('.', '/')
val targetDir = outputDir.get().asFile.resolve(pkgPath) val targetDir = outputDir.get().asFile.resolve(pkgPath)
if (targetDir.exists()) targetDir.deleteRecursively()
targetDir.mkdirs() targetDir.mkdirs()
val text = sourceFile.get().asFile.readText()
fun escapeForQuoted(s: String): String = buildString { fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) { for (ch in s) when (ch) {
'\\' -> append("\\\\") '\\' -> append("\\\\")
@@ -142,30 +197,39 @@ abstract class GenerateLyngioConsoleDecls : DefaultTask() {
val out = buildString { val out = buildString {
append("package ").append(targetPkg).append("\n\n") append("package ").append(targetPkg).append("\n\n")
append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n") append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
append("internal val consoleLyng = \"") sourceDir.get().asFile
append(escapeForQuoted(text)) .listFiles { file -> file.isFile && file.extension == "lyng" }
?.sortedBy { it.name }
?.forEach { file ->
val propertyName = buildString {
append(file.nameWithoutExtension)
append("Lyng")
}
append("internal val ").append(propertyName).append(" = \"")
append(escapeForQuoted(file.readText()))
append("\"\n") append("\"\n")
} }
targetDir.resolve("console_types_lyng.generated.kt").writeText(out) }
targetDir.resolve("lyngio_types_lyng.generated.kt").writeText(out)
} }
} }
val lyngioConsoleDeclsFile = layout.projectDirectory.file("stdlib/lyng/io/console.lyng") val lyngioDeclsDir = layout.projectDirectory.dir("stdlib/lyng/io")
val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin") val generatedLyngioDeclsDir = layout.buildDirectory.dir("generated/source/lyngioDecls/commonMain/kotlin")
val generateLyngioConsoleDecls by tasks.registering(GenerateLyngioConsoleDecls::class) { val generateLyngioDecls by tasks.registering(GenerateLyngioDecls::class) {
sourceFile.set(lyngioConsoleDeclsFile) sourceDir.set(lyngioDeclsDir)
outputDir.set(generatedLyngioDeclsDir) outputDir.set(generatedLyngioDeclsDir)
} }
kotlin.sourceSets.named("commonMain") { kotlin.sourceSets.named("commonMain") {
kotlin.srcDir(generateLyngioConsoleDecls) kotlin.srcDir(generateLyngioDecls)
} }
kotlin.targets.configureEach { kotlin.targets.configureEach {
compilations.configureEach { compilations.configureEach {
compileTaskProvider.configure { compileTaskProvider.configure {
dependsOn(generateLyngioConsoleDecls) dependsOn(generateLyngioDecls)
} }
} }
} }
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.http
import io.ktor.client.engine.cio.CIO
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(CIO)
@@ -0,0 +1,206 @@
package net.sergeych.lyngio.net
import io.ktor.network.selector.ActorSelectorManager
import io.ktor.network.selector.SelectorManager
import io.ktor.network.sockets.BoundDatagramSocket
import io.ktor.network.sockets.InetSocketAddress
import io.ktor.network.sockets.ServerSocket
import io.ktor.network.sockets.Socket
import io.ktor.network.sockets.aSocket
import io.ktor.network.sockets.isClosed
import io.ktor.network.sockets.openReadChannel
import io.ktor.network.sockets.openWriteChannel
import io.ktor.network.sockets.toJavaAddress
import io.ktor.utils.io.ByteReadChannel
import io.ktor.utils.io.ByteWriteChannel
import io.ktor.utils.io.readAvailable
import io.ktor.utils.io.readUTF8Line
import io.ktor.utils.io.writeFully
import io.ktor.utils.io.writeStringUtf8
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import kotlinx.io.Buffer
import kotlinx.io.readByteArray
import java.net.Inet4Address
import java.net.Inet6Address
import java.net.InetAddress
actual fun getSystemNetEngine(): LyngNetEngine = AndroidKtorNetEngine
private object AndroidKtorNetEngine : LyngNetEngine {
private val selectorManager: SelectorManager by lazy { ActorSelectorManager(Dispatchers.IO) }
override val isSupported: Boolean = true
override val isTcpAvailable: Boolean = true
override val isTcpServerAvailable: Boolean = true
override val isUdpAvailable: Boolean = true
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> = withContext(Dispatchers.IO) {
InetAddress.getAllByName(host).map { address ->
address.toLyngSocketAddress(port = port, resolved = true)
}
}
override suspend fun tcpConnect(
host: String,
port: Int,
timeoutMillis: Long?,
noDelay: Boolean,
): LyngTcpSocket {
val connectBlock: suspend () -> Socket = {
aSocket(selectorManager).tcp().connect(host, port) {
this.noDelay = noDelay
}
}
val socket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connectBlock() } else connectBlock()
return AndroidLyngTcpSocket(socket)
}
override suspend fun tcpListen(
host: String?,
port: Int,
backlog: Int,
reuseAddress: Boolean,
): LyngTcpServer {
val bindHost = host ?: "0.0.0.0"
val server = aSocket(selectorManager).tcp().bind(bindHost, port) {
backlogSize = backlog
this.reuseAddress = reuseAddress
}
return AndroidLyngTcpServer(server)
}
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
val bindHost = host ?: "0.0.0.0"
val socket = aSocket(selectorManager).udp().bind(bindHost, port) {
this.reuseAddress = reuseAddress
}
return AndroidLyngUdpSocket(socket)
}
}
private class AndroidLyngTcpSocket(
private val socket: Socket,
) : LyngTcpSocket {
private val input: ByteReadChannel by lazy { socket.openReadChannel() }
private val output: ByteWriteChannel by lazy { socket.openWriteChannel(autoFlush = true) }
override fun isOpen(): Boolean = !socket.isClosed
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
override fun remoteAddress(): LyngSocketAddress = socket.remoteAddress.toLyngSocketAddress(resolved = true)
override suspend fun read(maxBytes: Int): ByteArray? {
if (!input.awaitContent(1)) return null
val buffer = ByteArray(maxBytes)
val count = input.readAvailable(buffer, 0, maxBytes)
return when {
count <= 0 -> null
count == maxBytes -> buffer
else -> buffer.copyOf(count)
}
}
override suspend fun readLine(): String? = input.readUTF8Line()
override suspend fun write(data: ByteArray) {
output.writeFully(data, 0, data.size)
}
override suspend fun writeUtf8(text: String) {
output.writeStringUtf8(text)
}
override suspend fun flush() {
output.flush()
}
override fun close() {
socket.close()
}
}
private class AndroidLyngTcpServer(
private val server: ServerSocket,
) : LyngTcpServer {
override fun isOpen(): Boolean = !server.isClosed
override fun localAddress(): LyngSocketAddress = server.localAddress.toLyngSocketAddress(resolved = true)
override suspend fun accept(): LyngTcpSocket = AndroidLyngTcpSocket(server.accept())
override fun close() {
server.close()
}
}
private class AndroidLyngUdpSocket(
private val socket: BoundDatagramSocket,
) : LyngUdpSocket {
override fun isOpen(): Boolean = !socket.isClosed
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
override suspend fun receive(maxBytes: Int): LyngDatagram? {
val datagram = try {
socket.receive()
} catch (e: Throwable) {
if (!isOpen()) return null
throw e
}
val bytes = datagram.packet.readByteArray().let {
if (it.size <= maxBytes) it else it.copyOf(maxBytes)
}
return LyngDatagram(bytes, datagram.address.toLyngSocketAddress(resolved = true))
}
override suspend fun send(data: ByteArray, host: String, port: Int) {
val packet = Buffer()
packet.write(data)
socket.send(io.ktor.network.sockets.Datagram(packet, InetSocketAddress(host, port)))
}
override fun close() {
socket.close()
}
}
private fun io.ktor.network.sockets.SocketAddress.toLyngSocketAddress(
port: Int? = null,
resolved: Boolean,
): LyngSocketAddress {
val javaAddress = this.toJavaAddress()
val inetSocket = javaAddress as? java.net.InetSocketAddress
if (inetSocket != null) {
val inetAddress = inetSocket.address
val host = inetAddress?.hostAddress ?: inetSocket.hostString
val actualPort = port ?: inetSocket.port
val version = when (inetAddress) {
is Inet6Address -> LyngIpVersion.IPV6
is Inet4Address -> LyngIpVersion.IPV4
else -> if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
}
return LyngSocketAddress(host = host, port = actualPort, ipVersion = version, resolved = resolved)
}
val rendered = toString()
return LyngSocketAddress(
host = rendered,
port = port ?: 0,
ipVersion = if (rendered.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
resolved = resolved,
)
}
private fun InetAddress.toLyngSocketAddress(port: Int, resolved: Boolean): LyngSocketAddress =
LyngSocketAddress(
host = hostAddress ?: hostName ?: "0.0.0.0",
port = port,
ipVersion = when (this) {
is Inet6Address -> LyngIpVersion.IPV6
else -> LyngIpVersion.IPV4
},
resolved = resolved,
)
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.ws
import io.ktor.client.engine.cio.CIO
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(CIO)
@@ -0,0 +1,390 @@
/*
* 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.io.http
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjBuffer
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjImmutableMap
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjList
import net.sergeych.lyng.obj.ObjMap
import net.sergeych.lyng.obj.ObjMapEntry
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.obj.requiredArg
import net.sergeych.lyng.obj.thisAs
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.raiseIllegalOperation
import net.sergeych.lyng.requireNoArgs
import net.sergeych.lyng.requireScope
import net.sergeych.lyngio.http.LyngHttpRequest
import net.sergeych.lyngio.http.LyngHttpResponse
import net.sergeych.lyngio.http.getSystemHttpEngine
import net.sergeych.lyngio.http.security.HttpAccessDeniedException
import net.sergeych.lyngio.http.security.HttpAccessOp
import net.sergeych.lyngio.http.security.HttpAccessPolicy
import net.sergeych.lyngio.stdlib_included.httpLyng
private const val HTTP_MODULE_NAME = "lyng.io.http"
fun createHttpModule(policy: HttpAccessPolicy, scope: Scope): Boolean =
createHttpModule(policy, scope.importManager)
fun createHttp(policy: HttpAccessPolicy, scope: Scope): Boolean = createHttpModule(policy, scope)
fun createHttpModule(policy: HttpAccessPolicy, manager: ImportManager): Boolean {
if (manager.packageNames.contains(HTTP_MODULE_NAME)) return false
manager.addPackage(HTTP_MODULE_NAME) { module ->
buildHttpModule(module, policy)
}
return true
}
fun createHttp(policy: HttpAccessPolicy, manager: ImportManager): Boolean = createHttpModule(policy, manager)
private suspend fun buildHttpModule(module: ModuleScope, policy: HttpAccessPolicy) {
module.eval(Source(HTTP_MODULE_NAME, httpLyng))
val engine = getSystemHttpEngine()
val headersType = ObjHttpHeaders.type
val requestType = ObjHttpRequest.type
val responseType = ObjHttpResponse.type
val httpType = object : ObjClass("Http") {}
httpType.addClassFn("isSupported") {
ObjBool(engine.isSupported)
}
httpType.addClassFn("request") {
httpGuard {
val req = requiredArg<ObjHttpRequest>(0)
val built = req.toRequest(this)
policy.require(HttpAccessOp.Request(built.method, built.url))
ObjHttpResponse.from(engine.request(built))
}
}
httpType.addClassFn("get") {
httpGuard {
val url = requiredArg<ObjString>(0).value
val headers = parseHeaderEntries(args.list.drop(1))
policy.require(HttpAccessOp.Request("GET", url))
ObjHttpResponse.from(engine.request(LyngHttpRequest(method = "GET", url = url, headers = headers)))
}
}
httpType.addClassFn("post") {
httpGuard {
val url = requiredArg<ObjString>(0).value
val bodyText = requiredArg<ObjString>(1).value
val contentType = args.list.getOrNull(2)?.let { objOrNullToString(this, it) }
val headers = parseHeaderEntries(args.list.drop(3)).toMutableMap()
if (contentType != null && "Content-Type" !in headers) headers["Content-Type"] = contentType
policy.require(HttpAccessOp.Request("POST", url))
ObjHttpResponse.from(
engine.request(
LyngHttpRequest(method = "POST", url = url, headers = headers, bodyText = bodyText)
)
)
}
}
httpType.addClassFn("postBytes") {
httpGuard {
val url = requiredArg<ObjString>(0).value
val body = requiredArg<ObjBuffer>(1).byteArray.toByteArray()
val contentType = args.list.getOrNull(2)?.let { objOrNullToString(this, it) }
val headers = parseHeaderEntries(args.list.drop(3)).toMutableMap()
if (contentType != null && "Content-Type" !in headers) headers["Content-Type"] = contentType
policy.require(HttpAccessOp.Request("POST", url))
ObjHttpResponse.from(
engine.request(
LyngHttpRequest(method = "POST", url = url, headers = headers, bodyBytes = body)
)
)
}
}
module.addConst("Http", httpType)
module.addConst("HttpHeaders", headersType)
module.addConst("HttpRequest", requestType)
module.addConst("HttpResponse", responseType)
}
private suspend inline fun ScopeFacade.httpGuard(crossinline block: suspend () -> Obj): Obj {
return try {
block()
} catch (e: HttpAccessDeniedException) {
raiseIllegalOperation(e.reasonDetail ?: "http access denied")
} catch (e: Exception) {
raiseIllegalOperation(e.message ?: "http error")
}
}
private class ObjHttpHeaders(
singleValueHeaders: Map<String, String> = emptyMap(),
private val allHeaders: Map<String, List<String>> = emptyMap(),
) : Obj() {
private val entries: LinkedHashMap<Obj, Obj> =
LinkedHashMap(singleValueHeaders.entries.associate { ObjString(it.key) to ObjString(it.value) })
override val objClass: ObjClass
get() = type
override suspend fun getAt(scope: Scope, index: Obj): Obj = findEntry(index)?.value ?: ObjNull
override suspend fun contains(scope: Scope, other: Obj): Boolean = findEntry(other) != null
override suspend fun defaultToString(scope: Scope): ObjString {
val rendered = buildString {
append("HttpHeaders(")
var first = true
for ((k, v) in entries) {
if (!first) append(", ")
append(k.toString(scope).value)
append(" => ")
append(v.toString(scope).value)
first = false
}
append(")")
}
return ObjString(rendered)
}
companion object {
val type = object : ObjClass("HttpHeaders", ObjMap.type) {
override suspend fun callOn(scope: Scope): Obj = ObjHttpHeaders()
}.apply {
addFn("get") {
val self = thisAs<ObjHttpHeaders>()
val name = requiredArg<ObjString>(0).value
self.firstValue(name)?.let(::ObjString) ?: ObjNull
}
addFn("getAll") {
val self = thisAs<ObjHttpHeaders>()
val name = requiredArg<ObjString>(0).value
ObjList(self.valuesOf(name).map(::ObjString).toMutableList())
}
addFn("names") {
val self = thisAs<ObjHttpHeaders>()
ObjList(self.allHeaders.keys.map(::ObjString).toMutableList())
}
addFn("getOrNull") {
val self = thisAs<ObjHttpHeaders>()
val name = requiredArg<ObjString>(0).value
self.firstValue(name)?.let(::ObjString) ?: ObjNull
}
addProperty("size", getter = { ObjInt(thisAs<ObjHttpHeaders>().entries.size.toLong()) })
addProperty("keys", getter = { ObjList(thisAs<ObjHttpHeaders>().entries.keys.toMutableList()) })
addProperty("values", getter = { ObjList(thisAs<ObjHttpHeaders>().entries.values.toMutableList()) })
addFn("iterator") {
ObjList(
thisAs<ObjHttpHeaders>().entries.map { (k, v) -> ObjMapEntry(k, v) }.toMutableList()
).invokeInstanceMethod(requireScope(), "iterator")
}
}
}
private fun valuesOf(name: String): List<String> = allHeaders[lookupKey(name)] ?: emptyList()
private fun firstValue(name: String): String? = valuesOf(name).firstOrNull()
private fun lookupKey(name: String): String =
allHeaders.keys.firstOrNull { it.equals(name, ignoreCase = true) } ?: name
private fun findEntry(index: Obj): Map.Entry<Obj, Obj>? {
if (index is ObjString) {
return entries.entries.firstOrNull { (k, _) ->
(k as? ObjString)?.value?.equals(index.value, ignoreCase = true) == true
}
}
return entries.entries.firstOrNull { it.key == index }
}
}
private class ObjHttpRequest(
var method: String = "GET",
var url: String = "",
val headers: MutableMap<String, String> = linkedMapOf(),
var bodyText: String? = null,
var bodyBytes: ByteArray? = null,
var timeoutMillis: Long? = null,
) : Obj() {
override val objClass: ObjClass
get() = type
suspend fun toRequest(scope: ScopeFacade): LyngHttpRequest {
if (bodyText != null && bodyBytes != null) {
scope.raiseIllegalArgument("Only one of bodyText or bodyBytes may be set")
}
return LyngHttpRequest(
method = method,
url = url,
headers = LinkedHashMap(headers),
bodyText = bodyText,
bodyBytes = bodyBytes,
timeoutMillis = timeoutMillis,
)
}
companion object {
val type = object : ObjClass("HttpRequest") {
override suspend fun callOn(scope: Scope): Obj {
if (scope.args.list.isNotEmpty()) scope.raiseError("HttpRequest() does not accept arguments")
return ObjHttpRequest()
}
}.apply {
addProperty("method",
getter = { ObjString(thisAs<ObjHttpRequest>().method) },
setter = { value ->
thisAs<ObjHttpRequest>().method = objOrNullToString(this, value)
?: raiseIllegalArgument("method cannot be null")
}
)
addProperty("url",
getter = { ObjString(thisAs<ObjHttpRequest>().url) },
setter = { value ->
thisAs<ObjHttpRequest>().url = objOrNullToString(this, value)
?: raiseIllegalArgument("url cannot be null")
}
)
addProperty("headers",
getter = { thisAs<ObjHttpRequest>().headers.toObjMap() },
setter = { value ->
thisAs<ObjHttpRequest>().headers.clear()
thisAs<ObjHttpRequest>().headers.putAll(mapObjToStrings(this, value))
}
)
addProperty("bodyText",
getter = { thisAs<ObjHttpRequest>().bodyText?.let(::ObjString) ?: ObjNull },
setter = { value ->
thisAs<ObjHttpRequest>().bodyText = objOrNullToString(this, value)
}
)
addProperty("bodyBytes",
getter = { thisAs<ObjHttpRequest>().bodyBytes?.let { ObjBuffer(it.toUByteArray()) } ?: ObjNull },
setter = { value ->
thisAs<ObjHttpRequest>().bodyBytes = when (value) {
ObjNull -> null
is ObjBuffer -> value.byteArray.toByteArray()
else -> raiseClassCastError("bodyBytes must be Buffer or null")
}
}
)
addProperty("timeoutMillis",
getter = { thisAs<ObjHttpRequest>().timeoutMillis?.let { ObjInt(it) } ?: ObjNull },
setter = { value ->
thisAs<ObjHttpRequest>().timeoutMillis = when (value) {
ObjNull -> null
is ObjInt -> value.value
else -> raiseClassCastError("timeoutMillis must be Int or null")
}
}
)
}
}
}
private class ObjHttpResponse(
val status: Long,
val statusText: String,
val headers: ObjHttpHeaders,
private val bodyBytes: ByteArray,
) : Obj() {
override val objClass: ObjClass
get() = type
companion object {
val type = object : ObjClass("HttpResponse") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("HttpResponse cannot be created directly")
}
}.apply {
addProperty("status", getter = { ObjInt(thisAs<ObjHttpResponse>().status) })
addProperty("statusText", getter = { ObjString(thisAs<ObjHttpResponse>().statusText) })
addProperty("headers", getter = { thisAs<ObjHttpResponse>().headers })
addFn("text") {
ObjString(thisAs<ObjHttpResponse>().bodyBytes.decodeToString())
}
addFn("bytes") {
ObjBuffer(thisAs<ObjHttpResponse>().bodyBytes.toUByteArray())
}
}
fun from(response: LyngHttpResponse): ObjHttpResponse {
val single = linkedMapOf<String, String>()
response.headers.forEach { (name, values) ->
if (values.isNotEmpty() && !single.containsKey(name)) {
single[name] = values.first()
}
}
return ObjHttpResponse(
status = response.status.toLong(),
statusText = response.statusText,
headers = ObjHttpHeaders(singleValueHeaders = single, allHeaders = response.headers),
bodyBytes = response.bodyBytes,
)
}
}
}
private suspend fun ScopeFacade.parseHeaderEntries(values: List<Obj>): Map<String, String> {
val out = linkedMapOf<String, String>()
values.forEach { value ->
when (value) {
is ObjMapEntry -> {
out[toStringOf(value.key).value] = toStringOf(value.value).value
}
else -> {
if (!value.isInstanceOf(net.sergeych.lyng.obj.ObjArray)) {
raiseIllegalArgument("headers entries must be MapEntry or [key, value]")
}
val size = (value.invokeInstanceMethod(requireScope(), "size") as ObjInt).value.toInt()
if (size != 2) {
raiseIllegalArgument("header entry array must contain exactly 2 items")
}
out[toStringOf(value.getAt(requireScope(), ObjInt.Zero)).value] =
toStringOf(value.getAt(requireScope(), ObjInt.One)).value
}
}
}
return out
}
private suspend fun mapObjToStrings(scope: ScopeFacade, value: Obj): MutableMap<String, String> {
val entries = when (value) {
is ObjMap -> value.map
is ObjImmutableMap -> value.map
ObjNull -> return linkedMapOf()
else -> scope.raiseClassCastError("headers must be Map<String, String>")
}
return entries.entries.associateTo(linkedMapOf()) { (k, v) ->
scope.toStringOf(k).value to scope.toStringOf(v).value
}
}
private suspend fun objOrNullToString(scope: ScopeFacade, value: Obj): String? = when (value) {
ObjNull -> null
else -> scope.toStringOf(value).value
}
private fun Map<String, String>.toObjMap(): ObjMap =
ObjMap(entries.associate { ObjString(it.key) to ObjString(it.value) }.toMutableMap())
@@ -0,0 +1,376 @@
/*
* 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.io.net
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjBuffer
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjList
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.obj.requiredArg
import net.sergeych.lyng.obj.thisAs
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.raiseIllegalOperation
import net.sergeych.lyng.requireNoArgs
import net.sergeych.lyngio.net.LyngDatagram
import net.sergeych.lyngio.net.LyngIpVersion
import net.sergeych.lyngio.net.LyngNetEngine
import net.sergeych.lyngio.net.LyngSocketAddress
import net.sergeych.lyngio.net.LyngTcpServer
import net.sergeych.lyngio.net.LyngTcpSocket
import net.sergeych.lyngio.net.LyngUdpSocket
import net.sergeych.lyngio.net.getSystemNetEngine
import net.sergeych.lyngio.net.security.NetAccessDeniedException
import net.sergeych.lyngio.net.security.NetAccessOp
import net.sergeych.lyngio.net.security.NetAccessPolicy
import net.sergeych.lyngio.stdlib_included.netLyng
private const val NET_MODULE_NAME = "lyng.io.net"
fun createNetModule(policy: NetAccessPolicy, scope: Scope): Boolean =
createNetModule(policy, scope.importManager)
fun createNet(policy: NetAccessPolicy, scope: Scope): Boolean = createNetModule(policy, scope)
fun createNetModule(policy: NetAccessPolicy, manager: ImportManager): Boolean {
if (manager.packageNames.contains(NET_MODULE_NAME)) return false
manager.addPackage(NET_MODULE_NAME) { module ->
buildNetModule(module, policy)
}
return true
}
fun createNet(policy: NetAccessPolicy, manager: ImportManager): Boolean = createNetModule(policy, manager)
private suspend fun buildNetModule(module: ModuleScope, policy: NetAccessPolicy) {
module.eval(Source(NET_MODULE_NAME, netLyng))
val engine = getSystemNetEngine()
val enumValues = NetEnumValues.load(module)
val netType = object : ObjClass("Net") {}
netType.addClassFn("isSupported") { ObjBool(engine.isSupported) }
netType.addClassFn("isTcpAvailable") { ObjBool(engine.isTcpAvailable) }
netType.addClassFn("isTcpServerAvailable") { ObjBool(engine.isTcpServerAvailable) }
netType.addClassFn("isUdpAvailable") { ObjBool(engine.isUdpAvailable) }
netType.addClassFn("resolve") {
netGuard {
val host = requiredArg<ObjString>(0).value
val port = requirePort(requiredArg<ObjInt>(1).value)
policy.require(NetAccessOp.Resolve(host, port))
ObjList(engine.resolve(host, port).map { ObjSocketAddress(it, enumValues) }.toMutableList())
}
}
netType.addClassFn("tcpConnect") {
netGuard {
val host = requiredArg<ObjString>(0).value
val port = requirePort(requiredArg<ObjInt>(1).value)
val timeoutMillis = args.list.getOrNull(2)?.let { objOrNullToLong(this, it, "timeoutMillis") }
val noDelay = args.list.getOrNull(3)?.let { objToBool(this, it, "noDelay") } ?: true
policy.require(NetAccessOp.TcpConnect(host, port))
ObjTcpSocket(engine.tcpConnect(host, port, timeoutMillis, noDelay), enumValues)
}
}
netType.addClassFn("tcpListen") {
netGuard {
val port = requirePort(requiredArg<ObjInt>(0).value)
val host = args.list.getOrNull(1)?.let { objOrNullToString(this, it, "host") }
val backlog = args.list.getOrNull(2)?.let { objToInt(this, it, "backlog") } ?: 128
requirePositive(backlog, "backlog")
val reuseAddress = args.list.getOrNull(3)?.let { objToBool(this, it, "reuseAddress") } ?: true
policy.require(NetAccessOp.TcpListen(host, port, backlog))
ObjTcpServer(engine.tcpListen(host, port, backlog, reuseAddress), enumValues)
}
}
netType.addClassFn("udpBind") {
netGuard {
val port = args.list.getOrNull(0)?.let { objToInt(this, it, "port") } ?: 0
requirePort(port)
val host = args.list.getOrNull(1)?.let { objOrNullToString(this, it, "host") }
val reuseAddress = args.list.getOrNull(2)?.let { objToBool(this, it, "reuseAddress") } ?: true
policy.require(NetAccessOp.UdpBind(host, port))
ObjUdpSocket(engine.udpBind(host, port, reuseAddress), enumValues)
}
}
module.addConst("Net", netType)
module.addConst("SocketAddress", ObjSocketAddress.type(enumValues))
module.addConst("Datagram", ObjDatagram.type(enumValues))
module.addConst("TcpSocket", ObjTcpSocket.type(enumValues))
module.addConst("TcpServer", ObjTcpServer.type(enumValues))
module.addConst("UdpSocket", ObjUdpSocket.type(enumValues))
}
private suspend inline fun ScopeFacade.netGuard(crossinline block: suspend () -> Obj): Obj {
return try {
block()
} catch (e: NetAccessDeniedException) {
raiseIllegalOperation(e.reasonDetail ?: "network access denied")
} catch (e: Exception) {
raiseIllegalOperation(e.message ?: "network error")
}
}
private class NetEnumValues(
val ipv4: Obj,
val ipv6: Obj,
) {
fun of(version: LyngIpVersion): Obj = when (version) {
LyngIpVersion.IPV4 -> ipv4
LyngIpVersion.IPV6 -> ipv6
}
companion object {
suspend fun load(module: ModuleScope): NetEnumValues {
val ipVersionClass = module["IpVersion"]?.value as? ObjClass
?: error("lyng.io.net.IpVersion is missing after declaration load")
return NetEnumValues(
ipv4 = ipVersionClass.readField(module, "IPV4").value,
ipv6 = ipVersionClass.readField(module, "IPV6").value,
)
}
}
}
private class ObjSocketAddress(
private val address: LyngSocketAddress,
private val enumValues: NetEnumValues,
) : Obj() {
override val objClass: ObjClass
get() = type(enumValues)
override suspend fun defaultToString(scope: Scope): ObjString = ObjString(renderAddress(address))
companion object {
private val types = mutableMapOf<NetEnumValues, ObjClass>()
fun type(enumValues: NetEnumValues): ObjClass =
types.getOrPut(enumValues) {
object : ObjClass("SocketAddress") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("SocketAddress cannot be created directly")
}
}.apply {
addProperty("host", getter = { ObjString(thisAs<ObjSocketAddress>().address.host) })
addProperty("port", getter = { ObjInt(thisAs<ObjSocketAddress>().address.port.toLong()) })
addProperty("ipVersion", getter = { enumValues.of(thisAs<ObjSocketAddress>().address.ipVersion) })
addProperty("resolved", getter = { ObjBool(thisAs<ObjSocketAddress>().address.resolved) })
addFn("toString") { ObjString(renderAddress(thisAs<ObjSocketAddress>().address)) }
}
}
}
}
private class ObjDatagram(
private val datagram: LyngDatagram,
private val enumValues: NetEnumValues,
) : Obj() {
override val objClass: ObjClass
get() = type(enumValues)
companion object {
private val types = mutableMapOf<NetEnumValues, ObjClass>()
fun type(enumValues: NetEnumValues): ObjClass =
types.getOrPut(enumValues) {
object : ObjClass("Datagram") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("Datagram cannot be created directly")
}
}.apply {
addProperty("data", getter = {
ObjBuffer(thisAs<ObjDatagram>().datagram.data.toUByteArray())
})
addProperty("address", getter = {
ObjSocketAddress(thisAs<ObjDatagram>().datagram.address, enumValues)
})
}
}
}
}
private class ObjTcpSocket(
private val socket: LyngTcpSocket,
private val enumValues: NetEnumValues,
) : Obj() {
override val objClass: ObjClass
get() = type(enumValues)
companion object {
private val types = mutableMapOf<NetEnumValues, ObjClass>()
fun type(enumValues: NetEnumValues): ObjClass =
types.getOrPut(enumValues) {
object : ObjClass("TcpSocket") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("TcpSocket cannot be created directly")
}
}.apply {
addFn("isOpen") { ObjBool(thisAs<ObjTcpSocket>().socket.isOpen()) }
addFn("localAddress") { ObjSocketAddress(thisAs<ObjTcpSocket>().socket.localAddress(), enumValues) }
addFn("remoteAddress") { ObjSocketAddress(thisAs<ObjTcpSocket>().socket.remoteAddress(), enumValues) }
addFn("read") {
val maxBytes = args.list.getOrNull(0)?.let { objToInt(this, it, "maxBytes") } ?: 65536
requirePositive(maxBytes, "maxBytes")
thisAs<ObjTcpSocket>().socket.read(maxBytes)?.let { ObjBuffer(it.toUByteArray()) } ?: ObjNull
}
addFn("readLine") {
thisAs<ObjTcpSocket>().socket.readLine()?.let(::ObjString) ?: ObjNull
}
addFn("write") {
val data = requiredArg<ObjBuffer>(0).byteArray.toByteArray()
thisAs<ObjTcpSocket>().socket.write(data)
ObjVoid
}
addFn("writeUtf8") {
val text = requiredArg<ObjString>(0).value
thisAs<ObjTcpSocket>().socket.writeUtf8(text)
ObjVoid
}
addFn("flush") {
requireNoArgs()
thisAs<ObjTcpSocket>().socket.flush()
ObjVoid
}
addFn("close") {
requireNoArgs()
thisAs<ObjTcpSocket>().socket.close()
ObjVoid
}
}
}
}
}
private class ObjTcpServer(
private val server: LyngTcpServer,
private val enumValues: NetEnumValues,
) : Obj() {
override val objClass: ObjClass
get() = type(enumValues)
companion object {
private val types = mutableMapOf<NetEnumValues, ObjClass>()
fun type(enumValues: NetEnumValues): ObjClass =
types.getOrPut(enumValues) {
object : ObjClass("TcpServer") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("TcpServer cannot be created directly")
}
}.apply {
addFn("isOpen") { ObjBool(thisAs<ObjTcpServer>().server.isOpen()) }
addFn("localAddress") { ObjSocketAddress(thisAs<ObjTcpServer>().server.localAddress(), enumValues) }
addFn("accept") {
ObjTcpSocket(thisAs<ObjTcpServer>().server.accept(), enumValues)
}
addFn("close") {
requireNoArgs()
thisAs<ObjTcpServer>().server.close()
ObjVoid
}
}
}
}
}
private class ObjUdpSocket(
private val socket: LyngUdpSocket,
private val enumValues: NetEnumValues,
) : Obj() {
override val objClass: ObjClass
get() = type(enumValues)
companion object {
private val types = mutableMapOf<NetEnumValues, ObjClass>()
fun type(enumValues: NetEnumValues): ObjClass =
types.getOrPut(enumValues) {
object : ObjClass("UdpSocket") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("UdpSocket cannot be created directly")
}
}.apply {
addFn("isOpen") { ObjBool(thisAs<ObjUdpSocket>().socket.isOpen()) }
addFn("localAddress") { ObjSocketAddress(thisAs<ObjUdpSocket>().socket.localAddress(), enumValues) }
addFn("receive") {
val maxBytes = args.list.getOrNull(0)?.let { objToInt(this, it, "maxBytes") } ?: 65536
requirePositive(maxBytes, "maxBytes")
thisAs<ObjUdpSocket>().socket.receive(maxBytes)?.let { ObjDatagram(it, enumValues) } ?: ObjNull
}
addFn("send") {
val data = requiredArg<ObjBuffer>(0).byteArray.toByteArray()
val host = requiredArg<ObjString>(1).value
val port = requirePort(requiredArg<ObjInt>(2).value)
thisAs<ObjUdpSocket>().socket.send(data, host, port)
ObjVoid
}
addFn("close") {
requireNoArgs()
thisAs<ObjUdpSocket>().socket.close()
ObjVoid
}
}
}
}
}
private fun renderAddress(address: LyngSocketAddress): String =
if (address.ipVersion == LyngIpVersion.IPV6) "[${address.host}]:${address.port}" else "${address.host}:${address.port}"
private fun ScopeFacade.requirePort(value: Long): Int {
if (value !in 0..65535) raiseIllegalArgument("port must be in 0..65535")
return value.toInt()
}
private fun ScopeFacade.requirePort(value: Int): Int {
if (value !in 0..65535) raiseIllegalArgument("port must be in 0..65535")
return value
}
private fun ScopeFacade.requirePositive(value: Int, name: String) {
if (value <= 0) raiseIllegalArgument("$name must be positive")
}
private suspend fun objOrNullToString(scope: ScopeFacade, value: Obj, name: String): String? = when (value) {
ObjNull -> null
else -> scope.toStringOf(value).value
}
private fun objToInt(scope: ScopeFacade, value: Obj, name: String): Int = when (value) {
is ObjInt -> value.value.toInt()
else -> scope.raiseClassCastError("$name must be Int")
}
private fun objToBool(scope: ScopeFacade, value: Obj, name: String): Boolean = when (value) {
is ObjBool -> value.value
else -> scope.raiseClassCastError("$name must be Bool")
}
private fun objOrNullToLong(scope: ScopeFacade, value: Obj, name: String): Long? = when (value) {
ObjNull -> null
is ObjInt -> value.value
else -> scope.raiseClassCastError("$name must be Int or null")
}
@@ -0,0 +1,199 @@
/*
* 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.io.ws
import net.sergeych.lyng.ModuleScope
import net.sergeych.lyng.Scope
import net.sergeych.lyng.ScopeFacade
import net.sergeych.lyng.Source
import net.sergeych.lyng.obj.Obj
import net.sergeych.lyng.obj.ObjBool
import net.sergeych.lyng.obj.ObjBuffer
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjMapEntry
import net.sergeych.lyng.obj.ObjNull
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyng.obj.requiredArg
import net.sergeych.lyng.obj.thisAs
import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.raiseIllegalOperation
import net.sergeych.lyng.requireNoArgs
import net.sergeych.lyng.requireScope
import net.sergeych.lyngio.stdlib_included.wsLyng
import net.sergeych.lyngio.ws.LyngWsEngine
import net.sergeych.lyngio.ws.LyngWsMessage
import net.sergeych.lyngio.ws.LyngWsSession
import net.sergeych.lyngio.ws.getSystemWsEngine
import net.sergeych.lyngio.ws.security.WsAccessDeniedException
import net.sergeych.lyngio.ws.security.WsAccessOp
import net.sergeych.lyngio.ws.security.WsAccessPolicy
private const val WS_MODULE_NAME = "lyng.io.ws"
fun createWsModule(policy: WsAccessPolicy, scope: Scope): Boolean =
createWsModule(policy, scope.importManager)
fun createWs(policy: WsAccessPolicy, scope: Scope): Boolean = createWsModule(policy, scope)
fun createWsModule(policy: WsAccessPolicy, manager: ImportManager): Boolean {
if (manager.packageNames.contains(WS_MODULE_NAME)) return false
manager.addPackage(WS_MODULE_NAME) { module ->
buildWsModule(module, policy)
}
return true
}
fun createWs(policy: WsAccessPolicy, manager: ImportManager): Boolean = createWsModule(policy, manager)
private suspend fun buildWsModule(module: ModuleScope, policy: WsAccessPolicy) {
module.eval(Source(WS_MODULE_NAME, wsLyng))
val engine = getSystemWsEngine()
val wsType = object : ObjClass("Ws") {}
wsType.addClassFn("isSupported") { ObjBool(engine.isSupported) }
wsType.addClassFn("connect") {
wsGuard {
val url = requiredArg<ObjString>(0).value
val headers = parseHeaderEntries(args.list.drop(1))
policy.require(WsAccessOp.Connect(url))
ObjWsSession(url, engine.connect(url, headers), policy)
}
}
module.addConst("Ws", wsType)
module.addConst("WsMessage", ObjWsMessage.type)
module.addConst("WsSession", ObjWsSession.type)
}
private suspend inline fun ScopeFacade.wsGuard(crossinline block: suspend () -> Obj): Obj {
return try {
block()
} catch (e: WsAccessDeniedException) {
raiseIllegalOperation(e.reasonDetail ?: "websocket access denied")
} catch (e: Exception) {
raiseIllegalOperation(e.message ?: "websocket error")
}
}
private class ObjWsMessage(
private val message: LyngWsMessage,
) : Obj() {
override val objClass: ObjClass
get() = type
companion object {
val type = object : ObjClass("WsMessage") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("WsMessage cannot be created directly")
}
}.apply {
addProperty("isText", getter = { ObjBool(thisAs<ObjWsMessage>().message.isText) })
addProperty("text", getter = {
thisAs<ObjWsMessage>().message.text?.let(::ObjString) ?: ObjNull
})
addProperty("data", getter = {
thisAs<ObjWsMessage>().message.data?.let { ObjBuffer(it.toUByteArray()) } ?: ObjNull
})
}
}
}
private class ObjWsSession(
private val targetUrl: String,
private val session: LyngWsSession,
private val policy: WsAccessPolicy,
) : Obj() {
override val objClass: ObjClass
get() = type
companion object {
val type = object : ObjClass("WsSession") {
override suspend fun callOn(scope: Scope): Obj {
scope.raiseError("WsSession cannot be created directly")
}
}.apply {
addFn("isOpen") {
ObjBool(thisAs<ObjWsSession>().session.isOpen())
}
addFn("url") {
ObjString(thisAs<ObjWsSession>().targetUrl)
}
addFn("sendText") {
val self = thisAs<ObjWsSession>()
val text = requiredArg<ObjString>(0).value
self.policy.require(WsAccessOp.Send(self.targetUrl, text.encodeToByteArray().size, isText = true))
self.session.sendText(text)
ObjVoid
}
addFn("sendBytes") {
val self = thisAs<ObjWsSession>()
val data = requiredArg<ObjBuffer>(0).byteArray.toByteArray()
self.policy.require(WsAccessOp.Send(self.targetUrl, data.size, isText = false))
self.session.sendBytes(data)
ObjVoid
}
addFn("receive") {
val self = thisAs<ObjWsSession>()
self.policy.require(WsAccessOp.Receive(self.targetUrl))
self.session.receive()?.let(::ObjWsMessage) ?: ObjNull
}
addFn("close") {
val self = thisAs<ObjWsSession>()
val code = args.list.getOrNull(0)?.let { objToInt(this, it, "code") } ?: 1000
val reason = args.list.getOrNull(1)?.let { objOrNullToString(this, it, "reason") } ?: ""
self.session.close(code, reason)
ObjVoid
}
}
}
}
private suspend fun ScopeFacade.parseHeaderEntries(values: List<Obj>): Map<String, String> {
val out = linkedMapOf<String, String>()
values.forEach { value ->
when (value) {
is ObjMapEntry -> {
out[toStringOf(value.key).value] = toStringOf(value.value).value
}
else -> {
if (!value.isInstanceOf(net.sergeych.lyng.obj.ObjArray)) {
raiseIllegalArgument("headers entries must be MapEntry or [key, value]")
}
val size = (value.invokeInstanceMethod(requireScope(), "size") as ObjInt).value.toInt()
if (size != 2) {
raiseIllegalArgument("header entry array must contain exactly 2 items")
}
out[toStringOf(value.getAt(requireScope(), ObjInt.Zero)).value] =
toStringOf(value.getAt(requireScope(), ObjInt.One)).value
}
}
}
return out
}
private suspend fun objOrNullToString(scope: ScopeFacade, value: Obj, name: String): String? = when (value) {
ObjNull -> null
else -> scope.toStringOf(value).value
}
private fun objToInt(scope: ScopeFacade, value: Obj, name: String): Int = when (value) {
is ObjInt -> value.value.toInt()
else -> scope.raiseClassCastError("$name must be Int")
}
@@ -0,0 +1,61 @@
package net.sergeych.lyngio.http
import io.ktor.client.HttpClient
import io.ktor.client.call.body
import io.ktor.client.engine.HttpClientEngineConfig
import io.ktor.client.engine.HttpClientEngineFactory
import io.ktor.client.plugins.timeout
import io.ktor.client.request.HttpRequestBuilder
import io.ktor.client.request.request
import io.ktor.client.request.setBody
import io.ktor.http.HttpMethod
import io.ktor.http.headers
import io.ktor.http.takeFrom
internal fun createKtorHttpEngine(
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
): LyngHttpEngine = KtorLyngHttpEngine(engineFactory)
private class KtorLyngHttpEngine(
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
) : LyngHttpEngine {
private val clientResult = runCatching {
HttpClient(engineFactory) {
expectSuccess = false
}
}
override val isSupported: Boolean
get() = clientResult.isSuccess
override suspend fun request(request: LyngHttpRequest): LyngHttpResponse {
val httpClient = clientResult.getOrElse {
throw UnsupportedOperationException(it.message ?: "HTTP client is not supported")
}
val response = httpClient.request {
applyRequest(request)
}
return LyngHttpResponse(
status = response.status.value,
statusText = response.status.description,
headers = response.headers.entries().associate { it.key to it.value.toList() },
bodyBytes = response.body<ByteArray>(),
)
}
private fun HttpRequestBuilder.applyRequest(request: LyngHttpRequest) {
method = HttpMethod.parse(request.method.uppercase())
url.takeFrom(request.url)
headers {
request.headers.forEach { (name, value) -> append(name, value) }
}
request.timeoutMillis?.let { timeout { requestTimeoutMillis = it } }
when {
request.bodyBytes != null && request.bodyText != null ->
throw IllegalArgumentException("Only one of bodyText or bodyBytes may be set")
request.bodyBytes != null -> setBody(request.bodyBytes)
request.bodyText != null -> setBody(request.bodyText)
}
}
}
@@ -0,0 +1,49 @@
/*
* 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.lyngio.http
data class LyngHttpRequest(
val method: String,
val url: String,
val headers: Map<String, String> = emptyMap(),
val bodyText: String? = null,
val bodyBytes: ByteArray? = null,
val timeoutMillis: Long? = null,
)
data class LyngHttpResponse(
val status: Int,
val statusText: String,
val headers: Map<String, List<String>>,
val bodyBytes: ByteArray,
)
interface LyngHttpEngine {
val isSupported: Boolean
suspend fun request(request: LyngHttpRequest): LyngHttpResponse
}
internal object UnsupportedHttpEngine : LyngHttpEngine {
override val isSupported: Boolean = false
override suspend fun request(request: LyngHttpRequest): LyngHttpResponse {
throw UnsupportedOperationException("HTTP client is not supported on this runtime")
}
}
expect fun getSystemHttpEngine(): LyngHttpEngine
@@ -0,0 +1,45 @@
/*
* 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.lyngio.http.security
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
sealed interface HttpAccessOp {
data class Request(val method: String, val url: String) : HttpAccessOp
}
class HttpAccessDeniedException(
val op: HttpAccessOp,
val reasonDetail: String? = null,
) : IllegalStateException("HTTP access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
interface HttpAccessPolicy {
suspend fun check(op: HttpAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
suspend fun require(op: HttpAccessOp, ctx: AccessContext = AccessContext()) {
val res = check(op, ctx)
if (!res.isAllowed()) throw HttpAccessDeniedException(op, res.reason)
}
}
object PermitAllHttpAccessPolicy : HttpAccessPolicy {
override suspend fun check(op: HttpAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Allow)
}
@@ -0,0 +1,99 @@
/*
* 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.lyngio.net
enum class LyngIpVersion {
IPV4,
IPV6,
}
data class LyngSocketAddress(
val host: String,
val port: Int,
val ipVersion: LyngIpVersion,
val resolved: Boolean,
)
data class LyngDatagram(
val data: ByteArray,
val address: LyngSocketAddress,
)
interface LyngTcpSocket {
fun isOpen(): Boolean
fun localAddress(): LyngSocketAddress
fun remoteAddress(): LyngSocketAddress
suspend fun read(maxBytes: Int): ByteArray?
suspend fun readLine(): String?
suspend fun write(data: ByteArray)
suspend fun writeUtf8(text: String)
suspend fun flush()
fun close()
}
interface LyngTcpServer {
fun isOpen(): Boolean
fun localAddress(): LyngSocketAddress
suspend fun accept(): LyngTcpSocket
fun close()
}
interface LyngUdpSocket {
fun isOpen(): Boolean
fun localAddress(): LyngSocketAddress
suspend fun receive(maxBytes: Int): LyngDatagram?
suspend fun send(data: ByteArray, host: String, port: Int)
fun close()
}
interface LyngNetEngine {
val isSupported: Boolean
val isTcpAvailable: Boolean
val isTcpServerAvailable: Boolean
val isUdpAvailable: Boolean
suspend fun resolve(host: String, port: Int): List<LyngSocketAddress>
suspend fun tcpConnect(host: String, port: Int, timeoutMillis: Long?, noDelay: Boolean): LyngTcpSocket
suspend fun tcpListen(host: String?, port: Int, backlog: Int, reuseAddress: Boolean): LyngTcpServer
suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket
}
internal object UnsupportedLyngNetEngine : LyngNetEngine {
override val isSupported: Boolean = false
override val isTcpAvailable: Boolean = false
override val isTcpServerAvailable: Boolean = false
override val isUdpAvailable: Boolean = false
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> {
throw UnsupportedOperationException("Raw networking is not supported on this runtime")
}
override suspend fun tcpConnect(host: String, port: Int, timeoutMillis: Long?, noDelay: Boolean): LyngTcpSocket {
throw UnsupportedOperationException("TCP client sockets are not supported on this runtime")
}
override suspend fun tcpListen(host: String?, port: Int, backlog: Int, reuseAddress: Boolean): LyngTcpServer {
throw UnsupportedOperationException("TCP server sockets are not supported on this runtime")
}
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
throw UnsupportedOperationException("UDP sockets are not supported on this runtime")
}
}
expect fun getSystemNetEngine(): LyngNetEngine
@@ -0,0 +1,48 @@
/*
* 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.lyngio.net.security
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
sealed interface NetAccessOp {
data class Resolve(val host: String, val port: Int) : NetAccessOp
data class TcpConnect(val host: String, val port: Int) : NetAccessOp
data class TcpListen(val host: String?, val port: Int, val backlog: Int) : NetAccessOp
data class UdpBind(val host: String?, val port: Int) : NetAccessOp
}
class NetAccessDeniedException(
val op: NetAccessOp,
val reasonDetail: String? = null,
) : IllegalStateException("Network access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
interface NetAccessPolicy {
suspend fun check(op: NetAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
suspend fun require(op: NetAccessOp, ctx: AccessContext = AccessContext()) {
val res = check(op, ctx)
if (!res.isAllowed()) throw NetAccessDeniedException(op, res.reason)
}
}
object PermitAllNetAccessPolicy : NetAccessPolicy {
override suspend fun check(op: NetAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Allow)
}
@@ -0,0 +1,94 @@
package net.sergeych.lyngio.ws
import io.ktor.client.HttpClient
import io.ktor.client.engine.HttpClientEngineConfig
import io.ktor.client.engine.HttpClientEngineFactory
import io.ktor.client.plugins.websocket.WebSockets
import io.ktor.client.plugins.websocket.webSocketSession
import io.ktor.client.request.header
import io.ktor.client.request.url
import io.ktor.websocket.CloseReason
import io.ktor.websocket.DefaultWebSocketSession
import io.ktor.websocket.Frame
import io.ktor.websocket.close
import io.ktor.websocket.readText
import io.ktor.websocket.send
import kotlinx.coroutines.channels.ClosedReceiveChannelException
internal fun createKtorWsEngine(
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
): LyngWsEngine = KtorLyngWsEngine(engineFactory)
private class KtorLyngWsEngine(
engineFactory: HttpClientEngineFactory<HttpClientEngineConfig>,
) : LyngWsEngine {
private val clientResult = runCatching {
HttpClient(engineFactory) {
install(WebSockets)
}
}
override val isSupported: Boolean
get() = clientResult.isSuccess
override suspend fun connect(url: String, headers: Map<String, String>): LyngWsSession {
val client = clientResult.getOrElse {
throw UnsupportedOperationException(it.message ?: "WebSocket client is not supported")
}
val session = client.webSocketSession {
url(url)
headers.forEach { (name, value) -> header(name, value) }
}
return KtorLyngWsSession(url, session)
}
}
private class KtorLyngWsSession(
private val targetUrl: String,
private val session: DefaultWebSocketSession,
) : LyngWsSession {
private var closed = false
override fun isOpen(): Boolean = !closed
override fun url(): String = targetUrl
override suspend fun sendText(text: String) {
ensureOpen()
session.send(text)
}
override suspend fun sendBytes(data: ByteArray) {
ensureOpen()
session.send(data)
}
override suspend fun receive(): LyngWsMessage? {
if (closed) return null
val frame = try {
session.incoming.receive()
} catch (_: ClosedReceiveChannelException) {
closed = true
return null
}
return when (frame) {
is Frame.Text -> LyngWsMessage(isText = true, text = frame.readText())
is Frame.Binary -> LyngWsMessage(isText = false, data = frame.data.copyOf())
is Frame.Close -> {
closed = true
null
}
else -> receive()
}
}
override suspend fun close(code: Int, reason: String) {
if (closed) return
closed = true
session.close(CloseReason(code.toShort(), reason))
}
private fun ensureOpen() {
if (closed) throw IllegalStateException("websocket session is closed")
}
}
@@ -0,0 +1,48 @@
/*
* 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.lyngio.ws
data class LyngWsMessage(
val isText: Boolean,
val text: String? = null,
val data: ByteArray? = null,
)
interface LyngWsSession {
fun isOpen(): Boolean
fun url(): String
suspend fun sendText(text: String)
suspend fun sendBytes(data: ByteArray)
suspend fun receive(): LyngWsMessage?
suspend fun close(code: Int, reason: String)
}
interface LyngWsEngine {
val isSupported: Boolean
suspend fun connect(url: String, headers: Map<String, String>): LyngWsSession
}
internal object UnsupportedLyngWsEngine : LyngWsEngine {
override val isSupported: Boolean = false
override suspend fun connect(url: String, headers: Map<String, String>): LyngWsSession {
throw UnsupportedOperationException("WebSocket client is not supported on this runtime")
}
}
expect fun getSystemWsEngine(): LyngWsEngine
@@ -0,0 +1,47 @@
/*
* 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.lyngio.ws.security
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
sealed interface WsAccessOp {
data class Connect(val url: String) : WsAccessOp
data class Send(val url: String, val bytes: Int, val isText: Boolean) : WsAccessOp
data class Receive(val url: String) : WsAccessOp
}
class WsAccessDeniedException(
val op: WsAccessOp,
val reasonDetail: String? = null,
) : IllegalStateException("WebSocket access denied for $op" + (reasonDetail?.let { ": $it" } ?: ""))
interface WsAccessPolicy {
suspend fun check(op: WsAccessOp, ctx: AccessContext = AccessContext()): AccessDecision
suspend fun require(op: WsAccessOp, ctx: AccessContext = AccessContext()) {
val res = check(op, ctx)
if (!res.isAllowed()) throw WsAccessDeniedException(op, res.reason)
}
}
object PermitAllWsAccessPolicy : WsAccessPolicy {
override suspend fun check(op: WsAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Allow)
}
@@ -0,0 +1,69 @@
/*
* 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.io.net
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Script
import net.sergeych.lyngio.net.getSystemNetEngine
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import kotlin.test.Test
import kotlin.test.assertEquals
class LyngNetTcpServerExampleTest {
@Test
fun tcpServerExampleRoundTripsOverLoopback() = runBlocking {
val engine = getSystemNetEngine()
if (!engine.isSupported || !engine.isTcpAvailable || !engine.isTcpServerAvailable) return@runBlocking
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.net
val server = Net.tcpListen(0, "127.0.0.1")
val port = server.localAddress().port
val accepted = launch {
val client = server.accept()
val line = (client.read(4) as Buffer).decodeUtf8()
client.writeUtf8("echo:" + line)
client.flush()
client.close()
server.close()
line
}
val socket = Net.tcpConnect("127.0.0.1", port)
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
socket.close()
"${'$'}{accepted.await()}: ${'$'}reply"
""".trimIndent()
val result = withTimeout(5_000) {
Compiler.compile(code).execute(scope).inspect(scope)
}
assertEquals("\"ping: echo:ping\"", result)
}
}
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.http
import io.ktor.client.engine.darwin.Darwin
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(Darwin)
@@ -0,0 +1,8 @@
package net.sergeych.lyngio.net
actual fun getSystemNetEngine(): LyngNetEngine = createNativeKtorNetEngine(
isSupported = true,
isTcpAvailable = true,
isTcpServerAvailable = true,
isUdpAvailable = true,
)
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.ws
import io.ktor.client.engine.darwin.Darwin
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(Darwin)
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.http
import io.ktor.client.engine.js.Js
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(Js)
@@ -0,0 +1,422 @@
@file:Suppress("UnsafeCastFromDynamic", "SpellCheckingInspection")
package net.sergeych.lyngio.net
import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.withTimeout
import kotlinx.coroutines.withTimeoutOrNull
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
import kotlin.js.json
import org.khronos.webgl.Uint8Array
actual fun getSystemNetEngine(): LyngNetEngine = jsNodeNetEngineOrNull ?: UnsupportedLyngNetEngine
private val jsNodeNetEngineOrNull: LyngNetEngine? by lazy {
if (!isNodeRuntime()) return@lazy null
val net = requireNodeModule("net") ?: return@lazy null
val dgram = requireNodeModule("dgram") ?: return@lazy null
val dns = requireNodeModule("dns") ?: return@lazy null
JsNodeNetEngine(net, dgram, dns)
}
private class JsNodeNetEngine(
private val netModule: dynamic,
private val dgramModule: dynamic,
private val dnsModule: dynamic,
) : LyngNetEngine {
override val isSupported: Boolean = true
override val isTcpAvailable: Boolean = true
override val isTcpServerAvailable: Boolean = true
override val isUdpAvailable: Boolean = true
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> {
val family = netModule.isIP(host) as Int
if (family == 4 || family == 6) {
return listOf(
LyngSocketAddress(
host = host,
port = port,
ipVersion = if (family == 6) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
resolved = true,
)
)
}
return suspendCancellableCoroutine { cont ->
dnsModule.lookup(host, json("all" to true), { error: dynamic, result: dynamic ->
if (!cont.isActive) return@lookup
if (error != null) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "DNS lookup failed"))
return@lookup
}
val addresses = mutableListOf<LyngSocketAddress>()
val items = result.unsafeCast<Array<dynamic>>()
for (item in items) {
val address = item.address?.unsafeCast<String>() ?: continue
val itemFamily = item.family?.unsafeCast<Int>() ?: if (address.contains(':')) 6 else 4
addresses += LyngSocketAddress(
host = address,
port = port,
ipVersion = if (itemFamily == 6) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
resolved = true,
)
}
cont.resume(addresses)
})
}
}
override suspend fun tcpConnect(
host: String,
port: Int,
timeoutMillis: Long?,
noDelay: Boolean,
): LyngTcpSocket {
var socket: dynamic = null
return try {
val connected = suspend {
suspendCancellableCoroutine<dynamic> { cont ->
socket = netModule.createConnection(json("host" to host, "port" to port)) {
if (cont.isActive) cont.resume(socket)
}
socket.once("error", { error: dynamic ->
if (cont.isActive) {
cont.resumeWithException(
IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP connect failed")
)
}
})
}
}
val connectedSocket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connected() } else connected()
connectedSocket.setNoDelay(noDelay)
JsNodeTcpSocket(connectedSocket)
} catch (e: Throwable) {
if (socket != null) socket.destroy()
throw e
}
}
override suspend fun tcpListen(
host: String?,
port: Int,
backlog: Int,
reuseAddress: Boolean,
): LyngTcpServer {
val accepted = Channel<LyngTcpSocket>(Channel.UNLIMITED)
val server = netModule.createServer({ socket: dynamic ->
accepted.trySend(JsNodeTcpSocket(socket))
})
server.on("error", { _: dynamic -> })
val listenHost = host ?: "0.0.0.0"
val options = json(
"host" to listenHost,
"port" to port,
"backlog" to backlog,
"exclusive" to !reuseAddress,
)
suspendCancellableCoroutine<Unit> { cont ->
server.once("error", { error: dynamic ->
if (cont.isActive) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP listen failed"))
}
})
server.listen(options) {
if (cont.isActive) cont.resume(Unit)
}
}
return JsNodeTcpServer(server, accepted)
}
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
val socketType = if ((host ?: "").contains(':')) "udp6" else "udp4"
val socket = dgramModule.createSocket(json("type" to socketType, "reuseAddr" to reuseAddress))
val incoming = Channel<LyngDatagram>(Channel.UNLIMITED)
socket.on("message", { msg: dynamic, rinfo: dynamic ->
incoming.trySend(
LyngDatagram(
data = dynamicToByteArray(msg),
address = rinfoToAddress(rinfo),
)
)
})
socket.on("error", { _: dynamic -> })
suspendCancellableCoroutine<Unit> { cont ->
socket.once("error", { error: dynamic ->
if (cont.isActive) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "UDP bind failed"))
}
})
socket.bind(port, host ?: "0.0.0.0") {
if (cont.isActive) cont.resume(Unit)
}
}
return JsNodeUdpSocket(socket, incoming)
}
}
private class JsNodeTcpSocket(
private val socket: dynamic,
) : LyngTcpSocket {
private val incoming = Channel<ByteArray?>(Channel.UNLIMITED)
private val buffered = ArrayDeque<Byte>()
private var closed = false
private var failure: Throwable? = null
init {
socket.on("data", { chunk: dynamic ->
incoming.trySend(dynamicToByteArray(chunk))
})
socket.on("end", {
closed = true
incoming.trySend(null)
})
socket.on("close", {
closed = true
incoming.trySend(null)
})
socket.on("error", { error: dynamic ->
failure = IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP socket failed")
closed = true
incoming.trySend(null)
})
}
override fun isOpen(): Boolean = !closed && socket.destroyed != true
override fun localAddress(): LyngSocketAddress = socketAddress(
host = socket.localAddress?.unsafeCast<String>() ?: "0.0.0.0",
port = socket.localPort?.unsafeCast<Int>() ?: 0,
family = socket.localFamily,
resolved = true,
)
override fun remoteAddress(): LyngSocketAddress = socketAddress(
host = socket.remoteAddress?.unsafeCast<String>() ?: "0.0.0.0",
port = socket.remotePort?.unsafeCast<Int>() ?: 0,
family = socket.remoteFamily,
resolved = true,
)
override suspend fun read(maxBytes: Int): ByteArray? {
if (!ensureBuffered()) return null
val count = minOf(maxBytes, buffered.size)
return ByteArray(count) { buffered.removeFirst() }
}
override suspend fun readLine(): String? {
while (true) {
val newlineIndex = buffered.indexOfFirst { it == '\n'.code.toByte() }
if (newlineIndex >= 0) {
val raw = takeBuffered(newlineIndex + 1)
val trimmed = if (raw.lastOrNull() == '\n'.code.toByte()) raw.dropLast(1) else raw
val withoutCr = if (trimmed.lastOrNull() == '\r'.code.toByte()) trimmed.dropLast(1) else trimmed
return withoutCr.toByteArray().decodeToString()
}
if (!fillBuffer()) break
}
if (buffered.isEmpty()) {
failure?.let { throw it }
return null
}
return takeBuffered(buffered.size).toByteArray().decodeToString()
}
override suspend fun write(data: ByteArray) {
ensureOpen()
suspendCancellableCoroutine<Unit> { cont ->
socket.write(byteArrayToUint8Array(data), { error: dynamic ->
if (!cont.isActive) return@write
if (error != null) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP write failed"))
} else {
cont.resume(Unit)
}
})
}
}
override suspend fun writeUtf8(text: String) {
ensureOpen()
suspendCancellableCoroutine<Unit> { cont ->
socket.write(text, "utf8", { error: dynamic ->
if (!cont.isActive) return@write
if (error != null) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "TCP write failed"))
} else {
cont.resume(Unit)
}
})
}
}
override suspend fun flush() {
ensureOpen()
if (socket.writableNeedDrain == true) {
withTimeoutOrNull(5_000) {
awaitNodeEvent(socket, "drain")
}
}
}
override fun close() {
if (closed) return
closed = true
if (socket.destroyed == true) {
incoming.trySend(null)
return
}
if (socket.writable == true) socket.end() else socket.destroy()
}
private suspend fun ensureBuffered(): Boolean {
if (buffered.isNotEmpty()) return true
return fillBuffer()
}
private suspend fun fillBuffer(): Boolean {
while (buffered.isEmpty()) {
val chunk = incoming.receive()
if (chunk == null) {
failure?.let { if (buffered.isEmpty()) throw it }
return buffered.isNotEmpty()
}
chunk.forEach { buffered.addLast(it) }
}
return true
}
private fun takeBuffered(count: Int): List<Byte> = List(count) { buffered.removeFirst() }
private fun ensureOpen() {
if (!isOpen()) throw IllegalStateException("tcp socket is closed")
}
}
private class JsNodeTcpServer(
private val server: dynamic,
private val accepted: Channel<LyngTcpSocket>,
) : LyngTcpServer {
private var closed = false
override fun isOpen(): Boolean = !closed && server.listening == true
override fun localAddress(): LyngSocketAddress {
val info = server.address()
return socketAddress(
host = info.address?.unsafeCast<String>() ?: "0.0.0.0",
port = info.port?.unsafeCast<Int>() ?: 0,
family = info.family,
resolved = true,
)
}
override suspend fun accept(): LyngTcpSocket = accepted.receive()
override fun close() {
if (closed) return
closed = true
server.close()
accepted.close()
}
}
private class JsNodeUdpSocket(
private val socket: dynamic,
private val incoming: Channel<LyngDatagram>,
) : LyngUdpSocket {
private var closed = false
override fun isOpen(): Boolean = !closed
override fun localAddress(): LyngSocketAddress = rinfoToAddress(socket.address())
override suspend fun receive(maxBytes: Int): LyngDatagram? {
val datagram = incoming.receiveCatching().getOrNull() ?: return null
return if (datagram.data.size <= maxBytes) datagram else datagram.copy(data = datagram.data.copyOf(maxBytes))
}
override suspend fun send(data: ByteArray, host: String, port: Int) {
if (closed) throw IllegalStateException("udp socket is closed")
suspendCancellableCoroutine<Unit> { cont ->
socket.send(byteArrayToUint8Array(data), port, host, { error: dynamic ->
if (!cont.isActive) return@send
if (error != null) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "UDP send failed"))
} else {
cont.resume(Unit)
}
})
}
}
override fun close() {
if (closed) return
closed = true
socket.close()
incoming.close()
}
}
private suspend fun awaitNodeEvent(target: dynamic, name: String) {
suspendCancellableCoroutine<Unit> { cont ->
target.once("error", { error: dynamic ->
if (cont.isActive) {
cont.resumeWithException(IllegalStateException(error.message?.unsafeCast<String>() ?: "Node operation failed"))
}
})
target.once(name) {
if (cont.isActive) cont.resume(Unit)
}
}
}
private fun socketAddress(host: String, port: Int, family: dynamic, resolved: Boolean): LyngSocketAddress =
LyngSocketAddress(
host = host,
port = port,
ipVersion = when (family?.toString()) {
"IPv6", "6" -> LyngIpVersion.IPV6
else -> if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
},
resolved = resolved,
)
private fun rinfoToAddress(rinfo: dynamic): LyngSocketAddress = socketAddress(
host = rinfo.address?.unsafeCast<String>() ?: "0.0.0.0",
port = rinfo.port?.unsafeCast<Int>() ?: 0,
family = rinfo.family,
resolved = true,
)
private fun isNodeRuntime(): Boolean = js(
"""
typeof process !== "undefined" &&
process != null &&
process.versions != null &&
process.versions.node != null
"""
).unsafeCast<Boolean>()
private fun requireNodeModule(name: String): dynamic {
val requireFn = js("typeof require !== 'undefined' ? require : undefined")
if (requireFn == js("undefined")) return null
return try {
requireFn(name)
} catch (_: Throwable) {
null
}
}
private fun dynamicToByteArray(value: dynamic): ByteArray {
val source = js("new Uint8Array(value)").unsafeCast<Uint8Array>()
val size = source.length
return ByteArray(size) { index -> source.asDynamic()[index].unsafeCast<Byte>() }
}
private fun byteArrayToUint8Array(value: ByteArray): Uint8Array {
val out = Uint8Array(value.size)
value.forEachIndexed { index, byte -> out.asDynamic()[index] = byte.toInt() and 0xff }
return out
}
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.ws
import io.ktor.client.engine.js.Js
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(Js)
@@ -0,0 +1,117 @@
package net.sergeych.lyng.io.net
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.promise
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.ExecutionError
import net.sergeych.lyng.Script
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import net.sergeych.lyngio.net.getSystemNetEngine
import net.sergeych.lyngio.net.security.NetAccessOp
import net.sergeych.lyngio.net.security.NetAccessPolicy
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import kotlin.test.Test
import kotlin.test.assertFailsWith
import kotlin.test.assertTrue
@OptIn(DelicateCoroutinesApi::class)
class LyngNetModuleJsNodeTest {
@Test
fun testResolveAndCapabilities() = GlobalScope.promise {
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.io.net
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
[Net.isSupported(), Net.isTcpAvailable(), Net.isTcpServerAvailable(), Net.isUdpAvailable(), a.toString(), a.resolved, a.ipVersion == IpVersion.IPV4]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("true,true,true,true"), result)
assertTrue(result.contains("127.0.0.1:4040"), result)
}
@Test
fun testTcpConnectConvenience() = GlobalScope.promise {
val engine = getSystemNetEngine()
val server = engine.tcpListen(host = "127.0.0.1", port = 0, backlog = 8, reuseAddress = true)
val serverPort = server.localAddress().port
val worker = async {
val client = server.accept()
val line = client.read(4)?.decodeToString()
client.writeUtf8("reply:$line")
client.flush()
client.close()
}
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.net
val socket = Net.tcpConnect("127.0.0.1", $serverPort)
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
val localPort = socket.localAddress().port
val remotePort = socket.remoteAddress().port
socket.close()
[reply, localPort > 0, remotePort == $serverPort]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
worker.await()
server.close()
assertTrue(result.contains("reply:ping"), result)
assertTrue(result.contains("true,true"), result)
}
@Test
fun testUdpLoopback() = GlobalScope.promise {
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.net
val server = Net.udpBind(0, "127.0.0.1")
val client = Net.udpBind(0, "127.0.0.1")
client.send(Buffer("ping"), "127.0.0.1", server.localAddress().port)
val d = server.receive()
client.close()
server.close()
[d.data.decodeUtf8(), d.address.port > 0]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("[ping,true]"), result)
}
@Test
fun testPolicyDenialSurfacesAsLyngError() = GlobalScope.promise {
val scope = Script.newScope()
val denyAll = object : NetAccessPolicy {
override suspend fun check(op: NetAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Deny, "blocked by test policy")
}
createNetModule(denyAll, scope)
val code = """
import lyng.io.net
Net.tcpConnect("127.0.0.1", 1)
""".trimIndent()
val error = assertFailsWith<ExecutionError> {
Compiler.compile(code).execute(scope)
}
assertTrue(error.errorMessage.isNotBlank())
}
}
@@ -0,0 +1,70 @@
package net.sergeych.lyngio
import kotlinx.coroutines.DelicateCoroutinesApi
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.async
import kotlinx.coroutines.promise
import net.sergeych.lyngio.net.LyngIpVersion
import net.sergeych.lyngio.net.getSystemNetEngine
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNotNull
import kotlin.test.assertTrue
@OptIn(DelicateCoroutinesApi::class)
class NetJsNodeTest {
@Test
fun testNodeNetCapabilitiesAndResolve() = GlobalScope.promise {
val engine = getSystemNetEngine()
assertTrue(engine.isSupported)
assertTrue(engine.isTcpAvailable)
assertTrue(engine.isTcpServerAvailable)
assertTrue(engine.isUdpAvailable)
val resolved = engine.resolve("127.0.0.1", 4040)
assertTrue(resolved.isNotEmpty())
assertEquals(4040, resolved.first().port)
assertEquals(LyngIpVersion.IPV4, resolved.first().ipVersion)
}
@Test
fun testNodeTcpLoopback() = GlobalScope.promise {
val engine = getSystemNetEngine()
val server = engine.tcpListen(host = "127.0.0.1", port = 0, backlog = 8, reuseAddress = true)
val accepted = async {
val socket = server.accept()
val line = socket.readLine()
socket.writeUtf8("echo:$line\n")
socket.flush()
socket.close()
line
}
val client = engine.tcpConnect("127.0.0.1", server.localAddress().port, timeoutMillis = null, noDelay = true)
client.writeUtf8("ping\n")
client.flush()
val reply = client.readLine()
client.close()
server.close()
assertEquals("ping", accepted.await())
assertEquals("echo:ping", reply)
}
@Test
fun testNodeUdpLoopback() = GlobalScope.promise {
val engine = getSystemNetEngine()
val server = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
val client = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
client.send("ping".encodeToByteArray(), "127.0.0.1", server.localAddress().port)
val received = server.receive(1024)
client.close()
server.close()
assertNotNull(received)
assertEquals("ping", received.data.decodeToString())
assertTrue(received.address.port > 0)
}
}
@@ -0,0 +1,14 @@
package net.sergeych.lyngio
import net.sergeych.lyngio.http.getSystemHttpEngine
import net.sergeych.lyngio.ws.getSystemWsEngine
import kotlin.test.Test
import kotlin.test.assertTrue
class PlatformCapabilityJsTest {
@Test
fun testJsHttpAndWsCapabilitiesReportSupported() {
assertTrue(getSystemHttpEngine().isSupported, "JS HTTP engine should be available")
assertTrue(getSystemWsEngine().isSupported, "JS websocket engine should be available")
}
}
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.http
import io.ktor.client.engine.cio.CIO
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(CIO)
@@ -0,0 +1,223 @@
/*
* 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.lyngio.net
import io.ktor.network.selector.ActorSelectorManager
import io.ktor.network.selector.SelectorManager
import io.ktor.network.sockets.BoundDatagramSocket
import io.ktor.network.sockets.InetSocketAddress
import io.ktor.network.sockets.ServerSocket
import io.ktor.network.sockets.Socket
import io.ktor.network.sockets.aSocket
import io.ktor.network.sockets.isClosed
import io.ktor.network.sockets.openReadChannel
import io.ktor.network.sockets.openWriteChannel
import io.ktor.network.sockets.toJavaAddress
import io.ktor.utils.io.ByteReadChannel
import io.ktor.utils.io.ByteWriteChannel
import io.ktor.utils.io.readAvailable
import io.ktor.utils.io.readUTF8Line
import io.ktor.utils.io.writeFully
import io.ktor.utils.io.writeStringUtf8
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeout
import kotlinx.io.Buffer
import kotlinx.io.readByteArray
import java.net.Inet4Address
import java.net.Inet6Address
import java.net.InetAddress
actual fun getSystemNetEngine(): LyngNetEngine = JvmKtorNetEngine
private object JvmKtorNetEngine : LyngNetEngine {
private val selectorManager: SelectorManager by lazy { ActorSelectorManager(Dispatchers.IO) }
override val isSupported: Boolean = true
override val isTcpAvailable: Boolean = true
override val isTcpServerAvailable: Boolean = true
override val isUdpAvailable: Boolean = true
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> = withContext(Dispatchers.IO) {
InetAddress.getAllByName(host).map { address ->
address.toLyngSocketAddress(port = port, resolved = true)
}
}
override suspend fun tcpConnect(
host: String,
port: Int,
timeoutMillis: Long?,
noDelay: Boolean,
): LyngTcpSocket {
val connectBlock: suspend () -> Socket = {
aSocket(selectorManager).tcp().connect(host, port) {
this.noDelay = noDelay
}
}
val socket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connectBlock() } else connectBlock()
return JvmLyngTcpSocket(socket)
}
override suspend fun tcpListen(
host: String?,
port: Int,
backlog: Int,
reuseAddress: Boolean,
): LyngTcpServer {
val bindHost = host ?: "0.0.0.0"
val server = aSocket(selectorManager).tcp().bind(bindHost, port) {
backlogSize = backlog
this.reuseAddress = reuseAddress
}
return JvmLyngTcpServer(server)
}
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
val bindHost = host ?: "0.0.0.0"
val socket = aSocket(selectorManager).udp().bind(bindHost, port) {
this.reuseAddress = reuseAddress
}
return JvmLyngUdpSocket(socket)
}
}
private class JvmLyngTcpSocket(
private val socket: Socket,
) : LyngTcpSocket {
private val input: ByteReadChannel by lazy { socket.openReadChannel() }
private val output: ByteWriteChannel by lazy { socket.openWriteChannel(autoFlush = true) }
override fun isOpen(): Boolean = !socket.isClosed
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
override fun remoteAddress(): LyngSocketAddress = socket.remoteAddress.toLyngSocketAddress(resolved = true)
override suspend fun read(maxBytes: Int): ByteArray? {
if (!input.awaitContent(1)) return null
val buffer = ByteArray(maxBytes)
val count = input.readAvailable(buffer, 0, maxBytes)
return when {
count <= 0 -> null
count == maxBytes -> buffer
else -> buffer.copyOf(count)
}
}
override suspend fun readLine(): String? = input.readUTF8Line()
override suspend fun write(data: ByteArray) {
output.writeFully(data, 0, data.size)
}
override suspend fun writeUtf8(text: String) {
output.writeStringUtf8(text)
}
override suspend fun flush() {
output.flush()
}
override fun close() {
socket.close()
}
}
private class JvmLyngTcpServer(
private val server: ServerSocket,
) : LyngTcpServer {
override fun isOpen(): Boolean = !server.isClosed
override fun localAddress(): LyngSocketAddress = server.localAddress.toLyngSocketAddress(resolved = true)
override suspend fun accept(): LyngTcpSocket = JvmLyngTcpSocket(server.accept())
override fun close() {
server.close()
}
}
private class JvmLyngUdpSocket(
private val socket: BoundDatagramSocket,
) : LyngUdpSocket {
override fun isOpen(): Boolean = !socket.isClosed
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
override suspend fun receive(maxBytes: Int): LyngDatagram? {
val datagram = try {
socket.receive()
} catch (e: Throwable) {
if (!isOpen()) return null
throw e
}
val bytes = datagram.packet.readByteArray().let {
if (it.size <= maxBytes) it else it.copyOf(maxBytes)
}
return LyngDatagram(bytes, datagram.address.toLyngSocketAddress(resolved = true))
}
override suspend fun send(data: ByteArray, host: String, port: Int) {
val packet = Buffer()
packet.write(data)
socket.send(io.ktor.network.sockets.Datagram(packet, InetSocketAddress(host, port)))
}
override fun close() {
socket.close()
}
}
private fun io.ktor.network.sockets.SocketAddress.toLyngSocketAddress(
port: Int? = null,
resolved: Boolean,
): LyngSocketAddress {
val javaAddress = this.toJavaAddress()
val inetSocket = javaAddress as? java.net.InetSocketAddress
if (inetSocket != null) {
val inetAddress = inetSocket.address
val host = inetAddress?.hostAddress ?: inetSocket.hostString
val actualPort = port ?: inetSocket.port
val version = when (inetAddress) {
is Inet6Address -> LyngIpVersion.IPV6
is Inet4Address -> LyngIpVersion.IPV4
else -> if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
}
return LyngSocketAddress(host = host, port = actualPort, ipVersion = version, resolved = resolved)
}
val rendered = toString()
return LyngSocketAddress(
host = rendered,
port = port ?: 0,
ipVersion = if (rendered.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
resolved = resolved,
)
}
private fun InetAddress.toLyngSocketAddress(port: Int, resolved: Boolean): LyngSocketAddress =
LyngSocketAddress(
host = hostAddress,
port = port,
ipVersion = when (this) {
is Inet6Address -> LyngIpVersion.IPV6
else -> LyngIpVersion.IPV4
},
resolved = resolved,
)
@@ -0,0 +1,22 @@
/*
* 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.lyngio.ws
import io.ktor.client.engine.cio.CIO
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(CIO)
+256
View File
@@ -0,0 +1,256 @@
/*
* 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.
*
*/
import com.sun.net.httpserver.HttpExchange
import com.sun.net.httpserver.HttpServer
import com.sun.net.httpserver.HttpsConfigurator
import com.sun.net.httpserver.HttpsServer
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flow
import kotlinx.coroutines.flow.flowOn
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.Scope
import net.sergeych.lyng.Script
import net.sergeych.lyng.io.http.createHttpModule
import net.sergeych.lyng.io.net.createNetModule
import net.sergeych.lyng.io.testtls.TlsTestMaterial
import net.sergeych.lyng.io.ws.TestWebSocketServer
import net.sergeych.lyng.io.ws.createWsModule
import net.sergeych.lyng.leftMargin
import net.sergeych.lyng.obj.ObjInt
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjVoid
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
import java.net.InetSocketAddress
import java.net.ServerSocket
import java.nio.file.Files.readAllLines
import java.nio.file.Paths
import kotlin.concurrent.thread
import kotlin.io.path.absolutePathString
import kotlin.test.Test
import kotlin.test.assertEquals
data class IoDocTest(
val fileName: String,
val line: Int,
val code: String,
val expectedOutput: String,
val expectedResult: String,
) {
val fileNamePart by lazy { Paths.get(fileName).fileName.toString() }
override fun toString(): String = "DocTest: ${Paths.get(fileName).absolutePathString()}:${line + 1}"
}
private fun parseIoDocTests(fileName: String): Flow<IoDocTest> = flow {
val book = readAllLines(Paths.get(fileName))
var startOffset = 0
val block = mutableListOf<String>()
var startIndex = 0
for ((index, l) in book.withIndex()) {
val off = leftMargin(l)
when {
off < startOffset && startOffset != 0 -> {
if (l.isBlank()) continue
if (block.size > 1) {
for ((i, s) in block.withIndex()) {
var x = s
val initial = leftMargin(x)
do {
x = x.drop(1)
} while (initial - leftMargin(x) != startOffset)
block[i] = x
}
val outStart = block.indexOfFirst { it.startsWith(">>>") }
if (outStart >= 0) {
val result = mutableListOf<String>()
while (block.lastOrNull()?.isEmpty() == true) block.removeLast()
var valid = true
while (block.size > outStart) {
val line = block.removeAt(outStart)
if (!line.startsWith(">>> ")) {
valid = false
break
}
result.add(line.drop(4))
}
if (valid) {
emit(
IoDocTest(
fileName = fileName,
line = startIndex,
code = block.joinToString("\n"),
expectedOutput = if (result.size > 1) result.dropLast(1).joinToString("") { "$it\n" } else "",
expectedResult = result.last(),
)
)
}
}
}
block.clear()
startOffset = 0
}
off != 0 && startOffset == 0 -> {
block.clear()
startIndex = index
block.add(l)
startOffset = off
}
off != 0 -> block.add(l)
}
}
}.flowOn(Dispatchers.IO)
private suspend fun IoDocTest.run(scope: Scope) {
val output = StringBuilder()
scope.addFn("println") {
for ((i, a) in args.withIndex()) {
if (i > 0) output.append(' ')
output.append(toStringOf(a).value)
}
output.append('\n')
ObjVoid
}
val result = scope.eval(code).inspect(scope).replace(Regex("@\\d+"), "@...")
assertEquals(expectedOutput, output.toString(), "script output mismatch at $this")
assertEquals(expectedResult, result, "script result mismatch at $this")
}
private suspend fun runIoDocTests(
fileName: String,
installModules: suspend (Scope) -> Unit,
installConsts: suspend (Scope) -> Unit = {},
) {
parseIoDocTests(fileName).collect { test ->
val scope = Script.newScope()
installModules(scope)
installConsts(scope)
test.run(scope)
}
}
class LyngioBookTest {
@Test
fun testHttpDocs() = runBlocking {
val server = newHttpServer(secure = false)
val secureServer = newHttpServer(secure = true)
try {
runIoDocTests(
fileName = "../docs/lyng.io.http.md",
installModules = { scope -> createHttpModule(PermitAllHttpAccessPolicy, scope) },
installConsts = { scope ->
scope.addConst("HTTP_TEST_URL", ObjString("http://127.0.0.1:${server.address.port}"))
scope.addConst("HTTPS_TEST_URL", ObjString("https://127.0.0.1:${secureServer.address.port}"))
},
)
} finally {
server.stop(0)
secureServer.stop(0)
}
}
@Test
fun testNetDocs() = runBlocking {
ServerSocket(0, 50).use { server ->
val worker = thread(start = true) {
server.accept().use { client ->
val line = client.getInputStream().readNBytes(4).decodeToString()
client.getOutputStream().write(("reply:" + line).toByteArray())
client.getOutputStream().flush()
}
}
try {
runIoDocTests(
fileName = "../docs/lyng.io.net.md",
installModules = { scope -> createNetModule(PermitAllNetAccessPolicy, scope) },
installConsts = { scope -> scope.addConst("NET_TEST_TCP_PORT", ObjInt(server.localPort.toLong())) },
)
} finally {
worker.join(2000)
}
}
}
@Test
fun testWsDocs() = runBlocking {
TestWebSocketServer { connection ->
val text = connection.receiveText()
connection.sendText("echo:$text")
connection.close()
}.use { textServer ->
TestWebSocketServer { connection ->
val data = connection.receiveBinary()
connection.sendBinary(byteArrayOf(1, 2, 3) + data)
connection.close()
}.use { binaryServer ->
TestWebSocketServer(secure = true) { connection ->
val text = connection.receiveText()
connection.sendText("secure:$text")
connection.close()
}.use { secureServer ->
runIoDocTests(
fileName = "../docs/lyng.io.ws.md",
installModules = { scope -> createWsModule(PermitAllWsAccessPolicy, scope) },
installConsts = { scope ->
scope.addConst("WS_TEST_URL", ObjString(textServer.url))
scope.addConst("WS_TEST_BINARY_URL", ObjString(binaryServer.url))
scope.addConst("WSS_TEST_URL", ObjString(secureServer.url))
},
)
}
}
}
}
private fun writeResponse(exchange: HttpExchange, status: Int, body: String) {
val bytes = body.toByteArray()
exchange.sendResponseHeaders(status, bytes.size.toLong())
exchange.responseBody.use { it.write(bytes) }
}
private fun newHttpServer(secure: Boolean): HttpServer {
if (secure) TlsTestMaterial.installJvmClientTrust()
val server = if (secure) {
HttpsServer.create(InetSocketAddress("127.0.0.1", 0), 0).apply {
httpsConfigurator = HttpsConfigurator(TlsTestMaterial.sslContext)
}
} else {
HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
}
server.createContext("/hello") { exchange ->
exchange.responseHeaders.add("Content-Type", "text/plain; charset=utf-8")
writeResponse(exchange, 200, "hello from test")
}
server.createContext("/headers") { exchange ->
exchange.responseHeaders.add("X-Reply", "one")
exchange.responseHeaders.add("X-Reply", "two")
writeResponse(exchange, 200, "header demo")
}
server.createContext("/echo") { exchange ->
val body = exchange.requestBody.readBytes().decodeToString()
writeResponse(exchange, 200, exchange.requestMethod + ":" + body)
}
server.start()
return server
}
}
@@ -0,0 +1,176 @@
/*
* 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.io.http
import com.sun.net.httpserver.HttpExchange
import com.sun.net.httpserver.HttpServer
import com.sun.net.httpserver.HttpsConfigurator
import com.sun.net.httpserver.HttpsServer
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.ExecutionError
import net.sergeych.lyng.Script
import net.sergeych.lyng.io.testtls.TlsTestMaterial
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import net.sergeych.lyngio.http.security.HttpAccessOp
import net.sergeych.lyngio.http.security.HttpAccessPolicy
import net.sergeych.lyngio.http.security.PermitAllHttpAccessPolicy
import java.net.InetSocketAddress
import kotlin.test.Test
import kotlin.test.assertFailsWith
import kotlin.test.assertTrue
class LyngHttpModuleTest {
@Test
fun testConvenienceGetAndHeaders() = runBlocking {
val server = newServer { exchange ->
exchange.responseHeaders.add("Content-Type", "text/plain; charset=utf-8")
exchange.responseHeaders.add("X-Reply", "one")
exchange.responseHeaders.add("X-Reply", "two")
writeResponse(exchange, 200, "hello from test")
}
try {
val scope = Script.newScope()
createHttpModule(PermitAllHttpAccessPolicy, scope)
val code = """
import lyng.io.http
val r = Http.get(
"http://127.0.0.1:${server.address.port}/hello",
"Accept" => "text/plain",
"X-Test" => "yes"
)
[r.status, r.headers["Content-Type"], r.headers.getAll("X-Reply").size, r.text()]
""".trimIndent()
val result = Compiler.compile(code).execute(scope)
val rendered = result.inspect(scope)
assertTrue(rendered.contains("200"), rendered)
assertTrue(rendered.contains("text/plain"), rendered)
assertTrue(rendered.contains("2"), rendered)
assertTrue(rendered.contains("hello from test"), rendered)
} finally {
server.stop(0)
}
}
@Test
fun testMutableRequestPost() = runBlocking {
val server = newServer { exchange ->
val body = exchange.requestBody.readBytes().decodeToString()
exchange.responseHeaders.add("Content-Type", "text/plain")
writeResponse(exchange, 200, exchange.requestMethod + ":" + body)
}
try {
val scope = Script.newScope()
createHttpModule(PermitAllHttpAccessPolicy, scope)
val code = """
import lyng.io.http
val q = HttpRequest()
q.method = "POST"
q.url = "http://127.0.0.1:${server.address.port}/echo"
q.headers = Map("Content-Type" => "text/plain")
q.bodyText = "ping"
val r = Http.request(q)
r.text()
""".trimIndent()
val result = Compiler.compile(code).execute(scope)
assertTrue(result.inspect(scope).contains("POST:ping"))
} finally {
server.stop(0)
}
}
@Test
fun testHttpsGet() = runBlocking {
TlsTestMaterial.installJvmClientTrust()
val server = newServer(secure = true) { exchange ->
exchange.responseHeaders.add("Content-Type", "text/plain; charset=utf-8")
writeResponse(exchange, 200, "hello over tls")
}
try {
val scope = Script.newScope()
createHttpModule(PermitAllHttpAccessPolicy, scope)
val code = """
import lyng.io.http
val r = Http.get("https://127.0.0.1:${server.address.port}/hello")
[r.status, r.text()]
""".trimIndent()
val result = Compiler.compile(code).execute(scope)
val rendered = result.inspect(scope)
assertTrue(rendered.contains("200"), rendered)
assertTrue(rendered.contains("hello over tls"), rendered)
} finally {
server.stop(0)
}
}
@Test
fun testPolicyDenialSurfacesAsLyngError() = runBlocking {
val scope = Script.newScope()
val denyAll = object : HttpAccessPolicy {
override suspend fun check(op: HttpAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Deny, "blocked by test policy")
}
createHttpModule(denyAll, scope)
val code = """
import lyng.io.http
Http.get("http://127.0.0.1:1/")
""".trimIndent()
val error = assertFailsWith<ExecutionError> {
Compiler.compile(code).execute(scope)
}
assertTrue(error.errorMessage.isNotBlank())
}
private fun newServer(secure: Boolean = false, handler: (HttpExchange) -> Unit): HttpServer {
val server = if (secure) {
HttpsServer.create(InetSocketAddress("127.0.0.1", 0), 0).apply {
httpsConfigurator = HttpsConfigurator(TlsTestMaterial.sslContext)
}
} else {
HttpServer.create(InetSocketAddress("127.0.0.1", 0), 0)
}
server.createContext("/") { exchange ->
handler(exchange)
}
server.start()
return server
}
private fun writeResponse(exchange: HttpExchange, status: Int, body: String) {
val bytes = body.toByteArray()
exchange.sendResponseHeaders(status, bytes.size.toLong())
exchange.responseBody.use { out ->
out.write(bytes)
}
}
}
@@ -0,0 +1,168 @@
/*
* 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.io.net
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withContext
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.ExecutionError
import net.sergeych.lyng.Script
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import net.sergeych.lyngio.net.security.NetAccessOp
import net.sergeych.lyngio.net.security.NetAccessPolicy
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import java.net.DatagramPacket
import java.net.DatagramSocket
import java.net.ServerSocket
import java.net.Socket
import kotlin.concurrent.thread
import kotlin.test.Test
import kotlin.test.assertFailsWith
import kotlin.test.assertTrue
class LyngNetModuleTest {
@Test
fun testResolveAndCapabilities() = runBlocking {
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.io.net
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
[Net.isSupported(), Net.isTcpAvailable(), Net.isTcpServerAvailable(), Net.isUdpAvailable(), a.toString(), a.resolved, a.ipVersion == IpVersion.IPV4]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("true,true,true,true"), result)
assertTrue(result.contains("127.0.0.1:4040"), result)
}
@Test
fun testTcpConnectConvenience() = runBlocking {
ServerSocket(0, 50).use { server ->
val worker = thread(start = true) {
server.accept().use { client ->
val line = client.getInputStream().readNBytes(4).decodeToString()
client.getOutputStream().write(("reply:" + line).toByteArray())
client.getOutputStream().flush()
}
}
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.net
val socket = Net.tcpConnect("127.0.0.1", ${server.localPort})
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
val localPort = socket.localAddress().port
val remotePort = socket.remoteAddress().port
socket.close()
[reply, localPort > 0, remotePort == ${server.localPort}]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
worker.join(2000)
assertTrue(result.contains("reply:ping"), result)
assertTrue(result.contains("true,true"), result)
}
}
@Test
fun testTcpListenAndAcceptInLyng() = runBlocking {
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.net
val server = Net.tcpListen(0, "127.0.0.1")
val port = server.localAddress().port
val accepted = launch {
val client = server.accept()
val line = (client.read(4) as Buffer).decodeUtf8()
client.writeUtf8("echo:" + line)
client.flush()
client.close()
server.close()
line
}
val socket = Net.tcpConnect("127.0.0.1", port)
socket.writeUtf8("ping")
socket.flush()
val reply = (socket.read(16) as Buffer).decodeUtf8()
socket.close()
[accepted.await(), reply]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("[ping,echo:ping]"), result)
}
@Test
fun testUdpLoopback() = runBlocking {
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.net
val server = Net.udpBind(0, "127.0.0.1")
val client = Net.udpBind(0, "127.0.0.1")
client.send(Buffer("ping"), "127.0.0.1", server.localAddress().port)
val d = server.receive()
client.close()
server.close()
[d.data.decodeUtf8(), d.address.port > 0]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("[ping,true]"), result)
}
@Test
fun testPolicyDenialSurfacesAsLyngError() = runBlocking {
val scope = Script.newScope()
val denyAll = object : NetAccessPolicy {
override suspend fun check(op: NetAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Deny, "blocked by test policy")
}
createNetModule(denyAll, scope)
val code = """
import lyng.io.net
Net.tcpConnect("127.0.0.1", 1)
""".trimIndent()
val error = assertFailsWith<ExecutionError> {
Compiler.compile(code).execute(scope)
}
assertTrue(error.errorMessage.isNotBlank())
}
}
@@ -0,0 +1,123 @@
/*
* 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.io.testtls
import java.nio.file.Files
import java.nio.file.Path
import java.security.KeyStore
import javax.net.ssl.KeyManagerFactory
import javax.net.ssl.SSLContext
import javax.net.ssl.SSLServerSocketFactory
import javax.net.ssl.TrustManagerFactory
import kotlin.io.path.absolutePathString
internal object TlsTestMaterial {
private const val STORE_PASSWORD = "changeit"
private const val KEY_ALIAS = "lyng-io-test"
private val dir: Path by lazy { Files.createTempDirectory("lyng-io-tls-test-") }
private val serverStore: Path by lazy { dir.resolve("server.p12") }
private val trustStore: Path by lazy { dir.resolve("trust.p12") }
private val certFile: Path by lazy { dir.resolve("server.cer") }
val serverSocketFactory: SSLServerSocketFactory by lazy {
ensureGenerated()
val keyStore = KeyStore.getInstance("PKCS12")
serverStore.toFile().inputStream().use { keyStore.load(it, STORE_PASSWORD.toCharArray()) }
val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
kmf.init(keyStore, STORE_PASSWORD.toCharArray())
SSLContext.getInstance("TLS").apply {
init(kmf.keyManagers, null, null)
}.serverSocketFactory
}
val sslContext: SSLContext by lazy {
ensureGenerated()
val keyStore = KeyStore.getInstance("PKCS12")
serverStore.toFile().inputStream().use { keyStore.load(it, STORE_PASSWORD.toCharArray()) }
val kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm())
kmf.init(keyStore, STORE_PASSWORD.toCharArray())
val trust = KeyStore.getInstance("PKCS12")
trustStore.toFile().inputStream().use { trust.load(it, STORE_PASSWORD.toCharArray()) }
val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
tmf.init(trust)
SSLContext.getInstance("TLS").apply {
init(kmf.keyManagers, tmf.trustManagers, null)
}
}
fun installJvmClientTrust() {
ensureGenerated()
System.setProperty("javax.net.ssl.trustStore", trustStore.absolutePathString())
System.setProperty("javax.net.ssl.trustStorePassword", STORE_PASSWORD)
System.setProperty("javax.net.ssl.trustStoreType", "PKCS12")
val trust = KeyStore.getInstance("PKCS12")
trustStore.toFile().inputStream().use { trust.load(it, STORE_PASSWORD.toCharArray()) }
val tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
tmf.init(trust)
SSLContext.setDefault(
SSLContext.getInstance("TLS").apply {
init(null, tmf.trustManagers, null)
}
)
}
private fun ensureGenerated() {
if (Files.exists(serverStore) && Files.exists(trustStore) && Files.exists(certFile)) return
runKeytool(
"-genkeypair",
"-alias", KEY_ALIAS,
"-keyalg", "RSA",
"-keysize", "2048",
"-validity", "2",
"-storetype", "PKCS12",
"-keystore", serverStore.absolutePathString(),
"-storepass", STORE_PASSWORD,
"-keypass", STORE_PASSWORD,
"-dname", "CN=127.0.0.1, OU=Lyng, O=Lyng, L=Test, ST=Test, C=US",
"-ext", "SAN=ip:127.0.0.1,dns:localhost",
)
runKeytool(
"-exportcert",
"-alias", KEY_ALIAS,
"-keystore", serverStore.absolutePathString(),
"-storepass", STORE_PASSWORD,
"-rfc",
"-file", certFile.absolutePathString(),
)
runKeytool(
"-importcert",
"-noprompt",
"-alias", KEY_ALIAS,
"-storetype", "PKCS12",
"-keystore", trustStore.absolutePathString(),
"-storepass", STORE_PASSWORD,
"-file", certFile.absolutePathString(),
)
}
private fun runKeytool(vararg args: String) {
val process = ProcessBuilder(listOf("keytool") + args)
.redirectErrorStream(true)
.start()
val output = process.inputStream.bufferedReader().readText()
val code = process.waitFor()
require(code == 0) { "keytool failed: $output" }
}
}
@@ -0,0 +1,135 @@
/*
* 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.io.ws
import kotlinx.coroutines.runBlocking
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.ExecutionError
import net.sergeych.lyng.Script
import net.sergeych.lyngio.fs.security.AccessContext
import net.sergeych.lyngio.fs.security.AccessDecision
import net.sergeych.lyngio.fs.security.Decision
import net.sergeych.lyngio.ws.security.PermitAllWsAccessPolicy
import net.sergeych.lyngio.ws.security.WsAccessOp
import net.sergeych.lyngio.ws.security.WsAccessPolicy
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertTrue
class LyngWsModuleTest {
@Test
fun testTextSessionAndHeaders() = runBlocking {
TestWebSocketServer { connection ->
assertEquals("yes", connection.requestHeaders["x-test"])
val text = connection.receiveText()
connection.sendText("echo:$text")
connection.close()
}.use { server ->
val scope = Script.newScope()
createWsModule(PermitAllWsAccessPolicy, scope)
val code = """
import lyng.io.ws
val ws = Ws.connect("${server.url}", "X-Test" => "yes")
ws.sendText("ping")
val m: WsMessage = ws.receive()
ws.close()
[ws.url(), m.isText, m.text]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains(server.url), result)
assertTrue(result.contains("true,echo:ping"), result)
}
}
@Test
fun testBinarySession() = runBlocking {
TestWebSocketServer { connection ->
val data = connection.receiveBinary()
connection.sendBinary(byteArrayOf(1, 2, 3) + data)
connection.close()
}.use { server ->
val scope = Script.newScope()
createWsModule(PermitAllWsAccessPolicy, scope)
val code = """
import lyng.buffer
import lyng.io.ws
val ws = Ws.connect("${server.url}")
ws.sendBytes(Buffer(9, 8, 7))
val m: WsMessage = ws.receive()
ws.close()
[m.isText, (m.data as Buffer).hex]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("false,010203090807"), result)
}
}
@Test
fun testSecureTextSession() = runBlocking {
TestWebSocketServer(secure = true) { connection ->
val text = connection.receiveText()
connection.sendText("secure:$text")
connection.close()
}.use { server ->
val scope = Script.newScope()
createWsModule(PermitAllWsAccessPolicy, scope)
val code = """
import lyng.io.ws
val ws = Ws.connect("${server.url}")
ws.sendText("ping")
val m: WsMessage = ws.receive()
ws.close()
[ws.url(), m.text]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains(server.url), result)
assertTrue(result.contains("secure:ping"), result)
}
}
@Test
fun testPolicyDenialSurfacesAsLyngError() = runBlocking {
val scope = Script.newScope()
val denyAll = object : WsAccessPolicy {
override suspend fun check(op: WsAccessOp, ctx: AccessContext): AccessDecision =
AccessDecision(Decision.Deny, "blocked by test policy")
}
createWsModule(denyAll, scope)
val code = """
import lyng.io.ws
Ws.connect("ws://127.0.0.1:1/ws")
""".trimIndent()
val error = assertFailsWith<ExecutionError> {
Compiler.compile(code).execute(scope)
}
assertTrue(error.errorMessage.isNotBlank())
}
}
@@ -0,0 +1,180 @@
/*
* 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.io.ws
import net.sergeych.lyng.io.testtls.TlsTestMaterial
import java.io.BufferedInputStream
import java.io.BufferedOutputStream
import java.net.InetAddress
import java.net.ServerSocket
import java.net.Socket
import java.security.MessageDigest
import java.util.Base64
import kotlin.concurrent.thread
internal class TestWebSocketServer(
secure: Boolean = false,
private val handler: (TestWebSocketConnection) -> Unit,
) : AutoCloseable {
private val server: ServerSocket = if (secure) {
TlsTestMaterial.installJvmClientTrust()
TlsTestMaterial.serverSocketFactory.createServerSocket(0, 50, InetAddress.getByName("127.0.0.1")) as ServerSocket
} else {
ServerSocket(0, 50, InetAddress.getByName("127.0.0.1"))
}
private val scheme = if (secure) "wss" else "ws"
private val worker = thread(start = true, name = "ws-test-server") {
try {
server.accept().use { socket ->
val connection = TestWebSocketConnection(socket)
connection.handshake()
handler(connection)
}
} catch (_: Exception) {
}
}
val url: String = "$scheme://127.0.0.1:${server.localPort}/ws"
override fun close() {
server.close()
worker.join(2000)
}
}
internal class TestWebSocketConnection(socket: Socket) {
private val input = BufferedInputStream(socket.getInputStream())
private val output = BufferedOutputStream(socket.getOutputStream())
val requestHeaders = linkedMapOf<String, String>()
fun handshake() {
val requestLine = input.readAsciiLine() ?: error("missing websocket request line")
require(requestLine.startsWith("GET ")) { "unexpected request: $requestLine" }
while (true) {
val line = input.readAsciiLine() ?: error("unexpected EOF during websocket handshake")
if (line.isEmpty()) break
val colon = line.indexOf(':')
if (colon > 0) {
requestHeaders[line.substring(0, colon).trim().lowercase()] = line.substring(colon + 1).trim()
}
}
val key = requestHeaders["sec-websocket-key"] ?: error("missing Sec-WebSocket-Key")
val accept = Base64.getEncoder().encodeToString(
MessageDigest.getInstance("SHA-1")
.digest((key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").toByteArray())
)
output.write(
(
"HTTP/1.1 101 Switching Protocols\r\n" +
"Upgrade: websocket\r\n" +
"Connection: Upgrade\r\n" +
"Sec-WebSocket-Accept: $accept\r\n" +
"\r\n"
).toByteArray()
)
output.flush()
}
fun receiveText(): String = receiveFrame().let { frame ->
require(frame.opcode == 0x1) { "expected text frame, got opcode=${frame.opcode}" }
frame.payload.decodeToString()
}
fun receiveBinary(): ByteArray = receiveFrame().let { frame ->
require(frame.opcode == 0x2) { "expected binary frame, got opcode=${frame.opcode}" }
frame.payload
}
fun sendText(text: String) {
sendFrame(0x1, text.encodeToByteArray())
}
fun sendBinary(data: ByteArray) {
sendFrame(0x2, data)
}
fun close(code: Int = 1000, reason: String = "") {
val reasonBytes = reason.encodeToByteArray()
val payload = ByteArray(2 + reasonBytes.size)
payload[0] = ((code shr 8) and 0xff).toByte()
payload[1] = (code and 0xff).toByte()
reasonBytes.copyInto(payload, 2)
sendFrame(0x8, payload)
}
private fun sendFrame(opcode: Int, payload: ByteArray) {
output.write(0x80 or opcode)
when {
payload.size < 126 -> output.write(payload.size)
payload.size <= 0xffff -> {
output.write(126)
output.write((payload.size ushr 8) and 0xff)
output.write(payload.size and 0xff)
}
else -> error("payload too large for test websocket server")
}
output.write(payload)
output.flush()
}
private fun receiveFrame(): IncomingFrame {
val b0 = input.read()
require(b0 >= 0) { "unexpected EOF reading websocket frame" }
val b1 = input.read()
require(b1 >= 0) { "unexpected EOF reading websocket frame length" }
val opcode = b0 and 0x0f
var length = b1 and 0x7f
if (length == 126) {
length = (input.read() shl 8) or input.read()
} else if (length == 127) {
error("64-bit websocket lengths are not supported in tests")
}
val masked = (b1 and 0x80) != 0
val mask = if (masked) ByteArray(4).also { input.readFully(it) } else null
val payload = ByteArray(length)
input.readFully(payload)
if (mask != null) {
for (i in payload.indices) payload[i] = (payload[i].toInt() xor mask[i % 4].toInt()).toByte()
}
return IncomingFrame(opcode, payload)
}
}
private data class IncomingFrame(val opcode: Int, val payload: ByteArray)
private fun BufferedInputStream.readAsciiLine(): String? {
val out = StringBuilder()
while (true) {
val b = read()
if (b < 0) return if (out.isEmpty()) null else out.toString()
if (b == '\n'.code) {
if (out.endsWith("\r")) out.setLength(out.length - 1)
return out.toString()
}
out.append(b.toChar())
}
}
private fun BufferedInputStream.readFully(target: ByteArray) {
var offset = 0
while (offset < target.size) {
val read = read(target, offset, target.size - offset)
require(read > 0) { "unexpected EOF" }
offset += read
}
}
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.http
import io.ktor.client.engine.curl.Curl
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(Curl)
@@ -0,0 +1,8 @@
package net.sergeych.lyngio.net
actual fun getSystemNetEngine(): LyngNetEngine = createNativeKtorNetEngine(
isSupported = true,
isTcpAvailable = true,
isTcpServerAvailable = true,
isUdpAvailable = true,
)
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.ws
import io.ktor.client.engine.curl.Curl
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(Curl)
@@ -0,0 +1,90 @@
package net.sergeych.lyngio.net
import kotlinx.coroutines.async
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import net.sergeych.lyng.Compiler
import net.sergeych.lyng.Script
import net.sergeych.lyng.io.net.createNetModule
import net.sergeych.lyngio.net.security.PermitAllNetAccessPolicy
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertTrue
class NetLinuxNativeTest {
@Test
fun testLinuxNativeCapabilitiesAndResolve() = runBlocking {
val engine = getSystemNetEngine()
assertTrue(engine.isSupported)
assertTrue(engine.isTcpAvailable)
assertTrue(engine.isTcpServerAvailable)
assertTrue(engine.isUdpAvailable)
val resolved = engine.resolve("127.0.0.1", 4040)
assertEquals(1, resolved.size)
assertEquals("127.0.0.1", resolved.single().host)
assertEquals(4040, resolved.single().port)
assertEquals(LyngIpVersion.IPV4, resolved.single().ipVersion)
assertTrue(resolved.single().resolved)
}
@Test
fun testLinuxNativeLyngModuleCapabilities() = runBlocking {
val scope = Script.newScope()
createNetModule(PermitAllNetAccessPolicy, scope)
val code = """
import lyng.io.net
val a: SocketAddress = Net.resolve("127.0.0.1", 4040)[0]
[Net.isSupported(), Net.isTcpAvailable(), Net.isTcpServerAvailable(), Net.isUdpAvailable(), a.toString(), a.resolved]
""".trimIndent()
val result = Compiler.compile(code).execute(scope).inspect(scope)
assertTrue(result.contains("true,true,true,true"), result)
assertTrue(result.contains("127.0.0.1:4040"), result)
}
@Test
fun testLinuxNativeTcpAndUdpLoopback() = runBlocking {
val engine = getSystemNetEngine()
withTimeout(5_000) {
val server = engine.tcpListen(host = "127.0.0.1", port = 0, backlog = 16, reuseAddress = true)
val accepted = async {
val client = server.accept()
val text = client.read(4)?.decodeToString()
client.writeUtf8("echo:$text")
client.flush()
client.close()
server.close()
text
}
val socket = engine.tcpConnect("127.0.0.1", server.localAddress().port, timeoutMillis = 2_000, noDelay = true)
socket.writeUtf8("ping")
socket.flush()
val reply = socket.read(32)?.decodeToString()
socket.close()
assertEquals("ping", accepted.await())
assertEquals("echo:ping", reply)
}
withTimeout(5_000) {
val receiver = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
val sender = engine.udpBind(host = "127.0.0.1", port = 0, reuseAddress = true)
sender.send("ping".encodeToByteArray(), "127.0.0.1", receiver.localAddress().port)
val datagram = receiver.receive(32)
sender.close()
receiver.close()
assertEquals("ping", datagram?.data?.decodeToString())
assertTrue((datagram?.address?.port ?: 0) > 0)
}
}
}
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.http
import io.ktor.client.engine.winhttp.WinHttp
actual fun getSystemHttpEngine(): LyngHttpEngine = createKtorHttpEngine(WinHttp)
@@ -0,0 +1,3 @@
package net.sergeych.lyngio.net
actual fun getSystemNetEngine(): LyngNetEngine = UnsupportedLyngNetEngine
@@ -0,0 +1,5 @@
package net.sergeych.lyngio.ws
import io.ktor.client.engine.winhttp.WinHttp
actual fun getSystemWsEngine(): LyngWsEngine = createKtorWsEngine(WinHttp)
@@ -0,0 +1,216 @@
package net.sergeych.lyngio.net
import io.ktor.network.selector.SelectorManager
import io.ktor.network.sockets.BoundDatagramSocket
import io.ktor.network.sockets.Datagram
import io.ktor.network.sockets.InetSocketAddress
import io.ktor.network.sockets.ServerSocket
import io.ktor.network.sockets.Socket
import io.ktor.network.sockets.SocketAddress
import io.ktor.network.sockets.aSocket
import io.ktor.network.sockets.isClosed
import io.ktor.network.sockets.openReadChannel
import io.ktor.network.sockets.openWriteChannel
import io.ktor.utils.io.ByteReadChannel
import io.ktor.utils.io.ByteWriteChannel
import io.ktor.utils.io.readAvailable
import io.ktor.utils.io.readUTF8Line
import io.ktor.utils.io.writeFully
import io.ktor.utils.io.writeStringUtf8
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withTimeout
import kotlinx.io.Buffer
import kotlinx.io.readByteArray
internal fun createNativeKtorNetEngine(
isSupported: Boolean,
isTcpAvailable: Boolean,
isTcpServerAvailable: Boolean,
isUdpAvailable: Boolean,
): LyngNetEngine = NativeKtorNetEngine(
isSupported = isSupported,
isTcpAvailable = isTcpAvailable,
isTcpServerAvailable = isTcpServerAvailable,
isUdpAvailable = isUdpAvailable,
)
private class NativeKtorNetEngine(
override val isSupported: Boolean,
override val isTcpAvailable: Boolean,
override val isTcpServerAvailable: Boolean,
override val isUdpAvailable: Boolean,
) : LyngNetEngine {
private val selectorManager: SelectorManager by lazy { SelectorManager(Dispatchers.Default) }
override suspend fun resolve(host: String, port: Int): List<LyngSocketAddress> {
val rawAddress = InetSocketAddress(host, port).resolveAddress()
?: throw IllegalStateException("Failed to resolve address for $host")
return listOf(
LyngSocketAddress(
host = rawAddress.toIpHostString(),
port = port,
ipVersion = rawAddress.toLyngIpVersion(),
resolved = true,
)
)
}
override suspend fun tcpConnect(
host: String,
port: Int,
timeoutMillis: Long?,
noDelay: Boolean,
): LyngTcpSocket {
val connectBlock: suspend () -> Socket = {
aSocket(selectorManager).tcp().connect(host, port) {
this.noDelay = noDelay
}
}
val socket = if (timeoutMillis != null) withTimeout(timeoutMillis) { connectBlock() } else connectBlock()
return NativeLyngTcpSocket(socket)
}
override suspend fun tcpListen(
host: String?,
port: Int,
backlog: Int,
reuseAddress: Boolean,
): LyngTcpServer {
val bindHost = host ?: "0.0.0.0"
val server = aSocket(selectorManager).tcp().bind(bindHost, port) {
backlogSize = backlog
this.reuseAddress = reuseAddress
}
return NativeLyngTcpServer(server)
}
override suspend fun udpBind(host: String?, port: Int, reuseAddress: Boolean): LyngUdpSocket {
val bindHost = host ?: "0.0.0.0"
val socket = aSocket(selectorManager).udp().bind(bindHost, port) {
this.reuseAddress = reuseAddress
}
return NativeLyngUdpSocket(socket)
}
}
private class NativeLyngTcpSocket(
private val socket: Socket,
) : LyngTcpSocket {
private val input: ByteReadChannel by lazy { socket.openReadChannel() }
private val output: ByteWriteChannel by lazy { socket.openWriteChannel(autoFlush = true) }
override fun isOpen(): Boolean = !socket.isClosed
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
override fun remoteAddress(): LyngSocketAddress = socket.remoteAddress.toLyngSocketAddress(resolved = true)
override suspend fun read(maxBytes: Int): ByteArray? {
if (!input.awaitContent(1)) return null
val buffer = ByteArray(maxBytes)
val count = input.readAvailable(buffer, 0, maxBytes)
return when {
count <= 0 -> null
count == maxBytes -> buffer
else -> buffer.copyOf(count)
}
}
override suspend fun readLine(): String? = input.readUTF8Line()
override suspend fun write(data: ByteArray) {
output.writeFully(data, 0, data.size)
}
override suspend fun writeUtf8(text: String) {
output.writeStringUtf8(text)
}
override suspend fun flush() {
output.flush()
}
override fun close() {
socket.close()
}
}
private class NativeLyngTcpServer(
private val server: ServerSocket,
) : LyngTcpServer {
override fun isOpen(): Boolean = !server.isClosed
override fun localAddress(): LyngSocketAddress = server.localAddress.toLyngSocketAddress(resolved = true)
override suspend fun accept(): LyngTcpSocket = NativeLyngTcpSocket(server.accept())
override fun close() {
server.close()
}
}
private class NativeLyngUdpSocket(
private val socket: BoundDatagramSocket,
) : LyngUdpSocket {
override fun isOpen(): Boolean = !socket.isClosed
override fun localAddress(): LyngSocketAddress = socket.localAddress.toLyngSocketAddress(resolved = true)
override suspend fun receive(maxBytes: Int): LyngDatagram? {
val datagram = try {
socket.receive()
} catch (e: Throwable) {
if (!isOpen()) return null
throw e
}
val bytes = datagram.packet.readByteArray().let {
if (it.size <= maxBytes) it else it.copyOf(maxBytes)
}
return LyngDatagram(bytes, datagram.address.toLyngSocketAddress(resolved = true))
}
override suspend fun send(data: ByteArray, host: String, port: Int) {
val packet = Buffer()
packet.write(data)
socket.send(Datagram(packet, InetSocketAddress(host, port)))
}
override fun close() {
socket.close()
}
}
private fun SocketAddress.toLyngSocketAddress(resolved: Boolean): LyngSocketAddress {
val inetAddress = this as? InetSocketAddress
if (inetAddress != null) {
val rawAddress = inetAddress.resolveAddress()
val host = rawAddress?.toIpHostString() ?: inetAddress.hostname
return LyngSocketAddress(
host = host,
port = inetAddress.port,
ipVersion = rawAddress?.toLyngIpVersion()
?: if (host.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
resolved = resolved,
)
}
val rendered = toString()
return LyngSocketAddress(
host = rendered,
port = 0,
ipVersion = if (rendered.contains(':')) LyngIpVersion.IPV6 else LyngIpVersion.IPV4,
resolved = resolved,
)
}
private fun ByteArray.toLyngIpVersion(): LyngIpVersion = if (size == 16) LyngIpVersion.IPV6 else LyngIpVersion.IPV4
private fun ByteArray.toIpHostString(): String = when (size) {
4 -> joinToString(".") { (it.toInt() and 0xff).toString() }
16 -> (0 until 8).joinToString(":") { index ->
val hi = this[index * 2].toInt() and 0xff
val lo = this[index * 2 + 1].toInt() and 0xff
((hi shl 8) or lo).toString(16)
}
else -> error("Unsupported IP address length: $size")
}
+72
View File
@@ -0,0 +1,72 @@
package lyng.io.http
/*
Response/header view that behaves like a map for the first value of each header name.
Multi-valued headers are exposed through `getAll`.
*/
extern class HttpHeaders : Map<String, String> {
/* Return the first value for the given header name, or null when absent. */
fun get(name: String): String?
/* Return all values for the given header name, preserving wire order when available. */
fun getAll(name: String): List<String>
/* Return distinct header names present in this response. */
fun names(): List<String>
}
/* Mutable request descriptor for programmatic HTTP calls. */
extern class HttpRequest {
/* Request method, e.g. GET, POST, PUT, DELETE. */
var method: String
/* Absolute URL including scheme. */
var url: String
/* Simple request headers map. */
var headers: Map<String, String>
/* Optional UTF-8 request body. */
var bodyText: String?
/* Optional binary request body. */
var bodyBytes: Buffer?
/* Optional total request timeout in milliseconds. */
var timeoutMillis: Int?
}
/* HTTP response snapshot with cached body accessors. */
extern class HttpResponse {
/* Numeric status code, e.g. 200, 404, 500. */
val status: Int
/* Human-readable status text when available. */
val statusText: String
/* Response headers. */
val headers: HttpHeaders
/* Decode response body as text. Cached after first call. */
fun text(): String
/* Return response body as bytes. Cached after first call. */
fun bytes(): Buffer
}
/* HTTP/HTTPS client singleton. */
extern object Http {
/* True when HTTP client support is available on this runtime. */
fun isSupported(): Bool
/* Execute a request described by `HttpRequest`. */
fun request(req: HttpRequest): HttpResponse
/*
Convenience GET request.
`headers...` accepts `MapEntry` values such as `"Accept" => "text/plain"`
and 2-item lists such as `["Accept", "text/plain"]`.
*/
fun get(url: String, headers...): HttpResponse
/*
Convenience POST request with UTF-8 body text.
`headers...` follows the same rules as `get`.
*/
fun post(url: String, bodyText: String = "", contentType: String? = null, headers...): HttpResponse
/*
Convenience POST request with binary body.
`headers...` follows the same rules as `get`.
*/
fun postBytes(url: String, body: Buffer, contentType: String? = null, headers...): HttpResponse
}
+113
View File
@@ -0,0 +1,113 @@
package lyng.io.net
/* Address family for resolved or bound endpoints. */
enum IpVersion {
IPV4,
IPV6
}
/* Concrete socket endpoint. */
extern class SocketAddress {
/* Numeric or host-form address string. */
val host: String
/* Transport port number. */
val port: Int
/* Address family. */
val ipVersion: IpVersion
/* True when obtained from DNS resolution rather than raw bind input. */
val resolved: Bool
/* Stable printable form such as `127.0.0.1:4040` or `[::1]:4040`. */
override fun toString(): String
}
/* Datagram payload paired with sender/peer address. */
extern class Datagram {
val data: Buffer
val address: SocketAddress
}
/* Connected TCP socket. */
extern class TcpSocket {
/* True while the socket remains open. */
fun isOpen(): Bool
/* Local bound address after connect/bind. */
fun localAddress(): SocketAddress
/* Connected peer address. */
fun remoteAddress(): SocketAddress
/* Read up to `maxBytes`; returns null on clean EOF before any data. */
fun read(maxBytes: Int = 65536): Buffer?
/* Read one UTF-8 line without trailing newline; null on clean EOF. */
fun readLine(): String?
/* Write all bytes from the buffer. */
fun write(data: Buffer): void
/* Write UTF-8 encoded text. */
fun writeUtf8(text: String): void
/* Flush buffered output if needed by the backend. */
fun flush(): void
/* Close the socket. */
fun close(): void
}
/* Listening TCP server socket. */
extern class TcpServer {
/* True while the listening socket remains open. */
fun isOpen(): Bool
/* Actual local bind address. */
fun localAddress(): SocketAddress
/* Accept next incoming client connection. */
fun accept(): TcpSocket
/* Close the listening socket. */
fun close(): void
}
/* Bound UDP socket. */
extern class UdpSocket {
/* True while the socket remains open. */
fun isOpen(): Bool
/* Actual local bind address. */
fun localAddress(): SocketAddress
/* Receive one datagram up to `maxBytes`, or null on clean shutdown. */
fun receive(maxBytes: Int = 65536): Datagram?
/* Send one datagram to the provided host and port. */
fun send(data: Buffer, host: String, port: Int): void
/* Close the socket. */
fun close(): void
}
/* Raw transport networking singleton. */
extern object Net {
/* True when at least one transport feature is implemented on this runtime. */
fun isSupported(): Bool
/* True when outbound TCP client sockets are available. */
fun isTcpAvailable(): Bool
/* True when listening TCP server sockets are available. */
fun isTcpServerAvailable(): Bool
/* True when UDP datagram sockets are available. */
fun isUdpAvailable(): Bool
/* Resolve host name and port into concrete addresses. */
fun resolve(host: String, port: Int): List<SocketAddress>
/* Connect outbound TCP socket. */
fun tcpConnect(
host: String,
port: Int,
timeoutMillis: Int? = null,
noDelay: Bool = true
): TcpSocket
/* Start listening TCP server socket. */
fun tcpListen(
port: Int,
host: String? = null,
backlog: Int = 128,
reuseAddress: Bool = true
): TcpServer
/* Bind UDP socket, using an ephemeral port by default. */
fun udpBind(
port: Int = 0,
host: String? = null,
reuseAddress: Bool = true
): UdpSocket
}
+40
View File
@@ -0,0 +1,40 @@
package lyng.io.ws
/* Received WebSocket message. */
extern class WsMessage {
/* True when this message carries text payload. */
val isText: Bool
/* Text payload for text messages, otherwise null. */
val text: String?
/* Binary payload for binary messages, otherwise null. */
val data: Buffer?
}
/* Active WebSocket client session. */
extern class WsSession {
/* True while the session remains open. */
fun isOpen(): Bool
/* Connected URL string. */
fun url(): String
/* Send a text message. */
fun sendText(text: String): void
/* Send a binary message. */
fun sendBytes(data: Buffer): void
/* Receive next message, or null on clean close. */
fun receive(): WsMessage?
/* Close the session with optional status code and reason. */
fun close(code: Int = 1000, reason: String = ""): void
}
/* WebSocket client singleton. */
extern object Ws {
/* True when WebSocket client support is available on this runtime. */
fun isSupported(): Bool
/*
Open a client WebSocket session.
`headers...` accepts `MapEntry` values such as `"Authorization" => "Bearer x"`
and 2-item lists such as `["Authorization", "Bearer x"]`.
*/
fun connect(url: String, headers...): WsSession
}
+70 -17
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
import org.jetbrains.kotlin.gradle.dsl.JvmTarget import org.jetbrains.kotlin.gradle.dsl.JvmTarget
group = "net.sergeych" group = "net.sergeych"
version = "1.5.1" version = "1.5.4-SNAPSHOT"
// Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below // Removed legacy buildscript classpath declarations; plugins are applied via the plugins DSL below
@@ -29,7 +29,7 @@ plugins {
alias(libs.plugins.kotlinMultiplatform) alias(libs.plugins.kotlinMultiplatform)
alias(libs.plugins.androidLibrary) alias(libs.plugins.androidLibrary)
// alias(libs.plugins.vanniktech.mavenPublish) // alias(libs.plugins.vanniktech.mavenPublish)
kotlin("plugin.serialization") version "2.2.21" kotlin("plugin.serialization") version "2.3.20"
id("com.codingfeline.buildkonfig") version "0.17.1" id("com.codingfeline.buildkonfig") version "0.17.1"
`maven-publish` `maven-publish`
} }
@@ -58,7 +58,6 @@ kotlin {
iosX64() iosX64()
iosArm64() iosArm64()
iosSimulatorArm64() iosSimulatorArm64()
macosX64()
macosArm64() macosArm64()
mingwX64() mingwX64()
linuxX64() linuxX64()
@@ -76,11 +75,13 @@ kotlin {
// Suppress Beta warning for expect/actual classes across all targets // Suppress Beta warning for expect/actual classes across all targets
targets.configureEach { targets.configureEach {
compilations.configureEach { compilations.configureEach {
compilerOptions.configure { compileTaskProvider.configure {
compilerOptions {
freeCompilerArgs.add("-Xexpect-actual-classes") freeCompilerArgs.add("-Xexpect-actual-classes")
} }
} }
} }
}
sourceSets { sourceSets {
all { all {
@@ -94,7 +95,7 @@ kotlin {
} }
val commonMain by getting { val commonMain by getting {
kotlin.srcDir("$buildDir/generated/buildConfig/commonMain/kotlin") kotlin.srcDir(layout.buildDirectory.dir("generated/buildConfig/commonMain/kotlin"))
dependencies { dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0") implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0")
implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1") implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.1")
@@ -110,6 +111,51 @@ kotlin {
implementation(libs.kotlinx.coroutines.test) implementation(libs.kotlinx.coroutines.test)
} }
} }
val matrixMultikMain by creating {
dependsOn(commonMain)
dependencies {
implementation(libs.multik.default)
}
}
val nativeMain by creating {
dependsOn(commonMain)
}
val matrixPureMain by creating {
dependsOn(commonMain)
}
val jvmMain by getting { dependsOn(matrixMultikMain) }
val androidMain by getting { dependsOn(matrixPureMain) }
val jsMain by getting { dependsOn(matrixMultikMain) }
val wasmJsMain by getting { dependsOn(matrixMultikMain) }
// Multik 0.3.0 does not publish ios native artifacts, so keep iOS on the pure backend.
val iosX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val iosArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val iosSimulatorArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val macosArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val mingwX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val linuxX64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val linuxArm64Main by getting {
dependsOn(nativeMain)
dependsOn(matrixPureMain)
}
val jvmTest by getting { val jvmTest by getting {
dependencies { dependencies {
// Allow tests to load external docs like lyng.io.fs via registrar // Allow tests to load external docs like lyng.io.fs via registrar
@@ -149,6 +195,9 @@ abstract class GenerateLyngStdlib : DefaultTask() {
val outBase = outputDir.get().asFile val outBase = outputDir.get().asFile
val targetDir = outBase.resolve(pkgPath) val targetDir = outBase.resolve(pkgPath)
targetDir.mkdirs() targetDir.mkdirs()
targetDir.listFiles()
?.filter { it.isFile && it.name.endsWith(".generated.kt") }
?.forEach { it.delete() }
val srcDir = sourceDir.get().asFile val srcDir = sourceDir.get().asFile
val files = srcDir.walkTopDown() val files = srcDir.walkTopDown()
@@ -156,34 +205,38 @@ abstract class GenerateLyngStdlib : DefaultTask() {
.sortedBy { it.name } .sortedBy { it.name }
.toList() .toList()
val content = if (files.isEmpty()) "" else buildString {
files.forEachIndexed { idx, f ->
val text = f.readText()
if (idx > 0) append("\n\n")
append(text)
}
}
fun escapeForQuoted(s: String): String = buildString { fun escapeForQuoted(s: String): String = buildString {
for (ch in s) when (ch) { for (ch in s) when (ch) {
'\\' -> append("\\\\") '\\' -> append("\\\\")
'"' -> append("\\\"") '"' -> append("\\\"")
'$' -> append("\\$")
'\n' -> append("\\n") '\n' -> append("\\n")
'\r' -> {} '\r' -> {}
'\t' -> append("\\t") '\t' -> append("\\t")
else -> append(ch) else -> append(ch)
} }
} }
val body = escapeForQuoted(content)
fun constantName(baseName: String): String {
val parts = baseName.split(Regex("[^A-Za-z0-9]+")).filter { it.isNotEmpty() }
if (parts.isEmpty()) return "moduleLyng"
val head = parts.first().replaceFirstChar { it.lowercase() }
val tail = parts.drop(1).joinToString("") { part ->
part.replaceFirstChar { it.uppercase() }
}
return "${head}${tail}Lyng"
}
for (file in files) {
val body = escapeForQuoted(file.readText())
val sb = StringBuilder() val sb = StringBuilder()
sb.append("package ").append(targetPkg).append("\n\n") sb.append("package ").append(targetPkg).append("\n\n")
sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n") sb.append("@Suppress(\"Unused\", \"MemberVisibilityCanBePrivate\")\n")
sb.append("internal val rootLyng = \"") sb.append("internal val ").append(constantName(file.nameWithoutExtension)).append(" = \"")
sb.append(body) sb.append(body)
sb.append("\"\n") sb.append("\"\n")
targetDir.resolve("${file.nameWithoutExtension}_lyng.generated.kt").writeText(sb.toString())
targetDir.resolve("root_lyng.generated.kt").writeText(sb.toString()) }
} }
} }
@@ -172,6 +172,7 @@ class Compiler(
private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf() private val callReturnTypeDeclByRef: MutableMap<CallRef, TypeDecl> = mutableMapOf()
private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf() private val callableReturnTypeByScopeId: MutableMap<Int, MutableMap<Int, ObjClass>> = mutableMapOf()
private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf() private val callableReturnTypeByName: MutableMap<String, ObjClass> = mutableMapOf()
private val callableReturnTypeDeclByName: MutableMap<String, TypeDecl> = mutableMapOf()
private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf() private val lambdaReturnTypeByRef: MutableMap<ObjRef, ObjClass> = mutableMapOf()
private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> = private val lambdaCaptureEntriesByRef: MutableMap<ValueFnRef, List<net.sergeych.lyng.bytecode.LambdaCaptureEntry>> =
mutableMapOf() mutableMapOf()
@@ -186,6 +187,8 @@ class Compiler(
private val externCallableNames: MutableSet<String> = mutableSetOf() private val externCallableNames: MutableSet<String> = mutableSetOf()
private val externBindingNames: MutableSet<String> = mutableSetOf() private val externBindingNames: MutableSet<String> = mutableSetOf()
private val moduleDeclaredNames: MutableSet<String> = mutableSetOf() private val moduleDeclaredNames: MutableSet<String> = mutableSetOf()
private val predeclaredTopLevelValueNames: MutableSet<String> = mutableSetOf()
private val moduleReferencePosByName: MutableMap<String, Pos> = mutableMapOf()
private var seedingSlotPlan: Boolean = false private var seedingSlotPlan: Boolean = false
private fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> { private fun moduleForcedLocalSlotInfo(): Map<String, ForcedLocalSlotInfo> {
@@ -340,6 +343,73 @@ class Compiler(
} }
return t return t
} }
fun handleTopLevelKeyword(keyword: Token): Boolean {
when (keyword.value) {
"fun", "fn" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) return true
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionCallableName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionCallableName(nameToken.value, actual.value))
}
return true
}
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
return true
}
"val", "var" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) return true
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionPropertyGetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertyGetterName(nameToken.value, actual.value))
if (keyword.value == "var") {
declareSlotNameIn(plan, extensionPropertySetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertySetterName(nameToken.value, actual.value))
}
}
return true
}
declareSlotNameIn(plan, nameToken.value, isMutable = keyword.value == "var", isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
predeclaredTopLevelValueNames.add(nameToken.value)
return true
}
"class", "object" -> {
val nameToken = nextNonWs()
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
return true
}
"enum" -> {
val next = nextNonWs()
val nameToken = if (next.type == Token.Type.ID && next.value == "class") nextNonWs() else next
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
return true
}
}
return false
}
try { try {
while (cc.hasNext()) { while (cc.hasNext()) {
val t = cc.next() val t = cc.next()
@@ -352,65 +422,11 @@ class Compiler(
Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth-- Token.Type.RBRACKET -> if (bracketDepth > 0) bracketDepth--
Token.Type.ID -> if (depth == 0) { Token.Type.ID -> if (depth == 0) {
if (parenDepth > 0 || bracketDepth > 0) continue if (parenDepth > 0 || bracketDepth > 0) continue
when (t.value) { if (t.value == "extern") {
"fun", "fn" -> { handleTopLevelKeyword(nextNonWs())
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) continue
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionCallableName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionCallableName(nameToken.value, actual.value))
}
continue continue
} }
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false) handleTopLevelKeyword(t)
moduleDeclaredNames.add(nameToken.value)
}
"val", "var" -> {
val nameToken = nextNonWs()
if (nameToken.type != Token.Type.ID) continue
val afterName = cc.peekNextNonWhitespace()
if (afterName.type == Token.Type.DOT) {
cc.nextNonWhitespace()
val actual = cc.nextNonWhitespace()
if (actual.type == Token.Type.ID) {
extensionNames.add(actual.value)
registerExtensionName(nameToken.value, actual.value)
declareSlotNameIn(plan, extensionPropertyGetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertyGetterName(nameToken.value, actual.value))
if (t.value == "var") {
declareSlotNameIn(plan, extensionPropertySetterName(nameToken.value, actual.value), isMutable = false, isDelegated = false)
moduleDeclaredNames.add(extensionPropertySetterName(nameToken.value, actual.value))
}
}
continue
}
declareSlotNameIn(plan, nameToken.value, isMutable = t.value == "var", isDelegated = false)
moduleDeclaredNames.add(nameToken.value)
}
"class", "object" -> {
val nameToken = nextNonWs()
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
}
"enum" -> {
val next = nextNonWs()
val nameToken = if (next.type == Token.Type.ID && next.value == "class") nextNonWs() else next
if (nameToken.type == Token.Type.ID) {
declareSlotNameIn(plan, nameToken.value, isMutable = false, isDelegated = false)
scopeSeedNames.add(nameToken.value)
moduleDeclaredNames.add(nameToken.value)
}
}
}
} }
else -> {} else -> {}
} }
@@ -420,6 +436,12 @@ class Compiler(
} }
} }
private fun rememberModuleReferencePos(name: String, pos: Pos) {
if (!moduleReferencePosByName.containsKey(name)) {
moduleReferencePosByName[name] = pos
}
}
private fun predeclareClassMembers(target: MutableSet<String>, overrides: MutableMap<String, Boolean>) { private fun predeclareClassMembers(target: MutableSet<String>, overrides: MutableMap<String, Boolean>) {
val saved = cc.savePos() val saved = cc.savePos()
var depth = 0 var depth = 0
@@ -932,6 +954,7 @@ class Compiler(
} }
} }
captureLocalRef(name, slotLoc, pos)?.let { ref -> captureLocalRef(name, slotLoc, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -977,8 +1000,11 @@ class Compiler(
if (moduleLoc != null) { if (moduleLoc != null) {
val moduleDeclaredNames = localNamesStack.firstOrNull() val moduleDeclaredNames = localNamesStack.firstOrNull()
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) { if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
resolveImportBinding(name, pos)?.let { resolved -> val resolvedImport = resolveImportBinding(name, pos)
registerImportBinding(name, resolved.binding, pos) if (resolvedImport != null) {
registerImportBinding(name, resolvedImport.binding, pos)
} else if (predeclaredTopLevelValueNames.contains(name)) {
throw ScriptError(pos, "symbol '$name' is not defined")
} }
} }
val ref = LocalSlotRef( val ref = LocalSlotRef(
@@ -1007,8 +1033,11 @@ class Compiler(
if (moduleEntry != null) { if (moduleEntry != null) {
val moduleDeclaredNames = localNamesStack.firstOrNull() val moduleDeclaredNames = localNamesStack.firstOrNull()
if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) { if (moduleDeclaredNames == null || !moduleDeclaredNames.contains(name)) {
resolveImportBinding(name, pos)?.let { resolved -> val resolvedImport = resolveImportBinding(name, pos)
registerImportBinding(name, resolved.binding, pos) if (resolvedImport != null) {
registerImportBinding(name, resolvedImport.binding, pos)
} else if (predeclaredTopLevelValueNames.contains(name)) {
throw ScriptError(pos, "symbol '$name' is not defined")
} }
} }
val moduleLoc = SlotLocation( val moduleLoc = SlotLocation(
@@ -1019,6 +1048,7 @@ class Compiler(
moduleEntry.isDelegated moduleEntry.isDelegated
) )
captureLocalRef(name, moduleLoc, pos)?.let { ref -> captureLocalRef(name, moduleLoc, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1045,6 +1075,7 @@ class Compiler(
strictSlotRefs strictSlotRefs
) )
} }
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1079,6 +1110,7 @@ class Compiler(
val slot = lookupSlotLocation(name) val slot = lookupSlotLocation(name)
if (slot != null) { if (slot != null) {
captureLocalRef(name, slot, pos)?.let { ref -> captureLocalRef(name, slot, pos)?.let { ref ->
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1105,6 +1137,7 @@ class Compiler(
strictSlotRefs strictSlotRefs
) )
} }
rememberModuleReferencePos(name, pos)
resolutionSink?.reference(name, pos) resolutionSink?.reference(name, pos)
return ref return ref
} }
@@ -1281,23 +1314,11 @@ class Compiler(
} }
} }
if (seedRecord != null) { if (seedRecord != null) {
val value = seedRecord.value seedImportTypeMetadata(name, seedRecord)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord) return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Seed), seedRecord)
} }
if (rootRecord != null) { if (rootRecord != null) {
val value = rootRecord.value seedImportTypeMetadata(name, rootRecord)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord) return ImportBindingResolution(ImportBinding(name, ImportBindingSource.Root), rootRecord)
} }
if (moduleMatches.isEmpty()) return null if (moduleMatches.isEmpty()) return null
@@ -1312,13 +1333,7 @@ class Compiler(
val candidates = byOrigin[origin] ?: mutableListOf() val candidates = byOrigin[origin] ?: mutableListOf()
val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first() val preferred = candidates.firstOrNull { it.first.scope.packageName == origin } ?: candidates.first()
val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos)) val binding = ImportBinding(name, ImportBindingSource.Module(origin, preferred.first.pos))
val value = preferred.second.value seedImportTypeMetadata(name, preferred.second)
if (!nameObjClass.containsKey(name)) {
when (value) {
is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass
}
}
return ImportBindingResolution(binding, preferred.second) return ImportBindingResolution(binding, preferred.second)
} }
val moduleNames = moduleMatches.keys.toList() val moduleNames = moduleMatches.keys.toList()
@@ -1326,14 +1341,24 @@ class Compiler(
} }
val (module, record) = moduleMatches.values.first() val (module, record) = moduleMatches.values.first()
val binding = ImportBinding(name, ImportBindingSource.Module(module.scope.packageName, module.pos)) val binding = ImportBinding(name, ImportBindingSource.Module(module.scope.packageName, module.pos))
val value = record.value seedImportTypeMetadata(name, record)
return ImportBindingResolution(binding, record)
}
private fun seedImportTypeMetadata(name: String, record: ObjRecord) {
if (record.typeDecl != null && nameTypeDecl[name] == null) {
nameTypeDecl[name] = record.typeDecl
}
if (!nameObjClass.containsKey(name)) { if (!nameObjClass.containsKey(name)) {
when (value) { record.typeDecl?.let { resolveTypeDeclObjClass(it) }?.let {
nameObjClass[name] = it
return
}
when (val value = record.value) {
is ObjClass -> nameObjClass[name] = value is ObjClass -> nameObjClass[name] = value
is ObjInstance -> nameObjClass[name] = value.objClass is ObjInstance -> nameObjClass[name] = value.objClass
} }
} }
return ImportBindingResolution(binding, record)
} }
private fun collectModuleRecordMatches( private fun collectModuleRecordMatches(
@@ -1756,6 +1781,8 @@ class Compiler(
callableReturnTypeByScopeId = callableReturnTypeByScopeId, callableReturnTypeByScopeId = callableReturnTypeByScopeId,
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) as BytecodeStatement ) as BytecodeStatement
unwrapped to bytecodeStmt.bytecodeFunction() unwrapped to bytecodeStmt.bytecodeFunction()
@@ -2084,6 +2111,8 @@ class Compiler(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2115,6 +2144,8 @@ class Compiler(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2171,6 +2202,8 @@ class Compiler(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = importBindings.keys,
scopeRefPosByName = moduleReferencePosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
} }
@@ -2915,9 +2948,9 @@ class Compiler(
operand?.let { left -> operand?.let { left ->
// array access via ObjRef // array access via ObjRef
val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX val isOptional = t.type == Token.Type.NULL_COALESCE_INDEX
val index = parseStatement() ?: throw ScriptError(t.pos, "Expecting index expression") val index = parseIndexExpression() ?: throw ScriptError(t.pos, "Expecting index expression")
cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal") cc.skipTokenOfType(Token.Type.RBRACKET, "missing ']' at the end of the list literal")
operand = IndexRef(left, StatementRef(index), isOptional) operand = IndexRef(left, index, isOptional)
} ?: run { } ?: run {
// array literal // array literal
val entries = parseArrayLiteral() val entries = parseArrayLiteral()
@@ -3412,6 +3445,20 @@ class Compiler(
} }
} }
private suspend fun parseIndexExpression(): ObjRef? {
val first = parseExpressionLevel() ?: return null
if (!cc.skipTokenOfType(Token.Type.COMMA, isOptional = true)) {
return first
}
val entries = mutableListOf<ListEntry>(ListEntry.Element(first))
do {
val next = parseExpressionLevel() ?: throw ScriptError(cc.currentPos(), "Expecting index expression")
entries += ListEntry.Element(next)
} while (cc.skipTokenOfType(Token.Type.COMMA, isOptional = true))
return ListLiteralRef(entries)
}
private suspend fun parseDestructuringPattern(): List<ListEntry> { private suspend fun parseDestructuringPattern(): List<ListEntry> {
// it should be called after Token.Type.LBRACKET is consumed // it should be called after Token.Type.LBRACKET is consumed
val entries = mutableListOf<ListEntry>() val entries = mutableListOf<ListEntry>()
@@ -4299,14 +4346,23 @@ class Compiler(
is MapLiteralRef -> inferMapLiteralTypeDecl(ref) is MapLiteralRef -> inferMapLiteralTypeDecl(ref)
is ConstRef -> inferTypeDeclFromConst(ref.constValue) is ConstRef -> inferTypeDeclFromConst(ref.constValue)
is CallRef -> { is CallRef -> {
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) } val targetDecl = resolveReceiverTypeDecl(ref.target) ?: seedTypeDeclFromRef(ref.target)
?: run {
val targetName = when (val target = ref.target) { val targetName = when (val target = ref.target) {
is LocalVarRef -> target.name is LocalVarRef -> target.name
is FastLocalVarRef -> target.name is FastLocalVarRef -> target.name
is LocalSlotRef -> target.name is LocalSlotRef -> target.name
else -> null else -> null
} }
if (targetDecl is TypeDecl.Function) {
return inferCallReturnTypeDecl(ref) ?: targetDecl.returnType
}
inferCallReturnTypeDecl(ref)?.let { return it }
if (targetName != null) {
callableReturnTypeDeclByName[targetName]?.let { return it }
(seedTypeDeclByName(targetName) as? TypeDecl.Function)?.let { return it.returnType }
}
inferCallReturnClass(ref)?.let { TypeDecl.Simple(it.className, false) }
?: run {
if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) { if (targetName != null && targetName.firstOrNull()?.isUpperCase() == true) {
TypeDecl.Simple(targetName, false) TypeDecl.Simple(targetName, false)
} else { } else {
@@ -4477,6 +4533,15 @@ class Compiler(
} }
} }
private fun inferForLoopElementType(source: Statement, constRange: ConstIntRange?): TypeDecl? {
if (constRange != null) return TypeDecl.Simple("Int", false)
val sourceType = inferTypeDeclFromInitializer(source) ?: return null
return when {
isRangeType(sourceType) -> TypeDecl.Simple("Int", false)
else -> inferCollectionElementType(expandTypeAliases(sourceType, source.pos))
}
}
private fun typeDeclSubtypeOf(arg: TypeDecl, param: TypeDecl): Boolean { private fun typeDeclSubtypeOf(arg: TypeDecl, param: TypeDecl): Boolean {
if (param == TypeDecl.TypeAny || param == TypeDecl.TypeNullableAny) return true if (param == TypeDecl.TypeAny || param == TypeDecl.TypeNullableAny) return true
val (argBase, argNullable) = stripNullable(arg) val (argBase, argNullable) = stripNullable(arg)
@@ -4637,6 +4702,17 @@ class Compiler(
return null return null
} }
private fun lookupLocalTypeDeclByName(name: String): TypeDecl? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
}
private fun lookupLocalObjClassByName(name: String): ObjClass? {
val slotLoc = lookupSlotLocation(name, includeModule = true) ?: return null
return slotTypeByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)
?: slotTypeDeclByScopeId[slotLoc.scopeId]?.get(slotLoc.slot)?.let { resolveTypeDeclObjClass(it) }
}
private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? { private fun resolveReceiverTypeDecl(ref: ObjRef): TypeDecl? {
return when (ref) { return when (ref) {
is LocalSlotRef -> { is LocalSlotRef -> {
@@ -4646,8 +4722,12 @@ class Compiler(
?: nameTypeDecl[ref.name] ?: nameTypeDecl[ref.name]
?: seedTypeDeclByName(ref.name) ?: seedTypeDeclByName(ref.name)
} }
is LocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name) is LocalVarRef -> nameTypeDecl[ref.name]
is FastLocalVarRef -> nameTypeDecl[ref.name] ?: seedTypeDeclByName(ref.name) ?: lookupLocalTypeDeclByName(ref.name)
?: seedTypeDeclByName(ref.name)
is FastLocalVarRef -> nameTypeDecl[ref.name]
?: lookupLocalTypeDeclByName(ref.name)
?: seedTypeDeclByName(ref.name)
is FieldRef -> { is FieldRef -> {
val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null val targetDecl = resolveReceiverTypeDecl(ref.target) ?: return null
val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target) val targetClass = resolveTypeDeclObjClass(targetDecl) ?: resolveReceiverClassForMember(ref.target)
@@ -4666,7 +4746,7 @@ class Compiler(
classMethodReturnTypeDecl(targetClass, "getAt") classMethodReturnTypeDecl(targetClass, "getAt")
} }
is MethodCallRef -> methodReturnTypeDeclByRef[ref] is MethodCallRef -> methodReturnTypeDeclByRef[ref]
is CallRef -> callReturnTypeDeclByRef[ref] is CallRef -> callReturnTypeDeclByRef[ref] ?: inferCallReturnTypeDecl(ref)
is BinaryOpRef -> inferBinaryOpReturnTypeDecl(ref) is BinaryOpRef -> inferBinaryOpReturnTypeDecl(ref)
is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) } is StatementRef -> (ref.statement as? ExpressionStatement)?.let { resolveReceiverTypeDecl(it.ref) }
else -> null else -> null
@@ -4693,11 +4773,13 @@ class Compiler(
is LocalVarRef -> nameObjClass[ref.name] is LocalVarRef -> nameObjClass[ref.name]
?.takeIf { it == ObjDynamic.type } ?.takeIf { it == ObjDynamic.type }
?: nameObjClass[ref.name] ?: nameObjClass[ref.name]
?: lookupLocalObjClassByName(ref.name)
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) } ?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: resolveClassByName(ref.name) ?: resolveClassByName(ref.name)
is FastLocalVarRef -> nameObjClass[ref.name] is FastLocalVarRef -> nameObjClass[ref.name]
?.takeIf { it == ObjDynamic.type } ?.takeIf { it == ObjDynamic.type }
?: nameObjClass[ref.name] ?: nameObjClass[ref.name]
?: lookupLocalObjClassByName(ref.name)
?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) } ?: nameTypeDecl[ref.name]?.let { resolveTypeDeclObjClass(it) }
?: resolveClassByName(ref.name) ?: resolveClassByName(ref.name)
is ClassScopeMemberRef -> { is ClassScopeMemberRef -> {
@@ -4730,7 +4812,7 @@ class Compiler(
is ImplicitThisMethodCallRef -> inferMethodCallReturnClass(ref.methodName()) is ImplicitThisMethodCallRef -> inferMethodCallReturnClass(ref.methodName())
is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName()) is ThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName()) is QualifiedThisMethodSlotCallRef -> inferMethodCallReturnClass(ref.methodName())
is CallRef -> inferCallReturnClass(ref) is CallRef -> inferCallReturnTypeDecl(ref)?.let { resolveTypeDeclObjClass(it) } ?: inferCallReturnClass(ref)
is BinaryOpRef -> inferBinaryOpReturnClass(ref) is BinaryOpRef -> inferBinaryOpReturnClass(ref)
is FieldRef -> { is FieldRef -> {
val targetClass = resolveReceiverClassForMember(ref.target) val targetClass = resolveReceiverClassForMember(ref.target)
@@ -4862,12 +4944,33 @@ class Compiler(
private fun inferCallReturnClass(ref: CallRef): ObjClass? { private fun inferCallReturnClass(ref: CallRef): ObjClass? {
return when (val target = ref.target) { return when (val target = ref.target) {
is LocalSlotRef -> callableReturnTypeByScopeId[target.scopeId]?.get(target.slot) is LocalSlotRef -> when (target.name) {
"lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator
"flow" -> ObjFlow.type
"launch" -> ObjDeferred.type
"dynamic" -> ObjDynamic.type
else -> callableReturnTypeByScopeId[target.scopeId]?.get(target.slot)
?: resolveClassByName(target.name) ?: resolveClassByName(target.name)
is LocalVarRef -> callableReturnTypeByName[target.name] }
is LocalVarRef -> when (target.name) {
"lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator
"flow" -> ObjFlow.type
"launch" -> ObjDeferred.type
"dynamic" -> ObjDynamic.type
else -> callableReturnTypeByName[target.name]
?: resolveClassByName(target.name) ?: resolveClassByName(target.name)
is FastLocalVarRef -> callableReturnTypeByName[target.name] }
is FastLocalVarRef -> when (target.name) {
"lazy" -> resolveClassByName("lazy")
"iterator" -> ObjIterator
"flow" -> ObjFlow.type
"launch" -> ObjDeferred.type
"dynamic" -> ObjDynamic.type
else -> callableReturnTypeByName[target.name]
?: resolveClassByName(target.name) ?: resolveClassByName(target.name)
}
is ConstRef -> when (val value = target.constValue) { is ConstRef -> when (val value = target.constValue) {
is ObjClass -> value is ObjClass -> value
is ObjString -> ObjString.type is ObjString -> ObjString.type
@@ -5376,12 +5479,45 @@ class Compiler(
args: List<ParsedArgument>, args: List<ParsedArgument>,
pos: Pos pos: Pos
) { ) {
lookupNamedFunctionDecl(target)?.let { decl ->
val hasComplexArgs = args.any { it.name != null } ||
decl.typeParams.isNotEmpty() ||
decl.params.any { it.defaultValue != null || it.isEllipsis }
if (hasComplexArgs) return
if (args.any { it.isSplat }) return
val actual = args.size
val params = decl.params
val ellipsisIndex = params.indexOfFirst { it.isEllipsis }
if (ellipsisIndex < 0) {
val minArgs = params.count { it.defaultValue == null }
val maxArgs = params.size
if (actual < minArgs || actual > maxArgs) {
val message = if (minArgs == maxArgs) {
"expected $maxArgs arguments, got $actual"
} else {
"expected $minArgs..$maxArgs arguments, got $actual"
}
throw ScriptError(pos, message)
}
return
}
val headRequired = (0 until ellipsisIndex).count { params[it].defaultValue == null }
val tailRequired = (ellipsisIndex + 1 until params.size).count { params[it].defaultValue == null }
val minArgs = headRequired + tailRequired
if (actual < minArgs) {
throw ScriptError(pos, "expected at least $minArgs arguments, got $actual")
}
return
}
val seededCallable = lookupNamedCallableRecord(target)
if (seededCallable != null && seededCallable.type == ObjRecord.Type.Fun && seededCallable.value !is ObjExternCallable) {
return
}
val decl = (resolveReceiverTypeDecl(target) as? TypeDecl.Function) val decl = (resolveReceiverTypeDecl(target) as? TypeDecl.Function)
?: seedTypeDeclFromRef(target) as? TypeDecl.Function ?: seedTypeDeclFromRef(target) as? TypeDecl.Function
?: return ?: return
if (args.any { it.isSplat }) return if (args.any { it.isSplat }) return
val actual = args.size val actual = args.size
val receiverCount = if (decl.receiver != null) 1 else 0
val paramList = mutableListOf<TypeDecl>() val paramList = mutableListOf<TypeDecl>()
decl.receiver?.let { paramList += it } decl.receiver?.let { paramList += it }
paramList += decl.params paramList += decl.params
@@ -5410,6 +5546,91 @@ class Compiler(
} ?: return null } ?: return null
seedScope?.getLocalRecordDirect(name)?.typeDecl?.let { return it } seedScope?.getLocalRecordDirect(name)?.typeDecl?.let { return it }
return seedScope?.get(name)?.typeDecl return seedScope?.get(name)?.typeDecl
?: importManager.rootScope.getLocalRecordDirect(name)?.typeDecl
?: importManager.rootScope.get(name)?.typeDecl
}
private fun lookupNamedFunctionDecl(target: ObjRef): GenericFunctionDecl? {
val name = when (target) {
is LocalVarRef -> target.name
is LocalSlotRef -> target.name
is FastLocalVarRef -> target.name
else -> null
} ?: return null
return lookupGenericFunctionDecl(name)
}
private fun lookupNamedCallableRecord(target: ObjRef): ObjRecord? {
val name = when (target) {
is LocalVarRef -> target.name
is LocalSlotRef -> target.name
is FastLocalVarRef -> target.name
else -> null
} ?: return null
findSeedScopeRecord(name)?.let { return it }
importManager.rootScope.getLocalRecordDirect(name)?.let { return it }
importManager.rootScope.get(name)?.let { return it }
for (module in importedModules.asReversed()) {
module.scope.get(name)?.let { return it }
}
return null
}
private fun inferCallReturnTypeDecl(ref: CallRef): TypeDecl? {
callReturnTypeDeclByRef[ref]?.let { return it }
val targetDecl = (resolveReceiverTypeDecl(ref.target) ?: seedTypeDeclFromRef(ref.target)) as? TypeDecl.Function
?: return null
val bindings = mutableMapOf<String, TypeDecl>()
val paramList = mutableListOf<TypeDecl>()
targetDecl.receiver?.let { paramList += it }
paramList += targetDecl.params
fun argTypeDecl(arg: ParsedArgument): TypeDecl? {
val stmt = arg.value as? ExpressionStatement ?: return null
val directRef = stmt.ref
return inferTypeDeclFromRef(directRef)
?: inferObjClassFromRef(directRef)?.let { TypeDecl.Simple(it.className, false) }
}
val ellipsisIndex = paramList.indexOfFirst { it is TypeDecl.Ellipsis }
if (ellipsisIndex < 0) {
val limit = minOf(paramList.size, ref.args.size)
for (i in 0 until limit) {
val argType = argTypeDecl(ref.args[i]) ?: continue
collectTypeVarBindings(paramList[i], argType, bindings)
}
} else {
val headCount = ellipsisIndex
val tailCount = paramList.size - ellipsisIndex - 1
val argCount = ref.args.size
val headLimit = minOf(headCount, argCount)
for (i in 0 until headLimit) {
val argType = argTypeDecl(ref.args[i]) ?: continue
collectTypeVarBindings(paramList[i], argType, bindings)
}
val tailStartArg = maxOf(headCount, argCount - tailCount)
for (i in tailStartArg until argCount) {
val paramIndex = paramList.size - (argCount - i)
val argType = argTypeDecl(ref.args[i]) ?: continue
collectTypeVarBindings(paramList[paramIndex], argType, bindings)
}
val ellipsisArgEnd = argCount - tailCount
val ellipsisType = paramList[ellipsisIndex] as TypeDecl.Ellipsis
for (i in headCount until ellipsisArgEnd) {
val argType = if (ref.args[i].isSplat) {
val stmt = ref.args[i].value as? ExpressionStatement
stmt?.ref?.let { inferElementTypeFromSpread(it) }
} else {
argTypeDecl(ref.args[i])
} ?: continue
collectTypeVarBindings(ellipsisType.elementType, argType, bindings)
}
}
val inferred = if (bindings.isEmpty()) targetDecl.returnType
else substituteTypeAliasTypeVars(targetDecl.returnType, bindings)
callReturnTypeDeclByRef[ref] = inferred
return inferred
} }
private fun checkFunctionTypeCallTypes( private fun checkFunctionTypeCallTypes(
@@ -5417,6 +5638,102 @@ class Compiler(
args: List<ParsedArgument>, args: List<ParsedArgument>,
pos: Pos pos: Pos
) { ) {
lookupNamedFunctionDecl(target)?.let { decl ->
val hasComplexArgs = args.any { it.name != null } ||
decl.typeParams.isNotEmpty() ||
decl.params.any { it.defaultValue != null || it.isEllipsis }
if (hasComplexArgs) return
val paramList = decl.params.map { if (it.isEllipsis) TypeDecl.Ellipsis(it.type) else it.type }
if (paramList.isEmpty()) return
val ellipsisIndex = decl.params.indexOfFirst { it.isEllipsis }
fun argTypeDecl(arg: ParsedArgument): TypeDecl? {
val stmt = arg.value as? ExpressionStatement ?: return null
val ref = stmt.ref
return inferTypeDeclFromRef(ref)
?: inferObjClassFromRef(ref)?.let { TypeDecl.Simple(it.className, false) }
}
fun typeDeclSubtypeOf(arg: TypeDecl, param: TypeDecl): Boolean {
if (param == TypeDecl.TypeAny || param == TypeDecl.TypeNullableAny) return true
val (argBase, argNullable) = stripNullable(arg)
val (paramBase, paramNullable) = stripNullable(param)
if (argNullable && !paramNullable) return false
if (paramBase == TypeDecl.TypeAny) return true
if (paramBase is TypeDecl.TypeVar) return true
if (argBase is TypeDecl.TypeVar) return true
if (paramBase is TypeDecl.Simple && (paramBase.name == "Object" || paramBase.name == "Obj")) return true
if (argBase is TypeDecl.Ellipsis) return typeDeclSubtypeOf(argBase.elementType, paramBase)
if (paramBase is TypeDecl.Ellipsis) return typeDeclSubtypeOf(argBase, paramBase.elementType)
return when (argBase) {
is TypeDecl.Union -> argBase.options.all { typeDeclSubtypeOf(it, paramBase) }
is TypeDecl.Intersection -> argBase.options.any { typeDeclSubtypeOf(it, paramBase) }
else -> when (paramBase) {
is TypeDecl.Union -> paramBase.options.any { typeDeclSubtypeOf(argBase, it) }
is TypeDecl.Intersection -> paramBase.options.all { typeDeclSubtypeOf(argBase, it) }
else -> {
val argClass = resolveTypeDeclObjClass(argBase) ?: return false
val paramClass = resolveTypeDeclObjClass(paramBase) ?: return false
argClass == paramClass || argClass.allParentsSet.contains(paramClass)
}
}
}
}
fun fail(argPos: Pos, expected: TypeDecl, got: TypeDecl) {
throw ScriptError(argPos, "argument type ${typeDeclName(got)} does not match ${typeDeclName(expected)}")
}
if (ellipsisIndex < 0) {
val limit = minOf(paramList.size, args.size)
for (i in 0 until limit) {
val arg = args[i]
val argType = argTypeDecl(arg) ?: continue
val paramType = paramList[i]
if (!typeDeclSubtypeOf(argType, paramType)) {
fail(arg.pos, paramType, argType)
}
}
return
}
val headCount = ellipsisIndex
val tailCount = paramList.size - ellipsisIndex - 1
val ellipsisType = paramList[ellipsisIndex] as TypeDecl.Ellipsis
val argCount = args.size
val headLimit = minOf(headCount, argCount)
for (i in 0 until headLimit) {
val arg = args[i]
val argType = argTypeDecl(arg) ?: continue
val paramType = paramList[i]
if (!typeDeclSubtypeOf(argType, paramType)) {
fail(arg.pos, paramType, argType)
}
}
val tailStartArg = maxOf(headCount, argCount - tailCount)
for (i in tailStartArg until argCount) {
val arg = args[i]
val paramType = paramList[paramList.size - (argCount - i)]
val argType = argTypeDecl(arg) ?: continue
if (!typeDeclSubtypeOf(argType, paramType)) {
fail(arg.pos, paramType, argType)
}
}
val ellipsisArgEnd = argCount - tailCount
for (i in headCount until ellipsisArgEnd) {
val arg = args[i]
val argType = if (arg.isSplat) {
val stmt = arg.value as? ExpressionStatement
val ref = stmt?.ref
ref?.let { inferElementTypeFromSpread(it) }
} else {
argTypeDecl(arg)
} ?: continue
if (!typeDeclSubtypeOf(argType, ellipsisType.elementType)) {
fail(arg.pos, ellipsisType.elementType, argType)
}
}
return
}
val seededCallable = lookupNamedCallableRecord(target)
if (seededCallable != null && seededCallable.type == ObjRecord.Type.Fun && seededCallable.value !is ObjExternCallable) {
return
}
val decl = (resolveReceiverTypeDecl(target) as? TypeDecl.Function) val decl = (resolveReceiverTypeDecl(target) as? TypeDecl.Function)
?: seedTypeDeclFromRef(target) as? TypeDecl.Function ?: seedTypeDeclFromRef(target) as? TypeDecl.Function
?: return ?: return
@@ -7418,6 +7735,20 @@ class Compiler(
val loopSlotPlan = SlotPlan(mutableMapOf(), 0, nextScopeId++) val loopSlotPlan = SlotPlan(mutableMapOf(), 0, nextScopeId++)
slotPlanStack.add(loopSlotPlan) slotPlanStack.add(loopSlotPlan)
declareSlotName(tVar.value, isMutable = true, isDelegated = false) declareSlotName(tVar.value, isMutable = true, isDelegated = false)
val loopSlotIndex = loopSlotPlan.slots[tVar.value]?.index
val loopVarTypeDecl = inferForLoopElementType(source, constRange)
val hadLoopNameType = nameTypeDecl.containsKey(tVar.value)
val prevLoopNameType = nameTypeDecl[tVar.value]
val hadLoopNameClass = nameObjClass.containsKey(tVar.value)
val prevLoopNameClass = nameObjClass[tVar.value]
if (loopSlotIndex != null && loopVarTypeDecl != null) {
slotTypeDeclByScopeId.getOrPut(loopSlotPlan.id) { mutableMapOf() }[loopSlotIndex] = loopVarTypeDecl
nameTypeDecl[tVar.value] = loopVarTypeDecl
resolveTypeDeclObjClass(loopVarTypeDecl)?.let { loopVarClass ->
slotTypeByScopeId.getOrPut(loopSlotPlan.id) { mutableMapOf() }[loopSlotIndex] = loopVarClass
nameObjClass[tVar.value] = loopVarClass
}
}
val (canBreak, body, elseStatement) = try { val (canBreak, body, elseStatement) = try {
resolutionSink?.enterScope(ScopeKind.BLOCK, tVar.pos, null) resolutionSink?.enterScope(ScopeKind.BLOCK, tVar.pos, null)
resolutionSink?.declareSymbol(tVar.value, SymbolKind.LOCAL, isMutable = true, pos = tVar.pos) resolutionSink?.declareSymbol(tVar.value, SymbolKind.LOCAL, isMutable = true, pos = tVar.pos)
@@ -7437,6 +7768,16 @@ class Compiler(
Triple(loopParsed.first, loopParsed.second, elseStmt) Triple(loopParsed.first, loopParsed.second, elseStmt)
} }
} finally { } finally {
if (hadLoopNameType) {
nameTypeDecl[tVar.value] = prevLoopNameType!!
} else {
nameTypeDecl.remove(tVar.value)
}
if (hadLoopNameClass) {
nameObjClass[tVar.value] = prevLoopNameClass!!
} else {
nameObjClass.remove(tVar.value)
}
resolutionSink?.exitScope(cc.currentPos()) resolutionSink?.exitScope(cc.currentPos())
slotPlanStack.removeLast() slotPlanStack.removeLast()
} }
@@ -7948,7 +8289,7 @@ class Compiler(
parseArgsDeclaration() ?: ArgsDeclaration(emptyList(), Token.Type.RPAREN) parseArgsDeclaration() ?: ArgsDeclaration(emptyList(), Token.Type.RPAREN)
} else ArgsDeclaration(emptyList(), Token.Type.RPAREN) } else ArgsDeclaration(emptyList(), Token.Type.RPAREN)
if (mergedTypeParamDecls.isNotEmpty() && declKind != SymbolKind.MEMBER) { if (declKind != SymbolKind.MEMBER) {
currentGenericFunctionDecls()[name] = GenericFunctionDecl(mergedTypeParamDecls, argsDeclaration.params, nameStartPos) currentGenericFunctionDecls()[name] = GenericFunctionDecl(mergedTypeParamDecls, argsDeclaration.params, nameStartPos)
} }
@@ -7971,6 +8312,9 @@ class Compiler(
if (compileBytecode) { if (compileBytecode) {
delegateExpression = wrapFunctionBytecode(delegateExpression, "delegate@$name") delegateExpression = wrapFunctionBytecode(delegateExpression, "delegate@$name")
} }
if (declKind != SymbolKind.MEMBER) {
currentGenericFunctionDecls().remove(name)
}
} }
if (isDelegated && declKind != SymbolKind.MEMBER) { if (isDelegated && declKind != SymbolKind.MEMBER) {
val plan = slotPlanStack.lastOrNull() val plan = slotPlanStack.lastOrNull()
@@ -8143,6 +8487,10 @@ class Compiler(
inferredReturnClass inferredReturnClass
} }
} }
val inferredReturnDecl = returnTypeDecl ?: inferredReturnClass?.let { TypeDecl.Simple(it.className, false) }
if (declKind != SymbolKind.MEMBER && inferredReturnDecl != null) {
callableReturnTypeDeclByName[name] = inferredReturnDecl
}
val fnStatements = rawFnStatements?.let { stmt -> val fnStatements = rawFnStatements?.let { stmt ->
if (!compileBytecode) return@let stmt if (!compileBytecode) return@let stmt
val paramKnownClasses = mutableMapOf<String, ObjClass>() val paramKnownClasses = mutableMapOf<String, ObjClass>()
@@ -8253,7 +8601,7 @@ class Compiler(
?: context.parent?.get(localName) ?: context.parent?.get(localName)
?: context.get(localName) ?: context.get(localName)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is ObjProperty) {
context.resolve(record, localName) context.resolve(record, localName)
} else { } else {
record.value record.value
@@ -8311,6 +8659,12 @@ class Compiler(
parentIsClassBody = parentIsClassBody, parentIsClassBody = parentIsClassBody,
externCallSignature = externCallSignature, externCallSignature = externCallSignature,
annotation = annotation, annotation = annotation,
typeDecl = if (isDelegated) null else TypeDecl.Function(
receiver = receiverTypeDecl,
params = argsDeclaration.params.map { it.type },
returnType = inferredReturnDecl ?: TypeDecl.TypeAny,
nullable = false
),
fnBody = fnBody, fnBody = fnBody,
closureBox = closureBox, closureBox = closureBox,
captureSlots = captureSlots, captureSlots = captureSlots,
@@ -9012,7 +9366,10 @@ class Compiler(
val effectiveEqToken = if (isProperty) null else eqToken val effectiveEqToken = if (isProperty) null else eqToken
// Register the local name at compile time so that subsequent identifiers can be emitted as fast locals // Register the local name at compile time so that subsequent identifiers can be emitted as fast locals
if (!isStatic && declaringClassNameCaptured == null && !actualExtern) declareLocalName(name, isMutable) val isTopLevelExtern = actualExtern && declaringClassNameCaptured == null && slotPlanStack.size == 1
if (!isStatic && declaringClassNameCaptured == null && (!actualExtern || isTopLevelExtern)) {
declareLocalName(name, isMutable)
}
val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) { val declKind = if (codeContexts.lastOrNull() is CodeContext.ClassBody) {
SymbolKind.MEMBER SymbolKind.MEMBER
} else { } else {
@@ -9085,7 +9442,6 @@ class Compiler(
varTypeDecl = inferred varTypeDecl = inferred
} }
} }
if (isDelegate && initialExpression != null) { if (isDelegate && initialExpression != null) {
ensureDelegateType(initialExpression) ensureDelegateType(initialExpression)
val lazyClass = resolveClassByName("lazy") val lazyClass = resolveClassByName("lazy")
@@ -0,0 +1,129 @@
/*
* 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.*
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.update
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import net.sergeych.lyng.obj.Obj
import kotlin.coroutines.AbstractCoroutineContextElement
import kotlin.coroutines.CoroutineContext
/**
* Host-managed lifetime owner for coroutines started from Lyng scripts.
*
* The session reuses a single [Scope] across eval calls and tracks async work launched by
* `launch { ... }` and active flow producers created from these evals.
*/
class EvalSession(initialScope: Scope? = null) {
private val ownerJob = SupervisorJob()
private val evalMutex = Mutex()
private val scopeMutex = Mutex()
private val activeJobs = MutableStateFlow(0)
private var _scope: Scope? = initialScope
val scope: Scope? get() = _scope
val isActive: Boolean get() = ownerJob.isActive
val isCancelled: Boolean get() = ownerJob.isCancelled
suspend fun getScope(): Scope = ensureScope()
suspend fun eval(code: String): Obj = eval(code.toSource())
suspend fun eval(source: Source): Obj = evalMutex.withLock {
throwIfCancelled()
val scope = ensureScope()
withEvalSession(this@EvalSession) {
scope.eval(source)
}
}
fun cancel(cause: String? = null) {
ownerJob.cancel(ScriptSessionCancelled(cause ?: "EvalSession cancelled"))
}
suspend fun join() {
activeJobs.filter { it == 0 }.first()
}
suspend fun cancelAndJoin() {
cancel()
join()
}
internal suspend fun <T> launchTrackedDeferred(block: suspend CoroutineScope.() -> T): Deferred<T> {
throwIfCancelled()
val deferred = CoroutineScope(currentTrackedCoroutineContext()).async(block = block)
track(deferred)
return deferred
}
internal suspend fun launchTrackedJob(block: suspend CoroutineScope.() -> Unit): Job {
throwIfCancelled()
val job = CoroutineScope(currentTrackedCoroutineContext()).launch(block = block)
track(job)
return job
}
private suspend fun currentTrackedCoroutineContext(): CoroutineContext {
val base = currentCoroutineContext()
return base.minusKey(Job) + ownerJob + EvalSessionElement(this)
}
private suspend fun ensureScope(): Scope {
_scope?.let { return it }
return scopeMutex.withLock {
_scope ?: Script.newScope().also { _scope = it }
}
}
private fun track(job: Job) {
activeJobs.update { it + 1 }
job.invokeOnCompletion {
activeJobs.update { count -> if (count > 0) count - 1 else 0 }
}
}
internal fun throwIfCancelled() {
if (ownerJob.isCancelled) {
throw ScriptSessionCancelled("EvalSession cancelled")
}
}
companion object {
suspend fun currentOrNull(): EvalSession? = currentCoroutineContext()[EvalSessionElement]?.session
}
}
internal class EvalSessionElement(val session: EvalSession) :
AbstractCoroutineContextElement(EvalSessionElement) {
companion object Key : CoroutineContext.Key<EvalSessionElement>
}
internal suspend fun <T> withEvalSession(session: EvalSession, block: suspend () -> T): T {
return kotlinx.coroutines.withContext(EvalSessionElement(session)) {
block()
}
}
class ScriptSessionCancelled(message: String) : CancellationException(message)
@@ -167,6 +167,19 @@ class RecordSlotRef(
} }
} }
suspend fun read(scope: Scope, name: String?): Obj {
val direct = record.value
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
return scope.resolve(record, name)
}
return when (direct) {
is FrameSlotRef -> direct.read()
is RecordSlotRef -> direct.read(scope, name)
is ScopeSlotRef -> direct.read()
else -> direct
}
}
override suspend fun callOn(scope: Scope): Obj { override suspend fun callOn(scope: Scope): Obj {
val resolved = read() val resolved = read()
if (resolved === this) { if (resolved === this) {
@@ -193,4 +206,18 @@ class RecordSlotRef(
record.value = value record.value = value
} }
} }
suspend fun write(scope: Scope, name: String?, value: Obj): Boolean {
val direct = record.value
if (name != null && (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || direct is ObjProperty)) {
scope.assign(record, name, value)
return true
}
when (direct) {
is ScopeSlotRef -> direct.write(value)
is RecordSlotRef -> if (direct.write(scope, name, value)) return true else direct.write(value)
else -> record.value = value
}
return false
}
} }
@@ -1,5 +1,5 @@
/* /*
* Copyright 2026 Sergey S. Chernov * Copyright 2026 Sergey S. Chernov real.sergeych@gmail.com
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@@ -12,19 +12,12 @@
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and * See the License for the specific language governing permissions and
* limitations under the License. * limitations under the License.
*
*/ */
package net.sergeych.lyng package net.sergeych.lyng
import net.sergeych.lyng.obj.Obj import net.sergeych.lyng.obj.*
import net.sergeych.lyng.obj.ObjClass
import net.sergeych.lyng.obj.ObjExternCallable
import net.sergeych.lyng.obj.ObjExtensionMethodCallable
import net.sergeych.lyng.obj.ObjInstance
import net.sergeych.lyng.obj.ObjRecord
import net.sergeych.lyng.obj.ObjString
import net.sergeych.lyng.obj.ObjUnset
import net.sergeych.lyng.obj.ObjVoid
class FunctionClosureBox( class FunctionClosureBox(
var closure: Scope? = null, var closure: Scope? = null,
@@ -50,6 +43,7 @@ data class FunctionDeclSpec(
val parentIsClassBody: Boolean, val parentIsClassBody: Boolean,
val externCallSignature: CallSignature?, val externCallSignature: CallSignature?,
val annotation: (suspend (Scope, ObjString, Statement) -> Statement)?, val annotation: (suspend (Scope, ObjString, Statement) -> Statement)?,
val typeDecl: TypeDecl?,
val fnBody: Statement, val fnBody: Statement,
val closureBox: FunctionClosureBox, val closureBox: FunctionClosureBox,
val captureSlots: List<CaptureSlot>, val captureSlots: List<CaptureSlot>,
@@ -73,7 +67,8 @@ internal suspend fun executeFunctionDecl(
false, false,
value, value,
spec.visibility, spec.visibility,
callSignature = existing.callSignature callSignature = existing.callSignature,
typeDecl = spec.typeDecl
) )
return value return value
} }
@@ -182,12 +177,20 @@ internal suspend fun executeFunctionDecl(
isMutable = false, isMutable = false,
visibility = spec.visibility, visibility = spec.visibility,
declaringClass = null, declaringClass = null,
type = ObjRecord.Type.Fun type = ObjRecord.Type.Fun,
typeDecl = spec.typeDecl
) )
) )
val wrapperName = spec.extensionWrapperName ?: extensionCallableName(typeName, spec.name) val wrapperName = spec.extensionWrapperName ?: extensionCallableName(typeName, spec.name)
val wrapper = ObjExtensionMethodCallable(spec.name, compiledFnBody) val wrapper = ObjExtensionMethodCallable(spec.name, compiledFnBody)
scope.addItem(wrapperName, false, wrapper, spec.visibility, recordType = ObjRecord.Type.Fun) scope.addItem(
wrapperName,
false,
wrapper,
spec.visibility,
recordType = ObjRecord.Type.Fun,
typeDecl = spec.typeDecl
)
} ?: run { } ?: run {
val th = scope.thisObj val th = scope.thisObj
if (!spec.isStatic && th is ObjClass) { if (!spec.isStatic && th is ObjClass) {
@@ -203,10 +206,18 @@ internal suspend fun executeFunctionDecl(
isClosed = spec.isClosed, isClosed = spec.isClosed,
isOverride = spec.isOverride, isOverride = spec.isOverride,
type = ObjRecord.Type.Fun, type = ObjRecord.Type.Fun,
methodId = spec.memberMethodId methodId = spec.memberMethodId,
typeDecl = spec.typeDecl
) )
val memberValue = cls.members[spec.name]?.value ?: compiledFnBody val memberValue = cls.members[spec.name]?.value ?: compiledFnBody
scope.addItem(spec.name, false, memberValue, spec.visibility, callSignature = spec.externCallSignature) scope.addItem(
spec.name,
false,
memberValue,
spec.visibility,
callSignature = spec.externCallSignature,
typeDecl = spec.typeDecl
)
compiledFnBody compiledFnBody
} else { } else {
scope.addItem( scope.addItem(
@@ -215,7 +226,8 @@ internal suspend fun executeFunctionDecl(
compiledFnBody, compiledFnBody,
spec.visibility, spec.visibility,
recordType = ObjRecord.Type.Fun, recordType = ObjRecord.Type.Fun,
callSignature = spec.externCallSignature callSignature = spec.externCallSignature,
typeDecl = spec.typeDecl
) )
} }
} }
@@ -732,7 +732,8 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
} }
val expanded = mutableListOf<Token>() val expanded = mutableListOf<Token>()
expanded += Token("(", tokenPos, Token.Type.LPAREN) expanded += Token("(", tokenPos, Token.Type.LPAREN)
var emittedPieces = 0 expanded += Token("", tokenPos, Token.Type.STRING)
var emittedPieces = 1
for (chunk in chunks) { for (chunk in chunks) {
val pieceTokens = when (chunk) { val pieceTokens = when (chunk) {
is StringChunk.Literal -> { is StringChunk.Literal -> {
@@ -755,9 +756,6 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
expanded += pieceTokens expanded += pieceTokens
emittedPieces++ emittedPieces++
} }
if (emittedPieces == 0) {
expanded += Token("", tokenPos, Token.Type.STRING)
}
expanded += Token(")", tokenPos, Token.Type.RPAREN) expanded += Token(")", tokenPos, Token.Type.RPAREN)
val first = expanded.first() val first = expanded.first()
@@ -766,10 +764,21 @@ private class Parser(fromPos: Pos, private val interpolationEnabled: Boolean = t
} }
private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> { private fun parseEmbeddedExpressionTokens(text: String, exprPos: Pos): List<Token> {
val tokens = parseLyng(Source(exprPos.source.fileName, text), interpolationEnabled) val tokens = try {
parseLyng(Source(exprPos.source.fileName, text), interpolationEnabled)
} catch (e: ScriptError) {
throw ScriptError(remapEmbeddedPos(exprPos, e.pos), e.errorMessage, e)
}
if (tokens.isEmpty()) return emptyList() if (tokens.isEmpty()) return emptyList()
val withoutEof = if (tokens.last().type == Token.Type.EOF) tokens.dropLast(1) else tokens val withoutEof = if (tokens.last().type == Token.Type.EOF) tokens.dropLast(1) else tokens
return withoutEof return withoutEof.map { it.copy(pos = remapEmbeddedPos(exprPos, it.pos)) }
}
private fun remapEmbeddedPos(exprPos: Pos, embeddedPos: Pos): Pos {
if (embeddedPos.line < 0 || embeddedPos.column < 0) return exprPos
val line = exprPos.line + embeddedPos.line
val column = if (embeddedPos.line == 0) exprPos.column + embeddedPos.column else embeddedPos.column
return Pos(exprPos.source, line, column)
} }
private fun readInterpolationExprText(start: Pos): String { private fun readInterpolationExprText(start: Pos): String {
@@ -17,6 +17,7 @@
package net.sergeych.lyng package net.sergeych.lyng
import com.ionspin.kotlin.bignum.decimal.BigDecimal
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
/** /**
@@ -133,3 +134,6 @@ fun ScopeFacade.raiseIllegalOperation(message: String = "Operation is illegal"):
fun ScopeFacade.raiseIterationFinished(): Nothing = fun ScopeFacade.raiseIterationFinished(): Nothing =
raiseError(ObjIterationFinishedException(requireScope())) raiseError(ObjIterationFinishedException(requireScope()))
suspend fun ScopeFacade.newDecimal(value: BigDecimal): ObjInstance =
ObjDecimalSupport.newDecimal(this, value)
@@ -27,7 +27,9 @@ import net.sergeych.lyng.bytecode.CmdVm
import net.sergeych.lyng.miniast.* import net.sergeych.lyng.miniast.*
import net.sergeych.lyng.obj.* import net.sergeych.lyng.obj.*
import net.sergeych.lyng.pacman.ImportManager import net.sergeych.lyng.pacman.ImportManager
import net.sergeych.lyng.stdlib_included.complexLyng
import net.sergeych.lyng.stdlib_included.decimalLyng import net.sergeych.lyng.stdlib_included.decimalLyng
import net.sergeych.lyng.stdlib_included.matrixLyng
import net.sergeych.lyng.stdlib_included.observableLyng import net.sergeych.lyng.stdlib_included.observableLyng
import net.sergeych.lyng.stdlib_included.operatorsLyng import net.sergeych.lyng.stdlib_included.operatorsLyng
import net.sergeych.lyng.stdlib_included.rootLyng import net.sergeych.lyng.stdlib_included.rootLyng
@@ -250,6 +252,44 @@ class Script(
companion object { companion object {
private suspend fun ScopeFacade.numberToDouble(value: Obj): Double =
ObjDecimalSupport.toDoubleOrNull(value) ?: value.toDouble()
private suspend fun ScopeFacade.decimalAwareUnaryMath(
value: Obj,
exactDecimal: (suspend ScopeFacade.(Obj) -> Obj?)? = null,
fallback: (Double) -> Double
): Obj {
exactDecimal?.let { exact ->
exact(value)?.let { return it }
}
if (ObjDecimalSupport.isDecimalValue(value)) {
return ObjDecimalSupport.fromRealLike(this, value, fallback(numberToDouble(value)))
?: raiseIllegalState("failed to convert Real result back to Decimal")
}
return ObjReal(fallback(numberToDouble(value)))
}
private suspend fun ScopeFacade.decimalAwareRoundLike(
value: Obj,
exactDecimal: suspend ScopeFacade.(Obj) -> Obj?,
realFallback: (Double) -> Double
): Obj {
if (value is ObjInt) return value
exactDecimal(value)?.let { return it }
return ObjReal(realFallback(numberToDouble(value)))
}
private suspend fun ScopeFacade.decimalAwarePow(base: Obj, exponent: Obj): Obj {
ObjDecimalSupport.exactPow(this, base, exponent)?.let { return it }
if (ObjDecimalSupport.isDecimalValue(base) || ObjDecimalSupport.isDecimalValue(exponent)) {
return ObjDecimalSupport.fromRealLike(this, base, numberToDouble(base).pow(numberToDouble(exponent)))
?: ObjDecimalSupport.fromRealLike(this, exponent, numberToDouble(base).pow(numberToDouble(exponent)))
?: raiseIllegalState("failed to convert Real pow result back to Decimal")
}
return ObjReal(numberToDouble(base).pow(numberToDouble(exponent)))
}
/** /**
* Create new scope using a standard safe set of modules, using [defaultImportManager]. It is * Create new scope using a standard safe set of modules, using [defaultImportManager]. It is
* suspended as first time invocation requires compilation of standard library or other * suspended as first time invocation requires compilation of standard library or other
@@ -287,87 +327,92 @@ class Script(
} }
addFn("floor") { addFn("floor") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
else ObjReal(floor(x.toDouble())))
} }
addFn("ceil") { addFn("ceil") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
else ObjReal(ceil(x.toDouble())))
} }
addFn("round") { addFn("round") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
(if (x is ObjInt) x decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
else ObjReal(round(x.toDouble())))
} }
addFn("sin") { addFn("sin") {
ObjReal(sin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
} }
addFn("cos") { addFn("cos") {
ObjReal(cos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
} }
addFn("tan") { addFn("tan") {
ObjReal(tan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
} }
addFn("asin") { addFn("asin") {
ObjReal(asin(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
} }
addFn("acos") { addFn("acos") {
ObjReal(acos(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
} }
addFn("atan") { addFn("atan") {
ObjReal(atan(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
} }
addFn("sinh") { addFn("sinh") {
ObjReal(sinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
} }
addFn("cosh") { addFn("cosh") {
ObjReal(cosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
} }
addFn("tanh") { addFn("tanh") {
ObjReal(tanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
} }
addFn("asinh") { addFn("asinh") {
ObjReal(asinh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
} }
addFn("acosh") { addFn("acosh") {
ObjReal(acosh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
} }
addFn("atanh") { addFn("atanh") {
ObjReal(atanh(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
} }
addFn("exp") { addFn("exp") {
ObjReal(exp(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
} }
addFn("ln") { addFn("ln") {
ObjReal(ln(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
} }
addFn("log10") { addFn("log10") {
ObjReal(log10(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
} }
addFn("log2") { addFn("log2") {
ObjReal(log2(args.firstAndOnly().toDouble())) decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
} }
addFn("pow") { addFn("pow") {
requireExactCount(2) requireExactCount(2)
ObjReal( decimalAwarePow(args[0], args[1])
(args[0].toDouble()).pow(args[1].toDouble())
)
} }
addFn("sqrt") { addItem(
ObjReal( "sqrt",
sqrt(args.firstAndOnly().toDouble()) false,
ObjExternCallable.fromBridge {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
},
recordType = ObjRecord.Type.Fun,
typeDecl = TypeDecl.Function(
receiver = null,
params = listOf(TypeDecl.TypeAny),
returnType = TypeDecl.Simple("Real", false),
nullable = false
)
) )
}
addFn("abs") { addFn("abs") {
val x = args.firstAndOnly() val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue) else ObjReal(x.toDouble().absoluteValue) if (x is ObjInt) ObjInt(x.value.absoluteValue)
else decimalAwareUnaryMath(x, ObjDecimalSupport::exactAbs) { it.absoluteValue }
} }
addFnDoc( addFnDoc(
@@ -591,9 +636,17 @@ class Script(
addFn("launch") { addFn("launch") {
val callable = requireOnlyArg<Obj>() val callable = requireOnlyArg<Obj>()
val captured = this val captured = this
ObjDeferred(globalDefer { val session = EvalSession.currentOrNull()
val deferred = if (session != null) {
session.launchTrackedDeferred {
captured.call(callable) captured.call(callable)
}) }
} else {
globalDefer {
captured.call(callable)
}
}
ObjDeferred(deferred)
} }
addFn("yield") { addFn("yield") {
@@ -604,7 +657,7 @@ class Script(
addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) { addFn("flow", callSignature = CallSignature(tailBlockReceiverType = "FlowBuilder")) {
// important is: current context contains closure often used in call; // important is: current context contains closure often used in call;
// we'll need it for the producer // we'll need it for the producer
ObjFlow(requireOnlyArg<Obj>(), requireScope()) ObjFlow(requireOnlyArg<Obj>(), requireScope(), EvalSession.currentOrNull())
} }
val pi = ObjReal(PI) val pi = ObjReal(PI)
@@ -615,12 +668,88 @@ class Script(
type = type("lyng.Real") type = type("lyng.Real")
) )
getOrCreateNamespace("Math").apply { getOrCreateNamespace("Math").apply {
fun ensureFn(name: String, fn: suspend ScopeFacade.() -> Obj) {
if (members.containsKey(name)) return
addFn(name, code = fn)
}
addConstDoc( addConstDoc(
name = "PI", name = "PI",
value = pi, value = pi,
doc = "The mathematical constant pi (π) in the Math namespace.", doc = "The mathematical constant pi (π) in the Math namespace.",
type = type("lyng.Real") type = type("lyng.Real")
) )
ensureFn("floor") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactFloor, ::floor)
}
ensureFn("ceil") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactCeil, ::ceil)
}
ensureFn("round") {
val x = args.firstAndOnly()
decimalAwareRoundLike(x, ObjDecimalSupport::exactRound, ::round)
}
ensureFn("sin") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sin)
}
ensureFn("cos") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cos)
}
ensureFn("tan") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tan)
}
ensureFn("asin") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asin)
}
ensureFn("acos") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acos)
}
ensureFn("atan") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atan)
}
ensureFn("sinh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sinh)
}
ensureFn("cosh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::cosh)
}
ensureFn("tanh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::tanh)
}
ensureFn("asinh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::asinh)
}
ensureFn("acosh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::acosh)
}
ensureFn("atanh") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::atanh)
}
ensureFn("exp") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::exp)
}
ensureFn("ln") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::ln)
}
ensureFn("log10") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log10)
}
ensureFn("log2") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::log2)
}
ensureFn("pow") {
requireExactCount(2)
decimalAwarePow(args[0], args[1])
}
ensureFn("sqrt") {
decimalAwareUnaryMath(args.firstAndOnly(), fallback = ::sqrt)
}
ensureFn("abs") {
val x = args.firstAndOnly()
if (x is ObjInt) ObjInt(x.value.absoluteValue)
else decimalAwareUnaryMath(x, ObjDecimalSupport::exactAbs) { it.absoluteValue }
}
} }
} }
@@ -757,7 +886,15 @@ class Script(
} }
addPackage("lyng.decimal") { module -> addPackage("lyng.decimal") { module ->
module.eval(Source("lyng.decimal", decimalLyng)) module.eval(Source("lyng.decimal", decimalLyng))
ObjBigDecimalSupport.bindTo(module) ObjDecimalSupport.bindTo(module)
}
addPackage("lyng.matrix") { module ->
module.eval(Source("lyng.matrix", matrixLyng))
ObjMatrixSupport.bindTo(module)
}
addPackage("lyng.complex") { module ->
module.eval(Source("lyng.complex", complexLyng))
ObjComplexSupport.bindTo(module)
} }
addPackage("lyng.buffer") { addPackage("lyng.buffer") {
it.addConstDoc( it.addConstDoc(
@@ -43,6 +43,8 @@ class BytecodeCompiler(
private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), private val callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
private val externCallableNames: Set<String> = emptySet(), private val externCallableNames: Set<String> = emptySet(),
private val externBindingNames: Set<String> = emptySet(), private val externBindingNames: Set<String> = emptySet(),
private val preparedModuleBindingNames: Set<String> = emptySet(),
private val scopeRefPosByName: Map<String, Pos> = emptyMap(),
private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), private val lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
) { ) {
private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null private val useScopeSlots: Boolean = allowedScopeNames != null || scopeSlotNameSet != null
@@ -53,12 +55,15 @@ class BytecodeCompiler(
private var scopeSlotIndices = IntArray(0) private var scopeSlotIndices = IntArray(0)
private var scopeSlotNames = emptyArray<String?>() private var scopeSlotNames = emptyArray<String?>()
private var scopeSlotIsModule = BooleanArray(0) private var scopeSlotIsModule = BooleanArray(0)
private var scopeSlotRequiresPreparedBinding = BooleanArray(0)
private var scopeSlotRefPos = emptyArray<Pos?>()
private var scopeSlotMutables = BooleanArray(0) private var scopeSlotMutables = BooleanArray(0)
private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>() private var scopeKeyByIndex = emptyArray<ScopeSlotKey?>()
private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>() private val scopeSlotMap = LinkedHashMap<ScopeSlotKey, Int>()
private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>() private val scopeSlotNameMap = LinkedHashMap<ScopeSlotKey, String>()
private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>() private val scopeSlotMutableMap = LinkedHashMap<ScopeSlotKey, Boolean>()
private val scopeSlotIndexByName = LinkedHashMap<String, Int>() private val scopeSlotIndexByName = LinkedHashMap<String, Int>()
private val scopeSlotRefPosByKey = LinkedHashMap<ScopeSlotKey, Pos>()
private val pendingScopeNameRefs = LinkedHashSet<String>() private val pendingScopeNameRefs = LinkedHashSet<String>()
private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>() private val addrSlotByScopeSlot = LinkedHashMap<Int, Int>()
private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean) private data class LocalSlotInfo(val name: String, val isMutable: Boolean, val isDelegated: Boolean)
@@ -119,6 +124,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -140,6 +147,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -158,6 +167,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -176,6 +187,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -194,6 +207,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -212,6 +227,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -230,6 +247,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -248,6 +267,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -266,6 +287,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -284,6 +307,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -302,6 +327,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -322,6 +349,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -340,6 +369,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -358,6 +389,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -376,6 +409,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -395,6 +430,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -416,6 +453,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -439,6 +478,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -459,6 +500,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -534,6 +577,7 @@ class BytecodeCompiler(
resolved = SlotType.INT resolved = SlotType.INT
} }
if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) { if (mapped < scopeSlotCount && resolved != SlotType.UNKNOWN) {
noteScopeSlotRef(mapped, ref.pos())
val addrSlot = ensureScopeAddr(mapped) val addrSlot = ensureScopeAddr(mapped)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, resolved) emitLoadFromAddr(addrSlot, local, resolved)
@@ -544,6 +588,7 @@ class BytecodeCompiler(
return CompiledValue(local, resolved) return CompiledValue(local, resolved)
} }
if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) { if (mapped < scopeSlotCount && resolved == SlotType.UNKNOWN) {
noteScopeSlotRef(mapped, ref.pos())
val addrSlot = ensureScopeAddr(mapped) val addrSlot = ensureScopeAddr(mapped)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, SlotType.OBJ) emitLoadFromAddr(addrSlot, local, SlotType.OBJ)
@@ -563,6 +608,7 @@ class BytecodeCompiler(
} }
if (allowLocalSlots) { if (allowLocalSlots) {
scopeSlotIndexByName[ref.name]?.let { slot -> scopeSlotIndexByName[ref.name]?.let { slot ->
noteScopeSlotRef(slot, callSitePos())
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
@@ -585,6 +631,7 @@ class BytecodeCompiler(
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
scopeSlotIndexByName[ref.name]?.let { slot -> scopeSlotIndexByName[ref.name]?.let { slot ->
noteScopeSlotRef(slot, callSitePos())
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
return CompiledValue(slot, resolved) return CompiledValue(slot, resolved)
} }
@@ -596,6 +643,7 @@ class BytecodeCompiler(
val slot = ref.slotIndex() val slot = ref.slotIndex()
val resolved = slotTypes[slot] ?: SlotType.UNKNOWN val resolved = slotTypes[slot] ?: SlotType.UNKNOWN
if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) { if (slot < scopeSlotCount && resolved != SlotType.UNKNOWN) {
noteScopeSlotRef(slot, callSitePos())
val addrSlot = ensureScopeAddr(slot) val addrSlot = ensureScopeAddr(slot)
val local = allocSlot() val local = allocSlot()
emitLoadFromAddr(addrSlot, local, resolved) emitLoadFromAddr(addrSlot, local, resolved)
@@ -2396,7 +2444,8 @@ class BytecodeCompiler(
builder.emit(Opcode.THROW, posId, msgSlot) builder.emit(Opcode.THROW, posId, msgSlot)
return value return value
} }
val slot = resolveSlot(localTarget) val slot = resolveCapturedOwnerScopeSlot(localTarget)
?: resolveSlot(localTarget)
?: resolveAssignableSlotByName(localTarget.name)?.first ?: resolveAssignableSlotByName(localTarget.name)?.first
?: return null ?: return null
if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) { if (slot < scopeSlotCount && value.type != SlotType.UNKNOWN) {
@@ -2702,7 +2751,7 @@ class BytecodeCompiler(
return CompiledValue(result, SlotType.OBJ) return CompiledValue(result, SlotType.OBJ)
} }
if (localTarget.isDelegated) return compileEvalRef(ref) if (localTarget.isDelegated) return compileEvalRef(ref)
val slot = resolveSlot(localTarget) ?: return null val slot = resolveCapturedOwnerScopeSlot(localTarget) ?: resolveSlot(localTarget) ?: return null
val targetType = slotTypes[slot] ?: SlotType.OBJ val targetType = slotTypes[slot] ?: SlotType.OBJ
if (!localTarget.isMutable) { if (!localTarget.isMutable) {
if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref) if (targetType != SlotType.OBJ && targetType != SlotType.UNKNOWN) return compileEvalRef(ref)
@@ -5001,6 +5050,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5020,6 +5071,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5040,6 +5093,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5060,6 +5115,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5083,6 +5140,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5102,6 +5161,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -5726,6 +5787,8 @@ class BytecodeCompiler(
scopeSlotIndices, scopeSlotIndices,
scopeSlotNames, scopeSlotNames,
scopeSlotIsModule, scopeSlotIsModule,
scopeSlotRequiresPreparedBinding,
scopeSlotRefPos,
localSlotNames, localSlotNames,
localSlotMutables, localSlotMutables,
localSlotDelegated, localSlotDelegated,
@@ -7598,6 +7661,14 @@ class BytecodeCompiler(
private fun assignValue(ref: AssignRef): ObjRef = ref.value private fun assignValue(ref: AssignRef): ObjRef = ref.value
private fun refPos(ref: BinaryOpRef): Pos = Pos.builtIn private fun refPos(ref: BinaryOpRef): Pos = Pos.builtIn
private fun noteScopeSlotRef(slot: Int, pos: Pos) {
if (slot >= scopeSlotCount) return
val key = scopeKeyByIndex.getOrNull(slot) ?: return
if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = pos
}
}
private fun resolveSlot(ref: LocalSlotRef): Int? { private fun resolveSlot(ref: LocalSlotRef): Int? {
loopSlotOverrides[ref.name]?.let { return it } loopSlotOverrides[ref.name]?.let { return it }
val scopeId = refScopeId(ref) val scopeId = refScopeId(ref)
@@ -7605,8 +7676,18 @@ class BytecodeCompiler(
val key = ScopeSlotKey(scopeId, refSlot(ref)) val key = ScopeSlotKey(scopeId, refSlot(ref))
val localIndex = localSlotIndexByKey[key] val localIndex = localSlotIndexByKey[key]
if (localIndex != null) return scopeSlotCount + localIndex if (localIndex != null) return scopeSlotCount + localIndex
scopeSlotMap[key]?.let { return it } scopeSlotMap[key]?.let {
scopeSlotIndexByName[ref.name]?.let { return it } if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = ref.pos()
}
return it
}
scopeSlotIndexByName[ref.name]?.let {
if (!scopeSlotRefPosByKey.containsKey(key)) {
scopeSlotRefPosByKey[key] = ref.pos()
}
return it
}
} }
if (ref.captureOwnerScopeId != null) { if (ref.captureOwnerScopeId != null) {
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
@@ -7616,7 +7697,13 @@ class BytecodeCompiler(
return scopeSlotCount + localIndex return scopeSlotCount + localIndex
} }
} }
return scopeSlotMap[scopeKey] val resolved = scopeSlotMap[scopeKey]
if (resolved != null) {
if (!scopeSlotRefPosByKey.containsKey(scopeKey)) {
scopeSlotRefPosByKey[scopeKey] = ref.pos()
}
}
return resolved
} }
if (ref.isDelegated) { if (ref.isDelegated) {
val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val localKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
@@ -7627,7 +7714,20 @@ class BytecodeCompiler(
val localIndex = localSlotIndexByKey[localKey] val localIndex = localSlotIndexByKey[localKey]
if (localIndex != null) return scopeSlotCount + localIndex if (localIndex != null) return scopeSlotCount + localIndex
val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref)) val scopeKey = ScopeSlotKey(refScopeId(ref), refSlot(ref))
return scopeSlotMap[scopeKey] val resolved = scopeSlotMap[scopeKey]
if (resolved != null) {
if (!scopeSlotRefPosByKey.containsKey(scopeKey)) {
scopeSlotRefPosByKey[scopeKey] = ref.pos()
}
}
return resolved
}
private fun resolveCapturedOwnerScopeSlot(ref: LocalSlotRef): Int? {
val ownerScopeId = ref.captureOwnerScopeId ?: return null
val ownerSlot = ref.captureOwnerSlot ?: return null
val key = ScopeSlotKey(ownerScopeId, ownerSlot)
return scopeSlotMap[key]
} }
private fun updateSlotType(slot: Int, type: SlotType) { private fun updateSlotType(slot: Int, type: SlotType) {
@@ -7850,6 +7950,8 @@ class BytecodeCompiler(
scopeSlotIndices = IntArray(scopeSlotCount) scopeSlotIndices = IntArray(scopeSlotCount)
scopeSlotNames = arrayOfNulls(scopeSlotCount) scopeSlotNames = arrayOfNulls(scopeSlotCount)
scopeSlotIsModule = BooleanArray(scopeSlotCount) scopeSlotIsModule = BooleanArray(scopeSlotCount)
scopeSlotRequiresPreparedBinding = BooleanArray(scopeSlotCount)
scopeSlotRefPos = arrayOfNulls(scopeSlotCount)
scopeSlotMutables = BooleanArray(scopeSlotCount) { true } scopeSlotMutables = BooleanArray(scopeSlotCount) { true }
scopeKeyByIndex = arrayOfNulls(scopeSlotCount) scopeKeyByIndex = arrayOfNulls(scopeSlotCount)
for ((key, index) in scopeSlotMap) { for ((key, index) in scopeSlotMap) {
@@ -7857,6 +7959,8 @@ class BytecodeCompiler(
scopeSlotIndices[index] = key.slot scopeSlotIndices[index] = key.slot
scopeSlotNames[index] = name scopeSlotNames[index] = name
scopeSlotIsModule[index] = moduleScopeId != null && key.scopeId == moduleScopeId scopeSlotIsModule[index] = moduleScopeId != null && key.scopeId == moduleScopeId
scopeSlotRequiresPreparedBinding[index] = name != null && preparedModuleBindingNames.contains(name)
scopeSlotRefPos[index] = name?.let { scopeRefPosByName[it] } ?: scopeSlotRefPosByKey[key]
scopeSlotMutableMap[key]?.let { scopeSlotMutables[index] = it } scopeSlotMutableMap[key]?.let { scopeSlotMutables[index] = it }
scopeKeyByIndex[index] = key scopeKeyByIndex[index] = key
} }
@@ -50,7 +50,7 @@ class BytecodeStatement private constructor(
?: scope.parent?.get(name) ?: scope.parent?.get(name)
?: scope.get(name) ?: scope.get(name)
?: continue ?: continue
val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property) { val value = if (record.type == ObjRecord.Type.Delegated || record.type == ObjRecord.Type.Property || record.value is net.sergeych.lyng.obj.ObjProperty) {
scope.resolve(record, name) scope.resolve(record, name)
} else { } else {
record.value record.value
@@ -88,6 +88,8 @@ class BytecodeStatement private constructor(
callableReturnTypeByName: Map<String, ObjClass> = emptyMap(), callableReturnTypeByName: Map<String, ObjClass> = emptyMap(),
externCallableNames: Set<String> = emptySet(), externCallableNames: Set<String> = emptySet(),
externBindingNames: Set<String> = emptySet(), externBindingNames: Set<String> = emptySet(),
preparedModuleBindingNames: Set<String> = emptySet(),
scopeRefPosByName: Map<String, Pos> = emptyMap(),
lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(), lambdaCaptureEntriesByRef: Map<ValueFnRef, List<LambdaCaptureEntry>> = emptyMap(),
slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(), slotTypeDeclByScopeId: Map<Int, Map<Int, TypeDecl>> = emptyMap(),
): Statement { ): Statement {
@@ -124,6 +126,8 @@ class BytecodeStatement private constructor(
callableReturnTypeByName = callableReturnTypeByName, callableReturnTypeByName = callableReturnTypeByName,
externCallableNames = externCallableNames, externCallableNames = externCallableNames,
externBindingNames = externBindingNames, externBindingNames = externBindingNames,
preparedModuleBindingNames = preparedModuleBindingNames,
scopeRefPosByName = scopeRefPosByName,
lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef lambdaCaptureEntriesByRef = lambdaCaptureEntriesByRef
) )
val compiled = compiler.compileStatement(nameHint, statement) val compiled = compiler.compileStatement(nameHint, statement)
@@ -67,6 +67,8 @@ class CmdBuilder {
scopeSlotIndices: IntArray = IntArray(0), scopeSlotIndices: IntArray = IntArray(0),
scopeSlotNames: Array<String?> = emptyArray(), scopeSlotNames: Array<String?> = emptyArray(),
scopeSlotIsModule: BooleanArray = BooleanArray(0), scopeSlotIsModule: BooleanArray = BooleanArray(0),
scopeSlotRequiresPreparedBinding: BooleanArray = BooleanArray(0),
scopeSlotRefPos: Array<net.sergeych.lyng.Pos?> = emptyArray(),
localSlotNames: Array<String?> = emptyArray(), localSlotNames: Array<String?> = emptyArray(),
localSlotMutables: BooleanArray = BooleanArray(0), localSlotMutables: BooleanArray = BooleanArray(0),
localSlotDelegated: BooleanArray = BooleanArray(0), localSlotDelegated: BooleanArray = BooleanArray(0),
@@ -79,6 +81,12 @@ class CmdBuilder {
require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) { require(scopeSlotIsModule.isEmpty() || scopeSlotIsModule.size == scopeSlotCount) {
"scope slot module mapping size mismatch" "scope slot module mapping size mismatch"
} }
require(scopeSlotRequiresPreparedBinding.isEmpty() || scopeSlotRequiresPreparedBinding.size == scopeSlotCount) {
"scope slot prepared-binding mapping size mismatch"
}
require(scopeSlotRefPos.isEmpty() || scopeSlotRefPos.size == scopeSlotCount) {
"scope slot position mapping size mismatch"
}
require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" } require(localSlotNames.size == localSlotMutables.size) { "local slot metadata size mismatch" }
require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" } require(localSlotNames.size == localSlotDelegated.size) { "local slot delegation size mismatch" }
require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" } require(localSlotNames.size == localSlotCaptures.size) { "local slot capture size mismatch" }
@@ -113,6 +121,8 @@ class CmdBuilder {
scopeSlotIndices = scopeSlotIndices, scopeSlotIndices = scopeSlotIndices,
scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames, scopeSlotNames = if (scopeSlotNames.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotNames,
scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule, scopeSlotIsModule = if (scopeSlotIsModule.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotIsModule,
scopeSlotRequiresPreparedBinding = if (scopeSlotRequiresPreparedBinding.isEmpty()) BooleanArray(scopeSlotCount) else scopeSlotRequiresPreparedBinding,
scopeSlotRefPos = if (scopeSlotRefPos.isEmpty()) Array(scopeSlotCount) { null } else scopeSlotRefPos,
localSlotNames = localSlotNames, localSlotNames = localSlotNames,
localSlotMutables = localSlotMutables, localSlotMutables = localSlotMutables,
localSlotDelegated = localSlotDelegated, localSlotDelegated = localSlotDelegated,
Loaded 100 of 153 files, more files were not shown because too many files have changed in this diff. Show more