@abaplint/runtime 2.13.93 → 2.13.94

package/build/src/builtin/_extremum.d.ts

@@ -0,0 +1,9 @@
+import { DecFloat34, Float, Integer, Integer8, Packed } from "../types";
+import { INumeric } from "../types/_numeric";
+export type ExtremumArgument = number | INumeric | undefined;
+/** nmax( ) and nmin( ): the result has the calculation type of the arguments,
+ * as an arithmetic expression would determine it - decfloat34 before f before
+ * p before int8 before i. So nmin( val1 = i1 val2 = i2 ) is an i, which DO
+ * nmin( ... ) TIMES and every other integer position rely on, and a p result
+ * keeps the most decimals of its arguments. */
+export declare function extremum(args: ExtremumArgument[], isBetter: (candidate: number, best: number) => boolean): Float | Integer8 | Integer | DecFloat34 | Packed;

package/build/src/builtin/_extremum.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extremum = extremum;
+const _parse_1 = require("../operators/_parse");
+const types_1 = require("../types");
+// the calculation types in the order an arithmetic expression ranks them
+const INT = 0;
+const INT8 = 1;
+const PACKED = 2;
+const FLOAT = 3;
+const DECFLOAT = 4;
+/** nmax( ) and nmin( ): the result has the calculation type of the arguments,
+ * as an arithmetic expression would determine it - decfloat34 before f before
+ * p before int8 before i. So nmin( val1 = i1 val2 = i2 ) is an i, which DO
+ * nmin( ... ) TIMES and every other integer position rely on, and a p result
+ * keeps the most decimals of its arguments. */
+function extremum(args, isBetter) {
+    let best = undefined;
+    let bestValue = 0;
+    let type = INT;
+    let decimals = 0;
+    for (let arg of args) {
+        if (arg === undefined) {
+            continue;
+        }
+        if (arg instanceof types_1.FieldSymbol) {
+            arg = arg.getPointer();
+        }
+        if (arg instanceof types_1.DecFloat34) {
+            type = Math.max(type, DECFLOAT);
+        }
+        else if (arg instanceof types_1.Float) {
+            type = Math.max(type, FLOAT);
+        }
+        else if (arg instanceof types_1.Packed) {
+            type = Math.max(type, PACKED);
+            decimals = Math.max(decimals, arg.getDecimals());
+        }
+        else if (arg instanceof types_1.Integer8) {
+            type = Math.max(type, INT8);
+        }
+        else if (arg instanceof types_1.Integer || (typeof arg === "number" && Number.isInteger(arg))) {
+            // i, the lowest type
+        }
+        else {
+            // character-like and other arguments, as before: f
+            type = Math.max(type, FLOAT);
+        }
+        const value = (0, _parse_1.parse)(arg);
+        if (best === undefined || isBetter(value, bestValue)) {
+            best = arg;
+            bestValue = value;
+        }
+    }
+    switch (type) {
+        case DECFLOAT:
+            return new types_1.DecFloat34().set(bestValue);
+        case FLOAT:
+            return new types_1.Float().set(bestValue);
+        case PACKED:
+            if (best instanceof types_1.Packed) {
+                // through the digits, not through a binary float
+                return new types_1.Packed({ length: 16, decimals }).set(best.toFixed(best.getDecimals()));
+            }
+            return new types_1.Packed({ length: 16, decimals }).set(bestValue);
+        case INT8:
+            if (best instanceof types_1.Integer8) {
+                return new types_1.Integer8().set(best.get());
+            }
+            return new types_1.Integer8().set(bestValue);
+        default:
+            return new types_1.Integer().set(bestValue);
+    }
+}
+//# sourceMappingURL=_extremum.js.map

package/build/src/builtin/nmax.d.ts

@@ -1,5 +1,4 @@
 import { INumeric } from "../types/_numeric";
