@abaplint/runtime 2.13.94 → 2.13.95

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/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/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/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/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/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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "2.13.94",
+  "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"
   }
 }