Compare commits
30
Commits
eefecae7b4
...
0.9.3
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
65963ce537 | ||
|
|
9d222be924 | ||
|
|
f00631cd88 | ||
|
|
b8d6ff01a6 | ||
|
|
ba725fc9ed | ||
|
|
5d4d548275 | ||
|
|
7e289382ed | ||
|
|
c854b06683 | ||
|
|
e8b630715a | ||
|
|
3481a718b1 | ||
|
|
2696f1546d | ||
|
|
f45fa7f7a0 | ||
|
|
ead2f7168e | ||
|
|
2743511b62 | ||
|
|
8431ab4f96 | ||
|
|
80735f032d | ||
|
|
dc837e2095 | ||
|
|
0ec0ed96ee | ||
|
|
a5e51a3f90 | ||
|
|
cf79163802 | ||
|
|
c8e8bdc466 | ||
|
|
4b613fda7c | ||
|
|
8d1cafae80 | ||
|
|
0526cdfb38 | ||
|
|
cad6ba936d | ||
|
|
cb333ab6bd | ||
|
|
23737f9b5c | ||
|
|
fb6e2aa49e | ||
|
|
95c1da60ed | ||
|
|
835333dfad |
No files matched your search
@@ -1,54 +0,0 @@
|
|||||||
# This workflow uses actions that are not certified by GitHub.
|
|
||||||
# They are provided by a third-party and are governed by
|
|
||||||
# separate terms of service, privacy policy, and support
|
|
||||||
# documentation.
|
|
||||||
# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
|
|
||||||
# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle
|
|
||||||
|
|
||||||
name: Java CI with Gradle
|
|
||||||
|
|
||||||
on:
|
|
||||||
push:
|
|
||||||
branches: [ "main" ]
|
|
||||||
pull_request:
|
|
||||||
branches: [ "main" ]
|
|
||||||
workflow_call:
|
|
||||||
|
|
||||||
permissions:
|
|
||||||
contents: read
|
|
||||||
|
|
||||||
jobs:
|
|
||||||
build:
|
|
||||||
strategy:
|
|
||||||
matrix:
|
|
||||||
include:
|
|
||||||
- target: iosSimulatorArm64Test
|
|
||||||
os: macos-latest
|
|
||||||
- target: jvmTest
|
|
||||||
os: ubuntu-latest
|
|
||||||
- target: linuxX64Test
|
|
||||||
os: ubuntu-latest
|
|
||||||
- target: testDebugUnitTest
|
|
||||||
os: ubuntu-latest
|
|
||||||
- target: testReleaseUnitTest
|
|
||||||
os: ubuntu-latest
|
|
||||||
runs-on: ${{ matrix.os }}
|
|
||||||
|
|
||||||
steps:
|
|
||||||
- uses: actions/checkout@v3
|
|
||||||
- name: Validate Gradle Wrapper
|
|
||||||
uses: gradle/actions/wrapper-validation@v3
|
|
||||||
- uses: actions/cache@v3
|
|
||||||
with:
|
|
||||||
path: |
|
|
||||||
~/.konan
|
|
||||||
key: ${{ runner.os }}-${{ hashFiles('**/.lock') }}
|
|
||||||
- name: Set up JDK 17
|
|
||||||
uses: actions/setup-java@v3
|
|
||||||
with:
|
|
||||||
java-version: '17'
|
|
||||||
distribution: 'temurin'
|
|
||||||
- name: Build with Gradle
|
|
||||||
uses: gradle/gradle-build-action@ce999babab2de1c4b649dc15f0ee67e6246c994f
|
|
||||||
with:
|
|
||||||
arguments: ${{ matrix.target }}
|
|
||||||
@@ -1,25 +0,0 @@
|
|||||||
name: Publish
|
|
||||||
on:
|
|
||||||
release:
|
|
||||||
types: [released, prereleased]
|
|
||||||
jobs:
|
|
||||||
publish:
|
|
||||||
name: Release build and publish
|
|
||||||
runs-on: macOS-latest
|
|
||||||
steps:
|
|
||||||
- name: Check out code
|
|
||||||
uses: actions/checkout@v4
|
|
||||||
- name: Set up JDK 21
|
|
||||||
uses: actions/setup-java@v4
|
|
||||||
with:
|
|
||||||
distribution: 'zulu'
|
|
||||||
java-version: 21
|
|
||||||
- name: Publish to MavenCentral
|
|
||||||
run: ./gradlew publishToMavenCentral --no-configuration-cache
|
|
||||||
env:
|
|
||||||
ORG_GRADLE_PROJECT_mavenCentralUsername: ${{ secrets.MAVEN_CENTRAL_USERNAME }}
|
|
||||||
ORG_GRADLE_PROJECT_mavenCentralPassword: ${{ secrets.MAVEN_CENTRAL_PASSWORD }}
|
|
||||||
ORG_GRADLE_PROJECT_signingInMemoryKeyId: ${{ secrets.SIGNING_KEY_ID }}
|
|
||||||
ORG_GRADLE_PROJECT_signingInMemoryKeyPassword: ${{ secrets.SIGNING_PASSWORD }}
|
|
||||||
ORG_GRADLE_PROJECT_signingInMemoryKey: ${{ secrets.GPG_KEY_CONTENTS }}
|
|
||||||
|
|
||||||
@@ -1,42 +0,0 @@
|
|||||||
<!--
|
|
||||||
~ Copyright 2025 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.
|
|
||||||
~
|
|
||||||
-->
|
|
||||||
|
|
||||||
<component name="ProjectRunConfigurationManager">
|
|
||||||
<configuration default="false" name="Tests in 'lyng.lynglib.jvmTest'" type="GradleRunConfiguration" factoryName="Gradle">
|
|
||||||
<ExternalSystemSettings>
|
|
||||||
<option name="executionName" />
|
|
||||||
<option name="externalProjectPath" value="$PROJECT_DIR$" />
|
|
||||||
<option name="externalSystemIdString" value="GRADLE" />
|
|
||||||
<option name="scriptParameters" value="" />
|
|
||||||
<option name="taskDescriptions">
|
|
||||||
<list />
|
|
||||||
</option>
|
|
||||||
<option name="taskNames">
|
|
||||||
<list>
|
|
||||||
<option value=":lynglib:cleanJvmTest" />
|
|
||||||
<option value=":lynglib:jvmTest" />
|
|
||||||
</list>
|
|
||||||
</option>
|
|
||||||
<option name="vmOptions" />
|
|
||||||
</ExternalSystemSettings>
|
|
||||||
<ExternalSystemDebugServerProcess>false</ExternalSystemDebugServerProcess>
|
|
||||||
<ExternalSystemReattachDebugProcess>true</ExternalSystemReattachDebugProcess>
|
|
||||||
<DebugAllEnabled>false</DebugAllEnabled>
|
|
||||||
<RunAsTest>true</RunAsTest>
|
|
||||||
<method v="2" />
|
|
||||||
</configuration>
|
|
||||||
</component>
|
|
||||||
@@ -134,7 +134,19 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
|
|||||||
|
|
||||||
# Language Roadmap
|
# Language Roadmap
|
||||||
|
|
||||||
## v1.0.0
|
```mermaid
|
||||||
|
flowchart
|
||||||
|
v0([the idea])
|
||||||
|
v1([v1: make it happen])
|
||||||
|
v2([v1.5: testmake it fasted and rich featured])
|
||||||
|
v3([v2: ideal script language])
|
||||||
|
v0 --code MVP--> v1
|
||||||
|
v1 --refine and extend--> v2
|
||||||
|
v2 -- optimize --> v3
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
## v1.0.0 "Make it happen"
|
||||||
|
|
||||||
Planned autumn 2025. Complete dynamic language with sufficient standard library:
|
Planned autumn 2025. Complete dynamic language with sufficient standard library:
|
||||||
|
|
||||||
@@ -158,27 +170,32 @@ Ready features:
|
|||||||
- [x] compression/decompression (integrated in serialization)
|
- [x] compression/decompression (integrated in serialization)
|
||||||
- [x] dynamic fields
|
- [x] dynamic fields
|
||||||
- [x] function annotations
|
- [x] function annotations
|
||||||
|
- [x] better stack reporting
|
||||||
|
|
||||||
### Under way:
|
### Under way:
|
||||||
|
|
||||||
- [ ] regular exceptions
|
- [ ] regular exceptions + extended `when`
|
||||||
- [ ] multiple inheritance for user classes
|
- [ ] multiple inheritance for user classes
|
||||||
- [ ] site with integrated interpreter to give a try
|
- [ ] site with integrated interpreter to give a try
|
||||||
- [ ] kotlin part public API good docs, integration focused
|
- [ ] kotlin part public API good docs, integration focused
|
||||||
- [ ] better stack reporting
|
|
||||||
|
|
||||||
## v1.1+
|
## plan: v1.0 - v1.5 "Rich and stable"
|
||||||
|
|
||||||
|
Estimated spring of 2026
|
||||||
|
|
||||||
Planned features.
|
Planned features.
|
||||||
|
|
||||||
- [ ] type specifications
|
- [ ] type specifications
|
||||||
|
- [ ] language server or compose-based lyng-aware editor
|
||||||
- [ ] source docs and maybe lyng.md to a standard
|
- [ ] source docs and maybe lyng.md to a standard
|
||||||
- [ ] metadata first class access from lyng
|
- [ ] metadata first class access from lyng
|
||||||
|
|
||||||
Further
|
## After 1.5 "Ideal scripting"
|
||||||
|
|
||||||
|
Estimated winter 2027
|
||||||
|
|
||||||
- [ ] client with GUI support based on compose multiplatform somehow
|
- [ ] client with GUI support based on compose multiplatform somehow
|
||||||
- [ ] notebook - style workbooks with graphs, formulae, etc.
|
- [ ] notebook - style workbooks with graphs, formulae, etc.
|
||||||
- [ ] language server or compose-based lyng-aware editor
|
- [ ] aggressive optimizations
|
||||||
|
|
||||||
[parallelism]: docs/parallelism.md
|
[parallelism]: docs/parallelism.md
|
||||||
@@ -0,0 +1,37 @@
|
|||||||
|
# Array
|
||||||
|
|
||||||
|
It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
|
||||||
|
Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
|
||||||
|
[List].
|
||||||
|
|
||||||
|
Array adds the following methods:
|
||||||
|
|
||||||
|
## Binary search
|
||||||
|
|
||||||
|
When applied to sorted arrays, binary search allow to quicly find an index of the element in the array, or where to insert it to keep order:
|
||||||
|
|
||||||
|
val coll = [1,2,3,4,5]
|
||||||
|
assertEquals( 2, coll.binarySearch(3) )
|
||||||
|
assertEquals( 0, coll.binarySearch(1) )
|
||||||
|
assertEquals( 4, coll.binarySearch(5) )
|
||||||
|
|
||||||
|
val src = (1..50).toList().shuffled()
|
||||||
|
val result = []
|
||||||
|
for( x in src ) {
|
||||||
|
val i = result.binarySearch(x)
|
||||||
|
assert( i < 0 )
|
||||||
|
result.insertAt(-i-1, x)
|
||||||
|
}
|
||||||
|
assertEquals( src.sorted(), result )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
So `binarySearch(x)` returns:
|
||||||
|
|
||||||
|
- index of `x`, a non-negative number
|
||||||
|
- negative: `x` not found, but if inserted at position `-returnedValue-1` will leave array sorted.
|
||||||
|
|
||||||
|
To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families, see [List] and [Iterable] docs.
|
||||||
|
|
||||||
|
[Collection]: Collection.md
|
||||||
|
[Iterable]: Iterable.md
|
||||||
|
[List]: List.md
|
||||||
+6
-2
@@ -121,7 +121,7 @@ which is used in `toString`) and hex encoding:
|
|||||||
## Members
|
## Members
|
||||||
|
|
||||||
| name | meaning | type |
|
| name | meaning | type |
|
||||||
|---------------------------|-----------------------------------|---------------|
|
|----------------------------|-----------------------------------------|---------------|
|
||||||
| `size` | size | Int |
|
| `size` | size | Int |
|
||||||
| `decodeUtf8` | decode to String using UTF8 rules | Any |
|
| `decodeUtf8` | decode to String using UTF8 rules | Any |
|
||||||
| `+` | buffer concatenation | Any |
|
| `+` | buffer concatenation | Any |
|
||||||
@@ -129,7 +129,8 @@ which is used in `toString`) and hex encoding:
|
|||||||
| `hex` | encode to hex strign | String |
|
| `hex` | encode to hex strign | String |
|
||||||
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
|
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
|
||||||
| `base64` | encode to base64 (url flavor) (2) | String |
|
| `base64` | encode to base64 (url flavor) (2) | String |
|
||||||
| `Buffer.decodeBase64` | decode base64 to new Buffer (2) | Buffer |
|
| `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2) | Buffer |
|
||||||
|
| `toBitInput()` | create bit input from a byte buffer (3) | |
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: optimized implementation that override `Iterable` one
|
: optimized implementation that override `Iterable` one
|
||||||
@@ -139,6 +140,9 @@ which is used in `toString`) and hex encoding:
|
|||||||
decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
|
decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
|
||||||
well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
|
well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
|
||||||
|
|
||||||
|
(3)
|
||||||
|
: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
|
||||||
|
|
||||||
Also, it inherits methods from [Iterable] and [Array].
|
Also, it inherits methods from [Iterable] and [Array].
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
|
|||||||
val size
|
val size
|
||||||
}
|
}
|
||||||
|
|
||||||
|
| name | description |
|
||||||
|
|------------------------|------------------------------------------------------|
|
||||||
|
|
||||||
|
(1)
|
||||||
|
: `comparator(a,b)` should return -1 if `a < b`, +1 if `a > b` or zero.
|
||||||
|
|
||||||
See [List], [Set] and [Iterable]
|
See [List], [Set] and [Iterable]
|
||||||
|
|
||||||
[Iterable]: Iterable.md
|
[Iterable]: Iterable.md
|
||||||
|
|||||||
+40
-7
@@ -1,9 +1,13 @@
|
|||||||
# Iterable interface
|
# Iterable interface
|
||||||
|
|
||||||
The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`, `Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
|
The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed
|
||||||
|
sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`,
|
||||||
|
`Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
|
||||||
|
|
||||||
`Map` and `String` have `Iterable` members to access its contents too.
|
`Map` and `String` have `Iterable` members to access its contents too.
|
||||||
|
|
||||||
|
Please see also [Collection] interface: many iterables are also collections, and it adds important features.
|
||||||
|
|
||||||
## Definition:
|
## Definition:
|
||||||
|
|
||||||
Iterable is a class that provides function that creates _the iterator_:
|
Iterable is a class that provides function that creates _the iterator_:
|
||||||
@@ -23,7 +27,8 @@ Iterator itself is a simple interface that should provide only to method:
|
|||||||
|
|
||||||
Just remember at this stage typed declarations are not yet supported.
|
Just remember at this stage typed declarations are not yet supported.
|
||||||
|
|
||||||
Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions available, for example
|
Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions
|
||||||
|
available, for example
|
||||||
|
|
||||||
val r = 1..10 // Range is Iterable!
|
val r = 1..10 // Range is Iterable!
|
||||||
assertEquals( [9,10], r.takeLast(2).toList() )
|
assertEquals( [9,10], r.takeLast(2).toList() )
|
||||||
@@ -34,7 +39,8 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
|
|||||||
|
|
||||||
## joinToString
|
## joinToString
|
||||||
|
|
||||||
This methods convert any iterable to a string joining string representation of each element, optionally transforming it and joining using specified suffix.
|
This methods convert any iterable to a string joining string representation of each element, optionally transforming it
|
||||||
|
and joining using specified suffix.
|
||||||
|
|
||||||
Iterable.joinToString(suffux=' ', transform=null)
|
Iterable.joinToString(suffux=' ', transform=null)
|
||||||
|
|
||||||
@@ -49,11 +55,23 @@ Here is the sample:
|
|||||||
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## `sum` and `sumBy`
|
||||||
|
|
||||||
|
These, again, does the thing:
|
||||||
|
|
||||||
|
assertEquals( 6, [1,2,3].sum() )
|
||||||
|
assertEquals( 12, [1,2,3].sumOf { it*2 } )
|
||||||
|
|
||||||
|
// sum of empty collections is null:
|
||||||
|
assertEquals( null, [].sum() )
|
||||||
|
assertEquals( null, [].sumOf { 2*it } )
|
||||||
|
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Instance methods:
|
## Instance methods:
|
||||||
|
|
||||||
|
|
||||||
| fun/method | description |
|
| fun/method | description |
|
||||||
|-------------------|---------------------------------------------------------------------------|
|
|------------------------|---------------------------------------------------------------------------------|
|
||||||
| toList() | create a list from iterable |
|
| toList() | create a list from iterable |
|
||||||
| toSet() | create a set from iterable |
|
| toSet() | create a set from iterable |
|
||||||
| contains(i) | check that iterable contains `i` |
|
| contains(i) | check that iterable contains `i` |
|
||||||
@@ -70,13 +88,24 @@ Here is the sample:
|
|||||||
| taleLast(n) | return [Iterable] of up to n last elements |
|
| taleLast(n) | return [Iterable] of up to n last elements |
|
||||||
| drop(n) | return new [Iterable] without first n elements |
|
| drop(n) | return new [Iterable] without first n elements |
|
||||||
| dropLast(n) | return new [Iterable] without last n elements |
|
| dropLast(n) | return new [Iterable] without last n elements |
|
||||||
|
| sum() | return sum of the collection applying `+` to its elements (3) |
|
||||||
|
| sumOf(predicate) | sum of the modified collection items (3) |
|
||||||
|
| sorted() | return [List] with collection items sorted naturally |
|
||||||
|
| sortedWith(comparator) | sort using a comparator that compares elements (1) |
|
||||||
|
| sortedBy(predicate) | sort by comparing results of the predicate function |
|
||||||
| joinToString(s,t) | convert iterable to string, see (2) |
|
| joinToString(s,t) | convert iterable to string, see (2) |
|
||||||
|
| reversed() | create a list containing items from this in reverse order |
|
||||||
|
| shuffled() | create a listof shiffled elements |
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: throws `NoSuchElementException` if there is no such element
|
: throws `NoSuchElementException` if there is no such element
|
||||||
|
|
||||||
(2)
|
(2)
|
||||||
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
|
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is
|
||||||
|
optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
|
||||||
|
|
||||||
|
(3)
|
||||||
|
: sum of empty collection is `null`
|
||||||
|
|
||||||
fun Iterable.toList(): List
|
fun Iterable.toList(): List
|
||||||
fun Iterable.toSet(): Set
|
fun Iterable.toSet(): Set
|
||||||
@@ -87,7 +116,6 @@ Here is the sample:
|
|||||||
fun Iterable.map(block: (Any?)->Void ): List
|
fun Iterable.map(block: (Any?)->Void ): List
|
||||||
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
|
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
|
||||||
|
|
||||||
|
|
||||||
## Abstract methods:
|
## Abstract methods:
|
||||||
|
|
||||||
fun iterator(): Iterator
|
fun iterator(): Iterator
|
||||||
@@ -102,7 +130,12 @@ Creates a list by iterating to the end. So, the Iterator should be finite to be
|
|||||||
|
|
||||||
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
|
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
|
||||||
|
|
||||||
|
[Collection]: Collection.md
|
||||||
|
|
||||||
[List]: List.md
|
[List]: List.md
|
||||||
|
|
||||||
[Range]: Range.md
|
[Range]: Range.md
|
||||||
|
|
||||||
[Set]: Set.md
|
[Set]: Set.md
|
||||||
|
|
||||||
[RingBuffer]: RingBuffer.md
|
[RingBuffer]: RingBuffer.md
|
||||||
+37
-4
@@ -24,7 +24,7 @@ There is a shortcut for the last:
|
|||||||
|
|
||||||
val list = [10, 20, 30]
|
val list = [10, 20, 30]
|
||||||
[list.last, list.lastIndex]
|
[list.last, list.lastIndex]
|
||||||
>>> [30, 2]
|
>>> [30,2]
|
||||||
|
|
||||||
__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.
|
||||||
|
|
||||||
@@ -92,10 +92,29 @@ Open end ranges remove head and tail elements:
|
|||||||
assert( [1, 2, 3] !== [1, 2, 3])
|
assert( [1, 2, 3] !== [1, 2, 3])
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## In-place sort
|
||||||
|
|
||||||
|
List could be sorted in place, just like [Collection] provide sorted copies, in a very like way:
|
||||||
|
|
||||||
|
val l1 = [6,3,1,9]
|
||||||
|
l1.sort()
|
||||||
|
assertEquals( [1,3,6,9], l1)
|
||||||
|
|
||||||
|
l1.sortBy { -it }
|
||||||
|
assertEquals( [1,3,6,9].reversed(), l1)
|
||||||
|
|
||||||
|
l1.sort() // 1 3 6 9
|
||||||
|
l1.sortBy { it % 4 }
|
||||||
|
// 1,3,6,9 gives, mod 4:
|
||||||
|
// 1 3 2 1
|
||||||
|
// we hope we got it also stable:
|
||||||
|
assertEquals( [1,9,6,3], l1)
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Members
|
## Members
|
||||||
|
|
||||||
| name | meaning | type |
|
| name | meaning | type |
|
||||||
|-------------------------------|---------------------------------------|-------------|
|
|-------------------------------|----------------------------------------------|-------------|
|
||||||
| `size` | current size | Int |
|
| `size` | current size | Int |
|
||||||
| `add(elements...)` | add one or more elements to the end | Any |
|
| `add(elements...)` | add one or more elements to the end | Any |
|
||||||
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
|
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
|
||||||
@@ -107,7 +126,11 @@ Open end ranges remove head and tail elements:
|
|||||||
| `contains(element)` | check the element is in the list (1) | |
|
| `contains(element)` | check the element is in the list (1) | |
|
||||||
| `[index]` | get or set element at index | Int |
|
| `[index]` | get or set element at index | Int |
|
||||||
| `[Range]` | get slice of the array (copy) | Range |
|
| `[Range]` | get slice of the array (copy) | Range |
|
||||||
| `+=` | append element(s) | List or Obj |
|
| `+=` | append element(s) (2) | List or Obj |
|
||||||
|
| `sort()` | in-place sort, natural order | void |
|
||||||
|
| `sortBy(predicate)` | in-place sort bu `predicate` call result (3) | void |
|
||||||
|
| `sortWith(comparator)` | in-place sort using `comarator` function (4) | void |
|
||||||
|
| `shiffle()` | in-place shiffle contents | |
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: optimized implementation that override `Array` one
|
: optimized implementation that override `Array` one
|
||||||
@@ -116,7 +139,16 @@ Open end ranges remove head and tail elements:
|
|||||||
: `+=` append either a single element, or all elements if the List or other Iterable
|
: `+=` append either a single element, or all elements if the List or other Iterable
|
||||||
instance is appended. If you want to append an Iterable object itself, use `add` instead.
|
instance is appended. If you want to append an Iterable object itself, use `add` instead.
|
||||||
|
|
||||||
It inherits from [Iterable] too.
|
(3)
|
||||||
|
: predicate is called on each element, and the returned values are used to sort in natural
|
||||||
|
order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
|
||||||
|
|
||||||
|
(4)
|
||||||
|
: comparator callable takes tho arguments and must return: negative value when first is less,
|
||||||
|
positive if first is greater, and zero if they are equal. For example, the equvalent comparator
|
||||||
|
for `sort()` will be `sort { a, b -> a <=> b }
|
||||||
|
|
||||||
|
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
|
||||||
|
|
||||||
## Member inherited from Array
|
## Member inherited from Array
|
||||||
|
|
||||||
@@ -134,4 +166,5 @@ It inherits from [Iterable] too.
|
|||||||
|
|
||||||
|
|
||||||
[Range]: Range.md
|
[Range]: Range.md
|
||||||
|
|
||||||
[Iterable]: Iterable.md
|
[Iterable]: Iterable.md
|
||||||
+48
-1
@@ -266,7 +266,7 @@ The same we can provide writable dynamic fields (var-type), adding set method:
|
|||||||
// constant field
|
// constant field
|
||||||
"foo" -> "bar"
|
"foo" -> "bar"
|
||||||
// mutable field
|
// mutable field
|
||||||
"bar" -> setValueForBar
|
"bar" -> storedValueForBar
|
||||||
|
|
||||||
else -> throw SymbolNotFoundException()
|
else -> throw SymbolNotFoundException()
|
||||||
}
|
}
|
||||||
@@ -289,9 +289,56 @@ The same we can provide writable dynamic fields (var-type), adding set method:
|
|||||||
assertThrows {
|
assertThrows {
|
||||||
accessor.bad = "!23"
|
accessor.bad = "!23"
|
||||||
}
|
}
|
||||||
|
void
|
||||||
|
>>> void
|
||||||
|
|
||||||
Of course, you can return any object from dynamic fields; returning lambdas let create _dynamic methods_ - the callable method. It is very convenient to implement libraries with dynamic remote interfaces, etc.
|
Of course, you can return any object from dynamic fields; returning lambdas let create _dynamic methods_ - the callable method. It is very convenient to implement libraries with dynamic remote interfaces, etc.
|
||||||
|
|
||||||
|
### Dynamic indexers
|
||||||
|
|
||||||
|
Index access for dynamics is passed to the same getter and setter, so it is
|
||||||
|
generally the same:
|
||||||
|
|
||||||
|
var storedValue = "bar"
|
||||||
|
val x = dynamic {
|
||||||
|
get {
|
||||||
|
if( it == "foo" ) storedValue
|
||||||
|
else null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals("bar", x["foo"] )
|
||||||
|
assertEquals("bar", x.foo )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
And assigning them works the same. You can make it working
|
||||||
|
mimicking arrays, but remember, it is not Collection so
|
||||||
|
collection's sugar won't work with it:
|
||||||
|
|
||||||
|
var storedValue = "bar"
|
||||||
|
val x = dynamic {
|
||||||
|
get {
|
||||||
|
when(it) {
|
||||||
|
"size" -> 1
|
||||||
|
0 -> storedValue
|
||||||
|
else -> null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
set { index, value ->
|
||||||
|
if( index == 0 ) storedValue = value
|
||||||
|
else throw "Illegal index: "+index
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals("bar", x[0] )
|
||||||
|
assertEquals(1, x.size )
|
||||||
|
x[0] = "buzz"
|
||||||
|
assertThrows { x[1] = 1 }
|
||||||
|
assertEquals("buzz", storedValue)
|
||||||
|
assertEquals("buzz", x[0])
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
If you want dynamic to function like an array, create a [feature
|
||||||
|
request](https://gitea.sergeych.net/SergeychWorks/lyng/issues).
|
||||||
|
|
||||||
# Theory
|
# Theory
|
||||||
|
|
||||||
## Basic principles:
|
## Basic principles:
|
||||||
|
|||||||
+1
-1
@@ -87,7 +87,7 @@ You can use Char as both ends of the closed range:
|
|||||||
Exclusive end char ranges are supported too:
|
Exclusive end char ranges are supported too:
|
||||||
|
|
||||||
('a'..<'c').toList
|
('a'..<'c').toList
|
||||||
>>> ['a', 'b']
|
>>> [a,b]
|
||||||
|
|
||||||
|
|
||||||
# Instance members
|
# Instance members
|
||||||
|
|||||||
@@ -0,0 +1,91 @@
|
|||||||
|
# Regular expressions
|
||||||
|
|
||||||
|
In lyng, you create regular expressions using class `Regex` or `String.re` methods:
|
||||||
|
|
||||||
|
assert( "\d*".re is Regex )
|
||||||
|
assert( Regex("\d*") is Regex )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
We plan to add slash syntax at some point.
|
||||||
|
|
||||||
|
To check that some string matches as whole to some regex:
|
||||||
|
|
||||||
|
assert( "123".matches("\d{3}".re) )
|
||||||
|
assert( !"123".matches("\d{4}".re) )
|
||||||
|
assert( !"1234".matches("\d".re) )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
To check that _part of the string_ matches some regular expession, use _match operator_ `=~` just like in Ruby, and its
|
||||||
|
counterpart, _not match_ operator `!~`:
|
||||||
|
|
||||||
|
assert( "abc123def" =~ "\d\d\d".re )
|
||||||
|
assert( "abc" !~ "\d\d\d".re )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
When you need to find groups, and more detailed match information, use `Regex.find`:
|
||||||
|
|
||||||
|
val result = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
|
||||||
|
assert( result != null )
|
||||||
|
assertEquals( 12 .. 17, result.range )
|
||||||
|
assertEquals( "abc123", result[0] )
|
||||||
|
assertEquals( "1", result[1] )
|
||||||
|
assertEquals( "2", result[2] )
|
||||||
|
assertEquals( "3", result[3] )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Note that the object `RegexMatch`, returned by [Regex.find], behaves much like in many other languages: it provides the
|
||||||
|
index range and groups matches as indexes.
|
||||||
|
|
||||||
|
Match operator actually also provides `RegexMatch` in `$~` reserved variable (borrowed from Ruby too):
|
||||||
|
|
||||||
|
assert( "bad456 good abc123" =~ "abc(\d)(\d)(\d)".re )
|
||||||
|
assertEquals( 12 .. 17, $~.range )
|
||||||
|
assertEquals( "abc123", $~[0] )
|
||||||
|
assertEquals( "1", $~[1] )
|
||||||
|
assertEquals( "2", $~[2] )
|
||||||
|
assertEquals( "3", $~[3] )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
This is often more readable than calling `find`.
|
||||||
|
|
||||||
|
Note that `=~` and `!~` operators against strings and regular expressions are commutative, e.g. regular expression and a
|
||||||
|
string can be either left or right operator, but not both:
|
||||||
|
|
||||||
|
assert( "abc" =~ "\wc".re )
|
||||||
|
assert( "abc" !~ "\w1c".re )
|
||||||
|
assert( "a\wc".re =~ "abcd" )
|
||||||
|
assert( "a[a-z]c".re !~ "a2cd" )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!_):
|
||||||
|
|
||||||
|
assert( "cd" == "abcdef"[ "c.".re ].value )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
|
# Regex class reference
|
||||||
|
|
||||||
|
| name | description | notes |
|
||||||
|
|--------------|-------------------------------------|-------|
|
||||||
|
| matches(str) | true if the whole `str` matches | |
|
||||||
|
| find(str) | find first match in `str` or null | (1) |
|
||||||
|
| findAll(str) | find all matches in `str` as [List] | (1) |
|
||||||
|
|
||||||
|
(1)
|
||||||
|
:: See `RegexMatch` class description below
|
||||||
|
|
||||||
|
# RegexMatch
|
||||||
|
|
||||||
|
| name | description | notes |
|
||||||
|
|-------|-------------------------------------------|-------|
|
||||||
|
| range | the [Range] of the match in source string | |
|
||||||
|
| value | the value that matches | |
|
||||||
|
| [n] | [List] of group matches | (1) |
|
||||||
|
|
||||||
|
(1)
|
||||||
|
:: the [0] element is always value, [1] is group 1 match of any, etc.
|
||||||
|
|
||||||
|
[List]: List.md
|
||||||
|
|
||||||
|
[Range]: Range.md
|
||||||
|
|
||||||
Whitespace-only changes.
@@ -71,7 +71,7 @@ destructuring arrays when calling functions and lambdas:
|
|||||||
[ first, last ]
|
[ first, last ]
|
||||||
}
|
}
|
||||||
getFirstAndLast( ...(1..10) ) // see "splats" section below
|
getFirstAndLast( ...(1..10) ) // see "splats" section below
|
||||||
>>> [1, 10]
|
>>> [1,10]
|
||||||
|
|
||||||
# Splats
|
# Splats
|
||||||
|
|
||||||
@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
|
|||||||
}
|
}
|
||||||
val array = [1,2,3]
|
val array = [1,2,3]
|
||||||
testSplat("start", ...array, "end")
|
testSplat("start", ...array, "end")
|
||||||
>>> ["start", 1, 2, 3, "end"]
|
>>> [start,1,2,3,end]
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
There could be any number of splats at any positions. You can splat any other [Iterable] type:
|
There could be any number of splats at any positions. You can splat any other [Iterable] type:
|
||||||
@@ -93,7 +93,7 @@ There could be any number of splats at any positions. You can splat any other [I
|
|||||||
}
|
}
|
||||||
val range = 1..3
|
val range = 1..3
|
||||||
testSplat("start", ...range, "end")
|
testSplat("start", ...range, "end")
|
||||||
>>> ["start", 1, 2, 3, "end"]
|
>>> [start,1,2,3,end]
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -0,0 +1,26 @@
|
|||||||
|
# String
|
||||||
|
|
||||||
|
# This document is for developer notes only
|
||||||
|
|
||||||
|
--------------------------
|
||||||
|
|
||||||
|
|
||||||
|
## Interpolation proposal
|
||||||
|
|
||||||
|
"""no $iterpolation"""
|
||||||
|
|
||||||
|
val inpterpolation1 = "foo"
|
||||||
|
"${interpolation1}"
|
||||||
|
>>> "foo"
|
||||||
|
|
||||||
|
"$interpolation2"
|
||||||
|
"no $$ interpolatino"
|
||||||
|
|
||||||
|
|
||||||
|
## Regexp vs div / ?
|
||||||
|
|
||||||
|
```EBNF
|
||||||
|
regex_literal = "/", { regchar }, "/", [ flag ]
|
||||||
|
foag = "i" | "n"....
|
||||||
|
regchar = x`x`
|
||||||
|
```
|
||||||
@@ -122,6 +122,32 @@ This way, in turn, can also be shortened, as it is overly popular:
|
|||||||
The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
|
The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
|
||||||
most often not enough.
|
most often not enough.
|
||||||
|
|
||||||
|
# Exception class
|
||||||
|
|
||||||
|
Serializable class that conveys information about the exception. Important members and methods are:
|
||||||
|
|
||||||
|
| name | description |
|
||||||
|
|-------------------|--------------------------------------------------------|
|
||||||
|
| message | String message |
|
||||||
|
| stackTrace | lyng stack trace, list of `StackTraceEntry`, see below |
|
||||||
|
| printStackTrace() | format and print stack trace using println() |
|
||||||
|
|
||||||
|
## StackTraceEntry
|
||||||
|
|
||||||
|
A simple structire that stores single entry in Lyng stack, it is created automatically on exception creation:
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
class StackTraceEntry(
|
||||||
|
val sourceName: String,
|
||||||
|
val line: Int,
|
||||||
|
val column: Int,
|
||||||
|
val sourceString: String
|
||||||
|
)
|
||||||
|
```
|
||||||
|
|
||||||
|
- `sourceString` is a line extracted from sources. Note that it _is serialized and printed_, so if you want to conceal it, catch all exceptions and filter out sensitive information.
|
||||||
|
|
||||||
|
|
||||||
# Custom error classes
|
# Custom error classes
|
||||||
|
|
||||||
_this functionality is not yet released_
|
_this functionality is not yet released_
|
||||||
|
|||||||
+2
-2
@@ -183,8 +183,8 @@ Important difference from the channels or like, every time you collect the flow,
|
|||||||
// and again:
|
// and again:
|
||||||
assertEquals( result, f.toList() )
|
assertEquals( result, f.toList() )
|
||||||
|
|
||||||
>>> ["start", 1, 2, 3, 4]
|
>>> [start,1,2,3,4]
|
||||||
>>> ["start", 1, 2, 3, 4]
|
>>> [start,1,2,3,4]
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
Notice that flow's lambda is not called until actual collection is started. Cold flows are
|
Notice that flow's lambda is not called until actual collection is started. Cold flows are
|
||||||
|
|||||||
@@ -16,9 +16,15 @@ fun naiveCountHappyNumbers() {
|
|||||||
count
|
count
|
||||||
}
|
}
|
||||||
|
|
||||||
|
import lyng.time
|
||||||
|
|
||||||
//
|
//
|
||||||
// After all optimizations it takes ~120ms.
|
// After all optimizations it takes ~120ms.
|
||||||
//
|
//
|
||||||
val found = naiveCountHappyNumbers()
|
for( r in 1..100 ) {
|
||||||
println("Found happy numbers: "+found)
|
val start = Instant.now()
|
||||||
assert( found == 55252 )
|
val found = naiveCountHappyNumbers()
|
||||||
|
println("Found happy numbers: %d time %s"(found, Instant.now() - start))
|
||||||
|
assert( found == 55252 )
|
||||||
|
delay(0.1)
|
||||||
|
}
|
||||||
@@ -0,0 +1,46 @@
|
|||||||
|
# Lyng serialization
|
||||||
|
|
||||||
|
Lyng has builting binary bit-effective serialization format, called Lynon for LYng Object Notation. It is typed, binary, implements caching, automatic compression, variable-length ints, one-bit Booleans an many nice features.
|
||||||
|
|
||||||
|
It is as simple as:
|
||||||
|
|
||||||
|
import lyng.serialization
|
||||||
|
|
||||||
|
val text = "
|
||||||
|
We hold these truths to be self-evident, that all men are created equal,
|
||||||
|
that they are endowed by their Creator with certain unalienable Rights,
|
||||||
|
that among these are Life, Liberty and the pursuit of Happiness.
|
||||||
|
"
|
||||||
|
val encodedBits = Lynon.encode(text)
|
||||||
|
|
||||||
|
// decode bits source:
|
||||||
|
assertEquals( text, Lynon.decode(encodedBits) )
|
||||||
|
|
||||||
|
// compression was used automatically
|
||||||
|
assert( text.length > encodedBits.toBuffer().size )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Any class you create is serializable by default; lynon serializes first constructor fields, then any `var` member fields:
|
||||||
|
|
||||||
|
import lyng.serialization
|
||||||
|
|
||||||
|
class Point(x,y)
|
||||||
|
|
||||||
|
val p = Lynon.decode( Lynon.encode( Point(5,6) ) )
|
||||||
|
|
||||||
|
assertEquals( 5, p.x )
|
||||||
|
assertEquals( 6, p.y )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
|
just as expected.
|
||||||
|
|
||||||
|
Important is to understand that normally `Lynon.decode` wants [BitBuffer], as `Lynon.encode` produces. If you have the regular [Buffer], be sure to convert it:
|
||||||
|
|
||||||
|
buffer.toBitInput()
|
||||||
|
|
||||||
|
this possibly creates extra zero bits at the end, as bit content could be shorter than byte-grained but for the Lynon format it does not make sense. Note that when you serialize [BitBuffer], exact number of bits is written. To convert bit buffer to bytes:
|
||||||
|
|
||||||
|
Lynon.encode("hello").toBuffer()
|
||||||
|
|
||||||
|
(topic is incomplete and under construction)
|
||||||
+96
-17
@@ -16,7 +16,8 @@ __Other documents to read__ maybe after this one:
|
|||||||
- [math in Lyng](math.md)
|
- [math in Lyng](math.md)
|
||||||
- [time](time.md) and [parallelism](parallelism.md)
|
- [time](time.md) and [parallelism](parallelism.md)
|
||||||
- [parallelism] - multithreaded code, coroutines, etc.
|
- [parallelism] - multithreaded code, coroutines, etc.
|
||||||
- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [RingBuffer], [Buffer].
|
- Some class
|
||||||
|
references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
|
||||||
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
|
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
|
||||||
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
|
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
|
||||||
|
|
||||||
@@ -225,6 +226,19 @@ It works much like `also`, but is executed in the context of the source object:
|
|||||||
assertEquals(p, Point(2,3))
|
assertEquals(p, Point(2,3))
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## run
|
||||||
|
|
||||||
|
Executes a block after it returning the value passed by the block. for example, can be used with elvis operator:
|
||||||
|
|
||||||
|
var someVar = null
|
||||||
|
val result = someVar ?: run {
|
||||||
|
someVar = 121
|
||||||
|
"reset"
|
||||||
|
}
|
||||||
|
assertEquals("reset", result)
|
||||||
|
assertEquals(121, someVar)
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Math
|
## Math
|
||||||
|
|
||||||
It is rather simple, like everywhere else:
|
It is rather simple, like everywhere else:
|
||||||
@@ -261,6 +275,8 @@ Logical operation could be used the same
|
|||||||
| === | | Any | (2) |
|
| === | | Any | (2) |
|
||||||
| !== | | Any | (2) |
|
| !== | | Any | (2) |
|
||||||
| != | | Any | (1) |
|
| != | | Any | (1) |
|
||||||
|
| =~ | | | (3) |
|
||||||
|
| !~ | | | (3) |
|
||||||
| ++a, a++ | | Int | |
|
| ++a, a++ | | Int | |
|
||||||
| --a, a-- | | Int | |
|
| --a, a-- | | Int | |
|
||||||
|
|
||||||
@@ -272,6 +288,9 @@ Logical operation could be used the same
|
|||||||
singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
|
singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
|
||||||
likely referentially not equal
|
likely referentially not equal
|
||||||
|
|
||||||
|
(3)
|
||||||
|
: Implemented now in String and Regex as regular expression match and not match, see [Regex].
|
||||||
|
|
||||||
Reference quality and object equality example:
|
Reference quality and object equality example:
|
||||||
|
|
||||||
assert( null == null) // singletons
|
assert( null == null) // singletons
|
||||||
@@ -475,7 +494,8 @@ Lyng has built-in mutable array class `List` with simple literals:
|
|||||||
[1, "two", 3.33].size
|
[1, "two", 3.33].size
|
||||||
>>> 3
|
>>> 3
|
||||||
|
|
||||||
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable], many collection based methods are implemented there.
|
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
|
||||||
|
many collection based methods are implemented there.
|
||||||
|
|
||||||
Lists can contain any type of objects, lists too:
|
Lists can contain any type of objects, lists too:
|
||||||
|
|
||||||
@@ -492,21 +512,21 @@ Notice usage of indexing. You can use negative indexes to offset from the end of
|
|||||||
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]
|
||||||
>>> [1, 2, 3, 4]
|
>>> [1,2,3,4]
|
||||||
|
|
||||||
Of course, you can splat from anything that is List (or list-like, but it will be defined later):
|
Of course, you can splat from anything that is List (or list-like, but it will be defined later):
|
||||||
|
|
||||||
val a = ["one", "two"]
|
val a = ["one", "two"]
|
||||||
val b = [10.1, 20.2]
|
val b = [10.1, 20.2]
|
||||||
["start", ...b, ...a, "end"]
|
["start", ...b, ...a, "end"]
|
||||||
>>> ["start", 10.1, 20.2, "one", "two", "end"]
|
>>> [start,10.1,20.2,one,two,end]
|
||||||
|
|
||||||
Of course, you can set any list element:
|
Of course, you can set any list element:
|
||||||
|
|
||||||
val a = [1, 2, 3]
|
val a = [1, 2, 3]
|
||||||
a[1] = 200
|
a[1] = 200
|
||||||
a
|
a
|
||||||
>>> [1, 200, 3]
|
>>> [1,200,3]
|
||||||
|
|
||||||
Lists are comparable, and it works well as long as their respective elements are:
|
Lists are comparable, and it works well as long as their respective elements are:
|
||||||
|
|
||||||
@@ -596,20 +616,20 @@ Using splat arguments can simplify inserting list in list:
|
|||||||
val x = [1, 2, 3]
|
val x = [1, 2, 3]
|
||||||
x.insertAt( 1, ...[0,100,0])
|
x.insertAt( 1, ...[0,100,0])
|
||||||
x
|
x
|
||||||
>>> [1, 0, 100, 0, 2, 3]
|
>>> [1,0,100,0,2,3]
|
||||||
|
|
||||||
Note that to add to the end you still need to use `add` or positive index of the after-last element:
|
Note that to add to the end you still need to use `add` or positive index of the after-last element:
|
||||||
|
|
||||||
val x = [1,2,3]
|
val x = [1,2,3]
|
||||||
x.insertAt(3, 10)
|
x.insertAt(3, 10)
|
||||||
x
|
x
|
||||||
>>> [1, 2, 3, 10]
|
>>> [1,2,3,10]
|
||||||
|
|
||||||
but it is much simpler, and we recommend to use '+='
|
but it is much simpler, and we recommend to use '+='
|
||||||
|
|
||||||
val x = [1,2,3]
|
val x = [1,2,3]
|
||||||
x += 10
|
x += 10
|
||||||
>>> [1, 2, 3, 10]
|
>>> [1,2,3,10]
|
||||||
|
|
||||||
## Removing list items
|
## Removing list items
|
||||||
|
|
||||||
@@ -750,8 +770,8 @@ thrown.
|
|||||||
Typical builtin types that are containers (e.g. support `contains`):
|
Typical builtin types that are containers (e.g. support `contains`):
|
||||||
|
|
||||||
| class | notes |
|
| class | notes |
|
||||||
|------------|------------------------------------------------|
|
|--------------|------------------------------------------------|
|
||||||
| Collection | contains an element (1) |
|
| [Collection] | contains an element (1) |
|
||||||
| Array | faster maybe that Collection's |
|
| Array | faster maybe that Collection's |
|
||||||
| List | faster than Array's |
|
| List | faster than Array's |
|
||||||
| String | character in string or substring in string (3) |
|
| String | character in string or substring in string (3) |
|
||||||
@@ -1124,7 +1144,8 @@ See [more docs on time manipulation](time.md)
|
|||||||
|
|
||||||
# Enums
|
# Enums
|
||||||
|
|
||||||
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their _ordinal_ - [Int] value.
|
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their
|
||||||
|
_ordinal_ - [Int] value.
|
||||||
|
|
||||||
enum Color {
|
enum Color {
|
||||||
RED, GREEN, BLUE
|
RED, GREEN, BLUE
|
||||||
@@ -1139,7 +1160,8 @@ For the moment, only simple enums are implemented. Enum is a list of constants,
|
|||||||
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact than enum arrays, until `Lynon.encodeTyped` will be implemented.
|
Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact
|
||||||
|
than enum arrays, until `Lynon.encodeTyped` will be implemented.
|
||||||
|
|
||||||
# Comments
|
# Comments
|
||||||
|
|
||||||
@@ -1167,6 +1189,30 @@ See also [math operations](math.md)
|
|||||||
|
|
||||||
The type for the character objects is `Char`.
|
The type for the character objects is `Char`.
|
||||||
|
|
||||||
|
### String literal escapes
|
||||||
|
|
||||||
|
| escape | ASCII value |
|
||||||
|
|--------|-----------------------|
|
||||||
|
| \n | 0x10, newline |
|
||||||
|
| \r | 0x13, carriage return |
|
||||||
|
| \t | 0x07, tabulation |
|
||||||
|
| \\ | \ slash character |
|
||||||
|
| \" | " double quote |
|
||||||
|
|
||||||
|
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
|
||||||
|
|
||||||
|
val s = "\a"
|
||||||
|
assert(s[0] == '\')
|
||||||
|
assert(s[1] == 'a')
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
same as:
|
||||||
|
|
||||||
|
val s = "\\a"
|
||||||
|
assert(s[0] == '\')
|
||||||
|
assert(s[1] == 'a')
|
||||||
|
>>> void
|
||||||
|
|
||||||
### Char literal escapes
|
### Char literal escapes
|
||||||
|
|
||||||
Are the same as in string literals with little difference:
|
Are the same as in string literals with little difference:
|
||||||
@@ -1174,6 +1220,7 @@ Are the same as in string literals with little difference:
|
|||||||
| escape | ASCII value |
|
| escape | ASCII value |
|
||||||
|--------|-------------------|
|
|--------|-------------------|
|
||||||
| \n | 0x10, newline |
|
| \n | 0x10, newline |
|
||||||
|
| \r | 0x13, carriage return |
|
||||||
| \t | 0x07, tabulation |
|
| \t | 0x07, tabulation |
|
||||||
| \\ | \ slash character |
|
| \\ | \ slash character |
|
||||||
| \' | ' apostrophe |
|
| \' | ' apostrophe |
|
||||||
@@ -1243,9 +1290,26 @@ Open-ended ranges could be used to get start and end too:
|
|||||||
assertEquals( "pult", "catapult"[ 4.. ])
|
assertEquals( "pult", "catapult"[ 4.. ])
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
### String operations
|
### String operations
|
||||||
|
|
||||||
Concatenation is a `+`: `"hello " + name` works as expected. No confusion.
|
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
|
||||||
|
[Regex] support for strings, see the link, for example, whole string match:
|
||||||
|
|
||||||
|
assert( !"123".matches( "\d\d".re ) )
|
||||||
|
assert( "123".matches( "\d\d\d".re ) )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Extraction:
|
||||||
|
|
||||||
|
"abcd42def"[ "\d+".re ].value
|
||||||
|
>>> "42"
|
||||||
|
|
||||||
|
Part match:
|
||||||
|
|
||||||
|
assert( "abc foo def" =~ "f[oO]+".re )
|
||||||
|
assert( "foo" == $~.value )
|
||||||
|
>>> void
|
||||||
|
|
||||||
Typical set of String functions includes:
|
Typical set of String functions includes:
|
||||||
|
|
||||||
@@ -1253,6 +1317,7 @@ Typical set of String functions includes:
|
|||||||
|--------------------|------------------------------------------------------------|
|
|--------------------|------------------------------------------------------------|
|
||||||
| lower() | change case to unicode upper |
|
| lower() | change case to unicode upper |
|
||||||
| upper() | change case to unicode lower |
|
| upper() | change case to unicode lower |
|
||||||
|
| trim() | trim space chars from both ends |
|
||||||
| startsWith(prefix) | true if starts with a prefix |
|
| startsWith(prefix) | true if starts with a prefix |
|
||||||
| endsWith(prefix) | true if ends with a prefix |
|
| endsWith(prefix) | true if ends with a prefix |
|
||||||
| take(n) | get a new string from up to n first characters |
|
| take(n) | get a new string from up to n first characters |
|
||||||
@@ -1262,17 +1327,24 @@ Typical set of String functions includes:
|
|||||||
| size | size in characters like `length` because String is [Array] |
|
| size | size in characters like `length` because String is [Array] |
|
||||||
| (args...) | sprintf-like formatting, see [string formatting] |
|
| (args...) | sprintf-like formatting, see [string formatting] |
|
||||||
| [index] | character at index |
|
| [index] | character at index |
|
||||||
| [Range] | substring at range |
|
| [Range] | substring at range (2) |
|
||||||
|
| [Regex] | find first match of regex, like [Regex.find] (2) |
|
||||||
| s1 + s2 | concatenation |
|
| s1 + s2 | concatenation |
|
||||||
| s1 += s2 | self-modifying concatenation |
|
| s1 += s2 | self-modifying concatenation |
|
||||||
| toReal() | attempts to parse string as a Real value |
|
| toReal() | attempts to parse string as a Real value |
|
||||||
| toInt() | parse string to Int value |
|
| toInt() | parse string to Int value |
|
||||||
| characters() | create [List] of characters (1) |
|
| characters() | create [List] of characters (1) |
|
||||||
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
|
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
|
||||||
|
| matches(re) | matches the regular expression (2) |
|
||||||
|
| | |
|
||||||
|
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: List is mutable therefore a new copy is created on each call.
|
: List is mutable therefore a new copy is created on each call.
|
||||||
|
|
||||||
|
(2)
|
||||||
|
: See [Regex]
|
||||||
|
|
||||||
### Literals
|
### Literals
|
||||||
|
|
||||||
String literal could be multiline:
|
String literal could be multiline:
|
||||||
@@ -1292,7 +1364,8 @@ if blank, will be removed too, for example:
|
|||||||
>>> This is a second line.
|
>>> This is a second line.
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()` technique, but simpler ;)
|
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()`
|
||||||
|
technique, but simpler ;)
|
||||||
|
|
||||||
# Built-in functions
|
# Built-in functions
|
||||||
|
|
||||||
@@ -1311,7 +1384,7 @@ See [math functions](math.md). Other general purpose functions are:
|
|||||||
| flow {} | create flow sequence, see [parallelism] |
|
| flow {} | create flow sequence, see [parallelism] |
|
||||||
| delay, launch, yield | see [parallelism] |
|
| delay, launch, yield | see [parallelism] |
|
||||||
| cached(builder) | remembers builder() on first invocation and return it then |
|
| cached(builder) | remembers builder() on first invocation and return it then |
|
||||||
|
| let, also, apply, run | see above, flow controls |
|
||||||
|
|
||||||
# Built-in constants
|
# Built-in constants
|
||||||
|
|
||||||
@@ -1330,7 +1403,7 @@ See [math functions](math.md). Other general purpose functions are:
|
|||||||
|
|
||||||
[Range]: Range.md
|
[Range]: Range.md
|
||||||
|
|
||||||
[String]: String.md
|
[String]: development/String.md
|
||||||
|
|
||||||
[string formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
|
[string formatting]: https://github.com/sergeych/mp_stools?tab=readme-ov-file#sprintf-syntax-summary
|
||||||
|
|
||||||
@@ -1343,3 +1416,9 @@ See [math functions](math.md). Other general purpose functions are:
|
|||||||
[parallelism]: parallelism.md
|
[parallelism]: parallelism.md
|
||||||
|
|
||||||
[RingBuffer]: RingBuffer.md
|
[RingBuffer]: RingBuffer.md
|
||||||
|
|
||||||
|
[Collection]: Collection.md
|
||||||
|
|
||||||
|
[Array]: Array.md
|
||||||
|
|
||||||
|
[Regex]: Regex.md
|
||||||
@@ -1,10 +1,10 @@
|
|||||||
[versions]
|
[versions]
|
||||||
agp = "8.5.2"
|
agp = "8.5.2"
|
||||||
clikt = "5.0.3"
|
clikt = "5.0.3"
|
||||||
kotlin = "2.1.21"
|
kotlin = "2.2.20"
|
||||||
android-minSdk = "24"
|
android-minSdk = "24"
|
||||||
android-compileSdk = "34"
|
android-compileSdk = "34"
|
||||||
kotlinx-coroutines = "1.9.0"
|
kotlinx-coroutines = "1.10.2"
|
||||||
mp_bintools = "0.1.12"
|
mp_bintools = "0.1.12"
|
||||||
firebaseCrashlyticsBuildtools = "3.0.3"
|
firebaseCrashlyticsBuildtools = "3.0.3"
|
||||||
okioVersion = "3.10.2"
|
okioVersion = "3.10.2"
|
||||||
|
|||||||
@@ -16,7 +16,7 @@
|
|||||||
*/
|
*/
|
||||||
|
|
||||||
plugins {
|
plugins {
|
||||||
kotlin("multiplatform") version "2.1.21"
|
kotlin("multiplatform") version "2.2.20"
|
||||||
}
|
}
|
||||||
|
|
||||||
group = "net.sergeych"
|
group = "net.sergeych"
|
||||||
|
|||||||
@@ -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 = "0.8.12-SNAPSHOT"
|
version = "0.9.3"
|
||||||
|
|
||||||
buildscript {
|
buildscript {
|
||||||
repositories {
|
repositories {
|
||||||
@@ -37,7 +37,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.0"
|
kotlin("plugin.serialization") version "2.1.0"
|
||||||
id("com.codingfeline.buildkonfig") version "0.17.1"
|
id("com.codingfeline.buildkonfig") version "0.17.1"
|
||||||
`maven-publish`
|
`maven-publish`
|
||||||
}
|
}
|
||||||
@@ -62,10 +62,14 @@ kotlin {
|
|||||||
jvmTarget.set(JvmTarget.JVM_11)
|
jvmTarget.set(JvmTarget.JVM_11)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
// iosX64()
|
iosX64()
|
||||||
// iosArm64()
|
iosArm64()
|
||||||
// iosSimulatorArm64()
|
iosSimulatorArm64()
|
||||||
|
macosX64()
|
||||||
|
macosArm64()
|
||||||
|
mingwX64()
|
||||||
linuxX64()
|
linuxX64()
|
||||||
|
linuxArm64()
|
||||||
js {
|
js {
|
||||||
browser()
|
browser()
|
||||||
nodejs()
|
nodejs()
|
||||||
@@ -79,9 +83,9 @@ kotlin {
|
|||||||
sourceSets {
|
sourceSets {
|
||||||
all {
|
all {
|
||||||
languageSettings.optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
|
languageSettings.optIn("kotlinx.coroutines.ExperimentalCoroutinesApi")
|
||||||
languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
|
|
||||||
languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
|
languageSettings.optIn("kotlin.ExperimentalUnsignedTypes")
|
||||||
languageSettings.optIn("kotlin.coroutines.DelicateCoroutinesApi")
|
languageSettings.optIn("kotlin.coroutines.DelicateCoroutinesApi")
|
||||||
|
languageSettings.optIn("kotlin.contracts.ExperimentalContracts")
|
||||||
languageSettings.optIn("kotlinx.coroutines.flow.DelicateCoroutinesApi")
|
languageSettings.optIn("kotlinx.coroutines.flow.DelicateCoroutinesApi")
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -138,6 +142,7 @@ publishing {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
//mavenPublishing {
|
//mavenPublishing {
|
||||||
// publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
|
// publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
|
||||||
//
|
//
|
||||||
|
|||||||
@@ -63,7 +63,7 @@ data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) :
|
|||||||
return list.map { it.toKotlin(scope) }
|
return list.map { it.toKotlin(scope) }
|
||||||
}
|
}
|
||||||
|
|
||||||
fun inspect(): String = list.joinToString(", ") { it.inspect() }
|
suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
val EMPTY = Arguments(emptyList())
|
val EMPTY = Arguments(emptyList())
|
||||||
|
|||||||
@@ -47,7 +47,7 @@ class Compiler(
|
|||||||
|
|
||||||
private val codeContexts = mutableListOf<CodeContext>(CodeContext.Module(null))
|
private val codeContexts = mutableListOf<CodeContext>(CodeContext.Module(null))
|
||||||
|
|
||||||
private suspend fun <T>inCodeContext(context: CodeContext,f: suspend ()->T): T {
|
private suspend fun <T> inCodeContext(context: CodeContext, f: suspend () -> T): T {
|
||||||
return try {
|
return try {
|
||||||
codeContexts.add(context)
|
codeContexts.add(context)
|
||||||
f()
|
f()
|
||||||
@@ -211,11 +211,32 @@ class Compiler(
|
|||||||
private suspend fun parseTerm(): Accessor? {
|
private suspend fun parseTerm(): Accessor? {
|
||||||
var operand: Accessor? = null
|
var operand: Accessor? = null
|
||||||
|
|
||||||
|
// newlines _before_
|
||||||
|
cc.skipWsTokens()
|
||||||
|
|
||||||
while (true) {
|
while (true) {
|
||||||
val t = cc.next()
|
val t = cc.next()
|
||||||
val startPos = t.pos
|
val startPos = t.pos
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
Token.Type.NEWLINE, Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
|
// Token.Type.NEWLINE, Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT-> {
|
||||||
|
// continue
|
||||||
|
// }
|
||||||
|
|
||||||
|
// very special case chained calls: call()<NL>.call2 {}.call3()
|
||||||
|
Token.Type.NEWLINE -> {
|
||||||
|
val saved = cc.savePos()
|
||||||
|
if (cc.peekNextNonWhitespace().type == Token.Type.DOT) {
|
||||||
|
// chained call continue from it
|
||||||
|
continue
|
||||||
|
} else {
|
||||||
|
// restore position and stop parsing as a term:
|
||||||
|
cc.restorePos(saved)
|
||||||
|
cc.previous()
|
||||||
|
return operand
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
|
||||||
cc.previous()
|
cc.previous()
|
||||||
return operand
|
return operand
|
||||||
}
|
}
|
||||||
@@ -376,6 +397,13 @@ class Compiler(
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
"throw" -> {
|
||||||
|
val s = parseThrowStatement()
|
||||||
|
operand = Accessor {
|
||||||
|
s.execute(it).asReadonly
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
else -> operand?.let { left ->
|
else -> operand?.let { left ->
|
||||||
// selector: <lvalue>, '.' , <id>
|
// selector: <lvalue>, '.' , <id>
|
||||||
// we replace operand with selector code, that
|
// we replace operand with selector code, that
|
||||||
@@ -461,7 +489,14 @@ class Compiler(
|
|||||||
// range operator
|
// range operator
|
||||||
val isEndInclusive = t.type == Token.Type.DOTDOT
|
val isEndInclusive = t.type == Token.Type.DOTDOT
|
||||||
val left = operand
|
val left = operand
|
||||||
val right = parseExpression()
|
// if it is an open end range, then the end of line could be here that we do not want
|
||||||
|
// to skip in parseExpression:
|
||||||
|
val current = cc.current()
|
||||||
|
val right =
|
||||||
|
if (current.type == Token.Type.NEWLINE || current.type == Token.Type.SINLGE_LINE_COMMENT)
|
||||||
|
null
|
||||||
|
else
|
||||||
|
parseExpression()
|
||||||
operand = Accessor {
|
operand = Accessor {
|
||||||
ObjRange(
|
ObjRange(
|
||||||
left?.getter?.invoke(it)?.value ?: ObjNull,
|
left?.getter?.invoke(it)?.value ?: ObjNull,
|
||||||
@@ -588,6 +623,8 @@ class Compiler(
|
|||||||
var endTokenType: Token.Type? = null
|
var endTokenType: Token.Type? = null
|
||||||
val startPos = cc.savePos()
|
val startPos = cc.savePos()
|
||||||
|
|
||||||
|
cc.skipWsTokens()
|
||||||
|
|
||||||
while (endTokenType == null) {
|
while (endTokenType == null) {
|
||||||
var t = cc.next()
|
var t = cc.next()
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
@@ -645,7 +682,7 @@ class Compiler(
|
|||||||
|
|
||||||
// important: valid argument list continues with ',' and ends with '->' or ')'
|
// important: valid argument list continues with ',' and ends with '->' or ')'
|
||||||
// otherwise it is not an argument list:
|
// otherwise it is not an argument list:
|
||||||
when (val tt = cc.next().type) {
|
when (val tt = cc.nextNonWhitespace().type) {
|
||||||
Token.Type.RPAREN -> {
|
Token.Type.RPAREN -> {
|
||||||
// end of arguments
|
// end of arguments
|
||||||
endTokenType = tt
|
endTokenType = tt
|
||||||
@@ -759,7 +796,7 @@ class Compiler(
|
|||||||
val v = left.getter(context)
|
val v = left.getter(context)
|
||||||
if (v.value == ObjNull && isOptional) return@Accessor v.value.asReadonly
|
if (v.value == ObjNull && isOptional) return@Accessor v.value.asReadonly
|
||||||
v.value.callOn(
|
v.value.callOn(
|
||||||
context.copy(
|
context.createChildScope(
|
||||||
context.pos,
|
context.pos,
|
||||||
args.toArguments(context, detectedBlockArgument)
|
args.toArguments(context, detectedBlockArgument)
|
||||||
// Arguments(
|
// Arguments(
|
||||||
@@ -851,20 +888,21 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Suppress("SameParameterValue")
|
||||||
private fun parseNumber(isPlus: Boolean): Obj {
|
private fun parseNumber(isPlus: Boolean): Obj {
|
||||||
return parseNumberOrNull(isPlus) ?: throw ScriptError(cc.currentPos(), "Expecting number")
|
return parseNumberOrNull(isPlus) ?: throw ScriptError(cc.currentPos(), "Expecting number")
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
|
suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
|
||||||
val extraArgs = parseArgsOrNull()
|
val extraArgs = parseArgsOrNull()
|
||||||
println("annotation ${t.value}: args: $extraArgs")
|
// println("annotation ${t.value}: args: $extraArgs")
|
||||||
return { scope, name, body ->
|
return { scope, name, body ->
|
||||||
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
|
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
|
||||||
val required = listOf(name, body)
|
val required = listOf(name, body)
|
||||||
val args = extras?.let { required + it } ?: required
|
val args = extras?.let { required + it } ?: required
|
||||||
val fn = scope.get(t.value)?.value ?: scope.raiseSymbolNotFound("annotation not found: ${t.value}")
|
val fn = scope.get(t.value)?.value ?: scope.raiseSymbolNotFound("annotation not found: ${t.value}")
|
||||||
if (fn !is Statement) scope.raiseIllegalArgument("annotation must be callable, got ${fn.objClass}")
|
if (fn !is Statement) scope.raiseIllegalArgument("annotation must be callable, got ${fn.objClass}")
|
||||||
(fn.execute(scope.copy(Arguments(args))) as? Statement)
|
(fn.execute(scope.createChildScope(Arguments(args))) as? Statement)
|
||||||
?: scope.raiseClassCastError("function annotation must return callable")
|
?: scope.raiseClassCastError("function annotation must return callable")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -948,7 +986,7 @@ class Compiler(
|
|||||||
|
|
||||||
private suspend fun parseWhenStatement(): Statement {
|
private suspend fun parseWhenStatement(): Statement {
|
||||||
// has a value, when(value) ?
|
// has a value, when(value) ?
|
||||||
var t = cc.skipWsTokens()
|
var t = cc.nextNonWhitespace()
|
||||||
return if (t.type == Token.Type.LPAREN) {
|
return if (t.type == Token.Type.LPAREN) {
|
||||||
// when(value)
|
// when(value)
|
||||||
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
|
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
|
||||||
@@ -963,6 +1001,7 @@ class Compiler(
|
|||||||
// condition could be a value, in and is clauses:
|
// condition could be a value, in and is clauses:
|
||||||
// parse several conditions for one then clause
|
// parse several conditions for one then clause
|
||||||
|
|
||||||
|
|
||||||
// loop cases
|
// loop cases
|
||||||
outer@ while (true) {
|
outer@ while (true) {
|
||||||
|
|
||||||
@@ -971,7 +1010,7 @@ class Compiler(
|
|||||||
|
|
||||||
// loop conditions
|
// loop conditions
|
||||||
while (true) {
|
while (true) {
|
||||||
t = cc.skipWsTokens()
|
t = cc.nextNonWhitespace()
|
||||||
|
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
Token.Type.IN,
|
Token.Type.IN,
|
||||||
@@ -1158,7 +1197,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (exceptionObject != null) {
|
if (exceptionObject != null) {
|
||||||
val catchContext = this.copy(pos = cdata.catchVar.pos)
|
val catchContext = this.createChildScope(pos = cdata.catchVar.pos)
|
||||||
catchContext.addItem(cdata.catchVar.value, false, objException)
|
catchContext.addItem(cdata.catchVar.value, false, objException)
|
||||||
result = cdata.block.execute(catchContext)
|
result = cdata.block.execute(catchContext)
|
||||||
isCaught = true
|
isCaught = true
|
||||||
@@ -1184,11 +1223,11 @@ class Compiler(
|
|||||||
cc.skipTokenOfType(Token.Type.LBRACE)
|
cc.skipTokenOfType(Token.Type.LBRACE)
|
||||||
|
|
||||||
do {
|
do {
|
||||||
val t = cc.skipWsTokens()
|
val t = cc.nextNonWhitespace()
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
Token.Type.ID -> {
|
Token.Type.ID -> {
|
||||||
names += t.value
|
names += t.value
|
||||||
val t1 = cc.skipWsTokens()
|
val t1 = cc.nextNonWhitespace()
|
||||||
when (t1.type) {
|
when (t1.type) {
|
||||||
Token.Type.COMMA ->
|
Token.Type.COMMA ->
|
||||||
continue
|
continue
|
||||||
@@ -1274,7 +1313,7 @@ class Compiler(
|
|||||||
// accessors, constructor registration, etc.
|
// accessors, constructor registration, etc.
|
||||||
addItem(className, false, newClass)
|
addItem(className, false, newClass)
|
||||||
if (initScope.isNotEmpty()) {
|
if (initScope.isNotEmpty()) {
|
||||||
val classScope = copy(newThisObj = newClass)
|
val classScope = createChildScope(newThisObj = newClass)
|
||||||
newClass.classScope = classScope
|
newClass.classScope = classScope
|
||||||
for (s in initScope)
|
for (s in initScope)
|
||||||
s.execute(classScope)
|
s.execute(classScope)
|
||||||
@@ -1327,8 +1366,8 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
return statement(body.pos) { ctx ->
|
return statement(body.pos) { cxt ->
|
||||||
val forContext = ctx.copy(start)
|
val forContext = cxt.createChildScope(start)
|
||||||
|
|
||||||
// loop var: StoredObject
|
// loop var: StoredObject
|
||||||
val loopSO = forContext.addItem(tVar.value, true, ObjNull)
|
val loopSO = forContext.addItem(tVar.value, true, ObjNull)
|
||||||
@@ -1339,15 +1378,28 @@ class Compiler(
|
|||||||
if (sourceObj is ObjRange && sourceObj.isIntRange) {
|
if (sourceObj is ObjRange && sourceObj.isIntRange) {
|
||||||
loopIntRange(
|
loopIntRange(
|
||||||
forContext,
|
forContext,
|
||||||
sourceObj.start!!.toInt(),
|
sourceObj.start!!.toLong(),
|
||||||
if (sourceObj.isEndInclusive) sourceObj.end!!.toInt() + 1 else sourceObj.end!!.toInt(),
|
if (sourceObj.isEndInclusive)
|
||||||
loopSO, body, elseStatement, label, canBreak
|
sourceObj.end!!.toLong() + 1
|
||||||
|
else
|
||||||
|
sourceObj.end!!.toLong(),
|
||||||
|
loopSO,
|
||||||
|
body,
|
||||||
|
elseStatement,
|
||||||
|
label,
|
||||||
|
canBreak
|
||||||
)
|
)
|
||||||
} else if (sourceObj.isInstanceOf(ObjIterable)) {
|
} else if (sourceObj.isInstanceOf(ObjIterable)) {
|
||||||
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
|
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
|
||||||
} else {
|
} else {
|
||||||
val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() }
|
val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() }
|
||||||
.getOrElse { throw ScriptError(tOp.pos, "object is not enumerable: no size", it) }
|
.getOrElse {
|
||||||
|
throw ScriptError(
|
||||||
|
tOp.pos,
|
||||||
|
"object is not enumerable: no size in $sourceObj",
|
||||||
|
it
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
var result: Obj = ObjVoid
|
var result: Obj = ObjVoid
|
||||||
var breakCaught = false
|
var breakCaught = false
|
||||||
@@ -1357,7 +1409,7 @@ class Compiler(
|
|||||||
.getOrElse {
|
.getOrElse {
|
||||||
throw ScriptError(
|
throw ScriptError(
|
||||||
tOp.pos,
|
tOp.pos,
|
||||||
"object is not enumerable: no index access for ${sourceObj.inspect()}",
|
"object is not enumerable: no index access for ${sourceObj.inspect(cxt)}",
|
||||||
it
|
it
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -1384,7 +1436,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (!breakCaught && elseStatement != null) {
|
if (!breakCaught && elseStatement != null) {
|
||||||
result = elseStatement.execute(ctx)
|
result = elseStatement.execute(cxt)
|
||||||
}
|
}
|
||||||
result
|
result
|
||||||
}
|
}
|
||||||
@@ -1396,7 +1448,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
|
|
||||||
private suspend fun loopIntRange(
|
private suspend fun loopIntRange(
|
||||||
forScope: Scope, start: Int, end: Int, loopVar: ObjRecord,
|
forScope: Scope, start: Long, end: Long, loopVar: ObjRecord,
|
||||||
body: Statement, elseStatement: Statement?, label: String?, catchBreak: Boolean
|
body: Statement, elseStatement: Statement?, label: String?, catchBreak: Boolean
|
||||||
): Obj {
|
): Obj {
|
||||||
var result: Obj = ObjVoid
|
var result: Obj = ObjVoid
|
||||||
@@ -1404,7 +1456,7 @@ class Compiler(
|
|||||||
loopVar.value = iVar
|
loopVar.value = iVar
|
||||||
if (catchBreak) {
|
if (catchBreak) {
|
||||||
for (i in start..<end) {
|
for (i in start..<end) {
|
||||||
iVar.value = i.toLong()
|
iVar.value = i//.toLong()
|
||||||
try {
|
try {
|
||||||
result = body.execute(forScope)
|
result = body.execute(forScope)
|
||||||
} catch (lbe: LoopBreakContinueException) {
|
} catch (lbe: LoopBreakContinueException) {
|
||||||
@@ -1416,7 +1468,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
for (i in start.toLong()..<end.toLong()) {
|
for (i in start..<end) {
|
||||||
iVar.value = i
|
iVar.value = i
|
||||||
result = body.execute(forScope)
|
result = body.execute(forScope)
|
||||||
}
|
}
|
||||||
@@ -1484,7 +1536,7 @@ class Compiler(
|
|||||||
var result: Obj = ObjVoid
|
var result: Obj = ObjVoid
|
||||||
lateinit var doScope: Scope
|
lateinit var doScope: Scope
|
||||||
do {
|
do {
|
||||||
doScope = it.copy().apply { skipScopeCreation = true }
|
doScope = it.createChildScope().apply { skipScopeCreation = true }
|
||||||
try {
|
try {
|
||||||
result = body.execute(doScope)
|
result = body.execute(doScope)
|
||||||
} catch (e: LoopBreakContinueException) {
|
} catch (e: LoopBreakContinueException) {
|
||||||
@@ -1630,7 +1682,7 @@ class Compiler(
|
|||||||
|
|
||||||
cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
|
cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
|
||||||
// could be else block:
|
// could be else block:
|
||||||
val t2 = cc.next()
|
val t2 = cc.nextNonWhitespace()
|
||||||
|
|
||||||
// we generate different statements: optimization
|
// we generate different statements: optimization
|
||||||
return if (t2.type == Token.Type.ID && t2.value == "else") {
|
return if (t2.type == Token.Type.ID && t2.value == "else") {
|
||||||
@@ -1721,7 +1773,7 @@ class Compiler(
|
|||||||
val fnCreateStatement = statement(start) { context ->
|
val fnCreateStatement = statement(start) { context ->
|
||||||
// we added fn in the context. now we must save closure
|
// we added fn in the context. now we must save closure
|
||||||
// for the function, unless we're in the class scope:
|
// for the function, unless we're in the class scope:
|
||||||
if( isStatic || parentContext !is CodeContext.ClassBody)
|
if (isStatic || parentContext !is CodeContext.ClassBody)
|
||||||
closure = context
|
closure = context
|
||||||
|
|
||||||
val annotatedFnBody = annotation?.invoke(context, ObjString(name), fnBody)
|
val annotatedFnBody = annotation?.invoke(context, ObjString(name), fnBody)
|
||||||
@@ -1764,7 +1816,7 @@ class Compiler(
|
|||||||
val block = parseScript()
|
val block = parseScript()
|
||||||
return statement(startPos) {
|
return statement(startPos) {
|
||||||
// block run on inner context:
|
// block run on inner context:
|
||||||
block.execute(if (it.skipScopeCreation) it else it.copy(startPos))
|
block.execute(if (it.skipScopeCreation) it else it.createChildScope(startPos))
|
||||||
}.also {
|
}.also {
|
||||||
val t1 = cc.next()
|
val t1 = cc.next()
|
||||||
if (t1.type != Token.Type.RBRACE)
|
if (t1.type != Token.Type.RBRACE)
|
||||||
@@ -1957,6 +2009,8 @@ class Compiler(
|
|||||||
Operator.simple(Token.Type.NEQ, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) != 0) },
|
Operator.simple(Token.Type.NEQ, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) != 0) },
|
||||||
Operator.simple(Token.Type.REF_EQ, lastPriority) { _, a, b -> ObjBool(a === b) },
|
Operator.simple(Token.Type.REF_EQ, lastPriority) { _, a, b -> ObjBool(a === b) },
|
||||||
Operator.simple(Token.Type.REF_NEQ, lastPriority) { _, a, b -> ObjBool(a !== b) },
|
Operator.simple(Token.Type.REF_NEQ, lastPriority) { _, a, b -> ObjBool(a !== b) },
|
||||||
|
Operator.simple(Token.Type.MATCH, lastPriority) { s, a, b -> a.operatorMatch(s,b) },
|
||||||
|
Operator.simple(Token.Type.NOTMATCH, lastPriority) { s, a, b -> a.operatorNotMatch(s,b) },
|
||||||
// relational <=,... 5
|
// relational <=,... 5
|
||||||
Operator.simple(Token.Type.LTE, ++lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) <= 0) },
|
Operator.simple(Token.Type.LTE, ++lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) <= 0) },
|
||||||
Operator.simple(Token.Type.LT, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) < 0) },
|
Operator.simple(Token.Type.LT, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) < 0) },
|
||||||
@@ -1968,7 +2022,15 @@ class Compiler(
|
|||||||
Operator.simple(Token.Type.IS, lastPriority) { _, a, b -> ObjBool(a.isInstanceOf(b)) },
|
Operator.simple(Token.Type.IS, lastPriority) { _, a, b -> ObjBool(a.isInstanceOf(b)) },
|
||||||
Operator.simple(Token.Type.NOTIS, lastPriority) { _, a, b -> ObjBool(!a.isInstanceOf(b)) },
|
Operator.simple(Token.Type.NOTIS, lastPriority) { _, a, b -> ObjBool(!a.isInstanceOf(b)) },
|
||||||
|
|
||||||
Operator.simple(Token.Type.ELVIS, ++lastPriority) { _, a, b -> if (a == ObjNull) b else a },
|
Operator(Token.Type.ELVIS, ++lastPriority, 2) { _: Pos, a: Accessor, b: Accessor ->
|
||||||
|
Accessor {
|
||||||
|
val aa = a.getter(it).value
|
||||||
|
(
|
||||||
|
if (aa != ObjNull) aa
|
||||||
|
else b.getter(it).value
|
||||||
|
).asReadonly
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
// shuttle <=> 6
|
// shuttle <=> 6
|
||||||
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
|
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
|
||||||
|
|||||||
@@ -39,7 +39,6 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
fun next() =
|
fun next() =
|
||||||
if (currentIndex < tokens.size) tokens[currentIndex++]
|
if (currentIndex < tokens.size) tokens[currentIndex++]
|
||||||
else Token("", tokens.last().pos, Token.Type.EOF)
|
else Token("", tokens.last().pos, Token.Type.EOF)
|
||||||
// throw IllegalStateException("No more tokens")
|
|
||||||
|
|
||||||
fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
|
fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
|
||||||
|
|
||||||
@@ -131,6 +130,28 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
previous()
|
previous()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fun nextNonWhitespace(): Token {
|
||||||
|
while (true) {
|
||||||
|
val t = next()
|
||||||
|
if (t.type !in wstokens) return t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Find next non-whitespace token and return it. The token is not extracted,
|
||||||
|
* is will be returned on [next] call.
|
||||||
|
* @return next non-whitespace token without extracting it from tokens list
|
||||||
|
*/
|
||||||
|
fun peekNextNonWhitespace(): Token {
|
||||||
|
while (true) {
|
||||||
|
val t = next()
|
||||||
|
if (t.type !in wstokens) {
|
||||||
|
previous()
|
||||||
|
return t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
|
inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
|
||||||
val t = next()
|
val t = next()
|
||||||
@@ -143,6 +164,7 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Suppress("NOTHING_TO_INLINE")
|
||||||
inline fun addBreak() {
|
inline fun addBreak() {
|
||||||
breakFound = true
|
breakFound = true
|
||||||
}
|
}
|
||||||
@@ -207,7 +229,7 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
while (current().type in wstokens) {
|
while (current().type in wstokens) {
|
||||||
next()
|
next()
|
||||||
}
|
}
|
||||||
return next()
|
return current()
|
||||||
}
|
}
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
|
|||||||
@@ -20,10 +20,10 @@ package net.sergeych.lyng
|
|||||||
val digitsSet = ('0'..'9').toSet()
|
val digitsSet = ('0'..'9').toSet()
|
||||||
val digits = { d: Char -> d in digitsSet }
|
val digits = { d: Char -> d in digitsSet }
|
||||||
val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
|
val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
|
||||||
val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() }
|
val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '$' || d == '~' }
|
||||||
|
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
val idFirstChars = { d: Char -> d.isLetter() || d == '_' }
|
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
|
||||||
|
|
||||||
fun parseLyng(source: Source): List<Token> {
|
fun parseLyng(source: Source): List<Token> {
|
||||||
val p = Parser(fromPos = source.startPos)
|
val p = Parser(fromPos = source.startPos)
|
||||||
@@ -67,13 +67,16 @@ private class Parser(fromPos: Pos) {
|
|||||||
pos.advance()
|
pos.advance()
|
||||||
Token("===", from, Token.Type.REF_EQ)
|
Token("===", from, Token.Type.REF_EQ)
|
||||||
}
|
}
|
||||||
|
|
||||||
else -> Token("==", from, Token.Type.EQ)
|
else -> Token("==", from, Token.Type.EQ)
|
||||||
}
|
}
|
||||||
} else if( currentChar == '>' ) {
|
} else if (currentChar == '>') {
|
||||||
pos.advance()
|
pos.advance()
|
||||||
Token("=>", from, Token.Type.EQARROW)
|
Token("=>", from, Token.Type.EQARROW)
|
||||||
}
|
} else if (currentChar == '~') {
|
||||||
else
|
pos.advance()
|
||||||
|
Token("=~", from, Token.Type.MATCH)
|
||||||
|
} else
|
||||||
Token("=", from, Token.Type.ASSIGN)
|
Token("=", from, Token.Type.ASSIGN)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -227,6 +230,9 @@ private class Parser(fromPos: Pos) {
|
|||||||
Token("!==", from, Token.Type.REF_NEQ)
|
Token("!==", from, Token.Type.REF_NEQ)
|
||||||
} else
|
} else
|
||||||
Token("!=", from, Token.Type.NEQ)
|
Token("!=", from, Token.Type.NEQ)
|
||||||
|
} else if (currentChar == '~') {
|
||||||
|
pos.advance()
|
||||||
|
Token("!~", from, Token.Type.NOTMATCH)
|
||||||
} else
|
} else
|
||||||
Token("!", from, Token.Type.NOT)
|
Token("!", from, Token.Type.NOT)
|
||||||
}
|
}
|
||||||
@@ -267,7 +273,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
|
|
||||||
in digitsSet -> {
|
in digitsSet -> {
|
||||||
pos.back()
|
pos.back()
|
||||||
decodeNumber(loadChars { it in digitsSet || it == '_'}, from)
|
decodeNumber(loadChars { it in digitsSet || it == '_' }, from)
|
||||||
}
|
}
|
||||||
|
|
||||||
'\'' -> {
|
'\'' -> {
|
||||||
@@ -291,7 +297,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
'?' -> {
|
'?' -> {
|
||||||
when(currentChar.also { pos.advance() }) {
|
when (currentChar.also { pos.advance() }) {
|
||||||
':' -> Token("??", from, Token.Type.ELVIS)
|
':' -> Token("??", from, Token.Type.ELVIS)
|
||||||
'?' -> Token("??", from, Token.Type.ELVIS)
|
'?' -> Token("??", from, Token.Type.ELVIS)
|
||||||
'.' -> Token("?.", from, Token.Type.NULL_COALESCE)
|
'.' -> Token("?.", from, Token.Type.NULL_COALESCE)
|
||||||
@@ -310,7 +316,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
// Labels processing is complicated!
|
// Labels processing is complicated!
|
||||||
// some@ statement: label 'some', ID 'statement'
|
// some@ statement: label 'some', ID 'statement'
|
||||||
// statement@some: ID 'statement', LABEL 'some'!
|
// statement@some: ID 'statement', LABEL 'some'!
|
||||||
if (ch.isLetter() || ch == '_') {
|
if (idNextChars(ch)) {
|
||||||
val text = ch + loadChars(idNextChars)
|
val text = ch + loadChars(idNextChars)
|
||||||
if (currentChar == '@') {
|
if (currentChar == '@') {
|
||||||
pos.advance()
|
pos.advance()
|
||||||
@@ -395,25 +401,24 @@ private class Parser(fromPos: Pos) {
|
|||||||
private fun fixMultilineStringLiteral(source: String): String {
|
private fun fixMultilineStringLiteral(source: String): String {
|
||||||
val sizes = mutableListOf<Int>()
|
val sizes = mutableListOf<Int>()
|
||||||
val lines = source.lines().toMutableList()
|
val lines = source.lines().toMutableList()
|
||||||
if( lines.size == 0 ) return ""
|
if (lines.size == 0) return ""
|
||||||
if( lines[0].isBlank() ) lines.removeFirst()
|
if (lines[0].isBlank()) lines.removeFirst()
|
||||||
if( lines.isEmpty()) return ""
|
if (lines.isEmpty()) return ""
|
||||||
if( lines.last().isBlank() ) lines.removeLast()
|
if (lines.last().isBlank()) lines.removeLast()
|
||||||
|
|
||||||
val normalized = lines.map { l ->
|
val normalized = lines.map { l ->
|
||||||
if( l.isBlank() ) {
|
if (l.isBlank()) {
|
||||||
sizes.add(-1)
|
sizes.add(-1)
|
||||||
""
|
""
|
||||||
}
|
} else {
|
||||||
else {
|
|
||||||
val margin = leftMargin(l)
|
val margin = leftMargin(l)
|
||||||
sizes += margin
|
sizes += margin
|
||||||
" ".repeat(margin) + l.trim()
|
" ".repeat(margin) + l.trim()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
val commonMargin = sizes.filter { it >= 0 }.min()
|
val commonMargin = sizes.filter { it >= 0 }.min()
|
||||||
val fixed = if( commonMargin < 1 ) lines else normalized.map {
|
val fixed = if (commonMargin < 1) lines else normalized.map {
|
||||||
if( it.isBlank() ) "" else it.drop(commonMargin)
|
if (it.isBlank()) "" else it.drop(commonMargin)
|
||||||
}
|
}
|
||||||
return fixed.joinToString("\n")
|
return fixed.joinToString("\n")
|
||||||
}
|
}
|
||||||
@@ -433,15 +438,34 @@ private class Parser(fromPos: Pos) {
|
|||||||
'\\' -> {
|
'\\' -> {
|
||||||
pos.advance() ?: raise("unterminated string")
|
pos.advance() ?: raise("unterminated string")
|
||||||
when (currentChar) {
|
when (currentChar) {
|
||||||
'n' -> sb.append('\n')
|
'n' -> {
|
||||||
'r' -> sb.append('\r')
|
sb.append('\n'); pos.advance()
|
||||||
't' -> sb.append('\t')
|
}
|
||||||
'"' -> sb.append('"')
|
|
||||||
else -> sb.append('\\').append(currentChar)
|
'r' -> {
|
||||||
|
sb.append('\r'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
't' -> {
|
||||||
|
sb.append('\t'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'"' -> {
|
||||||
|
sb.append('"'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'\\' -> {
|
||||||
|
sb.append('\\'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
sb.append('\\').append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
'\n', '\r'-> {
|
'\n', '\r' -> {
|
||||||
newlineDetected = true
|
newlineDetected = true
|
||||||
sb.append(currentChar)
|
sb.append(currentChar)
|
||||||
pos.advance()
|
pos.advance()
|
||||||
@@ -455,7 +479,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
}
|
}
|
||||||
pos.advance()
|
pos.advance()
|
||||||
|
|
||||||
val result = sb.toString().let { if( newlineDetected ) fixMultilineStringLiteral(it) else it }
|
val result = sb.toString().let { if (newlineDetected) fixMultilineStringLiteral(it) else it }
|
||||||
|
|
||||||
return Token(result, start, Token.Type.STRING)
|
return Token(result, start, Token.Type.STRING)
|
||||||
}
|
}
|
||||||
@@ -534,7 +558,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
|
|
||||||
init {
|
init {
|
||||||
// skip shebang
|
// skip shebang
|
||||||
if( pos.readFragment("#!") )
|
if (pos.readFragment("#!"))
|
||||||
loadToEndOfLine()
|
loadToEndOfLine()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -28,7 +28,9 @@ data class Pos(val source: Source, val line: Int, val column: Int) {
|
|||||||
else if( line > 0) Pos(source, line-1, source.lines[line-1].length - 1)
|
else if( line > 0) Pos(source, line-1, source.lines[line-1].length - 1)
|
||||||
else throw IllegalStateException("can't go back from line 0, column 0")
|
else throw IllegalStateException("can't go back from line 0, column 0")
|
||||||
|
|
||||||
val currentLine: String get() = if( end ) "EOF" else source.lines[line]
|
val currentLine: String get() =
|
||||||
|
if( end ) "EOF"
|
||||||
|
else if( line >= 0 ) source.lines[line] else "<no line information>"
|
||||||
|
|
||||||
val end: Boolean get() = line >= source.lines.size
|
val end: Boolean get() = line >= source.lines.size
|
||||||
|
|
||||||
|
|||||||
@@ -136,20 +136,29 @@ open class Scope(
|
|||||||
?: thisObj.objClass
|
?: thisObj.objClass
|
||||||
.getInstanceMemberOrNull(name)
|
.getInstanceMemberOrNull(name)
|
||||||
)
|
)
|
||||||
// ?.also {
|
|
||||||
// if( name == "predicate") {
|
|
||||||
// println("got predicate $it")
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
/**
|
||||||
|
* Creates a new child scope using the provided arguments and optional `thisObj`.
|
||||||
|
*/
|
||||||
|
fun createChildScope(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
||||||
Scope(this, args, pos, newThisObj ?: thisObj)
|
Scope(this, args, pos, newThisObj ?: thisObj)
|
||||||
|
|
||||||
fun copy(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
/**
|
||||||
|
* Creates a new child scope using the provided arguments and optional `thisObj`.
|
||||||
|
* The child scope inherits the current scope's properties such as position and the existing `thisObj` if no new `thisObj` is provided.
|
||||||
|
*
|
||||||
|
* @param args The arguments to associate with the child scope. Defaults to [Arguments.EMPTY].
|
||||||
|
* @param newThisObj The new `thisObj` to associate with the child scope. Defaults to the current scope's `thisObj` if not provided.
|
||||||
|
* @return A new instance of [Scope] initialized with the specified arguments and `thisObj`.
|
||||||
|
*/
|
||||||
|
fun createChildScope(args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
||||||
Scope(this, args, pos, newThisObj ?: thisObj)
|
Scope(this, args, pos, newThisObj ?: thisObj)
|
||||||
|
|
||||||
fun copy() = Scope(this, args, pos, thisObj)
|
/**
|
||||||
|
* @return A child scope with the same arguments, position and [thisObj]
|
||||||
|
*/
|
||||||
|
fun createChildScope() = Scope(this, args, pos, thisObj)
|
||||||
|
|
||||||
fun addItem(
|
fun addItem(
|
||||||
name: String,
|
name: String,
|
||||||
@@ -245,8 +254,6 @@ open class Scope(
|
|||||||
p = p.parent
|
p = p.parent
|
||||||
}
|
}
|
||||||
println("--------------------")
|
println("--------------------")
|
||||||
ObjVoid
|
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)
|
open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)
|
||||||
|
|||||||
@@ -26,6 +26,7 @@ import net.sergeych.lynon.ObjLynonClass
|
|||||||
import net.sergeych.mp_tools.globalDefer
|
import net.sergeych.mp_tools.globalDefer
|
||||||
import kotlin.math.*
|
import kotlin.math.*
|
||||||
|
|
||||||
|
@Suppress("TYPE_INTERSECTION_AS_REIFIED_WARNING")
|
||||||
class Script(
|
class Script(
|
||||||
override val pos: Pos,
|
override val pos: Pos,
|
||||||
private val statements: List<Statement> = emptyList(),
|
private val statements: List<Statement> = emptyList(),
|
||||||
@@ -57,15 +58,15 @@ class Script(
|
|||||||
ObjException.addExceptionsToContext(this)
|
ObjException.addExceptionsToContext(this)
|
||||||
addFn("print") {
|
addFn("print") {
|
||||||
for ((i, a) in args.withIndex()) {
|
for ((i, a) in args.withIndex()) {
|
||||||
if (i > 0) print(' ' + a.asStr.value)
|
if (i > 0) print(' ' + a.toString(this).value)
|
||||||
else print(a.asStr.value)
|
else print(a.toString(this).value)
|
||||||
}
|
}
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
addFn("println") {
|
addFn("println") {
|
||||||
for ((i, a) in args.withIndex()) {
|
for ((i, a) in args.withIndex()) {
|
||||||
if (i > 0) print(' ' + a.asStr.value)
|
if (i > 0) print(' ' + a.toString(this).value)
|
||||||
else print(a.asStr.value)
|
else print(a.toString(this).value)
|
||||||
}
|
}
|
||||||
println()
|
println()
|
||||||
ObjVoid
|
ObjVoid
|
||||||
@@ -165,13 +166,13 @@ class Script(
|
|||||||
val a = requiredArg<Obj>(0)
|
val a = requiredArg<Obj>(0)
|
||||||
val b = requiredArg<Obj>(1)
|
val b = requiredArg<Obj>(1)
|
||||||
if( a.compareTo(this, b) != 0 )
|
if( a.compareTo(this, b) != 0 )
|
||||||
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
|
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"))
|
||||||
}
|
}
|
||||||
addVoidFn("assertNotEquals") {
|
addVoidFn("assertNotEquals") {
|
||||||
val a = requiredArg<Obj>(0)
|
val a = requiredArg<Obj>(0)
|
||||||
val b = requiredArg<Obj>(1)
|
val b = requiredArg<Obj>(1)
|
||||||
if( a.compareTo(this, b) == 0 )
|
if( a.compareTo(this, b) == 0 )
|
||||||
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} != ${b.inspect()}"))
|
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"))
|
||||||
}
|
}
|
||||||
addFn("assertThrows") {
|
addFn("assertThrows") {
|
||||||
val code = requireOnlyArg<Statement>()
|
val code = requireOnlyArg<Statement>()
|
||||||
@@ -182,7 +183,7 @@ class Script(
|
|||||||
catch( e: ExecutionError ) {
|
catch( e: ExecutionError ) {
|
||||||
e.errorObject
|
e.errorObject
|
||||||
}
|
}
|
||||||
catch (e: ScriptError) {
|
catch (_: ScriptError) {
|
||||||
ObjNull
|
ObjNull
|
||||||
}
|
}
|
||||||
result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))
|
result ?: raiseError(ObjAssertionFailedException(this,"Expected exception but nothing was thrown"))
|
||||||
@@ -241,6 +242,8 @@ class Script(
|
|||||||
addConst("CompletableDeferred", ObjCompletableDeferred.type)
|
addConst("CompletableDeferred", ObjCompletableDeferred.type)
|
||||||
addConst("Mutex", ObjMutex.type)
|
addConst("Mutex", ObjMutex.type)
|
||||||
|
|
||||||
|
addConst("Regex", ObjRegex.type)
|
||||||
|
|
||||||
addFn("launch") {
|
addFn("launch") {
|
||||||
val callable = requireOnlyArg<Statement>()
|
val callable = requireOnlyArg<Statement>()
|
||||||
ObjDeferred(globalDefer {
|
ObjDeferred(globalDefer {
|
||||||
@@ -287,7 +290,7 @@ class Script(
|
|||||||
is ObjInt -> delay(a.value * 1000)
|
is ObjInt -> delay(a.value * 1000)
|
||||||
is ObjReal -> delay((a.value * 1000).roundToLong())
|
is ObjReal -> delay((a.value * 1000).roundToLong())
|
||||||
is ObjDuration -> delay(a.duration)
|
is ObjDuration -> delay(a.duration)
|
||||||
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect()}")
|
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
|
||||||
}
|
}
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -26,13 +26,13 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
|
|||||||
$pos: Error: $errorMessage
|
$pos: Error: $errorMessage
|
||||||
|
|
||||||
${pos.currentLine}
|
${pos.currentLine}
|
||||||
${"-".repeat(pos.column)}^
|
${if( pos.column >= 0 ) "-".repeat(pos.column) + "^" else ""}
|
||||||
""".trimIndent(),
|
""".trimIndent(),
|
||||||
cause
|
cause
|
||||||
)
|
)
|
||||||
|
|
||||||
class ScriptFlowIsNoMoreCollected: Exception()
|
class ScriptFlowIsNoMoreCollected: Exception()
|
||||||
|
|
||||||
class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message)
|
class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message.value)
|
||||||
|
|
||||||
class ImportException(pos: Pos, message: String) : ScriptError(pos, message)
|
class ImportException(pos: Pos, message: String) : ScriptError(pos, message)
|
||||||
@@ -17,10 +17,14 @@
|
|||||||
|
|
||||||
package net.sergeych.lyng
|
package net.sergeych.lyng
|
||||||
|
|
||||||
|
import net.sergeych.lyng.obj.ObjString
|
||||||
|
|
||||||
class Source(val fileName: String, text: String) {
|
class Source(val fileName: String, text: String) {
|
||||||
|
|
||||||
val lines = text.lines().map { it.trimEnd() }
|
val lines = text.lines().map { it.trimEnd() }
|
||||||
|
|
||||||
|
val objSourceName by lazy { ObjString(fileName) }
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
val builtIn: Source by lazy { Source("built-in", "") }
|
val builtIn: Source by lazy { Source("built-in", "") }
|
||||||
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
|
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
|
||||||
|
|||||||
@@ -30,14 +30,14 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
|
|||||||
|
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
enum class Type {
|
enum class Type {
|
||||||
ID, INT, REAL, HEX, STRING, CHAR,
|
ID, INT, REAL, HEX, STRING, STRING2, REGEX, CHAR,
|
||||||
LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET, COMMA,
|
LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET, COMMA,
|
||||||
SEMICOLON, COLON,
|
SEMICOLON, COLON,
|
||||||
PLUS, MINUS, STAR, SLASH, PERCENT,
|
PLUS, MINUS, STAR, SLASH, PERCENT,
|
||||||
ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
|
ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
|
||||||
PLUS2, MINUS2,
|
PLUS2, MINUS2,
|
||||||
IN, NOTIN, IS, NOTIS,
|
IN, NOTIN, IS, NOTIS,
|
||||||
EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ,
|
EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ, MATCH, NOTMATCH,
|
||||||
SHUTTLE,
|
SHUTTLE,
|
||||||
AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
|
AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
|
||||||
SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
|
SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
|
||||||
|
|||||||
@@ -17,18 +17,12 @@
|
|||||||
|
|
||||||
package net.sergeych.lyng.obj
|
package net.sergeych.lyng.obj
|
||||||
|
|
||||||
import kotlinx.coroutines.sync.Mutex
|
|
||||||
import kotlinx.coroutines.sync.withLock
|
|
||||||
import kotlinx.serialization.SerialName
|
import kotlinx.serialization.SerialName
|
||||||
import kotlinx.serialization.Serializable
|
import kotlinx.serialization.Serializable
|
||||||
import net.sergeych.bintools.encodeToHex
|
|
||||||
import net.sergeych.lyng.*
|
import net.sergeych.lyng.*
|
||||||
import net.sergeych.lynon.LynonDecoder
|
import net.sergeych.lynon.LynonDecoder
|
||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
import net.sergeych.synctools.ProtectedOp
|
|
||||||
import net.sergeych.synctools.withLock
|
|
||||||
import kotlin.contracts.ExperimentalContracts
|
|
||||||
|
|
||||||
open class Obj {
|
open class Obj {
|
||||||
|
|
||||||
@@ -42,14 +36,14 @@ open class Obj {
|
|||||||
|
|
||||||
var isFrozen: Boolean = false
|
var isFrozen: Boolean = false
|
||||||
|
|
||||||
private val monitor = Mutex()
|
// private val monitor = Mutex()
|
||||||
|
|
||||||
// private val memberMutex = Mutex()
|
// private val memberMutex = Mutex()
|
||||||
internal var parentInstances: MutableList<Obj> = mutableListOf()
|
// internal var parentInstances: MutableList<Obj> = mutableListOf()
|
||||||
|
|
||||||
private val opInstances = ProtectedOp()
|
// private val opInstances = ProtectedOp()
|
||||||
|
|
||||||
open fun inspect(): String = toString()
|
open suspend fun inspect(scope: Scope): String = toString(scope).value
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
|
* Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
|
||||||
@@ -84,14 +78,16 @@ open class Obj {
|
|||||||
scope: Scope,
|
scope: Scope,
|
||||||
name: String,
|
name: String,
|
||||||
args: Arguments = Arguments.EMPTY,
|
args: Arguments = Arguments.EMPTY,
|
||||||
onNotFoundResult: Obj?=null
|
onNotFoundResult: (() -> Obj?)? = null
|
||||||
): Obj =
|
): Obj {
|
||||||
objClass.getInstanceMemberOrNull(name)?.value?.invoke(
|
return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
|
||||||
scope,
|
scope,
|
||||||
this,
|
this,
|
||||||
args)
|
args
|
||||||
?: onNotFoundResult
|
)
|
||||||
|
?: onNotFoundResult?.invoke()
|
||||||
?: scope.raiseSymbolNotFound(name)
|
?: scope.raiseSymbolNotFound(name)
|
||||||
|
}
|
||||||
|
|
||||||
open suspend fun getInstanceMethod(
|
open suspend fun getInstanceMethod(
|
||||||
scope: Scope,
|
scope: Scope,
|
||||||
@@ -101,7 +97,7 @@ open class Obj {
|
|||||||
// note that getInstanceMember traverses the hierarchy
|
// note that getInstanceMember traverses the hierarchy
|
||||||
objClass.getInstanceMember(scope.pos, name).value
|
objClass.getInstanceMember(scope.pos, name).value
|
||||||
|
|
||||||
fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
|
// fun getMemberOrNull(name: String): Obj? = objClass.getInstanceMemberOrNull(name)?.value
|
||||||
|
|
||||||
// methods that to override
|
// methods that to override
|
||||||
|
|
||||||
@@ -113,8 +109,28 @@ open class Obj {
|
|||||||
return invokeInstanceMethod(scope, "contains", other).toBool()
|
return invokeInstanceMethod(scope, "contains", other).toBool()
|
||||||
}
|
}
|
||||||
|
|
||||||
open val asStr: ObjString by lazy {
|
/**
|
||||||
if (this is ObjString) this else ObjString(this.toString())
|
* Default toString implementation:
|
||||||
|
*
|
||||||
|
* - if the object is a string, returns it
|
||||||
|
* - otherwise, if not [calledFromLyng], calls Lyng override `toString()` if exists
|
||||||
|
* - otherwise, meaning either called from Lyng `toString`, or there is no
|
||||||
|
* Lyng override, returns the object's Kotlin variant of `toString()
|
||||||
|
*
|
||||||
|
* Note on kotlin's `toString()`: it is preferred to use this, 'scoped` version,
|
||||||
|
* as it can execute Lyng code using the scope and being suspending one.
|
||||||
|
*
|
||||||
|
* @param scope the scope where the string representation was requested
|
||||||
|
* @param calledFromLyng true if called from Lyng's `toString`. Normally this parameter should be ignored,
|
||||||
|
* but it is used to avoid endless recursion in [Obj.toString] base implementation
|
||||||
|
*/
|
||||||
|
suspend open fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
|
||||||
|
return if (this is ObjString) this
|
||||||
|
else if( !calledFromLyng ) {
|
||||||
|
invokeInstanceMethod(scope, "toString") {
|
||||||
|
ObjString(this.toString())
|
||||||
|
} as ObjString
|
||||||
|
} else { ObjString(this.toString()) }
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -159,6 +175,14 @@ open class Obj {
|
|||||||
scope.raiseNotImplemented()
|
scope.raiseNotImplemented()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
open suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
scope.raiseNotImplemented()
|
||||||
|
}
|
||||||
|
|
||||||
|
open suspend fun operatorNotMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
return operatorMatch(scope,other).logicalNot(scope)
|
||||||
|
}
|
||||||
|
|
||||||
open suspend fun assign(scope: Scope, other: Obj): Obj? = null
|
open suspend fun assign(scope: Scope, other: Obj): Obj? = null
|
||||||
|
|
||||||
open fun getValue(scope: Scope) = this
|
open fun getValue(scope: Scope) = this
|
||||||
@@ -205,14 +229,14 @@ open class Obj {
|
|||||||
if (isFrozen) scope.raiseError("attempt to mutate frozen object")
|
if (isFrozen) scope.raiseError("attempt to mutate frozen object")
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
|
// suspend fun <T> sync(block: () -> T): T = monitor.withLock { block() }
|
||||||
|
|
||||||
open suspend fun readField(scope: Scope, name: String): ObjRecord {
|
open suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||||
// could be property or class field:
|
// could be property or class field:
|
||||||
val obj = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError("no such field: $name")
|
val obj = objClass.getInstanceMemberOrNull(name) ?: scope.raiseError("no such field: $name")
|
||||||
return when (val value = obj.value) {
|
return when (val value = obj.value) {
|
||||||
is Statement -> {
|
is Statement -> {
|
||||||
ObjRecord(value.execute(scope.copy(scope.pos, newThisObj = this)), obj.isMutable)
|
ObjRecord(value.execute(scope.createChildScope(scope.pos, newThisObj = this)), obj.isMutable)
|
||||||
}
|
}
|
||||||
// could be writable property naturally
|
// could be writable property naturally
|
||||||
// null -> ObjNull.asReadonly
|
// null -> ObjNull.asReadonly
|
||||||
@@ -241,11 +265,11 @@ open class Obj {
|
|||||||
}
|
}
|
||||||
|
|
||||||
suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments): Obj =
|
suspend fun invoke(scope: Scope, thisObj: Obj, args: Arguments): Obj =
|
||||||
callOn(scope.copy(scope.pos, args = args, newThisObj = thisObj))
|
callOn(scope.createChildScope(scope.pos, args = args, newThisObj = thisObj))
|
||||||
|
|
||||||
suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
|
suspend fun invoke(scope: Scope, thisObj: Obj, vararg args: Obj): Obj =
|
||||||
callOn(
|
callOn(
|
||||||
scope.copy(
|
scope.createChildScope(
|
||||||
scope.pos,
|
scope.pos,
|
||||||
args = Arguments(args.toList()),
|
args = Arguments(args.toList()),
|
||||||
newThisObj = thisObj
|
newThisObj = thisObj
|
||||||
@@ -254,7 +278,7 @@ open class Obj {
|
|||||||
|
|
||||||
suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
|
suspend fun invoke(scope: Scope, thisObj: Obj): Obj =
|
||||||
callOn(
|
callOn(
|
||||||
scope.copy(
|
scope.createChildScope(
|
||||||
scope.pos,
|
scope.pos,
|
||||||
args = Arguments.EMPTY,
|
args = Arguments.EMPTY,
|
||||||
newThisObj = thisObj
|
newThisObj = thisObj
|
||||||
@@ -262,7 +286,7 @@ open class Obj {
|
|||||||
)
|
)
|
||||||
|
|
||||||
suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
|
suspend fun invoke(scope: Scope, atPos: Pos, thisObj: Obj, args: Arguments): Obj =
|
||||||
callOn(scope.copy(atPos, args = args, newThisObj = thisObj))
|
callOn(scope.createChildScope(atPos, args = args, newThisObj = thisObj))
|
||||||
|
|
||||||
|
|
||||||
val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
|
val asReadonly: ObjRecord by lazy { ObjRecord(this, false) }
|
||||||
@@ -275,44 +299,57 @@ open class Obj {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fun autoInstanceScope(parent: Scope): Scope {
|
fun autoInstanceScope(parent: Scope): Scope {
|
||||||
val scope = parent.copy(newThisObj = this, args = parent.args)
|
val scope = parent.createChildScope(newThisObj = this, args = parent.args)
|
||||||
for( m in objClass.members) {
|
for (m in objClass.members) {
|
||||||
scope.objects[m.key] = m.value
|
scope.objects[m.key] = m.value
|
||||||
}
|
}
|
||||||
return scope
|
return scope
|
||||||
}
|
}
|
||||||
|
|
||||||
|
inline fun <reified R: Obj> cast(scope: Scope): R {
|
||||||
|
castOrNull<R>()?.let { return it }
|
||||||
|
scope.raiseClassCastError("can't cast ${this::class.simpleName} to ${R::class.simpleName}")
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
inline fun <reified R: Obj> castOrNull(): R? {
|
||||||
|
(this as? R)?.let { return it }
|
||||||
|
// todo: check for subclasses
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
|
|
||||||
val rootObjectType = ObjClass("Obj").apply {
|
val rootObjectType = ObjClass("Obj").apply {
|
||||||
addFn("toString") {
|
addFn("toString", true) {
|
||||||
thisObj.asStr
|
thisObj.toString(this, true)
|
||||||
}
|
}
|
||||||
addFn("inspect", true) {
|
addFn("inspect", true) {
|
||||||
thisObj.inspect().toObj()
|
thisObj.inspect(this).toObj()
|
||||||
}
|
}
|
||||||
addFn("contains") {
|
addFn("contains") {
|
||||||
ObjBool(thisObj.contains(this, args.firstAndOnly()))
|
ObjBool(thisObj.contains(this, args.firstAndOnly()))
|
||||||
}
|
}
|
||||||
// utilities
|
// utilities
|
||||||
addFn("let") {
|
addFn("let") {
|
||||||
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
|
args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
|
||||||
}
|
}
|
||||||
addFn("apply") {
|
addFn("apply") {
|
||||||
val body = args.firstAndOnly()
|
val body = args.firstAndOnly()
|
||||||
(thisObj as? ObjInstance)?.let {
|
(thisObj as? ObjInstance)?.let {
|
||||||
println("apply in ${thisObj is ObjInstance}, ${it.instanceScope}")
|
|
||||||
body.callOn(ApplyScope(this, it.instanceScope))
|
body.callOn(ApplyScope(this, it.instanceScope))
|
||||||
} ?: run {
|
} ?: run {
|
||||||
println("apply on non-instance $thisObj")
|
|
||||||
body.callOn(this)
|
body.callOn(this)
|
||||||
}
|
}
|
||||||
thisObj
|
thisObj
|
||||||
}
|
}
|
||||||
addFn("also") {
|
addFn("also") {
|
||||||
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
|
args.firstAndOnly().callOn(createChildScope(Arguments(thisObj)))
|
||||||
thisObj
|
thisObj
|
||||||
}
|
}
|
||||||
|
addFn("run") {
|
||||||
|
args.firstAndOnly().callOn(this)
|
||||||
|
}
|
||||||
addFn("getAt") {
|
addFn("getAt") {
|
||||||
requireExactCount(1)
|
requireExactCount(1)
|
||||||
thisObj.getAt(this, requiredArg<Obj>(0))
|
thisObj.getAt(this, requiredArg<Obj>(0))
|
||||||
@@ -327,6 +364,7 @@ open class Obj {
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
@Suppress("NOTHING_TO_INLINE")
|
||||||
inline fun from(obj: Any?): Obj {
|
inline fun from(obj: Any?): Obj {
|
||||||
@Suppress("UNCHECKED_CAST")
|
@Suppress("UNCHECKED_CAST")
|
||||||
return when (obj) {
|
return when (obj) {
|
||||||
@@ -387,9 +425,14 @@ object ObjNull : Obj() {
|
|||||||
scope.raiseNPE()
|
scope.raiseNPE()
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj {
|
// override suspend fun invokeInstanceMethod(
|
||||||
scope.raiseNPE()
|
// scope: Scope,
|
||||||
}
|
// name: String,
|
||||||
|
// args: Arguments,
|
||||||
|
// onNotFoundResult: (()->Obj?)?
|
||||||
|
// ): Obj {
|
||||||
|
// scope.raiseNPE()
|
||||||
|
// }
|
||||||
|
|
||||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
scope.raiseNPE()
|
scope.raiseNPE()
|
||||||
@@ -431,6 +474,9 @@ object ObjNull : Obj() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* TODO: get rid of it. Maybe we ise some Lyng inheritance instead
|
||||||
|
*/
|
||||||
interface Numeric {
|
interface Numeric {
|
||||||
val longValue: Long
|
val longValue: Long
|
||||||
val doubleValue: Double
|
val doubleValue: Double
|
||||||
@@ -461,129 +507,11 @@ fun Obj.toBool(): Boolean =
|
|||||||
data class ObjNamespace(val name: String) : Obj() {
|
data class ObjNamespace(val name: String) : Obj() {
|
||||||
override val objClass by lazy { ObjClass(name) }
|
override val objClass by lazy { ObjClass(name) }
|
||||||
|
|
||||||
override fun inspect(): String = "Ns[$name]"
|
override suspend fun inspect(scope: Scope): String = "Ns[$name]"
|
||||||
|
|
||||||
override fun toString(): String {
|
override fun toString(): String {
|
||||||
return "package $name"
|
return "package $name"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val message: String) : Obj() {
|
|
||||||
constructor(name: String, scope: Scope, message: String) : this(
|
|
||||||
getOrCreateExceptionClass(name),
|
|
||||||
scope,
|
|
||||||
message
|
|
||||||
)
|
|
||||||
|
|
||||||
constructor(scope: Scope, message: String) : this(Root, scope, message)
|
|
||||||
|
|
||||||
fun raise(): Nothing {
|
|
||||||
throw ExecutionError(this)
|
|
||||||
}
|
|
||||||
|
|
||||||
override val objClass: ObjClass = exceptionClass
|
|
||||||
|
|
||||||
override fun toString(): String {
|
|
||||||
return "ObjException:${objClass.className}:${scope.pos}@${hashCode().encodeToHex()}"
|
|
||||||
}
|
|
||||||
|
|
||||||
companion object {
|
|
||||||
|
|
||||||
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
|
|
||||||
override suspend fun callOn(scope: Scope): Obj {
|
|
||||||
val message = scope.args.getOrNull(0)?.toString() ?: name
|
|
||||||
return ObjException(this, scope, message)
|
|
||||||
}
|
|
||||||
|
|
||||||
override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
|
|
||||||
}
|
|
||||||
|
|
||||||
val Root = ExceptionClass("Throwable").apply {
|
|
||||||
addConst("message", statement {
|
|
||||||
(thisObj as ObjException).message.toObj()
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
private val op = ProtectedOp()
|
|
||||||
private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
|
|
||||||
|
|
||||||
|
|
||||||
@OptIn(ExperimentalContracts::class)
|
|
||||||
protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
|
|
||||||
return op.withLock {
|
|
||||||
existingErrorClasses.getOrPut(name) {
|
|
||||||
ExceptionClass(name, Root)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Get [ObjClass] for error class by name if exists.
|
|
||||||
*/
|
|
||||||
@OptIn(ExperimentalContracts::class)
|
|
||||||
fun getErrorClass(name: String): ObjClass? = op.withLock {
|
|
||||||
existingErrorClasses[name]
|
|
||||||
}
|
|
||||||
|
|
||||||
fun addExceptionsToContext(scope: Scope) {
|
|
||||||
scope.addConst("Exception", Root)
|
|
||||||
existingErrorClasses["Exception"] = Root
|
|
||||||
for (name in listOf(
|
|
||||||
"NullReferenceException",
|
|
||||||
"AssertionFailedException",
|
|
||||||
"ClassCastException",
|
|
||||||
"IndexOutOfBoundsException",
|
|
||||||
"IllegalArgumentException",
|
|
||||||
"NoSuchElementException",
|
|
||||||
"IllegalAssignmentException",
|
|
||||||
"SymbolNotDefinedException",
|
|
||||||
"IterationEndException",
|
|
||||||
"AccessException",
|
|
||||||
"UnknownException",
|
|
||||||
"NotFoundException"
|
|
||||||
)) {
|
|
||||||
scope.addConst(name, getOrCreateExceptionClass(name))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
|
|
||||||
|
|
||||||
class ObjAssertionFailedException(scope: Scope, message: String) :
|
|
||||||
ObjException("AssertionFailedException", scope, message)
|
|
||||||
|
|
||||||
class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
|
|
||||||
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
|
|
||||||
ObjException("IndexOutOfBoundsException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
|
|
||||||
ObjException("IllegalArgumentException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
|
|
||||||
ObjException("IllegalStateException", scope, message)
|
|
||||||
|
|
||||||
@Suppress("unused")
|
|
||||||
class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
|
|
||||||
ObjException("IllegalArgumentException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
|
|
||||||
ObjException("NoSuchElementException", scope, message)
|
|
||||||
|
|
||||||
class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
|
|
||||||
ObjException("SymbolNotDefinedException", scope, message)
|
|
||||||
|
|
||||||
class ObjIterationFinishedException(scope: Scope) :
|
|
||||||
ObjException("IterationEndException", scope, "iteration finished")
|
|
||||||
|
|
||||||
class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
|
|
||||||
ObjException("AccessException", scope, message)
|
|
||||||
|
|
||||||
class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
|
|
||||||
ObjException("UnknownException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
|
|
||||||
ObjException("IllegalOperationException", scope, message)
|
|
||||||
|
|
||||||
class ObjNotFoundException(scope: Scope, message: String = "not found") :
|
|
||||||
ObjException("NotFoundException", scope, message)
|
|
||||||
@@ -51,5 +51,25 @@ val ObjArray by lazy {
|
|||||||
ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
|
ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
addFn("binarySearch") {
|
||||||
|
val target = args.firstAndOnly()
|
||||||
|
var low = 0
|
||||||
|
var high = thisObj.invokeInstanceMethod(this, "size").toInt() - 1
|
||||||
|
|
||||||
|
while (low <= high) {
|
||||||
|
val mid = (low + high) / 2
|
||||||
|
val midVal = thisObj.getAt(this, ObjInt(mid.toLong()))
|
||||||
|
|
||||||
|
val cmp = midVal.compareTo(this, target)
|
||||||
|
when {
|
||||||
|
cmp == 0 -> return@addFn (mid).toObj()
|
||||||
|
cmp > 0 -> high = mid - 1
|
||||||
|
else -> low = mid + 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Элемент не найден, возвращаем -(точка вставки) - 1
|
||||||
|
(-low - 1).toObj()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -35,12 +35,12 @@ class ObjBitBuffer(val bitArray: BitArray) : Obj() {
|
|||||||
}.apply {
|
}.apply {
|
||||||
addFn("toBuffer") {
|
addFn("toBuffer") {
|
||||||
requireNoArgs()
|
requireNoArgs()
|
||||||
ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUbyteArray())
|
ObjBuffer(thisAs<ObjBitBuffer>().bitArray.asUByteArray())
|
||||||
}
|
}
|
||||||
addFn("toDump") {
|
addFn("toDump") {
|
||||||
requireNoArgs()
|
requireNoArgs()
|
||||||
ObjString(
|
ObjString(
|
||||||
thisAs<ObjBitBuffer>().bitArray.asUbyteArray().toDump()
|
thisAs<ObjBitBuffer>().bitArray.asUByteArray().toDump()
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
addFn("size") {
|
addFn("size") {
|
||||||
|
|||||||
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
|
|||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
|
|
||||||
data class ObjBool(val value: Boolean) : Obj() {
|
data class ObjBool(val value: Boolean) : Obj() {
|
||||||
override val asStr by lazy { ObjString(value.toString()) }
|
|
||||||
|
|
||||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||||
if (other !is ObjBool) return -2
|
if (other !is ObjBool) return -2
|
||||||
|
|||||||
@@ -24,6 +24,7 @@ import net.sergeych.bintools.encodeToHex
|
|||||||
import net.sergeych.bintools.toDump
|
import net.sergeych.bintools.toDump
|
||||||
import net.sergeych.lyng.Scope
|
import net.sergeych.lyng.Scope
|
||||||
import net.sergeych.lyng.statement
|
import net.sergeych.lyng.statement
|
||||||
|
import net.sergeych.lynon.BitArray
|
||||||
import net.sergeych.lynon.LynonDecoder
|
import net.sergeych.lynon.LynonDecoder
|
||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
@@ -86,7 +87,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
|
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
|
||||||
.toUByteArray()
|
.toUByteArray()
|
||||||
)
|
)
|
||||||
} else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect()}")
|
} else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect(scope)}")
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun toString(): String = base64
|
override fun toString(): String = base64
|
||||||
@@ -106,7 +107,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
encoder.encodeCachedBytes(byteArray.asByteArray())
|
encoder.encodeCachedBytes(byteArray.asByteArray())
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun inspect(): String = "Buf($base64)"
|
override suspend fun inspect(scope: Scope): String = "Buf($base64)"
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
|
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
|
||||||
@@ -128,7 +129,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
)
|
)
|
||||||
} else
|
} else
|
||||||
scope.raiseIllegalArgument(
|
scope.raiseIllegalArgument(
|
||||||
"can't construct buffer from ${obj.inspect()}"
|
"can't construct buffer from ${obj.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -148,7 +149,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
is ObjChar -> b.value.code.toUByte()
|
is ObjChar -> b.value.code.toUByte()
|
||||||
is ObjInt -> b.value.toUByte()
|
is ObjInt -> b.value.toUByte()
|
||||||
else -> scope.raiseIllegalArgument(
|
else -> scope.raiseIllegalArgument(
|
||||||
"invalid byte value for buffer constructor at index $i: ${b.inspect()}"
|
"invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
data[i] = code
|
data[i] = code
|
||||||
@@ -200,6 +201,9 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
|
thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
addFn("toBitInput") {
|
||||||
|
ObjBitBuffer(BitArray(thisAs<ObjBuffer>().byteArray, 8))
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -28,7 +28,7 @@ class ObjChar(val value: Char): Obj() {
|
|||||||
|
|
||||||
override fun toString(): String = value.toString()
|
override fun toString(): String = value.toString()
|
||||||
|
|
||||||
override fun inspect(): String = "'$value'"
|
override suspend fun inspect(scope: Scope): String = "'$value'"
|
||||||
|
|
||||||
override fun hashCode(): Int {
|
override fun hashCode(): Int {
|
||||||
return value.hashCode()
|
return value.hashCode()
|
||||||
|
|||||||
@@ -61,13 +61,17 @@ open class ObjClass(
|
|||||||
|
|
||||||
override suspend fun callOn(scope: Scope): Obj {
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
val instance = ObjInstance(this)
|
val instance = ObjInstance(this)
|
||||||
instance.instanceScope = scope.copy(newThisObj = instance,args = scope.args)
|
instance.instanceScope = scope.createChildScope(newThisObj = instance, args = scope.args)
|
||||||
if (instanceConstructor != null) {
|
if (instanceConstructor != null) {
|
||||||
instanceConstructor!!.execute(instance.instanceScope)
|
instanceConstructor!!.execute(instance.instanceScope)
|
||||||
}
|
}
|
||||||
return instance
|
return instance
|
||||||
}
|
}
|
||||||
|
|
||||||
|
suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
|
||||||
|
return callOn(scope.createChildScope(Arguments(*plainArgs)))
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
fun createField(
|
fun createField(
|
||||||
name: String,
|
name: String,
|
||||||
@@ -77,13 +81,13 @@ open class ObjClass(
|
|||||||
pos: Pos = Pos.builtIn
|
pos: Pos = Pos.builtIn
|
||||||
) {
|
) {
|
||||||
val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
|
val existing = members[name] ?: allParentsSet.firstNotNullOfOrNull { it.members[name] }
|
||||||
if( existing?.isMutable == false)
|
if (existing?.isMutable == false)
|
||||||
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
|
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
|
||||||
members[name] = ObjRecord(initialValue, isMutable, visibility)
|
members[name] = ObjRecord(initialValue, isMutable, visibility)
|
||||||
}
|
}
|
||||||
|
|
||||||
private fun initClassScope(): Scope {
|
private fun initClassScope(): Scope {
|
||||||
if( classScope == null ) classScope = Scope()
|
if (classScope == null) classScope = Scope()
|
||||||
return classScope!!
|
return classScope!!
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -96,7 +100,7 @@ open class ObjClass(
|
|||||||
) {
|
) {
|
||||||
initClassScope()
|
initClassScope()
|
||||||
val existing = classScope!!.objects[name]
|
val existing = classScope!!.objects[name]
|
||||||
if( existing != null)
|
if (existing != null)
|
||||||
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
|
throw ScriptError(pos, "$name is already defined in $objClass or one of its supertypes")
|
||||||
classScope!!.addItem(name, isMutable, initialValue, visibility)
|
classScope!!.addItem(name, isMutable, initialValue, visibility)
|
||||||
}
|
}
|
||||||
@@ -127,26 +131,29 @@ open class ObjClass(
|
|||||||
|
|
||||||
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||||
classScope?.objects?.get(name)?.let {
|
classScope?.objects?.get(name)?.let {
|
||||||
if( it.visibility.isPublic ) return it
|
if (it.visibility.isPublic) return it
|
||||||
}
|
}
|
||||||
return super.readField(scope, name)
|
return super.readField(scope, name)
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
||||||
initClassScope().objects[name]?.let {
|
initClassScope().objects[name]?.let {
|
||||||
if( it.isMutable) it.value = newValue
|
if (it.isMutable) it.value = newValue
|
||||||
else scope.raiseIllegalAssignment("can't assign $name is not mutable")
|
else scope.raiseIllegalAssignment("can't assign $name is not mutable")
|
||||||
}
|
}
|
||||||
?: super.writeField(scope, name, newValue)
|
?: super.writeField(scope, name, newValue)
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
override suspend fun invokeInstanceMethod(
|
||||||
onNotFoundResult: Obj?): Obj {
|
scope: Scope, name: String, args: Arguments,
|
||||||
|
onNotFoundResult: (() -> Obj?)?
|
||||||
|
): Obj {
|
||||||
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
|
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
|
||||||
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
||||||
}
|
}
|
||||||
|
|
||||||
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = scope.raiseNotImplemented()
|
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
|
||||||
|
scope.raiseNotImplemented()
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -18,8 +18,8 @@
|
|||||||
package net.sergeych.lyng.obj
|
package net.sergeych.lyng.obj
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Collection is an iterator with `size`]
|
* Collection is an iterator with `size`
|
||||||
*/
|
*/
|
||||||
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
|
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
|
||||||
|
}
|
||||||
|
|
||||||
}
|
|
||||||
@@ -57,7 +57,7 @@ class ObjDuration(val duration: Duration) : Obj() {
|
|||||||
override suspend fun callOn(scope: Scope): Obj {
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
val args = scope.args
|
val args = scope.args
|
||||||
if( args.list.size > 1 )
|
if( args.list.size > 1 )
|
||||||
scope.raiseIllegalArgument("can't construct Duration(${args.inspect()})")
|
scope.raiseIllegalArgument("can't construct Duration(${args.inspect(scope)})")
|
||||||
val a0 = args.list.getOrNull(0)
|
val a0 = args.list.getOrNull(0)
|
||||||
|
|
||||||
return ObjDuration(
|
return ObjDuration(
|
||||||
@@ -66,7 +66,7 @@ class ObjDuration(val duration: Duration) : Obj() {
|
|||||||
is ObjInt -> a0.value.seconds
|
is ObjInt -> a0.value.seconds
|
||||||
is ObjReal -> a0.value.seconds
|
is ObjReal -> a0.value.seconds
|
||||||
else -> {
|
else -> {
|
||||||
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
|
scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -47,13 +47,20 @@ class ObjDynamicContext(val delegate: ObjDynamic) : Obj() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
class ObjDynamic : Obj() {
|
/**
|
||||||
|
* Object that delegates all its field access/invocation operations to a callback. It is used to implement dynamic
|
||||||
|
* objects using "dynamic" keyword.
|
||||||
|
*/
|
||||||
|
open class ObjDynamic(var readCallback: Statement? = null, var writeCallback: Statement? = null) : Obj() {
|
||||||
|
|
||||||
internal var readCallback: Statement? = null
|
override val objClass: ObjClass = type
|
||||||
internal var writeCallback: Statement? = null
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Use read callback to dynamically resolve the field name. Note that it does not work
|
||||||
|
* with method invocation which is implemented separately in [invokeInstanceMethod] below.
|
||||||
|
*/
|
||||||
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||||
return readCallback?.execute(scope.copy(Arguments(ObjString(name))))?.let {
|
return readCallback?.execute(scope.createChildScope(Arguments(ObjString(name))))?.let {
|
||||||
if (writeCallback != null)
|
if (writeCallback != null)
|
||||||
it.asMutable
|
it.asMutable
|
||||||
else
|
else
|
||||||
@@ -62,21 +69,53 @@ class ObjDynamic : Obj() {
|
|||||||
?: super.readField(scope, name)
|
?: super.readField(scope, name)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Notice that invocation currently does not rely on [readField], which is a buffy moment to be reconsidered
|
||||||
|
* in the future, so we implement it separately:
|
||||||
|
*/
|
||||||
|
override suspend fun invokeInstanceMethod(
|
||||||
|
scope: Scope,
|
||||||
|
name: String,
|
||||||
|
args: Arguments,
|
||||||
|
onNotFoundResult: (() -> Obj?)?
|
||||||
|
): Obj {
|
||||||
|
val over = readCallback?.execute(
|
||||||
|
scope.createChildScope(
|
||||||
|
Arguments(ObjString(name)
|
||||||
|
)
|
||||||
|
)
|
||||||
|
)
|
||||||
|
return over?.invoke(scope, scope.thisObj, args)
|
||||||
|
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
||||||
|
}
|
||||||
|
|
||||||
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
||||||
writeCallback?.execute(scope.copy(Arguments(ObjString(name), newValue)))
|
writeCallback?.execute(scope.createChildScope(Arguments(ObjString(name), newValue)))
|
||||||
?: super.writeField(scope, name, newValue)
|
?: super.writeField(scope, name, newValue)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
|
return readCallback?.execute(scope.createChildScope(Arguments(index)))
|
||||||
|
?: super.getAt(scope, index)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun putAt(scope: Scope, index: Obj, newValue: Obj) {
|
||||||
|
writeCallback?.execute(scope.createChildScope(Arguments(index, newValue)))
|
||||||
|
?: super.putAt(scope, index, newValue)
|
||||||
|
}
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
|
|
||||||
suspend fun create(scope: Scope, builder: Statement): ObjDynamic {
|
suspend fun create(scope: Scope, builder: Statement): ObjDynamic {
|
||||||
val delegate = ObjDynamic()
|
val delegate = ObjDynamic()
|
||||||
val context = ObjDynamicContext(delegate)
|
val context = ObjDynamicContext(delegate)
|
||||||
builder.execute(scope.copy(newThisObj = context))
|
builder.execute(scope.createChildScope(newThisObj = context))
|
||||||
return delegate
|
return delegate
|
||||||
}
|
}
|
||||||
|
|
||||||
val type = object : ObjClass("Delegate") {}
|
val type = object : ObjClass("Delegate") {}.apply {
|
||||||
|
// addClassConst("IndexGetName", operatorGetName)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
@@ -0,0 +1,221 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2025 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.obj
|
||||||
|
|
||||||
|
import net.sergeych.bintools.encodeToHex
|
||||||
|
import net.sergeych.lyng.*
|
||||||
|
import net.sergeych.lynon.LynonDecoder
|
||||||
|
import net.sergeych.lynon.LynonEncoder
|
||||||
|
import net.sergeych.lynon.LynonType
|
||||||
|
import net.sergeych.mptools.CachedExpression
|
||||||
|
import net.sergeych.synctools.ProtectedOp
|
||||||
|
import net.sergeych.synctools.withLock
|
||||||
|
import kotlin.contracts.ExperimentalContracts
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Note on [getStackTrace]. If [useStackTrace] is not null, it is used instead. Otherwise, it is calculated
|
||||||
|
* from the current scope, which is treated as an exception scope. It is used to restore a serialized
|
||||||
|
* exception with stack trace; the scope of the deserialized exception is not valid
|
||||||
|
* for stack unwinding.
|
||||||
|
*/
|
||||||
|
open class ObjException(
|
||||||
|
val exceptionClass: ExceptionClass,
|
||||||
|
val scope: Scope,
|
||||||
|
val message: ObjString,
|
||||||
|
@Suppress("unused") val extraData: Obj = ObjNull,
|
||||||
|
val useStackTrace: ObjList? = null
|
||||||
|
) : Obj() {
|
||||||
|
constructor(name: String, scope: Scope, message: String) : this(
|
||||||
|
getOrCreateExceptionClass(name),
|
||||||
|
scope,
|
||||||
|
ObjString(message)
|
||||||
|
)
|
||||||
|
|
||||||
|
private val cachedStackTrace = CachedExpression(initialValue = useStackTrace)
|
||||||
|
|
||||||
|
suspend fun getStackTrace(): ObjList {
|
||||||
|
return cachedStackTrace.get {
|
||||||
|
val result = ObjList()
|
||||||
|
val cls = scope.get("StackTraceEntry")!!.value as ObjClass
|
||||||
|
var s: Scope? = scope
|
||||||
|
var lastPos: Pos? = null
|
||||||
|
while (s != null) {
|
||||||
|
val pos = s.pos
|
||||||
|
if (pos != lastPos && !pos.currentLine.isEmpty()) {
|
||||||
|
result.list += cls.callWithArgs(
|
||||||
|
scope,
|
||||||
|
pos.source.objSourceName,
|
||||||
|
ObjInt(pos.line.toLong()),
|
||||||
|
ObjInt(pos.column.toLong()),
|
||||||
|
ObjString(pos.currentLine)
|
||||||
|
)
|
||||||
|
}
|
||||||
|
s = s.parent
|
||||||
|
lastPos = pos
|
||||||
|
}
|
||||||
|
result
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
constructor(scope: Scope, message: String) : this(Root, scope, ObjString(message))
|
||||||
|
|
||||||
|
fun raise(): Nothing {
|
||||||
|
throw ExecutionError(this)
|
||||||
|
}
|
||||||
|
|
||||||
|
override val objClass: ObjClass = exceptionClass
|
||||||
|
|
||||||
|
override suspend fun toString(scope: Scope, calledFromLyng: Boolean): ObjString {
|
||||||
|
val at = getStackTrace().list.firstOrNull()?.toString(scope)
|
||||||
|
?: ObjString("(unknown)")
|
||||||
|
return ObjString("${objClass.className}: $message at $at")
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
||||||
|
encoder.encodeAny(scope, exceptionClass.classNameObj)
|
||||||
|
encoder.encodeAny(scope, message)
|
||||||
|
encoder.encodeAny(scope, extraData)
|
||||||
|
encoder.encodeAny(scope, getStackTrace())
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
|
||||||
|
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
|
||||||
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
|
val message = scope.args.getOrNull(0)?.toString(scope) ?: ObjString(name)
|
||||||
|
return ObjException(this, scope, message)
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
|
||||||
|
|
||||||
|
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
||||||
|
return try {
|
||||||
|
val lyngClass = decoder.decodeAnyAs<ObjString>(scope).value.let {
|
||||||
|
((scope[it] ?: scope.raiseIllegalArgument("Unknown exception class: $it"))
|
||||||
|
.value as? ExceptionClass)
|
||||||
|
?: scope.raiseIllegalArgument("Not an exception class: $it")
|
||||||
|
}
|
||||||
|
ObjException(
|
||||||
|
lyngClass,
|
||||||
|
scope,
|
||||||
|
decoder.decodeAnyAs<ObjString>(scope),
|
||||||
|
decoder.decodeAny(scope),
|
||||||
|
decoder.decodeAnyAs<ObjList>(scope)
|
||||||
|
)
|
||||||
|
} catch (e: ScriptError) {
|
||||||
|
throw e
|
||||||
|
} catch (e: Exception) {
|
||||||
|
e.printStackTrace()
|
||||||
|
scope.raiseIllegalArgument("Failed to deserialize exception: ${e.message}")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val Root = ExceptionClass("Exception").apply {
|
||||||
|
addConst("message", statement {
|
||||||
|
(thisObj as ObjException).message.toObj()
|
||||||
|
})
|
||||||
|
addFn("stackTrace") {
|
||||||
|
(thisObj as ObjException).getStackTrace()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private val op = ProtectedOp()
|
||||||
|
private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
|
||||||
|
|
||||||
|
|
||||||
|
@OptIn(ExperimentalContracts::class)
|
||||||
|
protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
|
||||||
|
return op.withLock {
|
||||||
|
existingErrorClasses.getOrPut(name) {
|
||||||
|
ExceptionClass(name, Root)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Get [ObjClass] for error class by name if exists.
|
||||||
|
*/
|
||||||
|
@OptIn(ExperimentalContracts::class)
|
||||||
|
fun getErrorClass(name: String): ObjClass? = op.withLock {
|
||||||
|
existingErrorClasses[name]
|
||||||
|
}
|
||||||
|
|
||||||
|
fun addExceptionsToContext(scope: Scope) {
|
||||||
|
scope.addConst("Exception", Root)
|
||||||
|
existingErrorClasses["Exception"] = Root
|
||||||
|
for (name in listOf(
|
||||||
|
"NullReferenceException",
|
||||||
|
"AssertionFailedException",
|
||||||
|
"ClassCastException",
|
||||||
|
"IndexOutOfBoundsException",
|
||||||
|
"IllegalArgumentException",
|
||||||
|
"NoSuchElementException",
|
||||||
|
"IllegalAssignmentException",
|
||||||
|
"SymbolNotDefinedException",
|
||||||
|
"IterationEndException",
|
||||||
|
"AccessException",
|
||||||
|
"UnknownException",
|
||||||
|
"NotFoundException"
|
||||||
|
)) {
|
||||||
|
scope.addConst(name, getOrCreateExceptionClass(name))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
|
||||||
|
|
||||||
|
class ObjAssertionFailedException(scope: Scope, message: String) :
|
||||||
|
ObjException("AssertionFailedException", scope, message)
|
||||||
|
|
||||||
|
class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
|
||||||
|
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
|
||||||
|
ObjException("IndexOutOfBoundsException", scope, message)
|
||||||
|
|
||||||
|
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
|
||||||
|
ObjException("IllegalArgumentException", scope, message)
|
||||||
|
|
||||||
|
class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
|
||||||
|
ObjException("IllegalStateException", scope, message)
|
||||||
|
|
||||||
|
@Suppress("unused")
|
||||||
|
class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
|
||||||
|
ObjException("IllegalArgumentException", scope, message)
|
||||||
|
|
||||||
|
class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
|
||||||
|
ObjException("NoSuchElementException", scope, message)
|
||||||
|
|
||||||
|
class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
|
||||||
|
ObjException("SymbolNotDefinedException", scope, message)
|
||||||
|
|
||||||
|
class ObjIterationFinishedException(scope: Scope) :
|
||||||
|
ObjException("IterationEndException", scope, "iteration finished")
|
||||||
|
|
||||||
|
class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
|
||||||
|
ObjException("AccessException", scope, message)
|
||||||
|
|
||||||
|
class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
|
||||||
|
ObjException("UnknownException", scope, message)
|
||||||
|
|
||||||
|
class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
|
||||||
|
ObjException("IllegalOperationException", scope, message)
|
||||||
|
|
||||||
|
class ObjNotFoundException(scope: Scope, message: String = "not found") :
|
||||||
|
ObjException("NotFoundException", scope, message)
|
||||||
@@ -58,7 +58,7 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
|
|||||||
private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> {
|
private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChannel<Obj> {
|
||||||
val channel = Channel<Obj>(Channel.RENDEZVOUS)
|
val channel = Channel<Obj>(Channel.RENDEZVOUS)
|
||||||
val builder = ObjFlowBuilder(channel)
|
val builder = ObjFlowBuilder(channel)
|
||||||
val builderScope = scope.copy(newThisObj = builder)
|
val builderScope = scope.createChildScope(newThisObj = builder)
|
||||||
globalLaunch {
|
globalLaunch {
|
||||||
try {
|
try {
|
||||||
producer.execute(builderScope)
|
producer.execute(builderScope)
|
||||||
|
|||||||
@@ -48,7 +48,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
||||||
onNotFoundResult: Obj?): Obj =
|
onNotFoundResult: (()->Obj?)?): Obj =
|
||||||
instanceScope[name]?.let {
|
instanceScope[name]?.let {
|
||||||
if (it.visibility.isPublic)
|
if (it.visibility.isPublic)
|
||||||
it.value.invoke(
|
it.value.invoke(
|
||||||
|
|||||||
@@ -30,12 +30,19 @@ class ObjInstanceClass(val name: String) : ObjClass(name) {
|
|||||||
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
override suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj {
|
||||||
val args = decoder.decodeAnyList(scope)
|
val args = decoder.decodeAnyList(scope)
|
||||||
val actualSize = constructorMeta?.params?.size ?: 0
|
val actualSize = constructorMeta?.params?.size ?: 0
|
||||||
if( args.size > actualSize )
|
if (args.size > actualSize)
|
||||||
scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
|
scope.raiseIllegalArgument("constructor $name has only $actualSize but serialized version has ${args.size}")
|
||||||
val newScope = scope.copy(args = Arguments(args))
|
val newScope = scope.createChildScope(args = Arguments(args))
|
||||||
return (callOn(newScope) as ObjInstance).apply {
|
return (callOn(newScope) as ObjInstance).apply {
|
||||||
deserializeStateVars(scope,decoder)
|
deserializeStateVars(scope, decoder)
|
||||||
invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid)
|
invokeInstanceMethod(scope, "onDeserialized") { ObjVoid }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
init {
|
||||||
|
addFn("toString", true) {
|
||||||
|
println("-------------- tos! --------------")
|
||||||
|
ObjString(thisObj.toString())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -117,7 +117,7 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
|
|||||||
is ObjInstant -> a0.instant
|
is ObjInstant -> a0.instant
|
||||||
|
|
||||||
else -> {
|
else -> {
|
||||||
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
|
scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
|
|||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
|
|
||||||
class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric {
|
class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric {
|
||||||
override val asStr get() = ObjString(value.toString())
|
|
||||||
override val longValue get() = value
|
override val longValue get() = value
|
||||||
override val doubleValue get() = value.toDouble()
|
override val doubleValue get() = value.toDouble()
|
||||||
override val toObjInt get() = this
|
override val toObjInt get() = this
|
||||||
@@ -62,7 +61,7 @@ class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Nu
|
|||||||
|
|
||||||
override fun toString(): String = value.toString()
|
override fun toString(): String = value.toString()
|
||||||
|
|
||||||
override val objClass: ObjClass = type
|
override val objClass: ObjClass by lazy { type }
|
||||||
|
|
||||||
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
||||||
if (other is ObjInt)
|
if (other is ObjInt)
|
||||||
|
|||||||
@@ -93,7 +93,7 @@ val ObjIterable by lazy {
|
|||||||
val fn = requiredArg<Statement>(0)
|
val fn = requiredArg<Statement>(0)
|
||||||
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
while (it.invokeInstanceMethod(this, "hasNext").toBool()) {
|
||||||
val x = it.invokeInstanceMethod(this, "next")
|
val x = it.invokeInstanceMethod(this, "next")
|
||||||
fn.execute(this.copy(Arguments(listOf(x))))
|
fn.execute(this.createChildScope(Arguments(listOf(x))))
|
||||||
}
|
}
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
@@ -119,12 +119,6 @@ val ObjIterable by lazy {
|
|||||||
ObjList(result)
|
ObjList(result)
|
||||||
}
|
}
|
||||||
|
|
||||||
// addFn("drop" ) {
|
|
||||||
// var n = requireOnlyArg<ObjInt>().value.toInt()
|
|
||||||
// if( n < 0 ) raiseIllegalArgument("drop($n): should be positive")
|
|
||||||
// val it = callMethod<>()
|
|
||||||
// }
|
|
||||||
|
|
||||||
addFn("isEmpty") {
|
addFn("isEmpty") {
|
||||||
ObjBool(
|
ObjBool(
|
||||||
thisObj.invokeInstanceMethod(this, "iterator")
|
thisObj.invokeInstanceMethod(this, "iterator")
|
||||||
@@ -132,5 +126,20 @@ val ObjIterable by lazy {
|
|||||||
.not()
|
.not()
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
addFn("sortedWith") {
|
||||||
|
val list = thisObj.callMethod<ObjList>(this, "toList")
|
||||||
|
val comparator = requireOnlyArg<Statement>()
|
||||||
|
list.quicksort { a, b ->
|
||||||
|
comparator.call(this, a, b).toInt()
|
||||||
|
}
|
||||||
|
list
|
||||||
|
}
|
||||||
|
|
||||||
|
addFn("reversed") {
|
||||||
|
val list = thisObj.callMethod<ObjList>(this, "toList")
|
||||||
|
list.list.reverse()
|
||||||
|
list
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -82,18 +82,18 @@ fun Obj.toFlow(scope: Scope): Flow<Obj> = flow {
|
|||||||
*
|
*
|
||||||
* IF callback returns false, iteration is stopped.
|
* IF callback returns false, iteration is stopped.
|
||||||
*/
|
*/
|
||||||
suspend fun Obj.enumerate(scope: Scope,callback: suspend (Obj)->Boolean) {
|
suspend fun Obj.enumerate(scope: Scope, callback: suspend (Obj) -> Boolean) {
|
||||||
val iterator = invokeInstanceMethod(scope, "iterator")
|
val iterator = invokeInstanceMethod(scope, "iterator")
|
||||||
val hasNext = iterator.getInstanceMethod(scope, "hasNext")
|
val hasNext = iterator.getInstanceMethod(scope, "hasNext")
|
||||||
val next = iterator.getInstanceMethod(scope, "next")
|
val next = iterator.getInstanceMethod(scope, "next")
|
||||||
var closeIt = false
|
var closeIt = false
|
||||||
while (hasNext.invoke(scope, iterator).toBool()) {
|
while (hasNext.invoke(scope, iterator).toBool()) {
|
||||||
val nextValue = next.invoke(scope, iterator)
|
val nextValue = next.invoke(scope, iterator)
|
||||||
if( !callback(nextValue) ) {
|
if (!callback(nextValue)) {
|
||||||
closeIt = true
|
closeIt = true
|
||||||
break
|
break
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if( closeIt )
|
if (closeIt)
|
||||||
iterator.invokeInstanceMethod(scope, "cancelIteration", onNotFoundResult = ObjVoid)
|
iterator.invokeInstanceMethod(scope, "cancelIteration") { ObjVoid }
|
||||||
}
|
}
|
||||||
@@ -18,6 +18,7 @@
|
|||||||
package net.sergeych.lyng.obj
|
package net.sergeych.lyng.obj
|
||||||
|
|
||||||
import net.sergeych.lyng.Scope
|
import net.sergeych.lyng.Scope
|
||||||
|
import net.sergeych.lyng.Statement
|
||||||
import net.sergeych.lyng.statement
|
import net.sergeych.lyng.statement
|
||||||
import net.sergeych.lynon.LynonDecoder
|
import net.sergeych.lynon.LynonDecoder
|
||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
@@ -25,10 +26,6 @@ import net.sergeych.lynon.LynonType
|
|||||||
|
|
||||||
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||||
|
|
||||||
override fun toString(): String = "[${
|
|
||||||
list.joinToString(separator = ", ") { it.inspect() }
|
|
||||||
}]"
|
|
||||||
|
|
||||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
return when (index) {
|
return when (index) {
|
||||||
is ObjInt -> {
|
is ObjInt -> {
|
||||||
@@ -65,7 +62,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
else -> scope.raiseIllegalArgument("Illegal index object for a list: ${index.inspect()}")
|
else -> scope.raiseIllegalArgument("Illegal index object for a list: ${index.inspect(scope)}")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -131,6 +128,33 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
return list.map { it.toKotlin(scope) }
|
return list.map { it.toKotlin(scope) }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
suspend fun quicksort(compare: suspend (Obj, Obj) -> Int) = quicksort(compare, 0, list.size - 1)
|
||||||
|
|
||||||
|
suspend fun quicksort(compare: suspend (Obj, Obj) -> Int, left: Int, right: Int) {
|
||||||
|
if (left >= right) return
|
||||||
|
var i = left
|
||||||
|
var j = right
|
||||||
|
val pivot = list[left]
|
||||||
|
while (i < j) {
|
||||||
|
// Сдвигаем j влево, пока элемент меньше pivot
|
||||||
|
while (i < j && compare(list[j], pivot) >= 0) {
|
||||||
|
j--
|
||||||
|
}
|
||||||
|
// Сдвигаем i вправо, пока элемент больше pivot
|
||||||
|
while (i < j && compare(list[i], pivot) <= 0) {
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
if (i < j) {
|
||||||
|
list.swap(i, j)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// После завершения i == j, ставим pivot на своё место
|
||||||
|
list.swap(left, i)
|
||||||
|
// Рекурсивно сортируем левую и правую части
|
||||||
|
quicksort(compare, left, i - 1)
|
||||||
|
quicksort(compare, i + 1, right)
|
||||||
|
}
|
||||||
|
|
||||||
override fun hashCode(): Int {
|
override fun hashCode(): Int {
|
||||||
// check?
|
// check?
|
||||||
return list.hashCode()
|
return list.hashCode()
|
||||||
@@ -239,8 +263,27 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
}
|
}
|
||||||
self
|
self
|
||||||
}
|
}
|
||||||
|
|
||||||
|
addFn("sortWith") {
|
||||||
|
val comparator = requireOnlyArg<Statement>()
|
||||||
|
thisAs<ObjList>().quicksort { a, b -> comparator.call(this, a, b).toInt() }
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
addFn("shuffle") {
|
||||||
|
thisAs<ObjList>().list.shuffle()
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Расширение MutableList для удобного обмена элементами
|
||||||
|
fun <T>MutableList<T>.swap(i: Int, j: Int) {
|
||||||
|
if (i in indices && j in indices) {
|
||||||
|
val temp = this[i]
|
||||||
|
this[i] = this[j]
|
||||||
|
this[j] = temp
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
@@ -28,7 +28,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
|
|||||||
is ObjInt -> newValue.value.toUByte()
|
is ObjInt -> newValue.value.toUByte()
|
||||||
is ObjChar -> newValue.value.code.toUByte()
|
is ObjChar -> newValue.value.code.toUByte()
|
||||||
else -> scope.raiseIllegalArgument(
|
else -> scope.raiseIllegalArgument(
|
||||||
"invalid byte value for buffer at index ${index.inspect()}: ${newValue.inspect()}"
|
"invalid byte value for buffer at index ${index.inspect(scope)}: ${newValue.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -54,7 +54,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
|
|||||||
)
|
)
|
||||||
} else
|
} else
|
||||||
scope.raiseIllegalArgument(
|
scope.raiseIllegalArgument(
|
||||||
"can't construct buffer from ${obj.inspect()}"
|
"can't construct buffer from ${obj.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -74,7 +74,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
|
|||||||
is ObjChar -> b.value.code.toUByte()
|
is ObjChar -> b.value.code.toUByte()
|
||||||
is ObjInt -> b.value.toUByte()
|
is ObjInt -> b.value.toUByte()
|
||||||
else -> scope.raiseIllegalArgument(
|
else -> scope.raiseIllegalArgument(
|
||||||
"invalid byte value for buffer constructor at index $i: ${b.inspect()}"
|
"invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
data[i] = code
|
data[i] = code
|
||||||
|
|||||||
@@ -26,12 +26,12 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
|
|||||||
|
|
||||||
override val objClass: ObjClass = type
|
override val objClass: ObjClass = type
|
||||||
|
|
||||||
override fun toString(): String {
|
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
|
||||||
val result = StringBuilder()
|
val result = StringBuilder()
|
||||||
result.append("${start?.inspect() ?: '∞'} ..")
|
result.append("${start?.inspect(scope) ?: '∞'} ..")
|
||||||
if (!isEndInclusive) result.append('<')
|
if (!isEndInclusive) result.append('<')
|
||||||
result.append(" ${end?.inspect() ?: '∞'}")
|
result.append(" ${end?.inspect(scope) ?: '∞'}")
|
||||||
return result.toString()
|
return ObjString(result.toString())
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -52,11 +52,11 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
|
|||||||
* if start is not ObjInt, raises [ObjIllegalArgumentException]
|
* if start is not ObjInt, raises [ObjIllegalArgumentException]
|
||||||
* otherwise returns start.value.toInt()
|
* otherwise returns start.value.toInt()
|
||||||
*/
|
*/
|
||||||
fun startInt(scope: Scope): Int =
|
suspend fun startInt(scope: Scope): Int =
|
||||||
if( start == null || start is ObjNull) 0
|
if( start == null || start is ObjNull) 0
|
||||||
else {
|
else {
|
||||||
if( start is ObjInt) start.value.toInt()
|
if( start is ObjInt) start.value.toInt()
|
||||||
else scope.raiseIllegalArgument("start is not Int: ${start.inspect()}")
|
else scope.raiseIllegalArgument("start is not Int: ${start.inspect(scope)}")
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
|
suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
|
||||||
|
|||||||
@@ -27,7 +27,6 @@ import kotlin.math.floor
|
|||||||
import kotlin.math.roundToLong
|
import kotlin.math.roundToLong
|
||||||
|
|
||||||
data class ObjReal(val value: Double) : Obj(), Numeric {
|
data class ObjReal(val value: Double) : Obj(), Numeric {
|
||||||
override val asStr by lazy { ObjString(value.toString()) }
|
|
||||||
override val longValue: Long by lazy { floor(value).toLong() }
|
override val longValue: Long by lazy { floor(value).toLong() }
|
||||||
override val doubleValue: Double by lazy { value }
|
override val doubleValue: Double by lazy { value }
|
||||||
override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
|
override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
|
||||||
|
|||||||
@@ -0,0 +1,112 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2025 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.obj
|
||||||
|
|
||||||
|
import net.sergeych.lyng.Scope
|
||||||
|
|
||||||
|
class ObjRegex(val regex: Regex) : Obj() {
|
||||||
|
override val objClass = type
|
||||||
|
|
||||||
|
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
return regex.find(other.cast<ObjString>(scope).value)?.let {
|
||||||
|
scope.addConst("$~", ObjRegexMatch(it))
|
||||||
|
ObjTrue
|
||||||
|
} ?: ObjFalse
|
||||||
|
}
|
||||||
|
|
||||||
|
fun find(s: ObjString): Obj =
|
||||||
|
regex.find(s.value)?.let { ObjRegexMatch(it) } ?: ObjNull
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type by lazy {
|
||||||
|
object : ObjClass("Regex") {
|
||||||
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
|
return ObjRegex(
|
||||||
|
scope.requireOnlyArg<ObjString>().value.toRegex()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}.apply {
|
||||||
|
addFn("matches") {
|
||||||
|
ObjBool(args.firstAndOnly().toString().matches(thisAs<ObjRegex>().regex))
|
||||||
|
}
|
||||||
|
addFn("find") {
|
||||||
|
thisAs<ObjRegex>().find(requireOnlyArg<ObjString>())
|
||||||
|
}
|
||||||
|
addFn("findAll") {
|
||||||
|
val s = requireOnlyArg<ObjString>().value
|
||||||
|
ObjList(thisAs<ObjRegex>().regex.findAll(s).map { ObjRegexMatch(it) }.toMutableList())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
class ObjRegexMatch(val match: MatchResult) : Obj() {
|
||||||
|
override val objClass = type
|
||||||
|
|
||||||
|
val objGroups: ObjList by lazy {
|
||||||
|
ObjList(
|
||||||
|
match.groups.map { it?.let { ObjString(it.value) } ?: ObjNull }.toMutableList()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
val objValue by lazy { ObjString(match.value) }
|
||||||
|
|
||||||
|
val objRange: ObjRange by lazy {
|
||||||
|
val r = match.range
|
||||||
|
|
||||||
|
ObjRange(
|
||||||
|
ObjInt(r.first.toLong()),
|
||||||
|
ObjInt(r.last.toLong()),
|
||||||
|
false
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
|
||||||
|
return ObjString("RegexMath(${objRange.toString(scope)},${objGroups.toString(scope)})")
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
|
return objGroups.getAt(scope, index)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||||
|
if( other === this) return 0
|
||||||
|
return -2
|
||||||
|
}
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type by lazy {
|
||||||
|
object : ObjClass("RegexMatch") {
|
||||||
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
|
scope.raiseError("RegexMatch can't be constructed directly")
|
||||||
|
}
|
||||||
|
}.apply {
|
||||||
|
addFn("groups") {
|
||||||
|
thisAs<ObjRegexMatch>().objGroups
|
||||||
|
}
|
||||||
|
addFn("value") {
|
||||||
|
thisAs<ObjRegexMatch>().objValue
|
||||||
|
}
|
||||||
|
addFn("range") {
|
||||||
|
thisAs<ObjRegexMatch>().objRange
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -44,9 +44,7 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
|
|
||||||
override fun toString(): String = value
|
override fun toString(): String = value
|
||||||
|
|
||||||
override val asStr: ObjString by lazy { this }
|
override suspend fun inspect(scope: Scope): String {
|
||||||
|
|
||||||
override fun inspect(): String {
|
|
||||||
return "\"$value\""
|
return "\"$value\""
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -54,12 +52,13 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
get() = type
|
get() = type
|
||||||
|
|
||||||
override suspend fun plus(scope: Scope, other: Obj): Obj {
|
override suspend fun plus(scope: Scope, other: Obj): Obj {
|
||||||
return ObjString(value + other.asStr.value)
|
return ObjString(value + other.toString(scope).value)
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
if (index is ObjInt) return ObjChar(value[index.toInt()])
|
when (index) {
|
||||||
if (index is ObjRange) {
|
is ObjInt -> return ObjChar(value[index.toInt()])
|
||||||
|
is ObjRange -> {
|
||||||
val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt()
|
val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt()
|
||||||
val end = if (index.end == null || index.end.isNull) value.length else {
|
val end = if (index.end == null || index.end.isNull) value.length else {
|
||||||
val e = index.end.toInt()
|
val e = index.end.toInt()
|
||||||
@@ -67,7 +66,13 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
}
|
}
|
||||||
return ObjString(value.substring(start, end))
|
return ObjString(value.substring(start, end))
|
||||||
}
|
}
|
||||||
scope.raiseIllegalArgument("String index must be Int or Range")
|
|
||||||
|
is ObjRegex -> {
|
||||||
|
return index.find(this)
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> scope.raiseIllegalArgument("String index must be Int, Regex or Range")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun hashCode(): Int {
|
override fun hashCode(): Int {
|
||||||
@@ -98,6 +103,11 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
return value == other.value
|
return value == other.value
|
||||||
}
|
}
|
||||||
|
|
||||||
|
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
val re = other.cast<ObjRegex>(scope)
|
||||||
|
return re.operatorMatch(scope, this)
|
||||||
|
}
|
||||||
|
|
||||||
override suspend fun lynonType(): LynonType = LynonType.String
|
override suspend fun lynonType(): LynonType = LynonType.String
|
||||||
|
|
||||||
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
||||||
@@ -110,7 +120,8 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
ObjString(decoder.unpackBinaryData().decodeToString())
|
ObjString(decoder.unpackBinaryData().decodeToString())
|
||||||
}.apply {
|
}.apply {
|
||||||
addFn("toInt") {
|
addFn("toInt") {
|
||||||
ObjInt(thisAs<ObjString>().value.toLongOrNull()
|
ObjInt(
|
||||||
|
thisAs<ObjString>().value.toLongOrNull()
|
||||||
?: raiseIllegalArgument("can't convert to int: $thisObj")
|
?: raiseIllegalArgument("can't convert to int: $thisObj")
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -159,6 +170,25 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
addFn("toReal") {
|
addFn("toReal") {
|
||||||
ObjReal(thisAs<ObjString>().value.toDouble())
|
ObjReal(thisAs<ObjString>().value.toDouble())
|
||||||
}
|
}
|
||||||
|
addFn("trim") {
|
||||||
|
thisAs<ObjString>().value.trim().let(::ObjString)
|
||||||
|
}
|
||||||
|
addFn("matches") {
|
||||||
|
val s = requireOnlyArg<Obj>()
|
||||||
|
val self = thisAs<ObjString>().value
|
||||||
|
ObjBool(
|
||||||
|
when (s) {
|
||||||
|
is ObjRegex -> self.matches(s.regex)
|
||||||
|
is ObjString -> {
|
||||||
|
if (s.value == ".*") true
|
||||||
|
else self.matches(s.value.toRegex())
|
||||||
|
}
|
||||||
|
|
||||||
|
else ->
|
||||||
|
raiseIllegalArgument("can't match ${s.objClass.className}: required Regex or String")
|
||||||
|
}
|
||||||
|
)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -71,7 +71,7 @@ abstract class ImportProvider(
|
|||||||
newModuleAt(pos).also {
|
newModuleAt(pos).also {
|
||||||
it.eval("import lyng.stdlib\n")
|
it.eval("import lyng.stdlib\n")
|
||||||
}
|
}
|
||||||
}.copy()
|
}.createChildScope()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -60,7 +60,7 @@ abstract class Statement(
|
|||||||
val type = ObjClass("Callable")
|
val type = ObjClass("Callable")
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.copy(args = Arguments(*args)))
|
suspend fun call(scope: Scope, vararg args: Obj) = execute(scope.createChildScope(args = Arguments(*args)))
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -77,9 +77,8 @@ fun Iterable.dropLast(n) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fun Iterable.takeLast(n) {
|
fun Iterable.takeLast(n) {
|
||||||
val list = this
|
|
||||||
val buffer = RingBuffer(n)
|
val buffer = RingBuffer(n)
|
||||||
for( item in list ) buffer += item
|
for( item in this ) buffer += item
|
||||||
buffer
|
buffer
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -104,5 +103,70 @@ fun Iterable.all(predicate): Bool {
|
|||||||
!any { !predicate(it) }
|
!any { !predicate(it) }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fun Iterable.sum() {
|
||||||
|
val i = iterator()
|
||||||
|
if( i.hasNext() ) {
|
||||||
|
var result = i.next()
|
||||||
|
while( i.hasNext() ) result += i.next()
|
||||||
|
result
|
||||||
|
}
|
||||||
|
else null
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.sumOf(f) {
|
||||||
|
val i = iterator()
|
||||||
|
if( i.hasNext() ) {
|
||||||
|
var result = f(i.next())
|
||||||
|
while( i.hasNext() ) result += f(i.next())
|
||||||
|
result
|
||||||
|
}
|
||||||
|
else null
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.sorted() {
|
||||||
|
sortedWith { a, b -> a <=> b }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.sortedBy(predicate) {
|
||||||
|
sortedWith { a, b -> predicate(a) <=> predicate(b) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.shuffled() {
|
||||||
|
toList().apply { shuffle() }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun List.toString() {
|
||||||
|
"[" + joinToString(",") + "]"
|
||||||
|
}
|
||||||
|
|
||||||
|
fun List.sortBy(predicate) {
|
||||||
|
sortWith { a, b -> predicate(a) <=> predicate(b) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun List.sort() {
|
||||||
|
sortWith { a, b -> a <=> b }
|
||||||
|
}
|
||||||
|
|
||||||
|
class StackTraceEntry(
|
||||||
|
val sourceName: String,
|
||||||
|
val line: Int,
|
||||||
|
val column: Int,
|
||||||
|
val sourceString: String
|
||||||
|
) {
|
||||||
|
fun toString() {
|
||||||
|
"%s:%d:%d: %s"(sourceName, line, column, sourceString.trim())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Exception.printStackTrace() {
|
||||||
|
println(this)
|
||||||
|
for( entry in stackTrace() ) {
|
||||||
|
println("\tat "+entry)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun String.re() { Regex(this) }
|
||||||
|
|
||||||
|
|
||||||
""".trimIndent()
|
""".trimIndent()
|
||||||
|
|
||||||
@@ -17,8 +17,10 @@
|
|||||||
|
|
||||||
package net.sergeych.lynon
|
package net.sergeych.lynon
|
||||||
|
|
||||||
|
import kotlin.math.min
|
||||||
|
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
interface BitList {
|
interface BitList: Comparable<BitList> {
|
||||||
operator fun get(bitIndex: Long): Int
|
operator fun get(bitIndex: Long): Int
|
||||||
operator fun set(bitIndex: Long,value: Int)
|
operator fun set(bitIndex: Long,value: Int)
|
||||||
val size: Long
|
val size: Long
|
||||||
@@ -31,6 +33,22 @@ interface BitList {
|
|||||||
if( index < size) this@BitList[index++]
|
if( index < size) this@BitList[index++]
|
||||||
else null
|
else null
|
||||||
}
|
}
|
||||||
|
|
||||||
|
override fun compareTo(other: BitList): Int {
|
||||||
|
val m = min(size, other.size)
|
||||||
|
for( i in 0 ..< m) {
|
||||||
|
val a = this[i]
|
||||||
|
val b = other[i]
|
||||||
|
when {
|
||||||
|
a < b -> return -1
|
||||||
|
a > b -> return 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if( size > other.size) return 1
|
||||||
|
if( size < other.size) return -1
|
||||||
|
return 0
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fun bitListOf(vararg bits: Int): BitList {
|
fun bitListOf(vararg bits: Int): BitList {
|
||||||
|
|||||||
@@ -101,7 +101,6 @@ interface BitOutput {
|
|||||||
val compressed = LZW.compress(source.asUByteArray())
|
val compressed = LZW.compress(source.asUByteArray())
|
||||||
// check that compression is effective including header bits size:
|
// check that compression is effective including header bits size:
|
||||||
if( compressed.size + 2 < source.size * 8L) {
|
if( compressed.size + 2 < source.size * 8L) {
|
||||||
println("write compressed")
|
|
||||||
putBit(1)
|
putBit(1)
|
||||||
// LZW algorithm
|
// LZW algorithm
|
||||||
putBits(0, 2)
|
putBits(0, 2)
|
||||||
|
|||||||
@@ -63,6 +63,19 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decode any object with [decodeAny] and cast it to [T] or raise Lyng's class cast error
|
||||||
|
* with [Scope.raiseClassCastError].
|
||||||
|
*
|
||||||
|
* @return T typed Lyng object
|
||||||
|
*/
|
||||||
|
suspend inline fun <reified T : Obj> decodeAnyAs(scope: Scope): T {
|
||||||
|
val x = decodeAny(scope)
|
||||||
|
return (x as? T) ?: scope.raiseClassCastError(
|
||||||
|
"Expected ${T::class.simpleName} but got $x"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
private suspend fun decodeClassObj(scope: Scope): ObjClass {
|
private suspend fun decodeClassObj(scope: Scope): ObjClass {
|
||||||
val className = decodeObject(scope, ObjString.type, null) as ObjString
|
val className = decodeObject(scope, ObjString.type, null) as ObjString
|
||||||
return scope.get(className.value)?.value?.let {
|
return scope.get(className.value)?.value?.let {
|
||||||
@@ -72,20 +85,21 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
|
|||||||
} ?: scope.raiseSymbolNotFound("can't deserialize: not found type $className")
|
} ?: scope.raiseSymbolNotFound("can't deserialize: not found type $className")
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun decodeAnyList(scope: Scope,fixedSize: Int?=null): MutableList<Obj> {
|
suspend fun decodeAnyList(scope: Scope, fixedSize: Int? = null): MutableList<Obj> {
|
||||||
return if (bin.getBit() == 1) {
|
return if (bin.getBit() == 1) {
|
||||||
// homogenous
|
// homogenous
|
||||||
val type = LynonType.entries[getBitsAsInt(4)]
|
val type = LynonType.entries[getBitsAsInt(4)]
|
||||||
val list = mutableListOf<Obj>()
|
val list = mutableListOf<Obj>()
|
||||||
val objClass = if (type == LynonType.Other)
|
val objClass = if (type == LynonType.Other)
|
||||||
decodeClassObj(scope).also { println("detected class obj: $it") }
|
decodeClassObj(scope)//.also { println("detected class obj: $it") }
|
||||||
else type.objClass
|
else type.objClass
|
||||||
val size = fixedSize ?: bin.unpackUnsigned().toInt()
|
val size = fixedSize ?: bin.unpackUnsigned().toInt()
|
||||||
println("detected homogenous list type $type, $size items")
|
// println("detected homogenous list type $type, $size items")
|
||||||
for (i in 0..<size) {
|
for (i in 0..<size) {
|
||||||
list += decodeObject(scope, objClass, type).also {
|
list += decodeObject(scope, objClass, type)
|
||||||
println("decoded: $it")
|
//.also {
|
||||||
}
|
// println("decoded: $it")
|
||||||
|
// }
|
||||||
}
|
}
|
||||||
list
|
list
|
||||||
} else {
|
} else {
|
||||||
|
|||||||
@@ -17,13 +17,18 @@
|
|||||||
|
|
||||||
package net.sergeych.lynon
|
package net.sergeych.lynon
|
||||||
|
|
||||||
|
import kotlinx.serialization.Serializable
|
||||||
import kotlin.math.min
|
import kotlin.math.min
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* BitList implementation as fixed suze array of bits; indexing works exactly same as if
|
* BitList implementation as fixed suze array of bits; indexing works exactly same as if
|
||||||
* [MemoryBitInput] is used with [MemoryBitInput.getBit]. See [MemoryBitOutput] for
|
* [MemoryBitInput] is used with [MemoryBitInput.getBit]. See [MemoryBitOutput] for
|
||||||
* bits order and more information.
|
* bits order and more information.
|
||||||
|
*
|
||||||
|
* It is [BitList] - comparable, and provides valid [hashCode] and [equals], so it could
|
||||||
|
* also be used as a key in maps.
|
||||||
*/
|
*/
|
||||||
|
@Serializable
|
||||||
class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
|
class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
|
||||||
|
|
||||||
val bytesSize: Int get() = bytes.size
|
val bytesSize: Int get() = bytes.size
|
||||||
@@ -73,7 +78,21 @@ class BitArray(val bytes: UByteArray, val lastByteBits: Int) : BitList {
|
|||||||
fun asByteArray(): ByteArray = bytes.asByteArray()
|
fun asByteArray(): ByteArray = bytes.asByteArray()
|
||||||
|
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
fun asUbyteArray(): UByteArray = bytes
|
fun asUByteArray(): UByteArray = bytes
|
||||||
|
|
||||||
|
override fun equals(other: Any?): Boolean {
|
||||||
|
return when(other) {
|
||||||
|
is BitArray ->
|
||||||
|
// important: size must match as trailing zero bits will generate false eq otherwise:
|
||||||
|
size == other.size && bytes contentEquals other.bytes
|
||||||
|
is BitList -> compareTo(other) == 0
|
||||||
|
else -> false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
override fun hashCode(): Int {
|
||||||
|
return bytes.contentHashCode()
|
||||||
|
}
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
|
|
||||||
|
|||||||
@@ -17,6 +17,8 @@
|
|||||||
|
|
||||||
package net.sergeych.lynon
|
package net.sergeych.lynon
|
||||||
|
|
||||||
|
import kotlin.random.Random
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Hoq many tetrades needed to store the value. It is faster to use this function
|
* Hoq many tetrades needed to store the value. It is faster to use this function
|
||||||
* than to use sizeInBits
|
* than to use sizeInBits
|
||||||
@@ -35,7 +37,7 @@ fun sizeInTetrades(value: ULong): Int {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* How many bits needed to store the value. Size for 0 is 1,
|
* Calculates ow many bits needed to store the value. Size for 0, for example, is 1.
|
||||||
*/
|
*/
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
fun sizeInBits(value: ULong): Int {
|
fun sizeInBits(value: ULong): Int {
|
||||||
@@ -50,3 +52,20 @@ fun sizeInBits(value: ULong): Int {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fun sizeInBits(value: Int): Int = sizeInBits(value.toULong())
|
fun sizeInBits(value: Int): Int = sizeInBits(value.toULong())
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Generates a random BitArray of the specified size. Important: this is
|
||||||
|
* __not cryptographically secure__. Use random from [crypto2](https://gitea.sergeych.net/sergeych/crypto2),
|
||||||
|
* `randomInt()`, `randomUBytes()`, etc., for cryptographically secure random data.
|
||||||
|
*
|
||||||
|
* @param sizeInBits The size of the BitArray to generate in bits.
|
||||||
|
* @return A BitArray of the specified size filled with random bits.
|
||||||
|
*/
|
||||||
|
@Suppress("unused")
|
||||||
|
fun BitArray.Companion.random(sizeInBits: Int): BitArray {
|
||||||
|
val result = BitArray.withBitSize(sizeInBits.toLong())
|
||||||
|
for (i in 0..<sizeInBits) {
|
||||||
|
result[i.toLong()] = Random.nextInt() and 1
|
||||||
|
}
|
||||||
|
return result
|
||||||
|
}
|
||||||
@@ -18,7 +18,6 @@
|
|||||||
package net.sergeych.lynon
|
package net.sergeych.lynon
|
||||||
|
|
||||||
import net.sergeych.collections.SortedList
|
import net.sergeych.collections.SortedList
|
||||||
import net.sergeych.lynon.Huffman.Alphabet
|
|
||||||
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -285,7 +284,7 @@ object Huffman {
|
|||||||
|
|
||||||
fun <T>decompress(bin: BitInput,alphabet: Alphabet<T>): UByteArray {
|
fun <T>decompress(bin: BitInput,alphabet: Alphabet<T>): UByteArray {
|
||||||
val codes = deserializeCanonicCodes(bin, alphabet)
|
val codes = deserializeCanonicCodes(bin, alphabet)
|
||||||
return decompressUsingCodes(bin, codes, alphabet).asUbyteArray()
|
return decompressUsingCodes(bin, codes, alphabet).asUByteArray()
|
||||||
}
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
@@ -21,7 +21,9 @@ import net.sergeych.bintools.ByteChunk
|
|||||||
import kotlin.math.roundToInt
|
import kotlin.math.roundToInt
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* LZW lightweight pure kotlin compression.
|
* LZW lightweight pure kotlin compression. LZW works with but streams [BitInput] and [BitOutput]
|
||||||
|
* to be used effectively in Lynon or other bit-grained formats. To safely comress byte arresy and
|
||||||
|
* strings without boilerplate use [lzwCompress], [lzwDecompress], [lzwCompressUtf8] and [lzwDecompressUtf8].
|
||||||
*/
|
*/
|
||||||
object LZW {
|
object LZW {
|
||||||
|
|
||||||
@@ -30,8 +32,10 @@ object LZW {
|
|||||||
val MAX_DICT_SIZE = (STOP_CODE * 0.92).roundToInt()
|
val MAX_DICT_SIZE = (STOP_CODE * 0.92).roundToInt()
|
||||||
|
|
||||||
|
|
||||||
fun compress(input: ByteArray, bitOutput: BitOutput)
|
/**
|
||||||
= compress(input.asUByteArray(), bitOutput)
|
* Compress a byte array using LZW algorithm writing the result to [bitOutput]
|
||||||
|
*/
|
||||||
|
fun compress(input: ByteArray, bitOutput: BitOutput) = compress(input.asUByteArray(), bitOutput)
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Compresses the input string using LZW algorithm
|
* Compresses the input string using LZW algorithm
|
||||||
@@ -139,7 +143,42 @@ object LZW {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
private operator fun ByteChunk.plus(byte: UByte): ByteChunk {
|
private operator fun ByteChunk.plus(byte: UByte): ByteChunk {
|
||||||
return ByteChunk(data + byte)
|
return ByteChunk(data + byte)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Safely compress binary byte data using the LZW algorithm. This can use up to one byte more space than
|
||||||
|
* with [LZW.compress] and [BitOutput] but you often need byte array operations. Source data size is also
|
||||||
|
* encoded to prevent file-bomb-like attacks. Note that content protection is not included (we assume
|
||||||
|
* LZW is robust).
|
||||||
|
* @param source the data to compress
|
||||||
|
*/
|
||||||
|
fun lzwCompress(source: UByteArray): UByteArray {
|
||||||
|
val out = MemoryBitOutput()
|
||||||
|
out.packUnsigned(source.size.toULong())
|
||||||
|
LZW.compress(source, out)
|
||||||
|
return out.toBitArray().asUByteArray()
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Safely decompress data compressed with [lzwCompress], checking size. Contect checks are not implemented
|
||||||
|
* here as we assume LZW is robust.
|
||||||
|
* @param packed the compressed data
|
||||||
|
* @throws DecompressionException if something goes wrong, like size mismatch or bad compressed data
|
||||||
|
*/
|
||||||
|
fun lzwDecompress(packed: UByteArray): UByteArray {
|
||||||
|
val inp = MemoryBitInput(packed, 8)
|
||||||
|
val size = inp.unpackUnsigned()
|
||||||
|
return LZW.decompress(inp, size.toInt())
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Compress a text using utf-8 encoding and [lzwCompress]
|
||||||
|
*/
|
||||||
|
fun lzwCompressUtf8(text: String) = lzwCompress(text.encodeToByteArray().toUByteArray())
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decompress a text compressed with [lzwCompressUtf8]. See also [lzwDecompress]
|
||||||
|
*/
|
||||||
|
fun lzwDecompressUtf8(packed: UByteArray): String = lzwDecompress(packed).asByteArray().decodeToString()
|
||||||
@@ -56,7 +56,7 @@ object ObjLynonClass : ObjClass("Lynon") {
|
|||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
suspend fun lynonEncodeAny(scope: Scope, value: Obj): UByteArray =
|
suspend fun lynonEncodeAny(scope: Scope, value: Obj): UByteArray =
|
||||||
(ObjLynonClass.encodeAny(scope, value))
|
(ObjLynonClass.encodeAny(scope, value))
|
||||||
.bitArray.asUbyteArray()
|
.bitArray.asUByteArray()
|
||||||
|
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
suspend fun lynonDecodeAny(scope: Scope, encoded: UByteArray): Obj =
|
suspend fun lynonDecodeAny(scope: Scope, encoded: UByteArray): Obj =
|
||||||
|
|||||||
@@ -1,16 +0,0 @@
|
|||||||
|
|
||||||
fun Iterable.filter( predicate ) {
|
|
||||||
flow {
|
|
||||||
for( item in this )
|
|
||||||
if( predicate(item) )
|
|
||||||
emit(item)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fun Iterable.drop(n) {
|
|
||||||
require( n >= 0, "drop amount must be non-negative")
|
|
||||||
var count = 0
|
|
||||||
filter {
|
|
||||||
count++ < N
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@@ -106,4 +106,84 @@ class OOTest {
|
|||||||
}
|
}
|
||||||
""".trimIndent())
|
""".trimIndent())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testDynamicIndexAccess() = runTest {
|
||||||
|
eval("""
|
||||||
|
val store = Map()
|
||||||
|
val accessor = dynamic {
|
||||||
|
get { name ->
|
||||||
|
store[name]
|
||||||
|
}
|
||||||
|
set { name, value ->
|
||||||
|
store[name] = value
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals(null, accessor["foo"])
|
||||||
|
assertEquals(null, accessor.foo)
|
||||||
|
accessor["foo"] = "bar"
|
||||||
|
assertEquals("bar", accessor["foo"])
|
||||||
|
assertEquals("bar", accessor.foo)
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testMultilineConstructor() = runTest {
|
||||||
|
eval("""
|
||||||
|
class Point(
|
||||||
|
x,
|
||||||
|
y
|
||||||
|
)
|
||||||
|
assertEquals(Point(1,2), Point(1,2) )
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testDynamicClass() = runTest {
|
||||||
|
eval("""
|
||||||
|
|
||||||
|
fun getContract(contractName) {
|
||||||
|
dynamic {
|
||||||
|
get { name ->
|
||||||
|
println("Call: %s.%s"(contractName,name))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
getContract("foo").bar
|
||||||
|
""")
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testDynamicClassReturn2() = runTest {
|
||||||
|
// todo: should work without extra parenthesis
|
||||||
|
// see below
|
||||||
|
eval("""
|
||||||
|
|
||||||
|
fun getContract(contractName) {
|
||||||
|
println("1")
|
||||||
|
dynamic {
|
||||||
|
get { name ->
|
||||||
|
println("innrer %s.%s"(contractName,name))
|
||||||
|
{ args... ->
|
||||||
|
if( name == "bar" ) args.sum() else null
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val cc = dynamic {
|
||||||
|
get { name ->
|
||||||
|
println("Call cc %s"(name))
|
||||||
|
getContract(name)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
val x = cc.foo.bar
|
||||||
|
println(x)
|
||||||
|
x(1,2,3)
|
||||||
|
assertEquals(6, x(1,2,3))
|
||||||
|
// v HERE v
|
||||||
|
assertEquals(15, cc.foo.bar(10,2,3))
|
||||||
|
""")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -1184,6 +1184,35 @@ class ScriptTest {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testOpenEndRanges2() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
var r = 5..; var r2 = 6..
|
||||||
|
val r3 = 7.. // open end
|
||||||
|
assert( r::class == Range)
|
||||||
|
assert( r.end == null)
|
||||||
|
assert( r.start == 5)
|
||||||
|
|
||||||
|
assert( r3::class == Range)
|
||||||
|
assertEquals( r3.end, null)
|
||||||
|
assert( r3.start == 7)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testOpenEndRanges3() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val r3 = 7.. // open end with comment
|
||||||
|
assert( r3::class == Range)
|
||||||
|
assertEquals( r3.end, null)
|
||||||
|
assert( r3.start == 7)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testCharacterRange() = runTest {
|
fun testCharacterRange() = runTest {
|
||||||
eval(
|
eval(
|
||||||
@@ -1760,7 +1789,7 @@ class ScriptTest {
|
|||||||
"e="+e+"f="+f()
|
"e="+e+"f="+f()
|
||||||
}
|
}
|
||||||
assertEquals("e=[]f=xx", f { "xx" })
|
assertEquals("e=[]f=xx", f { "xx" })
|
||||||
assertEquals("e=[1, 2]f=xx", f(1,2) { "xx" })
|
assertEquals("e=[1,2]f=xx", f(1,2) { "xx" })
|
||||||
""".trimIndent()
|
""".trimIndent()
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -1795,7 +1824,7 @@ class ScriptTest {
|
|||||||
}
|
}
|
||||||
val f = Foo()
|
val f = Foo()
|
||||||
assertEquals("e=[]f=xx", f.f { "xx" })
|
assertEquals("e=[]f=xx", f.f { "xx" })
|
||||||
assertEquals("e=[1, 2]f=xx", f.f(1,2) { "xx" })
|
assertEquals("e=[1,2]f=xx", f.f(1,2) { "xx" })
|
||||||
""".trimIndent()
|
""".trimIndent()
|
||||||
)
|
)
|
||||||
|
|
||||||
@@ -2006,7 +2035,7 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testThrowFromKotlin() = runTest {
|
fun testThrowFromKotlin() = runTest {
|
||||||
val c = Scope()
|
val c = Script.newScope()
|
||||||
c.addFn("callThrow") {
|
c.addFn("callThrow") {
|
||||||
raiseIllegalArgument("fromKotlin")
|
raiseIllegalArgument("fromKotlin")
|
||||||
}
|
}
|
||||||
@@ -2213,6 +2242,45 @@ class ScriptTest {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testParseSpecialVars() {
|
||||||
|
val l = parseLyng("$~".toSource("test$~"))
|
||||||
|
println(l)
|
||||||
|
assertEquals(Token.Type.ID, l[0].type)
|
||||||
|
assertEquals("$~", l[0].value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testMatchOperator() = runTest {
|
||||||
|
eval("""
|
||||||
|
assert( "abc123".matches(".*\d{3}") )
|
||||||
|
assert( ".*\d{3}".re =~ "abc123" )
|
||||||
|
assert( "abc123" =~ ".*\d{3}".re )
|
||||||
|
assert( "abc123" !~ ".*\d{4}".re )
|
||||||
|
|
||||||
|
"abc123" =~ ".*(\d)(\d)(\d)$".re
|
||||||
|
println($~)
|
||||||
|
assertEquals("1", $~[1])
|
||||||
|
assertEquals("2", $~[2])
|
||||||
|
assertEquals("3", $~[3])
|
||||||
|
assertEquals("abc123", $~[0])
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
// @Test
|
||||||
|
// fun testWhenMatch() = runTest {
|
||||||
|
// eval(
|
||||||
|
// """
|
||||||
|
// when("abc123") {
|
||||||
|
// ".*(\d)(\d)(\d)".re -> { x ->
|
||||||
|
// assertEquals("123", x[0])
|
||||||
|
// }
|
||||||
|
// else -> assert(false)
|
||||||
|
// }
|
||||||
|
// """.trimIndent()
|
||||||
|
// )
|
||||||
|
// }
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testWhenSample1() = runTest {
|
fun testWhenSample1() = runTest {
|
||||||
eval(
|
eval(
|
||||||
@@ -2632,7 +2700,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testBufferEncodings() = runTest {
|
fun testBufferEncodings() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
import lyng.buffer
|
import lyng.buffer
|
||||||
|
|
||||||
val b = Buffer("hello")
|
val b = Buffer("hello")
|
||||||
@@ -2647,7 +2716,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
println(b.inspect())
|
println(b.inspect())
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -2871,7 +2941,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun tesFunAnnotation() = runTest {
|
fun tesFunAnnotation() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
|
|
||||||
val exportedSymbols = Map()
|
val exportedSymbols = Map()
|
||||||
|
|
||||||
@@ -2890,7 +2961,8 @@ class ScriptTest {
|
|||||||
assert( exportedSymbols["getBalance"] != null )
|
assert( exportedSymbols["getBalance"] != null )
|
||||||
assertEquals(122, getBalance(1))
|
assertEquals(122, getBalance(1))
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -2910,12 +2982,14 @@ class ScriptTest {
|
|||||||
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
||||||
|
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun enumSerializationTest() = runTest {
|
fun enumSerializationTest() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
import lyng.serialization
|
import lyng.serialization
|
||||||
|
|
||||||
enum Color {
|
enum Color {
|
||||||
@@ -2931,12 +3005,14 @@ class ScriptTest {
|
|||||||
assert( e1.size / 1000.0 < 6)
|
assert( e1.size / 1000.0 < 6)
|
||||||
println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
|
println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun cachedTest() = runTest {
|
fun cachedTest() = runTest {
|
||||||
eval( """
|
eval(
|
||||||
|
"""
|
||||||
|
|
||||||
var counter = 0
|
var counter = 0
|
||||||
var value = cached {
|
var value = cached {
|
||||||
@@ -2949,17 +3025,329 @@ class ScriptTest {
|
|||||||
assertEquals(1, counter)
|
assertEquals(1, counter)
|
||||||
assertEquals("ok", value())
|
assertEquals("ok", value())
|
||||||
assertEquals(1, counter)
|
assertEquals(1, counter)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testJoinToString() = runTest {
|
fun testJoinToString() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
assertEquals( (1..3).joinToString(), "1 2 3")
|
assertEquals( (1..3).joinToString(), "1 2 3")
|
||||||
assertEquals( (1..3).joinToString(":"), "1:2:3")
|
assertEquals( (1..3).joinToString(":"), "1:2:3")
|
||||||
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testElvisAndThrow() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = assertThrows {
|
||||||
|
null ?: throw "test" + "x"
|
||||||
|
}
|
||||||
|
assertEquals( "testx", x.message)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testElvisAndThrow2() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val t = "112"
|
||||||
|
val x = t ?: run { throw "testx" }
|
||||||
|
}
|
||||||
|
assertEquals( "112", x)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testElvisAndRunThrow() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = assertThrows {
|
||||||
|
null ?: run { throw "testx" }
|
||||||
|
}
|
||||||
|
assertEquals( "testx", x.message)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testNewlinesAnsCommentsInExpressions() = runTest {
|
||||||
|
assertEquals(
|
||||||
|
2, (Scope().eval(
|
||||||
|
"""
|
||||||
|
val e = 1 + 4 -
|
||||||
|
3
|
||||||
|
""".trimIndent()
|
||||||
|
)).toInt()
|
||||||
|
)
|
||||||
|
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = [1,2,3]
|
||||||
|
.map { it * 10 }
|
||||||
|
.map { it + 1 }
|
||||||
|
assertEquals( [11,21,31], x)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testNotExpressionWithoutWs() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun test() { false }
|
||||||
|
class T(value)
|
||||||
|
assert( !false )
|
||||||
|
assert( !test() )
|
||||||
|
assert( !test() )
|
||||||
|
val t = T(false)
|
||||||
|
assert( !t.value )
|
||||||
|
assert( !if( true ) false else true )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testMultilineFnDeclaration() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun test(
|
||||||
|
x = 1,
|
||||||
|
y = 2
|
||||||
|
) {
|
||||||
|
x * y
|
||||||
|
}
|
||||||
|
assertEquals( 10, test(5) )
|
||||||
|
assertEquals( 42, test(
|
||||||
|
6,
|
||||||
|
7
|
||||||
|
) )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testOverridenListToString() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = [1,2,3]
|
||||||
|
assertEquals( "[1,2,3]", x.toString() )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testExceptionSerialization() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
import lyng.serialization
|
||||||
|
val x = [1,2,3]
|
||||||
|
assertEquals( "[1,2,3]", x.toString() )
|
||||||
|
try {
|
||||||
|
require(false)
|
||||||
|
}
|
||||||
|
catch (e) {
|
||||||
|
println(e.stackTrace)
|
||||||
|
e.printStackTrace()
|
||||||
|
val coded = Lynon.encode(e)
|
||||||
|
val decoded = Lynon.decode(coded)
|
||||||
|
assertEquals( e::class, decoded::class )
|
||||||
|
assertEquals( e.stackTrace, decoded.stackTrace )
|
||||||
|
assertEquals( e.message, decoded.message )
|
||||||
|
println("-------------------- e")
|
||||||
|
println(e.toString())
|
||||||
|
println("-------------------- dee")
|
||||||
|
println(decoded.toString())
|
||||||
|
assertEquals( e.toString(), decoded.toString() )
|
||||||
|
}
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testExceptionSerializationPlain() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
import lyng.serialization
|
||||||
|
val x = [1,2,3]
|
||||||
|
assertEquals( "[1,2,3]", x.toString() )
|
||||||
|
try {
|
||||||
|
throw "test"
|
||||||
|
}
|
||||||
|
catch (e) {
|
||||||
|
println(e.stackTrace)
|
||||||
|
e.printStackTrace()
|
||||||
|
val coded = Lynon.encode(e)
|
||||||
|
val decoded = Lynon.decode(coded)
|
||||||
|
assertEquals( e::class, decoded::class )
|
||||||
|
assertEquals( e.stackTrace, decoded.stackTrace )
|
||||||
|
assertEquals( e.message, decoded.message )
|
||||||
|
println("-------------------- e")
|
||||||
|
println(e.toString())
|
||||||
|
println("-------------------- dee")
|
||||||
|
println(decoded.toString())
|
||||||
|
assertEquals( e.toString(), decoded.toString() )
|
||||||
|
}
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testThisInClosure() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun Iterable.sum2by(f) {
|
||||||
|
var acc = null
|
||||||
|
for( x in this ) {
|
||||||
|
println(x)
|
||||||
|
println(f(x))
|
||||||
|
acc = acc?.let { acc + f(x) } ?: f(x)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
class T(val coll, val factor) {
|
||||||
|
fun sum() {
|
||||||
|
// here we use ths::T and it must be available:
|
||||||
|
coll.sum2by { it * factor }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals(60, T([1,2,3], 10).sum())
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testThisInFlowClosure() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
class T(val coll, val factor) {
|
||||||
|
fun seq() {
|
||||||
|
flow {
|
||||||
|
for( x in coll ) {
|
||||||
|
emit(x*factor)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals([10,20,30], T([1,2,3], 10).seq().toList())
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testSum() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
assertEquals(1, [1].sum())
|
||||||
|
assertEquals(null, [].sum())
|
||||||
|
assertEquals(6, [1,2,3].sum())
|
||||||
|
assertEquals(30, [3].sumOf { it * 10 })
|
||||||
|
assertEquals(null, [].sumOf { it * 10 })
|
||||||
|
assertEquals(60, [1,2,3].sumOf { it * 10 })
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testSort() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val coll = [5,4,1,7]
|
||||||
|
assertEquals( [1,4,5,7], coll.sortedWith { a,b -> a <=> b })
|
||||||
|
assertEquals( [1,4,5,7], coll.sorted())
|
||||||
|
assertEquals( [7,5,4,1], coll.sortedBy { -it })
|
||||||
|
assertEquals( [1,4,5,7], coll.sortedBy { -it }.reversed())
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testListSortInPlace() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val l1 = [6,3,1,9]
|
||||||
|
l1.sort()
|
||||||
|
assertEquals( [1,3,6,9], l1)
|
||||||
|
l1.sortBy { -it }
|
||||||
|
assertEquals( [1,3,6,9].reversed(), l1)
|
||||||
|
l1.sort()
|
||||||
|
l1.sortBy { it % 4 }
|
||||||
|
// 1,3,6,9
|
||||||
|
// 1 3 2 1
|
||||||
|
// we hope we got it also stable:
|
||||||
|
assertEquals( [1,9,6,3], l1)
|
||||||
|
"""
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun binarySearchTest() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val coll = [1,2,3,4,5]
|
||||||
|
assertEquals( 2, coll.binarySearch(3) )
|
||||||
|
assertEquals( 0, coll.binarySearch(1) )
|
||||||
|
assertEquals( 4, coll.binarySearch(5) )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun binarySearchTest2() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val src = (1..50).toList().shuffled()
|
||||||
|
val result = []
|
||||||
|
for( x in src ) {
|
||||||
|
val i = result.binarySearch(x)
|
||||||
|
assert( i < 0 )
|
||||||
|
result.insertAt(-i-1, x)
|
||||||
|
}
|
||||||
|
assertEquals( src.sorted(), result )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// @Test
|
||||||
|
// fun testMinimumOptimization() = runTest {
|
||||||
|
// val x = Scope().eval(
|
||||||
|
// """
|
||||||
|
// fun naiveCountHappyNumbers() {
|
||||||
|
// var count = 0
|
||||||
|
// for( n1 in 0..9 )
|
||||||
|
// for( n2 in 0..9 )
|
||||||
|
// for( n3 in 0..9 )
|
||||||
|
// for( n4 in 0..9 )
|
||||||
|
// for( n5 in 0..9 )
|
||||||
|
// for( n6 in 0..9 )
|
||||||
|
// if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
|
||||||
|
// count
|
||||||
|
// }
|
||||||
|
// naiveCountHappyNumbers()
|
||||||
|
// """.trimIndent()
|
||||||
|
// ).toInt()
|
||||||
|
// assertEquals(55252, x)
|
||||||
|
// }
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRegex1() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
assert( ! "123".re.matches("abs123def") )
|
||||||
|
assert( ".*123.*".re.matches("abs123def") )
|
||||||
|
// assertEquals( "123", "123".re.find("abs123def")?.value )
|
||||||
|
// assertEquals( "123", "[0-9]{3}".re.find("abs123def")?.value )
|
||||||
|
assertEquals( "123", "\d{3}".re.find("abs123def")?.value )
|
||||||
|
assertEquals( "123", "\\d{3}".re.find("abs123def")?.value )
|
||||||
|
assertEquals( [1,2,3], "\d".re.findAll("abs123def").map { it.value.toInt() } )
|
||||||
|
"""
|
||||||
|
.trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -177,11 +177,11 @@ suspend fun DocTest.test(_scope: Scope? = null) {
|
|||||||
scope.apply {
|
scope.apply {
|
||||||
addFn("println") {
|
addFn("println") {
|
||||||
if( bookMode ) {
|
if( bookMode ) {
|
||||||
println("${currentTest.fileNamePart}:${currentTest.line}> ${args.joinToString(" "){it.asStr.value}}")
|
println("${currentTest.fileNamePart}:${currentTest.line}> ${args.map{it.toString(this).value}.joinToString(" ")}")
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
for ((i, a) in args.withIndex()) {
|
for ((i, a) in args.withIndex()) {
|
||||||
if (i > 0) collectedOutput.append(' '); collectedOutput.append(a.asStr.value)
|
if (i > 0) collectedOutput.append(' '); collectedOutput.append(a.toString(this).value)
|
||||||
collectedOutput.append('\n')
|
collectedOutput.append('\n')
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -194,7 +194,7 @@ suspend fun DocTest.test(_scope: Scope? = null) {
|
|||||||
} catch (e: Throwable) {
|
} catch (e: Throwable) {
|
||||||
error = e
|
error = e
|
||||||
null
|
null
|
||||||
}?.inspect()?.replace(Regex("@\\d+"), "@...")
|
}?.inspect(scope)?.replace(Regex("@\\d+"), "@...")
|
||||||
|
|
||||||
if (bookMode) {
|
if (bookMode) {
|
||||||
if (error != null) {
|
if (error != null) {
|
||||||
@@ -322,4 +322,18 @@ class BookTest {
|
|||||||
runDocTests("../docs/Iterable.md")
|
runDocTests("../docs/Iterable.md")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testSerialization() = runBlocking {
|
||||||
|
runDocTests("../docs/serialization.md")
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testArray() = runBlocking {
|
||||||
|
runDocTests("../docs/Array.md")
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRegex() = runBlocking {
|
||||||
|
runDocTests("../docs/Regex.md")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -397,6 +397,13 @@ class LynonTests {
|
|||||||
assertEquals(original, decompressed)
|
assertEquals(original, decompressed)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testCompressed() {
|
||||||
|
val compressed = lzwCompressUtf8(original)
|
||||||
|
println("${compressed.size/original.encodeToByteArray().size.toDouble()} compression ratio")
|
||||||
|
assertEquals(original, lzwDecompressUtf8(compressed))
|
||||||
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testTinyBits() {
|
fun testTinyBits() {
|
||||||
var a0 = TinyBits()
|
var a0 = TinyBits()
|
||||||
@@ -649,6 +656,48 @@ class LynonTests {
|
|||||||
""".trimIndent())
|
""".trimIndent())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testTokenFailure() = runTest {
|
||||||
|
val s = Scope()
|
||||||
|
val t = s.eval(
|
||||||
|
"""
|
||||||
|
import lyng.serialization
|
||||||
|
import lyng.buffer
|
||||||
|
import lyng.time
|
||||||
|
|
||||||
|
class Wallet( id, ownerKey, balance=0, createdAt=Instant.now().truncateToSecond(), isBlocked=false) {
|
||||||
|
|
||||||
|
/*
|
||||||
|
Create new key for the given owner multikey
|
||||||
|
*/
|
||||||
|
static fun new( ownerKey ) {
|
||||||
|
|
||||||
|
// this is per-contract unique id generated and approved by the network.
|
||||||
|
// it is not random, but it _is_ unique, and we use it as a walletId.
|
||||||
|
val newId = Buffer("testid")
|
||||||
|
|
||||||
|
val w = Wallet(newId, ownerKey)
|
||||||
|
println(w)
|
||||||
|
println(w.balance)
|
||||||
|
|
||||||
|
val x = Lynon.encode(Wallet(newId, ownerKey) ).toBuffer()
|
||||||
|
val t = Lynon.decode(x.toBitInput())
|
||||||
|
println(x)
|
||||||
|
println(t)
|
||||||
|
assertEquals(w.balance, t.balance)
|
||||||
|
w
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
Wallet.new(Buffer("1234"))
|
||||||
|
|
||||||
|
""".trimIndent())
|
||||||
|
println(t)
|
||||||
|
// val bb = lynonEncodeAny(s, t)
|
||||||
|
// val t2 = lynonDecodeAny(s, bb)
|
||||||
|
// println(t2.readField(s, "balance"))
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -22,7 +22,10 @@ import net.sergeych.lyng.Source
|
|||||||
import net.sergeych.lyng.eval
|
import net.sergeych.lyng.eval
|
||||||
import net.sergeych.lyng.pacman.InlineSourcesImportProvider
|
import net.sergeych.lyng.pacman.InlineSourcesImportProvider
|
||||||
import net.sergeych.lyng.toSource
|
import net.sergeych.lyng.toSource
|
||||||
|
import net.sergeych.lynon.BitArray
|
||||||
|
import net.sergeych.lynon.BitList
|
||||||
import kotlin.test.Test
|
import kotlin.test.Test
|
||||||
|
import kotlin.test.assertNotEquals
|
||||||
|
|
||||||
class OtherTests {
|
class OtherTests {
|
||||||
@Test
|
@Test
|
||||||
@@ -67,4 +70,33 @@ class OtherTests {
|
|||||||
Unit
|
Unit
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testBitArrayEqAndHash() {
|
||||||
|
|
||||||
|
val b1 = BitArray.ofBits(1, 0, 1, 1)
|
||||||
|
val b11 = BitArray.ofBits(1, 0, 1, 1)
|
||||||
|
val b2 = BitArray.ofBits(1, 1, 1, 1)
|
||||||
|
val b3 = BitArray.ofBits(1, 0, 1, 1, 0)
|
||||||
|
|
||||||
|
assert( b3 > b1 )
|
||||||
|
assert( b2 > b1)
|
||||||
|
assert( b11.compareTo(b1) == 0)
|
||||||
|
|
||||||
|
assertEquals(b1, b11)
|
||||||
|
assertNotEquals(b1, b2)
|
||||||
|
assertNotEquals(b1, b3)
|
||||||
|
|
||||||
|
assert( b1.hashCode() == b11.hashCode() )
|
||||||
|
|
||||||
|
val x = mutableMapOf<BitList,String>()
|
||||||
|
x[b1] = "wrong"
|
||||||
|
x[b11] = "OK"
|
||||||
|
x[b2] = "other"
|
||||||
|
|
||||||
|
assertEquals("OK", x[b11])
|
||||||
|
assertEquals("OK", x[b1])
|
||||||
|
assertEquals("other", x[b2])
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
Reference in new issue
Block a user