-import { Float } from "../types";
 export interface INmaxInput {
     val1: number | INumeric;
     val2: number | INumeric;
@@ -11,4 +10,4 @@ export interface INmaxInput {
     val8?: number | INumeric;
     val9?: number | INumeric;
 }
-export declare function nmax(input: INmaxInput): Float;
+export declare function nmax(input: INmaxInput): import("../types").Float | import("../types").Integer8 | import("../types").Integer | import("../types").DecFloat34 | import("../types").Packed;

package/build/src/builtin/nmax.js

@@ -1,34 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nmax = nmax;
-const _parse_1 = require("../operators/_parse");
-const types_1 = require("../types");
+const _extremum_1 = require("./_extremum");
 function nmax(input) {
-    const values = [];
-    values.push((0, _parse_1.parse)(input.val1));
-    values.push((0, _parse_1.parse)(input.val2));
-    if (input.val3) {
-        values.push((0, _parse_1.parse)(input.val3));
-    }
-    if (input.val4) {
-        values.push((0, _parse_1.parse)(input.val4));
-    }
-    if (input.val5) {
-        values.push((0, _parse_1.parse)(input.val5));
-    }
-    if (input.val6) {
-        values.push((0, _parse_1.parse)(input.val6));
-    }
-    if (input.val7) {
-        values.push((0, _parse_1.parse)(input.val7));
-    }
-    if (input.val8) {
-        values.push((0, _parse_1.parse)(input.val8));
-    }
-    if (input.val9) {
-        values.push((0, _parse_1.parse)(input.val9));
-    }
-    values.sort((a, b) => (b - a));
-    return new types_1.Float().set(values[0]);
+    return (0, _extremum_1.extremum)([input.val1, input.val2, input.val3, input.val4, input.val5,
+        input.val6, input.val7, input.val8, input.val9], (candidate, best) => candidate > best);
 }
 //# sourceMappingURL=nmax.js.map

package/build/src/builtin/nmin.d.ts

@@ -1,5 +1,4 @@
 import { INumeric } from "../types/_numeric";
-import { Float } from "../types";
 export interface INminInput {
     val1: number | INumeric;
     val2: number | INumeric;
@@ -11,4 +10,4 @@ export interface INminInput {
     val8?: number | INumeric;
     val9?: number | INumeric;
 }
-export declare function nmin(input: INminInput): Float;
+export declare function nmin(input: INminInput): import("../types").Float | import("../types").Integer8 | import("../types").Integer | import("../types").DecFloat34 | import("../types").Packed;

package/build/src/builtin/nmin.js

@@ -1,34 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nmin = nmin;
-const _parse_1 = require("../operators/_parse");
-const types_1 = require("../types");
+const _extremum_1 = require("./_extremum");
 function nmin(input) {
-    const values = [];
-    values.push((0, _parse_1.parse)(input.val1));
-    values.push((0, _parse_1.parse)(input.val2));
-    if (input.val3) {
-        values.push((0, _parse_1.parse)(input.val3));
-    }
-    if (input.val4) {
-        values.push((0, _parse_1.parse)(input.val4));
-    }
-    if (input.val5) {
-        values.push((0, _parse_1.parse)(input.val5));
-    }
-    if (input.val6) {
-        values.push((0, _parse_1.parse)(input.val6));
-    }
-    if (input.val7) {
-        values.push((0, _parse_1.parse)(input.val7));
-    }
-    if (input.val8) {
-        values.push((0, _parse_1.parse)(input.val8));
-    }
-    if (input.val9) {
-        values.push((0, _parse_1.parse)(input.val9));
-    }
-    values.sort((a, b) => (a - b));
-    return new types_1.Float().set(values[0]);
+    return (0, _extremum_1.extremum)([input.val1, input.val2, input.val3, input.val4, input.val5,
+        input.val6, input.val7, input.val8, input.val9], (candidate, best) => candidate < best);
 }
 //# sourceMappingURL=nmin.js.map

package/build/src/builtin/round.d.ts

@@ -1,8 +1,17 @@
-import { Float } from "../types";
+import { DecFloat34 } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
+type Input = INumeric | ICharacter | string | number;
+/** round( val = arg {dec = n}|{prec = n} [mode = m] )
+ *
+ * The argument is converted to decfloat34 and rounded as a decimal number, so
+ * round( val = '2.675' dec = 2 ) is 2.68 - not 2.67, which is what scaling the
+ * nearest binary float would give. A binary float argument brings its full
+ * binary expansion along, the way converting f to decfloat34 does. */
 export declare function round(input: {
-    val: ICharacter | string;
-    dec: INumeric | number;
-    mode?: INumeric | number;
-}): Float;
+    val: Input;
+    dec?: Input;
+    prec?: Input;
+    mode?: Input;
+}): DecFloat34;
+export {};

package/build/src/builtin/round.js

@@ -3,39 +3,87 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.round = round;
 const _parse_1 = require("../operators/_parse");
 const types_1 = require("../types");
