@abaplint/runtime 2.13.36 → 2.13.38

package/build/src/statements/write.js

@@ -44,14 +44,13 @@ class WriteStatement {
                 }
             }
             else if (source instanceof types_1.Packed) {
-                let num = source.get();
-                let decimals = source.getDecimals();
                 if (NO_DEICMAL_CURRENCIES.includes(options?.currency?.get().trimEnd() || "")) {
                     // todo: more work needed here,
-                    num = num * 100;
-                    decimals = 0;
+                    result = (source.get() * 100).toFixed(0).replace(".", ",");
+                }
+                else {
+                    result = source.toFixed(source.getDecimals()).replace(".", ",");
                 }
-                result = num.toFixed(decimals).replace(".", ",");
                 right = true;
             }
             else {

package/build/src/template_formatting.js

@@ -44,10 +44,10 @@ function templateFormatting(source, options) {
     }
     else if (source instanceof types_1.Packed) {
         if (options?.decimals) {
-            text = source.get().toFixed(options.decimals);
+            text = source.toFixed(options.decimals);
         }
         else {
-            text = source.get().toFixed(source.getDecimals());
+            text = source.toFixed(source.getDecimals());
         }
     }
     else {

package/build/src/types/packed.d.ts

@@ -11,10 +11,12 @@ export declare class Packed implements INumeric {
     });
     clone(): Packed;
     getQualifiedName(): string | undefined;
-    private round;
+    private numberToScaled;
+    private stringToScaled;
     set(value: INumeric | number | string): this;
     getLength(): number;
     getDecimals(): number;
+    toFixed(decimals: number): string;
     clear(): void;
     get(): number;
 }

package/build/src/types/packed.js

@@ -4,15 +4,42 @@ exports.Packed = void 0;
 const float_1 = require("./float");
 const throw_error_1 = require("../throw_error");
 const integer8_1 = require("./integer8");
-const digits = new RegExp(/^\s*-?\+?\d*\.?\d* *$/i);
+const digits = new RegExp(/^\s*-?\+?\d*\.?\d*(?:E[+-]?\d+)? *$/i);
+function pow10(exp) {
+    return 10n ** BigInt(exp);
+}
+// rescale a non-negative magnitude from fromScale to toScale decimal places,
+// rounding half away from zero
+function rescale(mag, fromScale, toScale) {
+    if (toScale >= fromScale) {
+        return mag * pow10(toScale - fromScale);
+    }
+    const div = pow10(fromScale - toScale);
+    const q = mag / div;
+    const r = mag % div;
+    return r * 2n >= div ? q + 1n : q;
+}
+// format a non-negative magnitude at the given scale as a decimal string
+function formatMag(mag, scale) {
+    let s = mag.toString();
+    if (scale === 0) {
+        return s;
+    }
+    while (s.length <= scale) {
+        s = "0" + s;
+    }
+    const intPart = s.slice(0, s.length - scale);
+    const fracPart = s.slice(s.length - scale);
+    return intPart + "." + fracPart;
+}
 class Packed {
-    // todo: change this to bigint to get the proper precision? for larger than maxsafeint
+    // value holds the number scaled by 10^decimals, as a bigint, to keep full precision
     value;
     length;
     decimals;
     qualifiedName;
     constructor(input) {
-        this.value = 0;
+        this.value = 0n;
         this.length = 666;
         if (input?.length) {
             this.length = input.length;
@@ -31,29 +58,60 @@ class Packed {
     getQualifiedName() {
         return this.qualifiedName;
     }
-    round(value, places) {
-        // @ts-ignore
-        return +(Math.round(value + "e+" + places) + "e-" + places);
+    numberToScaled(value) {
+        const factor = Math.pow(10, this.decimals);
+        return BigInt(Math.round(value * factor));
+    }
+    stringToScaled(input) {
+        let str = input.trim();
+        let negative = false;
+        while (str.length > 0 && (str[0] === "+" || str[0] === "-")) {
+            if (str[0] === "-") {
+                negative = true;
+            }
+            str = str.slice(1);
+        }
+        if (/[eE]/.test(str)) {
+            // scientific notation, fall back to floating point parsing
+            return this.numberToScaled(parseFloat((negative ? "-" : "") + str));
+        }
+        let intPart = str;
+        let fracPart = "";
+        const dot = str.indexOf(".");
+        if (dot >= 0) {
+            intPart = str.slice(0, dot);
+            fracPart = str.slice(dot + 1);
+        }
+        if (intPart === "") {
+            intPart = "0";
+        }
+        const kept = fracPart.slice(0, this.decimals).padEnd(this.decimals, "0");
+        let scaled = BigInt(intPart + kept);
+        // round half up based on the first dropped fractional digit
+        if (fracPart.length > this.decimals && fracPart[this.decimals] >= "5") {
+            scaled += 1n;
+        }
+        return negative ? -scaled : scaled;
     }
     set(value) {
         if (typeof value === "number") {
-            this.value = value;
+            this.value = this.numberToScaled(value);
         }
         else if (typeof value === "string") {
             if (value.trim().length === 0) {
-                this.value = 0;
+                this.value = 0n;
                 return this;
             }
             else if (digits.test(value) === false) {
                 (0, throw_error_1.throwError)("CX_SY_CONVERSION_NO_NUMBER");
             }
-            this.value = this.round(parseFloat(value), this.decimals);
+            this.value = this.stringToScaled(value);
         }
         else if (value instanceof integer8_1.Integer8) {
-            this.value = Number(value.get());
+            this.value = value.get() * pow10(this.decimals);
         }
         else if (value instanceof float_1.Float) {
-            this.value = this.round(value.getRaw(), this.decimals);
+            this.value = this.numberToScaled(value.getRaw());
         }
         else {
             this.set(value.get());
@@ -66,11 +124,20 @@ class Packed {
     getDecimals() {
         return this.decimals;
     }
+    // returns the value as a fixed decimal string with the given number of
+    // decimals, keeping full precision (unlike get() which is limited to double)
+    toFixed(decimals) {
+        const negative = this.value < 0n;
+        const mag = negative ? -this.value : this.value;
+        const scaled = rescale(mag, this.decimals, decimals);
+        const formatted = formatMag(scaled, decimals);
+        return (negative ? "-" : "") + formatted;
+    }
     clear() {
-        this.value = 0;
+        this.value = 0n;
     }
     get() {
-        return this.value;
+        return Number(this.value) / Math.pow(10, this.decimals);
     }
 }
 exports.Packed = Packed;

package/build/src/types/string.js

@@ -45,9 +45,9 @@ class String {
             this.value = value.getCharacter().trimEnd();
         }
         else if (value instanceof packed_1.Packed) {
-            const lv_sign = value.get() >= 0 ? " " : "-";
-            this.value = Math.abs(value.get()).toFixed(value.getDecimals());
-            this.value += lv_sign;
+            const fixed = value.toFixed(value.getDecimals());
+            const lv_sign = fixed.startsWith("-") ? "-" : " ";
+            this.value = (fixed.startsWith("-") ? fixed.slice(1) : fixed) + lv_sign;
         }
         else if (value instanceof integer_1.Integer) {
             const lv_sign = value.get() >= 0 ? " " : "-";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "2.13.36",
+  "version": "2.13.38",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",