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)
+	tree := createSyntaxBaum(t, prs)
-	return tree, err
+	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.SetKind(subant.getLabel())
-			tree.Kind = subant.getLabel()
+			tree.SetExpr(subant.getTextContentLeaves())
-			tree.Children = [](*syntaxbaum.SyntaxBaum){}
+			tree.SetChildren([](*syntaxbaum.SyntaxBaum){})
-			tree.Valence = 0
+			return tree
-			return tree, nil
 		}
 	case "not":
-		if nChildren == 2 { // Children: [NotSymbol, Teilformel]
+		if nChildren == 2 {
-			subtree, err := subants[1].toSyntaxBaum()
+			// NOTE: Children = [NotSymbol, Teilformel]
+			subtree := subants[1].toSyntaxBaum()
 			tree = syntaxbaum.SyntaxBaum{}
-			tree.Expr = subants[0].getTextContent() + " " + subtree.Expr
+			tree.SetKind(label)
-			tree.Kind = label
+			tree.SetExpr(subants[0].getTextContent() + " " + subtree.GetExpr())
-			tree.Children = [](*syntaxbaum.SyntaxBaum){&subtree}
+			tree.SetChildren([](*syntaxbaum.SyntaxBaum){&subtree})
-			tree.Valence = 1
+			return tree
-			return tree, err
 		}
 	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()
+					subtree := subant.toSyntaxBaum()
-					if err_ != nil {
-						err = err_
-					}
 					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.SetKind(label)
-			tree.Kind = label
+			tree.SetExpr(lbrace + expr + rbrace)
-			tree.Children = subtrees
+			tree.SetChildren(subtrees)
-			tree.Valence = n
+			return tree
-			return tree, err
 		}
 	}
 
-	return tree, errors.New("Could not parse expression")
+	panic("Could not parse expression")
 }

codego/aussagenlogik/syntaxbaum/syntaxbaum.go

@@ -7,20 +7,40 @@ import (
 )
 
 type SyntaxBaum struct {
-	Kind     string
+	kind     string
-	Expr     string
+	expr     string
-	Valence  int
+	valence  int
-	Children [](*SyntaxBaum)
+	children [](*SyntaxBaum)
 }
 
 /* ---------------------------------------------------------------- *
  * METHODS
  * ---------------------------------------------------------------- */
+func (tree *SyntaxBaum) SetKind(kind string) {
+	tree.kind = kind
+}
+
+func (tree SyntaxBaum) GetKind() string {
+	return tree.kind
+}
+
+func (tree *SyntaxBaum) SetExpr(expr string) {
+	tree.expr = expr
+}
+
+func (tree SyntaxBaum) GetExpr() string {
+	return tree.expr
+}
+
+func (tree *SyntaxBaum) SetChildren(children [](*SyntaxBaum)) {
+	tree.children = children
+	tree.valence = len(children)
+}
 
 func (tree SyntaxBaum) GetChildren() []SyntaxBaum {
-	var n int = tree.Valence
+	var n int = tree.valence
 	var children = make([]SyntaxBaum, n)
-	for i, subtreePtr := range tree.Children {
+	for i, subtreePtr := range tree.children {
 		children[i] = *subtreePtr
 	}
 	return children
@@ -33,8 +53,8 @@ func (tree SyntaxBaum) GetChild(indexOpt ...int) (SyntaxBaum, error) {
 	}
 	var subtree SyntaxBaum
 	var err error
-	if 0 <= index && index < tree.Valence {
+	if 0 <= index && index < tree.valence {
-		subtree = *(tree.Children[index])
+		subtree = *(tree.children[index])
 	} else {
 		err = errors.New(fmt.Sprintf("Instance has no child of index %d !", index))
 	}
@@ -51,18 +71,18 @@ func (tree SyntaxBaum) Pretty(preindentOpt ...string) string {
 
 func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, depth int) string {
 	var indent string = preindent + strings.Repeat(tab, depth)
-	switch tree.Valence {
+	switch tree.valence {
 	case 0:
-		switch kind := tree.Kind; kind {
+		switch kind := tree.kind; kind {
 		case "atom", "generic":
-			return indent + prepend + kind + " " + tree.Expr
+			return indent + prepend + kind + " " + tree.expr
 		default:
 			return indent + prepend + kind
 		}
 	default:
-		var lines string = indent + prepend + tree.Kind
+		var lines string = indent + prepend + tree.kind
 		prepend = "|__ "
-		for _, subtree := range tree.Children {
+		for _, subtree := range tree.children {
 			lines += "\n" + subtree.pretty(preindent, tab, prepend, depth+1)
 		}
 		return lines
@@ -74,11 +94,11 @@ func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, dept
 // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 func (tree SyntaxBaum) IsIrreducible() bool {
-	return tree.Valence == 0
+	return tree.valence == 0
 }
 
 func (tree SyntaxBaum) IsAtom() bool {
-	return tree.Kind == "atom"
+	return tree.kind == "atom"
 }
 
 func (tree SyntaxBaum) IsLiteral() bool {
@@ -94,41 +114,41 @@ func (tree SyntaxBaum) IsLiteral() bool {
 }
 
 func (tree SyntaxBaum) IsGeneric() bool {
-	return tree.Kind == "generic"
+	return tree.kind == "generic"
 }
 
 func (tree SyntaxBaum) IsTautologySymbol() bool {
-	return tree.Kind == "taut"
+	return tree.kind == "taut"
 }
 
 func (tree SyntaxBaum) IsContradictionSymbol() bool {
-	return tree.Kind == "contradiction"
+	return tree.kind == "contradiction"
 }
 
 func (tree SyntaxBaum) IsConnective() bool {
-	return tree.Valence > 0
+	return tree.valence > 0
 }
 
 func (tree SyntaxBaum) IsNegation() bool {
-	return tree.Kind == "not"
+	return tree.kind == "not"
 }
 
 func (tree SyntaxBaum) IsConjunction2() bool {
-	return tree.Kind == "and2"
+	return tree.kind == "and2"
 }
 
 func (tree SyntaxBaum) IsConjunction() bool {
-	return tree.Kind == "and" || tree.Kind == "and2"
+	return tree.kind == "and" || tree.kind == "and2"
 }
 
 func (tree SyntaxBaum) IsDisjunction2() bool {
-	return tree.Kind == "or2"
+	return tree.kind == "or2"
 }
 
 func (tree SyntaxBaum) IsDisjunction() bool {
-	return tree.Kind == "or" || tree.Kind == "or2"
+	return tree.kind == "or" || tree.kind == "or2"
 }
 
 func (tree SyntaxBaum) IsImplication() bool {
-	return tree.Kind == "implies"
+	return tree.kind == "implies"
 }