+// the rounding modes of CL_ABAP_MATH, the decNumber enumeration
+const ROUND_CEILING = 0;
+const ROUND_UP = 1;
+const ROUND_HALF_UP = 2;
+const ROUND_HALF_EVEN = 3;
+const ROUND_HALF_DOWN = 4;
+const ROUND_DOWN = 5;
+const ROUND_FLOOR = 6;
+/** round( val = arg {dec = n}|{prec = n} [mode = m] )
+ *
+ * The argument is converted to decfloat34 and rounded as a decimal number, so
+ * round( val = '2.675' dec = 2 ) is 2.68 - not 2.67, which is what scaling the
+ * nearest binary float would give. A binary float argument brings its full
+ * binary expansion along, the way converting f to decfloat34 does. */
 function round(input) {
-    let mode = input.mode;
-    if (mode === undefined) {
-        mode = 2;
+    const mode = input.mode === undefined ? ROUND_HALF_UP : (0, _parse_1.parse)(input.mode);
+    let arg = input.val;
+    if (arg instanceof types_1.FieldSymbol) {
+        arg = arg.getPointer();
     }
-    else if (typeof mode !== "number") {
-        mode = mode?.get();
+    const val = (0, _parse_1.parse)(arg);
+    const text = arg instanceof types_1.Float ? val.toPrecision(34) : String(val);
+    const match = /^(-?)(\d*)\.?(\d*)(?:e([+-]?\d+))?$/i.exec(text);
+    if (match === null || !Number.isFinite(val)) {
+        return new types_1.DecFloat34().set(val);
     }
-    const val = (0, _parse_1.parse)(input.val);
-    const dec = (0, _parse_1.parse)(input.dec);
-    if (dec !== 0) {
-        throw new Error("round(), todo, handle decimals");
+    const negative = match[1] === "-";
+    const digits = BigInt((match[2] + match[3]).replace(/^0+/, "") || "0");
+    // the value is digits * 10^exponent
+    const exponent = parseInt(match[4] || "0", 10) - match[3].length;
+    let dec;
+    if (input.prec !== undefined) {
+        const prec = (0, _parse_1.parse)(input.prec);
+        if (prec <= 0) {
+            throw new Error("CX_SY_ARITHMETIC_ERROR, round( ) prec must be positive");
+        }
+        // position of the most significant digit
+        const top = digits.toString().length - 1 + exponent;
+        dec = prec - 1 - top;
     }
-    const ret = new types_1.Float();
+    else {
+        dec = input.dec === undefined ? 0 : (0, _parse_1.parse)(input.dec);
+    }
+    const drop = -exponent - dec;
+    if (drop <= 0 || digits === 0n) {
+        return new types_1.DecFloat34().set(val);
+    }
+    const divisor = 10n ** BigInt(drop);
+    let kept = digits / divisor;
+    const rest = digits % divisor;
+    // compare the dropped part with one half of the last kept digit
+    const half = rest * 2n === divisor ? 0 : (rest * 2n > divisor ? 1 : -1);
+    let away;
     switch (mode) {
-        case 1:
-            ret.set(Math.ceil(val));
+        case ROUND_CEILING:
+            away = rest > 0n && negative === false;
+            break;
+        case ROUND_UP:
+            away = rest > 0n;
             break;
-        case 2:
-            ret.set(Math.round(val));
+        case ROUND_HALF_UP:
+            away = half >= 0;
             break;
-        case 4:
-            ret.set(-Math.round(-val));
+        case ROUND_HALF_EVEN:
+            away = half > 0 || (half === 0 && kept % 2n === 1n);
             break;
-        case 5:
-            ret.set(Math.trunc(val));
+        case ROUND_HALF_DOWN:
+            away = half > 0;
             break;
-        case 6:
-            ret.set(Math.floor(val));
+        case ROUND_DOWN:
+            away = false;
+            break;
+        case ROUND_FLOOR:
+            away = rest > 0n && negative === true;
             break;
         default:
             throw new Error("round(), unknown mode: " + mode);
     }
-    return ret;
+    if (away) {
+        kept += 1n;
+    }
+    return new types_1.DecFloat34().set(Number((negative ? "-" : "") + kept.toString() + "e" + (-dec)));
 }
 //# sourceMappingURL=round.js.map

package/build/src/compare/eq.js

@@ -347,6 +347,16 @@ function eq(left, right) {
     else if (right instanceof types_1.Float && typeof l === "number") {
         r = right.getRaw();
     }
+    else if ((right instanceof types_1.Float || right instanceof types_1.DecFloat34) && typeof l === "string") {
+        // a character-like operand is compared as a number: get( ) of a float
+        // writes 1,4800000000000000E+02, which no text compares equal with
+        r = right.getRaw();
+        l = Number(l);
+    }
+    else if (left instanceof types_1.DecFloat34 && typeof r === "string") {
+        l = left.getRaw();
+        r = Number(r);
+    }
     else if (left instanceof types_1.Float) {
         if (typeof r === "number") {
             l = left.getRaw();

package/build/src/compare/in.d.ts

@@ -1,4 +1,6 @@
 import { Table } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
-export declare function compareIn(left: number | string | ICharacter | INumeric, right: Table): boolean;
+type Operand = number | string | ICharacter | INumeric;
+export declare function compareIn(left: Operand, right: Table): boolean;
+export {};

package/build/src/compare/in.js

@@ -3,32 +3,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.compareIn = compareIn;
 const cp_1 = require("./cp");
 const eq_1 = require("./eq");
+const ge_1 = require("./ge");
+const gt_1 = require("./gt");
+const le_1 = require("./le");
+const lt_1 = require("./lt");
 const ne_1 = require("./ne");
-function compareIn(left, right) {
-    if (right.array().length === 0) {
-        return true;
+function matches(left, option, low, high) {
+    switch (option) {
+        case "EQ": return (0, eq_1.eq)(left, low);
+        case "NE": return (0, ne_1.ne)(left, low);
+        case "GT": return (0, gt_1.gt)(left, low);
+        case "GE": return (0, ge_1.ge)(left, low);
+        case "LT": return (0, lt_1.lt)(left, low);
+        case "LE": return (0, le_1.le)(left, low);
+        case "BT": return (0, ge_1.ge)(left, low) && (0, le_1.le)(left, high);
+        case "NB": return !((0, ge_1.ge)(left, low) && (0, le_1.le)(left, high));
+        case "CP": return (0, cp_1.cp)(left, low);
+        case "NP": return !(0, cp_1.cp)(left, low);
+        default: throw new Error("compareIn, unknown option " + option);
     }
+}
+// A value is in a range table when some I row admits it, or there is no I
+// row at all, and no E row admits it. An empty table admits everything.
+function compareIn(left, right) {
+    let included = false;
+    let hasInclude = false;
     for (const row of right.array()) {
-        if ((0, eq_1.eq)(row.get()["sign"], "I") && (0, eq_1.eq)(row.get()["option"], "EQ")) {
-            if ((0, eq_1.eq)(row.get()["low"], left)) {
-                return true;
-            }
-        }
-        else if ((0, eq_1.eq)(row.get()["sign"], "E") && (0, eq_1.eq)(row.get()["option"], "EQ")) {
-            if ((0, ne_1.ne)(row.get()["low"], left)) {
-                return true;
-            }
+        const r = row.get();
+        const sign = r["sign"].get().toString().toUpperCase().trim();
+        const option = r["option"].get().toString().toUpperCase().trim();
+        const hit = matches(left, option, r["low"], r["high"]);
+        if (sign === "I") {
+            hasInclude = true;
+            included = included || hit;
         }
-        else if ((0, eq_1.eq)(row.get()["sign"], "I") && (0, eq_1.eq)(row.get()["option"], "CP")) {
-            if ((0, cp_1.cp)(left, row.get()["low"])) {
-                return true;
+        else if (sign === "E") {
+            if (hit) {
+                return false;
             }
         }
         else {
-            console.dir(row);
-            throw new Error("compareIn todo");
+            throw new Error("compareIn, unknown sign " + sign);
         }
     }
-    return false;
+    return hasInclude === false || included;
 }
 //# sourceMappingURL=in.js.map

package/build/src/statements/create_data.js

@@ -21,6 +21,18 @@ function createDataRefTo(target, name) {
     }
     target.assign(new abap.types.ABAPObject({ qualifiedName: name, RTTIName: name }));
 }
+/** CREATE DATA ... LIKE dobj takes the type of dobj, never its content: the
+ * created data object starts initial. A table is created empty right away
+ * instead of copying its rows first. */
+function initialLike(like) {
+    if (like instanceof types_1.Table || like instanceof types_1.HashedTable) {
+        const TableType = like.constructor;
+        return new TableType(like.getRowType(), like.getOptions(), like.getQualifiedName());
+    }
+    const copy = like.clone();
+    copy.clear();
+    return copy;
+}
 function createData(target, options) {
     // console.dir(options);
     if (target instanceof types_1.FieldSymbol) {
@@ -208,10 +220,10 @@ function createData(target, options) {
             options.like = options.like.getPointer();
         }
         if (options.table === true) {
-            target.assign(new abap.types.Table(options.like.clone(), tableOptions));
+            target.assign(new abap.types.Table(initialLike(options.like), tableOptions));
         }
         else {
-            target.assign(options.like.clone());
+            target.assign(initialLike(options.like));
         }
     }
     else {

package/build/src/statements/read_table.js

@@ -90,6 +90,73 @@ async function searchWithKeyPromise(arr, withKey, startIndex = 0, usesTableLine)
     };
 }
 /////////////////
+function toRow(a, isStructured, usesTableLine) {
+    if (usesTableLine === false && isStructured === true) {
+        return a.get();
+    }
+    return isStructured ? { table_line: a, ...a.get() } : { table_line: a };
+}
+/** READ with a key on a SORTED table: binary search over the leading key components that are given,
+ *  a miss gives sy-subrc 4 and sy-tabix of the row the key would be inserted before,
+ *  or sy-subrc 8 and sy-tabix lines + 1 when it would be inserted after the last row */
+/** true when every component of the condition is a component of the key */
+function onlyKeyComponents(keyFields, options) {
+    const key = keyFields.map(k => k.toLowerCase());
+    return Object.keys(options.withKeySimple || {}).every(n => key.includes(n.toLowerCase()));
+}
+function readSortedWithKey(arr, keyFields, options) {
+    const names = Object.keys(options.withKeySimple).map(n => n.toLowerCase());
+    const prefix = [];
+    for (const keyField of keyFields) {
+        const index = names.indexOf(keyField.toLowerCase());
+        if (index < 0) {
+            break;
+        }
+        prefix.push(options.withKeyValue[index]);
+    }
+    if (prefix.length === 0) {
+        const searchResult = searchWithKey(arr, options.withKey, 0, options.usesTableLine);
+        return { found: searchResult.found, foundIndex: searchResult.foundIndex, subrc: undefined };
+    }
+    const isStructured = arr[0] instanceof types_1.Structure;
+    const comparePrefix = (row) => {
+        for (const p of prefix) {
+            const value = p.key(row);
+            // eq first, lt and gt compare a c operand with its trailing blanks against a string
+            if ((0, compare_1.eq)(value, p.value)) {
+                continue;
+            }
+            else if ((0, compare_1.lt)(value, p.value)) {
+                return -1;
+            }
+            else if ((0, compare_1.gt)(value, p.value)) {
+                return 1;
+            }
+        }
+        return 0;
+    };
+    let left = 0;
+    let right = arr.length;
+    while (left < right) {
+        const middle = Math.floor((left + right) / 2);
+        if (comparePrefix(toRow(arr[middle], isStructured, options.usesTableLine)) < 0) {
+            left = middle + 1;
+        }
+        else {
+            right = middle;
+        }
+    }
+    for (let index = left; index < arr.length; index++) {
+        const row = toRow(arr[index], isStructured, options.usesTableLine);
+        if (comparePrefix(row) !== 0) {
+            break;
+        }
+        if (options.withKey(row) === true) {
+            return { found: arr[index], foundIndex: index + 1, subrc: undefined };
+        }
+    }
+    return { found: undefined, foundIndex: left + 1, subrc: left >= arr.length ? 8 : 4 };
+}
 function readTable(table, options) {
     let found = undefined;
     let foundIndex = 0;
@@ -187,15 +254,34 @@ function readTable(table, options) {
             // fallback
             return readTable(table, { ...options, withKeySimple: undefined });
         }
-        const startIndex = (0, binary_search_1.binarySearchFrom)(arr, 0, arr.length, firstKeyName.toLowerCase(), firstValue) - 1;
-        //    console.dir("startindex: " + startIndex);
-        if (startIndex >= 0) {
-            const searchResult = searchWithKeyEarlyExit(arr, options.withKey, startIndex, options.usesTableLine, firstKeyName, firstValue);
-            //      console.dir(searchResult);
-            found = searchResult.found;
-            foundIndex = searchResult.foundIndex;
+        if (keyInformation?.type === types_1.TableAccessType.sorted
+            && options.withKeyValue
+            && onlyKeyComponents(keyInformation.keyFields, options)) {
+            const result = readSortedWithKey(arr, keyInformation.keyFields, options);
+            found = result.found;
+            foundIndex = result.foundIndex;
+            binarySubrc = result.subrc;
+        }
+        else {
+            const startIndex = (0, binary_search_1.binarySearchFrom)(arr, 0, arr.length, firstKeyName.toLowerCase(), firstValue) - 1;
+            if (startIndex >= 0) {
+                const searchResult = searchWithKeyEarlyExit(arr, options.withKey, startIndex, options.usesTableLine, firstKeyName, firstValue);
+                found = searchResult.found;
+                foundIndex = searchResult.foundIndex;
+            }
         }
     }
+    else if (options?.withTableKey === true
+        && options.withKeyValue
+        && options.withKeySimple
+        && options.withKey
+        && table.getOptions().primaryKey?.type === types_1.TableAccessType.sorted
+        && onlyKeyComponents(table.getOptions().primaryKey?.keyFields || [], options)) {
+        const result = readSortedWithKey(table.array(), table.getOptions().primaryKey?.keyFields || [], options);
+        found = result.found;
+        foundIndex = result.foundIndex;
+        binarySubrc = result.subrc;
+    }
     else if ((options?.binarySearch === true || options?.withTableKey === true)
         && options.withKeyValue
         && (options?.binarySearch === true || table.getOptions().primaryKey?.type !== types_1.TableAccessType.standard)

package/build/src/template_formatting.js

@@ -3,6 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.templateFormatting = templateFormatting;
 const alpha_1 = require("./alpha");
 const types_1 = require("./types");
+/** DECIMALS for a decimal number: its decimal digits are rounded, half away
+ * from zero, the way ABAP rounds commercially - 2.675 gives 2.68, where
+ * toFixed( ) on the nearest binary float gives 2.67 */
+function decimalsOfDecimal(value, decimals) {
+    const shift = (x, places) => {
+        const [mantissa, exponent] = (x + "").split("e");
+        return Number(mantissa + "e" + (Number(exponent || 0) + places));
+    };
+    const rounded = shift(Math.round(shift(Math.abs(value), decimals)), -decimals);
+    return (value < 0 && rounded !== 0 ? "-" : "") + rounded.toFixed(decimals);
+}
 function templateFormatting(source, options) {
     let text = "";
     if (source instanceof types_1.FieldSymbol) {
@@ -22,7 +33,10 @@ function templateFormatting(source, options) {
     }
     else if (source instanceof types_1.DecFloat34) {
         const raw = source.getRaw();
-        if (Number.isInteger(raw)) {
+        if (options?.decimals !== undefined) {
+            text = decimalsOfDecimal(raw, options.decimals);
+        }
+        else if (Number.isInteger(raw)) {
             text = raw.toFixed(0);
         }
         else {
@@ -43,7 +57,7 @@ function templateFormatting(source, options) {
         }
     }
     else if (source instanceof types_1.Packed) {
-        if (options?.decimals) {
+        if (options?.decimals !== undefined) {
             text = source.toFixed(options.decimals);
         }
         else {
@@ -127,10 +141,10 @@ function templateFormatting(source, options) {
         else if (options.width) {
             text = text.trimEnd().padEnd(options.width, " ");
         }
-        else if (options.decimals && source instanceof types_1.Integer) {
+        else if (options.decimals !== undefined && source instanceof types_1.Integer) {
             text = source.get().toFixed(options.decimals);
         }
-        else if (options.decimals && source instanceof types_1.Float) {
+        else if (options.decimals !== undefined && source instanceof types_1.Float) {
             text = source.getRaw().toFixed(options.decimals);
         }
     }

package/build/src/types/table.js

@@ -550,8 +550,18 @@ class Table {
             return val;
         }
     }
-    /* appends and returns this */
+    /* appends and returns this - how VALUE #( ) builds a table, row by row.
+     * A sorted table gets each row at its sorted place, as INSERT ... INTO
+     * TABLE puts it: pushed, it was in insertion order until something
+     * assigned it, so a VALUE #( ) handed straight to a method or looped over
+     * was a SORTED table unsorted, and every binary search on it could miss.
+     * A duplicate of a unique key is kept, as before */
     appendThis(item) {
+        const primary = this.getOptions()?.primaryKey;
+        if (primary?.type === TableAccessType.sorted && !(item instanceof data_reference_1.DataReference)) {
+            this.insertSorted(item, (a, b) => (0, sort_1.compareRows)(a, b, primary.keyFields), false);
+            return this;
+        }
         this.append(item);
         return this;
     }

package/package.json

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