@abaplint/transpiler 2.13.95 → 2.13.97

package/build/src/statements/close_dataset.js

@@ -1,10 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CloseDatasetTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
 class CloseDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("CloseDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const name = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Source)).getCode();
+        return new chunk_1.Chunk()
+            .append("await abap.statements.closeDataset(", node, traversal)
+            .appendString(name)
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.CloseDatasetTranspiler = CloseDatasetTranspiler;

package/build/src/statements/create_data.js

@@ -83,7 +83,7 @@ class CreateDataTranspiler {
         }
         const handle = node.findExpressionAfterToken("HANDLE");
         if (handle) {
-            const so = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Source));
+            const so = traversal.traverse(handle);
             const lookup = traversal.lookupClassOrInterface("KERNEL_CREATE_DATA_HANDLE", node.getFirstToken());
             const call = `await ${lookup}.call({handle: ${so.getCode()}, dref: ${target.getCode()}});`;
             return new chunk_1.Chunk().append(`if (${lookup} === undefined) throw new Error("CreateData, kernel class missing");\n${call}`, node, traversal);

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class DeleteDatasetTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/delete_dataset.js

@@ -1,10 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleteDatasetTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
 class DeleteDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("DeleteDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const name = traversal.traverse(node.findDirectExpression(abaplint.Expressions.Source)).getCode();
+        return new chunk_1.Chunk()
+            .append("await abap.statements.deleteDataset(", node, traversal)
+            .appendString(name)
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.DeleteDatasetTranspiler = DeleteDatasetTranspiler;

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

@@ -3,5 +3,7 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class GenerateSubroutineTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    /** the expression directly after the addition keyword, MESSAGE does not match MESSAGE-ID */
+    private findAddition;
 }

package/build/src/statements/generate_subroutine.js

@@ -1,10 +1,80 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateSubroutineTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
+// GENERATE SUBROUTINE POOL cannot be supported, there is no compiler at runtime.
+// The statement is refused without an exception: sy-subrc = 8 (documented as "other
+// generation error"), NAME initial, MESSAGE filled, LINE 0 and WORD initial. This is
+// a refusal of its own, not what a system answers; the other additions are left untouched.
 class GenerateSubroutineTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("GenerateSubroutine, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const ret = new chunk_1.Chunk();
+        const name = this.findAddition(node, "NAME");
+        if (name) {
+            ret.appendString(traversal.traverse(name).getCode() + ".clear();\n");
+        }
+        const message = this.findAddition(node, "MESSAGE");
+        if (message) {
+            ret.appendString(traversal.traverse(message).getCode() + `.set("GENERATE SUBROUTINE POOL is not supported");\n`);
+        }
+        const line = this.findAddition(node, "LINE");
+        if (line) {
+            ret.appendString(traversal.traverse(line).getCode() + ".set(0);\n");
+        }
+        const word = this.findAddition(node, "WORD");
+        if (word) {
+            ret.appendString(traversal.traverse(word).getCode() + ".clear();\n");
+        }
+        ret.append("abap.builtin.sy.get().subrc.set(8);", node, traversal);
+        return ret;
+    }
+    /** the expression directly after the addition keyword, MESSAGE does not match MESSAGE-ID */
+    findAddition(node, keyword) {
+        const children = node.getChildren();
+        for (let i = 0; i < children.length - 1; i++) {
+            const child = children[i];
+            const next = children[i + 1];
+            if (child instanceof abaplint.Nodes.TokenNode
+                && child.getFirstToken().getStr().toUpperCase() === keyword
+                && next instanceof abaplint.Nodes.ExpressionNode) {
+                return next;
+            }
+        }
+        return undefined;
     }
 }
 exports.GenerateSubroutineTranspiler = GenerateSubroutineTranspiler;

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class GetDatasetTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/get_dataset.js

