@abaplint/runtime 2.13.45 → 2.13.47

package/build/src/builtin/abs.js

@@ -11,7 +11,7 @@ function abs(input) {
         num_in = parseFloat(input.val);
     }
     else if (input.val instanceof types_1.Float) {
-        num_in = input.val.getRaw();
+        num_in = input.val.getCalculationValue();
     }
     else {
         num_in = parseFloat(input.val.get().toString());

package/build/src/builtin/ceil.js

@@ -11,7 +11,7 @@ function ceil(input) {
         num_in = parseFloat(input.val);
     }
     else if (input.val instanceof types_1.Float) {
-        num_in = input.val.getRaw();
+        num_in = input.val.getCalculationValue();
     }
     else {
         num_in = parseFloat(input.val.get().toString());

package/build/src/builtin/floor.js

@@ -11,7 +11,7 @@ function floor(input) {
         num_in = parseFloat(input.val);
     }
     else if (input.val instanceof types_1.Float) {
-        num_in = input.val.getRaw();
+        num_in = input.val.getCalculationValue();
     }
     else {
         num_in = parseFloat(input.val.get().toString());

package/build/src/builtin/frac.js

@@ -12,8 +12,10 @@ function frac(input) {
     else if (typeof input.val === "string") {
         num_in = parseFloat(input.val);
     }
-    else if (input.val instanceof types_1.DecFloat34
-        || input.val instanceof types_1.Float) {
+    else if (input.val instanceof types_1.Float) {
+        num_in = input.val.getCalculationValue();
+    }
+    else if (input.val instanceof types_1.DecFloat34) {
         num_in = input.val.getRaw();
     }
     else {

package/build/src/builtin/trunc.js

@@ -11,7 +11,7 @@ function trunc(input) {
         num_in = parseFloat(input.val);
     }
     else if (input.val instanceof types_1.Float) {
-        num_in = input.val.getRaw();
+        num_in = input.val.getCalculationValue();
     }
     else {
         num_in = parseFloat(input.val.get().toString());

package/build/src/operators/add.js

@@ -22,16 +22,16 @@ function add(left, right) {
         return new types_1.Integer().set(left.get() + right);
     }
     else if ((left instanceof string_1.String || left instanceof types_1.Character) && isIntegerCharacter(left) && right instanceof types_1.Integer) {
-        return new types_1.Integer().set(Number.parseInt(left.get(), 10) + right.get());
+        return new types_1.Integer().set(Number.parseInt(left.get(), 10) + right.get()).clearIntegerCalculationType();
     }
     else if ((right instanceof string_1.String || right instanceof types_1.Character) && isIntegerCharacter(right) && left instanceof types_1.Integer) {
-        return new types_1.Integer().set(left.get() + Number.parseInt(right.get(), 10));
+        return new types_1.Integer().set(left.get() + Number.parseInt(right.get(), 10)).clearIntegerCalculationType();
     }
     else if ((left instanceof string_1.String || left instanceof types_1.Character)
         && (right instanceof string_1.String || right instanceof types_1.Character)
         && isIntegerCharacter(left)
         && isIntegerCharacter(right)) {
-        return new types_1.Integer().set(Number.parseInt(left.get(), 10) + Number.parseInt(right.get(), 10));
+        return new types_1.Integer().set(Number.parseInt(left.get(), 10) + Number.parseInt(right.get(), 10)).clearIntegerCalculationType();
     }
     else if (left instanceof types_1.Integer8) {
         if (right instanceof types_1.Integer8) {

package/build/src/operators/divide.js

@@ -30,6 +30,16 @@ function divide(left, right) {
         }
     }
     const val = l / r;
-    return new types_1.Float().set(val);
+    const ret = new types_1.Float().set(val);
+    if (isIntegerOperand(left) && isIntegerOperand(right)) {
+        ret.setIntegerCalculationType();
+    }
+    return ret;
+}
+function isIntegerOperand(val) {
+    if (val instanceof types_1.Integer) {
+        return val.isIntegerCalculationType();
+    }
+    return val instanceof types_1.Integer8;
 }
 //# sourceMappingURL=divide.js.map

package/build/src/operators/minus.js

@@ -36,10 +36,10 @@ function minus(left, right) {
         return new types_1.Integer().set(left.get() - right);
     }
     else if ((left instanceof string_1.String || left instanceof types_1.Character) && Number.isInteger(Number(left.get())) && right instanceof types_1.Integer) {
-        return new types_1.Integer().set(Number.parseInt(left.get(), 10) - right.get());
+        return new types_1.Integer().set(Number.parseInt(left.get(), 10) - right.get()).clearIntegerCalculationType();
     }
     else if ((right instanceof string_1.String || right instanceof types_1.Character) && Number.isInteger(Number(right)) && left instanceof types_1.Integer) {
-        return new types_1.Integer().set(left.get() - Number.parseInt(right.get(), 10));
+        return new types_1.Integer().set(left.get() - Number.parseInt(right.get(), 10)).clearIntegerCalculationType();
     }
     return new types_1.Float().set((0, _parse_1.parse)(left) - (0, _parse_1.parse)(right));
 }

package/build/src/operators/multiply.js

@@ -29,11 +29,11 @@ function multiply(left, right) {
     }
     else if ((left instanceof string_1.String || left instanceof types_1.Character) && Number.isInteger(Number(left.get())) && right instanceof types_1.Integer) {
         const val = Number.parseInt(left.get(), 10) * right.get();
-        return new types_1.Integer().set(val);
+        return new types_1.Integer().set(val).clearIntegerCalculationType();
     }
     else if ((right instanceof string_1.String || right instanceof types_1.Character) && Number.isInteger(Number(right)) && left instanceof types_1.Integer) {
         const val = left.get() * Number.parseInt(right.get(), 10);
-        return new types_1.Integer().set(val);
+        return new types_1.Integer().set(val).clearIntegerCalculationType();
     }
     return new types_1.Float().set((0, _parse_1.parse)(left) * (0, _parse_1.parse)(right));
 }

package/build/src/template_formatting.d.ts

@@ -13,5 +13,5 @@ type options = {
     alphaInContext?: any;
     align?: "left" | "right";
 };
-export declare function templateFormatting(source: ICharacter | INumeric, options?: options): string;
+export declare function templateFormatting(source: ICharacter | INumeric | number | string, options?: options): string;
 export {};

package/build/src/template_formatting.js

@@ -50,14 +50,24 @@ function templateFormatting(source, options) {
             text = source.toFixed(source.getDecimals());
         }
     }
+    else if (typeof source === "number" || typeof source === "string") {
+        text = source + "";
+    }
     else {
         text = source.get() + "";
     }
     if (options?.alpha === "out") {
-        text = (0, alpha_1.alphaOut)(source);
+        if (typeof source === "number" || typeof source === "string") {
+            text = text.replace(/^0+/, "");
+        }
+        else {
+            text = (0, alpha_1.alphaOut)(source);
+        }
     }
     else if (options?.alpha === "in") {
-        text = (0, alpha_1.alphaIn)(source, options.alphaInContext);
+        if (typeof source !== "number" && typeof source !== "string") {
+            text = (0, alpha_1.alphaIn)(source, options.alphaInContext);
+        }
     }
     if (options) {
         if (options.currency !== undefined) {

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

@@ -3,11 +3,18 @@ import { ICharacter } from "./_character";
 import { INumeric } from "./_numeric";
 export declare class Float {
     private value;
+    private integerCalculationType;
     private readonly qualifiedName;
     constructor(input?: {
         qualifiedName?: string;
     });
     clone(): Float;
+    /** ABAP calculates in type i if all operands are integers, ie. "3 / 2" is 2. The exact value is
+     * kept here, so assigning to a float or packed target, which raises the calculation type, still
+     * gives the exact result. Consumers without a target type must use getCalculationValue() */
+    setIntegerCalculationType(): Float;
+    /** value as seen by the calculation type, ie. rounded if the calculation type is integer */
+    getCalculationValue(): number;
     getQualifiedName(): string | undefined;
     set(value: INumeric | ICharacter | Hex | string | number): this;
     clear(): void;

package/build/src/types/float.js

@@ -21,6 +21,7 @@ function getNumberParts(x: number) {
 */
 class Float {
     value;
+    integerCalculationType = false;
     qualifiedName;
     constructor(input) {
         this.value = 0;
@@ -31,6 +32,21 @@ class Float {
         n.value = this.value;
         return n;
     }
+    /** ABAP calculates in type i if all operands are integers, ie. "3 / 2" is 2. The exact value is
+     * kept here, so assigning to a float or packed target, which raises the calculation type, still
+     * gives the exact result. Consumers without a target type must use getCalculationValue() */
+    setIntegerCalculationType() {
+        this.integerCalculationType = true;
+        return this;
+    }
+    /** value as seen by the calculation type, ie. rounded if the calculation type is integer */
+    getCalculationValue() {
+        if (this.integerCalculationType === true) {
+            // ABAP rounds half away from zero
+            return this.value < 0 ? -Math.round(-this.value) : Math.round(this.value);
+        }
+        return this.value;
+    }
     getQualifiedName() {
         return this.qualifiedName;
     }

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

@@ -9,10 +9,15 @@ export declare function toInteger(value: string, exception?: boolean): number;
 export declare class Integer implements INumeric {
     private value;
     private constant;
+    private integerCalculationType;
     private readonly qualifiedName;
     constructor(input?: {
         qualifiedName?: string;
     });
+    /** ABAP determines the calculation type from the operand types, character-like operands raise it
+     * above type i even if the intermediate result is integer, ie. "'1.0' * 18 / 16" is not rounded */
+    clearIntegerCalculationType(): Integer;
+    isIntegerCalculationType(): boolean;
     getQualifiedName(): string | undefined;
     clone(): Integer;
     setConstant(): this;

package/build/src/types/integer.js

@@ -33,11 +33,21 @@ function toInteger(value, exception = true) {
 class Integer {
     value;
     constant = false;
+    integerCalculationType = true;
     qualifiedName;
     constructor(input) {
         this.value = 0;
         this.qualifiedName = input?.qualifiedName;
     }
+    /** ABAP determines the calculation type from the operand types, character-like operands raise it
+     * above type i even if the intermediate result is integer, ie. "'1.0' * 18 / 16" is not rounded */
+    clearIntegerCalculationType() {
+        this.integerCalculationType = false;
+        return this;
+    }
+    isIntegerCalculationType() {
+        return this.integerCalculationType;
+    }
     getQualifiedName() {
         return this.qualifiedName;
     }

package/package.json

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