@abaplint/runtime 2.13.95 → 2.13.97

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,19 @@ export declare class Context {
     RFCDestinations: {
         [name: string]: RFC.RFCClient;
     };
+    updateTask: {
+        register(name: string, param: {
+            exporting?: any;
+            tables?: any;
+        }): Promise<void> | void;
+    } | undefined;
+    dataset: DatasetHost | undefined;
+    datasets: {
+        [name: string]: OpenDataset;
+    };
+    runTime: {
+        start: number;
+        last: number;
+    } | undefined;
     defaultDB(): DatabaseClient;
 }

package/build/src/context.js

@@ -8,6 +8,14 @@ class Context {
     // DEFAULT and secondary database connections
     databaseConnections = {};
     RFCDestinations = {};
+    // CALL FUNCTION IN UPDATE TASK hands the copied parameters to the host, if one is set
+    updateTask = undefined;
+    // the file system OPEN DATASET and friends read and write; none by default,
+    // and then every DATASET statement throws
+    dataset = undefined;
+    datasets = {};
+    // GET RUN TIME, the clock reading of the first call, and the last value returned
+    runTime = undefined;
     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/operators/divide.d.ts

@@ -2,3 +2,6 @@ import { Float, Integer, Integer8 } from "../types";
 import { ICharacter } from "../types/_character";
 import { INumeric } from "../types/_numeric";
 export declare function divide(left: INumeric | ICharacter | Integer8 | string | number, right: INumeric | ICharacter | Integer8 | string | number): Float | Integer8 | Integer;
+/** "/" in calculation type int8, which the transpiler knows from an int8 target: the
+ * operands are int8 and the quotient is rounded half away from zero, 7 / 2 = 4, -7 / 2 = -4 */
+export declare function divideInt8(left: INumeric | ICharacter | Integer8 | string | number, right: INumeric | ICharacter | Integer8 | string | number): Integer8;

package/build/src/operators/divide.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.divide = divide;
+exports.divideInt8 = divideInt8;
 const throw_error_1 = require("../throw_error");
 const types_1 = require("../types");
 const _parse_1 = require("./_parse");
@@ -42,4 +43,22 @@ function isIntegerOperand(val) {
     }
     return val instanceof types_1.Integer8;
 }
+/** "/" in calculation type int8, which the transpiler knows from an int8 target: the
+ * operands are int8 and the quotient is rounded half away from zero, 7 / 2 = 4, -7 / 2 = -4 */
+function divideInt8(left, right) {
+    const l = left instanceof types_1.Integer8 ? left.get() : new types_1.Integer8().set(left).get();
+    const r = right instanceof types_1.Integer8 ? right.get() : new types_1.Integer8().set(right).get();
+    if (r === 0n) {
+        if (l === 0n) {
+            return new types_1.Integer8().set(0n);
+        }
+        (0, throw_error_1.throwError)("CX_SY_ZERODIVIDE");
+    }
+    let q = l / r;
+    const rem = l % r;
+    if ((rem < 0n ? -rem : rem) * 2n >= (r < 0n ? -r : r)) {
+        q = (l < 0n) === (r < 0n) ? q + 1n : q - 1n;
+    }
+    return new types_1.Integer8().set(q);
+}
 //# sourceMappingURL=divide.js.map

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

