Fixed behavior of End statement to terminate the app

package.json

@@ -1,11 +1,11 @@
 {
   "name": "brs-engine",
-  "version": "1.8.2",
+  "version": "1.9.0-beta",
   "title": "BrightScript Simulation Engine",
   "description": "BrightScript Simulation Engine - Run Roku apps on Browsers and Node.js",
   "author": "Marcelo Lv Cabral <[email protected]> (https://lvcabral.com/)",
   "license": "MIT",
-  "copyright": "© 2019-2024, Marcelo Lv Cabral",
+  "copyright": "© 2019-2025, Marcelo Lv Cabral",
   "homepage": "https://lvcabral.com/brs/",
   "contributors": [
     "Sean Barag <[email protected]>",

src/core/index.ts

@@ -72,6 +72,7 @@ export const cecStatus: CECStatusEvent = { activeSource: true };
 export const memoryInfo: MemoryInfoEvent = { usedHeapSize: 0, heapSizeLimit: 0 };
 export const bscs = new Map<string, number>();
 export const stats = new Map<Lexeme, number>();
+export const terminateReasons = ["debug-exit", "end-statement"];
 
 const algorithm = "aes-256-ctr";
 
@@ -882,7 +883,7 @@ async function executeApp(
         await interpreter.exec(statements, sourceMap, inputParams);
     } catch (err: any) {
         exitReason = AppExitReason.FINISHED;
-        if (err.message !== "debug-exit") {
+        if (!terminateReasons.includes(err.message)) {
             if (interpreter.options.post ?? true) {
                 postMessage(`error,${err.message}`);
             } else {

src/core/interpreter/index.ts

@@ -1267,7 +1267,7 @@ export class Interpreter implements Expr.Visitor<BrsType>, Stmt.Visitor<BrsType>
                 });
             } catch (reason: any) {
                 if (!(reason instanceof Stmt.BlockEnd)) {
-                    if (reason.message === "debug-exit") {
+                    if (core.terminateReasons.includes(reason.message)) {
                         throw new Error(reason.message);
                     } else if (reason instanceof BrsError) {
                         throw reason;
@@ -1277,7 +1277,7 @@ export class Interpreter implements Expr.Visitor<BrsType>, Stmt.Visitor<BrsType>
                         throw new Error("");
                     }
                     throw new Error(reason.message);
-                } else if (reason.message === "debug-exit") {
+                } else if (core.terminateReasons.includes(reason.message)) {
                     throw new Error(reason.message);
                 }
 

src/core/lexer/ReservedWords.ts

@@ -68,6 +68,7 @@ export const KeyWords: { [key: string]: L } = {
     else: L.Else,
     elseif: L.ElseIf,
     "else if": L.ElseIf,
+    end: L.End,
     endfor: L.EndFor,
     "end for": L.EndFor,
     endfunction: L.EndFunction,

src/core/parser/Parser.ts

@@ -289,16 +289,6 @@ export class Parser {
             };
         }
 
-        /**
-         * A simple wrapper around `check` to make tests for a `end` identifier.
-         * `end` is a keyword, but not reserved, so associative arrays can have properties
-         * called `end`; the parser takes on this task.
-         * @returns `true` if the next token is an identifier with text `end`, otherwise `false`
-         */
-        function checkEnd() {
-            return check(Lexeme.Identifier) && peek().text.toLowerCase() === "end";
-        }
-
         function declaration(...additionalTerminators: BlockTerminator[]): Statement | undefined {
             try {
                 let statementSeparators = [Lexeme.Colon];
@@ -658,7 +648,7 @@ export class Parser {
                 return exitFor();
             }
 
-            if (checkEnd()) {
+            if (check(Lexeme.End)) {
                 return endStatement();
             }
 
@@ -1335,7 +1325,7 @@ export class Parser {
         function endStatement() {
             let tokens = { end: advance() };
 
-            while (match(Lexeme.Newline));
+            while (match(Lexeme.Newline, Lexeme.Colon));
 
             return new Stmt.End(tokens);
         }

test/e2e/StdLib.test.js

@@ -205,4 +205,12 @@ describe("end to end standard libary", () => {
             " 245",
         ]);
     });
+    test("stdlib/end.brs", async () => {
+        await execute([resourceFile("stdlib", "end.brs")], outputStreams);
+
+        expect(allArgs(outputStreams.stdout.write).map((arg) => arg.trimEnd())).toEqual([
+            "test the test",
+            "testing end...",
+        ]);
+    });
 });

test/e2e/resources/stdlib/end.brs

@@ -0,0 +1,5 @@
+sub main()
+    tester()
+end sub
+sub testEnd() : print "testing end..." : end: print "not printed" : end sub
+sub tester() : print "test the test" : testEnd() : print "should not print" : end sub

test/lexer/Lexer.test.js

@@ -23,6 +23,11 @@ describe("lexer", () => {
         ]);
     });
 
+    it("gives the `end` keyword its own Lexeme", () => {
+        let { tokens } = Lexer.scan("end");
+        expect(tokens.map((t) => t.kind)).toEqual([Lexeme.End, Lexeme.Eof]);
+    });
+
     it("gives the `stop` keyword its own Lexeme", () => {
         let { tokens } = Lexer.scan("stop");
         expect(tokens.map((t) => t.kind)).toEqual([Lexeme.Stop, Lexeme.Eof]);

test/parser/statement/End.test.js

@@ -0,0 +1,58 @@
+const brs = require("../../../bin/brs.node");
+const { Lexeme } = brs.lexer;
+
+const { token, identifier, EOF } = require("../ParserTests");
+
+describe("`end` statement", () => {
+    beforeEach(() => {
+        parser = new brs.parser.Parser();
+    });
+
+    it("does not produce errors", () => {
+        let { tokens } = brs.lexer.Lexer.scan(`
+                sub Main()
+                    end
+                end sub
+            `);
+        let { statements, errors } = parser.parse(tokens);
+        expect(errors.length).toEqual(0);
+        expect(statements).toMatchSnapshot();
+    });
+
+    it("is valid as a statement", () => {
+        let { statements, errors } = brs.parser.Parser.parse([token(Lexeme.End, "end"), EOF]);
+        expect(errors[0]).toBeUndefined();
+        expect(statements).toMatchSnapshot();
+    });
+
+    it("can be used as a property name on objects", () => {
+        let { tokens } = brs.lexer.Lexer.scan(`
+                sub Main()
+                    person = {
+                        end: true
+                    }
+                end sub
+            `);
+        let { statements, errors } = parser.parse(tokens);
+        expect(errors.length).toEqual(0);
+        expect(statements).toMatchSnapshot();
+    });
+
+    it("is not allowed as a standalone variable", () => {
+        //this test depends on token locations, so use the lexer to generate those locations.
+        let { tokens } = brs.lexer.Lexer.scan(`
+                sub Main()
+                    end = true
+                end sub
+            `);
+        let { statements, errors } = parser.parse(tokens);
+        expect(errors.length).toEqual(1);
+        //specifically check for the error location, because the identifier location was wrong in the past
+        expect(errors[0].location).toEqual({
+            file: "",
+            start: { line: 3, column: 24 },
+            end: { line: 3, column: 25 },
+        });
+        expect(statements).toMatchSnapshot();
+    });
+});

test/parser/statement/Misc.test.js

@@ -7,49 +7,6 @@ describe("parser", () => {
         parser = new brs.parser.Parser();
     });
 
-    describe("`end` keyword", () => {
-        it("does not produce errors", () => {
-            let { tokens } = brs.lexer.Lexer.scan(`
-                sub Main()
-                    end
-                end sub
-            `);
-            let { statements, errors } = parser.parse(tokens);
-            expect(errors.length).toEqual(0);
-            expect(statements).toMatchSnapshot();
-        });
-        it("can be used as a property name on objects", () => {
-            let { tokens } = brs.lexer.Lexer.scan(`
-                sub Main()
-                    person = {
-                        end: true
-                    }
-                end sub
-            `);
-            let { statements, errors } = parser.parse(tokens);
-            expect(errors.length).toEqual(0);
-            expect(statements).toMatchSnapshot();
-        });
-
-        it("is not allowed as a standalone variable", () => {
-            //this test depends on token locations, so use the lexer to generate those locations.
-            let { tokens } = brs.lexer.Lexer.scan(`
-                sub Main()
-                    end = true
-                end sub
-            `);
-            let { statements, errors } = parser.parse(tokens);
-            expect(errors.length).toEqual(1);
-            //specifically check for the error location, because the identifier location was wrong in the past
-            expect(errors[0].location).toEqual({
-                file: "",
-                start: { line: 3, column: 20 },
-                end: { line: 3, column: 23 },
-            });
-            expect(statements).toMatchSnapshot();
-        });
-    });
-
     it("certain reserved words are allowed as local var identifiers", () => {
         let { tokens } = brs.lexer.Lexer.scan(`
             sub Main()

test/parser/statement/Stop.test.js

@@ -1,6 +1,5 @@
 const brs = require("../../../bin/brs.node");
 const { Lexeme } = brs.lexer;
-const { Int32 } = brs.types;
 
 const { token, identifier, EOF } = require("../ParserTests");