@plurnk/plurnk-grammar 0.1.0

package/src/generated/plurnkParser.ts

@@ -0,0 +1,625 @@
+
+import * as antlr from "antlr4ng";
+import { Token } from "antlr4ng";
+
+import { plurnkParserVisitor } from "./plurnkParserVisitor.ts";
+
+// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
+// eslint-disable-next-line no-unused-vars
+type int = number;
+
+
+export class plurnkParser extends antlr.Parser {
+    public static readonly LBRACKET = 1;
+    public static readonly RBRACKET = 2;
+    public static readonly LPAREN = 3;
+    public static readonly RPAREN = 4;
+    public static readonly L_MARKER = 5;
+    public static readonly COLON = 6;
+    public static readonly SIGNAL_TEXT = 7;
+    public static readonly PATH_TEXT = 8;
+    public static readonly BODY_TEXT = 9;
+    public static readonly CLOSE_TAG = 10;
+    public static readonly TEXT = 11;
+    public static readonly OPEN_FIND = 12;
+    public static readonly OPEN_READ = 13;
+    public static readonly OPEN_EDIT = 14;
+    public static readonly OPEN_COPY = 15;
+    public static readonly OPEN_MOVE = 16;
+    public static readonly OPEN_SHOW = 17;
+    public static readonly OPEN_HIDE = 18;
+    public static readonly OPEN_SEND = 19;
+    public static readonly OPEN_EXEC = 20;
+    public static readonly OPENED_WS = 21;
+    public static readonly PS_WS = 22;
+    public static readonly PP_WS = 23;
+    public static readonly PL_WS = 24;
+    public static readonly BODY_COLON = 25;
+    public static readonly RULE_document = 0;
+    public static readonly RULE_statement = 1;
+    public static readonly RULE_openTag = 2;
+    public static readonly RULE_signal = 3;
+    public static readonly RULE_path = 4;
+    public static readonly RULE_lineMarker = 5;
+    public static readonly RULE_body = 6;
+
+    public static readonly literalNames = [
+        null, null, null, null, null, null, null, null, null, null, null, 
+        null, null, null, null, null, null, null, null, null, null, null, 
+        null, null, null, "':'"
+    ];
+
+    public static readonly symbolicNames = [
+        null, "LBRACKET", "RBRACKET", "LPAREN", "RPAREN", "L_MARKER", "COLON", 
+        "SIGNAL_TEXT", "PATH_TEXT", "BODY_TEXT", "CLOSE_TAG", "TEXT", "OPEN_FIND", 
+        "OPEN_READ", "OPEN_EDIT", "OPEN_COPY", "OPEN_MOVE", "OPEN_SHOW", 
+        "OPEN_HIDE", "OPEN_SEND", "OPEN_EXEC", "OPENED_WS", "PS_WS", "PP_WS", 
+        "PL_WS", "BODY_COLON"
+    ];
+    public static readonly ruleNames = [
+        "document", "statement", "openTag", "signal", "path", "lineMarker", 
+        "body",
+    ];
+
+    public get grammarFileName(): string { return "plurnkParser.g4"; }
+    public get literalNames(): (string | null)[] { return plurnkParser.literalNames; }
+    public get symbolicNames(): (string | null)[] { return plurnkParser.symbolicNames; }
+    public get ruleNames(): string[] { return plurnkParser.ruleNames; }
+    public get serializedATN(): number[] { return plurnkParser._serializedATN; }
+
+    protected createFailedPredicateException(predicate?: string, message?: string): antlr.FailedPredicateException {
+        return new antlr.FailedPredicateException(this, predicate, message);
+    }
+
+    public constructor(input: antlr.TokenStream) {
+        super(input);
+        this.interpreter = new antlr.ParserATNSimulator(this, plurnkParser._ATN, plurnkParser.decisionsToDFA, new antlr.PredictionContextCache());
+    }
+    public document(): DocumentContext {
+        let localContext = new DocumentContext(this.context, this.state);
+        this.enterRule(localContext, 0, plurnkParser.RULE_document);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 18;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 2095104) !== 0)) {
+                {
+                this.state = 16;
+                this.errorHandler.sync(this);
+                switch (this.tokenStream.LA(1)) {
+                case plurnkParser.OPEN_FIND:
+                case plurnkParser.OPEN_READ:
+                case plurnkParser.OPEN_EDIT:
+                case plurnkParser.OPEN_COPY:
+                case plurnkParser.OPEN_MOVE:
+                case plurnkParser.OPEN_SHOW:
+                case plurnkParser.OPEN_HIDE:
+                case plurnkParser.OPEN_SEND:
+                case plurnkParser.OPEN_EXEC:
+                    {
+                    this.state = 14;
+                    this.statement();
+                    }
+                    break;
+                case plurnkParser.TEXT:
+                    {
+                    this.state = 15;
+                    this.match(plurnkParser.TEXT);
+                    }
+                    break;
+                default:
+                    throw new antlr.NoViableAltException(this);
+                }
+                }
+                this.state = 20;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            }
+            this.state = 21;
+            this.match(plurnkParser.EOF);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public statement(): StatementContext {
+        let localContext = new StatementContext(this.context, this.state);
+        this.enterRule(localContext, 2, plurnkParser.RULE_statement);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 23;
+            this.openTag();
+            this.state = 25;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 1) {
+                {
+                this.state = 24;
+                this.signal();
+                }
+            }
+
+            this.state = 28;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 3) {
+                {
+                this.state = 27;
+                this.path();
+                }
+            }
+
+            this.state = 31;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 5) {
+                {
+                this.state = 30;
+                this.lineMarker();
+                }
+            }
+
+            this.state = 33;
+            this.match(plurnkParser.COLON);
+            this.state = 35;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 9) {
+                {
+                this.state = 34;
+                this.body();
+                }
+            }
+
+            this.state = 37;
+            this.match(plurnkParser.CLOSE_TAG);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public openTag(): OpenTagContext {
+        let localContext = new OpenTagContext(this.context, this.state);
+        this.enterRule(localContext, 4, plurnkParser.RULE_openTag);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 39;
+            _la = this.tokenStream.LA(1);
+            if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 2093056) !== 0))) {
+            this.errorHandler.recoverInline(this);
+            }
+            else {
+                this.errorHandler.reportMatch(this);
+                this.consume();
+            }
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public signal(): SignalContext {
+        let localContext = new SignalContext(this.context, this.state);
+        this.enterRule(localContext, 6, plurnkParser.RULE_signal);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 41;
+            this.match(plurnkParser.LBRACKET);
+            this.state = 43;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 7) {
+                {
+                this.state = 42;
+                this.match(plurnkParser.SIGNAL_TEXT);
+                }
+            }
+
+            this.state = 45;
+            this.match(plurnkParser.RBRACKET);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public path(): PathContext {
+        let localContext = new PathContext(this.context, this.state);
+        this.enterRule(localContext, 8, plurnkParser.RULE_path);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 47;
+            this.match(plurnkParser.LPAREN);
+            this.state = 49;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            if (_la === 8) {
+                {
+                this.state = 48;
+                this.match(plurnkParser.PATH_TEXT);
+                }
+            }
+
+            this.state = 51;
+            this.match(plurnkParser.RPAREN);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public lineMarker(): LineMarkerContext {
+        let localContext = new LineMarkerContext(this.context, this.state);
+        this.enterRule(localContext, 10, plurnkParser.RULE_lineMarker);
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 53;
+            this.match(plurnkParser.L_MARKER);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+    public body(): BodyContext {
+        let localContext = new BodyContext(this.context, this.state);
+        this.enterRule(localContext, 12, plurnkParser.RULE_body);
+        let _la: number;
+        try {
+            this.enterOuterAlt(localContext, 1);
+            {
+            this.state = 56;
+            this.errorHandler.sync(this);
+            _la = this.tokenStream.LA(1);
+            do {
+                {
+                {
+                this.state = 55;
+                this.match(plurnkParser.BODY_TEXT);
+                }
+                }
+                this.state = 58;
+                this.errorHandler.sync(this);
+                _la = this.tokenStream.LA(1);
+            } while (_la === 9);
+            }
+        }
+        catch (re) {
+            if (re instanceof antlr.RecognitionException) {
+                this.errorHandler.reportError(this, re);
+                this.errorHandler.recover(this, re);
+            } else {
+                throw re;
+            }
+        }
+        finally {
+            this.exitRule();
+        }
+        return localContext;
+    }
+
+    public static readonly _serializedATN: number[] = [
+        4,1,25,61,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
+        6,1,0,1,0,5,0,17,8,0,10,0,12,0,20,9,0,1,0,1,0,1,1,1,1,3,1,26,8,1,
+        1,1,3,1,29,8,1,1,1,3,1,32,8,1,1,1,1,1,3,1,36,8,1,1,1,1,1,1,2,1,2,
+        1,3,1,3,3,3,44,8,3,1,3,1,3,1,4,1,4,3,4,50,8,4,1,4,1,4,1,5,1,5,1,
+        6,4,6,57,8,6,11,6,12,6,58,1,6,0,0,7,0,2,4,6,8,10,12,0,1,1,0,12,20,
+        62,0,18,1,0,0,0,2,23,1,0,0,0,4,39,1,0,0,0,6,41,1,0,0,0,8,47,1,0,
+        0,0,10,53,1,0,0,0,12,56,1,0,0,0,14,17,3,2,1,0,15,17,5,11,0,0,16,
+        14,1,0,0,0,16,15,1,0,0,0,17,20,1,0,0,0,18,16,1,0,0,0,18,19,1,0,0,
+        0,19,21,1,0,0,0,20,18,1,0,0,0,21,22,5,0,0,1,22,1,1,0,0,0,23,25,3,
+        4,2,0,24,26,3,6,3,0,25,24,1,0,0,0,25,26,1,0,0,0,26,28,1,0,0,0,27,
+        29,3,8,4,0,28,27,1,0,0,0,28,29,1,0,0,0,29,31,1,0,0,0,30,32,3,10,
+        5,0,31,30,1,0,0,0,31,32,1,0,0,0,32,33,1,0,0,0,33,35,5,6,0,0,34,36,
+        3,12,6,0,35,34,1,0,0,0,35,36,1,0,0,0,36,37,1,0,0,0,37,38,5,10,0,
+        0,38,3,1,0,0,0,39,40,7,0,0,0,40,5,1,0,0,0,41,43,5,1,0,0,42,44,5,
+        7,0,0,43,42,1,0,0,0,43,44,1,0,0,0,44,45,1,0,0,0,45,46,5,2,0,0,46,
+        7,1,0,0,0,47,49,5,3,0,0,48,50,5,8,0,0,49,48,1,0,0,0,49,50,1,0,0,
+        0,50,51,1,0,0,0,51,52,5,4,0,0,52,9,1,0,0,0,53,54,5,5,0,0,54,11,1,
+        0,0,0,55,57,5,9,0,0,56,55,1,0,0,0,57,58,1,0,0,0,58,56,1,0,0,0,58,
+        59,1,0,0,0,59,13,1,0,0,0,9,16,18,25,28,31,35,43,49,58
+    ];
+
+    private static __ATN: antlr.ATN;
+    public static get _ATN(): antlr.ATN {
+        if (!plurnkParser.__ATN) {
+            plurnkParser.__ATN = new antlr.ATNDeserializer().deserialize(plurnkParser._serializedATN);
+        }
+
+        return plurnkParser.__ATN;
+    }
+
+
+    private static readonly vocabulary = new antlr.Vocabulary(plurnkParser.literalNames, plurnkParser.symbolicNames, []);
+
+    public override get vocabulary(): antlr.Vocabulary {
+        return plurnkParser.vocabulary;
+    }
+
+    private static readonly decisionsToDFA = plurnkParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
+}
+
+export class DocumentContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public EOF(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.EOF, 0)!;
+    }
+    public statement(): StatementContext[];
+    public statement(i: number): StatementContext | null;
+    public statement(i?: number): StatementContext[] | StatementContext | null {
+        if (i === undefined) {
+            return this.getRuleContexts(StatementContext);
+        }
+
+        return this.getRuleContext(i, StatementContext);
+    }
+    public TEXT(): antlr.TerminalNode[];
+    public TEXT(i: number): antlr.TerminalNode | null;
+    public TEXT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(plurnkParser.TEXT);
+    	} else {
+    		return this.getToken(plurnkParser.TEXT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_document;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitDocument) {
+            return visitor.visitDocument(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+
+
+export class StatementContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public openTag(): OpenTagContext {
+        return this.getRuleContext(0, OpenTagContext)!;
+    }
+    public COLON(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.COLON, 0)!;
+    }
+    public CLOSE_TAG(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.CLOSE_TAG, 0)!;
+    }
+    public signal(): SignalContext | null {
+        return this.getRuleContext(0, SignalContext);
+    }
+    public path(): PathContext | null {
+        return this.getRuleContext(0, PathContext);
+    }
+    public lineMarker(): LineMarkerContext | null {
+        return this.getRuleContext(0, LineMarkerContext);
+    }
+    public body(): BodyContext | null {
+        return this.getRuleContext(0, BodyContext);
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_statement;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitStatement) {
+            return visitor.visitStatement(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+
+
+export class OpenTagContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public OPEN_FIND(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_FIND, 0);
+    }
+    public OPEN_READ(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_READ, 0);
+    }
+    public OPEN_EDIT(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_EDIT, 0);
+    }
+    public OPEN_COPY(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_COPY, 0);
+    }
+    public OPEN_MOVE(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_MOVE, 0);
+    }
+    public OPEN_SHOW(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_SHOW, 0);
+    }
+    public OPEN_HIDE(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_HIDE, 0);
+    }
+    public OPEN_SEND(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_SEND, 0);
+    }
+    public OPEN_EXEC(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.OPEN_EXEC, 0);
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_openTag;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitOpenTag) {
+            return visitor.visitOpenTag(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+
+
+export class SignalContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LBRACKET(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.LBRACKET, 0)!;
+    }
+    public RBRACKET(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.RBRACKET, 0)!;
+    }
+    public SIGNAL_TEXT(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.SIGNAL_TEXT, 0);
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_signal;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitSignal) {
+            return visitor.visitSignal(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+
+
+export class PathContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public LPAREN(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.LPAREN, 0)!;
+    }
+    public RPAREN(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.RPAREN, 0)!;
+    }
+    public PATH_TEXT(): antlr.TerminalNode | null {
+        return this.getToken(plurnkParser.PATH_TEXT, 0);
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_path;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitPath) {
+            return visitor.visitPath(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+
+
+export class LineMarkerContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public L_MARKER(): antlr.TerminalNode {
+        return this.getToken(plurnkParser.L_MARKER, 0)!;
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_lineMarker;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitLineMarker) {
+            return visitor.visitLineMarker(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}
+
+
+export class BodyContext extends antlr.ParserRuleContext {
+    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
+        super(parent, invokingState);
+    }
+    public BODY_TEXT(): antlr.TerminalNode[];
+    public BODY_TEXT(i: number): antlr.TerminalNode | null;
+    public BODY_TEXT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
+    	if (i === undefined) {
+    		return this.getTokens(plurnkParser.BODY_TEXT);
+    	} else {
+    		return this.getToken(plurnkParser.BODY_TEXT, i);
+    	}
+    }
+    public override get ruleIndex(): number {
+        return plurnkParser.RULE_body;
+    }
+    public override accept<Result>(visitor: plurnkParserVisitor<Result>): Result | null {
+        if (visitor.visitBody) {
+            return visitor.visitBody(this);
+        } else {
+            return visitor.visitChildren(this);
+        }
+    }
+}

package/src/generated/plurnkParserVisitor.ts

@@ -0,0 +1,65 @@
+
+import { AbstractParseTreeVisitor } from "antlr4ng";
+
+
+import { DocumentContext } from "./plurnkParser.ts";
+import { StatementContext } from "./plurnkParser.ts";
+import { OpenTagContext } from "./plurnkParser.ts";
+import { SignalContext } from "./plurnkParser.ts";
+import { PathContext } from "./plurnkParser.ts";
+import { LineMarkerContext } from "./plurnkParser.ts";
+import { BodyContext } from "./plurnkParser.ts";
+
+
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `plurnkParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export class plurnkParserVisitor<Result> extends AbstractParseTreeVisitor<Result> {
+    /**
+     * Visit a parse tree produced by `plurnkParser.document`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitDocument?: (ctx: DocumentContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.statement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitStatement?: (ctx: StatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.openTag`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitOpenTag?: (ctx: OpenTagContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.signal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSignal?: (ctx: SignalContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.path`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPath?: (ctx: PathContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.lineMarker`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLineMarker?: (ctx: LineMarkerContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.body`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitBody?: (ctx: BodyContext) => Result;
+}
+