From 5e89d57dad0197c5b270b09bd912aafc62fed042 Mon Sep 17 00:00:00 2001 From: raj_mathe Date: Wed, 12 May 2021 18:45:18 +0200 Subject: [PATCH] =?UTF-8?q?master=20>=20master:=20codego=20Aufr=C3=A4umung?= =?UTF-8?q?=20von=20SyntaxBaum=20Methoden?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- codego/aussagenlogik/schema/schema.go | 64 +++++++---------- codego/aussagenlogik/syntaxbaum/syntaxbaum.go | 70 ++++++++++++------- 2 files changed, 70 insertions(+), 64 deletions(-) diff --git a/codego/aussagenlogik/schema/schema.go b/codego/aussagenlogik/schema/schema.go index 5fa3e5d..cadf525 100644 --- a/codego/aussagenlogik/schema/schema.go +++ b/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") } diff --git a/codego/aussagenlogik/syntaxbaum/syntaxbaum.go b/codego/aussagenlogik/syntaxbaum/syntaxbaum.go index 038ead2..9aa7478 100644 --- a/codego/aussagenlogik/syntaxbaum/syntaxbaum.go +++ b/codego/aussagenlogik/syntaxbaum/syntaxbaum.go @@ -7,20 +7,40 @@ import ( ) type SyntaxBaum struct { - Kind string - Expr string - Valence int - Children [](*SyntaxBaum) + kind string + expr string + valence int + 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 { - subtree = *(tree.Children[index]) + if 0 <= index && index < tree.valence { + 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" }