137 lines
2.9 KiB
Go
137 lines
2.9 KiB
Go
package syntaxbaum
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
type SyntaxBaum struct {
|
|
Kind string
|
|
Expr string
|
|
Valence int
|
|
Children [](*SyntaxBaum)
|
|
}
|
|
|
|
/* ---------------------------------------------------------------- *
|
|
* METHODS
|
|
* ---------------------------------------------------------------- */
|
|
|
|
func (tree SyntaxBaum) GetChildren() []SyntaxBaum {
|
|
var n int = tree.Valence
|
|
var children = make([]SyntaxBaum, n)
|
|
for i, subtreePtr := range tree.Children {
|
|
children[i] = *subtreePtr
|
|
}
|
|
return children
|
|
}
|
|
|
|
func (tree SyntaxBaum) GetChild(indexOpt ...int) (SyntaxBaum, error) {
|
|
var index int = 0
|
|
if len(indexOpt) > 0 {
|
|
index = indexOpt[0]
|
|
}
|
|
var subtree SyntaxBaum
|
|
var err error
|
|
if 0 <= index && index < tree.Valence {
|
|
subtree = *(tree.Children[index])
|
|
} else {
|
|
err = errors.New(fmt.Sprintf("Instance has no child of index %d !", index))
|
|
}
|
|
return subtree, err
|
|
}
|
|
|
|
func (tree SyntaxBaum) Pretty(preindentOpt ...string) string {
|
|
var preindent string = ""
|
|
if len(preindentOpt) > 0 {
|
|
preindent = preindentOpt[0]
|
|
}
|
|
return tree.pretty(preindent, " ", "", 0)
|
|
}
|
|
|
|
func (tree SyntaxBaum) pretty(preindent string, tab string, prepend string, depth int) string {
|
|
var indent string = preindent + strings.Repeat(tab, depth)
|
|
switch tree.Valence {
|
|
case 0:
|
|
switch kind := tree.Kind; kind {
|
|
case "atom", "generic":
|
|
return indent + prepend + kind + " " + tree.Expr
|
|
default:
|
|
return indent + prepend + kind
|
|
}
|
|
default:
|
|
var lines string = indent + prepend + tree.Kind
|
|
prepend = "|__ "
|
|
for _, subtree := range tree.Children {
|
|
lines += "\n" + subtree.pretty(preindent, tab, prepend, depth+1)
|
|
}
|
|
return lines
|
|
}
|
|
}
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// METHODS: Recognitong of Formula-Types
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
func (tree SyntaxBaum) isAtom() bool {
|
|
return tree.Kind == "atom"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isLiteral() bool {
|
|
if tree.isAtom() {
|
|
return true
|
|
} else if tree.isNegation() {
|
|
subtree, err := tree.GetChild()
|
|
if err == nil {
|
|
return subtree.isAtom()
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (tree SyntaxBaum) isBeliebig() bool {
|
|
return tree.Kind == "generic"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isTrueSymbol() bool {
|
|
return tree.Kind == "taut"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isFalseSymbol() bool {
|
|
return tree.Kind == "contradiction"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isNegation() bool {
|
|
return tree.Kind == "not"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isConjunction() bool {
|
|
return tree.Kind == "and2"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isLongConjunction() bool {
|
|
switch tree.Kind {
|
|
case "and", "and2":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (tree SyntaxBaum) isDisjunction() bool {
|
|
return tree.Kind == "or2"
|
|
}
|
|
|
|
func (tree SyntaxBaum) isLongDisjunction() bool {
|
|
switch tree.Kind {
|
|
case "or", "or2":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func (tree SyntaxBaum) isImplication() bool {
|
|
return tree.Kind == "implies"
|
|
}
|