@abaplint/runtime 2.13.83 → 2.13.85

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

@@ -0,0 +1,11 @@
+import { Integer } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IFindAnyNotOfInput {
+    val: ICharacter | string;
+    sub: ICharacter | string;
+    off?: INumeric | number;
+    len?: INumeric | number;
+    occ?: INumeric | number;
+}
+export declare function find_any_not_of(input: IFindAnyNotOfInput): Integer;

package/build/src/builtin/find_any_not_of.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.find_any_not_of = find_any_not_of;
+const types_1 = require("../types");
+const throw_error_1 = require("../throw_error");
+function find_any_not_of(input) {
+    const val = typeof input.val === "string" ? input.val : input.val.get();
+    const sub = typeof input.sub === "string" ? input.sub : input.sub.get();
+    const off = typeof input.off === "number" ? input.off : input.off?.get() || 0;
+    const len = typeof input.len === "number" ? input.len : input.len?.get();
+    let occ = typeof input.occ === "number" ? input.occ : input.occ?.get();
+    if (occ === 0) {
+        (0, throw_error_1.throwError)("CX_SY_STRG_PAR_VAL");
+    }
+    else if (occ === undefined) {
+        occ = 1;
+    }
+    if (off < 0 || off > val.length) {
+        (0, throw_error_1.throwError)("CX_SY_RANGE_OUT_OF_BOUNDS");
+    }
+    if (len !== undefined && (len < 0 || off + len > val.length)) {
+        (0, throw_error_1.throwError)("CX_SY_RANGE_OUT_OF_BOUNDS");
+    }
+    const end = len === undefined ? val.length : off + len;
+    const characters = new Set(sub.split(""));
+    let remaining = Math.abs(occ);
+    if (occ > 0) {
+        for (let i = off; i < end; i++) {
+            if (!characters.has(val.charAt(i)) && --remaining === 0) {
+                return new types_1.Integer().set(i);
+            }
+        }
+    }
+    else {
+        for (let i = end - 1; i >= off; i--) {
+            if (!characters.has(val.charAt(i)) && --remaining === 0) {
+                return new types_1.Integer().set(i);
+            }
+        }
+    }
+    return new types_1.Integer().set(-1);
+}
+//# sourceMappingURL=find_any_not_of.js.map

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

@@ -0,0 +1,11 @@
+import { Integer } from "../types";
+import { ICharacter } from "../types/_character";
+import { INumeric } from "../types/_numeric";
+export interface IFindAnyOfInput {
+    val: ICharacter | string;
+    sub: ICharacter | string;
+    off?: INumeric | number;
+    len?: INumeric | number;
+    occ?: INumeric | number;
+}
+export declare function find_any_of(input: IFindAnyOfInput): Integer;

package/build/src/builtin/find_any_of.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.find_any_of = find_any_of;
+const types_1 = require("../types");
+const throw_error_1 = require("../throw_error");
+function find_any_of(input) {
+    const val = typeof input.val === "string" ? input.val : input.val.get();
+    const sub = typeof input.sub === "string" ? input.sub : input.sub.get();
+    const off = typeof input.off === "number" ? input.off : input.off?.get() || 0;
+    const len = typeof input.len === "number" ? input.len : input.len?.get();
+    let occ = typeof input.occ === "number" ? input.occ : input.occ?.get();
+    if (occ === 0) {
+        (0, throw_error_1.throwError)("CX_SY_STRG_PAR_VAL");
+    }
+    else if (occ === undefined) {
+        occ = 1;
+    }
+    if (off < 0 || off > val.length) {
+        (0, throw_error_1.throwError)("CX_SY_RANGE_OUT_OF_BOUNDS");
+    }
+    if (len !== undefined && (len < 0 || off + len > val.length)) {
+        (0, throw_error_1.throwError)("CX_SY_RANGE_OUT_OF_BOUNDS");
+    }
+    if (sub === "") {
+        return new types_1.Integer().set(-1);
+    }
+    const end = len === undefined ? val.length : off + len;
+    const characters = new Set(sub.split(""));
+    let remaining = Math.abs(occ);
+    if (occ > 0) {
+        for (let i = off; i < end; i++) {
+            if (characters.has(val.charAt(i)) && --remaining === 0) {
+                return new types_1.Integer().set(i);
+            }
+        }
+    }
+    else {
+        for (let i = end - 1; i >= off; i--) {
+            if (characters.has(val.charAt(i)) && --remaining === 0) {
+                return new types_1.Integer().set(i);
+            }
+        }
+    }
+    return new types_1.Integer().set(-1);
+}
+//# sourceMappingURL=find_any_of.js.map

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

@@ -15,6 +15,8 @@ export * from "./count";
 export * from "./escape";
 export * from "./exp";
 export * from "./find";
+export * from "./find_any_not_of";
+export * from "./find_any_of";
 export * from "./floor";
 export * from "./frac";
 export * from "./from_mixed";

package/build/src/builtin/index.js

@@ -32,6 +32,8 @@ __exportStar(require("./count"), exports);
 __exportStar(require("./escape"), exports);
 __exportStar(require("./exp"), exports);
 __exportStar(require("./find"), exports);
