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); } }