Add BNF support package for bidirectional DS/Dsp syntax conversion

bnf/Ds.g4

@@ -0,0 +1,37 @@
+grammar Ds;
+
+rule_pool
+    : NEWLINE* (rule (NEWLINE+ rule)*)? NEWLINE* EOF
+    ;
+
+rule
+    : (term NEWLINE+)* RULE NEWLINE term
+    ;
+
+term
+    : SYMBOL                         # symbol
+    | '(subscript' term* ')'         # subscript
+    | '(function' term* ')'          # function
+    | '(unary' SYMBOL term ')'       # unary
+    | '(binary' SYMBOL term term ')' # binary
+    ;
+
+RULE
+    : '--' '-'*
+    ;
+
+WHITESPACE
+    : [ \t]+ -> skip
+    ;
+
+COMMENT
+    : '//' ~[\r\n]* -> skip
+    ;
+
+NEWLINE
+    : [\r\n]
+    ;
+
+SYMBOL
+    : ~[ \t\r\n,()[\]]+
+    ;

bnf/Dsp.g4

@@ -0,0 +1,48 @@
+grammar Dsp;
+
+rule_pool
+    : NEWLINE* (rule (NEWLINE+ rule)*)? NEWLINE* EOF
+    ;
+
+rule
+    : term
+    | (term (',' term)*)? '->' term
+    ;
+
+term
+    : SYMBOL                                                 # symbol
+    | '(' term ')'                                           # parentheses
+    | term '::' term                                         # binary
+    | term '.' term                                          # binary
+    | term '[' term (',' term)* ']'                          # subscript
+    | term '(' (term (',' term)*)? ')'                       # function
+    | <assoc=right> ('~' | '!' | '-' | '+' | '&' | '*') term # unary
+    | term '.*' term                                         # binary
+    | term ('*' | '/' | '%') term                            # binary
+    | term ('+' | '-') term                                  # binary
+    | term ('<<' | '>>') term                                # binary
+    | term ('<' | '>' | '<=' | '>=') term                    # binary
+    | term ('==' | '!=') term                                # binary
+    | term '&' term                                          # binary
+    | term '^' term                                          # binary
+    | term '|' term                                          # binary
+    | term '&&' term                                         # binary
+    | term '||' term                                         # binary
+    | term '=' term                                          # binary
+    ;
+
+WHITESPACE
+    : [ \t]+ -> skip
+    ;
+
+COMMENT
+    : '//' ~[\r\n]* -> skip
+    ;
+
+NEWLINE
+    : [\r\n]
+    ;
+
+SYMBOL
+    : ~[ \t\r\n,()[\]]+
+    ;

bnf/README.md

@@ -0,0 +1,6 @@
+# BNF Support Package for DS
+
+This package provides bidirectional conversion between two syntax formats for the DS deductive system:
+
+- **Ds**: The lisp-like syntax currently used in DS
+- **Dsp**: A traditional readable syntax with infix operators

bnf/apyds_bnf/.gitignore

@@ -0,0 +1,2 @@
+*
+!__init__.py

bnf/apyds_bnf/__init__.py

@@ -0,0 +1,88 @@
+__all__ = ["parse", "unparse"]
+
+from antlr4 import InputStream, CommonTokenStream
+from .DspLexer import DspLexer
+from .DspParser import DspParser
+from .DspVisitor import DspVisitor
+from .DsLexer import DsLexer
+from .DsParser import DsParser
+from .DsVisitor import DsVisitor
+
+
+class ParseVisitor(DspVisitor):
+    def visitRule_pool(self, ctx):
+        return "\n\n".join(self.visit(r) for r in ctx.rule_())
+
+    def visitRule(self, ctx):
+        result = [self.visit(t) for t in ctx.term()]
+        if len(result) == 1:
+            return f"----\n{result[0]}"
+        else:
+            conclusion = result.pop()
+            length = max(len(premise) for premise in result)
+            result.append("-" * max(length, 4))
+            result.append(conclusion)
+            return "\n".join(result)
+
+    def visitSymbol(self, ctx):
+        return ctx.SYMBOL().getText()
+
+    def visitParentheses(self, ctx):
+        return self.visit(ctx.term())
+
+    def visitSubscript(self, ctx):
+        return f"(subscript {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitFunction(self, ctx):
+        return f"(function {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitUnary(self, ctx):
+        return f"(unary {ctx.getChild(0).getText()} {self.visit(ctx.term())})"
+
+    def visitBinary(self, ctx):
+        return f"(binary {ctx.getChild(1).getText()} {self.visit(ctx.term(0))} {self.visit(ctx.term(1))})"
+
+
+class UnparseVisitor(DsVisitor):
+    def visitRule_pool(self, ctx):
+        return "\n".join(self.visit(r) for r in ctx.rule_())
+
+    def visitRule(self, ctx):
+        result = [self.visit(t) for t in ctx.term()]
+        conclusion = result.pop()
+        return ", ".join(result) + " -> " + conclusion
+
+    def visitSymbol(self, ctx):
+        return ctx.SYMBOL().getText()
+
+    def visitSubscript(self, ctx):
+        return f"{self.visit(ctx.term(0))}[{', '.join(self.visit(t) for t in ctx.term()[1:])}]"
+
+    def visitFunction(self, ctx):
+        return f"{self.visit(ctx.term(0))}({', '.join(self.visit(t) for t in ctx.term()[1:])})"
+
+    def visitUnary(self, ctx):
+        return f"({ctx.getChild(0).getText()} {self.visit(ctx.term())})"
+
+    def visitBinary(self, ctx):
+        return f"({self.visit(ctx.term(0))} {ctx.getChild(1).getText()} {self.visit(ctx.term(1))})"
+
+
+def parse(input):
+    chars = InputStream(input)
+    lexer = DspLexer(chars)
+    tokens = CommonTokenStream(lexer)
+    parser = DspParser(tokens)
+    tree = parser.rule_pool()
+    visitor = ParseVisitor()
+    return visitor.visit(tree)
+
+
+def unparse(input):
+    chars = InputStream(input)
+    lexer = DsLexer(chars)
+    tokens = CommonTokenStream(lexer)
+    parser = DsParser(tokens)
+    tree = parser.rule_pool()
+    visitor = UnparseVisitor()
+    return visitor.visit(tree)