+__exportStar(require("./find_any_not_of"), exports);
+__exportStar(require("./find_any_of"), exports);
 __exportStar(require("./floor"), exports);
 __exportStar(require("./frac"), exports);
 __exportStar(require("./from_mixed"), exports);

package/build/src/statements/find.js

@@ -12,7 +12,12 @@ function find(input, options) {
     let s = "";
     if (options.find) {
         s = options.find;
-        if (typeof s !== "string") {
+        if (s instanceof types_1.Character) {
+            // trailing blanks are ignored for fixed length character typed operands,
+            // note that text string operands keep them
+            s = s.getTrimEnd();
+        }
+        else if (typeof s !== "string") {
             s = s.get();
         }
         if (s === "") {

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

@@ -37,7 +37,7 @@ import { IRollbackOptions } from "./rollback";
 import { setBit } from "./set_bit";
 import { shift } from "./shift";
 import { sort } from "./sort";
-import { wait } from "./wait";
+import { IWaitOptions } from "./wait";
 import { IOpenCursorDatabaseOptions } from "./open_cursor";
 import { setHandler } from "./set_handler";
 import { split } from "./split";
@@ -88,7 +88,6 @@ export declare class Statements {
     sort: typeof sort;
     split: typeof split;
     translate: typeof translate;
-    wait: typeof wait;
     receive: typeof receive;
     callTransaction: typeof callTransaction;
     private readonly context;
@@ -99,6 +98,7 @@ export declare class Statements {
     closeCursor(cursor: INumeric): Promise<void>;
     commit(options?: ICommitOptions): Promise<void>;
     rollback(options?: IRollbackOptions): Promise<void>;
+    wait(options: IWaitOptions): Promise<void>;
     deleteDatabase(table: string | ICharacter, options: IDeleteDatabaseOptions): Promise<void>;
     insertDatabase(table: string | ICharacter, options: IInsertDatabaseOptions): Promise<number | undefined>;
     modifyDatabase(table: string | ICharacter, options: IModifyDatabaseOptions): Promise<void>;

package/build/src/statements/index.js

@@ -91,7 +91,6 @@ class Statements {
     sort = sort_1.sort;
     split = split_1.split;
     translate = translate_1.translate;
-    wait = wait_1.wait;
     receive = receive_1.receive;
     callTransaction = call_transaction_1.callTransaction;
     context;
@@ -117,6 +116,9 @@ class Statements {
     async rollback(options) {
         return (0, rollback_1.rollback)(this.context, options);
     }
+    async wait(options) {
+        return (0, wait_1.wait)(this.context, options);
+    }
     async deleteDatabase(table, options) {
         await (0, delete_database_1.deleteDatabase)(table, options, this.context);
     }

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

@@ -1,5 +1,9 @@
 import { INumeric } from "../types/_numeric";
-export declare function wait(options: {
-    cond: () => any;
+import { Context } from "../context";
+export interface IWaitOptions {
+    /** UNTIL, the logical expression, if not supplied its the simple "WAIT UP TO" variant */
+    cond?: () => any;
+    /** UP TO sec SECONDS */
     seconds?: INumeric;
-}): Promise<void>;
+}
+export declare function wait(context: Context, options: IWaitOptions): Promise<void>;

package/build/src/statements/wait.js

@@ -1,9 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wait = wait;
-async function wait(options) {
+// WAIT ends the current database LUW when it interrupts the execution of the program,
+// ie. all open database connections are committed, note that this is not a full COMMIT WORK,
+// sy-subrc is owned by the WAIT statement itself
+async function implicitCommit(context) {
+    for (const name of Object.keys(context.databaseConnections)) {
+        await context.databaseConnections[name].commit();
+    }
+}
+async function wait(context, options) {
     const timeout = options.seconds === undefined ? undefined : options.seconds.get() * 1000;
     const deadline = timeout === undefined ? undefined : Date.now() + timeout;
+    if (options.cond === undefined) {
+        // "WAIT UP TO sec SECONDS", the execution is always interrupted and sy-subrc is always zero
+        await implicitCommit(context);
+        await new Promise(r => setTimeout(r, timeout));
+        abap.builtin.sy.get().subrc.set(0);
+        return;
+    }
+    let interrupted = false;
     while (true) {
         if (options.cond() === true) {
             abap.builtin.sy.get().subrc.set(0);
@@ -14,6 +30,12 @@ async function wait(options) {
             abap.builtin.sy.get().subrc.set(8);
             return;
         }
+        if (interrupted === false) {
+            // the condition is not true, so the execution is about to be interrupted,
+            // commit before sleeping so the changes are visible to other sessions during the wait
+            interrupted = true;
+            await implicitCommit(context);
+        }
         await new Promise(r => setTimeout(r, Math.min(500, remaining)));
     }
 }

package/build/src/types/xstring.js

@@ -23,7 +23,9 @@ class XString {
     }
     set(value) {
         if (typeof value === "string") {
-            this.value = value;
+            // the input is interpreted as hexadecimal digits, the conversion stops at
+            // the first character which is not an uppercase hex digit
+            this.value = /^[0-9A-F]*/.exec(value)?.[0] || "";
             if (this.value.length % 2 === 1) {
                 this.value = this.value + "0";
             }

package/package.json

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