@abaplint/runtime 2.13.93 → 2.13.95

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/find.js

@@ -32,7 +32,7 @@ function find(input) {
         }
     }
     else {
-        const sub = typeof input.sub === "string" ? input.sub : input.sub?.get();
+        let sub = typeof input.sub === "string" ? input.sub : input.sub?.get() || "";
         let off = (0, _position_1.position)(input.off) || 0;
         let occ = (0, _position_1.position)(input.occ);
         if (occ === 0) {
@@ -41,6 +41,26 @@ function find(input) {
         else if (occ === undefined) {
             occ = 1;
         }
+        const caseInput = typeof input.case === "string" ? input.case : input.case?.get();
+        if (caseInput !== undefined && caseInput !== "X") {
+            val = foldCase(val);
+            sub = foldCase(sub);
+        }
+        if (occ < 0 && sub !== "" && off === 0) {
+            // search from the right, on the string as it is, so a "sub" of any length
+            // matches and the offset needs no mapping back
+            let from = val.length - sub.length;
+            let found = -1;
+            for (let i = 0; i < Math.abs(occ); i++) {
+                found = from < 0 ? -1 : val.lastIndexOf(sub, from);
+                if (found < 0) {
+                    return new types_1.Integer().set(-1);
+                }
+                from = found - 1;
+            }
+            return new types_1.Integer().set(found);
+        }
+        // a negative "occ" with an empty "sub" or an "off" still comes here, unchanged
         let negative = false;
         if (occ < 0) {
             negative = true;
@@ -54,7 +74,7 @@ function find(input) {
         }
         let found = -1;
         for (let i = 0; i < occ; i++) {
-            found = val.indexOf(sub || "", off);
+            found = val.indexOf(sub, off);
             if (found >= 0) {
                 off = found + 1;
             }
@@ -65,4 +85,15 @@ function find(input) {
         return new types_1.Integer().set(found);
     }
 }
+// lower case one character at a time and keep a character whose lower case form
+// has another length, so every offset stays valid - a plain toLowerCase( )
+// turns e.g. "\u0130" into two code units
+function foldCase(str) {
+    let ret = "";
+    for (const character of str) {
+        const lower = character.toLowerCase();
+        ret += lower.length === character.length ? lower : character;
+    }
+    return ret;
+}
 //# sourceMappingURL=find.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/cp.js

@@ -5,6 +5,41 @@ const types_1 = require("../types");
 function escapeRegExpCharacter(input) {
     return input.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
 }
+const CACHE_SIZE = 1000;
+const cache = new Map();
+/** `end` is the pattern's length after the last token that is not a `*`: what
+ *  follows is a run of trailing `[\s\S]*`, which matches any rest of the
+ *  string - so it goes, and so does the `$` that made the engine walk there */
+function compile(r) {
+    let pattern = "";
+    let end = 0;
+    for (let i = 0; i < r.length; i++) {
+        const current = r[i];
+        if (current === "*") {
+            pattern += "[\\s\\S]*";
+            continue;
+        }
+        if (current === "#") {
+            if (i + 1 < r.length) {
+                const next = r[i + 1];
+                pattern += next === "#" ? "#" : escapeRegExpCharacter(next);
+                i++;
+            }
+            else {
+                pattern += "#";
+            }
+        }
+        else if (current === "+") {
+            pattern += "[\\s\\S]";
+        }
+        else {
+            pattern += escapeRegExpCharacter(current);
+        }
+        end = pattern.length;
+    }
+    const open = end < pattern.length;
+    return new RegExp("^" + pattern.slice(0, end) + (open ? "" : "$"), "iu");
+}
 function cp(left, right) {
     let l = "";
     if (typeof left === "number" || typeof left === "string") {
@@ -35,36 +70,14 @@ function cp(left, right) {
     else {
         r = right.get().toString().trimEnd();
     }
-    let pattern = "";
-    for (let i = 0; i < r.length; i++) {
-        const current = r[i];
-        if (current === "#") {
-            if (i + 1 < r.length) {
-                const next = r[i + 1];
-                if (next === "#") {
-                    pattern += "#";
-                    i++;
-                }
-                else {
-                    pattern += escapeRegExpCharacter(next);
-                    i++;
-                }
-            }
-            else {
-                pattern += "#";
-            }
-        }
-        else if (current === "*") {
-            pattern += "[\\s\\S]*";
-        }
-        else if (current === "+") {
-            pattern += "[\\s\\S]";
-        }
-        else {
-            pattern += escapeRegExpCharacter(current);
+    let reg = cache.get(r);
+    if (reg === undefined) {
+        reg = compile(r);
+        if (cache.size >= CACHE_SIZE) {
+            cache.delete(cache.keys().next().value);
         }
+        cache.set(r, reg);
     }
-    const reg = new RegExp("^" + pattern + "$", "iu");
-    return l.match(reg) !== null;
+    return reg.test(l);
 }
 //# sourceMappingURL=cp.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/concatenate.js

@@ -38,8 +38,10 @@ function concatenate(input) {
                 if (hasSeparator === true && i > 0) {
                     result += sep;
                 }
-                const value = array[i].get();
-                result += respectingBlanks === true ? value : value.trimEnd();
+                const row = array[i];
+                const value = row.get();
+                // Preserve trailing blanks in string rows even without RESPECTING BLANKS.
+                result += respectingBlanks === true || row instanceof types_1.String ? value : value.trimEnd();
             }
         }
         setTarget(input.target, result);

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/loop.js

@@ -8,13 +8,17 @@ function determineFromTo(array, topEquals, key) {
         // if there is no WHERE supplied, its using the sorting of the secondary key
         return { from: 1, to: array.length };
     }
-    let from = 0;
+    // 1-based, as the branch without topEquals above answers: when the key's
+    // first field is not in topEquals (a key over a substructure component,
+    // s-x, is never put there) nothing is narrowed, and the loop must not start
+    // at row index -1
+    let from = 1;
     let to = array.length;
     // todo: multi field
     const keyField = key.keyFields[0].toLowerCase();
     const keyValue = topEquals[keyField];
     if (keyField && keyValue) {
-        from = (0, binary_search_1.binarySearchFrom)(array, from, to, keyField, keyValue);
+        from = (0, binary_search_1.binarySearchFrom)(array, 0, to, keyField, keyValue);
         to = (0, binary_search_1.binarySearchTo)(array, from, to, keyField, keyValue);
         //    console.dir("from: " + from + ", to: " + to);
     }
@@ -99,7 +103,9 @@ async function* loop(table, options) {
     let loopFrom = options?.from && options?.from.get() > 0 ? options.from.get() - 1 : 0;
     let loopTo = options?.to && options.to.get() < length ? options.to.get() : length;
     let array = [];
-    if (options?.usingKey && options.usingKey !== undefined && options.usingKey !== "primary_key") {
+    // a dynamic key name may come in any case, USING KEY ('PRIMARY_KEY') is the primary key too
+    const isPrimaryKey = options?.usingKey === undefined || options.usingKey.toLowerCase() === "primary_key";
+    if (options?.usingKey && isPrimaryKey === false) {
         array = table.getSecondaryIndex(options.usingKey);
         const { from, to } = determineFromTo(array, options.topEquals, table.getKeyByName(options.usingKey));
         loopFrom = Math.max(loopFrom, from) - 1;
@@ -122,7 +128,7 @@ async function* loop(table, options) {
     // The same goes for a loop that reads an index table through a hash
     // secondary key. Handing out 1, 2, 3 there looks helpful and is a lie the
     // caller cannot tell from the truth.
-    const usedKey = options?.usingKey === undefined || options.usingKey === "primary_key"
+    const usedKey = options?.usingKey === undefined || isPrimaryKey
         ? undefined
         : table.getKeyByName(options.usingKey);
     const hasRowNumber = usedKey !== undefined
@@ -131,7 +137,9 @@ async function* loop(table, options) {
     try {
         const isStructured = array[0] instanceof types_1.Structure;
         while (loopController.index < loopController.loopTo) {
-            if (loopController.index > array.length) {
+            // the body may have deleted rows: never read past the end, where
+            // array[array.length] is undefined
+            if (loopController.index >= array.length) {
                 break;
             }
             const current = array[loopController.index];

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/statements/update_database.js

@@ -15,6 +15,20 @@ async function updateDatabase(table, options, context) {
     if (typeof table !== "string") {
         table = table.get();
     }
+    if (options.table !== undefined) {
+        // row by row, as a work area each: sy-subrc 4 when a row found nothing
+        // to update, sy-dbcnt the rows updated
+        let subrc = 0;
+        let dbcnt = 0;
+        for (const row of options.table.array()) {
+            await updateDatabase(table, { from: row }, context);
+            subrc = Math.max(subrc, abap.builtin.sy.get().subrc.get());
+            dbcnt += abap.builtin.sy.get().dbcnt.get();
+        }
+        abap.builtin.sy.get().subrc.set(subrc);
+        abap.builtin.sy.get().dbcnt.set(dbcnt);
+        return subrc;
+    }
     const tabl = abap.DDIC[table.toUpperCase()];
     if (tabl === undefined) {
         await (0, throw_error_1.throwErrorWithParameters)("CX_SY_DYNAMIC_OSQL_SEMANTICS", { sqlmsg: new types_1.String().set(`Table ${table} not found`) });

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.d.ts

@@ -97,7 +97,7 @@ export declare class Table implements ITable {
     clone(): Table;
     getArrayLength(): number;
     getKeyByName(name: string): ITableKey | undefined;
-    getSecondaryIndex(name: string): TableRowType[];
+    getSecondaryIndex(name: string): any[];
     getQualifiedName(): string | undefined;
     getOptions(): ITableOptions;
     startLoop(from: number, to: number, array: any[]): LoopController;

package/build/src/types/table.js

@@ -27,6 +27,15 @@ var TableKeyType;
     TableKeyType["user"] = "USER";
     TableKeyType["empty"] = "EMPTY";
 })(TableKeyType || (exports.TableKeyType = TableKeyType = {}));
+/* rows are handed to a sorted secondary key in table order, and a duplicate of a
+ * non-unique key goes in front of its equals, as INSERT ... INTO TABLE does: reversed
+ * before the stable sort, the later of two equal rows comes first */
+function secondaryDuplicatesFirst(rows, key) {
+    if (key.type === TableAccessType.sorted && key.isUnique !== true) {
+        rows.reverse();
+    }
+    return rows;
+}
 class LoopController {
     index;
     loopTo;
@@ -109,7 +118,7 @@ class HashedTable {
             throw `Table, secondary key "${name}" not found`;
         }
         // note, array() already is a copy, so it can be used,
-        const copy = this.array();
+        const copy = secondaryDuplicatesFirst(this.array(), secondary);
         (0, sort_1.sort)(copy, { by: secondary.keyFields.map(k => { return { component: k.toLowerCase() }; }) });
         this.secondaryIndexes[name.toUpperCase()] = copy;
         return copy;
@@ -365,7 +374,7 @@ class Table {
         if (secondary === undefined) {
             throw `Table, secondary key "${name}" not found`;
         }
-        const copy = [...this.value];
+        const copy = secondaryDuplicatesFirst([...this.value], secondary);
         (0, sort_1.sort)(copy, { by: secondary.keyFields.map(k => { return { component: k.toLowerCase() }; }), skipSortedCheck: true });
         this.secondaryIndexes[name.toUpperCase()] = copy;
         return copy;
@@ -482,24 +491,25 @@ class Table {
             return { value: this.insertIndex(val, 0, true), subrc: 0 };
         }
         const lastComparison = compare(this.value[lastIndex], val);
-        if (lastComparison < 0 || (lastComparison === 0 && unique === false)) {
+        if (lastComparison < 0) {
             return { value: this.insertIndex(val, this.value.length, true), subrc: 0 };
         }
-        else if (lastComparison === 0) {
+        else if (lastComparison === 0 && unique === true) {
             return { value: undefined, subrc: 4 };
         }
         let low = 0;
         let high = this.value.length;
         while (low < high) {
             const middle = Math.floor((low + high) / 2);
-            if (compare(this.value[middle], val) <= 0) {
+            // a duplicate of a non-unique key goes in front of the rows it duplicates
+            if (compare(this.value[middle], val) < 0) {
                 low = middle + 1;
             }
             else {
                 high = middle;
             }
         }
-        if (unique === true && low > 0 && compare(this.value[low - 1], val) === 0) {
+        if (unique === true && low < this.value.length && compare(this.value[low], val) === 0) {
             return { value: undefined, subrc: 4 };
         }
         return { value: this.insertIndex(val, low, true), subrc: 0 };
@@ -550,8 +560,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.95",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -33,11 +33,11 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^26.4.1",
     "chai": "^6.2.2",
-    "mocha": "^12.0.2",
+    "mocha": "^12.0.3",
     "source-map-support": "^0.5.21",
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "temporal-polyfill": "^1.0.4"
+    "temporal-polyfill": "^1.0.5"
   }
 }