lynglib/build.gradle.kts

@@ -138,7 +138,6 @@ publishing {
     }
 }
 
-
 //mavenPublishing {
 //    publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
 //

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt

@@ -211,32 +211,11 @@ class Compiler(
     private suspend fun parseTerm(): Accessor? {
         var operand: Accessor? = null
 
-        // newlines _before_
-        cc.skipWsTokens()
-
         while (true) {
             val t = cc.next()
             val startPos = t.pos
             when (t.type) {
-//                Token.Type.NEWLINE, Token.Type.SINLGE_LINE_COMMENT, Token.Type.MULTILINE_COMMENT-> {
+                Token.Type.NEWLINE, Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
-//                    continue
-//                }
-
-                // very special case chained calls: call()<NL>.call2 {}.call3()
-                Token.Type.NEWLINE -> {
-                    val saved = cc.savePos()
-                    if( cc.peekNextNonWhitespace().type == Token.Type.DOT) {
-                        // chained call continue from it
-                        continue
-                    } else {
-                        // restore position and stop parsing as a term:
-                        cc.restorePos(saved)
-                        cc.previous()
-                        return operand
-                    }
-                }
-
-                Token.Type.SEMICOLON, Token.Type.EOF, Token.Type.RBRACE, Token.Type.COMMA -> {
                     cc.previous()
                     return operand
                 }
@@ -489,13 +468,7 @@ class Compiler(
                     // range operator
                     val isEndInclusive = t.type == Token.Type.DOTDOT
                     val left = operand
-                    // if it is an open end range, then the end of line could be here that we do not want
+                    val right = parseExpression()
-                    // to skip in parseExpression:
-                    val current = cc.current()
-                    val right = if( current.type == Token.Type.NEWLINE || current.type == Token.Type.SINLGE_LINE_COMMENT)
-                        null
-                    else
-                        parseExpression()
                     operand = Accessor {
                         ObjRange(
                             left?.getter?.invoke(it)?.value ?: ObjNull,
@@ -891,7 +864,7 @@ class Compiler(
 
     suspend fun parseAnnotation(t: Token): (suspend (Scope, ObjString, Statement) -> Statement) {
         val extraArgs = parseArgsOrNull()
-//        println("annotation ${t.value}: args: $extraArgs")
+        println("annotation ${t.value}: args: $extraArgs")
         return { scope, name, body ->
             val extras = extraArgs?.first?.toArguments(scope, extraArgs.second)?.list
             val required = listOf(name, body)
@@ -982,7 +955,7 @@ class Compiler(
 
     private suspend fun parseWhenStatement(): Statement {
         // has a value, when(value) ?
-        var t = cc.nextNonWhitespace()
+        var t = cc.skipWsTokens()
         return if (t.type == Token.Type.LPAREN) {
             // when(value)
             val value = parseStatement() ?: throw ScriptError(cc.currentPos(), "when(value) expected")
@@ -1005,7 +978,7 @@ class Compiler(
 
                 // loop conditions
                 while (true) {
-                    t = cc.nextNonWhitespace()
+                    t = cc.skipWsTokens()
 
                     when (t.type) {
                         Token.Type.IN,
@@ -1218,11 +1191,11 @@ class Compiler(
         cc.skipTokenOfType(Token.Type.LBRACE)
 
         do {
-            val t = cc.nextNonWhitespace()
+            val t = cc.skipWsTokens()
             when (t.type) {
                 Token.Type.ID -> {
                     names += t.value
-                    val t1 = cc.nextNonWhitespace()
+                    val t1 = cc.skipWsTokens()
                     when (t1.type) {
                         Token.Type.COMMA ->
                             continue

lynglib/src/commonMain/kotlin/net/sergeych/lyng/CompilerContext.kt

@@ -39,6 +39,7 @@ class CompilerContext(val tokens: List<Token>) {
     fun next() =
         if (currentIndex < tokens.size) tokens[currentIndex++]
         else Token("", tokens.last().pos, Token.Type.EOF)
+//        throw IllegalStateException("No more tokens")
 
     fun previous() = if (!hasPrevious()) throw IllegalStateException("No previous token") else tokens[--currentIndex]
 
@@ -130,28 +131,6 @@ class CompilerContext(val tokens: List<Token>) {
         previous()
     }
 
-    fun nextNonWhitespace(): Token {
-        while (true) {
-            val t = next()
-            if (t.type !in wstokens) return t
-        }
-    }
-
-    /**
-     * Find next non-whitespace token and return it. The token is not extracted,
-     * is will be returned on [next] call.
-     * @return next non-whitespace token without extracting it from tokens list
-     */
-    fun peekNextNonWhitespace(): Token {
-        while (true) {
-            val t = next()
-            if (t.type !in wstokens) {
-                previous()
-                return t
-            }
-        }
-    }
-
 
     inline fun ifNextIs(typeId: Token.Type, f: (Token) -> Unit): Boolean {
         val t = next()
@@ -228,7 +207,7 @@ class CompilerContext(val tokens: List<Token>) {
         while (current().type in wstokens) {
             next()
         }
-        return current()
+        return next()
     }
 
     companion object {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/obj/Obj.kt

@@ -436,9 +436,6 @@ object ObjNull : Obj() {
     }
 }
 
-/**
- * TODO: get rid of it. Maybe we ise some Lyng inheritance instead
- */
 interface Numeric {
     val longValue: Long
     val doubleValue: Double

lynglib/src/commonTest/kotlin/ScriptTest.kt

@@ -1184,35 +1184,6 @@ class ScriptTest {
         )
     }
 
-    @Test
-    fun testOpenEndRanges2() = runTest {
-        eval(
-            """
-            var r = 5..; var r2 = 6..
-            val r3 = 7.. // open end
-            assert( r::class == Range)
-            assert( r.end == null)
-            assert( r.start == 5)
-            
-            assert( r3::class == Range)
-            assertEquals( r3.end, null)
-            assert( r3.start == 7)
-        """.trimIndent()
-        )
-    }
-
-    @Test
-    fun testOpenEndRanges3() = runTest {
-        eval(
-            """
-            val r3 = 7.. // open end with comment
-            assert( r3::class == Range)
-            assertEquals( r3.end, null)
-            assert( r3.start == 7)
-        """.trimIndent()
-        )
-    }
-
     @Test
     fun testCharacterRange() = runTest {
         eval(
@@ -3020,20 +2991,5 @@ class ScriptTest {
         """.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())
-    }
-
 
 }