Bugfix/zero number literal initialization

rpgJavaInterpreter-core/src/main/kotlin/com/smeup/rpgparser/interpreter/typesystem.kt

@@ -281,7 +281,7 @@ fun Expression.type(): Type {
             NumberType(BigDecimal.valueOf(this.value).precision(), decimalDigits = 0)
         }
         is RealLiteral -> {
-            NumberType(this.value.precision() - this.value.scale(), this.value.scale())
+            NumberType(this.precision - this.value.scale(), this.value.scale())
         }
         is ArrayAccessExpr -> {
             val type = this.array.type().asArray()

rpgJavaInterpreter-core/src/main/kotlin/com/smeup/rpgparser/parsing/ast/expressions.kt

@@ -39,12 +39,21 @@ abstract class Expression(@Transient override val position: Position? = null) :
 abstract class NumberLiteral(@Transient override val position: Position? = null) : Expression(position)
 
 @Serializable
-data class IntLiteral(val value: Long, override val position: Position? = null) : NumberLiteral(position) {
+data class IntLiteral(
+    val value: Long,
+    override val position: Position? = null,
+    val precision: Int = BigDecimal(value).precision()
+) : NumberLiteral(position) {
     override fun render() = value.toString()
     override fun evalWith(evaluator: Evaluator): Value = evaluator.eval(this)
 }
 @Serializable
-data class RealLiteral(@Contextual val value: BigDecimal, override val position: Position? = null) : NumberLiteral(position) {
+data class RealLiteral(
+    @Contextual val value: BigDecimal,
+    override val position: Position? = null,
+    val precision: Int = value.precision()
+) : NumberLiteral(position) {
+
     override fun render() = value.toString()
     override fun evalWith(evaluator: Evaluator): Value = evaluator.eval(this)
 }

rpgJavaInterpreter-core/src/main/kotlin/com/smeup/rpgparser/parsing/parsetreetoast/expressions.kt

@@ -85,30 +85,31 @@ internal fun RpgParser.LiteralContext.toAst(conf: ToAstConfiguration = ToAstConf
 internal fun RpgParser.NumberContext.toAst(conf: ToAstConfiguration = ToAstConfiguration()): NumberLiteral {
     val position = this.toPosition(conf.considerPosition)
     require(this.NumberPart().isEmpty()) { "Number not empty $position" }
-    val text = (this.MINUS()?.text ?: "") + this.NUMBER().text
-
-    // When assigning a value to a numeric field we could either use
-    // a comma or a dot as decimal separators
-
-    // TODO Rifattorizzare con literalToNumber(text, position)
-    return when {
-        text.contains('.') -> {
-            text.toRealLiteral(position, Locale.US)
-        }
-        text.contains(',') -> {
-            text.toRealLiteral(position, Locale.ITALIAN)
-        }
-        else -> IntLiteral(text.toLong(), position)
-    }
+    return literalToNumber(this.text, position)
 }
 
 fun String.toRealLiteral(position: Position?, locale: Locale): RealLiteral {
     val nf = NumberFormat.getNumberInstance(locale)
     val formatter = nf as DecimalFormat
     formatter.isParseBigDecimal = true
+    val bd = (formatter.parse(this) as BigDecimal)
+    // in case of zero precision returned by big decimal il always 1
+    val precision = if (bd.toDouble() == 0.0) {
+        this.replace(Regex("[^0-9]"), "").length
+    } else {
+        bd.precision()
+    }
+    return RealLiteral(value = bd, position = position, precision = precision)
+}
 
-    val bd = formatter.parse(this) as BigDecimal
-    return RealLiteral(bd, position)
+fun String.toIntLiteral(position: Position?): IntLiteral {
+    val value = this.toLong()
+    val precision = if (value == 0L) {
+        this.replace(Regex("[^0-9]"), "").length
+    } else {
+        BigDecimal(value).precision()
+    }
+    return IntLiteral(value = value, position = position, precision = precision)
 }
 
 internal fun RpgParser.IdentifierContext.toAst(conf: ToAstConfiguration = ToAstConfiguration()): Expression {

rpgJavaInterpreter-core/src/main/kotlin/com/smeup/rpgparser/parsing/parsetreetoast/misc.kt

@@ -630,7 +630,7 @@ internal fun FactorContentContext.toAst(conf: ToAstConfiguration): Expression {
 fun literalToNumber(
     text: String,
     position: Position?
-): Expression {
+): NumberLiteral {
     // fix minus at right
     val value = if (text.endsWith('-')) {
         "-" + text.replaceFirst("-", "")
@@ -647,7 +647,7 @@ fun literalToNumber(
             value.toRealLiteral(position, Locale.ITALIAN)
         }
         else -> {
-            IntLiteral(value.toLong(), position)
+            value.toIntLiteral(position)
         }
     }
 }

rpgJavaInterpreter-core/src/test/kotlin/com/smeup/rpgparser/parsing/ast/ExpressionsTest.kt

@@ -1,9 +1,11 @@
 package com.smeup.rpgparser.parsing.ast
 
-import com.smeup.rpgparser.*
+import com.smeup.rpgparser.assertExpressionCanBeParsed
+import com.smeup.rpgparser.dataRef
 import com.smeup.rpgparser.parsing.parsetreetoast.ToAstConfiguration
 import com.smeup.rpgparser.parsing.parsetreetoast.toAst
 import com.strumenta.kolasu.model.ReferenceByName
+import java.math.BigDecimal
 import kotlin.test.Ignore
 import kotlin.test.assertEquals
 import org.junit.Test as test
@@ -144,4 +146,20 @@ class ExpressionsTest {
     @test fun parseIndicatorsInParenthesis() {
         assertExpressionCanBeParsed("X=*IN(01)")
     }
+
+    @test fun intLiteralParsingNumberWithPrecision() {
+        assertEquals(IntLiteral(value = 100, precision = 3), expression("100"))
+    }
+
+    @test fun intLiteralParsingZeroWithPrecision() {
+        assertEquals(IntLiteral(value = 0, precision = 3), expression("000"))
+    }
+
+    @test fun realLiteralParsingNumberWithPrecision() {
+        assertEquals(RealLiteral(value = BigDecimal("100.00"), precision = 5), expression("100.00"))
+    }
+
+    @test fun realLiteralParsingZeroWithPrecision() {
+        assertEquals(RealLiteral(value = BigDecimal("0.00"), precision = 3), expression("0.00"))
+    }
 }