@abaplint/transpiler 2.5.19 → 2.5.21

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

@@ -3,5 +3,13 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class LoopTranspiler implements IStatementTranspiler {
+    private unique;
+    private readonly injectFrom;
+    private readonly skipInto;
+    constructor(options?: {
+        injectFrom?: string;
+        skipInto?: boolean;
+    });
+    getTarget(): string;
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/loop.js

@@ -6,36 +6,46 @@ const unique_identifier_1 = require("../unique_identifier");
 const expressions_1 = require("../expressions");
 const chunk_1 = require("../chunk");
 class LoopTranspiler {
+    constructor(options) {
+        this.unique = "";
+        this.injectFrom = undefined;
+        this.skipInto = undefined;
+        this.injectFrom = options === null || options === void 0 ? void 0 : options.injectFrom;
+        this.skipInto = options === null || options === void 0 ? void 0 : options.skipInto;
+    }
+    getTarget() {
+        return this.unique;
+    }
     transpile(node, traversal) {
         var _a, _b, _c;
         if (!(node.get() instanceof abaplint.Statements.Loop)) {
             throw new Error("LoopTranspiler, unexpected node");
         }
         const source = traversal.traverse(node.findDirectExpression(abaplint.Expressions.SimpleSource2)).getCode();
-        const unique1 = unique_identifier_1.UniqueIdentifier.get();
+        this.unique = unique_identifier_1.UniqueIdentifier.get();
         let target = "";
         const into = (_a = node.findDirectExpression(abaplint.Expressions.LoopTarget)) === null || _a === void 0 ? void 0 : _a.findDirectExpression(abaplint.Expressions.Target);
-        if (into) {
+        if (into && this.skipInto !== true) {
             const concat = node.concatTokens().toUpperCase();
             const t = traversal.traverse(into).getCode();
             const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
             const typ = traversal.determineType(node, scope);
             if (concat.includes(" REFERENCE INTO ")) {
                 // target is assumed to be a data reference
-                target = t + ".assign(" + unique1 + ");";
+                target = t + ".assign(" + this.unique + ");";
             }
             else if (typ instanceof abaplint.BasicTypes.DataReference) {
                 // row type and target is assumed to be data references
-                target = t + ".assign(" + unique1 + ".getPointer());";
+                target = t + ".assign(" + this.unique + ".getPointer());";
             }
             else {
-                target = t + ".set(" + unique1 + ");";
+                target = t + ".set(" + this.unique + ");";
             }
         }
-        else {
+        else if (this.skipInto !== true) {
             const assigning = (_b = node.findFirstExpression(abaplint.Expressions.FSTarget)) === null || _b === void 0 ? void 0 : _b.findFirstExpression(abaplint.Expressions.FieldSymbol);
             if (assigning) {
-                target = traversal.traverse(assigning).getCode() + ".assign(" + unique1 + ");";
+                target = traversal.traverse(assigning).getCode() + ".assign(" + this.unique + ");";
             }
         }
         const extra = [];
@@ -44,6 +54,9 @@ class LoopTranspiler {
             const from = new expressions_1.SourceTranspiler().transpile(fromNode, traversal).getCode();
             extra.push("from: " + from);
         }
+        else if (this.injectFrom) {
+            extra.push("from: " + this.injectFrom);
+        }
         const toNode = node.findExpressionAfterToken("TO");
         if (toNode) {
             const to = new expressions_1.SourceTranspiler().transpile(toNode, traversal).getCode();
@@ -96,7 +109,7 @@ class LoopTranspiler {
         if (extra.length > 0) {
             concat = ",{" + extra.join(",") + "}";
         }
-        return new chunk_1.Chunk(`for await (const ${unique1} of abap.statements.loop(${source}${concat})) {\n${target}`);
+        return new chunk_1.Chunk(`for await (const ${this.unique} of abap.statements.loop(${source}${concat})) {\n${target}`);
     }
 }
 exports.LoopTranspiler = LoopTranspiler;

package/build/src/structures/at.d.ts

@@ -0,0 +1,7 @@
+import * as abaplint from "@abaplint/core";
+import { IStructureTranspiler } from "./_structure_transpiler";
+import { Traversal } from "../traversal";
+import { Chunk } from "../chunk";
+export declare class AtTranspiler implements IStructureTranspiler {
+    transpile(node: abaplint.Nodes.StructureNode, traversal: Traversal, previous?: string, loopTarget?: string, tabix?: string, loopStatement?: abaplint.Nodes.StatementNode): Chunk;
+}

package/build/src/structures/at.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtTranspiler = void 0;
+const abaplint = require("@abaplint/core");
+const chunk_1 = require("../chunk");
+const statements_1 = require("../statements");
+const unique_identifier_1 = require("../unique_identifier");
+class AtTranspiler {
+    transpile(node, traversal, previous, loopTarget, tabix, loopStatement) {
+        var _a, _b;
+        const ret = new chunk_1.Chunk();
+        const atStatement = node.findDirectStatement(abaplint.Statements.At);
+        const concat = atStatement === null || atStatement === void 0 ? void 0 : atStatement.concatTokens().toUpperCase();
+        const name = (_b = (_a = atStatement === null || atStatement === void 0 ? void 0 : atStatement.findDirectExpression(abaplint.Expressions.FieldSub)) === null || _a === void 0 ? void 0 : _a.concatTokens()) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+        let suffix = `.get().${name}`;
+        if (name === "table_line") {
+            suffix = "";
+        }
+        if (concat === null || concat === void 0 ? void 0 : concat.startsWith("AT NEW ")) {
+            // eslint-disable-next-line max-len
+            ret.appendString(`if (${previous} === undefined || abap.compare.eq(${previous}${suffix}, ${loopTarget}${suffix}) === false) {\n`);
+            const body = node.findDirectStructure(abaplint.Structures.Body);
+            if (body) {
+                ret.appendChunk(traversal.traverse(body));
+            }
+            ret.appendString("}\n");
+        }
+        else if (concat === null || concat === void 0 ? void 0 : concat.startsWith("AT END OF ")) {
+            const next = unique_identifier_1.UniqueIdentifier.get();
+            ret.appendString(`let ${next} = undefined;\n`);
+            const loop = new statements_1.LoopTranspiler({ injectFrom: tabix, skipInto: true });
+            ret.appendChunk(loop.transpile(loopStatement, traversal));
+            ret.appendString(`${next} = ${loop.getTarget()};\n`);
+            ret.appendString(`break;\n`);
+            ret.appendString(`}\n`);
+            // eslint-disable-next-line max-len
+            ret.appendString(`if (${next} === undefined || abap.compare.eq(${next}${suffix}, ${loopTarget}${suffix}) === false) {\n`);
+            const body = node.findDirectStructure(abaplint.Structures.Body);
+            if (body) {
+                ret.appendChunk(traversal.traverse(body));
+            }
+            ret.appendString("}\n");
+        }
+        return ret;
+    }
+}
+exports.AtTranspiler = AtTranspiler;
+//# sourceMappingURL=at.js.map

package/build/src/structures/loop.js

@@ -6,12 +6,26 @@ const chunk_1 = require("../chunk");
 const at_first_1 = require("./at_first");
 const at_last_1 = require("./at_last");
 const unique_identifier_1 = require("../unique_identifier");
+const statements_1 = require("../statements");
+const at_1 = require("./at");
 class LoopTranspiler {
     transpile(node, traversal) {
+        var _a;
         const ret = new chunk_1.Chunk();
         let pre = "";
         let atFirst = undefined;
         let atLast = undefined;
+        let loopStatement = undefined;
+        let previous = "";
+        let tabix = "";
+        let loopTarget = "";
+        let hasAt = false;
+        for (const n of ((_a = node.findDirectStructure(abaplint.Structures.Body)) === null || _a === void 0 ? void 0 : _a.findDirectStructures(abaplint.Structures.Normal)) || []) {
+            if (n.findDirectStructure(abaplint.Structures.At) !== undefined) {
+                hasAt = true;
+                break;
+            }
+        }
         for (const c of node.getChildren()) {
             if (c instanceof abaplint.Nodes.StructureNode && c.get() instanceof abaplint.Structures.Body) {
                 for (const b of c.getChildren()) {
@@ -28,12 +42,37 @@ class LoopTranspiler {
                         else if (n instanceof abaplint.Nodes.StructureNode && n.get() instanceof abaplint.Structures.AtLast) {
                             atLast = new at_last_1.AtLastTranspiler().transpile(n, traversal);
                         }
+                        else if (n instanceof abaplint.Nodes.StructureNode && n.get() instanceof abaplint.Structures.At) {
+                            ret.appendChunk(new at_1.AtTranspiler().transpile(n, traversal, previous, loopTarget, tabix, loopStatement));
+                        }
                         else {
                             ret.appendChunk(traversal.traverse(n));
                         }
                     }
                 }
             }
+            else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.Loop) {
+                if (hasAt === true) {
+                    previous = unique_identifier_1.UniqueIdentifier.get();
+                    tabix = unique_identifier_1.UniqueIdentifier.get();
+                    ret.appendString(`let ${previous} = undefined;\n`);
+                    ret.appendString(`let ${tabix} = undefined;\n`);
+                }
+                const loop = new statements_1.LoopTranspiler();
+                ret.appendChunk(loop.transpile(c, traversal));
+                ret.appendString("\n");
+                if (hasAt === true) {
+                    ret.appendString(tabix + " = new abap.types.Integer().set(abap.builtin.sy.get().tabix.get() + 1);\n");
+                }
+                loopTarget = loop.getTarget();
+                loopStatement = c;
+            }
+            else if (c instanceof abaplint.Nodes.StatementNode && c.get() instanceof abaplint.Statements.EndLoop) {
+                if (hasAt === true) {
+                    ret.appendString(`${previous} = ${loopTarget};\n`);
+                }
+                ret.appendChunk(traversal.traverse(c));
+            }
             else {
                 ret.appendChunk(traversal.traverse(c));
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.5.19",
+  "version": "2.5.21",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -28,7 +28,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.95.31",
+    "@abaplint/core": "^2.95.32",
     "source-map": "^0.7.4"
   },
   "devDependencies": {