master > master: codego - auslagern, erzeugungsmethode verbessert, SyntaxBaum -> Formula

codego/aussagenlogik/schema/schema.go

@@ -1,9 +1,8 @@
 package schema
 
 import (
-	"logik/aussagenlogik/syntaxbaum"
+	"logik/aussagenlogik/formulae"
 	parser "logik/grammars/aussagenlogik"
-	"strings"
 
 	"github.com/antlr/antlr4/runtime/Go/antlr"
 )
@@ -12,12 +11,12 @@ import (
  * EXPORTS
  * ---------------------------------------------------------------- */
 
-func ParseExpr(u string) syntaxbaum.SyntaxBaum {
+func ParseExpr(u string) formulae.Formula {
 	var lexer = createLexer(u)
 	var tokenStream = lexerToTokenStream(lexer)
 	var prs = parser.NewaussagenlogikParser(tokenStream)
 	var t = prs.Start()
-	tree := createSyntaxBaum(t, prs)
+	tree := createFormula(t, prs)
 	return tree
 }
 
@@ -38,9 +37,9 @@ func createLexer(u string) antlr.Lexer {
 	return parser.NewaussagenlogikLexer(stream)
 }
 
-func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) syntaxbaum.SyntaxBaum {
+func createFormula(tree antlr.Tree, parser antlr.Parser) formulae.Formula {
 	var ant = antlrTree{tree: tree, parser: &parser}
-	return ant.toSyntaxBaum()
+	return ant.toFormula()
 }
 
 /* ---------------------------------------------------------------- *
@@ -86,8 +85,7 @@ func (ant antlrTree) getTextContentLeaves() string {
 	return expr
 }
 
-func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
-	var tree syntaxbaum.SyntaxBaum
+func (ant antlrTree) toFormula() formulae.Formula {
 	var label string = ant.getLabel()
 	var subants = ant.getChildren()
 	var nChildren = len(subants)
@@ -95,65 +93,73 @@ func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
 	switch label {
 	case "start":
 		if nChildren == 1 {
-			return subants[0].toSyntaxBaum()
+			return subants[0].toFormula()
 		}
 	case "open":
 		if nChildren == 1 {
-			return subants[0].toSyntaxBaum()
+			return subants[0].toFormula()
 		}
 	case "closed":
 		switch nChildren {
 		case 1:
-			return subants[0].toSyntaxBaum()
+			return subants[0].toFormula()
+		// expr = ( expr )
 		case 3:
-			return subants[1].toSyntaxBaum()
+			return subants[1].toFormula()
 		}
 	case "atomic":
 		if nChildren == 1 {
-			subant := subants[0]
-			tree = syntaxbaum.SyntaxBaum{}
-			tree.SetKind(subant.getLabel())
-			tree.SetExpr(subant.getTextContentLeaves())
-			tree.SetChildren([](*syntaxbaum.SyntaxBaum){})
-			return tree
+			return subants[0].toFormula()
 		}
+	case "taut":
+		return formulae.Tautology
+	case "contradiction":
+		return formulae.Contradiction
+	case "atom":
+		return formulae.Atom(ant.getTextContentLeaves())
+	case "generic":
+		return formulae.Generic(ant.getTextContentLeaves())
 	case "not":
+		// NOTE: expr = ! expr
 		if nChildren == 2 {
-			// NOTE: Children = [NotSymbol, Teilformel]
-			subtree := subants[1].toSyntaxBaum()
-			tree = syntaxbaum.SyntaxBaum{}
-			tree.SetKind(label)
-			tree.SetExpr(subants[0].getTextContent() + " " + subtree.GetExpr())
-			tree.SetChildren([](*syntaxbaum.SyntaxBaum){&subtree})
-			return tree
+			return formulae.Negation(subants[1].toFormula())
 		}
-	case "and2", "and", "or2", "or", "implies":
+	case "and2":
+		// NOTE: expr = expr && expr
+		if nChildren == 3 {
+			return formulae.Conjunction2(subants[0].toFormula(), subants[2].toFormula())
+		}
+	case "or2":
+		// NOTE: expr = expr || expr
+		if nChildren == 3 {
+			return formulae.Disjunction2(subants[0].toFormula(), subants[2].toFormula())
+		}
+	case "implies":
+		// NOTE: expr = expr -> expr
+		if nChildren == 3 {
+			return formulae.Implies(subants[0].toFormula(), subants[2].toFormula())
+		}
+	case "and", "or":
+		// NOTE: expr = expr op expr op ... op expr
 		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 subtrees = make([]formulae.Formula, n)
+			var isSymb bool = true
 			var i int = 0
-			var expr string = ""
 			for _, subant := range subants {
 				if isSymb {
-					expr += " " + subant.getTextContent()
-				} else {
-					subtree := subant.toSyntaxBaum()
-					subtrees[i] = &subtree
-					expr += " " + subtree.GetExpr()
+					subtrees[i] = subant.toFormula()
 					i++
 				}
 				// NOTE: infix notation: alternatives between expression and symbol
 				isSymb = !isSymb
 			}
-			expr = strings.Trim(expr, " ")
-			var lbrace string = "("
-			var rbrace string = ")"
-			tree = syntaxbaum.SyntaxBaum{}
-			tree.SetKind(label)
-			tree.SetExpr(lbrace + expr + rbrace)
-			tree.SetChildren(subtrees)
-			return tree
+			switch label {
+			case "and":
+				return formulae.Conjunction(subtrees)
+			case "or":
+				return formulae.Disjunction(subtrees)
+			}
 		}
 	}