@@ -2,9 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class GetDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("GetDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        if (operands.after("POSITION") !== undefined) {
+            options.push("position: " + operands.after("POSITION"));
+        }
+        if (operands.after("ATTRIBUTES") !== undefined) {
+            options.push("attributes: " + operands.after("ATTRIBUTES"));
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.getDataset(", node, traversal)
+            .appendString(operands.first() + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.GetDatasetTranspiler = GetDatasetTranspiler;

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

@@ -15,4 +15,5 @@ export declare class LoopTranspiler implements IStatementTranspiler {
     getTarget(): string;
     private determineInto;
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private hasHeaderLine;
 }

package/build/src/statements/loop.js

@@ -94,6 +94,10 @@ class LoopTranspiler {
                 targetNode = assigning;
                 target = traversal.traverse(assigning).getCode() + ".assign(" + this.unique + ");";
             }
+            else if (!node.concatTokens().toUpperCase().includes(" TRANSPORTING NO FIELDS") && this.hasHeaderLine(loopSource, traversal)) {
+                // LOOP AT itab. without a target: the row goes into the header line of the table
+                target = source + ".getHeader().set(" + this.unique + ");";
+            }
         }
         const extra = [];
         const fromNode = node.findExpressionAfterToken("FROM");
@@ -188,6 +192,14 @@ class LoopTranspiler {
         }
         return ret;
     }
+    hasHeaderLine(loopSource, traversal) {
+        if (loopSource === undefined || /^[\w\/]+$/.test(loopSource.concatTokens()) === false) {
+            return false;
+        }
+        const token = loopSource.getFirstToken();
+        const type = traversal.findCurrentScopeByToken(token)?.findVariable(loopSource.concatTokens())?.getType();
+        return type instanceof abaplint.BasicTypes.TableType && type.isWithHeader();
+    }
 }
 exports.LoopTranspiler = LoopTranspiler;
 //# sourceMappingURL=loop.js.map

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

@@ -4,4 +4,6 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class MoveTranspiler implements IStatementTranspiler {
     transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private isInt8Calculation;
+    private integerOperands;
 }

package/build/src/statements/move.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoveTranspiler = void 0;
 const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
