raj_mathe/logik2021
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

master > master: codego Aufräumung von SyntaxBaum Methoden

Browse Source
This commit is contained in:
RD 2021-05-12 18:45:18 +02:00
parent 100701d610
commit 5e89d57dad
2 changed files with 70 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
codego/aussagenlogik/schema/schema.go
View File

@ -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")
}

70
codego/aussagenlogik/syntaxbaum/syntaxbaum.go
View File

@ -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"
}