// NotExpression := 'not' SS PrimaryExpression
private State DoParseNotExpression1Rule(State _state, List <Result> _outResults)
{
State _start = _state;
List <Result> results = new List <Result>();
_state = DoSequence(_state, results,
delegate(State s, List <Result> r) { return(DoParseLiteral(s, r, "not")); },
delegate(State s, List <Result> r) { return(DoParse(s, r, "SS")); },
delegate(State s, List <Result> r) { return(DoParse(s, r, "PrimaryExpression")); });
if (_state.Parsed)
{
Predicate value = results.Count > 0 ? results[0].Value : default(Predicate);
value = new NotPredicate(results[1].Value);
_outResults.Add(new Result(this, _start.Index, _state.Index - _start.Index, m_input, value));
}
else
{
string expected;
expected = "not expression";
if (expected != null)
{
_state = new State(_start.Index, false, ErrorSet.Combine(_start.Errors, new ErrorSet(_state.Errors.Index, expected)));
}
}
return(_state);
}
public string ConvertToString(TextPredicate predicate)
{
ContainsPhrase_Predicate contains = predicate as ContainsPhrase_Predicate;
if (contains != null)
{
return(this.ConvertToString(contains));
}
AndPredicate and = predicate as AndPredicate;
if (and != null)
{
return(this.ConvertToString(and));
}
OrPredicate or = predicate as OrPredicate;
if (or != null)
{
return(this.ConvertToString(or));
}
NotPredicate not = predicate as NotPredicate;
if (not != null)
{
return(this.ConvertToString(not));
}
throw new Exception("Unrecognized predicate: " + predicate);
}
private void NotButton_Clicked(object sender, EventArgs e)
{
NotPredicate not = new NotPredicate();
this.openPredicates.Add(not);
this.updateLayout();
}
public override void VisitLeave(NotPredicate expression)
{
IsMatchPredicate local = _matchStack.Pop();
_matchStack.Push(
delegate(IInputIterator iterator)
{
_disableCapturingGroup.Push(true);
_xmlDisableBackReferencePop.Push(true);
Boolean result = true;
Int32 savePosition = iterator.Index;
if (!local(iterator))
{
iterator.Index = savePosition;
result &= true;
}
else
{
iterator.Index = savePosition;
result &= false;
}
_xmlDisableBackReferencePop.Pop();
_disableCapturingGroup.Pop();
return(result);
}
);
}
public override void ExitNotPredicate(MiniSqlParserParser.NotPredicateContext context)
{
var operand = (Predicate)_stack.Pop();
var comments = this.GetComments(context.K_NOT());
var node = new NotPredicate(operand, comments);
_stack.Push(node);
}
public void NotPredicate_Constructor_SetsChildPredicate()
{
var expectedChildPredicate = new EqualsPredicate <TestPredicateFields>(new TestPredicateFields());
var predicate = new NotPredicate(expectedChildPredicate);
Assert.AreEqual(expectedChildPredicate, predicate.ChildPredicate);
}
public string ConvertToString(NotPredicate predicate)
{
StringBuilder content = new StringBuilder();
if (predicate.Child != null)
{
content.Append(this.ConvertToString(predicate.Child));
}
return(this.ConvertToString(content.ToString(), this.Not_Tag));
}
public void TestGrammar1NotLetterA()
{
TestGrammar1 grammar = TestGrammar1.Create();
Nonterminal nonterminal = grammar.GetNonterminal(o => o.NotLetterA());
Assert.AreEqual("NotLetterA", nonterminal.Name);
NotPredicate expression = (NotPredicate)nonterminal.Expression;
Assert.AreEqual("LetterA", ((Nonterminal)expression.Operand).Name);
}
public NotPredicate Read_NotPredicate(XmlNode nodeRepresentation)
{
NotPredicate predicate = new NotPredicate();
foreach (XmlNode childNode in nodeRepresentation.ChildNodes)
{
TextPredicate child = this.ReadTextPredicate(childNode);
predicate.Child = child;;
}
return(predicate);
}
public void NotPredicateTest3()
{
var expr = NotPredicate.Create(baseExpr, (index) => index + 1);
var parser = Parser.Create(expr);
{
Assert.IsFalse(parser.Parse("123", out _, out _, out _));
}
{
Assert.IsTrue(parser.Parse("abc", out var ret, out _, out var end));
Assert.AreEqual(ret, 1);
Assert.AreEqual(end, 0);
}
}
public void NotPredicateTest4()
{
var expr = NotPredicate.Create(baseExpr, (index) => index + 1, TestCustomException);
var parser = Parser.Create(expr);
{
Assert.IsFalse(parser.Parse("123", out _, out var exceptions, out _));
Assert.AreEqual(exceptions[0].Exception.Message, "error: 0");
}
{
Assert.IsTrue(parser.Parse("abc", out var ret, out _, out var end));
Assert.AreEqual(ret, 1);
Assert.AreEqual(end, 0);
}
}
// add the given predicate as a child of the leafmost existing predicate
private void addChild(TextPredicate predicate)
{
if (this.openPredicates.Count < 1)
{
// no predicates already exist, this one becomes the primary one
this.openPredicates.Add(predicate);
return;
}
TextPredicate last = this.openPredicates.Last();
OrPredicate or = last as OrPredicate;
if (or != null)
{
// we have a pending 'or'; add it here
or.AddChild(predicate);
return;
}
AndPredicate and = last as AndPredicate;
if (and != null)
{
// we have a pending 'and'; add it here
and.AddChild(predicate);
return;
}
NotPredicate not = last as NotPredicate;
if (not != null)
{
// we have a pending 'not'; add it here
not.Child = predicate;
return;
}
if (last == null)
{
// We have an empty spot to add this predicate to
// This user is expected to attach this to a parent later
// If the user doesn't attach this to a parent later, we will for them
this.openPredicates.RemoveAt(this.openPredicates.Count - 1);
this.openPredicates.Add(predicate);
return;
}
// error; do nothing
}
/// <summary>
/// Parser for Predicate
/// </summary>
/// <returns>Parsed Predicate</returns>
public Predicate ParsePredicate()
{
Predicate predicate = null; //Empty predicate
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "!")
{ //Not Predicate
NotPredicate notPredicate = new NotPredicate();
//Skip ! token
NextToken("!", "! predicate", '!');
//Parse predicate after !
notPredicate.SetPredicate(ParsePredicate());
predicate = notPredicate;
}
else
{ //Other predicates exists out of an expression
Expression expression = expressionParser.ParseExpression();
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == ".")
{ //IsPredicate
predicate = ParseIsPredicate(expression);
}
else
{ //ExpressionPredicate
predicate = ParseExpressionPredicate(expression);
}
}
//Check for && or || predicates
if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "&" && TokenStream.Peek(2).GetValue().ToString() == "&")
{ //AndPredicate
return(ParseAndPredicate(predicate));
}
else if (TokenStream.HasNext() && TokenStream.Peek(1).GetValue().ToString() == "|" && TokenStream.Peek(2).GetValue().ToString() == "|")
{ //OrPredicate
return(ParseOrPredicate(predicate));
}
return(predicate);
}
public override void VisitLeave(NotPredicate expression)
{
terminal.Peek().Append(")");
}
public virtual void Visit(NotPredicate expression, T context)
{
expression.Operand.Accept(this, context);
}
/// <summary>
/// Method which evaluates an predicate and returns true or false
/// </summary>
/// <param name="predicate">Predicate to evaluate</param>
/// <returns>True if predicate is true, otherwise false</returns>
private bool EvaluatePredicate(Predicate predicate)
{
if (predicate is IsPredicate)
{ //Evaluate Expression Predicate
IsPredicate isPredicate = (IsPredicate)predicate;
Expression expression = isPredicate.GetExpression();
//In case of VarExpression, get expression from symboltable
if (expression is VarExpression)
{
expression = GetReferenceExpression((VarExpression)expression);
if (expression == null)
{
return(false);
}
}
//If right type return true, otherwise false
if (isPredicate.GetType() is StringType)
{
return(expression is TextExpression);
}
else if (isPredicate.GetType() is ListType)
{
return(expression is ListExpression);
}
else if (isPredicate.GetType() is RecordType)
{
return(expression is RecordExpression);
}
else
{ //No match between types which could be checked, so false
return(false);
}
}
else if (predicate is ExpressionPredicate)
{ //Evaluate Expression Predicate
ExpressionPredicate expressionPredicate = (ExpressionPredicate)predicate;
Expression expression = expressionPredicate.GetExpression();
if (expression is FieldExpression)
{ //Check if specific field exists in record (not null)
Expression expr = GetExpression((FieldExpression)expression);
return(expr != null);
}
else if (expression is VarExpression)
{ //Check if specific variable is defined
VarExpression varExpr = (VarExpression)expression;
return(SymbolTable.ContainsVariable(varExpr.GetVariableIdentifier()));
}
else
{ //Other expressions are always true, because they doesn't refer to something
return(true);
}
}
else if (predicate is AndPredicate)
{ //Evaluate And Predicate
AndPredicate andPredicate = (AndPredicate)predicate;
return(EvaluatePredicate(andPredicate.GetLeftPredicate()) && EvaluatePredicate(andPredicate.GetLeftPredicate()));
}
else if (predicate is OrPredicate)
{ //Evaluate Or Predicate
OrPredicate orPredicate = (OrPredicate)predicate;
return(EvaluatePredicate(orPredicate.GetLeftPredicate()) || EvaluatePredicate(orPredicate.GetRightPredicate()));
}
else if (predicate is NotPredicate)
{ //Evaluate Not Predicate
NotPredicate notPredicate = (NotPredicate)predicate;
return(!EvaluatePredicate(notPredicate.GetPredicate()));
}
return(false);
}
public abstract void VisitLeave(NotPredicate expression);
/**
* Create a new Predicate that returns true if the specified predicate
* returns false and vice versa.
*
* @see org.apache.commons.collections.functors.NotPredicate
*
* @param predicate the predicate to not
* @return the <code>not</code> predicate
* @throws IllegalArgumentException if the predicate is null
*/
public static Predicate notPredicate(Predicate predicate)
{
return(NotPredicate.getInstance(predicate));
}
public abstract void VisitEnter(NotPredicate expression);
public abstract void VisitExecute(NotPredicate expression);
public override void VisitEnter(NotPredicate expression)
{
}
public IPredicate <T> Build()
{
var predicate = new NotPredicate <T>(_innerPredicate.Build());
return(predicate);
}
public void Visit(NotPredicate expression, Nonterminal context)
{
expression.Operand.Accept(this, context);
}
public override void Visit(NotPredicate expression, object context)
{
expressions.Add(expression);
base.Visit(expression, context);
}
public override void VisitEnter(NotPredicate expression)
{
terminal.Peek().Append("!(");
}
public override void VisitExecute(NotPredicate expression)
{
}
void IVisitor.VisitAfter(NotPredicate notPredicate)
{
this.ParentExists(notPredicate);
}
void IVisitor.VisitBefore(NotPredicate notPredicate)
{
this.ParentExists(notPredicate);
}
public virtual void Visit(NotPredicate predicate)
{
VisitSubNodes(predicate);
}