+const source_1 = require("../expressions/source");
 class MoveTranspiler {
     transpile(node, traversal) {
         const sourceExpression = node.findDirectExpression(abaplint.Expressions.Source);
@@ -55,7 +56,9 @@ class MoveTranspiler {
             ret.appendString(target + `.set(abap.alphaIn(${tSource.getCode()}, ${target}, ${target}));`);
             return ret;
         }
-        let source = traversal.traverse(sourceExpression);
+        let source = this.isInt8Calculation(node, sourceExpression, targetExpressions.length, traversal)
+            ? new source_1.SourceTranspiler(false, true).transpile(sourceExpression, traversal)
+            : traversal.traverse(sourceExpression);
         const second = node.getChildren()[1]?.concatTokens();
         switch (second) {
             case "?=":
@@ -117,6 +120,72 @@ class MoveTranspiler {
         }
         return ret;
     }
+    // The calculation type of an arithmetic expression comes from its operands and the target
+    // field, the type with the largest range wins. With operands of type i or int8 it is int8
+    // when the target or an operand is int8: i * i into int8 is exact up to 2^62, and "/"
+    // rounds. The runtime decides by the operands alone and does not know the target, so here
+    // the operands are converted to int8 before the calculation. Only for an i or int8 target
+    // and operands whose type is known to be i or int8, and not for **, which counts as f
+    isInt8Calculation(node, source, targets, traversal) {
+        if (source === undefined
+            || targets !== 1
+            || source.findFirstExpression(abaplint.Expressions.ArithOperator) === undefined) {
+            return false;
+        }
+        const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
+        const target = traversal.determineType(node, scope);
+        const found = { int8: target instanceof abaplint.BasicTypes.Integer8Type };
+        if (found.int8 === false && !(target instanceof abaplint.BasicTypes.IntegerType)) {
+            return false;
+        }
+        return this.integerOperands(source, scope, found) && found.int8;
+    }
+    integerOperands(node, scope, found) {
+        for (const c of node.getChildren()) {
+            if (c instanceof abaplint.Nodes.TokenNode) {
+                if (["(", ")", "-", "+"].includes(c.getFirstToken().getStr()) === false) {
+                    return false;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.Source) {
+                if (this.integerOperands(c, scope, found) === false) {
+                    return false;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.ArithOperator) {
+                if (["+", "-", "*", "/", "DIV", "MOD"].includes(c.concatTokens().toUpperCase()) === false) {
+                    return false;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.Constant) {
+                const integer = c.findDirectExpression(abaplint.Expressions.Integer);
+                if (integer === undefined) {
+                    return false;
+                }
+                else if (Math.abs(parseInt(integer.concatTokens().replace(/ /g, ""), 10)) > 2147483647) {
+                    // the transpiler makes an int8 of a literal outside the range of i
+                    found.int8 = true;
+                }
+            }
+            else if (c.get() instanceof abaplint.Expressions.FieldChain) {
+                const children = c.getChildren();
+                if (children.length !== 1) {
+                    return false;
+                }
+                const type = scope?.findVariable(children[0].concatTokens())?.getType();
+                if (!(type instanceof abaplint.BasicTypes.IntegerType) && !(type instanceof abaplint.BasicTypes.Integer8Type)) {
+                    return false;
+                }
+                if (type instanceof abaplint.BasicTypes.Integer8Type) {
+                    found.int8 = true;
+                }
+            }
+            else {
+                return false;
+            }
+        }
+        return true;
+    }
 }
 exports.MoveTranspiler = MoveTranspiler;
 //# sourceMappingURL=move.js.map

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class OpenDatasetTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/open_dataset.js

@@ -2,9 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class OpenDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("OpenDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        const mode = ["INPUT", "OUTPUT", "APPENDING", "UPDATE"].find(m => operands.has("FOR " + m)) ?? "INPUT";
+        options.push(`mode: "${mode}"`);
+        options.push(`binary: ${operands.has("BINARY MODE")}`);
+        const encoding = ["DEFAULT", "UTF-8", "NON-UNICODE"].find(e => operands.has("ENCODING " + e));
+        if (encoding !== undefined) {
+            options.push(`encoding: "${encoding}"`);
+        }
+        if (operands.has("IN LEGACY")) {
+            options.push("legacy: true");
+        }
+        if (operands.after("MESSAGE") !== undefined) {
+            options.push("message: " + operands.after("MESSAGE"));
+        }
+        if (operands.after("AT POSITION") !== undefined) {
+            options.push("position: " + operands.after("AT POSITION"));
+        }
+        // accepted by the syntax, not implemented by the runtime: it refuses them
+        // by name rather than ignoring them
+        const unsupported = ["CODE PAGE", "TYPE", "FILTER", "REPLACEMENT CHARACTER", "WITH BYTE-ORDER MARK", "SKIPPING BYTE-ORDER MARK",
+            "WITH SMART LINEFEED", "WITH NATIVE LINEFEED", "WITH UNIX LINEFEED", "WITH WINDOWS LINEFEED", "IGNORING CONVERSION ERRORS"]
+            .filter(u => operands.has(u) || operands.after(u) !== undefined);
+        if (unsupported.length > 0) {
+            options.push("unsupported: " + JSON.stringify(unsupported));
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.openDataset(", node, traversal)
+            .appendString(operands.first() + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.OpenDatasetTranspiler = OpenDatasetTranspiler;

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

@@ -3,5 +3,6 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class ParameterTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
+    private isFirstOfUnsetRadioGroup;
 }

package/build/src/statements/parameter.js

@@ -1,10 +1,76 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterTranspiler = void 0;
+const abaplint = __importStar(require("@abaplint/core"));
 const chunk_1 = require("../chunk");
+const transpile_types_1 = require("../transpile_types");
+const _selection_1 = require("./_selection");
 class ParameterTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("Parameter, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const variable = _selection_1.SelectionDefault.variable(node, traversal);
+        // abaplint types "TYPE c LENGTH 3" and "TYPE p ... DECIMALS 2" of a parameter
+        // without the length and the decimals, a value would be cut silently
+        const tokens = node.getTokens().map(t => t.getStr().toUpperCase());
+        const sized = tokens.some((t, i) => (t === "LENGTH" && tokens[i - 1] !== "VISIBLE") || t === "DECIMALS");
+        if (variable === undefined || sized === true) {
+            return new chunk_1.Chunk(`throw new Error("Parameter, not supported, transpiler");`);
+        }
+        const { name, type } = variable;
+        const ret = new chunk_1.Chunk().appendString("let " + name + " = " + transpile_types_1.TranspileTypes.toType(type) + ";");
+        const operand = _selection_1.SelectionDefault.after(node, "DEFAULT");
+        if (operand) {
+            ret.appendString(_selection_1.SelectionDefault.set(node, name, type, operand, traversal));
+        }
+        else if (this.isFirstOfUnsetRadioGroup(node, traversal)) {
+            // a radio button group without DEFAULT 'X' starts with its first button chosen
+            ret.appendString("\n" + name + ".set('X');");
+        }
+        return ret;
+    }
+    isFirstOfUnsetRadioGroup(node, traversal) {
+        const group = node.findDirectExpression(abaplint.Expressions.RadioGroupName)?.concatTokens().toUpperCase();
+        if (group === undefined) {
+            return false;
+        }
+        const members = traversal.getFile().getStatements().filter(s => s.get() instanceof abaplint.Statements.Parameter
+            && s.findDirectExpression(abaplint.Expressions.RadioGroupName)?.concatTokens().toUpperCase() === group);
+        if (members.some(m => _selection_1.SelectionDefault.after(m, "DEFAULT") !== undefined)) {
+            return false;
+        }
+        return members[0].getStart().equals(node.getStart());
     }
 }
 exports.ParameterTranspiler = ParameterTranspiler;

package/build/src/statements/perform.js

@@ -44,16 +44,18 @@ class PerformTranspiler {
             return new chunk_1.Chunk(`throw new Error("PerformTranspiler FormName not found");`);
         }
         else if (node.concatTokens().toUpperCase().includes(" IN PROGRAM ")) {
-            // todo: throw exception if not found?
             const expression = node.findExpressionAfterToken("PROGRAM");
             let ref = "";
+            let program = "";
             if (expression?.get() instanceof abaplint.Expressions.Dynamic) {
                 const name = expression.getChildren()[1].concatTokens() + ".get().trimEnd()";
                 ref = `abap.Forms['PROG-' + ${name} + '-${formName.concatTokens().toUpperCase()}']`;
+                program = `'PROG-' + ${name} + '-'`;
             }
             else {
                 const progName = expression?.concatTokens().toUpperCase();
                 ref = `abap.Forms['PROG-${progName}-${formName.concatTokens().toUpperCase()}']`;
+                program = `'PROG-${progName}-'`;
             }
             const params = [];
             // hacky hack
@@ -65,6 +67,16 @@ class PerformTranspiler {
             if (node.concatTokens().toUpperCase().includes(" IF FOUND")) {
                 call = `if (${ref} !== undefined) { ${call} }`;
             }
+            else {
+                // the form is missing from a program whose forms are registered: CX_SY_DYN_CALL_ILLEGAL_FORM,
+                // no form of the program is registered: CX_SY_PROGRAM_NOT_FOUND
+                const raise = (name) => {
+                    const cls = traversal.lookupClassOrInterface(`'${name}'`, node.getFirstToken(), true);
+                    return `if (${cls} === undefined) { throw "${name} not found"; } else { throw await new ${cls}().constructor_(); }`;
+                };
+                const loaded = `Object.keys(abap.Forms).some(k => k.startsWith(${program}))`;
+                call = `if (${ref} === undefined) { if (${loaded}) { ${raise("CX_SY_DYN_CALL_ILLEGAL_FORM")} } else { ${raise("CX_SY_PROGRAM_NOT_FOUND")} } }\n` + call;
+            }
             return new chunk_1.Chunk(call);
         }
         else {

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

@@ -3,5 +3,5 @@ import { IStatementTranspiler } from "./_statement_transpiler";
 import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class ReadDatasetTranspiler implements IStatementTranspiler {
-    transpile(_node: abaplint.Nodes.StatementNode, _traversal: Traversal): Chunk;
+    transpile(node: abaplint.Nodes.StatementNode, traversal: Traversal): Chunk;
 }

package/build/src/statements/read_dataset.js

@@ -2,9 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReadDatasetTranspiler = void 0;
 const chunk_1 = require("../chunk");
+const _dataset_1 = require("./_dataset");
 class ReadDatasetTranspiler {
-    transpile(_node, _traversal) {
-        return new chunk_1.Chunk(`throw new Error("ReadDataset, not supported, transpiler");`);
+    transpile(node, traversal) {
+        const operands = new _dataset_1.DatasetOperands(node, traversal);
+        const options = [];
+        if (operands.after("MAXIMUM LENGTH") !== undefined) {
+            options.push("maximumLength: " + operands.after("MAXIMUM LENGTH"));
+        }
+        // the obsolete LENGTH is ACTUAL LENGTH
+        const actual = operands.after("ACTUAL LENGTH") ?? operands.after("LENGTH", ["MAXIMUM", "ACTUAL"]);
+        if (actual !== undefined) {
+            options.push("actualLength: " + actual);
+        }
+        return new chunk_1.Chunk()
+            .append("await abap.statements.readDataset(", node, traversal)
+            .appendString(operands.first() + ", " + operands.after("INTO") + ", {" + options.join(", ") + "}")
+            .append(");", node.getLastToken(), traversal);
     }
 }
 exports.ReadDatasetTranspiler = ReadDatasetTranspiler;