Perf/misc ds improvements

rpgJavaInterpreter-core/src/main/kotlin/com/smeup/rpgparser/execution/Configuration.kt

@@ -331,6 +331,23 @@ data class JarikoCallback(
      */
     var finishRpgTrace: (() -> Unit) = {
         // Defaults to a no-op
+    },
+
+    /**
+     * Creates a `DataStructValueBuilder` based on the provided value and data structure type.
+     * The default implementation creates an `IndexedStringBuilder` for data structures with 100 or more fields
+     * and all fields are arrays, elsewhere it creates a `StringBuilderWrapper`.
+     * @param value The string value to be used for the data structure.
+     * @param type The data structure type which defines the fields.
+     * @return A `DataStructValueBuilder` instance.
+     */
+    var createDataStructValueBuilder: ((value: String, type: DataStructureType) -> DataStructValueBuilder) = { value, type ->
+        val totalFields = type.totalFields()
+        if (totalFields >= 100 && type.containsOnlyArrays()) {
+            IndexedStringBuilder(value = value, chunksSize = value.length / totalFields)
+        } else {
+            StringBuilderWrapper(value)
+        }
     }
 )
 

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

@@ -308,7 +308,7 @@ fun Type.lowValue(): Value {
         is ArrayType -> createArrayValue(this.element, this.nElements) { coerce(LowValValue, this.element) }
         is DataStructureType -> {
             val fields = this.fields.associateWith { field -> field.type.lowValue() }
-            DataStructValue.fromFields(fields)
+            DataStructValue.fromFields(fields = fields, type = this)
         }
         is BooleanType -> BooleanValue.FALSE
         is RecordFormatType -> BlanksValue
@@ -323,7 +323,7 @@ fun Type.hiValue(): Value {
         is ArrayType -> createArrayValue(this.element, this.nElements) { coerce(HiValValue, this.element) }
         is DataStructureType -> {
             val fields = this.fields.associateWith { field -> field.type.hiValue() }
-            DataStructValue.fromFields(fields)
+            DataStructValue.fromFields(fields = fields, type = this)
         }
         is BooleanType -> BooleanValue.TRUE
         is RecordFormatType -> BlanksValue

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

@@ -29,6 +29,7 @@ import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
 import java.math.BigDecimal
+import java.util.*
 
 @Serializable
 abstract class AbstractDataDefinition(
@@ -166,7 +167,7 @@ data class FileDefinition private constructor(
 
     var internalFormatName: String? = null
         set(value) {
-            field = value?.toUpperCase()
+            field = value?.uppercase(Locale.getDefault())
         }
 
     private var fieldNameToDataDefinitionName = mutableMapOf<String, String>()
@@ -505,15 +506,15 @@ fun encodeBinary(inValue: BigDecimal, size: Int): String {
 
         buffer[0] = (lsb and 0x0000FFFF).toByte()
 
-        return buffer[0].toChar().toString()
+        return buffer[0].toInt().toChar().toString()
     }
 
     if (size == 2) {
 
         buffer[0] = ((lsb shr 8) and 0x000000FF).toByte()
         buffer[1] = (lsb and 0x000000FF).toByte()
 
-        return buffer[1].toChar().toString() + buffer[0].toChar().toString()
+        return buffer[1].toInt().toChar().toString() + buffer[0].toInt().toChar().toString()
     }
     if (size == 4) {
 
@@ -522,7 +523,8 @@ fun encodeBinary(inValue: BigDecimal, size: Int): String {
         buffer[2] = ((lsb shr 8) and 0x0000FFFF).toByte()
         buffer[3] = (lsb and 0x0000FFFF).toByte()
 
-        return buffer[3].toChar().toString() + buffer[2].toChar().toString() + buffer[1].toChar().toString() + buffer[0].toChar().toString()
+        return buffer[3].toInt().toChar().toString() + buffer[2].toInt().toChar().toString() + buffer[1].toInt()
+            .toChar().toString() + buffer[0].toInt().toChar().toString()
     }
     if (size == 8) {
         val llsb = inValue.toLong()
@@ -535,8 +537,10 @@ fun encodeBinary(inValue: BigDecimal, size: Int): String {
         buffer[6] = ((llsb shr 8) and 0x0000FFFF).toByte()
         buffer[7] = (llsb and 0x0000FFFF).toByte()
 
-        return buffer[7].toChar().toString() + buffer[6].toChar().toString() + buffer[5].toChar().toString() + buffer[4].toChar().toString() +
-            buffer[3].toChar().toString() + buffer[2].toChar().toString() + buffer[1].toChar().toString() + buffer[0].toChar().toString()
+        return buffer[7].toInt().toChar().toString() + buffer[6].toInt().toChar().toString() + buffer[5].toInt()
+            .toChar().toString() + buffer[4].toInt().toChar().toString() +
+            buffer[3].toInt().toChar().toString() + buffer[2].toInt().toChar().toString() + buffer[1].toInt().toChar().toString() + buffer[0].toInt()
+            .toChar().toString()
     }
     TODO("encode binary for $size not implemented")
 }
@@ -552,39 +556,39 @@ fun encodeUnsigned(inValue: BigDecimal, size: Int): String {
 fun decodeBinary(value: String, size: Int): BigDecimal {
     if (size == 1) {
         var number: Long = 0x0000000
-        if (value[0].toInt() and 0x0010 != 0) {
+        if (value[0].code and 0x0010 != 0) {
             number = 0x00000000
         }
-        number += (value[0].toInt() and 0x00FF)
+        number += (value[0].code and 0x00FF)
         return BigDecimal(number.toInt().toString())
     }
 
     if (size == 2) {
         var number: Long = 0x0000000
-        if (value[1].toInt() and 0x8000 != 0) {
+        if (value[1].code and 0x8000 != 0) {
             number = 0xFFFF0000
         }
-        number += (value[0].toInt() and 0x00FF) + ((value[1].toInt() and 0x00FF) shl 8)
+        number += (value[0].code and 0x00FF) + ((value[1].code and 0x00FF) shl 8)
         return BigDecimal(number.toInt().toString())
     }
 
     if (size == 4) {
-        val number = (value[0].toLong() and 0x00FF) +
-            ((value[1].toLong() and 0x00FF) shl 8) +
-            ((value[2].toLong() and 0x00FF) shl 16) +
-            ((value[3].toLong() and 0x00FF) shl 24)
+        val number = (value[0].code.toLong() and 0x00FF) +
+            ((value[1].code.toLong() and 0x00FF) shl 8) +
+            ((value[2].code.toLong() and 0x00FF) shl 16) +
+            ((value[3].code.toLong() and 0x00FF) shl 24)
 
         return BigDecimal(number.toInt().toString())
     }
     if (size == 8) {
-        val number = (value[0].toLong() and 0x00FF) +
-            ((value[1].toLong() and 0x00FF) shl 8) +
-            ((value[2].toLong() and 0x00FF) shl 16) +
-            ((value[3].toLong() and 0x00FF) shl 24) +
-            ((value[4].toLong() and 0x00FF) shl 32) +
-            ((value[5].toLong() and 0x00FF) shl 40) +
-            ((value[6].toLong() and 0x00FF) shl 48) +
-            ((value[7].toLong() and 0x00FF) shl 56)
+        val number = (value[0].code.toLong() and 0x00FF) +
+            ((value[1].code.toLong() and 0x00FF) shl 8) +
+            ((value[2].code.toLong() and 0x00FF) shl 16) +
+            ((value[3].code.toLong() and 0x00FF) shl 24) +
+            ((value[4].code.toLong() and 0x00FF) shl 32) +
+            ((value[5].code.toLong() and 0x00FF) shl 40) +
+            ((value[6].code.toLong() and 0x00FF) shl 48) +
+            ((value[7].code.toLong() and 0x00FF) shl 56)
 
         return BigDecimal(number.toInt().toString())
     }
@@ -594,35 +598,35 @@ fun decodeBinary(value: String, size: Int): BigDecimal {
 fun decodeInteger(value: String, size: Int): BigDecimal {
     if (size == 1) {
         var number = 0x0000000
-        number += (value[0].toByte())
+        number += (value[0].code.toByte())
         return BigDecimal(number.toString())
     }
 
     if (size == 2) {
         var number: Long = 0x0000000
-        if (value[1].toInt() and 0x8000 != 0) {
+        if (value[1].code and 0x8000 != 0) {
             number = 0xFFFF0000
         }
-        number += (value[0].toInt() and 0x00FF) + ((value[1].toInt() and 0x00FF) shl 8)
+        number += (value[0].code and 0x00FF) + ((value[1].code and 0x00FF) shl 8)
         return BigDecimal(number.toInt().toString())
     }
     if (size == 4) {
-        val number = (value[0].toLong() and 0x00FF) +
-            ((value[1].toLong() and 0x00FF) shl 8) +
-            ((value[2].toLong() and 0x00FF) shl 16) +
-            ((value[3].toLong() and 0x00FF) shl 24)
+        val number = (value[0].code.toLong() and 0x00FF) +
+            ((value[1].code.toLong() and 0x00FF) shl 8) +
+            ((value[2].code.toLong() and 0x00FF) shl 16) +
+            ((value[3].code.toLong() and 0x00FF) shl 24)
 
         return BigDecimal(number.toInt().toString())
     }
     if (size == 8) {
-        val number = (value[0].toLong() and 0x00FF) +
-            ((value[1].toLong() and 0x00FF) shl 8) +
-            ((value[2].toLong() and 0x00FF) shl 16) +
-            ((value[3].toLong() and 0x00FF) shl 24) +
-            ((value[4].toLong() and 0x00FF) shl 32) +
-            ((value[5].toLong() and 0x00FF) shl 40) +
-            ((value[6].toLong() and 0x00FF) shl 48) +
-            ((value[7].toLong() and 0x00FF) shl 56)
+        val number = (value[0].code.toLong() and 0x00FF) +
+            ((value[1].code.toLong() and 0x00FF) shl 8) +
+            ((value[2].code.toLong() and 0x00FF) shl 16) +
+            ((value[3].code.toLong() and 0x00FF) shl 24) +
+            ((value[4].code.toLong() and 0x00FF) shl 32) +
+            ((value[5].code.toLong() and 0x00FF) shl 40) +
+            ((value[6].code.toLong() and 0x00FF) shl 48) +
+            ((value[7].code.toLong() and 0x00FF) shl 56)
 
         return BigDecimal(number.toString())
     }
@@ -633,40 +637,40 @@ fun decodeUnsigned(value: String, size: Int): BigDecimal {
 
     if (size == 1) {
         var number: Long = 0x0000000
-        if (value[0].toInt() and 0x0010 != 0) {
+        if (value[0].code and 0x0010 != 0) {
             number = 0x00000000
         }
-        number += (value[0].toInt() and 0x00FF)
+        number += (value[0].code and 0x00FF)
         return BigDecimal(number.toInt().toString())
     }
 
     if (size == 2) {
         var number: Long = 0x0000000
-        if (value[1].toInt() and 0x1000 != 0) {
+        if (value[1].code and 0x1000 != 0) {
             number = 0xFFFF0000
         }
-        number += (value[0].toInt() and 0x00FF) + ((value[1].toInt() and 0x00FF) shl 8)
+        number += (value[0].code and 0x00FF) + ((value[1].code and 0x00FF) shl 8)
         // make sure you count onlu 16 bits
         number = number and 0x0000FFFF
         return BigDecimal(number.toString())
     }
     if (size == 4) {
-        val number = (value[0].toLong() and 0x00FF) +
-            ((value[1].toLong() and 0x00FF) shl 8) +
-            ((value[2].toLong() and 0x00FF) shl 16) +
-            ((value[3].toLong() and 0x00FF) shl 24)
+        val number = (value[0].code.toLong() and 0x00FF) +
+            ((value[1].code.toLong() and 0x00FF) shl 8) +
+            ((value[2].code.toLong() and 0x00FF) shl 16) +
+            ((value[3].code.toLong() and 0x00FF) shl 24)
 
         return BigDecimal(number.toString())
     }
     if (size == 8) {
-        val number = (value[0].toLong() and 0x00FF) +
-            ((value[1].toLong() and 0x00FF) shl 8) +
-            ((value[2].toLong() and 0x00FF) shl 16) +
-            ((value[3].toLong() and 0x00FF) shl 24) +
-            ((value[4].toLong() and 0x00FF) shl 32) +
-            ((value[5].toLong() and 0x00FF) shl 40) +
-            ((value[6].toLong() and 0x00FF) shl 48) +
-            ((value[7].toLong() and 0x00FF) shl 56)
+        val number = (value[0].code.toLong() and 0x00FF) +
+            ((value[1].code.toLong() and 0x00FF) shl 8) +
+            ((value[2].code.toLong() and 0x00FF) shl 16) +
+            ((value[3].code.toLong() and 0x00FF) shl 24) +
+            ((value[4].code.toLong() and 0x00FF) shl 32) +
+            ((value[5].code.toLong() and 0x00FF) shl 40) +
+            ((value[6].code.toLong() and 0x00FF) shl 48) +
+            ((value[7].code.toLong() and 0x00FF) shl 56)
 
         return BigDecimal(number.toInt().toString())
     }
@@ -685,7 +689,7 @@ fun encodeToZoned(inValue: BigDecimal, digits: Int, scale: Int): String {
     val sign = inValue.signum()
 
     inChars.forEachIndexed { index, char ->
-        val digit = char.toInt()
+        val digit = char.code
         buffer[index] = digit
     }
     if (sign < 0) {
@@ -708,11 +712,11 @@ fun decodeFromZoned(value: String, digits: Int, scale: Int): BigDecimal {
         when {
             it.isDigit() -> builder.append(it)
             else -> {
-                if (it.toInt() == 0) {
+                if (it.code == 0) {
                     builder.append('0')
                 } else {
                     builder.insert(0, '-')
-                    builder.append((it.toInt() - 0x0049 + 0x0030).toChar())
+                    builder.append((it.code - 0x0049 + 0x0030).toChar())
                 }
             }
         }
@@ -741,16 +745,16 @@ fun encodeToDS(inValue: BigDecimal, digits: Int, scale: Int): String {
 
     // place all the digits except last one
     while (inPosition < inChars.size - 1) {
-        firstNibble = ((inChars[inPosition++].toInt()) and 0x000F) shl 4
-        secondNibble = (inChars[inPosition++].toInt()) and 0x000F
+        firstNibble = ((inChars[inPosition++].code) and 0x000F) shl 4
+        secondNibble = (inChars[inPosition++].code) and 0x000F
         buffer[offset++] = (firstNibble + secondNibble)
     }
 
     // place last digit and sign nibble
     firstNibble = if (inPosition == inChars.size) {
         0x00F0
     } else {
-        (inChars[inChars.size - 1].toInt()) and 0x000F shl 4
+        (inChars[inChars.size - 1].code) and 0x000F shl 4
     }
     if (sign != -1) {
         buffer[offset] = (firstNibble + 0x000F)
@@ -767,47 +771,43 @@ fun encodeToDS(inValue: BigDecimal, digits: Int, scale: Int): String {
 }
 
 fun decodeFromDS(value: String, digits: Int, scale: Int): BigDecimal {
-    val buffer = IntArray(value.length)
-    for (i in value.indices) {
-        buffer[i] = value[i].toInt()
-    }
+    return try {
+        value.toBigDecimal()
+    } catch (e: Exception) {
+        val buffer = IntArray(value.length)
+        for (i in value.indices) {
+            buffer[i] = value[i].code
+        }
 
-    var sign = ""
-    var number = ""
-    var nibble = ((buffer[buffer.size - 1]) and 0x0F)
-    if (nibble == 0x0B || nibble == 0x0D) {
-        sign = "-"
-    }
+        val sign = StringBuilder()
+        val number = StringBuilder()
+        var nibble = (buffer[buffer.size - 1] and 0x0F)
+        if (nibble == 0x0B || nibble == 0x0D) {
+            sign.append("-")
+        }
 
-    var offset = 0
-    while (offset < (buffer.size - 1)) {
-        nibble = (buffer[offset] and 0xFF).ushr(4)
-        number += Character.toString((nibble or 0x30).toChar())
-        nibble = buffer[offset] and 0x0F or 0x30
-        number += Character.toString((nibble or 0x30).toChar())
+        var offset = 0
+        while (offset < (buffer.size - 1)) {
+            nibble = (buffer[offset] and 0xFF).ushr(4)
+            number.append((nibble or 0x30).toChar())
+            nibble = buffer[offset] and 0x0F or 0x30
+            number.append((nibble or 0x30).toChar())
 
-        offset++
-    }
+            offset++
+        }
 
-    // read last digit
-    nibble = (buffer[offset] and 0xFF).ushr(4)
-    if (nibble <= 9) {
-        number += Character.toString((nibble or 0x30).toChar())
-    }
-    // adjust the scale
-    if (scale > 0 && number != "0") {
-        val len = number.length
-        number = buildString {
-            append(number.substring(0, len - scale))
-            append(".")
-            append(number.substring(len - scale, len))
+// read last digit
+        nibble = (buffer[offset] and 0xFF).ushr(4)
+        if (nibble <= 9) {
+            number.append((nibble or 0x30).toChar())
         }
-    }
-    number = sign + number
-    return try {
-        value.toBigDecimal()
-    } catch (e: Exception) {
-        number.toBigDecimal()
+// adjust the scale
+        if (scale > 0 && number.toString() != "0") {
+            val len = number.length
+            number.insert(len - scale, ".")
+        }
+        number.insert(0, sign)
+        number.toString().toBigDecimal()
     }
 }