@plurnk/plurnk-grammar 0.1.1 → 0.2.1

package/src/generated/plurnkParserVisitor.ts

@@ -4,8 +4,21 @@ 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 { FindStatementContext } from "./plurnkParser.ts";
+import { ReadStatementContext } from "./plurnkParser.ts";
+import { EditStatementContext } from "./plurnkParser.ts";
+import { CopyStatementContext } from "./plurnkParser.ts";
+import { MoveStatementContext } from "./plurnkParser.ts";
+import { ShowStatementContext } from "./plurnkParser.ts";
+import { HideStatementContext } from "./plurnkParser.ts";
+import { SendStatementContext } from "./plurnkParser.ts";
+import { ExecStatementContext } from "./plurnkParser.ts";
+import { TagOpModifiersContext } from "./plurnkParser.ts";
+import { SendModifiersContext } from "./plurnkParser.ts";
+import { ExecModifiersContext } from "./plurnkParser.ts";
+import { TagSignalContext } from "./plurnkParser.ts";
+import { IntSignalContext } from "./plurnkParser.ts";
+import { IdentSignalContext } from "./plurnkParser.ts";
 import { PathContext } from "./plurnkParser.ts";
 import { LineMarkerContext } from "./plurnkParser.ts";
 import { BodyContext } from "./plurnkParser.ts";
@@ -32,17 +45,95 @@ export class plurnkParserVisitor<Result> extends AbstractParseTreeVisitor<Result
      */
     visitStatement?: (ctx: StatementContext) => Result;
     /**
-     * Visit a parse tree produced by `plurnkParser.openTag`.
+     * Visit a parse tree produced by `plurnkParser.findStatement`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitOpenTag?: (ctx: OpenTagContext) => Result;
+    visitFindStatement?: (ctx: FindStatementContext) => Result;
     /**
-     * Visit a parse tree produced by `plurnkParser.signal`.
+     * Visit a parse tree produced by `plurnkParser.readStatement`.
      * @param ctx the parse tree
      * @return the visitor result
      */