@@ -1,6 +1,7 @@
 import { Context } from "../context";
 export interface ICallFunctionOptions {
     name: string;
+    updateTask?: boolean;
     destination?: string;
     calling?: (INPUT: any) => any;
     exporting?: any;

package/build/src/statements/call_function.js

@@ -9,7 +9,7 @@ class CallFunction {
     constructor(context) {
         this.context = context;
     }
-    // note: this is only called if DESTINIATION is supplied
+    // called for DESTINATION, CALLING or IN UPDATE TASK
     async callFunction(options) {
         const param = {
             exporting: options.exporting,
@@ -20,7 +20,32 @@ class CallFunction {
         };
         options.name = options.name.trimEnd();
         const fm = abap.FunctionModules[options.name];
-        if (options.destination) {
+        if (options.updateTask) {
+            if (fm === undefined) {
+                (0, throw_error_1.throwError)("CX_SY_DYN_CALL_ILLEGAL_FUNC");
+            }
+            const copy = (values) => {
+                if (values === undefined) {
+                    return undefined;
+                }
+                const result = {};
+                for (const key of Object.keys(values)) {
+                    const value = values[key];
+                    result[key] = value instanceof types_1.FieldSymbol ? value.getPointer().clone() : value.clone();
+                }
+                return result;
+            };
+            // IMPORTING and CHANGING do not apply to update modules.
+            const copied = { exporting: copy(options.exporting), tables: copy(options.tables) };
+            if (this.context.updateTask) {
+                await this.context.updateTask.register(options.name, copied);
+            }
+            else {
+                await fm(copied);
+            }
+            return;
+        }
+        else if (options.destination) {
             if (options.destination.trim() === "") {
                 if (fm === undefined) {
                     (0, throw_error_1.throwError)("CX_SY_DYN_CALL_ILLEGAL_FUNC");

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

@@ -1,2 +1,3 @@
+import { Context } from "../context";
 import { INumeric } from "../types/_numeric";
-export declare function getRunTime(value: INumeric): void;
+export declare function getRunTime(context: Context, value: INumeric): void;

package/build/src/statements/get_run_time.js

@@ -1,16 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRunTime = getRunTime;
-let prev = undefined;
-function getRunTime(value) {
-    if (prev === undefined) {
-        value.set(0);
-        prev = new Date().getTime();
+// milliseconds with a fraction, from a monotonic clock where there is one:
+// performance.now() in Node, Bun and browsers, Date.now() otherwise
+function now() {
+    if (typeof performance === "object" && typeof performance?.now === "function") {
+        return performance.now();
     }
-    else {
-        const now = new Date().getTime();
-        value.set(now - prev);
-        prev = now;
+    return Date.now();
+}
+// GET RUN TIME FIELD: microseconds since the first call in the internal
+// session, which gives 0. The first call is per context, so per ABAP instance
+function getRunTime(context, value) {
+    const t = now();
+    if (context.runTime === undefined) {
+        context.runTime = { start: t, last: 0 };
+    }
+    let micro = Math.floor((t - context.runTime.start) * 1000);
+    // never backwards, also when the clock is Date.now()
+    if (micro < context.runTime.last) {
+        micro = context.runTime.last;
     }
+    context.runTime.last = micro;
+    value.set(micro);
 }
 //# sourceMappingURL=get_run_time.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";
@@ -22,7 +23,6 @@ import { getLocale } from "./get_locale";
 import { unpack } from "./unpack";
 import { getParameter } from "./get_parameter";
 import { setLocale } from "./set_locale";
-import { getRunTime } from "./get_run_time";
 import { getTime } from "./get_time";
 import { IInsertDatabaseOptions } from "./insert_database";
 import { insertInternal } from "./insert_internal";
@@ -72,7 +72,6 @@ export declare class Statements {
     getBit: typeof getBit;
     getLocale: typeof getLocale;
     getParameter: typeof getParameter;
-    getRunTime: typeof getRunTime;
     getTime: typeof getTime;
     insertInternal: typeof insertInternal;
     loop: typeof loop;
@@ -95,6 +94,7 @@ export declare class Statements {
     private readonly context;
     constructor(context: Context);
     _setTrace(min?: number, totals?: boolean): Trace;
+    getRunTime(value: INumeric): void;
     openCursor(target: INumeric, select: string, options: IOpenCursorDatabaseOptions): Promise<void>;
     fetchNextCursor(cursor: INumeric, target: any, packageSize?: INumeric): Promise<void>;
     closeCursor(cursor: INumeric): Promise<void>;
@@ -110,5 +110,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");
@@ -75,7 +76,6 @@ class Statements {
     getBit = get_bit_1.getBit;
     getLocale = get_locale_1.getLocale;
     getParameter = get_parameter_1.getParameter;
-    getRunTime = get_run_time_1.getRunTime;
     getTime = get_time_1.getTime;
     insertInternal = insert_internal_1.insertInternal;
     loop = loop_1.loop;
@@ -102,6 +102,9 @@ class Statements {
     _setTrace(min = 10, totals = false) {
         return new trace_1.Trace().setTrace(min, totals, this);
     }
+    getRunTime(value) {
+        (0, get_run_time_1.getRunTime)(this.context, value);
+    }
     async openCursor(target, select, options) {
         const num = await (0, open_cursor_1.openCursor)(this.context, select, options);
         target.set(num);
@@ -148,6 +151,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,6 +2,7 @@
 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) {
@@ -27,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);
@@ -103,16 +151,36 @@ 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 = [];
-    // 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));
+    let block = undefined;
+    // the secondary key the loop runs over; undefined is the primary key, also
+    // when it is named - USING KEY PRIMARY_KEY, or a dynamic name holding it
+    const usingKey = (0, types_1.secondaryKeyName)(options?.usingKey);
+    if (usingKey !== undefined) {
+        array = table.getSecondaryIndex(usingKey);
+        const { from, to } = determineFromTo(array, options?.topEquals, table.getKeyByName(usingKey));
         loopFrom = Math.max(loopFrom, from) - 1;
         loopTo = Math.min(loopTo, to);
     }
     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;
@@ -128,9 +196,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 || isPrimaryKey
-        ? undefined
-        : table.getKeyByName(options.usingKey);
+    const usedKey = usingKey === undefined ? undefined : table.getKeyByName(usingKey);
     const hasRowNumber = usedKey !== undefined
         ? usedKey.type !== types_1.TableAccessType.hashed
         : !(table instanceof types_1.HashedTable);
@@ -143,6 +209,10 @@ async function* loop(table, options) {
                 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) {
@@ -155,7 +225,7 @@ async function* loop(table, options) {
             options?.atLast?.(loopController.index + 1 >= loopController.loopTo);
             yield current;
             loopController.index++;
-            if (options?.to === undefined && options?.usingKey === undefined) {
+            if (options?.to === undefined && usingKey === undefined) {
                 // extra rows might have been inserted inside the loop
                 loopController.loopTo = array.length;
             }

package/build/src/statements/read_table.js

@@ -169,6 +169,11 @@ function readTable(table, options) {
         // return readTable(table.getPointer(), options);
         table = table.getPointer();
     }
+    // WITH [TABLE] KEY primary_key COMPONENTS reads as the same READ without
+    // the key name; any other name, as ABAP reads it (secondaryKeyName)
+    if (options?.keyName !== undefined && (0, types_1.secondaryKeyName)(options.keyName) !== options.keyName) {
+        options = { ...options, keyName: (0, types_1.secondaryKeyName)(options.keyName) };
+    }
     // check if it is a primary index read specified with WITH KEY instead of WITH TABLE KEY
     if (options?.withTableKey === undefined
         && options?.withKeySimple

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

@@ -45,6 +45,11 @@ interface ITable {
 export declare class TableFactory {
     static construct(rowType: TableRowType, options?: ITableOptions, qualifiedName?: string): Table | HashedTable;
 }
+/** The secondary key a key name selects, as ABAP reads the name: without the
+ *  blanks a c field pads it with, in any case - and undefined for the primary
+ *  key, which primary_key names however it is written, and so does an initial
+ *  name (a dynamic USING KEY ( name ) that is empty). */
+export declare function secondaryKeyName(name: string | undefined): string | undefined;
 export declare class HashedTable implements ITable {
     private value;
     private readonly header;

package/build/src/types/table.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = exports.HashedTable = exports.TableFactory = exports.LoopController = exports.TableKeyType = exports.TableAccessType = void 0;
+exports.secondaryKeyName = secondaryKeyName;
 const integer_1 = require("./integer");
 const float_1 = require("./float");
 const abap_object_1 = require("./abap_object");
@@ -75,6 +76,14 @@ export class SortedTable {
   // todo
 }
 */
+/** The secondary key a key name selects, as ABAP reads the name: without the
+ *  blanks a c field pads it with, in any case - and undefined for the primary
+ *  key, which primary_key names however it is written, and so does an initial
+ *  name (a dynamic USING KEY ( name ) that is empty). */
+function secondaryKeyName(name) {
+    const trimmed = name?.trimEnd();
+    return trimmed === undefined || trimmed === "" || trimmed.toLowerCase() === "primary_key" ? undefined : trimmed;
+}
 class HashedTable {
     value;
     header;
@@ -107,11 +116,11 @@ class HashedTable {
         return Object.keys(this.value).length;
     }
     getKeyByName(name) {
-        return this.getOptions()?.secondary?.find(s => s.name.toUpperCase() === name.toUpperCase());
+        return this.getOptions()?.secondary?.find(s => s.name.toUpperCase() === name.trimEnd().toUpperCase());
     }
     getSecondaryIndex(name) {
-        if (this.secondaryIndexes[name.toUpperCase()]) {
-            return this.secondaryIndexes[name.toUpperCase()];
+        if (this.secondaryIndexes[name.trimEnd().toUpperCase()]) {
+            return this.secondaryIndexes[name.trimEnd().toUpperCase()];
         }
         const secondary = this.getKeyByName(name);
         if (secondary === undefined) {
@@ -120,7 +129,7 @@ class HashedTable {
         // note, array() already is a copy, so it can be used,
         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;
+        this.secondaryIndexes[name.trimEnd().toUpperCase()] = copy;
         return copy;
     }
     buildHashFromData(data) {
@@ -364,11 +373,11 @@ class Table {
         return this.value.length;
     }
     getKeyByName(name) {
-        return this.getOptions()?.secondary?.find(s => s.name.toUpperCase() === name.toUpperCase());
+        return this.getOptions()?.secondary?.find(s => s.name.toUpperCase() === name.trimEnd().toUpperCase());
     }
     getSecondaryIndex(name) {
-        if (this.secondaryIndexes[name.toUpperCase()]) {
-            return this.secondaryIndexes[name.toUpperCase()];
+        if (this.secondaryIndexes[name.trimEnd().toUpperCase()]) {
+            return this.secondaryIndexes[name.trimEnd().toUpperCase()];
         }
         const secondary = this.getKeyByName(name);
         if (secondary === undefined) {
@@ -376,7 +385,7 @@ class Table {
         }
         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;
+        this.secondaryIndexes[name.trimEnd().toUpperCase()] = copy;
         return copy;
     }
     getQualifiedName() {

package/package.json

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