private object EvaluateNode(DisjunctionNode expression, Context context)
{
var value = EvaluateNode(expression.lft, context);
if (expression.rgt == null || expression.rgt.Length == 0)
{
return(value);
}
foreach (var rgt in expression.rgt)
{
if (value != null)
{
return(value);
}
value = EvaluateNode(rgt, context);
}
return(value);
}
private void processTokenToExpression(LogicalExpressionNode current, Token token) {
if (LETokenType.Literal == token.Type) {
current.Children.Add(new LiteralNode {Literal = token.Value, Negative = token.Negation});
return;
}
if (LETokenType.Number == token.Type)
{
current.Children.Add(new LiteralNode { Literal = token.Value, IsNumber=true, Negative = token.Negation });
return;
}
if (LETokenType.And == token.Type || LETokenType.Block == token.Type) {
var conj = new ConjunctionNode {Negative = token.Negation};
current.Children.Add(conj);
foreach (var child in token.Children) {
processTokenToExpression(conj, child);
}
return;
}
if (LETokenType.Or == token.Type) {
var disj = new DisjunctionNode {Negative = token.Negation};
current.Children.Add(disj);
foreach (var child in token.Children) {
processTokenToExpression(disj, child);
}
return;
}
if (0!=(token.Type & LETokenType.Compare)) {
var fst = token.Children[0];
var sec = token.Children[1];
LogicalExpressionNode n;
if (token.Type == LETokenType.Regex) {
n = new RegexTestNode {
First = fst.Value,
Second = sec.Value,
FirstIsLiteral = fst.Type == LETokenType.Literal,
SecondIsLiteral = sec.Type == LETokenType.Literal
};
}else if (fst.Type == LETokenType.Number) {
var eq = new EqualValueNode();
n = eq;
eq.Literal = sec.Value;
eq.Value = fst.Value;
eq.IsNumber = true;
}
else if (sec.Type == LETokenType.Number) {
var eq = new EqualValueNode();
n = eq;
eq.Literal = fst.Value;
eq.Value = sec.Value;
eq.IsNumber = true;
}
else if (sec.Type == LETokenType.Literal) {
var eq = new EqualNode();
n = eq;
if (fst.Type == LETokenType.String) {
var eq2= new EqualValueNode();
eq2.Literal = sec.Value;
eq2.Value = fst.Value;
n = eq2;
}
else {
eq.FirstLiteral = fst.Value;
eq.SecondLiteral = sec.Value;
}
}
else {
var eq = new EqualValueNode();
n = eq;
eq.Literal = fst.Value;
eq.Value = sec.Value;
}
n.Negative = token.Negation;
n.Operation = token.Type;
if (token.Type != LETokenType.Neq && token.Type != LETokenType.Eq) {
n.IsNumber = true;
}
if (LETokenType.Neq == token.Type) {
n.Negative = !n.Negative;
}
current.Children.Add(n);
}
}
/// <summary>
/// A method that is called to actually build a tree from a given input. Is called from ProcessStringInput()
/// </summary>
/// <param name="input">input string</param>
/// <param name="root">Node used in recursion for creating a binary tree</param>
/// <exception cref="Exception"></exception>
private void BuildTree(string input, Node root)
{
if (input == string.Empty)
{
return;
}
char first_character = input[0];
if (first_character == '~')
{
NotNode node = new NotNode(input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (first_character == '>')
{
ImplicationNode node = new ImplicationNode(input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (first_character == '=')
{
BiImplicationNode node = new BiImplicationNode(input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (first_character == '&')
{
ConjunctionNode node = new ConjunctionNode(input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (first_character == '|')
{
DisjunctionNode node = new DisjunctionNode(input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (first_character == '%')
{
NandNode node = new NandNode(input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (Char.IsUpper(first_character) && input[1] == '(')
{
/* predicate case */
/* P(x), Q(x) */
int closingBracketIndex = GetIndexOfClosingBracket(input, 1);
var vars = QuantifierInputHandler.StringStartEndIndex(input, 2, closingBracketIndex - 1).Split(',');
PredicateNode predicate = new PredicateNode(first_character);
List <PropositionNode> propositions = new List <PropositionNode>();
foreach (var variable in vars)
{
propositions.Add(new PropositionNode(variable));
}
predicate.Formulas = propositions;
root.Insert(predicate);
predicate.parent = root;
input = input.Substring(closingBracketIndex + 1);
BuildTree(input, predicate);
}
else if (first_character == '@' || first_character == '!')
{
string quantifierInput = QuantifierInputHandler.ParseOutInputForQuantifiers(input);
QuantifierInputHandler quantifierInputHandler = new QuantifierInputHandler(quantifierInput);
var node = quantifierInputHandler.Create();
node.parent = root;
root.Insert(node);
var newInput = input.Substring(IndexTillWhichStringAreSame(quantifierInput, input) + 1);
BuildTree(newInput, node);
}
else if (first_character == ',')
{
if (root.parent == null)
{
throw new Exception("Error in your input");
}
root = root.parent;
input = input.Substring(1);
BuildTree(input, root);
}
else if (Char.IsLetter(first_character))
{
PropositionNode node = new PropositionNode(first_character.ToString(), input, root);
root.Insert(node);
BuildTree(node.Value, node);
}
else if (first_character == ')')
{
int numberOflevels = CalculateNumberOfLevelsToGoUp(input);
for (int i = 0; i < numberOflevels; i++)
{
if (root.parent != null)
{
root = root.parent;
}
else
{
throw new Exception("Error in string input. Source: class Processor, method BuildTree, else if (')')");
}
}
input = input.Substring(numberOflevels);
BuildTree(input, root);
}
else if (first_character == '(')
{
input = input.Substring(1);
BuildTree(input, root);
}
}
