master > master: codego initialisiert

codego/aussagenlogik/schema/schema.go

@@ -0,0 +1,175 @@
+package schema
+
+import (
+	"errors"
+	"logik/aussagenlogik/syntaxbaum"
+	parser "logik/grammars/aussagenlogik"
+	"strings"
+
+	"github.com/antlr/antlr4/runtime/Go/antlr"
+)
+
+/* ---------------------------------------------------------------- *
+ * EXPORTS
+ * ---------------------------------------------------------------- */
+
+func ParseExpr(u string) (syntaxbaum.SyntaxBaum, error) {
+	var lexer = createLexer(u)
+	var tokenStream = lexerToTokenStream(lexer)
+	var prs = parser.NewaussagenlogikParser(tokenStream)
+	var t = prs.Start()
+	tree, err := createSyntaxBaum(t, prs)
+	return tree, err
+}
+
+/* ---------------------------------------------------------------- *
+ * PRIVATE
+ * ---------------------------------------------------------------- */
+
+func exprToStream(u string) *antlr.InputStream {
+	return antlr.NewInputStream(u)
+}
+
+func lexerToTokenStream(lexer antlr.Lexer) antlr.TokenStream {
+	return antlr.NewCommonTokenStream(lexer, antlr.TokenDefaultChannel)
+}
+
+func createLexer(u string) antlr.Lexer {
+	stream := exprToStream(u)
+	return parser.NewaussagenlogikLexer(stream)
+}
+
+func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) (syntaxbaum.SyntaxBaum, error) {
+	var ant = antlrTree{tree: tree, parser: &parser}
+	return ant.toSyntaxBaum()
+}
+
+/* ---------------------------------------------------------------- *
+ * Struct: antlrTree + Methods
+ * ---------------------------------------------------------------- */
+
+type antlrTree struct {
+	tree   antlr.Tree
+	parser *antlr.Parser
+}
+
+func (ant antlrTree) getChildren() []antlrTree {
+	var nodes = ant.tree.GetChildren()
+	var subants = make([]antlrTree, len(nodes))
+	for i, node := range nodes {
+		subants[i] = antlrTree{tree: node, parser: ant.parser}
+	}
+	return subants
+}
+
+func (ant antlrTree) getLabel() string {
+	return antlr.TreesGetNodeText(ant.tree, []string{}, *ant.parser)
+}
+
+func (ant antlrTree) getTextContent() string {
+	var expr string = ant.getLabel()
+	for _, subant := range ant.getChildren() {
+		expr += subant.getTextContent()
+	}
+	return expr
+}
+
+func (ant antlrTree) getTextContentLeaves() string {
+	var expr string = ""
+	var subants = ant.getChildren()
+	if len(subants) == 0 {
+		expr = ant.getLabel()
+	} else {
+		for _, subant := range subants {
+			expr += subant.getTextContent()
+		}
+	}
+	return expr
+}
+
+func (ant antlrTree) toSyntaxBaum() (syntaxbaum.SyntaxBaum, error) {
+	var tree syntaxbaum.SyntaxBaum
+	var err error
+	var label string = ant.getLabel()
+	var subants = ant.getChildren()
+	var nChildren = len(subants)
+
+	switch label {
+	case "start":
+		if nChildren == 1 {
+			return subants[0].toSyntaxBaum()
+		}
+	case "open":
+		if nChildren == 1 {
+			return subants[0].toSyntaxBaum()
+		}
+	case "closed":
+		switch nChildren {
+		case 1:
+			return subants[0].toSyntaxBaum()
+		case 3:
+			return subants[1].toSyntaxBaum()
+		}
+	case "atomic":
+		if nChildren == 1 {
+			subant := subants[0]
+			tree = syntaxbaum.SyntaxBaum{}
+			tree.Expr = subant.getTextContentLeaves()
+			tree.Kind = subant.getLabel()
+			tree.Children = [](*syntaxbaum.SyntaxBaum){}
+			tree.Valence = 0
+			return tree, nil
+		}
+	case "not":
+		if nChildren == 2 { // Children: [NotSymbol, Teilformel]
+			subtree, err := subants[1].toSyntaxBaum()
+			tree = syntaxbaum.SyntaxBaum{}
+			tree.Expr = subants[0].getTextContent() + " " + subtree.Expr
+			tree.Kind = label
+			tree.Children = [](*syntaxbaum.SyntaxBaum){&subtree}
+			tree.Valence = 1
+			return tree, err
+		}
+	case "and2", "and", "or2", "or", "implies":
+		var n int = int((len(subants) + 1) / 2)
+		if nChildren == 2*n-1 && n >= 2 {
+			var isSymb bool = false
+			var subtrees = make([](*syntaxbaum.SyntaxBaum), n)
+			var i int = 0
+			var expr string = ""
+			for _, subant := range subants {
+				if isSymb {
+					expr += " " + subant.getTextContent() + " "
+				} else {
+					subtree, err_ := subant.toSyntaxBaum()
+					if err_ != nil {
+						err = err_
+					}
+					subtrees[i] = &subtree
+					expr += " " + subtree.Expr + " "
+					i++
+				}
+				isSymb = !isSymb
+			}
+			expr = strings.Trim(expr, " ")
+			var lbrace string = "("
+			var rbrace string = ")"
+			// var lbrace string = "( "
+			// var rbrace string = " )"
+			// if strings.HasPrefix(expr, "(") {
+			// 	lbrace = "("
+			// }
+			// if strings.HasSuffix(expr, ")") {
+			// 	rbrace = ")"
+			// }
+			tree = syntaxbaum.SyntaxBaum{}
+			tree.Expr = lbrace + expr + rbrace
+			tree.Kind = label
+			tree.Children = subtrees
+			tree.Valence = n
+			return tree, err
+		}
+	}
+
+	return tree, errors.New("Could not parse expression")
+}

codego/aussagenlogik/schema/schema_test.go

@@ -0,0 +1,22 @@
+package schema_test
+
+/* ---------------------------------------------------------------- *
+ * UNIT TESTING
+ * ---------------------------------------------------------------- */
+
+import (
+	"logik/aussagenlogik/schema"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE ParseExpr
+ * ---------------------------------------------------------------- */
+
+func TestParseExpr(test *testing.T) {
+	var assert = assert.New(test)
+	assert.Equal(0, 0)
+	schema.ParseExpr("A0")
+}