public virtual Expression VisitQuantifier(Quantifier quantifier)
{
if (quantifier == null) return null;
quantifier.Comprehension = (Comprehension)this.VisitComprehension(quantifier.Comprehension);
return quantifier;
}
public override Expression VisitQuantifier(Quantifier quantifier) {
if (quantifier == null) return null;
if (quantifier.Comprehension == null) return quantifier;
ExpressionList bindfilter = quantifier.Comprehension.BindingsAndFilters;
for (int i = 0; i < bindfilter.Count; i++) {
ComprehensionBinding binding = bindfilter[i] as ComprehensionBinding;
if (binding == null) // it's a filter
this.VisitExpression(bindfilter[i]);
else { // it's a binding
Expression sourceEnum = binding.SourceEnumerable;
if (sourceEnum == null) continue;
if (sourceEnum.Type == SystemTypes.Range)
this.VisitExpression(sourceEnum);
else {
QuantifierBinding = true;
this.VisitExpression(sourceEnum);
QuantifierBinding = false;
}
}
}
ExpressionList elems = quantifier.Comprehension.Elements;
for (int i = 0; i < elems.Count; i++)
this.VisitExpression(elems[i]);
return quantifier;
}
private Expression ParseUnaryExpression(TokenSet followers){
if (this.currentToken == Token.EndOfFile) {
if (this.returnedEmptyIdentForEOF)
return null;
else {
this.returnedEmptyIdentForEOF = true;
return this.scanner.GetIdentifier();
}
}
Expression expression;
switch(this.currentToken){
case Token.Plus:
case Token.BitwiseNot:
case Token.LogicalNot:
case Token.Subtract:
case Token.BitwiseAnd:
UnaryExpression uexpr = new UnaryExpression();
uexpr.SourceContext = this.scanner.CurrentSourceContext;
uexpr.NodeType = Parser.ConvertToUnaryNodeType(this.currentToken);
this.GetNextToken();
uexpr.Operand = this.ParseUnaryExpression(followers);
if (uexpr.Operand == null) return null;
uexpr.SourceContext.EndPos = uexpr.Operand.SourceContext.EndPos;
expression = uexpr;
break;
case Token.Multiply:
AddressDereference adref = new AddressDereference();
adref.SourceContext = this.scanner.CurrentSourceContext;
adref.ExplicitOperator = AddressDereference.ExplicitOp.Star;
this.GetNextToken();
adref.Address = this.ParseUnaryExpression(followers);
if (adref.Address == null) return null;
adref.SourceContext.EndPos = adref.Address.SourceContext.EndPos;
expression = adref;
break;
case Token.AddOne:
case Token.SubtractOne:
PrefixExpression prefixExpr = new PrefixExpression();
prefixExpr.SourceContext = this.scanner.CurrentSourceContext;
prefixExpr.Operator = Parser.ConvertToBinaryNodeType(this.currentToken);
this.GetNextToken();
prefixExpr.Expression = this.ParseUnaryExpression(followers);
if (prefixExpr.Expression == null) return null;
prefixExpr.SourceContext.EndPos = prefixExpr.Expression.SourceContext.EndPos;
expression = prefixExpr;
break;
case Token.LeftParenthesis:
expression = this.ParseCastExpression(followers);
break;
case Token.LeftBrace:
expression = this.ParseBlockExpression(ScannerState.Code, this.scanner.CurrentSourceContext, followers);
break;
case Token.Exists:
case Token.Forall:
case Token.Count:
case Token.Sum:
case Token.Max:
case Token.Min:
case Token.Product:
Quantifier q = new Quantifier();
q.SourceContext = this.scanner.CurrentSourceContext;
ScannerState ss = this.scanner.state;
Token quantType = this.currentToken;
SourceContext sctx = this.scanner.CurrentSourceContext;
this.GetNextToken();
if (this.currentToken == Token.Unique){
quantType = this.currentToken;
this.GetNextToken();
}
// not necessarily a quantifier unless there is an open curly!!
// REVIEW: Is that enough of a test? Or do we need to try parsing the comprehension?
if (this.currentToken != Token.LeftBrace) {
//Restore prior state and reparse as expression
this.scanner.endPos = q.SourceContext.StartPos;
this.scanner.state = ss;
this.currentToken = Token.None;
this.GetNextToken();
goto default;
}
q.QuantifierType = Parser.ConvertToQuantifierType(quantType);
this.Skip(Token.LeftBrace);
Comprehension c = this.ParseComprehension(followers, sctx);
if (c == null) {
return null;
}
q.Comprehension = c;
q.SourceContext.EndPos = c.SourceContext.EndPos;
expression = q;
break;
default:
expression = this.ParsePrimaryExpression(followers);
break;
}
return expression;
}
public override Expression VisitQuantifier(Quantifier quantifier)
{
if (quantifier == null) return null;
return base.VisitQuantifier((Quantifier)quantifier.Clone());
}
public EventingVisitor(Action<Quantifier> visitQuantifier) { VisitedQuantifier += visitQuantifier; } public event Action<Quantifier> VisitedQuantifier; public override Expression VisitQuantifier(Quantifier quantifier) { if (VisitedQuantifier != null) VisitedQuantifier(quantifier); return base.VisitQuantifier(quantifier); }
