Add a human friendly grammar.

Author: hzhangxyz

g4/.gitignore

@@ -0,0 +1,10 @@
+Ds.interp
+Ds.tokens
+DsLexer.interp
+DsLexer.tokens
+DsLexer.js
+DsLexer.py
+DsParser.js
+DsParser.py
+DsVisitor.js
+DsVisitor.py

g4/Ds.g4

@@ -0,0 +1,48 @@
+grammar Ds;
+
+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,()]+
+    ;

g4/main.js

@@ -0,0 +1,60 @@
+import {
+    InputStream,
+    CommonTokenStream
+} from "antlr4";
+import DsLexer from "./DsLexer.js";
+import DsParser from "./DsParser.js";
+import DsVisitor from "./DsVisitor.js";
+
+class Visitor extends DsVisitor {
+    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 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))})`;
+    }
+}
+
+export function parse(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 Visitor();
+    return visitor.visit(tree);
+}

g4/main.py

@@ -0,0 +1,50 @@
+__all__ = ["parse"]
+
+from antlr4 import InputStream, CommonTokenStream
+from DsLexer import DsLexer
+from DsParser import DsParser
+from DsVisitor import DsVisitor
+
+
+class Visitor(DsVisitor):
+    def visitRule_pool(self, ctx: DsParser.Rule_poolContext):
+        return "\n\n".join([self.visit(r) for r in ctx.rule_()])
+
+    def visitRule(self, ctx: DsParser.RuleContext):
+        result = [self.visit(t) for t in ctx.term()]
+        if len(result) == 1:
+            return 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: DsParser.SymbolContext):
+        return ctx.SYMBOL().getText()
+
+    def visitParentheses(self, ctx: DsParser.ParenthesesContext):
+        return self.visit(ctx.term())
+
+    def visitSubscript(self, ctx: DsParser.SubscriptContext):
+        return f"(subscript {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitFunction(self, ctx: DsParser.FunctionContext):
+        return f"(function {' '.join(self.visit(t) for t in ctx.term())})"
+
+    def visitUnary(self, ctx: DsParser.UnaryContext):
+        return f"(unary {ctx.getChild(0).getText()} {self.visit(ctx.term())})"
+
+    def visitBinary(self, ctx: DsParser.BinaryContext):
+        return f"(binary {ctx.getChild(1).getText()} {self.visit(ctx.term(0))} {self.visit(ctx.term(1))})"
+
+
+def parse(string):
+    input_stream = InputStream(string)
+    lexer = DsLexer(input_stream)
+    stream = CommonTokenStream(lexer)
+    parser = DsParser(stream)
+    tree = parser.rule_pool()
+    visitor = Visitor()
+    return visitor.visit(tree)