Compare commits
24
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f45fa7f7a0 | ||
|
|
ead2f7168e | ||
|
|
2743511b62 | ||
|
|
8431ab4f96 | ||
|
|
80735f032d | ||
|
|
dc837e2095 | ||
|
|
0ec0ed96ee | ||
|
|
a5e51a3f90 | ||
|
|
cf79163802 | ||
|
|
c8e8bdc466 | ||
|
|
4b613fda7c | ||
|
|
8d1cafae80 | ||
|
|
0526cdfb38 | ||
|
|
cad6ba936d | ||
|
|
cb333ab6bd | ||
|
|
23737f9b5c | ||
|
|
fb6e2aa49e | ||
|
|
95c1da60ed | ||
|
|
835333dfad | ||
|
|
eefecae7b4 | ||
|
|
2ac92a1d09 | ||
|
|
464a6dcb99 | ||
|
|
eca746b189 | ||
|
|
b07452e66e |
No files matched your search
@@ -134,7 +134,19 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
|
||||
|
||||
# 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:
|
||||
|
||||
@@ -158,27 +170,32 @@ Ready features:
|
||||
- [x] compression/decompression (integrated in serialization)
|
||||
- [x] dynamic fields
|
||||
- [x] function annotations
|
||||
- [x] better stack reporting
|
||||
|
||||
### Under way:
|
||||
|
||||
- [ ] regular exceptions
|
||||
- [ ] regular exceptions + extended `when`
|
||||
- [ ] multiple inheritance for user classes
|
||||
- [ ] site with integrated interpreter to give a try
|
||||
- [ ] 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.
|
||||
|
||||
- [ ] type specifications
|
||||
- [ ] language server or compose-based lyng-aware editor
|
||||
- [ ] source docs and maybe lyng.md to a standard
|
||||
- [ ] metadata first class access from lyng
|
||||
|
||||
Further
|
||||
## After 1.5 "Ideal scripting"
|
||||
|
||||
Estimated winter 2027
|
||||
|
||||
- [ ] client with GUI support based on compose multiplatform somehow
|
||||
- [ ] notebook - style workbooks with graphs, formulae, etc.
|
||||
- [ ] language server or compose-based lyng-aware editor
|
||||
- [ ] aggressive optimizations
|
||||
|
||||
[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
|
||||
+36
-6
@@ -102,20 +102,50 @@ As with [List], it is possible to use ranges as indexes to slice a Buffer:
|
||||
|
||||
>>> void
|
||||
|
||||
## Encoding
|
||||
|
||||
You can encode `String` to buffer using buffer constructor, as was shown. Also, buffer supports out of the box base64 (
|
||||
which is used in `toString`) and hex encoding:
|
||||
|
||||
import lyng.buffer
|
||||
|
||||
// to UTF8 and back:
|
||||
val b = Buffer("hello")
|
||||
assertEquals( "hello", b.decodeUtf8() )
|
||||
|
||||
// to base64 and back:
|
||||
assertEquals( b, Buffer.decodeBase64(b.base64) )
|
||||
assertEquals( b, Buffer.decodeHex(b.hex) )
|
||||
>>> void
|
||||
|
||||
## Members
|
||||
|
||||
| name | meaning | type |
|
||||
|---------------|------------------------------------|---------------|
|
||||
| `size` | size | Int |
|
||||
| `decodeUtf8` | decodee to String using UTF8 rules | Any |
|
||||
| `+` | buffer concatenation | Any |
|
||||
| `toMutable()` | create a mutable copy | MutableBuffer |
|
||||
| name | meaning | type |
|
||||
|----------------------------|-----------------------------------------|---------------|
|
||||
| `size` | size | Int |
|
||||
| `decodeUtf8` | decode to String using UTF8 rules | Any |
|
||||
| `+` | buffer concatenation | Any |
|
||||
| `toMutable()` | create a mutable copy | MutableBuffer |
|
||||
| `hex` | encode to hex strign | String |
|
||||
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
|
||||
| `base64` | encode to base64 (url flavor) (2) | String |
|
||||
| `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2) | Buffer |
|
||||
| `toBitInput()` | create bit input from a byte buffer (3) | |
|
||||
|
||||
(1)
|
||||
: optimized implementation that override `Iterable` one
|
||||
|
||||
(2)
|
||||
: base64url alphabet is used without trailing '=', which allows string to be used in URI without escaping. Note that
|
||||
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).
|
||||
|
||||
(3)
|
||||
: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
|
||||
|
||||
Also, it inherits methods from [Iterable] and [Array].
|
||||
|
||||
|
||||
[Range]: Range.md
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
|
||||
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]
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
|
||||
+81
-26
@@ -1,9 +1,13 @@
|
||||
# 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.
|
||||
|
||||
Please see also [Collection] interface: many iterables are also collections, and it adds important features.
|
||||
|
||||
## Definition:
|
||||
|
||||
Iterable is a class that provides function that creates _the iterator_:
|
||||
@@ -23,38 +27,85 @@ Iterator itself is a simple interface that should provide only to method:
|
||||
|
||||
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!
|
||||
assertEquals( [9,10] r.takeLast(2) )
|
||||
assertEquals( [1,2,3] r.take(3) )
|
||||
assertEquals( [9,10] r.drop(8) )
|
||||
assertEquals( [1,2] r.dropLast(8) )
|
||||
assertEquals( [9,10], r.takeLast(2).toList() )
|
||||
assertEquals( [1,2,3], r.take(3).toList() )
|
||||
assertEquals( [9,10], r.drop(8).toList() )
|
||||
assertEquals( [1,2], r.dropLast(8).toList() )
|
||||
>>> void
|
||||
|
||||
## joinToString
|
||||
|
||||
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)
|
||||
|
||||
- if `Iterable` `isEmpty`, the empty string `""` is returned.
|
||||
- `suffix` is inserted between items when there are more than one.
|
||||
- `transform` of specified is applied to each element, otherwise its `toString()` method is used.
|
||||
|
||||
Here is the sample:
|
||||
|
||||
assertEquals( (1..3).joinToString(), "1 2 3")
|
||||
assertEquals( (1..3).joinToString(":"), "1:2:3")
|
||||
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
||||
>>> 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:
|
||||
|
||||
| fun/method | description |
|
||||
|-----------------|---------------------------------------------------------------------------------|
|
||||
| toList() | create a list from iterable |
|
||||
| toSet() | create a set from iterable |
|
||||
| contains(i) | check that iterable contains `i` |
|
||||
| `i in iterator` | same as `contains(i)` |
|
||||
| isEmpty() | check iterable is empty |
|
||||
| forEach(f) | call f for each element |
|
||||
| toMap() | create a map from list of key-value pairs (arrays of 2 items or like) |
|
||||
| map(f) | create a list of values returned by `f` called for each element of the iterable |
|
||||
| indexOf(i) | return index if the first encounter of i or a negative value if not found |
|
||||
| associateBy(kf) | create a map where keys are returned by kf that will be called for each element |
|
||||
| first | first element (1) |
|
||||
| last | last element (1) |
|
||||
| take(n) | return [Iterable] of up to n first elements |
|
||||
| taleLast(n) | return [Iterable] of up to n last elements |
|
||||
| drop(n) | return new [Iterable] without first n elements |
|
||||
| dropLast(n) | return new [Iterable] without last n elements |
|
||||
| fun/method | description |
|
||||
|------------------------|---------------------------------------------------------------------------------|
|
||||
| toList() | create a list from iterable |
|
||||
| toSet() | create a set from iterable |
|
||||
| contains(i) | check that iterable contains `i` |
|
||||
| `i in iterator` | same as `contains(i)` |
|
||||
| isEmpty() | check iterable is empty |
|
||||
| forEach(f) | call f for each element |
|
||||
| toMap() | create a map from list of key-value pairs (arrays of 2 items or like) |
|
||||
| map(f) | create a list of values returned by `f` called for each element of the iterable |
|
||||
| indexOf(i) | return index if the first encounter of i or a negative value if not found |
|
||||
| associateBy(kf) | create a map where keys are returned by kf that will be called for each element |
|
||||
| first | first element (1) |
|
||||
| last | last element (1) |
|
||||
| take(n) | return [Iterable] of up to n first elements |
|
||||
| taleLast(n) | return [Iterable] of up to n last elements |
|
||||
| drop(n) | return new [Iterable] without first 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) |
|
||||
| reversed() | create a list containing items from this in reverse order |
|
||||
| shuffled() | create a listof shiffled elements |
|
||||
|
||||
(1)
|
||||
: throws `NoSuchElementException` if there is no such element
|
||||
: throws `NoSuchElementException` if there is no such element
|
||||
|
||||
(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.
|
||||
|
||||
(3)
|
||||
: sum of empty collection is `null`
|
||||
|
||||
fun Iterable.toList(): List
|
||||
fun Iterable.toSet(): Set
|
||||
@@ -64,7 +115,6 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
|
||||
fun Iterable.forEach(block: (Any?)->Void ): Void
|
||||
fun Iterable.map(block: (Any?)->Void ): List
|
||||
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
|
||||
|
||||
|
||||
## Abstract methods:
|
||||
|
||||
@@ -80,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]
|
||||
|
||||
[Collection]: Collection.md
|
||||
|
||||
[List]: List.md
|
||||
|
||||
[Range]: Range.md
|
||||
|
||||
[Set]: Set.md
|
||||
|
||||
[RingBuffer]: RingBuffer.md
|
||||
+49
-16
@@ -24,7 +24,7 @@ There is a shortcut for the last:
|
||||
|
||||
val list = [10, 20, 30]
|
||||
[list.last, list.lastIndex]
|
||||
>>> [30, 2]
|
||||
>>> [30,2]
|
||||
|
||||
__Important__ negative indexes works wherever indexes are used, e.g. in insertion and removal methods too.
|
||||
|
||||
@@ -92,22 +92,45 @@ Open end ranges remove head and tail elements:
|
||||
assert( [1, 2, 3] !== [1, 2, 3])
|
||||
>>> 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
|
||||
|
||||
| name | meaning | type |
|
||||
|-------------------------------|---------------------------------------|-------------|
|
||||
| `size` | current size | Int |
|
||||
| `add(elements...)` | add one or more elements to the end | Any |
|
||||
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
|
||||
| `removeAt(index)` | remove element at position | Int |
|
||||
| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl) | Int, Int |
|
||||
| `remove(Range)` | remove range | Range |
|
||||
| `removeLast()` | remove last element | |
|
||||
| `removeLast(n)` | remove n last elements | Int |
|
||||
| `contains(element)` | check the element is in the list (1) | |
|
||||
| `[index]` | get or set element at index | Int |
|
||||
| `[Range]` | get slice of the array (copy) | Range |
|
||||
| `+=` | append element(s) | List or Obj |
|
||||
| name | meaning | type |
|
||||
|-------------------------------|----------------------------------------------|-------------|
|
||||
| `size` | current size | Int |
|
||||
| `add(elements...)` | add one or more elements to the end | Any |
|
||||
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
|
||||
| `removeAt(index)` | remove element at position | Int |
|
||||
| `remove(from,toNonInclusive)` | remove range from (incl) to (nonincl) | Int, Int |
|
||||
| `remove(Range)` | remove range | Range |
|
||||
| `removeLast()` | remove last element | |
|
||||
| `removeLast(n)` | remove n last elements | Int |
|
||||
| `contains(element)` | check the element is in the list (1) | |
|
||||
| `[index]` | get or set element at index | Int |
|
||||
| `[Range]` | get slice of the array (copy) | Range |
|
||||
| `+=` | 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)
|
||||
: 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
|
||||
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
|
||||
|
||||
@@ -134,4 +166,5 @@ It inherits from [Iterable] too.
|
||||
|
||||
|
||||
[Range]: Range.md
|
||||
|
||||
[Iterable]: Iterable.md
|
||||
+1
-1
@@ -87,7 +87,7 @@ You can use Char as both ends of the closed range:
|
||||
Exclusive end char ranges are supported too:
|
||||
|
||||
('a'..<'c').toList
|
||||
>>> ['a', 'b']
|
||||
>>> [a,b]
|
||||
|
||||
|
||||
# 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
|
||||
|
||||
@@ -71,7 +71,7 @@ destructuring arrays when calling functions and lambdas:
|
||||
[ first, last ]
|
||||
}
|
||||
getFirstAndLast( ...(1..10) ) // see "splats" section below
|
||||
>>> [1, 10]
|
||||
>>> [1,10]
|
||||
|
||||
# Splats
|
||||
|
||||
@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
|
||||
}
|
||||
val array = [1,2,3]
|
||||
testSplat("start", ...array, "end")
|
||||
>>> ["start", 1, 2, 3, "end"]
|
||||
>>> [start,1,2,3,end]
|
||||
>>> void
|
||||
|
||||
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
|
||||
testSplat("start", ...range, "end")
|
||||
>>> ["start", 1, 2, 3, "end"]
|
||||
>>> [start,1,2,3,end]
|
||||
>>> void
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
|
||||
|
||||
Provide:
|
||||
|
||||
|
||||
fun outer(a1)
|
||||
// a1 is caller.a1:arg
|
||||
val a1_local = a1 + 1
|
||||
// we return lambda:
|
||||
{ it ->
|
||||
// a1_local
|
||||
a1_lcoal + it
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
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
|
||||
|
||||
_this functionality is not yet released_
|
||||
@@ -131,7 +157,7 @@ _this functionality is not yet released_
|
||||
| class | notes |
|
||||
|----------------------------|-------------------------------------------------------|
|
||||
| Exception | root of al throwable objects |
|
||||
| NullReferenceException | |
|
||||
| NullReferenceException | |
|
||||
| AssertionFailedException | |
|
||||
| ClassCastException | |
|
||||
| IndexOutOfBoundsException | |
|
||||
|
||||
+2
-2
@@ -183,8 +183,8 @@ Important difference from the channels or like, every time you collect the flow,
|
||||
// and again:
|
||||
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
|
||||
|
||||
Notice that flow's lambda is not called until actual collection is started. Cold flows are
|
||||
|
||||
@@ -16,9 +16,15 @@ fun naiveCountHappyNumbers() {
|
||||
count
|
||||
}
|
||||
|
||||
import lyng.time
|
||||
|
||||
//
|
||||
// After all optimizations it takes ~120ms.
|
||||
//
|
||||
val found = naiveCountHappyNumbers()
|
||||
println("Found happy numbers: "+found)
|
||||
assert( found == 55252 )
|
||||
//for( r in 1..100 ) {
|
||||
// val start = Instant.now()
|
||||
val found = naiveCountHappyNumbers()
|
||||
// println("Found happy numbers: %d time %s"(found, Instant.now() - start))
|
||||
assert( found == 55252 )
|
||||
// delay(0.01)
|
||||
//}
|
||||
@@ -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)
|
||||
+118
-35
@@ -16,7 +16,8 @@ __Other documents to read__ maybe after this one:
|
||||
- [math in Lyng](math.md)
|
||||
- [time](time.md) and [parallelism](parallelism.md)
|
||||
- [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
|
||||
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))
|
||||
>>> 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
|
||||
|
||||
It is rather simple, like everywhere else:
|
||||
@@ -261,6 +275,8 @@ Logical operation could be used the same
|
||||
| === | | Any | (2) |
|
||||
| !== | | Any | (2) |
|
||||
| != | | Any | (1) |
|
||||
| =~ | | | (3) |
|
||||
| !~ | | | (3) |
|
||||
| ++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
|
||||
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:
|
||||
|
||||
assert( null == null) // singletons
|
||||
@@ -475,7 +494,8 @@ Lyng has built-in mutable array class `List` with simple literals:
|
||||
[1, "two", 3.33].size
|
||||
>>> 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:
|
||||
|
||||
@@ -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:
|
||||
|
||||
[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):
|
||||
|
||||
val a = ["one", "two"]
|
||||
val b = [10.1, 20.2]
|
||||
["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:
|
||||
|
||||
val a = [1, 2, 3]
|
||||
a[1] = 200
|
||||
a
|
||||
>>> [1, 200, 3]
|
||||
>>> [1,200,3]
|
||||
|
||||
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]
|
||||
x.insertAt( 1, ...[0,100,0])
|
||||
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:
|
||||
|
||||
val x = [1,2,3]
|
||||
x.insertAt(3, 10)
|
||||
x
|
||||
>>> [1, 2, 3, 10]
|
||||
>>> [1,2,3,10]
|
||||
|
||||
but it is much simpler, and we recommend to use '+='
|
||||
|
||||
val x = [1,2,3]
|
||||
x += 10
|
||||
>>> [1, 2, 3, 10]
|
||||
>>> [1,2,3,10]
|
||||
|
||||
## Removing list items
|
||||
|
||||
@@ -747,15 +767,17 @@ You can thest that _when expression_ is _contained_, or not contained, in some o
|
||||
`!in container`. The container is any object that provides `contains` method, otherwise the runtime exception will be
|
||||
thrown.
|
||||
|
||||
Typical builtin types that are containers (e.g. support `conain`):
|
||||
Typical builtin types that are containers (e.g. support `contains`):
|
||||
|
||||
| class | notes |
|
||||
|------------|------------------------------------------------|
|
||||
| Collection | contains an element (1) |
|
||||
| Array | faster maybe that Collection's |
|
||||
| List | faster than Array's |
|
||||
| String | character in string or substring in string (3) |
|
||||
| Range | object is included in the range (2) |
|
||||
| class | notes |
|
||||
|--------------|------------------------------------------------|
|
||||
| [Collection] | contains an element (1) |
|
||||
| Array | faster maybe that Collection's |
|
||||
| List | faster than Array's |
|
||||
| String | character in string or substring in string (3) |
|
||||
| Range | object is included in the range (2) |
|
||||
| Buffer | byte is in buffer |
|
||||
| RingBuffer | object is in buffer |
|
||||
|
||||
(1)
|
||||
: Iterable is not the container as it can be infinite
|
||||
@@ -1122,7 +1144,8 @@ See [more docs on time manipulation](time.md)
|
||||
|
||||
# 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 {
|
||||
RED, GREEN, BLUE
|
||||
@@ -1137,7 +1160,8 @@ For the moment, only simple enums are implemented. Enum is a list of constants,
|
||||
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
||||
>>> 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
|
||||
|
||||
@@ -1165,6 +1189,30 @@ See also [math operations](math.md)
|
||||
|
||||
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
|
||||
|
||||
Are the same as in string literals with little difference:
|
||||
@@ -1172,6 +1220,7 @@ Are the same as in string literals with little difference:
|
||||
| escape | ASCII value |
|
||||
|--------|-------------------|
|
||||
| \n | 0x10, newline |
|
||||
| \r | 0x13, carriage return |
|
||||
| \t | 0x07, tabulation |
|
||||
| \\ | \ slash character |
|
||||
| \' | ' apostrophe |
|
||||
@@ -1241,9 +1290,26 @@ Open-ended ranges could be used to get start and end too:
|
||||
assertEquals( "pult", "catapult"[ 4.. ])
|
||||
>>> void
|
||||
|
||||
|
||||
### 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:
|
||||
|
||||
@@ -1251,6 +1317,7 @@ Typical set of String functions includes:
|
||||
|--------------------|------------------------------------------------------------|
|
||||
| lower() | change case to unicode upper |
|
||||
| upper() | change case to unicode lower |
|
||||
| trim() | trim space chars from both ends |
|
||||
| startsWith(prefix) | true if starts with a prefix |
|
||||
| endsWith(prefix) | true if ends with a prefix |
|
||||
| take(n) | get a new string from up to n first characters |
|
||||
@@ -1260,17 +1327,24 @@ Typical set of String functions includes:
|
||||
| size | size in characters like `length` because String is [Array] |
|
||||
| (args...) | sprintf-like formatting, see [string formatting] |
|
||||
| [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 | self-modifying concatenation |
|
||||
| toReal() | attempts to parse string as a Real value |
|
||||
| toInt() | parse string to Int value |
|
||||
| characters() | create [List] of characters (1) |
|
||||
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
|
||||
| matches(re) | matches the regular expression (2) |
|
||||
| | |
|
||||
|
||||
|
||||
(1)
|
||||
: List is mutable therefore a new copy is created on each call.
|
||||
|
||||
(2)
|
||||
: See [Regex]
|
||||
|
||||
### Literals
|
||||
|
||||
String literal could be multiline:
|
||||
@@ -1278,7 +1352,7 @@ String literal could be multiline:
|
||||
"Hello
|
||||
World"
|
||||
|
||||
In this case, it will be passed literally ot "hello\n World". But, if there are
|
||||
In this case, it will be passed literally ot "hello\n World". But, if there are
|
||||
several lines with common left indent, it will be removed, also, forst and last lines,
|
||||
if blank, will be removed too, for example:
|
||||
|
||||
@@ -1290,24 +1364,27 @@ if blank, will be removed too, for example:
|
||||
>>> This is a second line.
|
||||
>>> 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
|
||||
|
||||
See [math functions](math.md). Other general purpose functions are:
|
||||
|
||||
| name | description |
|
||||
|--------------------------------------------|-----------------------------------------------------------|
|
||||
| assert(condition,message="assertion failed") | runtime code check. There will be an option to skip them |
|
||||
| assertEquals(a,b) | |
|
||||
| assertNotEquals(a,b) | |
|
||||
| assertTrows { /* block */ } | |
|
||||
| check(condition, message=<default>) | throws IllegalStateException" of condition isn't met |
|
||||
| require(condition, message=<default>) | throws IllegalArgumentException" of condition isn't met |
|
||||
| println(args...) | Open for overriding, it prints to stdout with newline. |
|
||||
| print(args...) | Open for overriding, it prints to stdout without newline. |
|
||||
| flow {} | create flow sequence, see [parallelism] |
|
||||
| delay, launch, yield | see [parallelism] |
|
||||
| name | description |
|
||||
|----------------------------------------------|------------------------------------------------------------|
|
||||
| assert(condition,message="assertion failed") | runtime code check. There will be an option to skip them |
|
||||
| assertEquals(a,b) | |
|
||||
| assertNotEquals(a,b) | |
|
||||
| assertTrows { /* block */ } | |
|
||||
| check(condition, message=<default>) | throws IllegalStateException" of condition isn't met |
|
||||
| require(condition, message=<default>) | throws IllegalArgumentException" of condition isn't met |
|
||||
| println(args...) | Open for overriding, it prints to stdout with newline. |
|
||||
| print(args...) | Open for overriding, it prints to stdout without newline. |
|
||||
| flow {} | create flow sequence, see [parallelism] |
|
||||
| delay, launch, yield | see [parallelism] |
|
||||
| cached(builder) | remembers builder() on first invocation and return it then |
|
||||
| let, also, apply, run | see above, flow controls |
|
||||
|
||||
# Built-in constants
|
||||
|
||||
@@ -1338,4 +1415,10 @@ See [math functions](math.md). Other general purpose functions are:
|
||||
|
||||
[parallelism]: parallelism.md
|
||||
|
||||
[RingBuffer]: RingBuffer.md
|
||||
[RingBuffer]: RingBuffer.md
|
||||
|
||||
[Collection]: Collection.md
|
||||
|
||||
[Array]: Array.md
|
||||
|
||||
[Regex]: Regex.md
|
||||
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||
|
||||
group = "net.sergeych"
|
||||
version = "0.8.9-SNAPSHOT"
|
||||
version = "0.9.0-SNAPSHOT"
|
||||
|
||||
buildscript {
|
||||
repositories {
|
||||
@@ -138,6 +138,7 @@ publishing {
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//mavenPublishing {
|
||||
// publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
|
||||
//
|
||||
|
||||
@@ -48,13 +48,12 @@ data class ArgsDeclaration(val params: List<Item>, val endTokenType: Token.Type)
|
||||
arguments: Arguments = scope.args,
|
||||
defaultAccessType: AccessType = AccessType.Var,
|
||||
defaultVisibility: Visibility = Visibility.Public,
|
||||
defaultRecordType: ObjRecord.Type = ObjRecord.Type.ConstructorField
|
||||
) {
|
||||
fun assign(a: Item, value: Obj) {
|
||||
scope.addItem(a.name, (a.accessType ?: defaultAccessType).isMutable,
|
||||
value.byValueCopy(),
|
||||
a.visibility ?: defaultVisibility,
|
||||
recordType = defaultRecordType)
|
||||
recordType = ObjRecord.Type.Argument)
|
||||
}
|
||||
|
||||
// will be used with last lambda arg fix
|
||||
|
||||
@@ -63,7 +63,7 @@ data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) :
|
||||
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 {
|
||||
val EMPTY = Arguments(emptyList())
|
||||
|
||||
@@ -24,10 +24,33 @@ import net.sergeych.lyng.obj.ObjRecord
|
||||
* Inherits [Scope.args] and [Scope.thisObj] from [callScope] and adds lookup for symbols
|
||||
* from [closureScope] with proper precedence
|
||||
*/
|
||||
class ClosureScope(val callScope: Scope,val closureScope: Scope) : Scope(callScope, callScope.args, thisObj = callScope.thisObj) {
|
||||
class ClosureScope(val callScope: Scope, val closureScope: Scope) :
|
||||
Scope(callScope, callScope.args, thisObj = callScope.thisObj) {
|
||||
|
||||
override fun get(name: String): ObjRecord? {
|
||||
// closure should be treated below callScope
|
||||
return super.get(name) ?: closureScope.get(name)
|
||||
// we take arguments from the callerScope, the rest
|
||||
// from the closure.
|
||||
|
||||
// note using super, not callScope, as arguments are assigned by the constructor
|
||||
// and are not assigned yet to vars in callScope self:
|
||||
super.objects[name]?.let {
|
||||
// if( name == "predicate" ) {
|
||||
// println("predicate: ${it.type.isArgument}: ${it.value}")
|
||||
// }
|
||||
if( it.type.isArgument ) return it
|
||||
}
|
||||
return closureScope.get(name)
|
||||
}
|
||||
}
|
||||
|
||||
class ApplyScope(_parent: Scope,val applied: Scope) : Scope(_parent, thisObj = applied.thisObj) {
|
||||
|
||||
override fun get(name: String): ObjRecord? {
|
||||
return applied.get(name) ?: super.get(name)
|
||||
}
|
||||
|
||||
override fun applyClosure(closure: Scope): Scope {
|
||||
return this
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
* 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
|
||||
|
||||
sealed class CodeContext {
|
||||
class Module(@Suppress("unused") val packageName: String?): CodeContext()
|
||||
class Function(val name: String): CodeContext()
|
||||
class ClassBody(val name: String): CodeContext()
|
||||
}
|
||||
@@ -45,6 +45,17 @@ class Compiler(
|
||||
|
||||
private fun popInitScope(): MutableList<Statement> = initStack.removeLast()
|
||||
|
||||
private val codeContexts = mutableListOf<CodeContext>(CodeContext.Module(null))
|
||||
|
||||
private suspend fun <T> inCodeContext(context: CodeContext, f: suspend () -> T): T {
|
||||
return try {
|
||||
codeContexts.add(context)
|
||||
f()
|
||||
} finally {
|
||||
codeContexts.removeLast()
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun parseScript(): Script {
|
||||
val statements = mutableListOf<Statement>()
|
||||
val start = cc.currentPos()
|
||||
@@ -87,7 +98,7 @@ class Compiler(
|
||||
statements += it
|
||||
}
|
||||
if (s == null) {
|
||||
when( t.type ) {
|
||||
when (t.type) {
|
||||
Token.Type.RBRACE, Token.Type.EOF, Token.Type.SEMICOLON -> {}
|
||||
else ->
|
||||
throw ScriptError(t.pos, "unexpeced `${t.value}` here")
|
||||
@@ -114,7 +125,7 @@ class Compiler(
|
||||
return result.toString()
|
||||
}
|
||||
|
||||
private var lastAnnotation: (suspend (Scope, ObjString,Statement) -> Statement)? = null
|
||||
private var lastAnnotation: (suspend (Scope, ObjString, Statement) -> Statement)? = null
|
||||
|
||||
private suspend fun parseStatement(braceMeansLambda: Boolean = false): Statement? {
|
||||
lastAnnotation = null
|
||||
@@ -138,6 +149,7 @@ class Compiler(
|
||||
lastAnnotation = parseAnnotation(t)
|
||||
continue
|
||||
}
|
||||
|
||||
Token.Type.LABEL -> continue
|
||||
Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT -> continue
|
||||
|
||||
@@ -199,11 +211,32 @@ class Compiler(
|
||||
private suspend fun parseTerm(): Accessor? {
|
||||
var operand: Accessor? = null
|
||||
|
||||
// newlines _before_
|
||||
cc.skipWsTokens()
|
||||
|
||||
while (true) {
|
||||
val t = cc.next()
|
||||
val startPos = t.pos
|
||||
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()
|
||||
return operand
|
||||
}
|
||||
@@ -364,6 +397,13 @@ class Compiler(
|
||||
|
||||
}
|
||||
|
||||
"throw" -> {
|
||||
val s = parseThrowStatement()
|
||||
operand = Accessor {
|
||||
s.execute(it).asReadonly
|
||||
}
|
||||
}
|
||||
|
||||
else -> operand?.let { left ->
|
||||
// selector: <lvalue>, '.' , <id>
|
||||
// we replace operand with selector code, that
|
||||
@@ -449,7 +489,14 @@ class Compiler(
|
||||
// range operator
|
||||
val isEndInclusive = t.type == Token.Type.DOTDOT
|
||||
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 {
|
||||
ObjRange(
|
||||
left?.getter?.invoke(it)?.value ?: ObjNull,
|
||||
@@ -503,7 +550,7 @@ class Compiler(
|
||||
|
||||
val callStatement = statement {
|
||||
// and the source closure of the lambda which might have other thisObj.
|
||||
val context = ClosureScope(this, closure!!) //AppliedScope(closure!!, args, this)
|
||||
val context = this.applyClosure(closure!!)
|
||||
if (argsDeclaration == null) {
|
||||
// no args: automatic var 'it'
|
||||
val l = args.list
|
||||
@@ -515,7 +562,7 @@ class Compiler(
|
||||
// more args: it is a list of args
|
||||
else -> ObjList(l.toMutableList())
|
||||
}
|
||||
context.addItem("it", false, itValue)
|
||||
context.addItem("it", false, itValue, recordType = ObjRecord.Type.Argument)
|
||||
} else {
|
||||
// assign vars as declared the standard way
|
||||
argsDeclaration.assignToContext(context, defaultAccessType = AccessType.Val)
|
||||
@@ -524,7 +571,7 @@ class Compiler(
|
||||
}
|
||||
|
||||
return Accessor { x ->
|
||||
if (closure == null) closure = x
|
||||
closure = x
|
||||
callStatement.asReadonly
|
||||
}
|
||||
}
|
||||
@@ -576,6 +623,8 @@ class Compiler(
|
||||
var endTokenType: Token.Type? = null
|
||||
val startPos = cc.savePos()
|
||||
|
||||
cc.skipWsTokens()
|
||||
|
||||
while (endTokenType == null) {
|
||||
var t = cc.next()
|
||||
when (t.type) {
|
||||
@@ -633,7 +682,7 @@ class Compiler(
|
||||
|
||||
// important: valid argument list continues with ',' and ends with '->' or ')'
|
||||
// otherwise it is not an argument list:
|
||||
when (val tt = cc.next().type) {
|
||||
when (val tt = cc.nextNonWhitespace().type) {
|
||||
Token.Type.RPAREN -> {
|
||||
// end of arguments
|
||||
endTokenType = tt
|
||||
@@ -843,22 +892,22 @@ class Compiler(
|
||||
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()
|
||||
println("annotation ${t.value}: args: $extraArgs")
|
||||
// println("annotation ${t.value}: args: $extraArgs")
|
||||
return { scope, name, body ->
|
||||
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
|
||||
val required = listOf(name, body)
|
||||
val args = extras?.let { required + it } ?: required
|
||||
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)
|
||||
?: scope.raiseClassCastError("function annotation must return callable")
|
||||
}
|
||||
}
|
||||
|
||||
suspend fun parseArgsOrNull(): Pair<List<ParsedArgument>, Boolean>? =
|
||||
if( cc.skipNextIf(Token.Type.LPAREN))
|
||||
if (cc.skipNextIf(Token.Type.LPAREN))
|
||||
parseArgs()
|
||||
else
|
||||
null
|
||||
@@ -936,7 +985,7 @@ class Compiler(
|
||||
|
||||
private suspend fun parseWhenStatement(): Statement {
|
||||
// has a value, when(value) ?
|
||||
var t = cc.skipWsTokens()
|
||||
var t = cc.nextNonWhitespace()
|
||||
return if (t.type == Token.Type.LPAREN) {
|
||||
// when(value)
|
||||
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
|
||||
@@ -951,6 +1000,7 @@ class Compiler(
|
||||
// condition could be a value, in and is clauses:
|
||||
// parse several conditions for one then clause
|
||||
|
||||
|
||||
// loop cases
|
||||
outer@ while (true) {
|
||||
|
||||
@@ -959,7 +1009,7 @@ class Compiler(
|
||||
|
||||
// loop conditions
|
||||
while (true) {
|
||||
t = cc.skipWsTokens()
|
||||
t = cc.nextNonWhitespace()
|
||||
|
||||
when (t.type) {
|
||||
Token.Type.IN,
|
||||
@@ -1172,23 +1222,25 @@ class Compiler(
|
||||
cc.skipTokenOfType(Token.Type.LBRACE)
|
||||
|
||||
do {
|
||||
val t = cc.skipWsTokens()
|
||||
when(t.type) {
|
||||
val t = cc.nextNonWhitespace()
|
||||
when (t.type) {
|
||||
Token.Type.ID -> {
|
||||
names += t.value
|
||||
val t1 = cc.skipWsTokens()
|
||||
when(t1.type) {
|
||||
val t1 = cc.nextNonWhitespace()
|
||||
when (t1.type) {
|
||||
Token.Type.COMMA ->
|
||||
continue
|
||||
|
||||
Token.Type.RBRACE -> break
|
||||
else -> {
|
||||
t1.raiseSyntax("unexpected token")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
else -> t.raiseSyntax("expected enum entry name")
|
||||
}
|
||||
} while(true)
|
||||
} while (true)
|
||||
|
||||
return statement {
|
||||
ObjEnumClass.createSimpleEnum(nameToken.value, names).also {
|
||||
@@ -1199,74 +1251,76 @@ class Compiler(
|
||||
|
||||
private suspend fun parseClassDeclaration(): Statement {
|
||||
val nameToken = cc.requireToken(Token.Type.ID)
|
||||
val constructorArgsDeclaration =
|
||||
if (cc.skipTokenOfType(Token.Type.LPAREN, isOptional = true))
|
||||
parseArgsDeclaration(isClassDeclaration = true)
|
||||
else null
|
||||
return inCodeContext(CodeContext.ClassBody(nameToken.value)) {
|
||||
val constructorArgsDeclaration =
|
||||
if (cc.skipTokenOfType(Token.Type.LPAREN, isOptional = true))
|
||||
parseArgsDeclaration(isClassDeclaration = true)
|
||||
else null
|
||||
|
||||
if (constructorArgsDeclaration != null && constructorArgsDeclaration.endTokenType != Token.Type.RPAREN)
|
||||
throw ScriptError(
|
||||
nameToken.pos,
|
||||
"Bad class declaration: expected ')' at the end of the primary constructor"
|
||||
)
|
||||
if (constructorArgsDeclaration != null && constructorArgsDeclaration.endTokenType != Token.Type.RPAREN)
|
||||
throw ScriptError(
|
||||
nameToken.pos,
|
||||
"Bad class declaration: expected ')' at the end of the primary constructor"
|
||||
)
|
||||
|
||||
cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
|
||||
val t = cc.next()
|
||||
cc.skipTokenOfType(Token.Type.NEWLINE, isOptional = true)
|
||||
val t = cc.next()
|
||||
|
||||
pushInitScope()
|
||||
pushInitScope()
|
||||
|
||||
val bodyInit: Statement? = if (t.type == Token.Type.LBRACE) {
|
||||
// parse body
|
||||
parseScript().also {
|
||||
cc.skipTokens(Token.Type.RBRACE)
|
||||
val bodyInit: Statement? = if (t.type == Token.Type.LBRACE) {
|
||||
// parse body
|
||||
parseScript().also {
|
||||
cc.skipTokens(Token.Type.RBRACE)
|
||||
}
|
||||
} else {
|
||||
cc.previous()
|
||||
null
|
||||
}
|
||||
} else {
|
||||
cc.previous()
|
||||
null
|
||||
}
|
||||
|
||||
val initScope = popInitScope()
|
||||
val initScope = popInitScope()
|
||||
|
||||
// create class
|
||||
val className = nameToken.value
|
||||
// create class
|
||||
val className = nameToken.value
|
||||
|
||||
// @Suppress("UNUSED_VARIABLE") val defaultAccess = if (isStruct) AccessType.Var else AccessType.Initialization
|
||||
// @Suppress("UNUSED_VARIABLE") val defaultVisibility = Visibility.Public
|
||||
|
||||
// create instance constructor
|
||||
// create custom objClass with all fields and instance constructor
|
||||
// create instance constructor
|
||||
// create custom objClass with all fields and instance constructor
|
||||
|
||||
val constructorCode = statement {
|
||||
// constructor code is registered with class instance and is called over
|
||||
// new `thisObj` already set by class to ObjInstance.instanceContext
|
||||
thisObj as ObjInstance
|
||||
val constructorCode = statement {
|
||||
// constructor code is registered with class instance and is called over
|
||||
// new `thisObj` already set by class to ObjInstance.instanceContext
|
||||
thisObj as ObjInstance
|
||||
|
||||
// the context now is a "class creation context", we must use its args to initialize
|
||||
// fields. Note that 'this' is already set by class
|
||||
constructorArgsDeclaration?.assignToContext(this)
|
||||
bodyInit?.execute(this)
|
||||
// the context now is a "class creation context", we must use its args to initialize
|
||||
// fields. Note that 'this' is already set by class
|
||||
constructorArgsDeclaration?.assignToContext(this)
|
||||
bodyInit?.execute(this)
|
||||
|
||||
thisObj
|
||||
}
|
||||
// inheritance must alter this code:
|
||||
val newClass = ObjInstanceClass(className).apply {
|
||||
instanceConstructor = constructorCode
|
||||
constructorMeta = constructorArgsDeclaration
|
||||
}
|
||||
|
||||
return statement {
|
||||
// the main statement should create custom ObjClass instance with field
|
||||
// accessors, constructor registration, etc.
|
||||
addItem(className, false, newClass)
|
||||
if (initScope.isNotEmpty()) {
|
||||
val classScope = copy(newThisObj = newClass)
|
||||
newClass.classScope = classScope
|
||||
for (s in initScope)
|
||||
s.execute(classScope)
|
||||
.also { println("executed, ${classScope.objects}") }
|
||||
thisObj
|
||||
}
|
||||
// inheritance must alter this code:
|
||||
val newClass = ObjInstanceClass(className).apply {
|
||||
instanceConstructor = constructorCode
|
||||
constructorMeta = constructorArgsDeclaration
|
||||
}
|
||||
|
||||
statement {
|
||||
// the main statement should create custom ObjClass instance with field
|
||||
// accessors, constructor registration, etc.
|
||||
addItem(className, false, newClass)
|
||||
if (initScope.isNotEmpty()) {
|
||||
val classScope = copy(newThisObj = newClass)
|
||||
newClass.classScope = classScope
|
||||
for (s in initScope)
|
||||
s.execute(classScope)
|
||||
}
|
||||
newClass
|
||||
}
|
||||
newClass
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -1311,8 +1365,8 @@ class Compiler(
|
||||
}
|
||||
|
||||
|
||||
return statement(body.pos) { ctx ->
|
||||
val forContext = ctx.copy(start)
|
||||
return statement(body.pos) { cxt ->
|
||||
val forContext = cxt.copy(start)
|
||||
|
||||
// loop var: StoredObject
|
||||
val loopSO = forContext.addItem(tVar.value, true, ObjNull)
|
||||
@@ -1323,15 +1377,28 @@ class Compiler(
|
||||
if (sourceObj is ObjRange && sourceObj.isIntRange) {
|
||||
loopIntRange(
|
||||
forContext,
|
||||
sourceObj.start!!.toInt(),
|
||||
if (sourceObj.isEndInclusive) sourceObj.end!!.toInt() + 1 else sourceObj.end!!.toInt(),
|
||||
loopSO, body, elseStatement, label, canBreak
|
||||
sourceObj.start!!.toLong(),
|
||||
if (sourceObj.isEndInclusive)
|
||||
sourceObj.end!!.toLong() + 1
|
||||
else
|
||||
sourceObj.end!!.toLong(),
|
||||
loopSO,
|
||||
body,
|
||||
elseStatement,
|
||||
label,
|
||||
canBreak
|
||||
)
|
||||
} else if (sourceObj.isInstanceOf(ObjIterable)) {
|
||||
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
|
||||
} else {
|
||||
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 breakCaught = false
|
||||
@@ -1341,7 +1408,7 @@ class Compiler(
|
||||
.getOrElse {
|
||||
throw ScriptError(
|
||||
tOp.pos,
|
||||
"object is not enumerable: no index access for ${sourceObj.inspect()}",
|
||||
"object is not enumerable: no index access for ${sourceObj.inspect(cxt)}",
|
||||
it
|
||||
)
|
||||
}
|
||||
@@ -1368,7 +1435,7 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
if (!breakCaught && elseStatement != null) {
|
||||
result = elseStatement.execute(ctx)
|
||||
result = elseStatement.execute(cxt)
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -1380,7 +1447,7 @@ class Compiler(
|
||||
}
|
||||
|
||||
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
|
||||
): Obj {
|
||||
var result: Obj = ObjVoid
|
||||
@@ -1388,7 +1455,7 @@ class Compiler(
|
||||
loopVar.value = iVar
|
||||
if (catchBreak) {
|
||||
for (i in start..<end) {
|
||||
iVar.value = i.toLong()
|
||||
iVar.value = i//.toLong()
|
||||
try {
|
||||
result = body.execute(forScope)
|
||||
} catch (lbe: LoopBreakContinueException) {
|
||||
@@ -1400,7 +1467,7 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (i in start.toLong()..<end.toLong()) {
|
||||
for (i in start..<end) {
|
||||
iVar.value = i
|
||||
result = body.execute(forScope)
|
||||
}
|
||||
@@ -1637,8 +1704,7 @@ class Compiler(
|
||||
}
|
||||
}
|
||||
|
||||
private suspend fun
|
||||
parseFunctionDeclaration(
|
||||
private suspend fun parseFunctionDeclaration(
|
||||
visibility: Visibility = Visibility.Public,
|
||||
@Suppress("UNUSED_PARAMETER") isOpen: Boolean = false,
|
||||
isExtern: Boolean = false,
|
||||
@@ -1652,7 +1718,7 @@ class Compiler(
|
||||
else t.value
|
||||
|
||||
val annotation = lastAnnotation
|
||||
|
||||
val parentContext = codeContexts.last()
|
||||
|
||||
t = cc.next()
|
||||
// Is extension?
|
||||
@@ -1677,61 +1743,66 @@ class Compiler(
|
||||
|
||||
if (cc.current().type == Token.Type.COLON) parseTypeDeclaration()
|
||||
|
||||
// Here we should be at open body
|
||||
val fnStatements = if (isExtern)
|
||||
statement { raiseError("extern function not provided: $name") }
|
||||
else
|
||||
parseBlock()
|
||||
return inCodeContext(CodeContext.Function(name)) {
|
||||
|
||||
var closure: Scope? = null
|
||||
// Here we should be at open body
|
||||
val fnStatements = if (isExtern)
|
||||
statement { raiseError("extern function not provided: $name") }
|
||||
else
|
||||
parseBlock()
|
||||
|
||||
val fnBody = statement(t.pos) { callerContext ->
|
||||
callerContext.pos = start
|
||||
var closure: Scope? = null
|
||||
|
||||
// restore closure where the function was defined, and making a copy of it
|
||||
// for local space (otherwise it will write local stuff to closure!)
|
||||
val context = closure?.let { ClosureScope(callerContext, it) }
|
||||
?: callerContext.raiseError("bug: closure not set")
|
||||
val fnBody = statement(t.pos) { callerContext ->
|
||||
callerContext.pos = start
|
||||
|
||||
// load params from caller context
|
||||
argsDeclaration.assignToContext(context, callerContext.args, defaultAccessType = AccessType.Val)
|
||||
if (extTypeName != null) {
|
||||
context.thisObj = callerContext.thisObj
|
||||
}
|
||||
fnStatements.execute(context)
|
||||
}
|
||||
val fnCreateStatement = statement(start) { context ->
|
||||
// we added fn in the context. now we must save closure
|
||||
// for the function
|
||||
closure = context
|
||||
// restore closure where the function was defined, and making a copy of it
|
||||
// for local space. If there is no closure, we are in, say, class context where
|
||||
// the closure is in the class initialization and we needn't more:
|
||||
val context = closure?.let { ClosureScope(callerContext, it) }
|
||||
?: callerContext
|
||||
|
||||
val annotatedFnBody = annotation?.invoke(context, ObjString(name), fnBody)
|
||||
?: fnBody
|
||||
|
||||
extTypeName?.let { typeName ->
|
||||
// class extension method
|
||||
val type = context[typeName]?.value ?: context.raiseSymbolNotFound("class $typeName not found")
|
||||
if (type !is ObjClass) context.raiseClassCastError("$typeName is not the class instance")
|
||||
type.addFn(name, isOpen = true) {
|
||||
// ObjInstance has a fixed instance scope, so we need to build a closure
|
||||
(thisObj as? ObjInstance)?.let { i ->
|
||||
annotatedFnBody.execute(ClosureScope(this, i.instanceScope))
|
||||
}
|
||||
// other classes can create one-time scope for this rare case:
|
||||
?: annotatedFnBody.execute(thisObj.autoInstanceScope(this))
|
||||
// load params from caller context
|
||||
argsDeclaration.assignToContext(context, callerContext.args, defaultAccessType = AccessType.Val)
|
||||
if (extTypeName != null) {
|
||||
context.thisObj = callerContext.thisObj
|
||||
}
|
||||
fnStatements.execute(context)
|
||||
}
|
||||
// regular function/method
|
||||
?: context.addItem(name, false, annotatedFnBody, visibility)
|
||||
// as the function can be called from anywhere, we have
|
||||
// saved the proper context in the closure
|
||||
annotatedFnBody
|
||||
val fnCreateStatement = statement(start) { context ->
|
||||
// we added fn in the context. now we must save closure
|
||||
// for the function, unless we're in the class scope:
|
||||
if (isStatic || parentContext !is CodeContext.ClassBody)
|
||||
closure = context
|
||||
|
||||
val annotatedFnBody = annotation?.invoke(context, ObjString(name), fnBody)
|
||||
?: fnBody
|
||||
|
||||
extTypeName?.let { typeName ->
|
||||
// class extension method
|
||||
val type = context[typeName]?.value ?: context.raiseSymbolNotFound("class $typeName not found")
|
||||
if (type !is ObjClass) context.raiseClassCastError("$typeName is not the class instance")
|
||||
type.addFn(name, isOpen = true) {
|
||||
// ObjInstance has a fixed instance scope, so we need to build a closure
|
||||
(thisObj as? ObjInstance)?.let { i ->
|
||||
annotatedFnBody.execute(ClosureScope(this, i.instanceScope))
|
||||
}
|
||||
// other classes can create one-time scope for this rare case:
|
||||
?: annotatedFnBody.execute(thisObj.autoInstanceScope(this))
|
||||
}
|
||||
}
|
||||
// regular function/method
|
||||
?: context.addItem(name, false, annotatedFnBody, visibility)
|
||||
// as the function can be called from anywhere, we have
|
||||
// saved the proper context in the closure
|
||||
annotatedFnBody
|
||||
}
|
||||
if (isStatic) {
|
||||
currentInitScope += fnCreateStatement
|
||||
NopStatement
|
||||
} else
|
||||
fnCreateStatement
|
||||
}
|
||||
return if (isStatic) {
|
||||
currentInitScope += fnCreateStatement
|
||||
NopStatement
|
||||
} else
|
||||
fnCreateStatement
|
||||
}
|
||||
|
||||
private suspend fun parseBlock(skipLeadingBrace: Boolean = false): Statement {
|
||||
@@ -1766,24 +1837,31 @@ class Compiler(
|
||||
|
||||
val eqToken = cc.next()
|
||||
var setNull = false
|
||||
if (eqToken.type != Token.Type.ASSIGN) {
|
||||
if (!isMutable)
|
||||
throw ScriptError(start, "val must be initialized")
|
||||
else {
|
||||
cc.previous()
|
||||
setNull = true
|
||||
|
||||
val isDelegate = if (eqToken.isId("by")) {
|
||||
true
|
||||
} else {
|
||||
if (eqToken.type != Token.Type.ASSIGN) {
|
||||
if (!isMutable)
|
||||
throw ScriptError(start, "val must be initialized")
|
||||
else {
|
||||
cc.previous()
|
||||
setNull = true
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
val initialExpression = if (setNull) null else parseStatement(true)
|
||||
val initialExpression = if (setNull) null
|
||||
else parseStatement(true)
|
||||
?: throw ScriptError(eqToken.pos, "Expected initializer expression")
|
||||
|
||||
if (isStatic) {
|
||||
// find objclass instance: this is tricky: this code executes in object initializer,
|
||||
// when creating instance, but we need to execute it in the class initializer which
|
||||
// is missing as for now. Add it to the compiler context?
|
||||
// add there
|
||||
// return
|
||||
|
||||
// if (isDelegate) throw ScriptError(start, "static delegates are not yet implemented")
|
||||
currentInitScope += statement {
|
||||
val initValue = initialExpression?.execute(this)?.byValueCopy() ?: ObjNull
|
||||
(thisObj as ObjClass).createClassField(name, initValue, isMutable, visibility, pos)
|
||||
@@ -1797,12 +1875,32 @@ class Compiler(
|
||||
if (context.containsLocal(name))
|
||||
throw ScriptError(nameToken.pos, "Variable $name is already defined")
|
||||
|
||||
// init value could be a val; when we initialize by-value type var with it, we need to
|
||||
// create a separate copy:
|
||||
val initValue = initialExpression?.execute(context)?.byValueCopy() ?: ObjNull
|
||||
|
||||
context.addItem(name, isMutable, initValue, visibility, recordType = ObjRecord.Type.Field)
|
||||
initValue
|
||||
if (isDelegate) {
|
||||
TODO()
|
||||
// println("initial expr = $initialExpression")
|
||||
// val initValue =
|
||||
// (initialExpression?.execute(context.copy(Arguments(ObjString(name)))) as? Statement)
|
||||
// ?.execute(context.copy(Arguments(ObjString(name))))
|
||||
// ?: context.raiseError("delegate initialization required")
|
||||
// println("delegate init: $initValue")
|
||||
// if (!initValue.isInstanceOf(ObjArray))
|
||||
// context.raiseIllegalArgument("delegate initialized must be an array")
|
||||
// val s = initValue.getAt(context, 1)
|
||||
// val setter = if (s == ObjNull) statement { raiseNotImplemented("setter is not provided") }
|
||||
// else (s as? Statement) ?: context.raiseClassCastError("setter must be a callable")
|
||||
// ObjDelegate(
|
||||
// (initValue.getAt(context, 0) as? Statement)
|
||||
// ?: context.raiseClassCastError("getter must be a callable"), setter
|
||||
// ).also {
|
||||
// context.addItem(name, isMutable, it, visibility, recordType = ObjRecord.Type.Field)
|
||||
// }
|
||||
} else {
|
||||
// init value could be a val; when we initialize by-value type var with it, we need to
|
||||
// create a separate copy:
|
||||
val initValue = initialExpression?.execute(context)?.byValueCopy() ?: ObjNull
|
||||
context.addItem(name, isMutable, initValue, visibility, recordType = ObjRecord.Type.Field)
|
||||
initValue
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1910,6 +2008,8 @@ class Compiler(
|
||||
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_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
|
||||
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) },
|
||||
@@ -1921,7 +2021,15 @@ class Compiler(
|
||||
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.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
|
||||
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
|
||||
|
||||
@@ -39,7 +39,6 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
fun next() =
|
||||
if (currentIndex < tokens.size) tokens[currentIndex++]
|
||||
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]
|
||||
|
||||
@@ -131,6 +130,28 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
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 {
|
||||
val t = next()
|
||||
@@ -207,7 +228,7 @@ class CompilerContext(val tokens: List<Token>) {
|
||||
while (current().type in wstokens) {
|
||||
next()
|
||||
}
|
||||
return next()
|
||||
return current()
|
||||
}
|
||||
|
||||
companion object {
|
||||
|
||||
@@ -20,10 +20,10 @@ package net.sergeych.lyng
|
||||
val digitsSet = ('0'..'9').toSet()
|
||||
val digits = { d: Char -> d in digitsSet }
|
||||
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")
|
||||
val idFirstChars = { d: Char -> d.isLetter() || d == '_' }
|
||||
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
|
||||
|
||||
fun parseLyng(source: Source): List<Token> {
|
||||
val p = Parser(fromPos = source.startPos)
|
||||
@@ -67,13 +67,16 @@ private class Parser(fromPos: Pos) {
|
||||
pos.advance()
|
||||
Token("===", from, Token.Type.REF_EQ)
|
||||
}
|
||||
|
||||
else -> Token("==", from, Token.Type.EQ)
|
||||
}
|
||||
} else if( currentChar == '>' ) {
|
||||
} else if (currentChar == '>') {
|
||||
pos.advance()
|
||||
Token("=>", from, Token.Type.EQARROW)
|
||||
}
|
||||
else
|
||||
} else if (currentChar == '~') {
|
||||
pos.advance()
|
||||
Token("=~", from, Token.Type.MATCH)
|
||||
} else
|
||||
Token("=", from, Token.Type.ASSIGN)
|
||||
}
|
||||
|
||||
@@ -227,6 +230,9 @@ private class Parser(fromPos: Pos) {
|
||||
Token("!==", from, Token.Type.REF_NEQ)
|
||||
} else
|
||||
Token("!=", from, Token.Type.NEQ)
|
||||
} else if (currentChar == '~') {
|
||||
pos.advance()
|
||||
Token("!~", from, Token.Type.NOTMATCH)
|
||||
} else
|
||||
Token("!", from, Token.Type.NOT)
|
||||
}
|
||||
@@ -267,7 +273,7 @@ private class Parser(fromPos: Pos) {
|
||||
|
||||
in digitsSet -> {
|
||||
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.NULL_COALESCE)
|
||||
@@ -310,7 +316,7 @@ private class Parser(fromPos: Pos) {
|
||||
// Labels processing is complicated!
|
||||
// some@ statement: label 'some', ID 'statement'
|
||||
// statement@some: ID 'statement', LABEL 'some'!
|
||||
if (ch.isLetter() || ch == '_') {
|
||||
if (idNextChars(ch)) {
|
||||
val text = ch + loadChars(idNextChars)
|
||||
if (currentChar == '@') {
|
||||
pos.advance()
|
||||
@@ -395,25 +401,24 @@ private class Parser(fromPos: Pos) {
|
||||
private fun fixMultilineStringLiteral(source: String): String {
|
||||
val sizes = mutableListOf<Int>()
|
||||
val lines = source.lines().toMutableList()
|
||||
if( lines.size == 0 ) return ""
|
||||
if( lines[0].isBlank() ) lines.removeFirst()
|
||||
if( lines.isEmpty()) return ""
|
||||
if( lines.last().isBlank() ) lines.removeLast()
|
||||
if (lines.size == 0) return ""
|
||||
if (lines[0].isBlank()) lines.removeFirst()
|
||||
if (lines.isEmpty()) return ""
|
||||
if (lines.last().isBlank()) lines.removeLast()
|
||||
|
||||
val normalized = lines.map { l ->
|
||||
if( l.isBlank() ) {
|
||||
if (l.isBlank()) {
|
||||
sizes.add(-1)
|
||||
""
|
||||
}
|
||||
else {
|
||||
} else {
|
||||
val margin = leftMargin(l)
|
||||
sizes += margin
|
||||
" ".repeat(margin) + l.trim()
|
||||
}
|
||||
}
|
||||
val commonMargin = sizes.filter { it >= 0 }.min()
|
||||
val fixed = if( commonMargin < 1 ) lines else normalized.map {
|
||||
if( it.isBlank() ) "" else it.drop(commonMargin)
|
||||
val fixed = if (commonMargin < 1) lines else normalized.map {
|
||||
if (it.isBlank()) "" else it.drop(commonMargin)
|
||||
}
|
||||
return fixed.joinToString("\n")
|
||||
}
|
||||
@@ -433,15 +438,34 @@ private class Parser(fromPos: Pos) {
|
||||
'\\' -> {
|
||||
pos.advance() ?: raise("unterminated string")
|
||||
when (currentChar) {
|
||||
'n' -> sb.append('\n')
|
||||
'r' -> sb.append('\r')
|
||||
't' -> sb.append('\t')
|
||||
'"' -> sb.append('"')
|
||||
else -> sb.append('\\').append(currentChar)
|
||||
'n' -> {
|
||||
sb.append('\n'); pos.advance()
|
||||
}
|
||||
|
||||
'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
|
||||
sb.append(currentChar)
|
||||
pos.advance()
|
||||
@@ -455,7 +479,7 @@ private class Parser(fromPos: Pos) {
|
||||
}
|
||||
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)
|
||||
}
|
||||
@@ -534,7 +558,7 @@ private class Parser(fromPos: Pos) {
|
||||
|
||||
init {
|
||||
// skip shebang
|
||||
if( pos.readFragment("#!") )
|
||||
if (pos.readFragment("#!"))
|
||||
loadToEndOfLine()
|
||||
}
|
||||
|
||||
|
||||
@@ -131,9 +131,11 @@ open class Scope(
|
||||
open operator fun get(name: String): ObjRecord? =
|
||||
if (name == "this") thisObj.asReadonly
|
||||
else {
|
||||
objects[name]
|
||||
(objects[name]
|
||||
?: parent?.get(name)
|
||||
?: thisObj.objClass.getInstanceMemberOrNull(name)
|
||||
?: thisObj.objClass
|
||||
.getInstanceMemberOrNull(name)
|
||||
)
|
||||
}
|
||||
|
||||
fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
||||
@@ -242,6 +244,8 @@ open class Scope(
|
||||
|
||||
}
|
||||
|
||||
open fun applyClosure(closure: Scope): Scope = ClosureScope(this, closure)
|
||||
|
||||
companion object {
|
||||
|
||||
fun new(): Scope =
|
||||
|
||||
@@ -57,15 +57,15 @@ class Script(
|
||||
ObjException.addExceptionsToContext(this)
|
||||
addFn("print") {
|
||||
for ((i, a) in args.withIndex()) {
|
||||
if (i > 0) print(' ' + a.asStr.value)
|
||||
else print(a.asStr.value)
|
||||
if (i > 0) print(' ' + a.toString(this).value)
|
||||
else print(a.toString(this).value)
|
||||
}
|
||||
ObjVoid
|
||||
}
|
||||
addFn("println") {
|
||||
for ((i, a) in args.withIndex()) {
|
||||
if (i > 0) print(' ' + a.asStr.value)
|
||||
else print(a.asStr.value)
|
||||
if (i > 0) print(' ' + a.toString(this).value)
|
||||
else print(a.toString(this).value)
|
||||
}
|
||||
println()
|
||||
ObjVoid
|
||||
@@ -165,13 +165,13 @@ class Script(
|
||||
val a = requiredArg<Obj>(0)
|
||||
val b = requiredArg<Obj>(1)
|
||||
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") {
|
||||
val a = requiredArg<Obj>(0)
|
||||
val b = requiredArg<Obj>(1)
|
||||
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") {
|
||||
val code = requireOnlyArg<Statement>()
|
||||
@@ -241,6 +241,8 @@ class Script(
|
||||
addConst("CompletableDeferred", ObjCompletableDeferred.type)
|
||||
addConst("Mutex", ObjMutex.type)
|
||||
|
||||
addConst("Regex", ObjRegex.type)
|
||||
|
||||
addFn("launch") {
|
||||
val callable = requireOnlyArg<Statement>()
|
||||
ObjDeferred(globalDefer {
|
||||
@@ -287,7 +289,7 @@ class Script(
|
||||
is ObjInt -> delay(a.value * 1000)
|
||||
is ObjReal -> delay((a.value * 1000).roundToLong())
|
||||
is ObjDuration -> delay(a.duration)
|
||||
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect()}")
|
||||
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
|
||||
}
|
||||
ObjVoid
|
||||
}
|
||||
|
||||
@@ -33,6 +33,6 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
|
||||
|
||||
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)
|
||||
@@ -17,10 +17,14 @@
|
||||
|
||||
package net.sergeych.lyng
|
||||
|
||||
import net.sergeych.lyng.obj.ObjString
|
||||
|
||||
class Source(val fileName: String, text: String) {
|
||||
|
||||
val lines = text.lines().map { it.trimEnd() }
|
||||
|
||||
val objSourceName by lazy { ObjString(fileName) }
|
||||
|
||||
companion object {
|
||||
val builtIn: Source by lazy { Source("built-in", "") }
|
||||
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
|
||||
|
||||
@@ -24,6 +24,10 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
|
||||
|
||||
val isComment: Boolean by lazy { type == Type.SINLGE_LINE_COMMENT || type == Type.MULTILINE_COMMENT }
|
||||
|
||||
fun isId(text: String) =
|
||||
type == Type.ID && value == text
|
||||
|
||||
|
||||
@Suppress("unused")
|
||||
enum class Type {
|
||||
ID, INT, REAL, HEX, STRING, CHAR,
|
||||
@@ -33,7 +37,7 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
|
||||
ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
|
||||
PLUS2, MINUS2,
|
||||
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,
|
||||
AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
|
||||
SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
|
||||
|
||||
@@ -21,14 +21,11 @@ import kotlinx.coroutines.sync.Mutex
|
||||
import kotlinx.coroutines.sync.withLock
|
||||
import kotlinx.serialization.SerialName
|
||||
import kotlinx.serialization.Serializable
|
||||
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.synctools.ProtectedOp
|
||||
import net.sergeych.synctools.withLock
|
||||
import kotlin.contracts.ExperimentalContracts
|
||||
|
||||
open class Obj {
|
||||
|
||||
@@ -49,7 +46,7 @@ open class Obj {
|
||||
|
||||
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.
|
||||
@@ -84,14 +81,16 @@ open class Obj {
|
||||
scope: Scope,
|
||||
name: String,
|
||||
args: Arguments = Arguments.EMPTY,
|
||||
onNotFoundResult: Obj?=null
|
||||
): Obj =
|
||||
objClass.getInstanceMemberOrNull(name)?.value?.invoke(
|
||||
onNotFoundResult: (() -> Obj?)? = null
|
||||
): Obj {
|
||||
return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
|
||||
scope,
|
||||
this,
|
||||
args)
|
||||
?: onNotFoundResult
|
||||
args
|
||||
)
|
||||
?: onNotFoundResult?.invoke()
|
||||
?: scope.raiseSymbolNotFound(name)
|
||||
}
|
||||
|
||||
open suspend fun getInstanceMethod(
|
||||
scope: Scope,
|
||||
@@ -113,8 +112,28 @@ open class Obj {
|
||||
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,8 +178,18 @@ open class Obj {
|
||||
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 fun getValue(scope: Scope) = this
|
||||
|
||||
/**
|
||||
* a += b
|
||||
* if( the operation is not defined, it returns null and the compiler would try
|
||||
@@ -272,19 +301,34 @@ open class Obj {
|
||||
scope.raiseNotImplemented()
|
||||
}
|
||||
|
||||
fun autoInstanceScope(parent: Scope): Scope {
|
||||
val scope = parent.copy(newThisObj = this, args = parent.args)
|
||||
for( m in objClass.members) {
|
||||
fun autoInstanceScope(parent: Scope): Scope {
|
||||
val scope = parent.copy(newThisObj = this, args = parent.args)
|
||||
for (m in objClass.members) {
|
||||
scope.objects[m.key] = m.value
|
||||
}
|
||||
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 {
|
||||
|
||||
val rootObjectType = ObjClass("Obj").apply {
|
||||
addFn("toString") {
|
||||
thisObj.asStr
|
||||
addFn("toString", true) {
|
||||
thisObj.toString(this, true)
|
||||
}
|
||||
addFn("inspect", true) {
|
||||
thisObj.inspect(this).toObj()
|
||||
}
|
||||
addFn("contains") {
|
||||
ObjBool(thisObj.contains(this, args.firstAndOnly()))
|
||||
@@ -294,15 +338,21 @@ open class Obj {
|
||||
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
|
||||
}
|
||||
addFn("apply") {
|
||||
val newContext = (thisObj as? ObjInstance)?.instanceScope ?: this
|
||||
args.firstAndOnly()
|
||||
.callOn(newContext)
|
||||
val body = args.firstAndOnly()
|
||||
(thisObj as? ObjInstance)?.let {
|
||||
body.callOn(ApplyScope(this, it.instanceScope))
|
||||
} ?: run {
|
||||
body.callOn(this)
|
||||
}
|
||||
thisObj
|
||||
}
|
||||
addFn("also") {
|
||||
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
|
||||
thisObj
|
||||
}
|
||||
addFn("run") {
|
||||
args.firstAndOnly().callOn(this)
|
||||
}
|
||||
addFn("getAt") {
|
||||
requireExactCount(1)
|
||||
thisObj.getAt(this, requiredArg<Obj>(0))
|
||||
@@ -377,9 +427,14 @@ object ObjNull : Obj() {
|
||||
scope.raiseNPE()
|
||||
}
|
||||
|
||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj {
|
||||
scope.raiseNPE()
|
||||
}
|
||||
// override suspend fun invokeInstanceMethod(
|
||||
// scope: Scope,
|
||||
// name: String,
|
||||
// args: Arguments,
|
||||
// onNotFoundResult: (()->Obj?)?
|
||||
// ): Obj {
|
||||
// scope.raiseNPE()
|
||||
// }
|
||||
|
||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||
scope.raiseNPE()
|
||||
@@ -421,6 +476,9 @@ object ObjNull : Obj() {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* TODO: get rid of it. Maybe we ise some Lyng inheritance instead
|
||||
*/
|
||||
interface Numeric {
|
||||
val longValue: Long
|
||||
val doubleValue: Double
|
||||
@@ -451,129 +509,11 @@ fun Obj.toBool(): Boolean =
|
||||
data class ObjNamespace(val name: String) : Obj() {
|
||||
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 {
|
||||
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)
|
||||
}
|
||||
|
||||
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()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
|
||||
data class ObjBool(val value: Boolean) : Obj() {
|
||||
override val asStr by lazy { ObjString(value.toString()) }
|
||||
|
||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||
if (other !is ObjBool) return -2
|
||||
|
||||
@@ -19,19 +19,26 @@ package net.sergeych.lyng.obj
|
||||
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.flow.toList
|
||||
import net.sergeych.bintools.decodeHex
|
||||
import net.sergeych.bintools.encodeToHex
|
||||
import net.sergeych.bintools.toDump
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.statement
|
||||
import net.sergeych.lynon.BitArray
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
import net.sergeych.lynon.LynonType
|
||||
import net.sergeych.mp_tools.decodeBase64Url
|
||||
import net.sergeych.mp_tools.encodeToBase64Url
|
||||
import kotlin.math.min
|
||||
|
||||
open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
|
||||
override val objClass: ObjClass = type
|
||||
|
||||
val hex by lazy { byteArray.encodeToHex("")}
|
||||
val base64 by lazy { byteArray.toByteArray().encodeToBase64Url()}
|
||||
|
||||
fun checkIndex(scope: Scope, index: Obj): Int {
|
||||
if (index !is ObjInt)
|
||||
scope.raiseIllegalArgument("index must be Int")
|
||||
@@ -80,12 +87,10 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
|
||||
.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 {
|
||||
return "Buffer(${byteArray.encodeToHex()})"
|
||||
}
|
||||
override fun toString(): String = base64
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
@@ -102,6 +107,8 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
encoder.encodeCachedBytes(byteArray.asByteArray())
|
||||
}
|
||||
|
||||
override suspend fun inspect(scope: Scope): String = "Buf($base64)"
|
||||
|
||||
companion object {
|
||||
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
|
||||
when (obj) {
|
||||
@@ -122,7 +129,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
)
|
||||
} else
|
||||
scope.raiseIllegalArgument(
|
||||
"can't construct buffer from ${obj.inspect()}"
|
||||
"can't construct buffer from ${obj.inspect(scope)}"
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -142,7 +149,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
is ObjChar -> b.value.code.toUByte()
|
||||
is ObjInt -> b.value.toUByte()
|
||||
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
|
||||
@@ -158,11 +165,27 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
})
|
||||
|
||||
}.apply {
|
||||
addClassFn("decodeBase64") {
|
||||
ObjBuffer(requireOnlyArg<Obj>().toString().decodeBase64Url().asUByteArray())
|
||||
}
|
||||
addClassFn("decodeHex") {
|
||||
ObjBuffer(requireOnlyArg<Obj>().toString().decodeHex().asUByteArray())
|
||||
}
|
||||
createField("size",
|
||||
statement {
|
||||
(thisObj as ObjBuffer).byteArray.size.toObj()
|
||||
}
|
||||
)
|
||||
createField("hex",
|
||||
statement {
|
||||
thisAs<ObjBuffer>().hex.toObj()
|
||||
}
|
||||
)
|
||||
createField("base64",
|
||||
statement {
|
||||
thisAs<ObjBuffer>().base64.toObj()
|
||||
}
|
||||
)
|
||||
addFn("decodeUtf8") {
|
||||
ObjString(
|
||||
thisAs<ObjBuffer>().byteArray.toByteArray().decodeToString()
|
||||
@@ -178,6 +201,9 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
||||
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 inspect(): String = "'$value'"
|
||||
override suspend fun inspect(scope: Scope): String = "'$value'"
|
||||
|
||||
override fun hashCode(): Int {
|
||||
return value.hashCode()
|
||||
|
||||
@@ -61,13 +61,17 @@ open class ObjClass(
|
||||
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
val instance = ObjInstance(this)
|
||||
instance.instanceScope = scope.copy(newThisObj = instance,args = scope.args)
|
||||
instance.instanceScope = scope.copy(newThisObj = instance, args = scope.args)
|
||||
if (instanceConstructor != null) {
|
||||
instanceConstructor!!.execute(instance.instanceScope)
|
||||
}
|
||||
return instance
|
||||
}
|
||||
|
||||
suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
|
||||
return callOn(scope.copy(Arguments(*plainArgs)))
|
||||
}
|
||||
|
||||
|
||||
fun createField(
|
||||
name: String,
|
||||
@@ -77,13 +81,13 @@ open class ObjClass(
|
||||
pos: Pos = Pos.builtIn
|
||||
) {
|
||||
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")
|
||||
members[name] = ObjRecord(initialValue, isMutable, visibility)
|
||||
}
|
||||
|
||||
private fun initClassScope(): Scope {
|
||||
if( classScope == null ) classScope = Scope()
|
||||
if (classScope == null) classScope = Scope()
|
||||
return classScope!!
|
||||
}
|
||||
|
||||
@@ -96,7 +100,7 @@ open class ObjClass(
|
||||
) {
|
||||
initClassScope()
|
||||
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")
|
||||
classScope!!.addItem(name, isMutable, initialValue, visibility)
|
||||
}
|
||||
@@ -127,26 +131,29 @@ open class ObjClass(
|
||||
|
||||
override suspend fun readField(scope: Scope, name: String): ObjRecord {
|
||||
classScope?.objects?.get(name)?.let {
|
||||
if( it.visibility.isPublic ) return it
|
||||
if (it.visibility.isPublic) return it
|
||||
}
|
||||
return super.readField(scope, name)
|
||||
}
|
||||
|
||||
override suspend fun writeField(scope: Scope, name: String, newValue: Obj) {
|
||||
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")
|
||||
}
|
||||
?: super.writeField(scope, name, newValue)
|
||||
}
|
||||
|
||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
||||
onNotFoundResult: Obj?): Obj {
|
||||
override suspend fun invokeInstanceMethod(
|
||||
scope: Scope, name: String, args: Arguments,
|
||||
onNotFoundResult: (() -> Obj?)?
|
||||
): Obj {
|
||||
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
|
||||
?: 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
|
||||
|
||||
/**
|
||||
* Collection is an iterator with `size`]
|
||||
* Collection is an iterator with `size`
|
||||
*/
|
||||
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* 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
|
||||
|
||||
//class ObjDelegateContext()
|
||||
//
|
||||
//class ObjDelegate(
|
||||
// val getter: Statement,
|
||||
// val setter: Statement = statement { raiseNotImplemented("setter is not implemented") }
|
||||
//): Obj() {
|
||||
//
|
||||
// override suspend fun assign(scope: Scope, other: Obj): Obj? {
|
||||
// setter.execute(scope.copy(Arguments(other)))
|
||||
// return other
|
||||
// }
|
||||
//
|
||||
// companion object {
|
||||
// val type = object: ObjClass("Delegate") {
|
||||
// override suspend fun callOn(scope: Scope): Obj {
|
||||
// scope.raiseError("Delegate should not be constructed directly")
|
||||
// }
|
||||
// }.apply {
|
||||
//
|
||||
// }
|
||||
// }
|
||||
//
|
||||
//}
|
||||
@@ -57,7 +57,7 @@ class ObjDuration(val duration: Duration) : Obj() {
|
||||
override suspend fun callOn(scope: Scope): Obj {
|
||||
val args = scope.args
|
||||
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)
|
||||
|
||||
return ObjDuration(
|
||||
@@ -66,7 +66,7 @@ class ObjDuration(val duration: Duration) : Obj() {
|
||||
is ObjInt -> a0.value.seconds
|
||||
is ObjReal -> a0.value.seconds
|
||||
else -> {
|
||||
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
|
||||
scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
@@ -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 exception scope. It is used to restore serialized
|
||||
* exception with stack trace; the scope of the de-serialized 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("Throwable").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)
|
||||
@@ -40,12 +40,12 @@ class ObjFlowBuilder(val output: SendChannel<Obj>) : Obj() {
|
||||
val data = requireOnlyArg<Obj>()
|
||||
try {
|
||||
val channel = thisAs<ObjFlowBuilder>().output
|
||||
if( !channel.isClosedForSend )
|
||||
if (!channel.isClosedForSend)
|
||||
channel.send(data)
|
||||
else
|
||||
throw ScriptFlowIsNoMoreCollected()
|
||||
} catch (x: Exception) {
|
||||
if( x !is CancellationException )
|
||||
if (x !is CancellationException)
|
||||
x.printStackTrace()
|
||||
throw ScriptFlowIsNoMoreCollected()
|
||||
}
|
||||
@@ -62,12 +62,10 @@ private fun createLyngFlowInput(scope: Scope, producer: Statement): ReceiveChann
|
||||
globalLaunch {
|
||||
try {
|
||||
producer.execute(builderScope)
|
||||
}
|
||||
catch(x: ScriptFlowIsNoMoreCollected) {
|
||||
} catch (x: ScriptFlowIsNoMoreCollected) {
|
||||
x.printStackTrace()
|
||||
// premature flow closing, OK
|
||||
}
|
||||
catch(x: Exception) {
|
||||
} catch (x: Exception) {
|
||||
x.printStackTrace()
|
||||
}
|
||||
channel.close()
|
||||
@@ -87,7 +85,11 @@ class ObjFlow(val producer: Statement, val scope: Scope) : Obj() {
|
||||
}.apply {
|
||||
addFn("iterator") {
|
||||
val objFlow = thisAs<ObjFlow>()
|
||||
ObjFlowIterator( statement { objFlow.producer.execute(ClosureScope(this,objFlow.scope)) } )
|
||||
ObjFlowIterator(statement {
|
||||
objFlow.producer.execute(
|
||||
ClosureScope(this, objFlow.scope)
|
||||
)
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -105,9 +107,10 @@ class ObjFlowIterator(val producer: Statement) : Obj() {
|
||||
private var isCancelled = false
|
||||
|
||||
private fun checkNotCancelled(scope: Scope) {
|
||||
if( isCancelled )
|
||||
if (isCancelled)
|
||||
scope.raiseIllegalState("iteration is cancelled")
|
||||
}
|
||||
|
||||
suspend fun hasNext(scope: Scope): ObjBool {
|
||||
checkNotCancelled(scope)
|
||||
// cold start:
|
||||
|
||||
@@ -48,7 +48,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
||||
}
|
||||
|
||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
||||
onNotFoundResult: Obj?): Obj =
|
||||
onNotFoundResult: (()->Obj?)?): Obj =
|
||||
instanceScope[name]?.let {
|
||||
if (it.visibility.isPublic)
|
||||
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 {
|
||||
val args = decoder.decodeAnyList(scope)
|
||||
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}")
|
||||
val newScope = scope.copy(args = Arguments(args))
|
||||
return (callOn(newScope) as ObjInstance).apply {
|
||||
deserializeStateVars(scope,decoder)
|
||||
invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid)
|
||||
deserializeStateVars(scope, decoder)
|
||||
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
|
||||
|
||||
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
|
||||
|
||||
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 doubleValue get() = value.toDouble()
|
||||
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 val objClass: ObjClass = type
|
||||
override val objClass: ObjClass by lazy { type }
|
||||
|
||||
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
||||
if (other is ObjInt)
|
||||
|
||||
@@ -119,12 +119,6 @@ val ObjIterable by lazy {
|
||||
ObjList(result)
|
||||
}
|
||||
|
||||
// addFn("drop" ) {
|
||||
// var n = requireOnlyArg<ObjInt>().value.toInt()
|
||||
// if( n < 0 ) raiseIllegalArgument("drop($n): should be positive")
|
||||
// val it = callMethod<>()
|
||||
// }
|
||||
|
||||
addFn("isEmpty") {
|
||||
ObjBool(
|
||||
thisObj.invokeInstanceMethod(this, "iterator")
|
||||
@@ -132,5 +126,20 @@ val ObjIterable by lazy {
|
||||
.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.
|
||||
*/
|
||||
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 hasNext = iterator.getInstanceMethod(scope, "hasNext")
|
||||
val next = iterator.getInstanceMethod(scope, "next")
|
||||
var closeIt = false
|
||||
while (hasNext.invoke(scope, iterator).toBool()) {
|
||||
val nextValue = next.invoke(scope, iterator)
|
||||
if( !callback(nextValue) ) {
|
||||
if (!callback(nextValue)) {
|
||||
closeIt = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if( closeIt )
|
||||
iterator.invokeInstanceMethod(scope, "cancelIteration", onNotFoundResult = ObjVoid)
|
||||
if (closeIt)
|
||||
iterator.invokeInstanceMethod(scope, "cancelIteration") { ObjVoid }
|
||||
}
|
||||
@@ -18,6 +18,7 @@
|
||||
package net.sergeych.lyng.obj
|
||||
|
||||
import net.sergeych.lyng.Scope
|
||||
import net.sergeych.lyng.Statement
|
||||
import net.sergeych.lyng.statement
|
||||
import net.sergeych.lynon.LynonDecoder
|
||||
import net.sergeych.lynon.LynonEncoder
|
||||
@@ -25,10 +26,6 @@ import net.sergeych.lynon.LynonType
|
||||
|
||||
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 {
|
||||
return when (index) {
|
||||
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) }
|
||||
}
|
||||
|
||||
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 {
|
||||
// check?
|
||||
return list.hashCode()
|
||||
@@ -239,8 +263,27 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||
}
|
||||
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 ObjChar -> newValue.value.code.toUByte()
|
||||
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
|
||||
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 ObjInt -> b.value.toUByte()
|
||||
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
|
||||
|
||||
@@ -26,12 +26,12 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
|
||||
|
||||
override val objClass: ObjClass = type
|
||||
|
||||
override fun toString(): String {
|
||||
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
|
||||
val result = StringBuilder()
|
||||
result.append("${start?.inspect() ?: '∞'} ..")
|
||||
result.append("${start?.inspect(scope) ?: '∞'} ..")
|
||||
if (!isEndInclusive) result.append('<')
|
||||
result.append(" ${end?.inspect() ?: '∞'}")
|
||||
return result.toString()
|
||||
result.append(" ${end?.inspect(scope) ?: '∞'}")
|
||||
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]
|
||||
* otherwise returns start.value.toInt()
|
||||
*/
|
||||
fun startInt(scope: Scope): Int =
|
||||
suspend fun startInt(scope: Scope): Int =
|
||||
if( start == null || start is ObjNull) 0
|
||||
else {
|
||||
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 {
|
||||
|
||||
@@ -56,7 +56,7 @@ class ObjRangeIterator(val self: ObjRange) : Obj() {
|
||||
}
|
||||
|
||||
companion object {
|
||||
val type = ObjClass("RangeIterator", ObjIterable).apply {
|
||||
val type = ObjClass("RangeIterator", ObjIterator).apply {
|
||||
addFn("hasNext") {
|
||||
thisAs<ObjRangeIterator>().hasNext().toObj()
|
||||
}
|
||||
|
||||
@@ -27,7 +27,6 @@ import kotlin.math.floor
|
||||
import kotlin.math.roundToLong
|
||||
|
||||
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 doubleValue: Double by lazy { value }
|
||||
override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
|
||||
|
||||
@@ -35,11 +35,15 @@ data class ObjRecord(
|
||||
Field(true, true),
|
||||
@Suppress("unused")
|
||||
Fun,
|
||||
@Suppress("unused")
|
||||
ConstructorField(true, true),
|
||||
Argument(true, true),
|
||||
@Suppress("unused")
|
||||
Class,
|
||||
Enum,
|
||||
Other
|
||||
Other;
|
||||
|
||||
val isArgument get() = this == Argument
|
||||
}
|
||||
@Suppress("unused")
|
||||
fun qualifiedName(name: String): String =
|
||||
|
||||
@@ -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 val asStr: ObjString by lazy { this }
|
||||
|
||||
override fun inspect(): String {
|
||||
override suspend fun inspect(scope: Scope): String {
|
||||
return "\"$value\""
|
||||
}
|
||||
|
||||
@@ -54,20 +52,27 @@ data class ObjString(val value: String) : Obj() {
|
||||
get() = type
|
||||
|
||||
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 {
|
||||
if (index is ObjInt) return ObjChar(value[index.toInt()])
|
||||
if (index is ObjRange) {
|
||||
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 e = index.end.toInt()
|
||||
if (index.isEndInclusive) e + 1 else e
|
||||
when (index) {
|
||||
is ObjInt -> return ObjChar(value[index.toInt()])
|
||||
is ObjRange -> {
|
||||
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 e = index.end.toInt()
|
||||
if (index.isEndInclusive) e + 1 else e
|
||||
}
|
||||
return ObjString(value.substring(start, end))
|
||||
}
|
||||
return ObjString(value.substring(start, end))
|
||||
|
||||
is ObjRegex -> {
|
||||
return index.find(this)
|
||||
}
|
||||
|
||||
else -> scope.raiseIllegalArgument("String index must be Int, Regex or Range")
|
||||
}
|
||||
scope.raiseIllegalArgument("String index must be Int or Range")
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
@@ -98,6 +103,11 @@ data class ObjString(val value: String) : Obj() {
|
||||
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 serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
||||
@@ -110,8 +120,9 @@ data class ObjString(val value: String) : Obj() {
|
||||
ObjString(decoder.unpackBinaryData().decodeToString())
|
||||
}.apply {
|
||||
addFn("toInt") {
|
||||
ObjInt(thisAs<ObjString>().value.toLongOrNull()
|
||||
?: raiseIllegalArgument("can't convert to int: $thisObj")
|
||||
ObjInt(
|
||||
thisAs<ObjString>().value.toLongOrNull()
|
||||
?: raiseIllegalArgument("can't convert to int: $thisObj")
|
||||
)
|
||||
}
|
||||
addFn("startsWith") {
|
||||
@@ -159,6 +170,25 @@ data class ObjString(val value: String) : Obj() {
|
||||
addFn("toReal") {
|
||||
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")
|
||||
}
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -19,11 +19,23 @@ package net.sergeych.lyng.stdlib_included
|
||||
internal val rootLyng = """
|
||||
package lyng.stdlib
|
||||
|
||||
fun cached(builder) {
|
||||
var calculated = false
|
||||
var value = null
|
||||
{
|
||||
if( !calculated ) {
|
||||
value = builder()
|
||||
calculated = true
|
||||
}
|
||||
value
|
||||
}
|
||||
}
|
||||
|
||||
fun Iterable.filter(predicate) {
|
||||
val list = this
|
||||
flow {
|
||||
for( item in list ) {
|
||||
if( predicate(item) ) {
|
||||
if( predicate(item) ) {ln
|
||||
emit(item)
|
||||
}
|
||||
}
|
||||
@@ -38,7 +50,7 @@ fun Iterable.drop(n) {
|
||||
fun Iterable.first() {
|
||||
val i = iterator()
|
||||
if( !i.hasNext() ) throw NoSuchElementException()
|
||||
i.next()
|
||||
i.next().also { i.cancelIteration() }
|
||||
}
|
||||
|
||||
fun Iterable.last() {
|
||||
@@ -65,11 +77,96 @@ fun Iterable.dropLast(n) {
|
||||
}
|
||||
|
||||
fun Iterable.takeLast(n) {
|
||||
val list = this
|
||||
val buffer = RingBuffer(n)
|
||||
for( item in list ) buffer += item
|
||||
for( item in this ) buffer += item
|
||||
buffer
|
||||
}
|
||||
|
||||
fun Iterable.joinToString(prefix=" ", transformer=null) {
|
||||
var result = null
|
||||
for( part in this ) {
|
||||
val transformed = transformer?(part)?.toString() ?: part.toString()
|
||||
if( result == null ) result = transformed
|
||||
else result += prefix + transformed
|
||||
}
|
||||
result ?: ""
|
||||
}
|
||||
|
||||
fun Iterable.any(predicate): Bool {
|
||||
for( i in this ) {
|
||||
if( predicate(i) )
|
||||
break true
|
||||
} else false
|
||||
}
|
||||
|
||||
fun Iterable.all(predicate): Bool {
|
||||
!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()
|
||||
|
||||
@@ -101,7 +101,6 @@ interface BitOutput {
|
||||
val compressed = LZW.compress(source.asUByteArray())
|
||||
// check that compression is effective including header bits size:
|
||||
if( compressed.size + 2 < source.size * 8L) {
|
||||
println("write compressed")
|
||||
putBit(1)
|
||||
// LZW algorithm
|
||||
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 {
|
||||
val className = decodeObject(scope, ObjString.type, null) as ObjString
|
||||
return scope.get(className.value)?.value?.let {
|
||||
@@ -72,7 +85,7 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
|
||||
} ?: 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) {
|
||||
// homogenous
|
||||
val type = LynonType.entries[getBitsAsInt(4)]
|
||||
|
||||
@@ -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,15 @@ class OOTest {
|
||||
}
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testMultilineConstructor() = runTest {
|
||||
eval("""
|
||||
class Point(
|
||||
x,
|
||||
y
|
||||
)
|
||||
assertEquals(Point(1,2), Point(1,2) )
|
||||
""".trimIndent())
|
||||
}
|
||||
}
|
||||
@@ -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
|
||||
fun testCharacterRange() = runTest {
|
||||
eval(
|
||||
@@ -1359,9 +1388,6 @@ class ScriptTest {
|
||||
}
|
||||
|
||||
val prefix = ":"
|
||||
val lambda = {
|
||||
prefix + getText() + "!"
|
||||
}
|
||||
|
||||
val text = "invalid"
|
||||
val t1 = T("foo")
|
||||
@@ -1371,18 +1397,22 @@ class ScriptTest {
|
||||
// it must take "text" from class t1:
|
||||
assertEquals("foo", text)
|
||||
assertEquals( "foo!", getText() )
|
||||
assertEquals( ":foo!!", lambda() )
|
||||
assertEquals( ":foo!!", {
|
||||
prefix + getText() + "!"
|
||||
}())
|
||||
}
|
||||
t2.apply {
|
||||
assertEquals("bar", text)
|
||||
assertEquals( "bar!", getText() )
|
||||
assertEquals( ":bar!!", lambda() )
|
||||
assertEquals( ":bar!!", {
|
||||
prefix + getText() + "!"
|
||||
}())
|
||||
}
|
||||
// worst case: names clash
|
||||
fun badOne() {
|
||||
val prefix = "&"
|
||||
t1.apply {
|
||||
assertEquals( ":foo!!", lambda() )
|
||||
assertEquals( ":foo!!", prefix + getText() + "!" )
|
||||
}
|
||||
}
|
||||
badOne()
|
||||
@@ -1759,7 +1789,7 @@ class ScriptTest {
|
||||
"e="+e+"f="+f()
|
||||
}
|
||||
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()
|
||||
)
|
||||
|
||||
@@ -1794,7 +1824,7 @@ class ScriptTest {
|
||||
}
|
||||
val f = Foo()
|
||||
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()
|
||||
)
|
||||
|
||||
@@ -2005,7 +2035,7 @@ class ScriptTest {
|
||||
|
||||
@Test
|
||||
fun testThrowFromKotlin() = runTest {
|
||||
val c = Scope()
|
||||
val c = Script.newScope()
|
||||
c.addFn("callThrow") {
|
||||
raiseIllegalArgument("fromKotlin")
|
||||
}
|
||||
@@ -2212,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
|
||||
fun testWhenSample1() = runTest {
|
||||
eval(
|
||||
@@ -2629,6 +2698,28 @@ class ScriptTest {
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testBufferEncodings() = runTest {
|
||||
eval(
|
||||
"""
|
||||
import lyng.buffer
|
||||
|
||||
val b = Buffer("hello")
|
||||
println(b.toDump())
|
||||
assertEquals( "hello", b.decodeUtf8() )
|
||||
|
||||
println(b.base64)
|
||||
println(b.hex)
|
||||
|
||||
assertEquals( b, Buffer.decodeBase64(b.base64) )
|
||||
assertEquals( b, Buffer.decodeHex(b.hex) )
|
||||
|
||||
println(b.inspect())
|
||||
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testBufferCompare() = runTest {
|
||||
eval(
|
||||
@@ -2850,7 +2941,8 @@ class ScriptTest {
|
||||
|
||||
@Test
|
||||
fun tesFunAnnotation() = runTest {
|
||||
eval("""
|
||||
eval(
|
||||
"""
|
||||
|
||||
val exportedSymbols = Map()
|
||||
|
||||
@@ -2869,7 +2961,8 @@ class ScriptTest {
|
||||
assert( exportedSymbols["getBalance"] != null )
|
||||
assertEquals(122, getBalance(1))
|
||||
|
||||
""".trimIndent())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -2889,12 +2982,14 @@ class ScriptTest {
|
||||
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
||||
|
||||
|
||||
""".trimIndent())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun enumSerializationTest() = runTest {
|
||||
eval("""
|
||||
eval(
|
||||
"""
|
||||
import lyng.serialization
|
||||
|
||||
enum Color {
|
||||
@@ -2910,8 +3005,321 @@ class ScriptTest {
|
||||
assert( e1.size / 1000.0 < 6)
|
||||
println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
|
||||
|
||||
""".trimIndent())
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun cachedTest() = runTest {
|
||||
eval(
|
||||
"""
|
||||
|
||||
var counter = 0
|
||||
var value = cached {
|
||||
counter++
|
||||
"ok"
|
||||
}
|
||||
|
||||
assertEquals(0, counter)
|
||||
assertEquals("ok", value())
|
||||
assertEquals(1, counter)
|
||||
assertEquals("ok", value())
|
||||
assertEquals(1, counter)
|
||||
""".trimIndent()
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testJoinToString() = runTest {
|
||||
eval(
|
||||
"""
|
||||
assertEquals( (1..3).joinToString(), "1 2 3")
|
||||
assertEquals( (1..3).joinToString(":"), "1:2:3")
|
||||
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
||||
""".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 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()
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -23,8 +23,9 @@ class StdlibTest {
|
||||
@Test
|
||||
fun testIterableFilter() = runTest {
|
||||
eval("""
|
||||
assertEquals([1,3,5,7], (1..8).filter{ it % 2 == 1 }.toList() )
|
||||
assertEquals([2,4,6,8], (1..8).filter{ it % 2 == 0 }.toList() )
|
||||
assertEquals([2,4,6,8], (1..8).filter{ println("call2"); it % 2 == 0 }.toList() )
|
||||
println("-------------------")
|
||||
assertEquals([1,3,5,7], (1..8).filter{ println("call1"); it % 2 == 1 }.toList() )
|
||||
""".trimIndent())
|
||||
|
||||
}
|
||||
@@ -40,8 +41,19 @@ class StdlibTest {
|
||||
@Test
|
||||
fun testTake() = runTest {
|
||||
eval("""
|
||||
assertEquals([1,2,3], (1..8).take(3).toList() )
|
||||
assertEquals([7,8], (1..8).takeLast(2).toList() )
|
||||
val r = 1..8
|
||||
assertEquals([1,2,3], r.take(3).toList() )
|
||||
assertEquals([7,8], r.takeLast(2).toList() )
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testAnyAndAll() = runTest {
|
||||
eval("""
|
||||
assert( [1,2,3].any { it > 2 } )
|
||||
assert( ![1,2,3].any { it > 4 } )
|
||||
assert( [1,2,3].all { it <= 3 } )
|
||||
|
||||
""".trimIndent())
|
||||
}
|
||||
|
||||
|
||||
@@ -177,11 +177,11 @@ suspend fun DocTest.test(_scope: Scope? = null) {
|
||||
scope.apply {
|
||||
addFn("println") {
|
||||
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 {
|
||||
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')
|
||||
}
|
||||
}
|
||||
@@ -194,7 +194,7 @@ suspend fun DocTest.test(_scope: Scope? = null) {
|
||||
} catch (e: Throwable) {
|
||||
error = e
|
||||
null
|
||||
}?.inspect()?.replace(Regex("@\\d+"), "@...")
|
||||
}?.inspect(scope)?.replace(Regex("@\\d+"), "@...")
|
||||
|
||||
if (bookMode) {
|
||||
if (error != null) {
|
||||
@@ -317,4 +317,23 @@ class BookTest {
|
||||
runDocTests("../docs/RingBuffer.md")
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testIterable() = runBlocking {
|
||||
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")
|
||||
}
|
||||
}
|
||||
@@ -649,6 +649,48 @@ class LynonTests {
|
||||
""".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"))
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
Reference in new issue
Block a user