public void Negate()
{
if (IsNegated)
{
return;
}
IsNegated = true;
if (Condition != null)
{
if (!(Condition is SurroundingParenthesesExpression) && IsStaticIfCondition)
{
Condition = new SurroundingParenthesesExpression
{
Expression = Condition,
Location = Condition.Location,
EndLocation = Condition.EndLocation
}
}
;
Condition = new UnaryExpression_Not
{
UnaryExpression = Condition,
Location = Condition.Location
};
}
}
public ISymbolValue Visit(UnaryExpression_Not x)
{
var v = x.UnaryExpression.Accept(this);
if(v is VariableValue)
v = EvaluateValue(v as VariableValue, ValueProvider);
var pv = v as PrimitiveValue;
if(pv == null){
EvalError(x.UnaryExpression, "Expression must be a primitive value",v);
return null;
}
return new PrimitiveValue(!IsFalseZeroOrNull(pv),x);
}
public ISymbolValue Visit(UnaryExpression_Not x)
{
var v = x.UnaryExpression.Accept(this);
if (v is VariableValue)
{
v = EvaluateValue(v as VariableValue, ValueProvider);
}
var pv = v as PrimitiveValue;
if (pv == null)
{
EvalError(x.UnaryExpression, "Expression must be a primitive value", v);
return(null);
}
return(new PrimitiveValue(!IsFalseZeroOrNull(pv), x));
}
ISemantic E(UnaryExpression_Not x)
{
var v = E(x.UnaryExpression);
if (eval)
{
if (v is VariableValue)
{
v = EvaluateValue(v as VariableValue, ValueProvider);
}
var pv = v as PrimitiveValue;
if (pv == null)
{
EvalError(x.UnaryExpression, "Expression must be a primitive value", v);
return(null);
}
return(new PrimitiveValue(!IsFalseZeroOrNull(pv), x));
}
return(v);
}
public void Visit(UnaryExpression_Not x)
{
}
public AbstractType Visit(UnaryExpression_Not x)
{
return(x.UnaryExpression.Accept(this));
}
ISemantic E(UnaryExpression_Not x)
{
var v = E(x.UnaryExpression);
if(eval)
{
if(v is VariableValue)
v = EvaluateValue(v as VariableValue, ValueProvider);
var pv = v as PrimitiveValue;
if(pv == null){
EvalError(x.UnaryExpression, "Expression must be a primitive value",v);
return null;
}
return new PrimitiveValue(!IsFalseZeroOrNull(pv),x);
}
return v;
}
public void Visit(UnaryExpression_Not x)
{
}
IExpression UnaryExpression(IBlockNode Scope = null)
{
switch (laKind)
{
// Note: PowExpressions are handled in PowExpression()
case BitwiseAnd:
case Increment:
case Decrement:
case Times:
case Minus:
case Plus:
case Not:
case Tilde:
Step();
SimpleUnaryExpression sue;
switch (t.Kind)
{
case BitwiseAnd:
sue = new UnaryExpression_And();
break;
case Increment:
sue = new UnaryExpression_Increment();
break;
case Decrement:
sue = new UnaryExpression_Decrement();
break;
case Times:
sue = new UnaryExpression_Mul();
break;
case Minus:
sue = new UnaryExpression_Sub();
break;
case Plus:
sue = new UnaryExpression_Add();
break;
case Tilde:
sue = new UnaryExpression_Cat();
break;
case Not:
sue = new UnaryExpression_Not();
break;
default:
SynErr(t.Kind, "Illegal token for unary expressions");
return null;
}
sue.Location = t.Location;
sue.UnaryExpression = UnaryExpression(Scope);
return sue;
// CastExpression
case Cast:
Step();
var ce = new CastExpression { Location= t.Location };
if (Expect(OpenParenthesis))
{
if (laKind != CloseParenthesis) // Yes, it is possible that a cast() can contain an empty type!
ce.Type = Type();
Expect(CloseParenthesis);
}
ce.UnaryExpression = UnaryExpression(Scope);
ce.EndLocation = t.EndLocation;
return ce;
// DeleteExpression
case Delete:
Step();
return new DeleteExpression() { UnaryExpression = UnaryExpression(Scope) };
// PowExpression
default:
var left = PostfixExpression(Scope);
if (laKind != Pow)
return left;
Step();
var pe = new PowExpression();
pe.LeftOperand = left;
pe.RightOperand = UnaryExpression(Scope);
return pe;
}
}
IExpression UnaryExpression(IBlockNode Scope = null)
{
// Note: PowExpressions are handled in PowExpression()
if (laKind == (BitwiseAnd) || laKind == (Increment) ||
laKind == (Decrement) || laKind == (Times) ||
laKind == (Minus) || laKind == (Plus) ||
laKind == (Not) || laKind == (Tilde))
{
Step();
SimpleUnaryExpression ae;
switch (t.Kind)
{
case BitwiseAnd:
ae = new UnaryExpression_And();
break;
case Increment:
ae = new UnaryExpression_Increment();
break;
case Decrement:
ae = new UnaryExpression_Decrement();
break;
case Times:
ae = new UnaryExpression_Mul();
break;
case Minus:
ae = new UnaryExpression_Sub();
break;
case Plus:
ae = new UnaryExpression_Add();
break;
case Tilde:
ae = new UnaryExpression_Cat();
break;
case Not:
ae = new UnaryExpression_Not();
break;
default:
SynErr(t.Kind, "Illegal token for unary expressions");
return null;
}
LastParsedObject = ae;
ae.Location = t.Location;
ae.UnaryExpression = UnaryExpression(Scope);
return ae;
}
// CastExpression
if (laKind == (Cast))
{
Step();
var ae = new CastExpression { Location= t.Location };
if (Expect(OpenParenthesis))
{
if (laKind != CloseParenthesis) // Yes, it is possible that a cast() can contain an empty type!
ae.Type = Type();
Expect(CloseParenthesis);
}
ae.UnaryExpression = UnaryExpression(Scope);
ae.EndLocation = t.EndLocation;
return ae;
}
// DeleteExpression
if (laKind == (Delete))
{
Step();
return new DeleteExpression() { UnaryExpression = UnaryExpression(Scope) };
}
// PowExpression
var left = PostfixExpression(Scope);
if (laKind != Pow)
return left;
Step();
var pe = new PowExpression();
pe.LeftOperand = left;
pe.RightOperand = UnaryExpression(Scope);
return pe;
}
IExpression UnaryExpression(IBlockNode Scope = null)
{
// Note: PowExpressions are handled in PowExpression()
if (laKind == (BitwiseAnd) || laKind == (Increment) ||
laKind == (Decrement) || laKind == (Times) ||
laKind == (Minus) || laKind == (Plus) ||
laKind == (Not) || laKind == (Tilde))
{
Step();
SimpleUnaryExpression ae = null;
switch (t.Kind)
{
case BitwiseAnd:
ae = new UnaryExpression_And();
break;
case Increment:
ae = new UnaryExpression_Increment();
break;
case Decrement:
ae = new UnaryExpression_Decrement();
break;
case Times:
ae = new UnaryExpression_Mul();
break;
case Minus:
ae = new UnaryExpression_Sub();
break;
case Plus:
ae = new UnaryExpression_Add();
break;
case Tilde:
ae = new UnaryExpression_Cat();
break;
case Not:
ae = new UnaryExpression_Not();
break;
}
LastParsedObject = ae;
ae.Location = t.Location;
ae.UnaryExpression = UnaryExpression(Scope);
return ae;
}
// ( Type ) . Identifier
if (laKind == OpenParenthesis)
{
var wkParsing = AllowWeakTypeParsing;
AllowWeakTypeParsing = true;
var curLA = la;
Step();
var td = Type();
AllowWeakTypeParsing = wkParsing;
if (td!=null && ((t.Kind!=OpenParenthesis && laKind == CloseParenthesis && Peek(1).Kind == Dot && Peek(2).Kind == Identifier) ||
(IsEOF || Peek(1).Kind==EOF || Peek(2).Kind==EOF))) // Also take it as a type declaration if there's nothing following (see Expression Resolving)
{
Step(); // Skip to )
Step(); // Skip to .
Step(); // Skip to identifier
var accExpr = new UnaryExpression_Type() { Type=td, AccessIdentifier=t.Value };
accExpr.Location = curLA.Location;
accExpr.EndLocation = t.EndLocation;
return accExpr;
}
else
{
// Reset the current token with the earlier one to enable Expression parsing
la = curLA;
Peek(1);
}
}
// CastExpression
if (laKind == (Cast))
{
Step();
var ae = new CastExpression { Location= t.Location };
if (Expect(OpenParenthesis))
{
if (laKind != CloseParenthesis) // Yes, it is possible that a cast() can contain an empty type!
ae.Type = Type();
Expect(CloseParenthesis);
}
ae.UnaryExpression = UnaryExpression(Scope);
ae.EndLocation = t.EndLocation;
return ae;
}
// NewExpression
if (laKind == (New))
return NewExpression(Scope);
// DeleteExpression
if (laKind == (Delete))
{
Step();
return new DeleteExpression() { UnaryExpression = UnaryExpression(Scope) };
}
// PowExpression
var left = PostfixExpression(Scope);
if (laKind != Pow)
return left;
Step();
var pe = new PowExpression();
pe.LeftOperand = left;
pe.RightOperand = UnaryExpression(Scope);
return pe;
}
public void Negate()
{
if(IsNegated)
return;
IsNegated=true;
if (Condition != null)
{
if (!(Condition is SurroundingParenthesesExpression) && IsStaticIfCondition)
Condition = new SurroundingParenthesesExpression
{
Expression = Condition,
Location = Condition.Location,
EndLocation = Condition.EndLocation
};
Condition = new UnaryExpression_Not
{
UnaryExpression = Condition,
Location = Condition.Location
};
}
}
ISemantic E(UnaryExpression_Not x)
{
return E(x.UnaryExpression);
}