/// <summary>
/// Initializes a new instance of the <see cref="AssumptionCondition" /> class.
/// </summary>
/// <param name="form">Form of condition parts conjunction</param>
/// <param name="parts">Condition parts</param>
internal AssumptionCondition(ConditionForm form, params Expression[] parts)
{
_initialParts = parts;
Parts = from part in parts select Expressions.Converter.GetPostfix(part);
Form = form;
}
/// <summary>
/// Initializes a new instance of the <see cref="AssumptionExecuter" /> class.
///
/// Note that astElement can be n-ary expression with n > 1.
/// However, it cannot be logical expression (and, or, xor). Logical expressions are eliminated
/// in the stage of control-flow graph generation.
/// </summary>
/// <param name="conditionForm">The condition form. See <see cref="ConditionForm"/> for more details.</param>
/// <param name="astElement">The AST element corresponding to the condition.</param>
/// <param name="log">The log of evaluation the astElement and its sub-expressions.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
public AssumptionExecuter(ConditionForm conditionForm, LangElement astElement, EvaluationLog log, FlowOutputSet flowOutputSet)
{
this.flowOutputSet = flowOutputSet;
this.astElement = astElement;
this.conditionForm = conditionForm;
this.log = log;
}
private void barButtonItem11_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
//添加雨量字段并赋值 测试
ConditionForm condtion = new ConditionForm();
condtion.Show();
//addRains();
//roadRaskCaculate.RoadRaskCaulte(@"w001001.adf", 20, @"..\..\Rources\RoadData\RoadRasterData");
}
// 插入指令：条件语句
private void button5_Click(object sender, EventArgs e)
{
// 检查这个节点可否插入
if (this.isAbleInsert() == false)
{
return;
}
this.moveCursorToPoint(this, new Point(this.Size.Width / 2, this.Size.Height / 2), Cursor.Position, 0, 0);
ConditionForm cf = new ConditionForm();
cf.ShowDialog(this);
}
public EffectFormBuilder SetConditionForm(ConditionDefinition condition, ConditionForm.ConditionOperation operation, bool applyToSelf, bool forceOnSelf, List <ConditionDefinition> detrimentalConditions)
{
effectForm.FormType = EffectForm.EffectFormType.Condition;
ConditionForm conditionForm = new ConditionForm
{
Operation = operation,
ConditionDefinition = condition
};
conditionForm.SetConditionDefinitionName(condition.Name);
conditionForm.SetApplyToSelf(applyToSelf);
conditionForm.SetForceOnSelf(forceOnSelf);
conditionForm.SetField("detrimentalConditions", detrimentalConditions);
effectForm.ConditionForm = conditionForm;
return(this);
}
/// <summary>
/// Assumes the condition according to the possible results of the condition. The state of the inner block will be set up.
/// </summary>
/// <param name="conditionForm">The condition form. See <see cref="ConditionForm"/> for more details.</param>
/// <param name="memoryContext">The memory context of the code block and it's variables.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
/// <exception cref="System.NotSupportedException"></exception>
public void AssumeCondition(ConditionForm conditionForm, MemoryContext memoryContext, FlowOutputSet flowOutputSet)
{
var variables = GetVariables();
if (variables.Count() == 0)
{
//There is nothing to assume because there is no variable used in the expression.
return;
}
if (ConditionResult == PossibleValues.OnlyTrue)
{
AssumeTrue(conditionPart, memoryContext, flowOutputSet);
}
else if (ConditionResult == PossibleValues.OnlyFalse)
{
AssumeFalse(conditionPart, memoryContext, flowOutputSet);
}
else if (ConditionResult == PossibleValues.Unknown)
{
if (conditionForm == ConditionForm.All)
{
AssumeTrue(conditionPart, memoryContext, flowOutputSet);
}
else if (conditionForm == ConditionForm.None)
{
AssumeFalse(conditionPart, memoryContext, flowOutputSet);
}
else
{
//run both assumptions and merge results
MemoryContext memoryContextTrue = new MemoryContext(log, flowOutputSet);
AssumeTrue(conditionPart, memoryContextTrue, flowOutputSet);
AssumeFalse(conditionPart, memoryContext, flowOutputSet);
memoryContext.UnionMerge(memoryContextTrue);
}
}
else
{
throw new NotSupportedException(string.Format("Condition result \"{0}\" is not supported.", ConditionResult));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParts" /> class.
/// </summary>
/// <param name="conditionForm">The condition form.</param>
/// <param name="flowOutputSet">Output set where condition will be assumed.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="conditionParts">The elements of the condition.</param>
public ConditionParts(ConditionForm conditionForm, FlowOutputSet flowOutputSet, EvaluationLog log, IEnumerable <ConditionPart> conditionParts)
{
this.flowOutputSet = flowOutputSet;
this.conditionParts.AddRange(conditionParts);
this.log = log;
this.conditionForm = conditionForm;
if (this.conditionParts.Count == 1)
{
if (conditionForm == ConditionForm.Some || conditionForm == ConditionForm.ExactlyOne)
{
this.conditionForm = ConditionForm.All;
}
else if (conditionForm == ConditionForm.SomeNot || conditionForm == ConditionForm.NotExactlyOne)
{
this.conditionForm = ConditionForm.None;
}
}
}
/// <summary>
/// Gets the condition result.
/// </summary>
/// <returns>see <see cref="PossibleValues"/> for details of possible result.</returns>
private PossibleValues GetConditionResult(ConditionForm conditionForm, FlowOutputSet flowOutputSet, MemoryEntry evaluatedPart)
{
var converter = new BooleanConverter(flowOutputSet.Snapshot);
var value = converter.EvaluateToBoolean(evaluatedPart);
if (value == null)
{
return(PossibleValues.Unknown);
}
var flipResult = (conditionForm == ConditionForm.None) ? true : false;
if (value.Value ^ flipResult)
{
return(PossibleValues.OnlyTrue);
}
else
{
return(PossibleValues.OnlyFalse);
}
}
/// <summary>
/// Makes the assumption in case of <c>false</c> as a condition result.
/// </summary>
/// <param name="langElement">The language element to assume.</param>
/// <param name="memoryContext">The memory context of the code block and it's variables.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
void AssumeFalse(LangElement langElement, MemoryContext memoryContext, FlowOutputSet flowOutputSet)
{
if (langElement is BinaryEx)
{
BinaryEx binaryExpression = (BinaryEx)langElement;
if (binaryExpression.PublicOperation == Operations.Equal)
{
AssumeNotEquals(binaryExpression.LeftExpr, binaryExpression.RightExpr, memoryContext);
}
else if (binaryExpression.PublicOperation == Operations.NotEqual)
{
AssumeEquals(binaryExpression.LeftExpr, binaryExpression.RightExpr, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.GreaterThan)
{
AssumeLesserThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, true, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.GreaterThanOrEqual)
{
AssumeLesserThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, false, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.LessThan)
{
AssumeGreaterThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, true, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.LessThanOrEqual)
{
AssumeGreaterThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, false, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.And ||
binaryExpression.PublicOperation == Operations.Or ||
binaryExpression.PublicOperation == Operations.Xor)
{
ConditionForm conditionForm = ConditionForm.SomeNot; // !(a AND b) --> !a OR !b
if (binaryExpression.PublicOperation == Operations.Or)
{
conditionForm = ConditionForm.None; // !(a OR b) --> !a AND !b
}
else if (binaryExpression.PublicOperation == Operations.Xor)
{
conditionForm = ConditionForm.NotExactlyOne; //!(a XOR b) --> !((a OR b) AND !(a AND b)) --> (!a AND !b) OR (a AND b)
}
MemoryContext currentMemoryContext = new MemoryContext(log, flowOutputSet);
ConditionParts condition = new ConditionParts(conditionForm, flowOutputSet, log, binaryExpression.LeftExpr, binaryExpression.RightExpr);
condition.MakeAssumption(currentMemoryContext);
memoryContext.UnionMerge(currentMemoryContext);
}
}
else if (langElement is UnaryEx)
{
UnaryEx unaryExpression = (UnaryEx)langElement;
if (unaryExpression.PublicOperation == Operations.LogicNegation)
{
AssumeTrue(unaryExpression.Expr, memoryContext, flowOutputSet);
}
}
else if (langElement is DirectVarUse)
{
DirectVarUse directVarUse = (DirectVarUse)langElement;
AssumeFalseDirectVarUse(directVarUse, memoryContext, flowOutputSet.Snapshot);
}
else if (langElement is IssetEx)
{
IssetEx issetEx = (IssetEx)langElement;
AssumeIsset(issetEx, memoryContext, flowOutputSet.Snapshot, false);
}
}
/// <summary>
/// Makes the assumption in case of <c>true</c> as a condition result.
/// </summary>
/// <param name="langElement">The language element to assume.</param>
/// <param name="memoryContext">The memory context of the code block and it's variables.</param>
/// <param name="flowOutputSet">The Output set of a program point.</param>
void AssumeTrue(LangElement langElement, MemoryContext memoryContext, FlowOutputSet flowOutputSet)
{
if (langElement is BinaryEx)
{
BinaryEx binaryExpression = (BinaryEx)langElement;
if (binaryExpression.PublicOperation == Operations.Equal)
{
AssumeEquals(binaryExpression.LeftExpr, binaryExpression.RightExpr, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.NotEqual)
{
AssumeNotEquals(binaryExpression.LeftExpr, binaryExpression.RightExpr, memoryContext);
}
else if (binaryExpression.PublicOperation == Operations.GreaterThan)
{
AssumeGreaterThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, false, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.GreaterThanOrEqual)
{
AssumeGreaterThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, true, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.LessThan)
{
AssumeLesserThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, false, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.LessThanOrEqual)
{
AssumeLesserThan(binaryExpression.LeftExpr, binaryExpression.RightExpr, true, memoryContext, flowOutputSet.Snapshot);
}
else if (binaryExpression.PublicOperation == Operations.And ||
binaryExpression.PublicOperation == Operations.Or ||
binaryExpression.PublicOperation == Operations.Xor)
{
ConditionForm conditionForm = ConditionForm.All;
if (binaryExpression.PublicOperation == Operations.Or)
{
conditionForm = ConditionForm.Some;
}
else if (binaryExpression.PublicOperation == Operations.Xor)
{
conditionForm = ConditionForm.ExactlyOne;
}
MemoryContext currentMemoryContext = new MemoryContext(log, flowOutputSet);
ConditionParts condition = new Weverca.Analysis.FlowResolver.Deprecated.ConditionParts(conditionForm, flowOutputSet, log, binaryExpression.LeftExpr, binaryExpression.RightExpr);
condition.MakeAssumption(currentMemoryContext);
memoryContext.UnionMerge(currentMemoryContext);
}
}
else if (langElement is UnaryEx)
{
UnaryEx unaryExpression = (UnaryEx)langElement;
if (unaryExpression.PublicOperation == Operations.LogicNegation)
{
AssumeFalse(unaryExpression.Expr, memoryContext, flowOutputSet);
}
}
else if (langElement is DirectVarUse)
{
DirectVarUse directVarUse = (DirectVarUse)langElement;
AssumeTrueDirectVarUse(directVarUse, memoryContext, flowOutputSet.Snapshot);
}
else if (langElement is IssetEx)
{
IssetEx issetEx = (IssetEx)langElement;
AssumeIsset(issetEx, memoryContext, flowOutputSet.Snapshot, true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParts" /> class.
/// </summary>
/// <param name="conditionForm">The condition form.</param>
/// <param name="flowOutputSet">Output set where condition will be assumed.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="conditionParts">The elements of the condition.</param>
public ConditionParts(ConditionForm conditionForm, FlowOutputSet flowOutputSet, EvaluationLog log, IEnumerable <Postfix> conditionParts)
: this(conditionForm, flowOutputSet, log, conditionParts.Select(a => a.SourceElement).ToArray())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ConditionParts" /> class.
/// </summary>
/// <param name="conditionForm">The condition form.</param>
/// <param name="flowOutputSet">Output set where condition will be assumed.</param>
/// <param name="log">The log of evaluation of the conditions' parts.</param>
/// <param name="langElements">The elements of the condition.</param>
public ConditionParts(ConditionForm conditionForm, FlowOutputSet flowOutputSet, EvaluationLog log, params LangElement[] langElements)
: this(conditionForm, flowOutputSet, log, langElements.Select(a => new ConditionPart(a, log, flowOutputSet)))
{
}
