master > master: codego Aufräumung von SyntaxBaum Methoden

codego/aussagenlogik/schema/schema.go

@@ -1,7 +1,6 @@
 package schema
 
 import (
-	"errors"
 	"logik/aussagenlogik/syntaxbaum"
 	parser "logik/grammars/aussagenlogik"
 	"strings"
@@ -13,13 +12,13 @@ import (
  * EXPORTS
  * ---------------------------------------------------------------- */
 
-func ParseExpr(u string) (syntaxbaum.SyntaxBaum, error) {
+func ParseExpr(u string) syntaxbaum.SyntaxBaum {
 	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
+	tree := createSyntaxBaum(t, prs)
+	return tree
 }
 
 /* ---------------------------------------------------------------- *
@@ -39,7 +38,7 @@ func createLexer(u string) antlr.Lexer {
 	return parser.NewaussagenlogikLexer(stream)
 }
 
-func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) (syntaxbaum.SyntaxBaum, error) {
+func createSyntaxBaum(tree antlr.Tree, parser antlr.Parser) syntaxbaum.SyntaxBaum {
 	var ant = antlrTree{tree: tree, parser: &parser}
 	return ant.toSyntaxBaum()
 }
@@ -87,9 +86,8 @@ func (ant antlrTree) getTextContentLeaves() string {
 	return expr
 }
 
-func (ant antlrTree) toSyntaxBaum() (syntaxbaum.SyntaxBaum, error) {
+func (ant antlrTree) toSyntaxBaum() syntaxbaum.SyntaxBaum {
 	var tree syntaxbaum.SyntaxBaum
-	var err error
 	var label string = ant.getLabel()
 	var subants = ant.getChildren()
 	var nChildren = len(subants)
@@ -114,21 +112,20 @@ func (ant antlrTree) toSyntaxBaum() (syntaxbaum.SyntaxBaum, error) {
 		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
+			tree.SetKind(subant.getLabel())
+			tree.SetExpr(subant.getTextContentLeaves())
+			tree.SetChildren([](*syntaxbaum.SyntaxBaum){})
+			return tree
 		}
 	case "not":
-		if nChildren == 2 { // Children: [NotSymbol, Teilformel]
-			subtree, err := subants[1].toSyntaxBaum()
+		if nChildren == 2 {
+			// NOTE: Children = [NotSymbol, Teilformel]
+			subtree := 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
+			tree.SetKind(label)
+			tree.SetExpr(subants[0].getTextContent() + " " + subtree.GetExpr())
+			tree.SetChildren([](*syntaxbaum.SyntaxBaum){&subtree})
+			return tree
 		}
 	case "and2", "and", "or2", "or", "implies":
 		var n int = int((len(subants) + 1) / 2)
@@ -139,37 +136,26 @@ func (ant antlrTree) toSyntaxBaum() (syntaxbaum.SyntaxBaum, error) {
 			var expr string = ""
 			for _, subant := range subants {
 				if isSymb {
-					expr += " " + subant.getTextContent() + " "
+					expr += " " + subant.getTextContent()
 				} else {
-					subtree, err_ := subant.toSyntaxBaum()
-					if err_ != nil {
-						err = err_
-					}
+					subtree := subant.toSyntaxBaum()
 					subtrees[i] = &subtree
-					expr += " " + subtree.Expr + " "
+					expr += " " + subtree.GetExpr()
 					i++
 				}
+				// NOTE: infix notation: alternatives between expression and symbol
 				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
+			tree.SetKind(label)
+			tree.SetExpr(lbrace + expr + rbrace)
+			tree.SetChildren(subtrees)
+			return tree
 		}
 	}
 
-	return tree, errors.New("Could not parse expression")
+	panic("Could not parse expression")
 }