bnf/atsds_bnf/.gitignore

@@ -0,0 +1,2 @@
+*
+!index.js

bnf/atsds_bnf/index.mjs

@@ -0,0 +1,122 @@
+import { InputStream, CommonTokenStream } from "antlr4";
+import DspLexer from "./DspLexer.js";
+import DspParser from "./DspParser.js";
+import DspVisitor from "./DspVisitor.js";
+import DsLexer from "./DsLexer.js";
+import DsParser from "./DsParser.js";
+import DsVisitor from "./DsVisitor.js";
+
+class ParseVisitor extends DspVisitor {
+    visitRule_pool(ctx) {
+        return ctx
+            .rule_()
+            .map((r) => this.visit(r))
+            .join("\n\n");
+    }
+
+    visitRule(ctx) {
+        const result = ctx.term().map((t) => this.visit(t));
+        if (result.length === 1) {
+            return `----\n${result[0]}`;
+        } else {
+            const conclusion = result.pop();
+            const length = Math.max(...result.map((premise) => premise.length));
+            result.push("-".repeat(Math.max(length, 4)));
+            result.push(conclusion);
+            return result.join("\n");
+        }
+    }
+
+    visitSymbol(ctx) {
+        return ctx.SYMBOL().getText();
+    }
+
+    visitParentheses(ctx) {
+        return this.visit(ctx.term());
+    }
+
+    visitSubscript(ctx) {
+        return `(subscript ${ctx
+            .term()
+            .map((t) => this.visit(t))
+            .join(" ")})`;
+    }
+
+    visitFunction(ctx) {
+        return `(function ${ctx
+            .term()
+            .map((t) => this.visit(t))
+            .join(" ")})`;
+    }
+
+    visitUnary(ctx) {
+        return `(unary ${ctx.getChild(0).getText()} ${this.visit(ctx.term())})`;
+    }
+
+    visitBinary(ctx) {
+        return `(binary ${ctx.getChild(1).getText()} ${this.visit(ctx.term(0))} ${this.visit(ctx.term(1))})`;
+    }
+}
+
+class UnparseVisitor extends DsVisitor {
+    visitRule_pool(ctx) {
+        return ctx
+            .rule_()
+            .map((r) => this.visit(r))
+            .join("\n");
+    }
+
+    visitRule(ctx) {
+        const result = ctx.term().map((t) => this.visit(t));
+        const conclusion = result.pop();
+        return result.join(", ") + " -> " + conclusion;
+    }
+
+    visitSymbol(ctx) {
+        return ctx.SYMBOL().getText();
+    }
+
+    visitSubscript(ctx) {
+        return `${this.visit(ctx.term(0))}[${ctx
+            .term()
+            .slice(1)
+            .map((t) => this.visit(t))
+            .join(", ")}]`;
+    }
+
+    visitFunction(ctx) {
+        return `${this.visit(ctx.term(0))}(${ctx
+            .term()
+            .slice(1)
+            .map((t) => this.visit(t))
+            .join(", ")})`;
+    }
+
+    visitUnary(ctx) {
+        return `(${ctx.getChild(0).getText()} ${this.visit(ctx.term())})`;
+    }
+
+    visitBinary(ctx) {
+        return `(${this.visit(ctx.term(0))} ${ctx.getChild(1).getText()} ${this.visit(ctx.term(1))})`;
+    }
+}
+
+export function parse(input) {
+    const chars = new InputStream(input);
+    const lexer = new DspLexer(chars);
+    const tokens = new CommonTokenStream(lexer);
+    const parser = new DspParser(tokens);
+    const tree = parser.rule_pool();
+    const visitor = new ParseVisitor();
+    return visitor.visit(tree);
+}
+
+export function unparse(input) {
+    const chars = new InputStream(input);
+    const lexer = new DsLexer(chars);
+    const tokens = new CommonTokenStream(lexer);
+    const parser = new DsParser(tokens);
+    const tree = parser.rule_pool();
+    const visitor = new UnparseVisitor();
+    return visitor.visit(tree);
+}