Compare commits
19
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f45fa7f7a0 | ||
|
|
ead2f7168e | ||
|
|
2743511b62 | ||
|
|
8431ab4f96 | ||
|
|
80735f032d | ||
|
|
dc837e2095 | ||
|
|
0ec0ed96ee | ||
|
|
a5e51a3f90 | ||
|
|
cf79163802 | ||
|
|
c8e8bdc466 | ||
|
|
4b613fda7c | ||
|
|
8d1cafae80 | ||
|
|
0526cdfb38 | ||
|
|
cad6ba936d | ||
|
|
cb333ab6bd | ||
|
|
23737f9b5c | ||
|
|
fb6e2aa49e | ||
|
|
95c1da60ed | ||
|
|
835333dfad |
No files matched your search
@@ -134,7 +134,19 @@ Designed to add scripting to kotlin multiplatform application in easy and effici
|
|||||||
|
|
||||||
# Language Roadmap
|
# Language Roadmap
|
||||||
|
|
||||||
## v1.0.0
|
```mermaid
|
||||||
|
flowchart
|
||||||
|
v0([the idea])
|
||||||
|
v1([v1: make it happen])
|
||||||
|
v2([v1.5: testmake it fasted and rich featured])
|
||||||
|
v3([v2: ideal script language])
|
||||||
|
v0 --code MVP--> v1
|
||||||
|
v1 --refine and extend--> v2
|
||||||
|
v2 -- optimize --> v3
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
## v1.0.0 "Make it happen"
|
||||||
|
|
||||||
Planned autumn 2025. Complete dynamic language with sufficient standard library:
|
Planned autumn 2025. Complete dynamic language with sufficient standard library:
|
||||||
|
|
||||||
@@ -158,27 +170,32 @@ Ready features:
|
|||||||
- [x] compression/decompression (integrated in serialization)
|
- [x] compression/decompression (integrated in serialization)
|
||||||
- [x] dynamic fields
|
- [x] dynamic fields
|
||||||
- [x] function annotations
|
- [x] function annotations
|
||||||
|
- [x] better stack reporting
|
||||||
|
|
||||||
### Under way:
|
### Under way:
|
||||||
|
|
||||||
- [ ] regular exceptions
|
- [ ] regular exceptions + extended `when`
|
||||||
- [ ] multiple inheritance for user classes
|
- [ ] multiple inheritance for user classes
|
||||||
- [ ] site with integrated interpreter to give a try
|
- [ ] site with integrated interpreter to give a try
|
||||||
- [ ] kotlin part public API good docs, integration focused
|
- [ ] kotlin part public API good docs, integration focused
|
||||||
- [ ] better stack reporting
|
|
||||||
|
|
||||||
## v1.1+
|
## plan: v1.0 - v1.5 "Rich and stable"
|
||||||
|
|
||||||
|
Estimated spring of 2026
|
||||||
|
|
||||||
Planned features.
|
Planned features.
|
||||||
|
|
||||||
- [ ] type specifications
|
- [ ] type specifications
|
||||||
|
- [ ] language server or compose-based lyng-aware editor
|
||||||
- [ ] source docs and maybe lyng.md to a standard
|
- [ ] source docs and maybe lyng.md to a standard
|
||||||
- [ ] metadata first class access from lyng
|
- [ ] metadata first class access from lyng
|
||||||
|
|
||||||
Further
|
## After 1.5 "Ideal scripting"
|
||||||
|
|
||||||
|
Estimated winter 2027
|
||||||
|
|
||||||
- [ ] client with GUI support based on compose multiplatform somehow
|
- [ ] client with GUI support based on compose multiplatform somehow
|
||||||
- [ ] notebook - style workbooks with graphs, formulae, etc.
|
- [ ] notebook - style workbooks with graphs, formulae, etc.
|
||||||
- [ ] language server or compose-based lyng-aware editor
|
- [ ] aggressive optimizations
|
||||||
|
|
||||||
[parallelism]: docs/parallelism.md
|
[parallelism]: docs/parallelism.md
|
||||||
@@ -0,0 +1,37 @@
|
|||||||
|
# Array
|
||||||
|
|
||||||
|
It's an interface if the [Collection] that provides indexing access, like `array[3] = 0`.
|
||||||
|
Array therefore implements [Iterable] too. The well known implementatino of the `Array` is
|
||||||
|
[List].
|
||||||
|
|
||||||
|
Array adds the following methods:
|
||||||
|
|
||||||
|
## Binary search
|
||||||
|
|
||||||
|
When applied to sorted arrays, binary search allow to quicly find an index of the element in the array, or where to insert it to keep order:
|
||||||
|
|
||||||
|
val coll = [1,2,3,4,5]
|
||||||
|
assertEquals( 2, coll.binarySearch(3) )
|
||||||
|
assertEquals( 0, coll.binarySearch(1) )
|
||||||
|
assertEquals( 4, coll.binarySearch(5) )
|
||||||
|
|
||||||
|
val src = (1..50).toList().shuffled()
|
||||||
|
val result = []
|
||||||
|
for( x in src ) {
|
||||||
|
val i = result.binarySearch(x)
|
||||||
|
assert( i < 0 )
|
||||||
|
result.insertAt(-i-1, x)
|
||||||
|
}
|
||||||
|
assertEquals( src.sorted(), result )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
So `binarySearch(x)` returns:
|
||||||
|
|
||||||
|
- index of `x`, a non-negative number
|
||||||
|
- negative: `x` not found, but if inserted at position `-returnedValue-1` will leave array sorted.
|
||||||
|
|
||||||
|
To pre-sort and array use `Iterable.sorted*` or in-place `List.sort*` families, see [List] and [Iterable] docs.
|
||||||
|
|
||||||
|
[Collection]: Collection.md
|
||||||
|
[Iterable]: Iterable.md
|
||||||
|
[List]: List.md
|
||||||
+6
-2
@@ -121,7 +121,7 @@ which is used in `toString`) and hex encoding:
|
|||||||
## Members
|
## Members
|
||||||
|
|
||||||
| name | meaning | type |
|
| name | meaning | type |
|
||||||
|---------------------------|-----------------------------------|---------------|
|
|----------------------------|-----------------------------------------|---------------|
|
||||||
| `size` | size | Int |
|
| `size` | size | Int |
|
||||||
| `decodeUtf8` | decode to String using UTF8 rules | Any |
|
| `decodeUtf8` | decode to String using UTF8 rules | Any |
|
||||||
| `+` | buffer concatenation | Any |
|
| `+` | buffer concatenation | Any |
|
||||||
@@ -129,7 +129,8 @@ which is used in `toString`) and hex encoding:
|
|||||||
| `hex` | encode to hex strign | String |
|
| `hex` | encode to hex strign | String |
|
||||||
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
|
| `Buffer.decodeHex(hexStr) | decode hex string | Buffer |
|
||||||
| `base64` | encode to base64 (url flavor) (2) | String |
|
| `base64` | encode to base64 (url flavor) (2) | String |
|
||||||
| `Buffer.decodeBase64` | decode base64 to new Buffer (2) | Buffer |
|
| `Buffer.decodeBase64(str)` | decode base64 to new Buffer (2) | Buffer |
|
||||||
|
| `toBitInput()` | create bit input from a byte buffer (3) | |
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: optimized implementation that override `Iterable` one
|
: optimized implementation that override `Iterable` one
|
||||||
@@ -139,6 +140,9 @@ which is used in `toString`) and hex encoding:
|
|||||||
decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
|
decoding supports both traditional and URL alphabets automatically, and ignores filling `=` characters. Base64URL is
|
||||||
well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
|
well known and mentioned in the internet, for example, [here](https://base64.guru/standards/base64url).
|
||||||
|
|
||||||
|
(3)
|
||||||
|
: `BitInput` is a bit buffer that is used, for example, in [Lynon.decode](serialization.md)
|
||||||
|
|
||||||
Also, it inherits methods from [Iterable] and [Array].
|
Also, it inherits methods from [Iterable] and [Array].
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -6,6 +6,12 @@ Is a [Iterable] with known `size`, a finite [Iterable]:
|
|||||||
val size
|
val size
|
||||||
}
|
}
|
||||||
|
|
||||||
|
| name | description |
|
||||||
|
|------------------------|------------------------------------------------------|
|
||||||
|
|
||||||
|
(1)
|
||||||
|
: `comparator(a,b)` should return -1 if `a < b`, +1 if `a > b` or zero.
|
||||||
|
|
||||||
See [List], [Set] and [Iterable]
|
See [List], [Set] and [Iterable]
|
||||||
|
|
||||||
[Iterable]: Iterable.md
|
[Iterable]: Iterable.md
|
||||||
|
|||||||
+40
-7
@@ -1,9 +1,13 @@
|
|||||||
# Iterable interface
|
# Iterable interface
|
||||||
|
|
||||||
The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`, `Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
|
The interface for anything that can be iterated, e.g. finite or infinite ordered set of data that can be accessed
|
||||||
|
sequentially. Almost any data container in `Lyng` implements it: `List`, `Set`, `Buffer`, `RingBuffer`, `BitBuffer`,
|
||||||
|
`Range` and many others are `Iterable`, also `Collection` and `Array` interfaces inherit it.
|
||||||
|
|
||||||
`Map` and `String` have `Iterable` members to access its contents too.
|
`Map` and `String` have `Iterable` members to access its contents too.
|
||||||
|
|
||||||
|
Please see also [Collection] interface: many iterables are also collections, and it adds important features.
|
||||||
|
|
||||||
## Definition:
|
## Definition:
|
||||||
|
|
||||||
Iterable is a class that provides function that creates _the iterator_:
|
Iterable is a class that provides function that creates _the iterator_:
|
||||||
@@ -23,7 +27,8 @@ Iterator itself is a simple interface that should provide only to method:
|
|||||||
|
|
||||||
Just remember at this stage typed declarations are not yet supported.
|
Just remember at this stage typed declarations are not yet supported.
|
||||||
|
|
||||||
Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions available, for example
|
Having `Iterable` in base classes allows to use it in for loop. Also, each `Iterable` has some utility functions
|
||||||
|
available, for example
|
||||||
|
|
||||||
val r = 1..10 // Range is Iterable!
|
val r = 1..10 // Range is Iterable!
|
||||||
assertEquals( [9,10], r.takeLast(2).toList() )
|
assertEquals( [9,10], r.takeLast(2).toList() )
|
||||||
@@ -34,7 +39,8 @@ Having `Iterable` in base classes allows to use it in for loop. Also, each `Iter
|
|||||||
|
|
||||||
## joinToString
|
## joinToString
|
||||||
|
|
||||||
This methods convert any iterable to a string joining string representation of each element, optionally transforming it and joining using specified suffix.
|
This methods convert any iterable to a string joining string representation of each element, optionally transforming it
|
||||||
|
and joining using specified suffix.
|
||||||
|
|
||||||
Iterable.joinToString(suffux=' ', transform=null)
|
Iterable.joinToString(suffux=' ', transform=null)
|
||||||
|
|
||||||
@@ -49,11 +55,23 @@ Here is the sample:
|
|||||||
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## `sum` and `sumBy`
|
||||||
|
|
||||||
|
These, again, does the thing:
|
||||||
|
|
||||||
|
assertEquals( 6, [1,2,3].sum() )
|
||||||
|
assertEquals( 12, [1,2,3].sumOf { it*2 } )
|
||||||
|
|
||||||
|
// sum of empty collections is null:
|
||||||
|
assertEquals( null, [].sum() )
|
||||||
|
assertEquals( null, [].sumOf { 2*it } )
|
||||||
|
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Instance methods:
|
## Instance methods:
|
||||||
|
|
||||||
|
|
||||||
| fun/method | description |
|
| fun/method | description |
|
||||||
|-------------------|---------------------------------------------------------------------------|
|
|------------------------|---------------------------------------------------------------------------------|
|
||||||
| toList() | create a list from iterable |
|
| toList() | create a list from iterable |
|
||||||
| toSet() | create a set from iterable |
|
| toSet() | create a set from iterable |
|
||||||
| contains(i) | check that iterable contains `i` |
|
| contains(i) | check that iterable contains `i` |
|
||||||
@@ -70,13 +88,24 @@ Here is the sample:
|
|||||||
| taleLast(n) | return [Iterable] of up to n last elements |
|
| taleLast(n) | return [Iterable] of up to n last elements |
|
||||||
| drop(n) | return new [Iterable] without first n elements |
|
| drop(n) | return new [Iterable] without first n elements |
|
||||||
| dropLast(n) | return new [Iterable] without last n elements |
|
| dropLast(n) | return new [Iterable] without last n elements |
|
||||||
|
| sum() | return sum of the collection applying `+` to its elements (3) |
|
||||||
|
| sumOf(predicate) | sum of the modified collection items (3) |
|
||||||
|
| sorted() | return [List] with collection items sorted naturally |
|
||||||
|
| sortedWith(comparator) | sort using a comparator that compares elements (1) |
|
||||||
|
| sortedBy(predicate) | sort by comparing results of the predicate function |
|
||||||
| joinToString(s,t) | convert iterable to string, see (2) |
|
| joinToString(s,t) | convert iterable to string, see (2) |
|
||||||
|
| reversed() | create a list containing items from this in reverse order |
|
||||||
|
| shuffled() | create a listof shiffled elements |
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: throws `NoSuchElementException` if there is no such element
|
: throws `NoSuchElementException` if there is no such element
|
||||||
|
|
||||||
(2)
|
(2)
|
||||||
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
|
: `joinToString(suffix=" ",transform=null)`: suffix is inserted between items if there are more than one, trasnfom is
|
||||||
|
optional function applied to each item that must return result string for an item, otherwise `item.toString()` is used.
|
||||||
|
|
||||||
|
(3)
|
||||||
|
: sum of empty collection is `null`
|
||||||
|
|
||||||
fun Iterable.toList(): List
|
fun Iterable.toList(): List
|
||||||
fun Iterable.toSet(): Set
|
fun Iterable.toSet(): Set
|
||||||
@@ -87,7 +116,6 @@ Here is the sample:
|
|||||||
fun Iterable.map(block: (Any?)->Void ): List
|
fun Iterable.map(block: (Any?)->Void ): List
|
||||||
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
|
fun Iterable.associateBy( keyMaker: (Any?)->Any): Map
|
||||||
|
|
||||||
|
|
||||||
## Abstract methods:
|
## Abstract methods:
|
||||||
|
|
||||||
fun iterator(): Iterator
|
fun iterator(): Iterator
|
||||||
@@ -102,7 +130,12 @@ Creates a list by iterating to the end. So, the Iterator should be finite to be
|
|||||||
|
|
||||||
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
|
- [List], [Range], [Buffer](Buffer.md), [BitBuffer], [Buffer], [Set], [RingBuffer]
|
||||||
|
|
||||||
|
[Collection]: Collection.md
|
||||||
|
|
||||||
[List]: List.md
|
[List]: List.md
|
||||||
|
|
||||||
[Range]: Range.md
|
[Range]: Range.md
|
||||||
|
|
||||||
[Set]: Set.md
|
[Set]: Set.md
|
||||||
|
|
||||||
[RingBuffer]: RingBuffer.md
|
[RingBuffer]: RingBuffer.md
|
||||||
+36
-3
@@ -92,10 +92,29 @@ Open end ranges remove head and tail elements:
|
|||||||
assert( [1, 2, 3] !== [1, 2, 3])
|
assert( [1, 2, 3] !== [1, 2, 3])
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## In-place sort
|
||||||
|
|
||||||
|
List could be sorted in place, just like [Collection] provide sorted copies, in a very like way:
|
||||||
|
|
||||||
|
val l1 = [6,3,1,9]
|
||||||
|
l1.sort()
|
||||||
|
assertEquals( [1,3,6,9], l1)
|
||||||
|
|
||||||
|
l1.sortBy { -it }
|
||||||
|
assertEquals( [1,3,6,9].reversed(), l1)
|
||||||
|
|
||||||
|
l1.sort() // 1 3 6 9
|
||||||
|
l1.sortBy { it % 4 }
|
||||||
|
// 1,3,6,9 gives, mod 4:
|
||||||
|
// 1 3 2 1
|
||||||
|
// we hope we got it also stable:
|
||||||
|
assertEquals( [1,9,6,3], l1)
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Members
|
## Members
|
||||||
|
|
||||||
| name | meaning | type |
|
| name | meaning | type |
|
||||||
|-------------------------------|---------------------------------------|-------------|
|
|-------------------------------|----------------------------------------------|-------------|
|
||||||
| `size` | current size | Int |
|
| `size` | current size | Int |
|
||||||
| `add(elements...)` | add one or more elements to the end | Any |
|
| `add(elements...)` | add one or more elements to the end | Any |
|
||||||
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
|
| `insertAt(index,elements...)` | insert elements at position | Int, Any |
|
||||||
@@ -107,7 +126,11 @@ Open end ranges remove head and tail elements:
|
|||||||
| `contains(element)` | check the element is in the list (1) | |
|
| `contains(element)` | check the element is in the list (1) | |
|
||||||
| `[index]` | get or set element at index | Int |
|
| `[index]` | get or set element at index | Int |
|
||||||
| `[Range]` | get slice of the array (copy) | Range |
|
| `[Range]` | get slice of the array (copy) | Range |
|
||||||
| `+=` | append element(s) | List or Obj |
|
| `+=` | append element(s) (2) | List or Obj |
|
||||||
|
| `sort()` | in-place sort, natural order | void |
|
||||||
|
| `sortBy(predicate)` | in-place sort bu `predicate` call result (3) | void |
|
||||||
|
| `sortWith(comparator)` | in-place sort using `comarator` function (4) | void |
|
||||||
|
| `shiffle()` | in-place shiffle contents | |
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: optimized implementation that override `Array` one
|
: optimized implementation that override `Array` one
|
||||||
@@ -116,7 +139,16 @@ Open end ranges remove head and tail elements:
|
|||||||
: `+=` append either a single element, or all elements if the List or other Iterable
|
: `+=` append either a single element, or all elements if the List or other Iterable
|
||||||
instance is appended. If you want to append an Iterable object itself, use `add` instead.
|
instance is appended. If you want to append an Iterable object itself, use `add` instead.
|
||||||
|
|
||||||
It inherits from [Iterable] too.
|
(3)
|
||||||
|
: predicate is called on each element, and the returned values are used to sort in natural
|
||||||
|
order, e.g. is same as `list.sortWith { a,b -> predicate(a) <=> predicate(b) }`
|
||||||
|
|
||||||
|
(4)
|
||||||
|
: comparator callable takes tho arguments and must return: negative value when first is less,
|
||||||
|
positive if first is greater, and zero if they are equal. For example, the equvalent comparator
|
||||||
|
for `sort()` will be `sort { a, b -> a <=> b }
|
||||||
|
|
||||||
|
It inherits from [Iterable] too and thus all iterable methods are applicable to any list.
|
||||||
|
|
||||||
## Member inherited from Array
|
## Member inherited from Array
|
||||||
|
|
||||||
@@ -134,4 +166,5 @@ It inherits from [Iterable] too.
|
|||||||
|
|
||||||
|
|
||||||
[Range]: Range.md
|
[Range]: Range.md
|
||||||
|
|
||||||
[Iterable]: Iterable.md
|
[Iterable]: Iterable.md
|
||||||
+1
-1
@@ -87,7 +87,7 @@ You can use Char as both ends of the closed range:
|
|||||||
Exclusive end char ranges are supported too:
|
Exclusive end char ranges are supported too:
|
||||||
|
|
||||||
('a'..<'c').toList
|
('a'..<'c').toList
|
||||||
>>> ['a', 'b']
|
>>> [a,b]
|
||||||
|
|
||||||
|
|
||||||
# Instance members
|
# Instance members
|
||||||
|
|||||||
@@ -0,0 +1,91 @@
|
|||||||
|
# Regular expressions
|
||||||
|
|
||||||
|
In lyng, you create regular expressions using class `Regex` or `String.re` methods:
|
||||||
|
|
||||||
|
assert( "\d*".re is Regex )
|
||||||
|
assert( Regex("\d*") is Regex )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
We plan to add slash syntax at some point.
|
||||||
|
|
||||||
|
To check that some string matches as whole to some regex:
|
||||||
|
|
||||||
|
assert( "123".matches("\d{3}".re) )
|
||||||
|
assert( !"123".matches("\d{4}".re) )
|
||||||
|
assert( !"1234".matches("\d".re) )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
To check that _part of the string_ matches some regular expession, use _match operator_ `=~` just like in Ruby, and its
|
||||||
|
counterpart, _not match_ operator `!~`:
|
||||||
|
|
||||||
|
assert( "abc123def" =~ "\d\d\d".re )
|
||||||
|
assert( "abc" !~ "\d\d\d".re )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
When you need to find groups, and more detailed match information, use `Regex.find`:
|
||||||
|
|
||||||
|
val result = Regex("abc(\d)(\d)(\d)").find( "bad456 good abc123")
|
||||||
|
assert( result != null )
|
||||||
|
assertEquals( 12 .. 17, result.range )
|
||||||
|
assertEquals( "abc123", result[0] )
|
||||||
|
assertEquals( "1", result[1] )
|
||||||
|
assertEquals( "2", result[2] )
|
||||||
|
assertEquals( "3", result[3] )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Note that the object `RegexMatch`, returned by [Regex.find], behaves much like in many other languages: it provides the
|
||||||
|
index range and groups matches as indexes.
|
||||||
|
|
||||||
|
Match operator actually also provides `RegexMatch` in `$~` reserved variable (borrowed from Ruby too):
|
||||||
|
|
||||||
|
assert( "bad456 good abc123" =~ "abc(\d)(\d)(\d)".re )
|
||||||
|
assertEquals( 12 .. 17, $~.range )
|
||||||
|
assertEquals( "abc123", $~[0] )
|
||||||
|
assertEquals( "1", $~[1] )
|
||||||
|
assertEquals( "2", $~[2] )
|
||||||
|
assertEquals( "3", $~[3] )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
This is often more readable than calling `find`.
|
||||||
|
|
||||||
|
Note that `=~` and `!~` operators against strings and regular expressions are commutative, e.g. regular expression and a
|
||||||
|
string can be either left or right operator, but not both:
|
||||||
|
|
||||||
|
assert( "abc" =~ "\wc".re )
|
||||||
|
assert( "abc" !~ "\w1c".re )
|
||||||
|
assert( "a\wc".re =~ "abcd" )
|
||||||
|
assert( "a[a-z]c".re !~ "a2cd" )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Also, string indexing is Regex-aware, and works like `Regex.find` (_not findall!_):
|
||||||
|
|
||||||
|
assert( "cd" == "abcdef"[ "c.".re ].value )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
|
# Regex class reference
|
||||||
|
|
||||||
|
| name | description | notes |
|
||||||
|
|--------------|-------------------------------------|-------|
|
||||||
|
| matches(str) | true if the whole `str` matches | |
|
||||||
|
| find(str) | find first match in `str` or null | (1) |
|
||||||
|
| findAll(str) | find all matches in `str` as [List] | (1) |
|
||||||
|
|
||||||
|
(1)
|
||||||
|
:: See `RegexMatch` class description below
|
||||||
|
|
||||||
|
# RegexMatch
|
||||||
|
|
||||||
|
| name | description | notes |
|
||||||
|
|-------|-------------------------------------------|-------|
|
||||||
|
| range | the [Range] of the match in source string | |
|
||||||
|
| value | the value that matches | |
|
||||||
|
| [n] | [List] of group matches | (1) |
|
||||||
|
|
||||||
|
(1)
|
||||||
|
:: the [0] element is always value, [1] is group 1 match of any, etc.
|
||||||
|
|
||||||
|
[List]: List.md
|
||||||
|
|
||||||
|
[Range]: Range.md
|
||||||
|
|
||||||
@@ -83,7 +83,7 @@ or whatever implementing [Iterable], is called _splats_. Here is how we use it:
|
|||||||
}
|
}
|
||||||
val array = [1,2,3]
|
val array = [1,2,3]
|
||||||
testSplat("start", ...array, "end")
|
testSplat("start", ...array, "end")
|
||||||
>>> ["start", 1, 2, 3, "end"]
|
>>> [start,1,2,3,end]
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
There could be any number of splats at any positions. You can splat any other [Iterable] type:
|
There could be any number of splats at any positions. You can splat any other [Iterable] type:
|
||||||
@@ -93,7 +93,7 @@ There could be any number of splats at any positions. You can splat any other [I
|
|||||||
}
|
}
|
||||||
val range = 1..3
|
val range = 1..3
|
||||||
testSplat("start", ...range, "end")
|
testSplat("start", ...range, "end")
|
||||||
>>> ["start", 1, 2, 3, "end"]
|
>>> [start,1,2,3,end]
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -122,6 +122,32 @@ This way, in turn, can also be shortened, as it is overly popular:
|
|||||||
The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
|
The trick, though, works with strings only, and always provide `Exception` instances, which is good for debugging but
|
||||||
most often not enough.
|
most often not enough.
|
||||||
|
|
||||||
|
# Exception class
|
||||||
|
|
||||||
|
Serializable class that conveys information about the exception. Important members and methods are:
|
||||||
|
|
||||||
|
| name | description |
|
||||||
|
|-------------------|--------------------------------------------------------|
|
||||||
|
| message | String message |
|
||||||
|
| stackTrace | lyng stack trace, list of `StackTraceEntry`, see below |
|
||||||
|
| printStackTrace() | format and print stack trace using println() |
|
||||||
|
|
||||||
|
## StackTraceEntry
|
||||||
|
|
||||||
|
A simple structire that stores single entry in Lyng stack, it is created automatically on exception creation:
|
||||||
|
|
||||||
|
```kotlin
|
||||||
|
class StackTraceEntry(
|
||||||
|
val sourceName: String,
|
||||||
|
val line: Int,
|
||||||
|
val column: Int,
|
||||||
|
val sourceString: String
|
||||||
|
)
|
||||||
|
```
|
||||||
|
|
||||||
|
- `sourceString` is a line extracted from sources. Note that it _is serialized and printed_, so if you want to conceal it, catch all exceptions and filter out sensitive information.
|
||||||
|
|
||||||
|
|
||||||
# Custom error classes
|
# Custom error classes
|
||||||
|
|
||||||
_this functionality is not yet released_
|
_this functionality is not yet released_
|
||||||
|
|||||||
+2
-2
@@ -183,8 +183,8 @@ Important difference from the channels or like, every time you collect the flow,
|
|||||||
// and again:
|
// and again:
|
||||||
assertEquals( result, f.toList() )
|
assertEquals( result, f.toList() )
|
||||||
|
|
||||||
>>> ["start", 1, 2, 3, 4]
|
>>> [start,1,2,3,4]
|
||||||
>>> ["start", 1, 2, 3, 4]
|
>>> [start,1,2,3,4]
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
Notice that flow's lambda is not called until actual collection is started. Cold flows are
|
Notice that flow's lambda is not called until actual collection is started. Cold flows are
|
||||||
|
|||||||
@@ -16,9 +16,15 @@ fun naiveCountHappyNumbers() {
|
|||||||
count
|
count
|
||||||
}
|
}
|
||||||
|
|
||||||
|
import lyng.time
|
||||||
|
|
||||||
//
|
//
|
||||||
// After all optimizations it takes ~120ms.
|
// After all optimizations it takes ~120ms.
|
||||||
//
|
//
|
||||||
|
//for( r in 1..100 ) {
|
||||||
|
// val start = Instant.now()
|
||||||
val found = naiveCountHappyNumbers()
|
val found = naiveCountHappyNumbers()
|
||||||
println("Found happy numbers: "+found)
|
// println("Found happy numbers: %d time %s"(found, Instant.now() - start))
|
||||||
assert( found == 55252 )
|
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)
|
||||||
+90
-11
@@ -16,7 +16,8 @@ __Other documents to read__ maybe after this one:
|
|||||||
- [math in Lyng](math.md)
|
- [math in Lyng](math.md)
|
||||||
- [time](time.md) and [parallelism](parallelism.md)
|
- [time](time.md) and [parallelism](parallelism.md)
|
||||||
- [parallelism] - multithreaded code, coroutines, etc.
|
- [parallelism] - multithreaded code, coroutines, etc.
|
||||||
- Some class references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [RingBuffer], [Buffer].
|
- Some class
|
||||||
|
references: [List], [Set], [Map], [Real], [Range], [Iterable], [Iterator], [time manipulation](time.md), [Array], [RingBuffer], [Buffer].
|
||||||
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
|
- Some samples: [combinatorics](samples/combinatorics.lyng.md), national vars and
|
||||||
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
|
loops: [сумма ряда](samples/сумма_ряда.lyng.md). More at [samples folder](samples)
|
||||||
|
|
||||||
@@ -225,6 +226,19 @@ It works much like `also`, but is executed in the context of the source object:
|
|||||||
assertEquals(p, Point(2,3))
|
assertEquals(p, Point(2,3))
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
## run
|
||||||
|
|
||||||
|
Executes a block after it returning the value passed by the block. for example, can be used with elvis operator:
|
||||||
|
|
||||||
|
var someVar = null
|
||||||
|
val result = someVar ?: run {
|
||||||
|
someVar = 121
|
||||||
|
"reset"
|
||||||
|
}
|
||||||
|
assertEquals("reset", result)
|
||||||
|
assertEquals(121, someVar)
|
||||||
|
>>> void
|
||||||
|
|
||||||
## Math
|
## Math
|
||||||
|
|
||||||
It is rather simple, like everywhere else:
|
It is rather simple, like everywhere else:
|
||||||
@@ -261,6 +275,8 @@ Logical operation could be used the same
|
|||||||
| === | | Any | (2) |
|
| === | | Any | (2) |
|
||||||
| !== | | Any | (2) |
|
| !== | | Any | (2) |
|
||||||
| != | | Any | (1) |
|
| != | | Any | (1) |
|
||||||
|
| =~ | | | (3) |
|
||||||
|
| !~ | | | (3) |
|
||||||
| ++a, a++ | | Int | |
|
| ++a, a++ | | Int | |
|
||||||
| --a, a-- | | Int | |
|
| --a, a-- | | Int | |
|
||||||
|
|
||||||
@@ -272,6 +288,9 @@ Logical operation could be used the same
|
|||||||
singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
|
singleton object, like `null`, are referentially equal too, while string different literals even being equal are most
|
||||||
likely referentially not equal
|
likely referentially not equal
|
||||||
|
|
||||||
|
(3)
|
||||||
|
: Implemented now in String and Regex as regular expression match and not match, see [Regex].
|
||||||
|
|
||||||
Reference quality and object equality example:
|
Reference quality and object equality example:
|
||||||
|
|
||||||
assert( null == null) // singletons
|
assert( null == null) // singletons
|
||||||
@@ -475,7 +494,8 @@ Lyng has built-in mutable array class `List` with simple literals:
|
|||||||
[1, "two", 3.33].size
|
[1, "two", 3.33].size
|
||||||
>>> 3
|
>>> 3
|
||||||
|
|
||||||
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable], many collection based methods are implemented there.
|
[List] is an implementation of the type `Array`, and through it `Collection` and [Iterable]. Please read [Iterable],
|
||||||
|
many collection based methods are implemented there.
|
||||||
|
|
||||||
Lists can contain any type of objects, lists too:
|
Lists can contain any type of objects, lists too:
|
||||||
|
|
||||||
@@ -499,7 +519,7 @@ Of course, you can splat from anything that is List (or list-like, but it will b
|
|||||||
val a = ["one", "two"]
|
val a = ["one", "two"]
|
||||||
val b = [10.1, 20.2]
|
val b = [10.1, 20.2]
|
||||||
["start", ...b, ...a, "end"]
|
["start", ...b, ...a, "end"]
|
||||||
>>> ["start", 10.1, 20.2, "one", "two", "end"]
|
>>> [start,10.1,20.2,one,two,end]
|
||||||
|
|
||||||
Of course, you can set any list element:
|
Of course, you can set any list element:
|
||||||
|
|
||||||
@@ -750,8 +770,8 @@ thrown.
|
|||||||
Typical builtin types that are containers (e.g. support `contains`):
|
Typical builtin types that are containers (e.g. support `contains`):
|
||||||
|
|
||||||
| class | notes |
|
| class | notes |
|
||||||
|------------|------------------------------------------------|
|
|--------------|------------------------------------------------|
|
||||||
| Collection | contains an element (1) |
|
| [Collection] | contains an element (1) |
|
||||||
| Array | faster maybe that Collection's |
|
| Array | faster maybe that Collection's |
|
||||||
| List | faster than Array's |
|
| List | faster than Array's |
|
||||||
| String | character in string or substring in string (3) |
|
| String | character in string or substring in string (3) |
|
||||||
@@ -1124,7 +1144,8 @@ See [more docs on time manipulation](time.md)
|
|||||||
|
|
||||||
# Enums
|
# Enums
|
||||||
|
|
||||||
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their _ordinal_ - [Int] value.
|
For the moment, only simple enums are implemented. Enum is a list of constants, represented also by their
|
||||||
|
_ordinal_ - [Int] value.
|
||||||
|
|
||||||
enum Color {
|
enum Color {
|
||||||
RED, GREEN, BLUE
|
RED, GREEN, BLUE
|
||||||
@@ -1139,7 +1160,8 @@ For the moment, only simple enums are implemented. Enum is a list of constants,
|
|||||||
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact than enum arrays, until `Lynon.encodeTyped` will be implemented.
|
Enums are serialized as ordinals. Please note that due to caching, serialized string arrays could be even more compact
|
||||||
|
than enum arrays, until `Lynon.encodeTyped` will be implemented.
|
||||||
|
|
||||||
# Comments
|
# Comments
|
||||||
|
|
||||||
@@ -1167,6 +1189,30 @@ See also [math operations](math.md)
|
|||||||
|
|
||||||
The type for the character objects is `Char`.
|
The type for the character objects is `Char`.
|
||||||
|
|
||||||
|
### String literal escapes
|
||||||
|
|
||||||
|
| escape | ASCII value |
|
||||||
|
|--------|-----------------------|
|
||||||
|
| \n | 0x10, newline |
|
||||||
|
| \r | 0x13, carriage return |
|
||||||
|
| \t | 0x07, tabulation |
|
||||||
|
| \\ | \ slash character |
|
||||||
|
| \" | " double quote |
|
||||||
|
|
||||||
|
Other `\c` combinations, where c is any char except mentioned above, are left intact, e.g.:
|
||||||
|
|
||||||
|
val s = "\a"
|
||||||
|
assert(s[0] == '\')
|
||||||
|
assert(s[1] == 'a')
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
same as:
|
||||||
|
|
||||||
|
val s = "\\a"
|
||||||
|
assert(s[0] == '\')
|
||||||
|
assert(s[1] == 'a')
|
||||||
|
>>> void
|
||||||
|
|
||||||
### Char literal escapes
|
### Char literal escapes
|
||||||
|
|
||||||
Are the same as in string literals with little difference:
|
Are the same as in string literals with little difference:
|
||||||
@@ -1174,6 +1220,7 @@ Are the same as in string literals with little difference:
|
|||||||
| escape | ASCII value |
|
| escape | ASCII value |
|
||||||
|--------|-------------------|
|
|--------|-------------------|
|
||||||
| \n | 0x10, newline |
|
| \n | 0x10, newline |
|
||||||
|
| \r | 0x13, carriage return |
|
||||||
| \t | 0x07, tabulation |
|
| \t | 0x07, tabulation |
|
||||||
| \\ | \ slash character |
|
| \\ | \ slash character |
|
||||||
| \' | ' apostrophe |
|
| \' | ' apostrophe |
|
||||||
@@ -1243,9 +1290,26 @@ Open-ended ranges could be used to get start and end too:
|
|||||||
assertEquals( "pult", "catapult"[ 4.. ])
|
assertEquals( "pult", "catapult"[ 4.. ])
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
|
|
||||||
### String operations
|
### String operations
|
||||||
|
|
||||||
Concatenation is a `+`: `"hello " + name` works as expected. No confusion.
|
Concatenation is a `+`: `"hello " + name` works as expected. No confusion. There is also
|
||||||
|
[Regex] support for strings, see the link, for example, whole string match:
|
||||||
|
|
||||||
|
assert( !"123".matches( "\d\d".re ) )
|
||||||
|
assert( "123".matches( "\d\d\d".re ) )
|
||||||
|
>>> void
|
||||||
|
|
||||||
|
Extraction:
|
||||||
|
|
||||||
|
"abcd42def"[ "\d+".re ].value
|
||||||
|
>>> "42"
|
||||||
|
|
||||||
|
Part match:
|
||||||
|
|
||||||
|
assert( "abc foo def" =~ "f[oO]+".re )
|
||||||
|
assert( "foo" == $~.value )
|
||||||
|
>>> void
|
||||||
|
|
||||||
Typical set of String functions includes:
|
Typical set of String functions includes:
|
||||||
|
|
||||||
@@ -1253,6 +1317,7 @@ Typical set of String functions includes:
|
|||||||
|--------------------|------------------------------------------------------------|
|
|--------------------|------------------------------------------------------------|
|
||||||
| lower() | change case to unicode upper |
|
| lower() | change case to unicode upper |
|
||||||
| upper() | change case to unicode lower |
|
| upper() | change case to unicode lower |
|
||||||
|
| trim() | trim space chars from both ends |
|
||||||
| startsWith(prefix) | true if starts with a prefix |
|
| startsWith(prefix) | true if starts with a prefix |
|
||||||
| endsWith(prefix) | true if ends with a prefix |
|
| endsWith(prefix) | true if ends with a prefix |
|
||||||
| take(n) | get a new string from up to n first characters |
|
| take(n) | get a new string from up to n first characters |
|
||||||
@@ -1262,17 +1327,24 @@ Typical set of String functions includes:
|
|||||||
| size | size in characters like `length` because String is [Array] |
|
| size | size in characters like `length` because String is [Array] |
|
||||||
| (args...) | sprintf-like formatting, see [string formatting] |
|
| (args...) | sprintf-like formatting, see [string formatting] |
|
||||||
| [index] | character at index |
|
| [index] | character at index |
|
||||||
| [Range] | substring at range |
|
| [Range] | substring at range (2) |
|
||||||
|
| [Regex] | find first match of regex, like [Regex.find] (2) |
|
||||||
| s1 + s2 | concatenation |
|
| s1 + s2 | concatenation |
|
||||||
| s1 += s2 | self-modifying concatenation |
|
| s1 += s2 | self-modifying concatenation |
|
||||||
| toReal() | attempts to parse string as a Real value |
|
| toReal() | attempts to parse string as a Real value |
|
||||||
| toInt() | parse string to Int value |
|
| toInt() | parse string to Int value |
|
||||||
| characters() | create [List] of characters (1) |
|
| characters() | create [List] of characters (1) |
|
||||||
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
|
| encodeUtf8() | returns [Buffer] with characters encoded to utf8 |
|
||||||
|
| matches(re) | matches the regular expression (2) |
|
||||||
|
| | |
|
||||||
|
|
||||||
|
|
||||||
(1)
|
(1)
|
||||||
: List is mutable therefore a new copy is created on each call.
|
: List is mutable therefore a new copy is created on each call.
|
||||||
|
|
||||||
|
(2)
|
||||||
|
: See [Regex]
|
||||||
|
|
||||||
### Literals
|
### Literals
|
||||||
|
|
||||||
String literal could be multiline:
|
String literal could be multiline:
|
||||||
@@ -1292,7 +1364,8 @@ if blank, will be removed too, for example:
|
|||||||
>>> This is a second line.
|
>>> This is a second line.
|
||||||
>>> void
|
>>> void
|
||||||
|
|
||||||
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()` technique, but simpler ;)
|
- as expected, empty lines and common indent were removed. It is much like kotlin's `""" ... """.trimIndent()`
|
||||||
|
technique, but simpler ;)
|
||||||
|
|
||||||
# Built-in functions
|
# Built-in functions
|
||||||
|
|
||||||
@@ -1311,7 +1384,7 @@ See [math functions](math.md). Other general purpose functions are:
|
|||||||
| flow {} | create flow sequence, see [parallelism] |
|
| flow {} | create flow sequence, see [parallelism] |
|
||||||
| delay, launch, yield | see [parallelism] |
|
| delay, launch, yield | see [parallelism] |
|
||||||
| cached(builder) | remembers builder() on first invocation and return it then |
|
| cached(builder) | remembers builder() on first invocation and return it then |
|
||||||
|
| let, also, apply, run | see above, flow controls |
|
||||||
|
|
||||||
# Built-in constants
|
# Built-in constants
|
||||||
|
|
||||||
@@ -1343,3 +1416,9 @@ See [math functions](math.md). Other general purpose functions are:
|
|||||||
[parallelism]: parallelism.md
|
[parallelism]: parallelism.md
|
||||||
|
|
||||||
[RingBuffer]: RingBuffer.md
|
[RingBuffer]: RingBuffer.md
|
||||||
|
|
||||||
|
[Collection]: Collection.md
|
||||||
|
|
||||||
|
[Array]: Array.md
|
||||||
|
|
||||||
|
[Regex]: Regex.md
|
||||||
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
|
|||||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||||
|
|
||||||
group = "net.sergeych"
|
group = "net.sergeych"
|
||||||
version = "0.8.12-SNAPSHOT"
|
version = "0.9.0-SNAPSHOT"
|
||||||
|
|
||||||
buildscript {
|
buildscript {
|
||||||
repositories {
|
repositories {
|
||||||
@@ -138,6 +138,7 @@ publishing {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
//mavenPublishing {
|
//mavenPublishing {
|
||||||
// publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
|
// publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
|
||||||
//
|
//
|
||||||
|
|||||||
@@ -63,7 +63,7 @@ data class Arguments(val list: List<Obj>, val tailBlockMode: Boolean = false) :
|
|||||||
return list.map { it.toKotlin(scope) }
|
return list.map { it.toKotlin(scope) }
|
||||||
}
|
}
|
||||||
|
|
||||||
fun inspect(): String = list.joinToString(", ") { it.inspect() }
|
suspend fun inspect(scope: Scope): String = list.map{ it.inspect(scope)}.joinToString(",")
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
val EMPTY = Arguments(emptyList())
|
val EMPTY = Arguments(emptyList())
|
||||||
|
|||||||
@@ -211,11 +211,32 @@ class Compiler(
|
|||||||
private suspend fun parseTerm(): Accessor? {
|
private suspend fun parseTerm(): Accessor? {
|
||||||
var operand: Accessor? = null
|
var operand: Accessor? = null
|
||||||
|
|
||||||
|
// newlines _before_
|
||||||
|
cc.skipWsTokens()
|
||||||
|
|
||||||
while (true) {
|
while (true) {
|
||||||
val t = cc.next()
|
val t = cc.next()
|
||||||
val startPos = t.pos
|
val startPos = t.pos
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
Token.Type.NEWLINE, Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
|
// Token.Type.NEWLINE, Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT-> {
|
||||||
|
// continue
|
||||||
|
// }
|
||||||
|
|
||||||
|
// very special case chained calls: call()<NL>.call2 {}.call3()
|
||||||
|
Token.Type.NEWLINE -> {
|
||||||
|
val saved = cc.savePos()
|
||||||
|
if (cc.peekNextNonWhitespace().type == Token.Type.DOT) {
|
||||||
|
// chained call continue from it
|
||||||
|
continue
|
||||||
|
} else {
|
||||||
|
// restore position and stop parsing as a term:
|
||||||
|
cc.restorePos(saved)
|
||||||
|
cc.previous()
|
||||||
|
return operand
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
|
||||||
cc.previous()
|
cc.previous()
|
||||||
return operand
|
return operand
|
||||||
}
|
}
|
||||||
@@ -376,6 +397,13 @@ class Compiler(
|
|||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
"throw" -> {
|
||||||
|
val s = parseThrowStatement()
|
||||||
|
operand = Accessor {
|
||||||
|
s.execute(it).asReadonly
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
else -> operand?.let { left ->
|
else -> operand?.let { left ->
|
||||||
// selector: <lvalue>, '.' , <id>
|
// selector: <lvalue>, '.' , <id>
|
||||||
// we replace operand with selector code, that
|
// we replace operand with selector code, that
|
||||||
@@ -461,7 +489,14 @@ class Compiler(
|
|||||||
// range operator
|
// range operator
|
||||||
val isEndInclusive = t.type == Token.Type.DOTDOT
|
val isEndInclusive = t.type == Token.Type.DOTDOT
|
||||||
val left = operand
|
val left = operand
|
||||||
val right = parseExpression()
|
// if it is an open end range, then the end of line could be here that we do not want
|
||||||
|
// to skip in parseExpression:
|
||||||
|
val current = cc.current()
|
||||||
|
val right =
|
||||||
|
if (current.type == Token.Type.NEWLINE || current.type == Token.Type.SINLGE_LINE_COMMENT)
|
||||||
|
null
|
||||||
|
else
|
||||||
|
parseExpression()
|
||||||
operand = Accessor {
|
operand = Accessor {
|
||||||
ObjRange(
|
ObjRange(
|
||||||
left?.getter?.invoke(it)?.value ?: ObjNull,
|
left?.getter?.invoke(it)?.value ?: ObjNull,
|
||||||
@@ -588,6 +623,8 @@ class Compiler(
|
|||||||
var endTokenType: Token.Type? = null
|
var endTokenType: Token.Type? = null
|
||||||
val startPos = cc.savePos()
|
val startPos = cc.savePos()
|
||||||
|
|
||||||
|
cc.skipWsTokens()
|
||||||
|
|
||||||
while (endTokenType == null) {
|
while (endTokenType == null) {
|
||||||
var t = cc.next()
|
var t = cc.next()
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
@@ -645,7 +682,7 @@ class Compiler(
|
|||||||
|
|
||||||
// important: valid argument list continues with ',' and ends with '->' or ')'
|
// important: valid argument list continues with ',' and ends with '->' or ')'
|
||||||
// otherwise it is not an argument list:
|
// otherwise it is not an argument list:
|
||||||
when (val tt = cc.next().type) {
|
when (val tt = cc.nextNonWhitespace().type) {
|
||||||
Token.Type.RPAREN -> {
|
Token.Type.RPAREN -> {
|
||||||
// end of arguments
|
// end of arguments
|
||||||
endTokenType = tt
|
endTokenType = tt
|
||||||
@@ -857,7 +894,7 @@ class Compiler(
|
|||||||
|
|
||||||
suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
|
suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
|
||||||
val extraArgs = parseArgsOrNull()
|
val extraArgs = parseArgsOrNull()
|
||||||
println("annotation ${t.value}: args: $extraArgs")
|
// println("annotation ${t.value}: args: $extraArgs")
|
||||||
return { scope, name, body ->
|
return { scope, name, body ->
|
||||||
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
|
val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
|
||||||
val required = listOf(name, body)
|
val required = listOf(name, body)
|
||||||
@@ -948,7 +985,7 @@ class Compiler(
|
|||||||
|
|
||||||
private suspend fun parseWhenStatement(): Statement {
|
private suspend fun parseWhenStatement(): Statement {
|
||||||
// has a value, when(value) ?
|
// has a value, when(value) ?
|
||||||
var t = cc.skipWsTokens()
|
var t = cc.nextNonWhitespace()
|
||||||
return if (t.type == Token.Type.LPAREN) {
|
return if (t.type == Token.Type.LPAREN) {
|
||||||
// when(value)
|
// when(value)
|
||||||
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
|
val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
|
||||||
@@ -963,6 +1000,7 @@ class Compiler(
|
|||||||
// condition could be a value, in and is clauses:
|
// condition could be a value, in and is clauses:
|
||||||
// parse several conditions for one then clause
|
// parse several conditions for one then clause
|
||||||
|
|
||||||
|
|
||||||
// loop cases
|
// loop cases
|
||||||
outer@ while (true) {
|
outer@ while (true) {
|
||||||
|
|
||||||
@@ -971,7 +1009,7 @@ class Compiler(
|
|||||||
|
|
||||||
// loop conditions
|
// loop conditions
|
||||||
while (true) {
|
while (true) {
|
||||||
t = cc.skipWsTokens()
|
t = cc.nextNonWhitespace()
|
||||||
|
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
Token.Type.IN,
|
Token.Type.IN,
|
||||||
@@ -1184,11 +1222,11 @@ class Compiler(
|
|||||||
cc.skipTokenOfType(Token.Type.LBRACE)
|
cc.skipTokenOfType(Token.Type.LBRACE)
|
||||||
|
|
||||||
do {
|
do {
|
||||||
val t = cc.skipWsTokens()
|
val t = cc.nextNonWhitespace()
|
||||||
when (t.type) {
|
when (t.type) {
|
||||||
Token.Type.ID -> {
|
Token.Type.ID -> {
|
||||||
names += t.value
|
names += t.value
|
||||||
val t1 = cc.skipWsTokens()
|
val t1 = cc.nextNonWhitespace()
|
||||||
when (t1.type) {
|
when (t1.type) {
|
||||||
Token.Type.COMMA ->
|
Token.Type.COMMA ->
|
||||||
continue
|
continue
|
||||||
@@ -1327,8 +1365,8 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
return statement(body.pos) { ctx ->
|
return statement(body.pos) { cxt ->
|
||||||
val forContext = ctx.copy(start)
|
val forContext = cxt.copy(start)
|
||||||
|
|
||||||
// loop var: StoredObject
|
// loop var: StoredObject
|
||||||
val loopSO = forContext.addItem(tVar.value, true, ObjNull)
|
val loopSO = forContext.addItem(tVar.value, true, ObjNull)
|
||||||
@@ -1339,15 +1377,28 @@ class Compiler(
|
|||||||
if (sourceObj is ObjRange && sourceObj.isIntRange) {
|
if (sourceObj is ObjRange && sourceObj.isIntRange) {
|
||||||
loopIntRange(
|
loopIntRange(
|
||||||
forContext,
|
forContext,
|
||||||
sourceObj.start!!.toInt(),
|
sourceObj.start!!.toLong(),
|
||||||
if (sourceObj.isEndInclusive) sourceObj.end!!.toInt() + 1 else sourceObj.end!!.toInt(),
|
if (sourceObj.isEndInclusive)
|
||||||
loopSO, body, elseStatement, label, canBreak
|
sourceObj.end!!.toLong() + 1
|
||||||
|
else
|
||||||
|
sourceObj.end!!.toLong(),
|
||||||
|
loopSO,
|
||||||
|
body,
|
||||||
|
elseStatement,
|
||||||
|
label,
|
||||||
|
canBreak
|
||||||
)
|
)
|
||||||
} else if (sourceObj.isInstanceOf(ObjIterable)) {
|
} else if (sourceObj.isInstanceOf(ObjIterable)) {
|
||||||
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
|
loopIterable(forContext, sourceObj, loopSO, body, elseStatement, label, canBreak)
|
||||||
} else {
|
} else {
|
||||||
val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() }
|
val size = runCatching { sourceObj.invokeInstanceMethod(forContext, "size").toInt() }
|
||||||
.getOrElse { throw ScriptError(tOp.pos, "object is not enumerable: no size", it) }
|
.getOrElse {
|
||||||
|
throw ScriptError(
|
||||||
|
tOp.pos,
|
||||||
|
"object is not enumerable: no size in $sourceObj",
|
||||||
|
it
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
var result: Obj = ObjVoid
|
var result: Obj = ObjVoid
|
||||||
var breakCaught = false
|
var breakCaught = false
|
||||||
@@ -1357,7 +1408,7 @@ class Compiler(
|
|||||||
.getOrElse {
|
.getOrElse {
|
||||||
throw ScriptError(
|
throw ScriptError(
|
||||||
tOp.pos,
|
tOp.pos,
|
||||||
"object is not enumerable: no index access for ${sourceObj.inspect()}",
|
"object is not enumerable: no index access for ${sourceObj.inspect(cxt)}",
|
||||||
it
|
it
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -1384,7 +1435,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (!breakCaught && elseStatement != null) {
|
if (!breakCaught && elseStatement != null) {
|
||||||
result = elseStatement.execute(ctx)
|
result = elseStatement.execute(cxt)
|
||||||
}
|
}
|
||||||
result
|
result
|
||||||
}
|
}
|
||||||
@@ -1396,7 +1447,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
|
|
||||||
private suspend fun loopIntRange(
|
private suspend fun loopIntRange(
|
||||||
forScope: Scope, start: Int, end: Int, loopVar: ObjRecord,
|
forScope: Scope, start: Long, end: Long, loopVar: ObjRecord,
|
||||||
body: Statement, elseStatement: Statement?, label: String?, catchBreak: Boolean
|
body: Statement, elseStatement: Statement?, label: String?, catchBreak: Boolean
|
||||||
): Obj {
|
): Obj {
|
||||||
var result: Obj = ObjVoid
|
var result: Obj = ObjVoid
|
||||||
@@ -1404,7 +1455,7 @@ class Compiler(
|
|||||||
loopVar.value = iVar
|
loopVar.value = iVar
|
||||||
if (catchBreak) {
|
if (catchBreak) {
|
||||||
for (i in start..<end) {
|
for (i in start..<end) {
|
||||||
iVar.value = i.toLong()
|
iVar.value = i//.toLong()
|
||||||
try {
|
try {
|
||||||
result = body.execute(forScope)
|
result = body.execute(forScope)
|
||||||
} catch (lbe: LoopBreakContinueException) {
|
} catch (lbe: LoopBreakContinueException) {
|
||||||
@@ -1416,7 +1467,7 @@ class Compiler(
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
for (i in start.toLong()..<end.toLong()) {
|
for (i in start..<end) {
|
||||||
iVar.value = i
|
iVar.value = i
|
||||||
result = body.execute(forScope)
|
result = body.execute(forScope)
|
||||||
}
|
}
|
||||||
@@ -1957,6 +2008,8 @@ class Compiler(
|
|||||||
Operator.simple(Token.Type.NEQ, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) != 0) },
|
Operator.simple(Token.Type.NEQ, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) != 0) },
|
||||||
Operator.simple(Token.Type.REF_EQ, lastPriority) { _, a, b -> ObjBool(a === b) },
|
Operator.simple(Token.Type.REF_EQ, lastPriority) { _, a, b -> ObjBool(a === b) },
|
||||||
Operator.simple(Token.Type.REF_NEQ, lastPriority) { _, a, b -> ObjBool(a !== b) },
|
Operator.simple(Token.Type.REF_NEQ, lastPriority) { _, a, b -> ObjBool(a !== b) },
|
||||||
|
Operator.simple(Token.Type.MATCH, lastPriority) { s, a, b -> a.operatorMatch(s,b) },
|
||||||
|
Operator.simple(Token.Type.NOTMATCH, lastPriority) { s, a, b -> a.operatorNotMatch(s,b) },
|
||||||
// relational <=,... 5
|
// relational <=,... 5
|
||||||
Operator.simple(Token.Type.LTE, ++lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) <= 0) },
|
Operator.simple(Token.Type.LTE, ++lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) <= 0) },
|
||||||
Operator.simple(Token.Type.LT, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) < 0) },
|
Operator.simple(Token.Type.LT, lastPriority) { c, a, b -> ObjBool(a.compareTo(c, b) < 0) },
|
||||||
@@ -1968,7 +2021,15 @@ class Compiler(
|
|||||||
Operator.simple(Token.Type.IS, lastPriority) { _, a, b -> ObjBool(a.isInstanceOf(b)) },
|
Operator.simple(Token.Type.IS, lastPriority) { _, a, b -> ObjBool(a.isInstanceOf(b)) },
|
||||||
Operator.simple(Token.Type.NOTIS, lastPriority) { _, a, b -> ObjBool(!a.isInstanceOf(b)) },
|
Operator.simple(Token.Type.NOTIS, lastPriority) { _, a, b -> ObjBool(!a.isInstanceOf(b)) },
|
||||||
|
|
||||||
Operator.simple(Token.Type.ELVIS, ++lastPriority) { _, a, b -> if (a == ObjNull) b else a },
|
Operator(Token.Type.ELVIS, ++lastPriority, 2) { _: Pos, a: Accessor, b: Accessor ->
|
||||||
|
Accessor {
|
||||||
|
val aa = a.getter(it).value
|
||||||
|
(
|
||||||
|
if (aa != ObjNull) aa
|
||||||
|
else b.getter(it).value
|
||||||
|
).asReadonly
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
// shuttle <=> 6
|
// shuttle <=> 6
|
||||||
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
|
Operator.simple(Token.Type.SHUTTLE, ++lastPriority) { c, a, b ->
|
||||||
|
|||||||
@@ -39,7 +39,6 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
fun next() =
|
fun next() =
|
||||||
if (currentIndex < tokens.size) tokens[currentIndex++]
|
if (currentIndex < tokens.size) tokens[currentIndex++]
|
||||||
else Token("", tokens.last().pos, Token.Type.EOF)
|
else Token("", tokens.last().pos, Token.Type.EOF)
|
||||||
// throw IllegalStateException("No more tokens")
|
|
||||||
|
|
||||||
fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
|
fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
|
||||||
|
|
||||||
@@ -131,6 +130,28 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
previous()
|
previous()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fun nextNonWhitespace(): Token {
|
||||||
|
while (true) {
|
||||||
|
val t = next()
|
||||||
|
if (t.type !in wstokens) return t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Find next non-whitespace token and return it. The token is not extracted,
|
||||||
|
* is will be returned on [next] call.
|
||||||
|
* @return next non-whitespace token without extracting it from tokens list
|
||||||
|
*/
|
||||||
|
fun peekNextNonWhitespace(): Token {
|
||||||
|
while (true) {
|
||||||
|
val t = next()
|
||||||
|
if (t.type !in wstokens) {
|
||||||
|
previous()
|
||||||
|
return t
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
|
inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
|
||||||
val t = next()
|
val t = next()
|
||||||
@@ -207,7 +228,7 @@ class CompilerContext(val tokens: List<Token>) {
|
|||||||
while (current().type in wstokens) {
|
while (current().type in wstokens) {
|
||||||
next()
|
next()
|
||||||
}
|
}
|
||||||
return next()
|
return current()
|
||||||
}
|
}
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
|
|||||||
@@ -20,10 +20,10 @@ package net.sergeych.lyng
|
|||||||
val digitsSet = ('0'..'9').toSet()
|
val digitsSet = ('0'..'9').toSet()
|
||||||
val digits = { d: Char -> d in digitsSet }
|
val digits = { d: Char -> d in digitsSet }
|
||||||
val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
|
val hexDigits = digitsSet + ('a'..'f') + ('A'..'F')
|
||||||
val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() }
|
val idNextChars = { d: Char -> d.isLetter() || d == '_' || d.isDigit() || d == '$' || d == '~' }
|
||||||
|
|
||||||
@Suppress("unused")
|
@Suppress("unused")
|
||||||
val idFirstChars = { d: Char -> d.isLetter() || d == '_' }
|
val idFirstChars = { d: Char -> d.isLetter() || d == '_' || d == '$' }
|
||||||
|
|
||||||
fun parseLyng(source: Source): List<Token> {
|
fun parseLyng(source: Source): List<Token> {
|
||||||
val p = Parser(fromPos = source.startPos)
|
val p = Parser(fromPos = source.startPos)
|
||||||
@@ -67,13 +67,16 @@ private class Parser(fromPos: Pos) {
|
|||||||
pos.advance()
|
pos.advance()
|
||||||
Token("===", from, Token.Type.REF_EQ)
|
Token("===", from, Token.Type.REF_EQ)
|
||||||
}
|
}
|
||||||
|
|
||||||
else -> Token("==", from, Token.Type.EQ)
|
else -> Token("==", from, Token.Type.EQ)
|
||||||
}
|
}
|
||||||
} else if (currentChar == '>') {
|
} else if (currentChar == '>') {
|
||||||
pos.advance()
|
pos.advance()
|
||||||
Token("=>", from, Token.Type.EQARROW)
|
Token("=>", from, Token.Type.EQARROW)
|
||||||
}
|
} else if (currentChar == '~') {
|
||||||
else
|
pos.advance()
|
||||||
|
Token("=~", from, Token.Type.MATCH)
|
||||||
|
} else
|
||||||
Token("=", from, Token.Type.ASSIGN)
|
Token("=", from, Token.Type.ASSIGN)
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -227,6 +230,9 @@ private class Parser(fromPos: Pos) {
|
|||||||
Token("!==", from, Token.Type.REF_NEQ)
|
Token("!==", from, Token.Type.REF_NEQ)
|
||||||
} else
|
} else
|
||||||
Token("!=", from, Token.Type.NEQ)
|
Token("!=", from, Token.Type.NEQ)
|
||||||
|
} else if (currentChar == '~') {
|
||||||
|
pos.advance()
|
||||||
|
Token("!~", from, Token.Type.NOTMATCH)
|
||||||
} else
|
} else
|
||||||
Token("!", from, Token.Type.NOT)
|
Token("!", from, Token.Type.NOT)
|
||||||
}
|
}
|
||||||
@@ -310,7 +316,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
// Labels processing is complicated!
|
// Labels processing is complicated!
|
||||||
// some@ statement: label 'some', ID 'statement'
|
// some@ statement: label 'some', ID 'statement'
|
||||||
// statement@some: ID 'statement', LABEL 'some'!
|
// statement@some: ID 'statement', LABEL 'some'!
|
||||||
if (ch.isLetter() || ch == '_') {
|
if (idNextChars(ch)) {
|
||||||
val text = ch + loadChars(idNextChars)
|
val text = ch + loadChars(idNextChars)
|
||||||
if (currentChar == '@') {
|
if (currentChar == '@') {
|
||||||
pos.advance()
|
pos.advance()
|
||||||
@@ -404,8 +410,7 @@ private class Parser(fromPos: Pos) {
|
|||||||
if (l.isBlank()) {
|
if (l.isBlank()) {
|
||||||
sizes.add(-1)
|
sizes.add(-1)
|
||||||
""
|
""
|
||||||
}
|
} else {
|
||||||
else {
|
|
||||||
val margin = leftMargin(l)
|
val margin = leftMargin(l)
|
||||||
sizes += margin
|
sizes += margin
|
||||||
" ".repeat(margin) + l.trim()
|
" ".repeat(margin) + l.trim()
|
||||||
@@ -433,11 +438,30 @@ private class Parser(fromPos: Pos) {
|
|||||||
'\\' -> {
|
'\\' -> {
|
||||||
pos.advance() ?: raise("unterminated string")
|
pos.advance() ?: raise("unterminated string")
|
||||||
when (currentChar) {
|
when (currentChar) {
|
||||||
'n' -> sb.append('\n')
|
'n' -> {
|
||||||
'r' -> sb.append('\r')
|
sb.append('\n'); pos.advance()
|
||||||
't' -> sb.append('\t')
|
}
|
||||||
'"' -> sb.append('"')
|
|
||||||
else -> sb.append('\\').append(currentChar)
|
'r' -> {
|
||||||
|
sb.append('\r'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
't' -> {
|
||||||
|
sb.append('\t'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'"' -> {
|
||||||
|
sb.append('"'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
'\\' -> {
|
||||||
|
sb.append('\\'); pos.advance()
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> {
|
||||||
|
sb.append('\\').append(currentChar)
|
||||||
|
pos.advance()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -136,11 +136,6 @@ open class Scope(
|
|||||||
?: thisObj.objClass
|
?: thisObj.objClass
|
||||||
.getInstanceMemberOrNull(name)
|
.getInstanceMemberOrNull(name)
|
||||||
)
|
)
|
||||||
// ?.also {
|
|
||||||
// if( name == "predicate") {
|
|
||||||
// println("got predicate $it")
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
}
|
}
|
||||||
|
|
||||||
fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
fun copy(pos: Pos, args: Arguments = Arguments.EMPTY, newThisObj: Obj? = null): Scope =
|
||||||
|
|||||||
@@ -57,15 +57,15 @@ class Script(
|
|||||||
ObjException.addExceptionsToContext(this)
|
ObjException.addExceptionsToContext(this)
|
||||||
addFn("print") {
|
addFn("print") {
|
||||||
for ((i, a) in args.withIndex()) {
|
for ((i, a) in args.withIndex()) {
|
||||||
if (i > 0) print(' ' + a.asStr.value)
|
if (i > 0) print(' ' + a.toString(this).value)
|
||||||
else print(a.asStr.value)
|
else print(a.toString(this).value)
|
||||||
}
|
}
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
addFn("println") {
|
addFn("println") {
|
||||||
for ((i, a) in args.withIndex()) {
|
for ((i, a) in args.withIndex()) {
|
||||||
if (i > 0) print(' ' + a.asStr.value)
|
if (i > 0) print(' ' + a.toString(this).value)
|
||||||
else print(a.asStr.value)
|
else print(a.toString(this).value)
|
||||||
}
|
}
|
||||||
println()
|
println()
|
||||||
ObjVoid
|
ObjVoid
|
||||||
@@ -165,13 +165,13 @@ class Script(
|
|||||||
val a = requiredArg<Obj>(0)
|
val a = requiredArg<Obj>(0)
|
||||||
val b = requiredArg<Obj>(1)
|
val b = requiredArg<Obj>(1)
|
||||||
if( a.compareTo(this, b) != 0 )
|
if( a.compareTo(this, b) != 0 )
|
||||||
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} == ${b.inspect()}"))
|
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} == ${b.inspect(this)}"))
|
||||||
}
|
}
|
||||||
addVoidFn("assertNotEquals") {
|
addVoidFn("assertNotEquals") {
|
||||||
val a = requiredArg<Obj>(0)
|
val a = requiredArg<Obj>(0)
|
||||||
val b = requiredArg<Obj>(1)
|
val b = requiredArg<Obj>(1)
|
||||||
if( a.compareTo(this, b) == 0 )
|
if( a.compareTo(this, b) == 0 )
|
||||||
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect()} != ${b.inspect()}"))
|
raiseError(ObjAssertionFailedException(this,"Assertion failed: ${a.inspect(this)} != ${b.inspect(this)}"))
|
||||||
}
|
}
|
||||||
addFn("assertThrows") {
|
addFn("assertThrows") {
|
||||||
val code = requireOnlyArg<Statement>()
|
val code = requireOnlyArg<Statement>()
|
||||||
@@ -241,6 +241,8 @@ class Script(
|
|||||||
addConst("CompletableDeferred", ObjCompletableDeferred.type)
|
addConst("CompletableDeferred", ObjCompletableDeferred.type)
|
||||||
addConst("Mutex", ObjMutex.type)
|
addConst("Mutex", ObjMutex.type)
|
||||||
|
|
||||||
|
addConst("Regex", ObjRegex.type)
|
||||||
|
|
||||||
addFn("launch") {
|
addFn("launch") {
|
||||||
val callable = requireOnlyArg<Statement>()
|
val callable = requireOnlyArg<Statement>()
|
||||||
ObjDeferred(globalDefer {
|
ObjDeferred(globalDefer {
|
||||||
@@ -287,7 +289,7 @@ class Script(
|
|||||||
is ObjInt -> delay(a.value * 1000)
|
is ObjInt -> delay(a.value * 1000)
|
||||||
is ObjReal -> delay((a.value * 1000).roundToLong())
|
is ObjReal -> delay((a.value * 1000).roundToLong())
|
||||||
is ObjDuration -> delay(a.duration)
|
is ObjDuration -> delay(a.duration)
|
||||||
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect()}")
|
else -> raiseIllegalArgument("Expected Duration, Int or Real, got ${a.inspect(this)}")
|
||||||
}
|
}
|
||||||
ObjVoid
|
ObjVoid
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -33,6 +33,6 @@ open class ScriptError(val pos: Pos, val errorMessage: String, cause: Throwable?
|
|||||||
|
|
||||||
class ScriptFlowIsNoMoreCollected: Exception()
|
class ScriptFlowIsNoMoreCollected: Exception()
|
||||||
|
|
||||||
class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message)
|
class ExecutionError(val errorObject: ObjException) : ScriptError(errorObject.scope.pos, errorObject.message.value)
|
||||||
|
|
||||||
class ImportException(pos: Pos, message: String) : ScriptError(pos, message)
|
class ImportException(pos: Pos, message: String) : ScriptError(pos, message)
|
||||||
@@ -17,10 +17,14 @@
|
|||||||
|
|
||||||
package net.sergeych.lyng
|
package net.sergeych.lyng
|
||||||
|
|
||||||
|
import net.sergeych.lyng.obj.ObjString
|
||||||
|
|
||||||
class Source(val fileName: String, text: String) {
|
class Source(val fileName: String, text: String) {
|
||||||
|
|
||||||
val lines = text.lines().map { it.trimEnd() }
|
val lines = text.lines().map { it.trimEnd() }
|
||||||
|
|
||||||
|
val objSourceName by lazy { ObjString(fileName) }
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
val builtIn: Source by lazy { Source("built-in", "") }
|
val builtIn: Source by lazy { Source("built-in", "") }
|
||||||
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
|
val UNKNOWN: Source by lazy { Source("UNKNOWN", "") }
|
||||||
|
|||||||
@@ -37,7 +37,7 @@ data class Token(val value: String, val pos: Pos, val type: Type) {
|
|||||||
ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
|
ASSIGN, PLUSASSIGN, MINUSASSIGN, STARASSIGN, SLASHASSIGN, PERCENTASSIGN,
|
||||||
PLUS2, MINUS2,
|
PLUS2, MINUS2,
|
||||||
IN, NOTIN, IS, NOTIS,
|
IN, NOTIN, IS, NOTIS,
|
||||||
EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ,
|
EQ, NEQ, LT, LTE, GT, GTE, REF_EQ, REF_NEQ, MATCH, NOTMATCH,
|
||||||
SHUTTLE,
|
SHUTTLE,
|
||||||
AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
|
AND, BITAND, OR, BITOR, NOT, BITNOT, DOT, ARROW, EQARROW, QUESTION, COLONCOLON,
|
||||||
SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
|
SINLGE_LINE_COMMENT, MULTILINE_COMMENT,
|
||||||
|
|||||||
@@ -21,14 +21,11 @@ import kotlinx.coroutines.sync.Mutex
|
|||||||
import kotlinx.coroutines.sync.withLock
|
import kotlinx.coroutines.sync.withLock
|
||||||
import kotlinx.serialization.SerialName
|
import kotlinx.serialization.SerialName
|
||||||
import kotlinx.serialization.Serializable
|
import kotlinx.serialization.Serializable
|
||||||
import net.sergeych.bintools.encodeToHex
|
|
||||||
import net.sergeych.lyng.*
|
import net.sergeych.lyng.*
|
||||||
import net.sergeych.lynon.LynonDecoder
|
import net.sergeych.lynon.LynonDecoder
|
||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
import net.sergeych.synctools.ProtectedOp
|
import net.sergeych.synctools.ProtectedOp
|
||||||
import net.sergeych.synctools.withLock
|
|
||||||
import kotlin.contracts.ExperimentalContracts
|
|
||||||
|
|
||||||
open class Obj {
|
open class Obj {
|
||||||
|
|
||||||
@@ -49,7 +46,7 @@ open class Obj {
|
|||||||
|
|
||||||
private val opInstances = ProtectedOp()
|
private val opInstances = ProtectedOp()
|
||||||
|
|
||||||
open fun inspect(): String = toString()
|
open suspend fun inspect(scope: Scope): String = toString(scope).value
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
|
* Some objects are by-value, historically [ObjInt] and [ObjReal] are usually treated as such.
|
||||||
@@ -84,14 +81,16 @@ open class Obj {
|
|||||||
scope: Scope,
|
scope: Scope,
|
||||||
name: String,
|
name: String,
|
||||||
args: Arguments = Arguments.EMPTY,
|
args: Arguments = Arguments.EMPTY,
|
||||||
onNotFoundResult: Obj?=null
|
onNotFoundResult: (() -> Obj?)? = null
|
||||||
): Obj =
|
): Obj {
|
||||||
objClass.getInstanceMemberOrNull(name)?.value?.invoke(
|
return objClass.getInstanceMemberOrNull(name)?.value?.invoke(
|
||||||
scope,
|
scope,
|
||||||
this,
|
this,
|
||||||
args)
|
args
|
||||||
?: onNotFoundResult
|
)
|
||||||
|
?: onNotFoundResult?.invoke()
|
||||||
?: scope.raiseSymbolNotFound(name)
|
?: scope.raiseSymbolNotFound(name)
|
||||||
|
}
|
||||||
|
|
||||||
open suspend fun getInstanceMethod(
|
open suspend fun getInstanceMethod(
|
||||||
scope: Scope,
|
scope: Scope,
|
||||||
@@ -113,8 +112,28 @@ open class Obj {
|
|||||||
return invokeInstanceMethod(scope, "contains", other).toBool()
|
return invokeInstanceMethod(scope, "contains", other).toBool()
|
||||||
}
|
}
|
||||||
|
|
||||||
open val asStr: ObjString by lazy {
|
/**
|
||||||
if (this is ObjString) this else ObjString(this.toString())
|
* Default toString implementation:
|
||||||
|
*
|
||||||
|
* - if the object is a string, returns it
|
||||||
|
* - otherwise, if not [calledFromLyng], calls Lyng override `toString()` if exists
|
||||||
|
* - otherwise, meaning either called from Lyng `toString`, or there is no
|
||||||
|
* Lyng override, returns the object's Kotlin variant of `toString()
|
||||||
|
*
|
||||||
|
* Note on kotlin's `toString()`: it is preferred to use this, 'scoped` version,
|
||||||
|
* as it can execute Lyng code using the scope and being suspending one.
|
||||||
|
*
|
||||||
|
* @param scope the scope where the string representation was requested
|
||||||
|
* @param calledFromLyng true if called from Lyng's `toString`. Normally this parameter should be ignored,
|
||||||
|
* but it is used to avoid endless recursion in [Obj.toString] base implementation
|
||||||
|
*/
|
||||||
|
suspend open fun toString(scope: Scope,calledFromLyng: Boolean=false): ObjString {
|
||||||
|
return if (this is ObjString) this
|
||||||
|
else if( !calledFromLyng ) {
|
||||||
|
invokeInstanceMethod(scope, "toString") {
|
||||||
|
ObjString(this.toString())
|
||||||
|
} as ObjString
|
||||||
|
} else { ObjString(this.toString()) }
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -159,6 +178,14 @@ open class Obj {
|
|||||||
scope.raiseNotImplemented()
|
scope.raiseNotImplemented()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
open suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
scope.raiseNotImplemented()
|
||||||
|
}
|
||||||
|
|
||||||
|
open suspend fun operatorNotMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
return operatorMatch(scope,other).logicalNot(scope)
|
||||||
|
}
|
||||||
|
|
||||||
open suspend fun assign(scope: Scope, other: Obj): Obj? = null
|
open suspend fun assign(scope: Scope, other: Obj): Obj? = null
|
||||||
|
|
||||||
open fun getValue(scope: Scope) = this
|
open fun getValue(scope: Scope) = this
|
||||||
@@ -282,14 +309,26 @@ open class Obj {
|
|||||||
return scope
|
return scope
|
||||||
}
|
}
|
||||||
|
|
||||||
|
inline fun <reified R: Obj> cast(scope: Scope): R {
|
||||||
|
castOrNull<R>()?.let { return it }
|
||||||
|
scope.raiseClassCastError("can't cast ${this::class.simpleName} to ${R::class.simpleName}")
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
inline fun <reified R: Obj> castOrNull(): R? {
|
||||||
|
(this as? R)?.let { return it }
|
||||||
|
// todo: check for subclasses
|
||||||
|
return null
|
||||||
|
}
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
|
|
||||||
val rootObjectType = ObjClass("Obj").apply {
|
val rootObjectType = ObjClass("Obj").apply {
|
||||||
addFn("toString") {
|
addFn("toString", true) {
|
||||||
thisObj.asStr
|
thisObj.toString(this, true)
|
||||||
}
|
}
|
||||||
addFn("inspect", true) {
|
addFn("inspect", true) {
|
||||||
thisObj.inspect().toObj()
|
thisObj.inspect(this).toObj()
|
||||||
}
|
}
|
||||||
addFn("contains") {
|
addFn("contains") {
|
||||||
ObjBool(thisObj.contains(this, args.firstAndOnly()))
|
ObjBool(thisObj.contains(this, args.firstAndOnly()))
|
||||||
@@ -301,10 +340,8 @@ open class Obj {
|
|||||||
addFn("apply") {
|
addFn("apply") {
|
||||||
val body = args.firstAndOnly()
|
val body = args.firstAndOnly()
|
||||||
(thisObj as? ObjInstance)?.let {
|
(thisObj as? ObjInstance)?.let {
|
||||||
println("apply in ${thisObj is ObjInstance}, ${it.instanceScope}")
|
|
||||||
body.callOn(ApplyScope(this, it.instanceScope))
|
body.callOn(ApplyScope(this, it.instanceScope))
|
||||||
} ?: run {
|
} ?: run {
|
||||||
println("apply on non-instance $thisObj")
|
|
||||||
body.callOn(this)
|
body.callOn(this)
|
||||||
}
|
}
|
||||||
thisObj
|
thisObj
|
||||||
@@ -313,6 +350,9 @@ open class Obj {
|
|||||||
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
|
args.firstAndOnly().callOn(copy(Arguments(thisObj)))
|
||||||
thisObj
|
thisObj
|
||||||
}
|
}
|
||||||
|
addFn("run") {
|
||||||
|
args.firstAndOnly().callOn(this)
|
||||||
|
}
|
||||||
addFn("getAt") {
|
addFn("getAt") {
|
||||||
requireExactCount(1)
|
requireExactCount(1)
|
||||||
thisObj.getAt(this, requiredArg<Obj>(0))
|
thisObj.getAt(this, requiredArg<Obj>(0))
|
||||||
@@ -387,9 +427,14 @@ object ObjNull : Obj() {
|
|||||||
scope.raiseNPE()
|
scope.raiseNPE()
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments, onNotFoundResult: Obj?): Obj {
|
// override suspend fun invokeInstanceMethod(
|
||||||
scope.raiseNPE()
|
// scope: Scope,
|
||||||
}
|
// name: String,
|
||||||
|
// args: Arguments,
|
||||||
|
// onNotFoundResult: (()->Obj?)?
|
||||||
|
// ): Obj {
|
||||||
|
// scope.raiseNPE()
|
||||||
|
// }
|
||||||
|
|
||||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
scope.raiseNPE()
|
scope.raiseNPE()
|
||||||
@@ -431,6 +476,9 @@ object ObjNull : Obj() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* TODO: get rid of it. Maybe we ise some Lyng inheritance instead
|
||||||
|
*/
|
||||||
interface Numeric {
|
interface Numeric {
|
||||||
val longValue: Long
|
val longValue: Long
|
||||||
val doubleValue: Double
|
val doubleValue: Double
|
||||||
@@ -461,129 +509,11 @@ fun Obj.toBool(): Boolean =
|
|||||||
data class ObjNamespace(val name: String) : Obj() {
|
data class ObjNamespace(val name: String) : Obj() {
|
||||||
override val objClass by lazy { ObjClass(name) }
|
override val objClass by lazy { ObjClass(name) }
|
||||||
|
|
||||||
override fun inspect(): String = "Ns[$name]"
|
override suspend fun inspect(scope: Scope): String = "Ns[$name]"
|
||||||
|
|
||||||
override fun toString(): String {
|
override fun toString(): String {
|
||||||
return "package $name"
|
return "package $name"
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
open class ObjException(exceptionClass: ExceptionClass, val scope: Scope, val message: String) : Obj() {
|
|
||||||
constructor(name: String, scope: Scope, message: String) : this(
|
|
||||||
getOrCreateExceptionClass(name),
|
|
||||||
scope,
|
|
||||||
message
|
|
||||||
)
|
|
||||||
|
|
||||||
constructor(scope: Scope, message: String) : this(Root, scope, message)
|
|
||||||
|
|
||||||
fun raise(): Nothing {
|
|
||||||
throw ExecutionError(this)
|
|
||||||
}
|
|
||||||
|
|
||||||
override val objClass: ObjClass = exceptionClass
|
|
||||||
|
|
||||||
override fun toString(): String {
|
|
||||||
return "ObjException:${objClass.className}:${scope.pos}@${hashCode().encodeToHex()}"
|
|
||||||
}
|
|
||||||
|
|
||||||
companion object {
|
|
||||||
|
|
||||||
class ExceptionClass(val name: String, vararg parents: ObjClass) : ObjClass(name, *parents) {
|
|
||||||
override suspend fun callOn(scope: Scope): Obj {
|
|
||||||
val message = scope.args.getOrNull(0)?.toString() ?: name
|
|
||||||
return ObjException(this, scope, message)
|
|
||||||
}
|
|
||||||
|
|
||||||
override fun toString(): String = "ExceptionClass[$name]@${hashCode().encodeToHex()}"
|
|
||||||
}
|
|
||||||
|
|
||||||
val Root = ExceptionClass("Throwable").apply {
|
|
||||||
addConst("message", statement {
|
|
||||||
(thisObj as ObjException).message.toObj()
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
private val op = ProtectedOp()
|
|
||||||
private val existingErrorClasses = mutableMapOf<String, ExceptionClass>()
|
|
||||||
|
|
||||||
|
|
||||||
@OptIn(ExperimentalContracts::class)
|
|
||||||
protected fun getOrCreateExceptionClass(name: String): ExceptionClass {
|
|
||||||
return op.withLock {
|
|
||||||
existingErrorClasses.getOrPut(name) {
|
|
||||||
ExceptionClass(name, Root)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Get [ObjClass] for error class by name if exists.
|
|
||||||
*/
|
|
||||||
@OptIn(ExperimentalContracts::class)
|
|
||||||
fun getErrorClass(name: String): ObjClass? = op.withLock {
|
|
||||||
existingErrorClasses[name]
|
|
||||||
}
|
|
||||||
|
|
||||||
fun addExceptionsToContext(scope: Scope) {
|
|
||||||
scope.addConst("Exception", Root)
|
|
||||||
existingErrorClasses["Exception"] = Root
|
|
||||||
for (name in listOf(
|
|
||||||
"NullReferenceException",
|
|
||||||
"AssertionFailedException",
|
|
||||||
"ClassCastException",
|
|
||||||
"IndexOutOfBoundsException",
|
|
||||||
"IllegalArgumentException",
|
|
||||||
"NoSuchElementException",
|
|
||||||
"IllegalAssignmentException",
|
|
||||||
"SymbolNotDefinedException",
|
|
||||||
"IterationEndException",
|
|
||||||
"AccessException",
|
|
||||||
"UnknownException",
|
|
||||||
"NotFoundException"
|
|
||||||
)) {
|
|
||||||
scope.addConst(name, getOrCreateExceptionClass(name))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
class ObjNullReferenceException(scope: Scope) : ObjException("NullReferenceException", scope, "object is null")
|
|
||||||
|
|
||||||
class ObjAssertionFailedException(scope: Scope, message: String) :
|
|
||||||
ObjException("AssertionFailedException", scope, message)
|
|
||||||
|
|
||||||
class ObjClassCastException(scope: Scope, message: String) : ObjException("ClassCastException", scope, message)
|
|
||||||
class ObjIndexOutOfBoundsException(scope: Scope, message: String = "index out of bounds") :
|
|
||||||
ObjException("IndexOutOfBoundsException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalArgumentException(scope: Scope, message: String = "illegal argument") :
|
|
||||||
ObjException("IllegalArgumentException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalStateException(scope: Scope, message: String = "illegal state") :
|
|
||||||
ObjException("IllegalStateException", scope, message)
|
|
||||||
|
|
||||||
@Suppress("unused")
|
|
||||||
class ObjNoSuchElementException(scope: Scope, message: String = "no such element") :
|
|
||||||
ObjException("IllegalArgumentException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalAssignmentException(scope: Scope, message: String = "illegal assignment") :
|
|
||||||
ObjException("NoSuchElementException", scope, message)
|
|
||||||
|
|
||||||
class ObjSymbolNotDefinedException(scope: Scope, message: String = "symbol is not defined") :
|
|
||||||
ObjException("SymbolNotDefinedException", scope, message)
|
|
||||||
|
|
||||||
class ObjIterationFinishedException(scope: Scope) :
|
|
||||||
ObjException("IterationEndException", scope, "iteration finished")
|
|
||||||
|
|
||||||
class ObjAccessException(scope: Scope, message: String = "access not allowed error") :
|
|
||||||
ObjException("AccessException", scope, message)
|
|
||||||
|
|
||||||
class ObjUnknownException(scope: Scope, message: String = "access not allowed error") :
|
|
||||||
ObjException("UnknownException", scope, message)
|
|
||||||
|
|
||||||
class ObjIllegalOperationException(scope: Scope, message: String = "Operation is illegal") :
|
|
||||||
ObjException("IllegalOperationException", scope, message)
|
|
||||||
|
|
||||||
class ObjNotFoundException(scope: Scope, message: String = "not found") :
|
|
||||||
ObjException("NotFoundException", scope, message)
|
|
||||||
@@ -51,5 +51,25 @@ val ObjArray by lazy {
|
|||||||
ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
|
ObjRange(0.toObj(), thisObj.invokeInstanceMethod(this, "size"), false)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
addFn("binarySearch") {
|
||||||
|
val target = args.firstAndOnly()
|
||||||
|
var low = 0
|
||||||
|
var high = thisObj.invokeInstanceMethod(this, "size").toInt() - 1
|
||||||
|
|
||||||
|
while (low <= high) {
|
||||||
|
val mid = (low + high) / 2
|
||||||
|
val midVal = thisObj.getAt(this, ObjInt(mid.toLong()))
|
||||||
|
|
||||||
|
val cmp = midVal.compareTo(this, target)
|
||||||
|
when {
|
||||||
|
cmp == 0 -> return@addFn (mid).toObj()
|
||||||
|
cmp > 0 -> high = mid - 1
|
||||||
|
else -> low = mid + 1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Элемент не найден, возвращаем -(точка вставки) - 1
|
||||||
|
(-low - 1).toObj()
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
|
|||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
|
|
||||||
data class ObjBool(val value: Boolean) : Obj() {
|
data class ObjBool(val value: Boolean) : Obj() {
|
||||||
override val asStr by lazy { ObjString(value.toString()) }
|
|
||||||
|
|
||||||
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||||
if (other !is ObjBool) return -2
|
if (other !is ObjBool) return -2
|
||||||
|
|||||||
@@ -24,6 +24,7 @@ import net.sergeych.bintools.encodeToHex
|
|||||||
import net.sergeych.bintools.toDump
|
import net.sergeych.bintools.toDump
|
||||||
import net.sergeych.lyng.Scope
|
import net.sergeych.lyng.Scope
|
||||||
import net.sergeych.lyng.statement
|
import net.sergeych.lyng.statement
|
||||||
|
import net.sergeych.lynon.BitArray
|
||||||
import net.sergeych.lynon.LynonDecoder
|
import net.sergeych.lynon.LynonDecoder
|
||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
@@ -86,7 +87,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
|
byteArray + other.toFlow(scope).map { it.toLong().toUByte() }.toList().toTypedArray()
|
||||||
.toUByteArray()
|
.toUByteArray()
|
||||||
)
|
)
|
||||||
} else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect()}")
|
} else scope.raiseIllegalArgument("can't concatenate buffer with ${other.inspect(scope)}")
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun toString(): String = base64
|
override fun toString(): String = base64
|
||||||
@@ -106,7 +107,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
encoder.encodeCachedBytes(byteArray.asByteArray())
|
encoder.encodeCachedBytes(byteArray.asByteArray())
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun inspect(): String = "Buf($base64)"
|
override suspend fun inspect(scope: Scope): String = "Buf($base64)"
|
||||||
|
|
||||||
companion object {
|
companion object {
|
||||||
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
|
private suspend fun createBufferFrom(scope: Scope, obj: Obj): ObjBuffer =
|
||||||
@@ -128,7 +129,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
)
|
)
|
||||||
} else
|
} else
|
||||||
scope.raiseIllegalArgument(
|
scope.raiseIllegalArgument(
|
||||||
"can't construct buffer from ${obj.inspect()}"
|
"can't construct buffer from ${obj.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -148,7 +149,7 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
is ObjChar -> b.value.code.toUByte()
|
is ObjChar -> b.value.code.toUByte()
|
||||||
is ObjInt -> b.value.toUByte()
|
is ObjInt -> b.value.toUByte()
|
||||||
else -> scope.raiseIllegalArgument(
|
else -> scope.raiseIllegalArgument(
|
||||||
"invalid byte value for buffer constructor at index $i: ${b.inspect()}"
|
"invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
data[i] = code
|
data[i] = code
|
||||||
@@ -200,6 +201,9 @@ open class ObjBuffer(val byteArray: UByteArray) : Obj() {
|
|||||||
thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
|
thisAs<ObjBuffer>().byteArray.toByteArray().toDump()
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
addFn("toBitInput") {
|
||||||
|
ObjBitBuffer(BitArray(thisAs<ObjBuffer>().byteArray, 8))
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -28,7 +28,7 @@ class ObjChar(val value: Char): Obj() {
|
|||||||
|
|
||||||
override fun toString(): String = value.toString()
|
override fun toString(): String = value.toString()
|
||||||
|
|
||||||
override fun inspect(): String = "'$value'"
|
override suspend fun inspect(scope: Scope): String = "'$value'"
|
||||||
|
|
||||||
override fun hashCode(): Int {
|
override fun hashCode(): Int {
|
||||||
return value.hashCode()
|
return value.hashCode()
|
||||||
|
|||||||
@@ -68,6 +68,10 @@ open class ObjClass(
|
|||||||
return instance
|
return instance
|
||||||
}
|
}
|
||||||
|
|
||||||
|
suspend fun callWithArgs(scope: Scope, vararg plainArgs: Obj): Obj {
|
||||||
|
return callOn(scope.copy(Arguments(*plainArgs)))
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
fun createField(
|
fun createField(
|
||||||
name: String,
|
name: String,
|
||||||
@@ -140,13 +144,16 @@ open class ObjClass(
|
|||||||
?: super.writeField(scope, name, newValue)
|
?: super.writeField(scope, name, newValue)
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
override suspend fun invokeInstanceMethod(
|
||||||
onNotFoundResult: Obj?): Obj {
|
scope: Scope, name: String, args: Arguments,
|
||||||
|
onNotFoundResult: (() -> Obj?)?
|
||||||
|
): Obj {
|
||||||
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
|
return classScope?.objects?.get(name)?.value?.invoke(scope, this, args)
|
||||||
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
?: super.invokeInstanceMethod(scope, name, args, onNotFoundResult)
|
||||||
}
|
}
|
||||||
|
|
||||||
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj = scope.raiseNotImplemented()
|
open suspend fun deserialize(scope: Scope, decoder: LynonDecoder, lynonType: LynonType?): Obj =
|
||||||
|
scope.raiseNotImplemented()
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -18,8 +18,8 @@
|
|||||||
package net.sergeych.lyng.obj
|
package net.sergeych.lyng.obj
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Collection is an iterator with `size`]
|
* Collection is an iterator with `size`
|
||||||
*/
|
*/
|
||||||
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
|
val ObjCollection = ObjClass("Collection", ObjIterable).apply {
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -57,7 +57,7 @@ class ObjDuration(val duration: Duration) : Obj() {
|
|||||||
override suspend fun callOn(scope: Scope): Obj {
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
val args = scope.args
|
val args = scope.args
|
||||||
if( args.list.size > 1 )
|
if( args.list.size > 1 )
|
||||||
scope.raiseIllegalArgument("can't construct Duration(${args.inspect()})")
|
scope.raiseIllegalArgument("can't construct Duration(${args.inspect(scope)})")
|
||||||
val a0 = args.list.getOrNull(0)
|
val a0 = args.list.getOrNull(0)
|
||||||
|
|
||||||
return ObjDuration(
|
return ObjDuration(
|
||||||
@@ -66,7 +66,7 @@ class ObjDuration(val duration: Duration) : Obj() {
|
|||||||
is ObjInt -> a0.value.seconds
|
is ObjInt -> a0.value.seconds
|
||||||
is ObjReal -> a0.value.seconds
|
is ObjReal -> a0.value.seconds
|
||||||
else -> {
|
else -> {
|
||||||
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
|
scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -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)
|
||||||
@@ -48,7 +48,7 @@ class ObjInstance(override val objClass: ObjClass) : Obj() {
|
|||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
override suspend fun invokeInstanceMethod(scope: Scope, name: String, args: Arguments,
|
||||||
onNotFoundResult: Obj?): Obj =
|
onNotFoundResult: (()->Obj?)?): Obj =
|
||||||
instanceScope[name]?.let {
|
instanceScope[name]?.let {
|
||||||
if (it.visibility.isPublic)
|
if (it.visibility.isPublic)
|
||||||
it.value.invoke(
|
it.value.invoke(
|
||||||
|
|||||||
@@ -35,7 +35,14 @@ class ObjInstanceClass(val name: String) : ObjClass(name) {
|
|||||||
val newScope = scope.copy(args = Arguments(args))
|
val newScope = scope.copy(args = Arguments(args))
|
||||||
return (callOn(newScope) as ObjInstance).apply {
|
return (callOn(newScope) as ObjInstance).apply {
|
||||||
deserializeStateVars(scope, decoder)
|
deserializeStateVars(scope, decoder)
|
||||||
invokeInstanceMethod(scope, "onDeserialized", onNotFoundResult = ObjVoid)
|
invokeInstanceMethod(scope, "onDeserialized") { ObjVoid }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
init {
|
||||||
|
addFn("toString", true) {
|
||||||
|
println("-------------- tos! --------------")
|
||||||
|
ObjString(thisObj.toString())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|||||||
@@ -117,7 +117,7 @@ class ObjInstant(val instant: Instant,val truncateMode: LynonSettings.InstantTru
|
|||||||
is ObjInstant -> a0.instant
|
is ObjInstant -> a0.instant
|
||||||
|
|
||||||
else -> {
|
else -> {
|
||||||
scope.raiseIllegalArgument("can't construct Instant(${args.inspect()})")
|
scope.raiseIllegalArgument("can't construct Instant(${args.inspect(scope)})")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
)
|
)
|
||||||
|
|||||||
@@ -23,7 +23,6 @@ import net.sergeych.lynon.LynonEncoder
|
|||||||
import net.sergeych.lynon.LynonType
|
import net.sergeych.lynon.LynonType
|
||||||
|
|
||||||
class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric {
|
class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Numeric {
|
||||||
override val asStr get() = ObjString(value.toString())
|
|
||||||
override val longValue get() = value
|
override val longValue get() = value
|
||||||
override val doubleValue get() = value.toDouble()
|
override val doubleValue get() = value.toDouble()
|
||||||
override val toObjInt get() = this
|
override val toObjInt get() = this
|
||||||
@@ -62,7 +61,7 @@ class ObjInt(var value: Long, override val isConst: Boolean = false) : Obj(), Nu
|
|||||||
|
|
||||||
override fun toString(): String = value.toString()
|
override fun toString(): String = value.toString()
|
||||||
|
|
||||||
override val objClass: ObjClass = type
|
override val objClass: ObjClass by lazy { type }
|
||||||
|
|
||||||
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
override suspend fun plus(scope: Scope, other: Obj): Obj =
|
||||||
if (other is ObjInt)
|
if (other is ObjInt)
|
||||||
|
|||||||
@@ -119,12 +119,6 @@ val ObjIterable by lazy {
|
|||||||
ObjList(result)
|
ObjList(result)
|
||||||
}
|
}
|
||||||
|
|
||||||
// addFn("drop" ) {
|
|
||||||
// var n = requireOnlyArg<ObjInt>().value.toInt()
|
|
||||||
// if( n < 0 ) raiseIllegalArgument("drop($n): should be positive")
|
|
||||||
// val it = callMethod<>()
|
|
||||||
// }
|
|
||||||
|
|
||||||
addFn("isEmpty") {
|
addFn("isEmpty") {
|
||||||
ObjBool(
|
ObjBool(
|
||||||
thisObj.invokeInstanceMethod(this, "iterator")
|
thisObj.invokeInstanceMethod(this, "iterator")
|
||||||
@@ -132,5 +126,20 @@ val ObjIterable by lazy {
|
|||||||
.not()
|
.not()
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
addFn("sortedWith") {
|
||||||
|
val list = thisObj.callMethod<ObjList>(this, "toList")
|
||||||
|
val comparator = requireOnlyArg<Statement>()
|
||||||
|
list.quicksort { a, b ->
|
||||||
|
comparator.call(this, a, b).toInt()
|
||||||
|
}
|
||||||
|
list
|
||||||
|
}
|
||||||
|
|
||||||
|
addFn("reversed") {
|
||||||
|
val list = thisObj.callMethod<ObjList>(this, "toList")
|
||||||
|
list.list.reverse()
|
||||||
|
list
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -95,5 +95,5 @@ suspend fun Obj.enumerate(scope: Scope,callback: suspend (Obj)->Boolean) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (closeIt)
|
if (closeIt)
|
||||||
iterator.invokeInstanceMethod(scope, "cancelIteration", onNotFoundResult = ObjVoid)
|
iterator.invokeInstanceMethod(scope, "cancelIteration") { ObjVoid }
|
||||||
}
|
}
|
||||||
@@ -18,6 +18,7 @@
|
|||||||
package net.sergeych.lyng.obj
|
package net.sergeych.lyng.obj
|
||||||
|
|
||||||
import net.sergeych.lyng.Scope
|
import net.sergeych.lyng.Scope
|
||||||
|
import net.sergeych.lyng.Statement
|
||||||
import net.sergeych.lyng.statement
|
import net.sergeych.lyng.statement
|
||||||
import net.sergeych.lynon.LynonDecoder
|
import net.sergeych.lynon.LynonDecoder
|
||||||
import net.sergeych.lynon.LynonEncoder
|
import net.sergeych.lynon.LynonEncoder
|
||||||
@@ -25,10 +26,6 @@ import net.sergeych.lynon.LynonType
|
|||||||
|
|
||||||
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
||||||
|
|
||||||
override fun toString(): String = "[${
|
|
||||||
list.joinToString(separator = ", ") { it.inspect() }
|
|
||||||
}]"
|
|
||||||
|
|
||||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
return when (index) {
|
return when (index) {
|
||||||
is ObjInt -> {
|
is ObjInt -> {
|
||||||
@@ -65,7 +62,7 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
else -> scope.raiseIllegalArgument("Illegal index object for a list: ${index.inspect()}")
|
else -> scope.raiseIllegalArgument("Illegal index object for a list: ${index.inspect(scope)}")
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -131,6 +128,33 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
return list.map { it.toKotlin(scope) }
|
return list.map { it.toKotlin(scope) }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
suspend fun quicksort(compare: suspend (Obj, Obj) -> Int) = quicksort(compare, 0, list.size - 1)
|
||||||
|
|
||||||
|
suspend fun quicksort(compare: suspend (Obj, Obj) -> Int, left: Int, right: Int) {
|
||||||
|
if (left >= right) return
|
||||||
|
var i = left
|
||||||
|
var j = right
|
||||||
|
val pivot = list[left]
|
||||||
|
while (i < j) {
|
||||||
|
// Сдвигаем j влево, пока элемент меньше pivot
|
||||||
|
while (i < j && compare(list[j], pivot) >= 0) {
|
||||||
|
j--
|
||||||
|
}
|
||||||
|
// Сдвигаем i вправо, пока элемент больше pivot
|
||||||
|
while (i < j && compare(list[i], pivot) <= 0) {
|
||||||
|
i++
|
||||||
|
}
|
||||||
|
if (i < j) {
|
||||||
|
list.swap(i, j)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// После завершения i == j, ставим pivot на своё место
|
||||||
|
list.swap(left, i)
|
||||||
|
// Рекурсивно сортируем левую и правую части
|
||||||
|
quicksort(compare, left, i - 1)
|
||||||
|
quicksort(compare, i + 1, right)
|
||||||
|
}
|
||||||
|
|
||||||
override fun hashCode(): Int {
|
override fun hashCode(): Int {
|
||||||
// check?
|
// check?
|
||||||
return list.hashCode()
|
return list.hashCode()
|
||||||
@@ -239,8 +263,27 @@ class ObjList(val list: MutableList<Obj> = mutableListOf()) : Obj() {
|
|||||||
}
|
}
|
||||||
self
|
self
|
||||||
}
|
}
|
||||||
|
|
||||||
|
addFn("sortWith") {
|
||||||
|
val comparator = requireOnlyArg<Statement>()
|
||||||
|
thisAs<ObjList>().quicksort { a, b -> comparator.call(this, a, b).toInt() }
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
|
addFn("shuffle") {
|
||||||
|
thisAs<ObjList>().list.shuffle()
|
||||||
|
ObjVoid
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Расширение MutableList для удобного обмена элементами
|
||||||
|
fun <T>MutableList<T>.swap(i: Int, j: Int) {
|
||||||
|
if (i in indices && j in indices) {
|
||||||
|
val temp = this[i]
|
||||||
|
this[i] = this[j]
|
||||||
|
this[j] = temp
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
@@ -28,7 +28,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
|
|||||||
is ObjInt -> newValue.value.toUByte()
|
is ObjInt -> newValue.value.toUByte()
|
||||||
is ObjChar -> newValue.value.code.toUByte()
|
is ObjChar -> newValue.value.code.toUByte()
|
||||||
else -> scope.raiseIllegalArgument(
|
else -> scope.raiseIllegalArgument(
|
||||||
"invalid byte value for buffer at index ${index.inspect()}: ${newValue.inspect()}"
|
"invalid byte value for buffer at index ${index.inspect(scope)}: ${newValue.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -54,7 +54,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
|
|||||||
)
|
)
|
||||||
} else
|
} else
|
||||||
scope.raiseIllegalArgument(
|
scope.raiseIllegalArgument(
|
||||||
"can't construct buffer from ${obj.inspect()}"
|
"can't construct buffer from ${obj.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -74,7 +74,7 @@ class ObjMutableBuffer(byteArray: UByteArray) : ObjBuffer(byteArray) {
|
|||||||
is ObjChar -> b.value.code.toUByte()
|
is ObjChar -> b.value.code.toUByte()
|
||||||
is ObjInt -> b.value.toUByte()
|
is ObjInt -> b.value.toUByte()
|
||||||
else -> scope.raiseIllegalArgument(
|
else -> scope.raiseIllegalArgument(
|
||||||
"invalid byte value for buffer constructor at index $i: ${b.inspect()}"
|
"invalid byte value for buffer constructor at index $i: ${b.inspect(scope)}"
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
data[i] = code
|
data[i] = code
|
||||||
|
|||||||
@@ -26,12 +26,12 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
|
|||||||
|
|
||||||
override val objClass: ObjClass = type
|
override val objClass: ObjClass = type
|
||||||
|
|
||||||
override fun toString(): String {
|
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
|
||||||
val result = StringBuilder()
|
val result = StringBuilder()
|
||||||
result.append("${start?.inspect() ?: '∞'} ..")
|
result.append("${start?.inspect(scope) ?: '∞'} ..")
|
||||||
if (!isEndInclusive) result.append('<')
|
if (!isEndInclusive) result.append('<')
|
||||||
result.append(" ${end?.inspect() ?: '∞'}")
|
result.append(" ${end?.inspect(scope) ?: '∞'}")
|
||||||
return result.toString()
|
return ObjString(result.toString())
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@@ -52,11 +52,11 @@ class ObjRange(val start: Obj?, val end: Obj?, val isEndInclusive: Boolean) : Ob
|
|||||||
* if start is not ObjInt, raises [ObjIllegalArgumentException]
|
* if start is not ObjInt, raises [ObjIllegalArgumentException]
|
||||||
* otherwise returns start.value.toInt()
|
* otherwise returns start.value.toInt()
|
||||||
*/
|
*/
|
||||||
fun startInt(scope: Scope): Int =
|
suspend fun startInt(scope: Scope): Int =
|
||||||
if( start == null || start is ObjNull) 0
|
if( start == null || start is ObjNull) 0
|
||||||
else {
|
else {
|
||||||
if( start is ObjInt) start.value.toInt()
|
if( start is ObjInt) start.value.toInt()
|
||||||
else scope.raiseIllegalArgument("start is not Int: ${start.inspect()}")
|
else scope.raiseIllegalArgument("start is not Int: ${start.inspect(scope)}")
|
||||||
}
|
}
|
||||||
|
|
||||||
suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
|
suspend fun containsRange(scope: Scope, other: ObjRange): Boolean {
|
||||||
|
|||||||
@@ -27,7 +27,6 @@ import kotlin.math.floor
|
|||||||
import kotlin.math.roundToLong
|
import kotlin.math.roundToLong
|
||||||
|
|
||||||
data class ObjReal(val value: Double) : Obj(), Numeric {
|
data class ObjReal(val value: Double) : Obj(), Numeric {
|
||||||
override val asStr by lazy { ObjString(value.toString()) }
|
|
||||||
override val longValue: Long by lazy { floor(value).toLong() }
|
override val longValue: Long by lazy { floor(value).toLong() }
|
||||||
override val doubleValue: Double by lazy { value }
|
override val doubleValue: Double by lazy { value }
|
||||||
override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
|
override val toObjInt: ObjInt by lazy { ObjInt(longValue) }
|
||||||
|
|||||||
@@ -0,0 +1,112 @@
|
|||||||
|
/*
|
||||||
|
* Copyright 2025 Sergey S. Chernov real.sergeych@gmail.com
|
||||||
|
*
|
||||||
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
* you may not use this file except in compliance with the License.
|
||||||
|
* You may obtain a copy of the License at
|
||||||
|
*
|
||||||
|
* http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
*
|
||||||
|
* Unless required by applicable law or agreed to in writing, software
|
||||||
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
* See the License for the specific language governing permissions and
|
||||||
|
* limitations under the License.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
package net.sergeych.lyng.obj
|
||||||
|
|
||||||
|
import net.sergeych.lyng.Scope
|
||||||
|
|
||||||
|
class ObjRegex(val regex: Regex) : Obj() {
|
||||||
|
override val objClass = type
|
||||||
|
|
||||||
|
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
return regex.find(other.cast<ObjString>(scope).value)?.let {
|
||||||
|
scope.addConst("$~", ObjRegexMatch(it))
|
||||||
|
ObjTrue
|
||||||
|
} ?: ObjFalse
|
||||||
|
}
|
||||||
|
|
||||||
|
fun find(s: ObjString): Obj =
|
||||||
|
regex.find(s.value)?.let { ObjRegexMatch(it) } ?: ObjNull
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type by lazy {
|
||||||
|
object : ObjClass("Regex") {
|
||||||
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
|
return ObjRegex(
|
||||||
|
scope.requireOnlyArg<ObjString>().value.toRegex()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}.apply {
|
||||||
|
addFn("matches") {
|
||||||
|
ObjBool(args.firstAndOnly().toString().matches(thisAs<ObjRegex>().regex))
|
||||||
|
}
|
||||||
|
addFn("find") {
|
||||||
|
thisAs<ObjRegex>().find(requireOnlyArg<ObjString>())
|
||||||
|
}
|
||||||
|
addFn("findAll") {
|
||||||
|
val s = requireOnlyArg<ObjString>().value
|
||||||
|
ObjList(thisAs<ObjRegex>().regex.findAll(s).map { ObjRegexMatch(it) }.toMutableList())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
class ObjRegexMatch(val match: MatchResult) : Obj() {
|
||||||
|
override val objClass = type
|
||||||
|
|
||||||
|
val objGroups: ObjList by lazy {
|
||||||
|
ObjList(
|
||||||
|
match.groups.map { it?.let { ObjString(it.value) } ?: ObjNull }.toMutableList()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
val objValue by lazy { ObjString(match.value) }
|
||||||
|
|
||||||
|
val objRange: ObjRange by lazy {
|
||||||
|
val r = match.range
|
||||||
|
|
||||||
|
ObjRange(
|
||||||
|
ObjInt(r.first.toLong()),
|
||||||
|
ObjInt(r.last.toLong()),
|
||||||
|
false
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun toString(scope: Scope,calledFromLyng: Boolean): ObjString {
|
||||||
|
return ObjString("RegexMath(${objRange.toString(scope)},${objGroups.toString(scope)})")
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
|
return objGroups.getAt(scope, index)
|
||||||
|
}
|
||||||
|
|
||||||
|
override suspend fun compareTo(scope: Scope, other: Obj): Int {
|
||||||
|
if( other === this) return 0
|
||||||
|
return -2
|
||||||
|
}
|
||||||
|
|
||||||
|
companion object {
|
||||||
|
val type by lazy {
|
||||||
|
object : ObjClass("RegexMatch") {
|
||||||
|
override suspend fun callOn(scope: Scope): Obj {
|
||||||
|
scope.raiseError("RegexMatch can't be constructed directly")
|
||||||
|
}
|
||||||
|
}.apply {
|
||||||
|
addFn("groups") {
|
||||||
|
thisAs<ObjRegexMatch>().objGroups
|
||||||
|
}
|
||||||
|
addFn("value") {
|
||||||
|
thisAs<ObjRegexMatch>().objValue
|
||||||
|
}
|
||||||
|
addFn("range") {
|
||||||
|
thisAs<ObjRegexMatch>().objRange
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -44,9 +44,7 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
|
|
||||||
override fun toString(): String = value
|
override fun toString(): String = value
|
||||||
|
|
||||||
override val asStr: ObjString by lazy { this }
|
override suspend fun inspect(scope: Scope): String {
|
||||||
|
|
||||||
override fun inspect(): String {
|
|
||||||
return "\"$value\""
|
return "\"$value\""
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -54,12 +52,13 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
get() = type
|
get() = type
|
||||||
|
|
||||||
override suspend fun plus(scope: Scope, other: Obj): Obj {
|
override suspend fun plus(scope: Scope, other: Obj): Obj {
|
||||||
return ObjString(value + other.asStr.value)
|
return ObjString(value + other.toString(scope).value)
|
||||||
}
|
}
|
||||||
|
|
||||||
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
override suspend fun getAt(scope: Scope, index: Obj): Obj {
|
||||||
if (index is ObjInt) return ObjChar(value[index.toInt()])
|
when (index) {
|
||||||
if (index is ObjRange) {
|
is ObjInt -> return ObjChar(value[index.toInt()])
|
||||||
|
is ObjRange -> {
|
||||||
val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt()
|
val start = if (index.start == null || index.start.isNull) 0 else index.start.toInt()
|
||||||
val end = if (index.end == null || index.end.isNull) value.length else {
|
val end = if (index.end == null || index.end.isNull) value.length else {
|
||||||
val e = index.end.toInt()
|
val e = index.end.toInt()
|
||||||
@@ -67,7 +66,13 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
}
|
}
|
||||||
return ObjString(value.substring(start, end))
|
return ObjString(value.substring(start, end))
|
||||||
}
|
}
|
||||||
scope.raiseIllegalArgument("String index must be Int or Range")
|
|
||||||
|
is ObjRegex -> {
|
||||||
|
return index.find(this)
|
||||||
|
}
|
||||||
|
|
||||||
|
else -> scope.raiseIllegalArgument("String index must be Int, Regex or Range")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
override fun hashCode(): Int {
|
override fun hashCode(): Int {
|
||||||
@@ -98,6 +103,11 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
return value == other.value
|
return value == other.value
|
||||||
}
|
}
|
||||||
|
|
||||||
|
override suspend fun operatorMatch(scope: Scope, other: Obj): Obj {
|
||||||
|
val re = other.cast<ObjRegex>(scope)
|
||||||
|
return re.operatorMatch(scope, this)
|
||||||
|
}
|
||||||
|
|
||||||
override suspend fun lynonType(): LynonType = LynonType.String
|
override suspend fun lynonType(): LynonType = LynonType.String
|
||||||
|
|
||||||
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
override suspend fun serialize(scope: Scope, encoder: LynonEncoder, lynonType: LynonType?) {
|
||||||
@@ -110,7 +120,8 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
ObjString(decoder.unpackBinaryData().decodeToString())
|
ObjString(decoder.unpackBinaryData().decodeToString())
|
||||||
}.apply {
|
}.apply {
|
||||||
addFn("toInt") {
|
addFn("toInt") {
|
||||||
ObjInt(thisAs<ObjString>().value.toLongOrNull()
|
ObjInt(
|
||||||
|
thisAs<ObjString>().value.toLongOrNull()
|
||||||
?: raiseIllegalArgument("can't convert to int: $thisObj")
|
?: raiseIllegalArgument("can't convert to int: $thisObj")
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
@@ -159,6 +170,25 @@ data class ObjString(val value: String) : Obj() {
|
|||||||
addFn("toReal") {
|
addFn("toReal") {
|
||||||
ObjReal(thisAs<ObjString>().value.toDouble())
|
ObjReal(thisAs<ObjString>().value.toDouble())
|
||||||
}
|
}
|
||||||
|
addFn("trim") {
|
||||||
|
thisAs<ObjString>().value.trim().let(::ObjString)
|
||||||
|
}
|
||||||
|
addFn("matches") {
|
||||||
|
val s = requireOnlyArg<Obj>()
|
||||||
|
val self = thisAs<ObjString>().value
|
||||||
|
ObjBool(
|
||||||
|
when (s) {
|
||||||
|
is ObjRegex -> self.matches(s.regex)
|
||||||
|
is ObjString -> {
|
||||||
|
if (s.value == ".*") true
|
||||||
|
else self.matches(s.value.toRegex())
|
||||||
|
}
|
||||||
|
|
||||||
|
else ->
|
||||||
|
raiseIllegalArgument("can't match ${s.objClass.className}: required Regex or String")
|
||||||
|
}
|
||||||
|
)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -77,9 +77,8 @@ fun Iterable.dropLast(n) {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fun Iterable.takeLast(n) {
|
fun Iterable.takeLast(n) {
|
||||||
val list = this
|
|
||||||
val buffer = RingBuffer(n)
|
val buffer = RingBuffer(n)
|
||||||
for( item in list ) buffer += item
|
for( item in this ) buffer += item
|
||||||
buffer
|
buffer
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -104,5 +103,70 @@ fun Iterable.all(predicate): Bool {
|
|||||||
!any { !predicate(it) }
|
!any { !predicate(it) }
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fun Iterable.sum() {
|
||||||
|
val i = iterator()
|
||||||
|
if( i.hasNext() ) {
|
||||||
|
var result = i.next()
|
||||||
|
while( i.hasNext() ) result += i.next()
|
||||||
|
result
|
||||||
|
}
|
||||||
|
else null
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.sumOf(f) {
|
||||||
|
val i = iterator()
|
||||||
|
if( i.hasNext() ) {
|
||||||
|
var result = f(i.next())
|
||||||
|
while( i.hasNext() ) result += f(i.next())
|
||||||
|
result
|
||||||
|
}
|
||||||
|
else null
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.sorted() {
|
||||||
|
sortedWith { a, b -> a <=> b }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.sortedBy(predicate) {
|
||||||
|
sortedWith { a, b -> predicate(a) <=> predicate(b) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Iterable.shuffled() {
|
||||||
|
toList().apply { shuffle() }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun List.toString() {
|
||||||
|
"[" + joinToString(",") + "]"
|
||||||
|
}
|
||||||
|
|
||||||
|
fun List.sortBy(predicate) {
|
||||||
|
sortWith { a, b -> predicate(a) <=> predicate(b) }
|
||||||
|
}
|
||||||
|
|
||||||
|
fun List.sort() {
|
||||||
|
sortWith { a, b -> a <=> b }
|
||||||
|
}
|
||||||
|
|
||||||
|
class StackTraceEntry(
|
||||||
|
val sourceName: String,
|
||||||
|
val line: Int,
|
||||||
|
val column: Int,
|
||||||
|
val sourceString: String
|
||||||
|
) {
|
||||||
|
fun toString() {
|
||||||
|
"%s:%d:%d: %s"(sourceName, line, column, sourceString.trim())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun Exception.printStackTrace() {
|
||||||
|
println(this)
|
||||||
|
for( entry in stackTrace() ) {
|
||||||
|
println("\tat "+entry)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fun String.re() { Regex(this) }
|
||||||
|
|
||||||
|
|
||||||
""".trimIndent()
|
""".trimIndent()
|
||||||
|
|
||||||
@@ -101,7 +101,6 @@ interface BitOutput {
|
|||||||
val compressed = LZW.compress(source.asUByteArray())
|
val compressed = LZW.compress(source.asUByteArray())
|
||||||
// check that compression is effective including header bits size:
|
// check that compression is effective including header bits size:
|
||||||
if( compressed.size + 2 < source.size * 8L) {
|
if( compressed.size + 2 < source.size * 8L) {
|
||||||
println("write compressed")
|
|
||||||
putBit(1)
|
putBit(1)
|
||||||
// LZW algorithm
|
// LZW algorithm
|
||||||
putBits(0, 2)
|
putBits(0, 2)
|
||||||
|
|||||||
@@ -63,6 +63,19 @@ open class LynonDecoder(val bin: BitInput, val settings: LynonSettings = LynonSe
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Decode any object with [decodeAny] and cast it to [T] or raise Lyng's class cast error
|
||||||
|
* with [Scope.raiseClassCastError].
|
||||||
|
*
|
||||||
|
* @return T typed Lyng object
|
||||||
|
*/
|
||||||
|
suspend inline fun <reified T : Obj> decodeAnyAs(scope: Scope): T {
|
||||||
|
val x = decodeAny(scope)
|
||||||
|
return (x as? T) ?: scope.raiseClassCastError(
|
||||||
|
"Expected ${T::class.simpleName} but got $x"
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
private suspend fun decodeClassObj(scope: Scope): ObjClass {
|
private suspend fun decodeClassObj(scope: Scope): ObjClass {
|
||||||
val className = decodeObject(scope, ObjString.type, null) as ObjString
|
val className = decodeObject(scope, ObjString.type, null) as ObjString
|
||||||
return scope.get(className.value)?.value?.let {
|
return scope.get(className.value)?.value?.let {
|
||||||
|
|||||||
@@ -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())
|
""".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
|
@Test
|
||||||
fun testCharacterRange() = runTest {
|
fun testCharacterRange() = runTest {
|
||||||
eval(
|
eval(
|
||||||
@@ -2006,7 +2035,7 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testThrowFromKotlin() = runTest {
|
fun testThrowFromKotlin() = runTest {
|
||||||
val c = Scope()
|
val c = Script.newScope()
|
||||||
c.addFn("callThrow") {
|
c.addFn("callThrow") {
|
||||||
raiseIllegalArgument("fromKotlin")
|
raiseIllegalArgument("fromKotlin")
|
||||||
}
|
}
|
||||||
@@ -2213,6 +2242,45 @@ class ScriptTest {
|
|||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testParseSpecialVars() {
|
||||||
|
val l = parseLyng("$~".toSource("test$~"))
|
||||||
|
println(l)
|
||||||
|
assertEquals(Token.Type.ID, l[0].type)
|
||||||
|
assertEquals("$~", l[0].value)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testMatchOperator() = runTest {
|
||||||
|
eval("""
|
||||||
|
assert( "abc123".matches(".*\d{3}") )
|
||||||
|
assert( ".*\d{3}".re =~ "abc123" )
|
||||||
|
assert( "abc123" =~ ".*\d{3}".re )
|
||||||
|
assert( "abc123" !~ ".*\d{4}".re )
|
||||||
|
|
||||||
|
"abc123" =~ ".*(\d)(\d)(\d)$".re
|
||||||
|
println($~)
|
||||||
|
assertEquals("1", $~[1])
|
||||||
|
assertEquals("2", $~[2])
|
||||||
|
assertEquals("3", $~[3])
|
||||||
|
assertEquals("abc123", $~[0])
|
||||||
|
""".trimIndent())
|
||||||
|
}
|
||||||
|
|
||||||
|
// @Test
|
||||||
|
// fun testWhenMatch() = runTest {
|
||||||
|
// eval(
|
||||||
|
// """
|
||||||
|
// when("abc123") {
|
||||||
|
// ".*(\d)(\d)(\d)".re -> { x ->
|
||||||
|
// assertEquals("123", x[0])
|
||||||
|
// }
|
||||||
|
// else -> assert(false)
|
||||||
|
// }
|
||||||
|
// """.trimIndent()
|
||||||
|
// )
|
||||||
|
// }
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testWhenSample1() = runTest {
|
fun testWhenSample1() = runTest {
|
||||||
eval(
|
eval(
|
||||||
@@ -2632,7 +2700,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testBufferEncodings() = runTest {
|
fun testBufferEncodings() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
import lyng.buffer
|
import lyng.buffer
|
||||||
|
|
||||||
val b = Buffer("hello")
|
val b = Buffer("hello")
|
||||||
@@ -2647,7 +2716,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
println(b.inspect())
|
println(b.inspect())
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -2871,7 +2941,8 @@ class ScriptTest {
|
|||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun tesFunAnnotation() = runTest {
|
fun tesFunAnnotation() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
|
|
||||||
val exportedSymbols = Map()
|
val exportedSymbols = Map()
|
||||||
|
|
||||||
@@ -2890,7 +2961,8 @@ class ScriptTest {
|
|||||||
assert( exportedSymbols["getBalance"] != null )
|
assert( exportedSymbols["getBalance"] != null )
|
||||||
assertEquals(122, getBalance(1))
|
assertEquals(122, getBalance(1))
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
@@ -2910,12 +2982,14 @@ class ScriptTest {
|
|||||||
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
assertEquals( Color.valueOf("GREEN"), Color.GREEN )
|
||||||
|
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun enumSerializationTest() = runTest {
|
fun enumSerializationTest() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
import lyng.serialization
|
import lyng.serialization
|
||||||
|
|
||||||
enum Color {
|
enum Color {
|
||||||
@@ -2931,12 +3005,14 @@ class ScriptTest {
|
|||||||
assert( e1.size / 1000.0 < 6)
|
assert( e1.size / 1000.0 < 6)
|
||||||
println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
|
println(Lynon.encode( (1..100).map { "RED" } ).toDump() )
|
||||||
|
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun cachedTest() = runTest {
|
fun cachedTest() = runTest {
|
||||||
eval( """
|
eval(
|
||||||
|
"""
|
||||||
|
|
||||||
var counter = 0
|
var counter = 0
|
||||||
var value = cached {
|
var value = cached {
|
||||||
@@ -2949,17 +3025,301 @@ class ScriptTest {
|
|||||||
assertEquals(1, counter)
|
assertEquals(1, counter)
|
||||||
assertEquals("ok", value())
|
assertEquals("ok", value())
|
||||||
assertEquals(1, counter)
|
assertEquals(1, counter)
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
@Test
|
@Test
|
||||||
fun testJoinToString() = runTest {
|
fun testJoinToString() = runTest {
|
||||||
eval("""
|
eval(
|
||||||
|
"""
|
||||||
assertEquals( (1..3).joinToString(), "1 2 3")
|
assertEquals( (1..3).joinToString(), "1 2 3")
|
||||||
assertEquals( (1..3).joinToString(":"), "1:2:3")
|
assertEquals( (1..3).joinToString(":"), "1:2:3")
|
||||||
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
assertEquals( (1..3).joinToString { it * 10 }, "10 20 30")
|
||||||
""".trimIndent())
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testElvisAndThrow() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = assertThrows {
|
||||||
|
null ?: throw "test" + "x"
|
||||||
|
}
|
||||||
|
assertEquals( "testx", x.message)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testElvisAndThrow2() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val t = "112"
|
||||||
|
val x = t ?: run { throw "testx" }
|
||||||
|
}
|
||||||
|
assertEquals( "112", x)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testElvisAndRunThrow() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = assertThrows {
|
||||||
|
null ?: run { throw "testx" }
|
||||||
|
}
|
||||||
|
assertEquals( "testx", x.message)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testNewlinesAnsCommentsInExpressions() = runTest {
|
||||||
|
assertEquals(
|
||||||
|
2, (Scope().eval(
|
||||||
|
"""
|
||||||
|
val e = 1 + 4 -
|
||||||
|
3
|
||||||
|
""".trimIndent()
|
||||||
|
)).toInt()
|
||||||
|
)
|
||||||
|
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = [1,2,3]
|
||||||
|
.map { it * 10 }
|
||||||
|
.map { it + 1 }
|
||||||
|
assertEquals( [11,21,31], x)
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testNotExpressionWithoutWs() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun test() { false }
|
||||||
|
class T(value)
|
||||||
|
assert( !false )
|
||||||
|
assert( !test() )
|
||||||
|
assert( !test() )
|
||||||
|
val t = T(false)
|
||||||
|
assert( !t.value )
|
||||||
|
assert( !if( true ) false else true )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testMultilineFnDeclaration() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun test(
|
||||||
|
x = 1,
|
||||||
|
y = 2
|
||||||
|
) {
|
||||||
|
x * y
|
||||||
|
}
|
||||||
|
assertEquals( 10, test(5) )
|
||||||
|
assertEquals( 42, test(
|
||||||
|
6,
|
||||||
|
7
|
||||||
|
) )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testOverridenListToString() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val x = [1,2,3]
|
||||||
|
assertEquals( "[1,2,3]", x.toString() )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testExceptionSerialization() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
import lyng.serialization
|
||||||
|
val x = [1,2,3]
|
||||||
|
assertEquals( "[1,2,3]", x.toString() )
|
||||||
|
try {
|
||||||
|
require(false)
|
||||||
|
}
|
||||||
|
catch (e) {
|
||||||
|
println(e.stackTrace)
|
||||||
|
e.printStackTrace()
|
||||||
|
val coded = Lynon.encode(e)
|
||||||
|
val decoded = Lynon.decode(coded)
|
||||||
|
assertEquals( e::class, decoded::class )
|
||||||
|
assertEquals( e.stackTrace, decoded.stackTrace )
|
||||||
|
assertEquals( e.message, decoded.message )
|
||||||
|
println("-------------------- e")
|
||||||
|
println(e.toString())
|
||||||
|
println("-------------------- dee")
|
||||||
|
println(decoded.toString())
|
||||||
|
assertEquals( e.toString(), decoded.toString() )
|
||||||
|
}
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testThisInClosure() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
fun Iterable.sum2by(f) {
|
||||||
|
var acc = null
|
||||||
|
for( x in this ) {
|
||||||
|
println(x)
|
||||||
|
println(f(x))
|
||||||
|
acc = acc?.let { acc + f(x) } ?: f(x)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
class T(val coll, val factor) {
|
||||||
|
fun sum() {
|
||||||
|
// here we use ths::T and it must be available:
|
||||||
|
coll.sum2by { it * factor }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals(60, T([1,2,3], 10).sum())
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testThisInFlowClosure() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
class T(val coll, val factor) {
|
||||||
|
fun seq() {
|
||||||
|
flow {
|
||||||
|
for( x in coll ) {
|
||||||
|
emit(x*factor)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assertEquals([10,20,30], T([1,2,3], 10).seq().toList())
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testSum() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
assertEquals(1, [1].sum())
|
||||||
|
assertEquals(null, [].sum())
|
||||||
|
assertEquals(6, [1,2,3].sum())
|
||||||
|
assertEquals(30, [3].sumOf { it * 10 })
|
||||||
|
assertEquals(null, [].sumOf { it * 10 })
|
||||||
|
assertEquals(60, [1,2,3].sumOf { it * 10 })
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testSort() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val coll = [5,4,1,7]
|
||||||
|
assertEquals( [1,4,5,7], coll.sortedWith { a,b -> a <=> b })
|
||||||
|
assertEquals( [1,4,5,7], coll.sorted())
|
||||||
|
assertEquals( [7,5,4,1], coll.sortedBy { -it })
|
||||||
|
assertEquals( [1,4,5,7], coll.sortedBy { -it }.reversed())
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testListSortInPlace() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val l1 = [6,3,1,9]
|
||||||
|
l1.sort()
|
||||||
|
assertEquals( [1,3,6,9], l1)
|
||||||
|
l1.sortBy { -it }
|
||||||
|
assertEquals( [1,3,6,9].reversed(), l1)
|
||||||
|
l1.sort()
|
||||||
|
l1.sortBy { it % 4 }
|
||||||
|
// 1,3,6,9
|
||||||
|
// 1 3 2 1
|
||||||
|
// we hope we got it also stable:
|
||||||
|
assertEquals( [1,9,6,3], l1)
|
||||||
|
"""
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun binarySearchTest() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val coll = [1,2,3,4,5]
|
||||||
|
assertEquals( 2, coll.binarySearch(3) )
|
||||||
|
assertEquals( 0, coll.binarySearch(1) )
|
||||||
|
assertEquals( 4, coll.binarySearch(5) )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun binarySearchTest2() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
val src = (1..50).toList().shuffled()
|
||||||
|
val result = []
|
||||||
|
for( x in src ) {
|
||||||
|
val i = result.binarySearch(x)
|
||||||
|
assert( i < 0 )
|
||||||
|
result.insertAt(-i-1, x)
|
||||||
|
}
|
||||||
|
assertEquals( src.sorted(), result )
|
||||||
|
""".trimIndent()
|
||||||
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
// @Test
|
||||||
|
fun testMinimumOptimization() = runTest {
|
||||||
|
val x = Scope().eval(
|
||||||
|
"""
|
||||||
|
fun naiveCountHappyNumbers() {
|
||||||
|
var count = 0
|
||||||
|
for( n1 in 0..9 )
|
||||||
|
for( n2 in 0..9 )
|
||||||
|
for( n3 in 0..9 )
|
||||||
|
for( n4 in 0..9 )
|
||||||
|
for( n5 in 0..9 )
|
||||||
|
for( n6 in 0..9 )
|
||||||
|
if( n1 + n2 + n3 == n4 + n5 + n6 ) count++
|
||||||
|
count
|
||||||
|
}
|
||||||
|
naiveCountHappyNumbers()
|
||||||
|
""".trimIndent()
|
||||||
|
).toInt()
|
||||||
|
assertEquals(55252, x)
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRegex1() = runTest {
|
||||||
|
eval(
|
||||||
|
"""
|
||||||
|
assert( ! "123".re.matches("abs123def") )
|
||||||
|
assert( ".*123.*".re.matches("abs123def") )
|
||||||
|
// assertEquals( "123", "123".re.find("abs123def")?.value )
|
||||||
|
// assertEquals( "123", "[0-9]{3}".re.find("abs123def")?.value )
|
||||||
|
assertEquals( "123", "\d{3}".re.find("abs123def")?.value )
|
||||||
|
assertEquals( "123", "\\d{3}".re.find("abs123def")?.value )
|
||||||
|
assertEquals( [1,2,3], "\d".re.findAll("abs123def").map { it.value.toInt() } )
|
||||||
|
"""
|
||||||
|
.trimIndent()
|
||||||
|
)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -177,11 +177,11 @@ suspend fun DocTest.test(_scope: Scope? = null) {
|
|||||||
scope.apply {
|
scope.apply {
|
||||||
addFn("println") {
|
addFn("println") {
|
||||||
if( bookMode ) {
|
if( bookMode ) {
|
||||||
println("${currentTest.fileNamePart}:${currentTest.line}> ${args.joinToString(" "){it.asStr.value}}")
|
println("${currentTest.fileNamePart}:${currentTest.line}> ${args.map{it.toString(this).value}.joinToString(" ")}")
|
||||||
}
|
}
|
||||||
else {
|
else {
|
||||||
for ((i, a) in args.withIndex()) {
|
for ((i, a) in args.withIndex()) {
|
||||||
if (i > 0) collectedOutput.append(' '); collectedOutput.append(a.asStr.value)
|
if (i > 0) collectedOutput.append(' '); collectedOutput.append(a.toString(this).value)
|
||||||
collectedOutput.append('\n')
|
collectedOutput.append('\n')
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@@ -194,7 +194,7 @@ suspend fun DocTest.test(_scope: Scope? = null) {
|
|||||||
} catch (e: Throwable) {
|
} catch (e: Throwable) {
|
||||||
error = e
|
error = e
|
||||||
null
|
null
|
||||||
}?.inspect()?.replace(Regex("@\\d+"), "@...")
|
}?.inspect(scope)?.replace(Regex("@\\d+"), "@...")
|
||||||
|
|
||||||
if (bookMode) {
|
if (bookMode) {
|
||||||
if (error != null) {
|
if (error != null) {
|
||||||
@@ -322,4 +322,18 @@ class BookTest {
|
|||||||
runDocTests("../docs/Iterable.md")
|
runDocTests("../docs/Iterable.md")
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testSerialization() = runBlocking {
|
||||||
|
runDocTests("../docs/serialization.md")
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testArray() = runBlocking {
|
||||||
|
runDocTests("../docs/Array.md")
|
||||||
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testRegex() = runBlocking {
|
||||||
|
runDocTests("../docs/Regex.md")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -649,6 +649,48 @@ class LynonTests {
|
|||||||
""".trimIndent())
|
""".trimIndent())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@Test
|
||||||
|
fun testTokenFailure() = runTest {
|
||||||
|
val s = Scope()
|
||||||
|
val t = s.eval(
|
||||||
|
"""
|
||||||
|
import lyng.serialization
|
||||||
|
import lyng.buffer
|
||||||
|
import lyng.time
|
||||||
|
|
||||||
|
class Wallet( id, ownerKey, balance=0, createdAt=Instant.now().truncateToSecond(), isBlocked=false) {
|
||||||
|
|
||||||
|
/*
|
||||||
|
Create new key for the given owner multikey
|
||||||
|
*/
|
||||||
|
static fun new( ownerKey ) {
|
||||||
|
|
||||||
|
// this is per-contract unique id generated and approved by the network.
|
||||||
|
// it is not random, but it _is_ unique, and we use it as a walletId.
|
||||||
|
val newId = Buffer("testid")
|
||||||
|
|
||||||
|
val w = Wallet(newId, ownerKey)
|
||||||
|
println(w)
|
||||||
|
println(w.balance)
|
||||||
|
|
||||||
|
val x = Lynon.encode(Wallet(newId, ownerKey) ).toBuffer()
|
||||||
|
val t = Lynon.decode(x.toBitInput())
|
||||||
|
println(x)
|
||||||
|
println(t)
|
||||||
|
assertEquals(w.balance, t.balance)
|
||||||
|
w
|
||||||
|
}
|
||||||
|
|
||||||
|
}
|
||||||
|
Wallet.new(Buffer("1234"))
|
||||||
|
|
||||||
|
""".trimIndent())
|
||||||
|
println(t)
|
||||||
|
// val bb = lynonEncodeAny(s, t)
|
||||||
|
// val t2 = lynonDecodeAny(s, bb)
|
||||||
|
// println(t2.readField(s, "balance"))
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
Reference in new issue
Block a user