-    visitSignal?: (ctx: SignalContext) => Result;
+    visitReadStatement?: (ctx: ReadStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.editStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitEditStatement?: (ctx: EditStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.copyStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitCopyStatement?: (ctx: CopyStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.moveStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMoveStatement?: (ctx: MoveStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.showStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitShowStatement?: (ctx: ShowStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.hideStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitHideStatement?: (ctx: HideStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.sendStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSendStatement?: (ctx: SendStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.execStatement`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExecStatement?: (ctx: ExecStatementContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.tagOpModifiers`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTagOpModifiers?: (ctx: TagOpModifiersContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.sendModifiers`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSendModifiers?: (ctx: SendModifiersContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.execModifiers`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitExecModifiers?: (ctx: ExecModifiersContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.tagSignal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTagSignal?: (ctx: TagSignalContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.intSignal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitIntSignal?: (ctx: IntSignalContext) => Result;
+    /**
+     * Visit a parse tree produced by `plurnkParser.identSignal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitIdentSignal?: (ctx: IdentSignalContext) => Result;
     /**
      * Visit a parse tree produced by `plurnkParser.path`.
      * @param ctx the parse tree

package/src/index.ts

@@ -1,142 +1,29 @@
-import {
-    BaseErrorListener,
-    CharStream,
-    CommonTokenStream,
-    type RecognitionException,
-    type Recognizer,
-    type Token,
-} from "antlr4ng";
-import { plurnkLexer } from "./generated/plurnkLexer.ts";
-import { plurnkParser } from "./generated/plurnkParser.ts";
-import { buildStatement, type PlurnkStatement, type Position } from "./ast.ts";
-import { PlurnkParseError } from "./errors.ts";
-import { PlurnkErrorStrategy, translateLexerMessage } from "./error-strategy.ts";
-
-export { PlurnkParseError } from "./errors.ts";
-export type { ErrorSource } from "./errors.ts";
-export {
-    type PlurnkStatement,
-    type PlurnkOp,
-    type Position,
-    type LineMarker,
-    type FindStatement,
-    type ReadStatement,
-    type EditStatement,
-    type CopyStatement,
-    type MoveStatement,
-    type ShowStatement,
-    type HideStatement,
-    type SendStatement,
-    type ExecStatement,
-} from "./ast.ts";
-
-export type ParseItem =
-    | { kind: "statement"; statement: PlurnkStatement }
-    | { kind: "error"; error: PlurnkParseError }
-    | { kind: "text"; text: string; position: Position };
-
-export type ParseResult = {
-    items: ParseItem[];
-    unparsedTail?: { from: Position; reason: string };
-};
-
-class RecordingListener extends BaseErrorListener {
-    readonly errors: PlurnkParseError[];
-    readonly source: "lexer" | "parser";
-
-    constructor(source: "lexer" | "parser", errors: PlurnkParseError[]) {
-        super();
-        this.source = source;
-        this.errors = errors;
-    }
-
-    override syntaxError(
-        recognizer: Recognizer<any>,
-        _offendingSymbol: Token | null,
-        line: number,
-        column: number,
-        msg: string,
-        _e: RecognitionException | null,
-    ): void {
-        const translated = this.source === "lexer"
-            ? translateLexerMessage(recognizer as plurnkLexer, msg)
-            : msg;
-        this.errors.push(new PlurnkParseError(line, column, this.source, translated));
-    }
-}
-
-const errorInRange = (
-    err: PlurnkParseError,
-    start: { line: number; column: number },
-    stop: { line: number; column: number },
-): boolean => {
-    if (err.line < start.line || err.line > stop.line) return false;
-    if (err.line === start.line && err.column < start.column) return false;
-    if (err.line === stop.line && err.column > stop.column) return false;
-    return true;
-};
-
-export const parse = (input: string): ParseResult => {
-    const lexer = new plurnkLexer(CharStream.fromString(input));
-    const errors: PlurnkParseError[] = [];
-    lexer.removeErrorListeners();
-    lexer.addErrorListener(new RecordingListener("lexer", errors));
-
-    const tokenStream = new CommonTokenStream(lexer);
-    const parser = new plurnkParser(tokenStream);
-    parser.removeErrorListeners();
-    parser.addErrorListener(new RecordingListener("parser", errors));
-    parser.errorHandler = new PlurnkErrorStrategy();
-
-    const tree = parser.document();
-
-    const items: ParseItem[] = [];
-    const consumedErrors = new Set<PlurnkParseError>();
-
-    for (const child of tree.children ?? []) {
-        const ctx = child as any;
-        const start = ctx.start ?? ctx.symbol;
-        const stop = ctx.stop ?? ctx.symbol;
-        if (!start) continue;
-
-        if (ctx.ruleIndex === plurnkParser.RULE_statement) {
-            const errForStatement = errors.find(
-                (e) => !consumedErrors.has(e) && errorInRange(e, start, stop ?? start),
-            );
-            if (errForStatement) {
-                consumedErrors.add(errForStatement);
-                items.push({ kind: "error", error: errForStatement });
-            } else {
-                try {
-                    items.push({ kind: "statement", statement: buildStatement(ctx) });
-                } catch (e) {
-                    if (e instanceof PlurnkParseError) {
-                        items.push({ kind: "error", error: e });
-                    } else {
-                        throw e;
-                    }
-                }
-            }
-        } else if (ctx.symbol?.type === plurnkLexer.TEXT) {
-            const position: Position = { line: start.line, column: start.column };
-            items.push({ kind: "text", text: ctx.symbol.text ?? "", position });
-        }
-    }
-
-    for (const err of errors) {
-        if (!consumedErrors.has(err)) {
-            items.push({ kind: "error", error: err });
-        }
-    }
-
-    let unparsedTail: ParseResult["unparsedTail"];
-    if (lexer.mode !== 0) {
-        const lastToken = tokenStream.get(tokenStream.size - 1);
-        unparsedTail = {
-            from: { line: lastToken?.line ?? 0, column: lastToken?.column ?? 0 },
-            reason: `lexer ended in non-default mode (${lexer.mode}); a statement was likely never closed`,
-        };
-    }
-
-    return { items, unparsedTail };
-};
+export { default as PlurnkParser } from "./PlurnkParser.ts";
+export { default as PlurnkParseError } from "./PlurnkParseError.ts";
+export { default as PlurnkErrorStrategy } from "./PlurnkErrorStrategy.ts";
+export { default as AstBuilder } from "./AstBuilder.ts";
+export { default as RecordingListener } from "./RecordingListener.ts";
+
+export type { ErrorSource } from "./PlurnkParseError.ts";
+export type {
+    CopyStatement,
+    EditStatement,
+    ExecStatement,
+    FindStatement,
+    HideStatement,
+    LineMarker,
+    LocalPath,
+    MatcherBody,
+    MoveStatement,
+    ParseItem,
+    ParseResult,
+    ParsedPath,
+    PlurnkOp,
+    PlurnkStatement,
+    Position,
+    ReadStatement,
+    SendBody,
+    SendStatement,
+    ShowStatement,
+    UrlPath,
+} from "./types.ts";