@abaplint/runtime 2.13.49 → 2.13.51

package/build/src/statements/concatenate.js

@@ -17,19 +17,22 @@ function concatenate(input) {
         }
     }
     if (input.lines === true) {
-        const list = [];
+        let result = "";
         const tab = input.source[0];
         if (tab instanceof types_1.Table) {
-            for (const l of tab.array()) {
-                if (input.respectingBlanks !== true) {
-                    list.push(l.get().trimEnd());
-                }
-                else {
-                    list.push(l.get());
+            const array = tab.array();
+            const length = array.length;
+            const respectingBlanks = input.respectingBlanks === true;
+            const hasSeparator = sep.length > 0;
+            for (let i = 0; i < length; i++) {
+                if (hasSeparator === true && i > 0) {
+                    result += sep;
                 }
+                const value = array[i].get();
+                result += respectingBlanks === true ? value : value.trimEnd();
             }
         }
-        input.target.set(list.join(sep));
+        input.target.set(result);
     }
     else {
         let result = "";

package/build/src/statements/insert_internal.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.insertInternal = insertInternal;
-const compare_1 = require("../compare");
 const types_1 = require("../types");
-const read_table_1 = require("./read_table");
 const sort_1 = require("./sort");
 function insertInternal(options) {
     if (options.table instanceof types_1.FieldSymbol) {
@@ -18,60 +16,34 @@ function insertInternal(options) {
         }
         options.data = options.data.getPointer();
     }
+    let data = options.data;
+    if (typeof data === "string") {
+        const tmp = options.table.getRowType().clone();
+        tmp.set(data);
+        data = tmp;
+    }
     const tableOptions = options.table.getOptions();
-    let isSorted = tableOptions?.primaryKey?.type === types_1.TableAccessType.sorted
+    const isSorted = tableOptions?.primaryKey?.type === types_1.TableAccessType.sorted
         || tableOptions?.primaryKey?.type === types_1.TableAccessType.hashed;
-    if (options.table instanceof types_1.HashedTable) {
-        isSorted = false;
-    }
-    else if (isSorted) {
-        const insert = options.data instanceof types_1.Structure ? options.data.get() : { table_line: options.data };
-        let compare = (row) => {
-            for (const key of tableOptions?.primaryKey?.keyFields || []) {
-                if (key.includes("-")) {
-                    const [first, second] = key.split("-");
-                    if ((0, compare_1.ne)(row[first.toLowerCase()].get()[second.toLowerCase()], insert[first.toLowerCase()].get()[second.toLowerCase()])) {
-                        return false;
-                    }
-                }
-                else {
-                    if ((0, compare_1.ne)(row[key.toLowerCase()], insert[key.toLowerCase()])) {
-                        return false;
-                    }
+    if (isSorted === true
+        && !(options.table instanceof types_1.HashedTable)
+        && options.index === undefined
+        && options.lines !== true) {
+        const insert = options.initial === true ? options.table.getRowType() : data;
+        if (insert !== undefined) {
+            const result = options.table.insertSorted(insert, (a, b) => (0, sort_1.compareRows)(a, b, tableOptions?.primaryKey?.keyFields || []), tableOptions?.primaryKey?.isUnique === true, options.noClone);
+            if (result.subrc === 0) {
+                if (options.assigning) {
+                    options.assigning.assign(result.value);
                 }
-            }
-            return true;
-        };
-        if (tableOptions.primaryKey?.isUnique === true) {
-            const withKeyValue = [];
-            let binary = false;
-            const data = options?.data;
-            if (data instanceof types_1.Structure) {
-                const fieldName = tableOptions.primaryKey.keyFields[0].toLowerCase();
-                if (fieldName !== "table_line" && fieldName.includes("-") === false) {
-                    withKeyValue.push({ key: (i) => { return i[fieldName]; }, value: data.get()[fieldName] });
-                    binary = true;
+                if (options.referenceInto) {
+                    options.referenceInto.assign(result.value);
                 }
             }
-            else {
-                compare = (row) => {
-                    // @ts-ignore
-                    return (0, compare_1.eq)(row.table_line, options.data);
-                };
-            }
-            (0, read_table_1.readTable)(options.table, { withKey: compare, withKeyValue: withKeyValue, binarySearch: binary });
-            if (abap.builtin.sy.get().subrc.get() === 0) {
-                abap.builtin.sy.get().subrc.set(4);
-                return;
-            }
+            abap.builtin.sy.get().subrc.set(result.subrc);
+            return;
         }
     }
-    let data = options.data;
-    if (typeof data === "string") {
-        const tmp = options.table.getRowType().clone();
-        tmp.set(data);
-        data = tmp;
-    }
     if (data && options.index) {
         const index = options.index.get() - 1;
         const val = options.table.insertIndex(data, index);
@@ -97,6 +69,19 @@ function insertInternal(options) {
         }
     }
     else if (options.initial === true) {
+        if (options.table instanceof types_1.HashedTable) {
+            const { value: val, subrc: subrc } = options.table.insert(options.table.getRowType());
+            if (subrc === 0) {
+                if (options.assigning) {
+                    options.assigning.assign(val);
+                }
+                if (options.referenceInto) {
+                    options.referenceInto.assign(val);
+                }
+            }
+            abap.builtin.sy.get().subrc.set(subrc);
+            return;
+        }
         let index = options.table.getArrayLength();
         if (options.index) {
             index = options.index.get() - 1;

package/build/src/statements/loop.js

@@ -31,10 +31,10 @@ function dynamicToWhere(condition, evaluate) {
     if (evaluate === undefined) {
         throw new Error("Dynamic WHERE evaluation function is not defined");
     }
-    const matches = text.matchAll(/([\w-]+)\s+(\w+)\s+([<>\w-]+)/gi);
+    const matches = text.matchAll(/([\w-]+)\s+(NOT\s+IN|\w+)\s+([<>\w-]+)/gi);
     for (const match of matches) {
         const left = match[1];
-        const comparator = match[2].toLowerCase();
+        const comparator = match[2].toLowerCase().replace(/\s+/g, " ");
         let right = "";
         //    console.dir({left, right});
         const cleft = "i." + left.toLowerCase().replace(/-/g, ".get().");
@@ -43,13 +43,21 @@ function dynamicToWhere(condition, evaluate) {
             const name = "fs_" + rightMatch[1].toLowerCase() + "_";
             right = `evaluate("${name}").get()["${rightMatch[2].toLowerCase()}"]`;
         }
+        const fieldSymbol = match[3].match(/^<(\w+)>$/);
+        if (right === "" && fieldSymbol) {
+            right = `evaluate("fs_${fieldSymbol[1].toLowerCase()}_").getPointer()`;
+        }
         if (right === "") {
-            right = `evaluate("${match[3]}")`;
+            right = `evaluate("${match[3].toLowerCase()}")`;
         }
         if (comparator === "in") {
             const cnew = `abap.compare.in(${cleft}, ${right})`;
             text = text.replace(match[0], cnew);
         }
+        else if (comparator === "not in") {
+            const cnew = `!abap.compare.in(${cleft}, ${right})`;
+            text = text.replace(match[0], cnew);
+        }
         else {
             const cnew = `abap.compare.${comparator}(${cleft}, ${right})`;
             text = text.replace(match[0], cnew);

package/build/src/statements/select.js

@@ -12,6 +12,12 @@ async function select(target, input, runtimeOptions, context) {
         target = target.getPointer();
     }
     if (rows.length === 0) {
+        // INTO TABLE always initializes the target, also when nothing is found;
+        // a work area is left untouched instead
+        if (runtimeOptions?.appending !== true
+            && (target instanceof types_1.Table || target instanceof types_1.HashedTable)) {
+            target.clear();
+        }
         abap.builtin.sy.get().dbcnt.set(0);
         abap.builtin.sy.get().subrc.set(4);
         return;

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

@@ -1,4 +1,4 @@
-import { FieldSymbol, Table } from "../types";
+import { FieldSymbol, Table, TableRowType } from "../types";
 export interface ISortOptions {
     descending?: boolean;
     skipSortedCheck?: boolean;
@@ -7,4 +7,5 @@ export interface ISortOptions {
         descending?: boolean;
     }[];
 }
+export declare function compareRows(a: TableRowType, b: TableRowType, keyFields: readonly string[]): number;
 export declare function sort(input: Table | FieldSymbol | any[], options?: ISortOptions): void;

package/build/src/statements/sort.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareRows = compareRows;
 exports.sort = sort;
 const types_1 = require("../types");
 const compare_1 = require("../compare");
@@ -63,6 +64,34 @@ function compare(a, b, input) {
         return 1;
     }
 }
+function compareWholeRows(a, b) {
+    if ((0, compare_1.eq)(a, b)) {
+        return 0;
+    }
+    else if ((0, compare_1.lt)(a, b)) {
+        return -1;
+    }
+    else {
+        return 1;
+    }
+}
+function compareRows(a, b, keyFields) {
+    if (keyFields.length > 0) {
+        for (const keyField of keyFields) {
+            const component = keyField.toLowerCase();
+            const result = component === "table_line"
+                ? compareWholeRows(a, b)
+                : compare(a, b, { component });
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    }
+    else {
+        return compareWholeRows(a, b);
+    }
+}
 function sort(input, options) {
     //  console.dir(input);
     if (input instanceof types_1.FieldSymbol) {

package/build/src/types/float.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Float = void 0;
+const throw_error_1 = require("../throw_error");
 const hex_1 = require("./hex");
 const xstring_1 = require("./xstring");
 const integer8_1 = require("./integer8");
 const decfloat34_1 = require("./decfloat34");
+const FLOAT_DIGITS = /^\s*[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)? *$/;
 /*
 function getNumberParts(x: number) {
   if(isNaN(x)) {
@@ -59,6 +61,12 @@ class Float {
             this.value = 0;
         }
         else if (typeof value === "string") {
+            if (value.endsWith("-")) {
+                value = "-" + value.substring(0, value.length - 1);
+            }
+            if (FLOAT_DIGITS.test(value) === false) {
+                (0, throw_error_1.throwError)("CX_SY_CONVERSION_NO_NUMBER");
+            }
             this.value = parseFloat(value);
         }
         else if (value instanceof integer8_1.Integer8) {

package/build/src/types/integer.js

@@ -85,11 +85,11 @@ class Integer {
             this.set(Math.round(value.getRaw()));
         }
         else if (value instanceof hex_1.Hex || value instanceof xstring_1.XString || value instanceof hex_uint8_1.HexUInt8) {
-            let num = parseInt(value.get(), 16);
-            // handle two complement,
-            if ((value instanceof hex_1.Hex || value instanceof hex_uint8_1.HexUInt8)
-                && value.getLength() >= 4) {
-                const maxVal = Math.pow(2, value.get().length / 2 * 8);
+            const hex = value.get();
+            let num = parseInt(hex, 16);
+            // handle two complement, the first bit is the sign
+            if (hex.length >= 8) {
+                const maxVal = Math.pow(2, hex.length / 2 * 8);
                 if (num > maxVal / 2 - 1) {
                     num = num - maxVal;
                 }

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

@@ -110,6 +110,10 @@ export declare class Table implements ITable {
     getHeader(): TableRowType;
     get(): TableRowType;
     insertIndex(item: TableRowType, index: number, noClone?: boolean): any;
+    insertSorted(item: TableRowType, compare: (a: TableRowType, b: TableRowType) => number, unique: boolean, noClone?: boolean): {
+        value: TableRowType | undefined;
+        subrc: number;
+    };
     /** index = javascript indexed */
     deleteIndex(index: number): void;
     append(item: TableRowType): any;

package/build/src/types/table.js

@@ -463,6 +463,42 @@ class Table {
         }
         return val;
     }
+    insertSorted(item, compare, unique, noClone = false) {
+        if (item instanceof field_symbol_1.FieldSymbol) {
+            const pointer = item.getPointer();
+            if (pointer === undefined) {
+                throw new Error("insertSorted, fs not assigned");
+            }
+            return this.insertSorted(pointer, compare, unique, noClone);
+        }
+        const val = noClone === true ? item : this.cloneRow(item);
+        const lastIndex = this.value.length - 1;
+        if (lastIndex < 0) {
+            return { value: this.insertIndex(val, 0, true), subrc: 0 };
+        }
+        const lastComparison = compare(this.value[lastIndex], val);
+        if (lastComparison < 0 || (lastComparison === 0 && unique === false)) {
+            return { value: this.insertIndex(val, this.value.length, true), subrc: 0 };
+        }
+        else if (lastComparison === 0) {
+            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) {
+                low = middle + 1;
+            }
+            else {
+                high = middle;
+            }
+        }
+        if (unique === true && low > 0 && compare(this.value[low - 1], val) === 0) {
+            return { value: undefined, subrc: 4 };
+        }
+        return { value: this.insertIndex(val, low, true), subrc: 0 };
+    }
     /** index = javascript indexed */
     deleteIndex(index) {
         this.secondaryIndexes = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/runtime",
-  "version": "2.13.49",
+  "version": "2.13.51",
   "description": "Transpiler - Runtime",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -11,9 +11,9 @@
   },
   "scripts": {
     "compile": "tsc",
-    "publish:major": "npm --no-git-tag-version version major && rm -rf build && npm install && npm run test && npm publish --access public",
-    "publish:minor": "npm --no-git-tag-version version minor && rm -rf build && npm install && npm run test && npm publish --access public",
-    "publish:patch": "npm --no-git-tag-version version patch && rm -rf build && npm install && npm run test && npm publish --access public",
+    "publish:major": "npm --no-git-tag-version version major && rimraf build && npm install && npm run test && npm publish --access public",
+    "publish:minor": "npm --no-git-tag-version version minor && rimraf build && npm install && npm run test && npm publish --access public",
+    "publish:patch": "npm --no-git-tag-version version patch && rimraf build && npm install && npm run test && npm publish --access public",
     "test": "npm run compile && mocha"
   },
   "mocha": {
@@ -33,7 +33,7 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.13.3",
     "chai": "^4.5.0",
-    "mocha": "^11.7.6",
+    "mocha": "^11.8.0",
     "source-map-support": "^0.5.21",
     "typescript": "^6.0.3"
   },