@abaplint/runtime 2.13.94 → 2.13.96

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

@@ -1,6 +1,7 @@
 import { Console } from "./console/console";
 import { DatabaseClient, DatabaseCursorCallbacks } from "./db/db";
 import * as RFC from "./rfc";
+import { DatasetHost, OpenDataset } from "./dataset/dataset";
 export declare class Context {
     console: Console;
     cursorCounter: number;
@@ -13,5 +14,9 @@ export declare class Context {
     RFCDestinations: {
         [name: string]: RFC.RFCClient;
     };
+    dataset: DatasetHost | undefined;
+    datasets: {
+        [name: string]: OpenDataset;
+    };
     defaultDB(): DatabaseClient;
 }

package/build/src/context.js

@@ -8,6 +8,10 @@ class Context {
     // DEFAULT and secondary database connections
     databaseConnections = {};
     RFCDestinations = {};
+    // the file system OPEN DATASET and friends read and write; none by default,
+    // and then every DATASET statement throws
+    dataset = undefined;
+    datasets = {};
     defaultDB() {
         if (this.databaseConnections["DEFAULT"] === undefined) {
             throw new Error("Runtime, database not initialized");

package/build/src/dataset/dataset.d.ts

@@ -0,0 +1,51 @@
+import { FieldSymbol } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export type DatasetMode = "INPUT" | "OUTPUT" | "APPENDING" | "UPDATE";
+/** an open file: positional reads and writes, the runtime keeps the position */
+export interface DatasetHandle {
+    /** up to length bytes from position; fewer at the end of the file */
+    read(position: number, length: number): Promise<Uint8Array>;
+    write(position: number, bytes: Uint8Array): Promise<void>;
+    size(): Promise<number>;
+    close(): Promise<void>;
+}
+export interface DatasetHost {
+    /** OUTPUT truncates or creates, APPENDING and UPDATE keep the content;
+     *  a failure is returned as the text OPEN DATASET ... MESSAGE receives
+     *  and becomes sy-subrc 8 */
+    open(name: string, mode: DatasetMode): Promise<DatasetHandle | {
+        message: string;
+    }>;
+    /** false when there was nothing to delete (sy-subrc 4) */
+    delete(name: string): Promise<boolean>;
+}
+export interface IOpenDatasetOptions {
+    mode: DatasetMode;
+    binary: boolean;
+    encoding?: "DEFAULT" | "UTF-8" | "NON-UNICODE";
+    legacy?: boolean;
+    message?: ICharacter | FieldSymbol;
+    position?: INumeric | FieldSymbol;
+    /** additions this runtime does not implement, by name */
+    unsupported?: string[];
+}
+export interface ITransferOptions {
+    length?: INumeric | FieldSymbol;
+    noEndOfLine?: boolean;
+}
+export interface IReadDatasetOptions {
+    maximumLength?: INumeric | FieldSymbol;
+    actualLength?: INumeric | FieldSymbol;
+}
+export interface IGetDatasetOptions {
+    position?: INumeric | FieldSymbol;
+    attributes?: any;
+}
+/** a file OPEN DATASET opened, as the runtime keeps it by name */
+export interface OpenDataset {
+    handle: DatasetHandle;
+    mode: DatasetMode;
+    binary: boolean;
+    position: number;
+}

package/build/src/dataset/dataset.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=dataset.js.map

package/build/src/dataset/memory_dataset.d.ts

@@ -0,0 +1,17 @@
+import { DatasetHandle, DatasetHost, DatasetMode } from "./dataset";
+/** A DatasetHost over a map of names to bytes: for tests, and for a runtime
+ *  in a browser, where there is no file system to hand to OPEN DATASET.
+ *  OUTPUT empties or creates a file, APPENDING and UPDATE create it when
+ *  missing, INPUT of a missing file fails with the message a system gives. */
+export declare class MemoryDataset implements DatasetHost {
+    readonly files: {
+        [name: string]: Uint8Array;
+    };
+    constructor(files?: {
+        [name: string]: Uint8Array;
+    });
+    open(name: string, mode: DatasetMode): Promise<DatasetHandle | {
+        message: string;
+    }>;
+    delete(name: string): Promise<boolean>;
+}

package/build/src/dataset/memory_dataset.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryDataset = void 0;
+/** A DatasetHost over a map of names to bytes: for tests, and for a runtime
+ *  in a browser, where there is no file system to hand to OPEN DATASET.
+ *  OUTPUT empties or creates a file, APPENDING and UPDATE create it when
+ *  missing, INPUT of a missing file fails with the message a system gives. */
+class MemoryDataset {
+    files;
+    constructor(files = {}) {
+        this.files = files;
+    }
+    async open(name, mode) {
+        const files = this.files;
+        if (files[name] === undefined) {
+            if (mode === "INPUT") {
+                return { message: "No such file or directory" };
+            }
+            files[name] = new Uint8Array(0);
+        }
+        if (mode === "OUTPUT") {
+            files[name] = new Uint8Array(0);
+        }
+        return {
+            read: async (position, length) => files[name].slice(position, position + length),
+            write: async (position, bytes) => {
+                const end = Math.max(files[name].length, position + bytes.length);
+                const out = new Uint8Array(end);
+                out.set(files[name], 0);
+                out.set(bytes, position);
+                files[name] = out;
+            },
+            size: async () => files[name].length,
+            close: async () => undefined,
+        };
+    }
+    async delete(name) {
+        if (this.files[name] === undefined) {
+            return false;
+        }
+        delete this.files[name];
+        return true;
+    }
+}
+exports.MemoryDataset = MemoryDataset;
+//# sourceMappingURL=memory_dataset.js.map

package/build/src/index.d.ts

@@ -21,7 +21,10 @@ import { ABAPEventing } from "./abap_eventing";
 import { isLineNotFound } from "./is_line_not_found";
 import { parametersCall } from "./parameters_call";
 import { alphaIn, alphaOut } from "./alpha";
+import { DatasetHost } from "./dataset/dataset";
 export { RFC, types, DB, MemoryConsole };
+export type { DatasetHost, DatasetHandle, DatasetMode } from "./dataset/dataset";
+export { MemoryDataset } from "./dataset/memory_dataset";
 export type RuntimeDatabaseOptions = {
     schemaPrefix?: string;
     tablePrefix?: string;
@@ -29,6 +32,7 @@ export type RuntimeDatabaseOptions = {
 export type RuntimeOptions = {
     console?: Console;
     database?: RuntimeDatabaseOptions;
+    dataset?: DatasetHost;
 };
 export declare class ABAP {
     Classes: {

package/build/src/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ABAP = exports.MemoryConsole = exports.DB = exports.types = exports.RFC = void 0;
+exports.ABAP = exports.MemoryDataset = exports.MemoryConsole = exports.DB = exports.types = exports.RFC = void 0;
 const context_1 = require("./context");
 const offset_length_1 = require("./offset_length");
 const statements_1 = require("./statements");
@@ -61,6 +61,8 @@ const abap_eventing_1 = require("./abap_eventing");
 const is_line_not_found_1 = require("./is_line_not_found");
 const parameters_call_1 = require("./parameters_call");
 const alpha_1 = require("./alpha");
+var memory_dataset_1 = require("./dataset/memory_dataset");
+Object.defineProperty(exports, "MemoryDataset", { enumerable: true, get: function () { return memory_dataset_1.MemoryDataset; } });
 class ABAP {
     // global objects
     Classes = {};
@@ -101,6 +103,7 @@ class ABAP {
         this.context = new context_1.Context();
         this.console = input?.console ? input?.console : new standard_out_console_1.StandardOutConsole();
         this.context.console = this.console;
+        this.context.dataset = input?.dataset;
         this.dbo = input?.database || { schemaPrefix: "", tablePrefix: "" };
         if (this.dbo.schemaPrefix === undefined) {
             this.dbo.schemaPrefix = "";

package/build/src/primary_key.d.ts

@@ -1,2 +1,2 @@
-import { Table } from "./types";
-export declare function primaryKeyValues(target: Table, row: any): any[];
+import { HashedTable, Table } from "./types";
+export declare function primaryKeyValues(target: Table | HashedTable, row: any): any[];

package/build/src/statements/collect.d.ts

@@ -1,3 +1,3 @@
-import { Table } from "../types";
+import { HashedTable, Structure, Table } from "../types";
 import { ICharacter } from "../types/_character";
-export declare function collect(source: ICharacter | Table, target?: Table): void;
+export declare function collect(source: ICharacter | Structure | Table, target?: Table | HashedTable): void;

package/build/src/statements/collect.js

@@ -2,25 +2,64 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collect = collect;
 const compare_1 = require("../compare");
+const primary_key_1 = require("../primary_key");
 const types_1 = require("../types");
 const insert_internal_1 = require("./insert_internal");
-const read_table_1 = require("./read_table");
+function sumNumeric(found, source, keyValues) {
+    if (found instanceof types_1.Structure && source instanceof types_1.Structure) {
+        for (const name of Object.keys(source.get())) {
+            sumNumeric(found.get()[name], source.get()[name], keyValues);
+        }
+    }
+    else if (keyValues.has(source)) {
+        return;
+    }
+    else if (found instanceof types_1.Integer && source instanceof types_1.Integer) {
+        found.set(found.get() + source.get());
+    }
+    else if (found instanceof types_1.Integer8 && source instanceof types_1.Integer8) {
+        found.set(found.get() + source.get());
+    }
+    else if (found instanceof types_1.Packed && source instanceof types_1.Packed) {
+        const decimals = found.getDecimals();
+        const factor = 10n ** BigInt(decimals);
+        const left = BigInt(found.toFixed(decimals).replace(".", ""));
+        const right = BigInt(source.toFixed(decimals).replace(".", ""));
+        const total = left + right;
+        const magnitude = total < 0n ? -total : total;
+        const fraction = decimals === 0 ? "" : "." + (magnitude % factor).toString().padStart(decimals, "0");
+        found.set((total < 0n ? "-" : "") + (magnitude / factor).toString() + fraction);
+    }
+    else if (found instanceof types_1.Float && source instanceof types_1.Float) {
+        found.set(found.getRaw() + source.getRaw());
+    }
+    else if (found instanceof types_1.DecFloat34 && source instanceof types_1.DecFloat34) {
+        found.set(found.getRaw() + source.getRaw());
+    }
+}
 function collect(source, target) {
     if (target === undefined && source instanceof types_1.Table) {
-        // with header line
-        const read = (0, read_table_1.readTable)(source, { withKey: (i) => { return (0, compare_1.eq)(i.table_line, source.getHeader()); } });
-        if (read.subrc === 4) {
-            (0, insert_internal_1.insertInternal)({ table: source, data: source.getHeader() });
-        }
+        target = source;
+        source = source.getHeader();
     }
-    else if (target !== undefined) {
-        const read = (0, read_table_1.readTable)(target, { withKey: (i) => { return (0, compare_1.eq)(i.table_line, source); } });
-        if (read.subrc === 4) {
-            (0, insert_internal_1.insertInternal)({ table: target, data: source });
-        }
+    if (target === undefined) {
+        throw new Error("COLLECT, no target specified");
+    }
+    const sourceKeys = (0, primary_key_1.primaryKeyValues)(target, source);
+    const matches = (row) => {
+        const rowKeys = (0, primary_key_1.primaryKeyValues)(target, row);
+        return rowKeys.length === sourceKeys.length && rowKeys.every((key, index) => (0, compare_1.eq)(key, sourceKeys[index]));
+    };
+    const rows = target.array();
+    let index = rows.findIndex(matches);
+    if (index >= 0) {
+        sumNumeric(rows[index], source, new Set(sourceKeys));
+        abap.builtin.sy.get().subrc.set(0);
     }
     else {
-        throw new Error("COLLECT, no target specified");
+        (0, insert_internal_1.insertInternal)({ table: target, data: source });
+        index = target.array().findIndex(matches);
     }
+    abap.builtin.sy.get().tabix.set(target instanceof types_1.HashedTable ? 0 : index + 1);
 }
 //# sourceMappingURL=collect.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/dataset.d.ts

@@ -0,0 +1,23 @@
+import { Context } from "../context";
+import { FieldSymbol } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+import { IGetDatasetOptions, IOpenDatasetOptions, IReadDatasetOptions, ITransferOptions } from "../dataset/dataset";
+export declare class DatasetStatements {
+    private readonly context;
+    constructor(context: Context);
+    private host;
+    private opened;
+    openDataset(nameIn: ICharacter | FieldSymbol | string, options: IOpenDatasetOptions): Promise<void>;
+    closeDataset(nameIn: ICharacter | FieldSymbol | string): Promise<void>;
+    deleteDataset(nameIn: ICharacter | FieldSymbol | string): Promise<void>;
+    transfer(sourceIn: any, nameIn: ICharacter | FieldSymbol | string, options?: ITransferOptions): Promise<void>;
+    readDataset(nameIn: ICharacter | FieldSymbol | string, targetIn: any, options?: IReadDatasetOptions): Promise<void>;
+    private readLine;
+    private readBytes;
+    getDataset(nameIn: ICharacter | FieldSymbol | string, options: IGetDatasetOptions): Promise<void>;
+    setDataset(nameIn: ICharacter | FieldSymbol | string, options: {
+        position?: INumeric | FieldSymbol;
+        endOfFile?: boolean;
+    }): Promise<void>;
+}

package/build/src/statements/dataset.js

@@ -0,0 +1,343 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatasetStatements = void 0;
+const throw_error_1 = require("../throw_error");
+const types_1 = require("../types");
+// OPEN / READ / TRANSFER / CLOSE / DELETE / GET / SET DATASET.
+//
+// The ABAP semantics live here, once: text lines, the byte layout of each
+// mode, ACTUAL LENGTH, sy-subrc and the exceptions. A host supplies bytes
+// only (DatasetHost), the way a DatabaseClient supplies rows, so that
+// a sandboxed file system, an in-memory one in a browser and a test double
+// all behave the same. Without a host every statement throws, as before.
+// The host and the options are defined in ../dataset/dataset.ts, and an
+// in-memory host is ../dataset/memory_dataset.ts.
+// what the text mode reads per host call while it looks for the end of a line
+const CHUNK = 64 * 1024;
+function deref(value) {
+    if (value instanceof types_1.FieldSymbol) {
+        const pointer = value.getPointer();
+        if (pointer === undefined) {
+            throw new Error("GETWA_NOT_ASSIGNED");
+        }
+        return pointer;
+    }
+    return value;
+}
+function nameOf(name) {
+    const value = typeof name === "string" ? name : deref(name).get();
+    // a C field holding the name is padded; the name is not
+    return (value + "").replace(/ +$/, "");
+}
+function numberOf(value) {
+    return value === undefined ? undefined : Number(deref(value).get());
+}
+function setSubrc(value) {
+    abap.builtin.sy.get().subrc.set(value);
+}
+function isHex(target) {
+    return target instanceof types_1.Hex || target instanceof types_1.HexUInt8;
+}
+function isCharLike(target) {
+    return typeof target?.get === "function" && typeof target.get() === "string" && !isHex(target) && !(target instanceof types_1.XString);
+}
+function hexToBytes(hex) {
+    const out = new Uint8Array(Math.floor(hex.length / 2));
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return out;
+}
+function bytesToHex(bytes) {
+    let out = "";
+    for (const b of bytes) {
+        out += b.toString(16).toUpperCase().padStart(2, "0");
+    }
+    return out;
+}
+// a character-like field in BINARY MODE is its code units in the system code
+// page, UTF-16LE on a Unicode system (measured: c(4) 'ab' is 6100 6200
+// 2000 2000)
+function utf16le(text) {
+    const out = new Uint8Array(text.length * 2);
+    for (let i = 0; i < text.length; i++) {
+        const code = text.charCodeAt(i);
+        out[i * 2] = code % 256;
+        out[i * 2 + 1] = Math.floor(code / 256);
+    }
+    return out;
+}
+function fromUtf16le(bytes) {
+    let out = "";
+    for (let i = 0; i + 1 < bytes.length; i += 2) {
+        out += globalThis.String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+    }
+    return out;
+}
+function concat(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+class DatasetStatements {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    host(statement) {
+        if (this.context.dataset === undefined) {
+            throw new Error(`${statement}, not supported: no dataset host installed (abap.context.dataset)`);
+        }
+        return this.context.dataset;
+    }
+    opened(name) {
+        const file = this.context.datasets[name];
+        if (file === undefined) {
+            (0, throw_error_1.throwError)("CX_SY_FILE_OPEN_MODE");
+        }
+        return file;
+    }
+    async openDataset(nameIn, options) {
+        const host = this.host("OPEN DATASET");
+        if (options.legacy === true || options.encoding === "NON-UNICODE") {
+            throw new Error("OPEN DATASET, LEGACY and NON-UNICODE modes not supported");
+        }
+        if (options.unsupported !== undefined && options.unsupported.length > 0) {
+            throw new Error(`OPEN DATASET, not supported: ${options.unsupported.join(", ")}`);
+        }
+        const name = nameOf(nameIn);
+        if (this.context.datasets[name] !== undefined) {
+            (0, throw_error_1.throwError)("CX_SY_FILE_OPEN");
+        }
+        const opened = await host.open(name, options.mode);
+        if (!("read" in opened)) {
+            if (options.message !== undefined) {
+                deref(options.message).set(opened.message);
+            }
+            setSubrc(8);
+            return;
+        }
+        let position = 0;
+        if (options.mode === "APPENDING") {
+            position = await opened.size();
+        }
+        const at = numberOf(options.position);
+        if (at !== undefined) {
+            position = at;
+        }
+        this.context.datasets[name] = { handle: opened, mode: options.mode, binary: options.binary, position };
+        setSubrc(0);
+    }
+    async closeDataset(nameIn) {
+        this.host("CLOSE DATASET");
+        const name = nameOf(nameIn);
+        const file = this.context.datasets[name];
+        // closing a file that is not open is no error (measured: sy-subrc 0)
+        if (file !== undefined) {
+            delete this.context.datasets[name];
+            await file.handle.close();
+        }
+        setSubrc(0);
+    }
+    async deleteDataset(nameIn) {
+        const host = this.host("DELETE DATASET");
+        const name = nameOf(nameIn);
+        // deleting an open file answers 0 and closes it: a READ after it raises
+        // CX_SY_FILE_OPEN_MODE (measured)
+        const file = this.context.datasets[name];
+        if (file !== undefined) {
+            delete this.context.datasets[name];
+            await file.handle.close();
+        }
+        setSubrc(await host.delete(name) ? 0 : 4);
+    }
+    async transfer(sourceIn, nameIn, options = {}) {
+        this.host("TRANSFER");
+        const file = this.opened(nameOf(nameIn));
+        if (file.mode === "INPUT") {
+            (0, throw_error_1.throwError)("CX_SY_FILE_OPEN_MODE");
+        }
+        const source = deref(sourceIn);
+        const length = numberOf(options.length);
+        let bytes;
+        if (file.binary === true) {
+            if (isHex(source) || source instanceof types_1.XString) {
+                bytes = hexToBytes(source.get());
+            }
+            else if (isCharLike(source)) {
+                let text = source.get();
+                if (source instanceof types_1.Character) {
+                    text = text.padEnd(source.getLength(), " ");
+                }
+                bytes = utf16le(length === undefined ? text : text.substring(0, length));
+                if (length !== undefined) {
+                    const want = length * 2;
+                    bytes = bytes.length >= want ? bytes : concat(bytes, utf16le(" ".repeat((want - bytes.length) / 2)));
+                }
+            }
+            else {
+                throw new Error("TRANSFER, BINARY MODE supports byte-like and character-like fields only");
+            }
+            if (length !== undefined && (isHex(source) || source instanceof types_1.XString)) {
+                bytes = bytes.length >= length ? bytes.slice(0, length) : concat(bytes, new Uint8Array(length - bytes.length));
+            }
+        }
+        else {
+            if (!isCharLike(source)) {
+                throw new Error("TRANSFER, TEXT MODE is only supported for character-type data objects");
+            }
+            let text = source.get();
+            if (length !== undefined) {
+                if (source instanceof types_1.Character) {
+                    text = text.padEnd(source.getLength(), " ");
+                }
+                text = text.substring(0, length);
+            }
+            else if (source instanceof types_1.Character) {
+                // measured: c(10) 'ab' is written as 'ab' and a line end;
+                // a string keeps its trailing blanks
+                text = source.getTrimEnd();
+            }
+            if (options.noEndOfLine !== true) {
+                text = text + "\n";
+            }
+            bytes = new TextEncoder().encode(text);
+        }
+        await file.handle.write(file.position, bytes);
+        file.position += bytes.length;
+        setSubrc(0);
+    }
+    async readDataset(nameIn, targetIn, options = {}) {
+        this.host("READ DATASET");
+        const file = this.opened(nameOf(nameIn));
+        const target = deref(targetIn);
+        const maximum = numberOf(options.maximumLength);
+        const setActual = (n) => {
+            if (options.actualLength !== undefined) {
+                deref(options.actualLength).set(n);
+            }
+        };
+        // a file opened for writing only answers 4 (measured, OUTPUT and APPENDING)
+        if (file.mode === "OUTPUT" || file.mode === "APPENDING") {
+            setActual(0);
+            setSubrc(4);
+            return;
+        }
+        if (file.binary === false) {
+            await this.readLine(file, target, maximum, setActual);
+        }
+        else {
+            await this.readBytes(file, target, maximum, setActual);
+        }
+    }
+    // TEXT MODE: one line per READ, without its LF (a CR before it stays,
+    // measured); the last line needs no LF; at the end sy-subrc 4 and the target
+    // cleared. ACTUAL LENGTH is the whole line even when the target is shorter,
+    // and the whole line is consumed either way.
+    async readLine(file, target, maximum, setActual) {
+        if (!isCharLike(target)) {
+            throw new Error("READ DATASET, the current statement is only supported for character-type data objects");
+        }
+        if (maximum !== undefined) {
+            throw new Error("READ DATASET, MAXIMUM LENGTH in TEXT MODE not supported");
+        }
+        let line = new Uint8Array(0);
+        let position = file.position;
+        let ended = false;
+        for (;;) {
+            const chunk = await file.handle.read(position, CHUNK);
+            if (chunk.length === 0) {
+                break;
+            }
+            const lf = chunk.indexOf(0x0A);
+            if (lf >= 0) {
+                line = concat(line, chunk.subarray(0, lf));
+                position += lf + 1;
+                ended = true;
+                break;
+            }
+            line = concat(line, chunk);
+            position += chunk.length;
+        }
+        if (ended === false && line.length === 0) {
+            target.clear();
+            setActual(0);
+            setSubrc(4);
+            return;
+        }
+        file.position = position;
+        const text = new TextDecoder("utf-8").decode(line);
+        target.set(text);
+        setActual(text.length);
+        setSubrc(0);
+    }
+    // BINARY MODE: a field of fixed length takes its length in bytes (a C
+    // field two per character, UTF-16LE), a string or xstring the rest of the
+    // file; MAXIMUM LENGTH caps the bytes; fewer bytes than asked is sy-subrc 4
+    // and ACTUAL LENGTH counts bytes (measured)
+    async readBytes(file, target, maximum, setActual) {
+        let want;
+        if (isHex(target)) {
+            want = target.getLength();
+        }
+        else if (target instanceof types_1.Character) {
+            want = target.getLength() * 2;
+        }
+        else if (target instanceof types_1.XString || target instanceof types_1.String) {
+            want = Math.max(0, await file.handle.size() - file.position);
+        }
+        else if (isCharLike(target) && typeof target.getLength === "function") {
+            want = target.getLength() * 2;
+        }
+        else {
+            throw new Error("READ DATASET, BINARY MODE supports byte-like and character-like fields only");
+        }
+        const variable = target instanceof types_1.XString || target instanceof types_1.String;
+        if (maximum !== undefined) {
+            want = Math.min(want, maximum);
+        }
+        const bytes = want === 0 ? new Uint8Array(0) : await file.handle.read(file.position, want);
+        file.position += bytes.length;
+        if (isHex(target)) {
+            target.set(bytesToHex(bytes).padEnd(target.getLength() * 2, "0"));
+        }
+        else if (target instanceof types_1.XString) {
+            target.set(bytesToHex(bytes));
+        }
+        else {
+            target.set(fromUtf16le(bytes));
+        }
+        setActual(bytes.length);
+        if (variable === true) {
+            setSubrc(bytes.length > 0 ? 0 : 4);
+        }
+        else {
+            setSubrc(bytes.length < want || want === 0 ? 4 : 0);
+        }
+    }
+    async getDataset(nameIn, options) {
+        this.host("GET DATASET");
+        const file = this.opened(nameOf(nameIn));
+        if (options.attributes !== undefined) {
+            throw new Error("GET DATASET, ATTRIBUTES not supported");
+        }
+        if (options.position !== undefined) {
+            deref(options.position).set(file.position);
+        }
+        setSubrc(0);
+    }
+    async setDataset(nameIn, options) {
+        this.host("SET DATASET");
+        const file = this.opened(nameOf(nameIn));
+        if (options.endOfFile === true) {
+            file.position = await file.handle.size();
+        }
+        else if (options.position !== undefined) {
+            file.position = numberOf(options.position) ?? 0;
+        }
+        setSubrc(0);
+    }
+}
+exports.DatasetStatements = DatasetStatements;
+//# sourceMappingURL=dataset.js.map

package/build/src/statements/index.d.ts

@@ -1,4 +1,5 @@
 import { append } from "./append";
+import { IGetDatasetOptions, IOpenDatasetOptions, IReadDatasetOptions, ITransferOptions } from "../dataset/dataset";
 import { assert } from "./assert";
 import { assign } from "./assign";
 import { ICommitOptions } from "./commit";
@@ -110,5 +111,15 @@ export declare class Statements {
     message(options: IMessageOptions): Promise<void>;
     readReport(name: ICharacter, options: Parameters<typeof readReport>[1]): Promise<void>;
     write(source: INumeric | ICharacter | FieldSymbol | string | number, options?: IWriteOptions): void;
+    openDataset(name: any, options: IOpenDatasetOptions): Promise<void>;
+    closeDataset(name: any): Promise<void>;
+    deleteDataset(name: any): Promise<void>;
+    transfer(source: any, name: any, options?: ITransferOptions): Promise<void>;
+    readDataset(name: any, target: any, options?: IReadDatasetOptions): Promise<void>;
+    getDataset(name: any, options: IGetDatasetOptions): Promise<void>;
+    setDataset(name: any, options: {
+        position?: any;
+        endOfFile?: boolean;
+    }): Promise<void>;
     skip(options?: ISkipOptions): void;
 }

package/build/src/statements/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Statements = void 0;
 const append_1 = require("./append");
+const dataset_1 = require("./dataset");
 const assert_1 = require("./assert");
 const assign_1 = require("./assign");
 const commit_1 = require("./commit");
@@ -148,6 +149,27 @@ class Statements {
     write(source, options) {
         return new write_1.WriteStatement(this.context).write(source, options);
     }
+    async openDataset(name, options) {
+        return new dataset_1.DatasetStatements(this.context).openDataset(name, options);
+    }
+    async closeDataset(name) {
+        return new dataset_1.DatasetStatements(this.context).closeDataset(name);
+    }
+    async deleteDataset(name) {
+        return new dataset_1.DatasetStatements(this.context).deleteDataset(name);
+    }
+    async transfer(source, name, options) {
+        return new dataset_1.DatasetStatements(this.context).transfer(source, name, options);
+    }
+    async readDataset(name, target, options) {
+        return new dataset_1.DatasetStatements(this.context).readDataset(name, target, options);
+    }
+    async getDataset(name, options) {
+        return new dataset_1.DatasetStatements(this.context).getDataset(name, options);
+    }
+    async setDataset(name, options) {
+        return new dataset_1.DatasetStatements(this.context).setDataset(name, options);
+    }
     skip(options) {
         return new skip_1.SkipStatement(this.context).skip(options);
     }

package/build/src/statements/loop.js

@@ -2,19 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loop = loop;
 const binary_search_1 = require("../binary_search");
+const compare_1 = require("../compare");
 const types_1 = require("../types");
 function determineFromTo(array, topEquals, key) {
     if (topEquals === undefined) {
         // 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);
     }
@@ -23,6 +28,53 @@ function determineFromTo(array, topEquals, key) {
         to: to,
     };
 }
+/** -1 / 0 / 1: the key field x sorts before / equal to / after the WHERE operand
+ *  v - only for pairs whose order agrees with the table's sort (sort.ts compares
+ *  the fields with lt/eq): the same type, of the same length for c, n and x, or
+ *  a c operand against a string field, which eq compares by its getTrimEnd() */
+function keyComparator(sample, value) {
+    if (value === null || typeof value !== "object" || sample === null || typeof sample !== "object") {
+        return undefined;
+    }
+    if (sample.constructor === value.constructor) {
+        const fixed = sample instanceof types_1.Character || sample instanceof types_1.Numc || sample instanceof types_1.Hex;
+        if (fixed && sample.getLength() !== value.getLength()) {
+            return undefined;
+        }
+        return (x, v) => ((0, compare_1.eq)(x, v) ? 0 : (0, compare_1.lt)(x, v) ? -1 : 1);
+    }
+    if (sample instanceof types_1.String && value instanceof types_1.Character) {
+        return (x, v) => {
+            const s = v.getTrimEnd();
+            const xs = x.get();
+            return xs === s ? 0 : xs < s ? -1 : 1;
+        };
+    }
+    return undefined;
+}
+/** A SORTED primary key, and a WHERE that requires its first field to equal a
+ *  value: the rows the WHERE can accept are one block of the array. Relies on
+ *  topEquals holding only conditions every row has to meet - see the
+ *  transpiler's LoopTranspiler, which emits it for a conjunction only */
+function sortedPrimaryBlock(table, options) {
+    const primary = table.getOptions()?.primaryKey;
+    if (!(table instanceof types_1.Table) || primary?.type !== types_1.TableAccessType.sorted
+        || !primary.keyFields?.length || options?.topEquals === undefined) {
+        return undefined;
+    }
+    const field = primary.keyFields[0].toLowerCase();
+    const value = options.topEquals[field];
+    const rowType = table.getRowType();
+    const structured = rowType instanceof types_1.Structure;
+    if (value === undefined || structured === (field === "table_line")) {
+        return undefined;
+    }
+    const compare = keyComparator(structured ? rowType.get()[field] : rowType, value);
+    if (compare === undefined) {
+        return undefined;
+    }
+    return structured ? (row) => compare(row.get()[field], value) : (row) => compare(row, value);
+}
 // todo: rewrite, this is a mess & hack & slow
 function dynamicToWhere(condition, evaluate) {
     //  console.dir(condition);
@@ -99,7 +151,10 @@ 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") {
+    let block = undefined;
+    // 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;
@@ -107,6 +162,24 @@ async function* loop(table, options) {
     }
     else {
         array = table.array();
+        if (options?.where !== undefined && options.from === undefined && options.to === undefined) {
+            block = sortedPrimaryBlock(table, options);
+        }
+        if (block !== undefined) {
+            // the first row that does not sort before the value
+            let lo = 0;
+            let hi = array.length;
+            while (lo < hi) {
+                const mid = Math.floor((lo + hi) / 2);
+                if (block(array[mid]) < 0) {
+                    lo = mid + 1;
+                }
+                else {
+                    hi = mid;
+                }
+            }
+            loopFrom = lo;
+        }
     }
     const loopController = table.startLoop(loopFrom, loopTo, array);
     let entered = false;
@@ -122,7 +195,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,10 +204,16 @@ 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];
+            if (block !== undefined && block(current) > 0) {
+                // this row sorts after the value, and so does every row behind it
+                break;
+            }
             if (options?.where) {
                 const row = isStructured ? current.get() : { table_line: current };
                 if (await options.where(row) === false) {

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.96",
   "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"
   }
 }