/// <summary>
/// Add the rule which defines the values of division variables. Remained rules will be added later in
/// BRulesStandardVar.assignLastCasesToDivisionVars
/// </summary>
/// <param name="childSmvInstance"></param>
/// <param name="variable"></param>
/// <param name="totalValue"></param>
private static void addRuleChildDivisionVariables(ChildInstance childSmvInstance, Variable variable, int totalValue)
{
CaseLine newCase = new CaseLine();
string childActivation = childSmvInstance.Name + "." + childSmvInstance.DivisionStatus.Name;
Expression left = new Expression();
left.Exp = childActivation;
Expression right = new Expression(StatusStates.NONEXIST);
BoolExp condition1 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
//next(child.status)=ACTIVE
left = new Expression();
left.Exp = SMVKeys.NEXT + "(" + childActivation + ")";
right = new Expression(StatusStates.ACTIVE);
BoolExp condition2 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
CompoundBoolExpression compound = new CompoundBoolExpression(condition1, NuSMV.BinaryOperator.AND, condition2);
newCase.Rule.Condition = compound;
Expression result = new Expression();
result.Exp = totalValue.ToString();
newCase.Result = result;
variable.Next.CaseStatement.CaseLines.Insert(0, newCase);
}
private static ICondition extractGuardConditionFromKpGuard(IGuard guard)
{
ICondition condition = null;
if (guard is BasicGuard)
{
BasicGuard basicGuard = (BasicGuard)guard;
condition = getBoolExpression(basicGuard);
}
else if (guard is NegatedGuard)
{
NegatedGuard negatedGuard = (NegatedGuard)guard;
Console.Error.WriteLine("KP NegatedGuard to SMV translation has not been implemented yet!");
}
else if (guard is CompoundGuard)
{
CompoundGuard compoundGuard = (CompoundGuard)guard;
CompoundBoolExpression compoundBoolExpr = new CompoundBoolExpression();
compoundBoolExpr.LeftCondition = extractGuardConditionFromKpGuard(compoundGuard.Lhs);
compoundBoolExpr.BinaryOperator = SMVUtil.getBinaryOperator(compoundGuard.Operator);
compoundBoolExpr.RightCondition = extractGuardConditionFromKpGuard(compoundGuard.Rhs);
condition = compoundBoolExpr;
}
return(condition);
}
/// <summary>
/// Extract condition from KP Rule, add condition to the next of variable. Rule behaviour are writing rules.
/// </summary>
/// <param name="variable"></param>
/// <param name="kpRule"></param>
/// <param name="module"></param>
/// <param name="strategyIndex"></param>
internal static void addCaseLineToStandardVariable(Variable variable, KpCore.Rule kpRule, Module module, int strategyIndex)
{
//for each variable generate a case line
CaseLine caseLine = new CaseLine();
caseLine.Result = getResultOfRuleFromKPRule(module, kpRule, variable);
caseLine.Rule = extractStandardRuleFromKPRule(kpRule, module, strategyIndex);
caseLine.Rule.ID = kpRule.Id;
//if result is division or dissolution it will be null
if (caseLine.Result != null)
{
caseLine.Rule.AddBoolExpression(getBoundCondition(variable, caseLine.Result), BinaryOperator.AND);
}
else
{
throw new Exception("BRulesStandarVar, line 176");
// caseLine.Result = new Expression(variable.Name);
}
ICondition statusCondition = getTurnCondition(module, strategyIndex);
ICondition sequenceCondition = getSequenceCondition(module, strategyIndex, kpRule.Id);
CompoundBoolExpression statusAndTurn = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequenceCondition);
caseLine.Rule.AddBoolExpression(statusAndTurn, BinaryOperator.AND);
if (variable.Next != null)
{
if (!BRulesComVar.ruleExist(variable.Next, caseLine))
{
variable.Next.addCaseLine(caseLine);
}
}
}
private static void addStatusToChildInstance(ParentInstance parentInstance, ChildInstance childSmvInstance)
{
//copy status variable and add custom activation case.
Variable status = module.Status;
Variable childStatus = new Variable(status.Name);
childStatus.Behaviour = VariableBehaviour.DIVISION;
childStatus.Type = status.Type;
foreach (var caseLine in status.Next.CaseStatement.CaseLines)
{
childStatus.Next.CaseStatement.CaseLines.Add(caseLine);
}
// add custom case (parent._status = willDivide) & (next( parent._status) = DIVIDED)
CaseLine newCase = new CaseLine();
string parentStatus = parentInstance.Name + "." + status.Name;
Expression left = new Expression();
left.Exp = parentStatus;
Expression right = new Expression(StatusStates.WILLDIVIDE);//I changed here for willDivide
BoolExp condition1 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
left = new Expression();
left.Exp = SMVKeys.NEXT + "( " + parentStatus + ")";
right = new Expression(StatusStates.DIVIDED);
BoolExp condition2 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
CompoundBoolExpression compound = new CompoundBoolExpression(condition1, NuSMV.BinaryOperator.AND, condition2);
Expression result = new Expression(StatusStates.ACTIVE);
newCase.Rule.Condition = compound;
newCase.Result = result;
//insert at the beginning
childStatus.Next.CaseStatement.CaseLines.Insert(0, newCase);
childSmvInstance.DivisionStatus = childStatus;
}
/// <summary> Insert the caseline at the beginning of child status' next, If parent divides then child will activate
/// case (parent._status = willDivide) & (next( parent._status) = DIVIDED) : _ACTIVE; </summary> <param
/// name="childSMVInstance"></param>
private static void updateChildModuleStatus(ChildInstance childSMVInstance)
{
//copy status variable and add custom activation case.
Variable status = module.Status;
status.Behaviour = VariableBehaviour.DIVISION;
// add custom case (parent._status = willDivide) & (next( parent._status) = DIVIDED)
CaseLine newCase = new CaseLine();
string parentStatus = childSMVInstance.ParentInstance.Name + "." + status.Name;
Expression left = new Expression();
left.Exp = parentStatus;
Expression right = new Expression(StatusStates.WILLDIVIDE);
BoolExp condition1 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
left = new Expression();
left.Exp = SMVKeys.NEXT + "( " + parentStatus + ")";
right = new Expression(StatusStates.DIVIDED);
BoolExp condition2 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
CompoundBoolExpression compound = new CompoundBoolExpression(condition1, BinaryOperator.AND, condition2);
Expression result = new Expression(StatusStates.ACTIVE);
newCase.Rule.Condition = compound;
newCase.Result = result;
//insert at the beginning
status.Next.CaseStatement.CaseLines.Insert(0, newCase);
childSMVInstance.DivisionStatus = status;
}
private static ICondition extractConditionFromKpGuard(Module sourceModule, IGuard guard)
{
ICondition condition = null;
if (guard is BasicGuard)
{
BasicGuard basicGuard = (BasicGuard)guard;
condition = getBoolExpression(sourceModule, basicGuard);
}
else if (guard is NegatedGuard)
{
NegatedGuard negatedGuard = (NegatedGuard)guard;
Console.Error.WriteLine("NegatedGuard is not applicable.");
// ICondition negatedBooleanExpression = getNegatedGuard(negatedGuard);
}
else if (guard is CompoundGuard)
{
CompoundGuard compoundGuard = (CompoundGuard)guard;
CompoundBoolExpression compoundBoolExpr = null;
compoundBoolExpr.LeftCondition = extractConditionFromKpGuard(sourceModule, compoundGuard.Lhs);
compoundBoolExpr.BinaryOperator = SMVUtil.getBinaryOperator(compoundGuard.Operator);
compoundBoolExpr.RightCondition = extractConditionFromKpGuard(sourceModule, compoundGuard.Rhs);
condition = compoundBoolExpr;
}
return(condition);
}
internal static void addCaseLineToCurrentCopyCommVar(Variable orjVariable, Variable copyCommVar, KpCore.Rule rule, Module module, Module targetModule, int strategyIndex)
{
//for each variable generate a case line
CaseLine caseLine = new CaseLine();
OperExp result = new OperExp();
int resultValue = 0;
RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule;
foreach (var target in rcr.TargetRhs.Values)
{
TargetedMultiset targetMultiSet = (TargetedMultiset)target;
InstanceIdentifier targetType = (InstanceIdentifier)targetMultiSet.Target;
if (targetModule.Type == targetType.Value)
{
Multiset ms = targetMultiSet.Multiset;
foreach (var obj in ms.Objects)
{
if (obj.Equals(orjVariable.Name))
{
resultValue += ms[obj];
}
}
}
}
result.Exp = copyCommVar.Name;
if (resultValue != 0)
{
result.Oper.Value = MathOper.ADD;
result.Result = new Expression(resultValue.ToString());
}
caseLine.Result = result;
caseLine.Rule = BRulesStandardVar.extractStandardRuleFromKPRule(rule, module, strategyIndex);
ICondition sequenceCondition = BRulesStandardVar.getSequenceCondition(module, strategyIndex, rule.Id);
ICondition targetBounds = getBoundCondition(copyCommVar, caseLine.Result);
CompoundBoolExpression sequenceAndBound = new CompoundBoolExpression(sequenceCondition, BinaryOperator.AND, targetBounds);
ICondition statusCondition = BRulesStandardVar.getTurnCondition(module, strategyIndex);
CompoundBoolExpression statusAndSequence = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, sequenceAndBound);
// _conn = to_c2
if (module.connectionToModuleExist(targetModule))
{
BoolExp connEqInstance = new BoolExp(module.getConnectionToModule(targetModule).Name, NuSMV.RelationalOperator.EQUAL, SMVPreFix.getConnectedTo(targetModule.Instance));
caseLine.Rule.AddBoolExpression(connEqInstance, BinaryOperator.AND);
}
caseLine.Rule.AddBoolExpression(statusAndSequence, BinaryOperator.AND);
caseLine.Rule.ID = rule.Id;
if (copyCommVar.Next != null)
{
//if the case line has not added yet
if (!ruleExist(copyCommVar.Next, caseLine))
{
copyCommVar.Next.addCaseLine(caseLine);
}
}
}
/// <summary> Combines status and turn conditions </summary> <param name="module">NuSMV module</param> <param
/// name="turnState">TurnStates.SEQUENCE + strategyIndex</param> <returns>(_status = _ACTIVE) & (_turn =
/// _SEQUENCE1)</returns>
public static CompoundBoolExpression getStatusAndTurnCondition(Module module, string turnState)
{
ICondition statusCondition = getStatusCondition(module, StatusStates.ACTIVE);
//turn = sequence1
ICondition turnIsSequence = getTurnCondition(turnState);
CompoundBoolExpression statusAndTurn = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, turnIsSequence);
return(statusAndTurn);
}
/// <summary> (((_status = _willDISSOLVE) | (_status = _willDIVIDE)) & (_sync = _EXCH)) </summary> <param
/// name="module"></param> <returns></returns>
private static ICondition getWillDissolveOrWillDivideAndSync(Module module)
{
ICondition statusWillDissolveOrWillDivide = getStatusWillDissolveOrWillDivide(module);
BoolExp synchIsExch = new BoolExp();
synchIsExch.Left = new Expression(CustomVariables.SYNCH);
synchIsExch.RelationalOperator.Operator = NuSMV.RelationalOperator.EQUAL;
synchIsExch.Right = new Expression(SynchStates.EXCHANGE);
CompoundBoolExpression willDisDivAndSync = new CompoundBoolExpression(statusWillDissolveOrWillDivide, BinaryOperator.AND, synchIsExch);
return(willDisDivAndSync);
}
public static ICondition getStatusAndTurnCondition(Module module, int strategyIndex)
{
Strategy ex = module.ExecutionStrategies.ElementAt(strategyIndex);
string turnState = ex.Name;
ICondition statusCondition = getStatusCondition(module);
//turn = sequence1
BoolExp turnEQState = new BoolExp();
turnEQState.Left = new Expression(CustomVariables.TURN);
turnEQState.RelationalOperator.Operator = NuSMV.RelationalOperator.EQUAL;
turnEQState.Right = new Expression(turnState + strategyIndex);
CompoundBoolExpression statusAndTurn = new CompoundBoolExpression(statusCondition, BinaryOperator.AND, turnEQState);
return(statusAndTurn);
}
/// <summary> Combines status and turn conditions </summary> <param name="module">NuSMV module</param> <param
/// name="turnState">TurnStates.SEQUENCE + strategyIndex</param> <returns>((_status = _ACTIVE) | (_status =
/// _willDISSOLVE))) & (next(_turn) = _SEQUENCE1)</returns>
public static ICondition getStatusAndNextTurnCondition(Module module, string turnState)
{
ICondition result = null;
//next(turn) = sequence1
result = getNextTurnCondition(turnState);
if (module.HasDissolutionRule || module.HasDivisionRule)
{
ICondition statusActive = getStatusCondition(module);
ICondition statusWillDissolveOrWillDivide = getStatusWillDissolveOrWillDivide(module);
statusActive = new CompoundBoolExpression(statusActive, BinaryOperator.OR, statusWillDissolveOrWillDivide);
result = new CompoundBoolExpression(statusActive, BinaryOperator.AND, result);
}
return(result);
}
/// <summary> (((_status = _ACTIVE) | ((_status = _willDISSOLVE) | (_status = _willDIVIDE))) & (_sync = _EXCH)) : 0;
/// </summary> <param name="module">NuSMV module</param> <param name="synchState">synchState = _EXCH</param>
/// <returns>((_status = _ACTIVE | status = willDissolve) & (_synch = _EXCH))</returns>
public static CompoundBoolExpression getStatusAndSynchCondition(Module module, string synchState)
{
ICondition status = null;
if (module.HasDissolutionRule | module.HasDivisionRule)
{
status = getStatusCondition(module);
}
BoolExp synchIsExch = new BoolExp();
synchIsExch.Left = new Expression(CustomVariables.SYNCH);
synchIsExch.RelationalOperator.Operator = NuSMV.RelationalOperator.EQUAL;
synchIsExch.Right = new Expression(synchState);
CompoundBoolExpression statusAndTurn = new CompoundBoolExpression(status, BinaryOperator.AND, synchIsExch);
return(statusAndTurn);
}
/// <summary> ((_status = _NONEXIST) & (next(_status) = _ACTIVE))) </summary> <param name="module"></param>
/// <returns></returns>
internal static CompoundBoolExpression getStatusNonExistNEXTActive(Module module)
{
CompoundBoolExpression statusNonExistNEXTActive = null;
if (module.HasDivisionRule)
{
ICondition statusNONEXIST = BRulesStandardVar.getStatusCondition(module, StatusStates.NONEXIST);
//next(child.status)=ACTIVE
Expression left = new Expression();
left.Exp = SMVKeys.NEXT + "(" + module.Status.Name + ")";
Expression right = new Expression(StatusStates.ACTIVE);
BoolExp nextStatusACTIVE = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
statusNonExistNEXTActive = new CompoundBoolExpression(statusNONEXIST, NuSMV.BinaryOperator.AND, nextStatusACTIVE);
}
return(statusNonExistNEXTActive);
}
/// <summary>
/// ((_status = _DISSOLVED) | (_status = _DIVIDED))
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
private static ICondition getDissolvedOrDivided(Module module)
{
CaseLine caseLine = new CaseLine();
ICondition dissolved = null;
ICondition divided = null;
ICondition dissolvedOrDivided = null;
if (module.HasDissolutionRule)
{
dissolved = getStatusCondition(module, StatusStates.DISSOLVED);
}
if (module.HasDivisionRule)
{
divided = getStatusCondition(module, StatusStates.DIVIDED);
}
dissolvedOrDivided = new CompoundBoolExpression(dissolved, BinaryOperator.OR, divided);
return(dissolvedOrDivided);
}
private static CaseLine assignStatusAndSyncToACommVariable(Module module, Variable variable)
{
CaseLine commCaseLine = new CaseLine();
OperExp result = new OperExp();
result.Exp = new InstancedExp(module.Instance.Name, variable.Name).ToString();
result.Oper.Value = MathOper.ADD;
//if it has copy var, then add var + var_cp
string res = "";
if (module.isVariableExist(SMVPreFix.getCopyName(variable)))
{
res += new InstancedExp(module.Instance.Name, SMVPreFix.getCopyName(variable));
}
foreach (var connectedInstance in module.Instance.ConnectedTo)
{
if (connectedInstance.Module.isVariableExist(SMVPreFix.getConnectedCopyCommVarName(variable, module)))
{
if (!string.IsNullOrWhiteSpace(res))
{
res += " + ";
}
res += new InstancedExp(connectedInstance.Name, SMVPreFix.getConnectedCopyCommVarName(variable, module));
}
}
result.Result = new Expression(res);
//(c1.status = _ACTIVE)
CompoundBoolExpression statusAndSync = getInstancedStatusAndSyncCondition(module);
ICondition boundCondition = getBoundCondition(variable, result);
ICondition compound = new CompoundBoolExpression(statusAndSync, BinaryOperator.AND, boundCondition);
CommunicationRule rule = new CommunicationRule();
rule.Condition = compound;
//commCaseLine.Rule.Condition = compound;
commCaseLine.Rule = rule;
commCaseLine.Result = result;
return(commCaseLine);
}
/// <summary>
/// ((_status = _willDISSOLVE | (_status = _willDIVIDE))
/// </summary>
/// <param name="module"></param>
/// <returns></returns>
public static ICondition getStatusWillDissolveOrWillDivide(Module module)
{
ICondition statusWillDissolveOrWillDivide = null;
if (module.HasDissolutionRule || module.HasDivisionRule)
{
ICondition statusWillDissolve = null;
ICondition statusWillDivide = null;
if (module.HasDissolutionRule)
{
statusWillDissolve = getStatusCondition(module, StatusStates.WILLDISSOLVE);
}
if (module.HasDivisionRule)
{
statusWillDivide = getStatusCondition(module, StatusStates.WILLDIVIDE);
}
statusWillDissolveOrWillDivide = new CompoundBoolExpression(statusWillDissolve, BinaryOperator.OR, statusWillDivide);
}
return(statusWillDissolveOrWillDivide);
}
private static CompoundBoolExpression getInstancedStatusAndSyncCondition(Module module)
{
ICondition status = null;
if (module.HasDissolutionRule || module.HasDivisionRule)
{
status = BRulesComVar.getInstancedStatus(module, StatusStates.ACTIVE);
}
// this is non-instanced _sync = _EXCH
BoolExp synchIsExch = new BoolExp();
synchIsExch.Left = new Expression(CustomVariables.SYNCH);
synchIsExch.RelationalOperator.Operator = NuSMV.RelationalOperator.EQUAL;
synchIsExch.Right = new Expression(SynchStates.EXCHANGE);
//(_sync = _EXCH)
CompoundBoolExpression statusAndSync = new CompoundBoolExpression(status, BinaryOperator.AND, synchIsExch);
return(statusAndSync);
}
/// <summary> Returns condition for lower and upper bound of a variable, to be added in rules. eg. ((step +
/// 1)>=0)&((step + 1)<=9) </summary> <param name="sequence">variable</param> <param name="result">result of a rule
/// e.g.(step + 1)</param> <returns>((step + 1)>=0)&((step + 1)<=9)</returns>
internal static ICondition getBoundCondition(Variable variable, IExp result)
{
//ex. ((step + 1)>=0)
BoolExp lowerCondition = new BoolExp();
lowerCondition.Left = result;
lowerCondition.RelationalOperator.Operator = NuSMV.RelationalOperator.GEQ;
lowerCondition.Right = new Expression(((variable.Type) as BoundInt).LowerBound.ToString());
//ex. ((step + 1)<=9)
BoolExp upperCondition = new BoolExp();
upperCondition.Left = result;
upperCondition.RelationalOperator.Operator = NuSMV.RelationalOperator.LEQ;
upperCondition.Right = new Expression(((variable.Type) as BoundInt).UpperBound.ToString());
CompoundBoolExpression boundCondition = new CompoundBoolExpression();
boundCondition.LeftCondition = lowerCondition;
boundCondition.BinaryOperator.Operator = BinaryOperator.AND;
boundCondition.RightCondition = upperCondition;
return(boundCondition);
}
/// <summary>
/// Add the rule which defines the values of division variables. Remained rules will be added later in
/// BRulesStandardVar.assignLastCasesToDivisionVars
/// </summary>
/// <param name="childSmvInstance"></param>
/// <param name="variable"></param>
/// <param name="totalValue"></param>
private static void addRuleChildDivisionVariables(ChildInstance childSmvInstance, Variable variable, int totalValue)
{
CaseLine newCase = new CaseLine();
string childActivation = childSmvInstance.Name + "." + childSmvInstance.DivisionStatus.Name;
Expression left = new Expression();
left.Exp = childActivation;
Expression right = new Expression(StatusStates.NONEXIST);
BoolExp condition1 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
//next(child.status)=ACTIVE
left = new Expression();
left.Exp = SMVKeys.NEXT + "(" + childActivation + ")";
right = new Expression(StatusStates.ACTIVE);
BoolExp condition2 = new BoolExp(left, NuSMV.RelationalOperator.EQUAL, right);
CompoundBoolExpression compound = new CompoundBoolExpression(condition1, NuSMV.BinaryOperator.AND, condition2);
newCase.Rule.Condition = compound;
Expression result = new Expression();
//inherit the parent's remained multiset objects
//result.Exp = SMVKeys.NEXT + "(" + childSmvInstance.ParentInstance.Name + "." + variable.Name + ") + " + totalValue.ToString();
//newCase.Rule.AppendBoolExpression(BRulesStandardVar.getBoundCondition(variable, result), BinaryOperator.AND);
result.Exp = totalValue.ToString();
newCase.Result = result;
variable.Next.CaseStatement.CaseLines.Insert(0, newCase);
////((((_status = _willDISSOLVE) | (_status = _willDIVIDE))) & (_sync = _EXCH)) : 0;
//CaseLine caseLine2 = new CaseLine();
//ICondition willDissolve = null;
//ICondition willDivide = null;
//ICondition willDissolveOrDivide = null;
//if (module.HasDissolutionRule)
//{
// willDissolve = BRulesComVar.getInstancedStatus(module, StatusStates.WILLDISSOLVE);
//}
//if (module.HasDivisionRule)
//{
// willDivide = BRulesComVar.getInstancedStatus(module, StatusStates.WILLDIVIDE);
//}
//willDissolveOrDivide = new CompoundBoolExpression(willDissolve, BinaryOperator.OR, willDivide);
//// this is non-instanced _sync = _EXCH
//BoolExp synchIsExch = new BoolExp();
//synchIsExch.Left = new Expression(CustomVariables.SYNCH);
//synchIsExch.RelationalOperator.Operator = NuSMV.RelationalOperator.EQUAL;
//synchIsExch.Right = new Expression(SynchStates.EXCHANGE);
//CompoundBoolExpression statusAndSync = new CompoundBoolExpression(willDissolveOrDivide, BinaryOperator.AND, synchIsExch);
//caseLine2.Rule.Condition = statusAndSync;
//caseLine2.Result = new Expression("0");
//variable.Next.CaseStatement.CaseLines.Insert(1, caseLine2);
////((_status = _DISSOLVED) | (_status = _DIVIDED)) : 0;
//CaseLine caseLine3 = new CaseLine();
//ICondition dissolved = null;
//ICondition divided = null;
//ICondition dissolvedOrDivided= null;
//if (module.HasDissolutionRule)
//{
// dissolved = BRulesComVar.getInstancedStatus(module, StatusStates.DISSOLVED);
//}
//if (module.HasDivisionRule)
//{
// divided = BRulesComVar.getInstancedStatus(module, StatusStates.DIVIDED);
//}
//dissolvedOrDivided = new CompoundBoolExpression(dissolved, BinaryOperator.OR, divided);
//caseLine3.Rule.Condition = dissolvedOrDivided;
//caseLine3.Result = new Expression("0");
//variable.Next.CaseStatement.CaseLines.Insert(2, caseLine3);
}
public static ICondition insertInstanceName(ICondition left, Instance instance)
{
// ICondition condition = null;
if (left is BoolExp)
{
BoolExp condition = new BoolExp();
BoolExp boolExp = (BoolExp)left;
if (boolExp.Left.Exp.Contains(SMVKeys.SELF))
{
if (boolExp.Left is OperExp)
{
OperExp tempOper = new OperExp();
tempOper.Exp = (boolExp.Left as OperExp).Exp;
tempOper.Oper.Value = (boolExp.Left as OperExp).Oper.Value;
tempOper.Result = (boolExp.Left as OperExp).Result;
condition.Left = new Expression();
condition.Left.Exp = tempOper.ToString().Replace(SMVKeys.SELF, instance.Name);
}
else
{
condition.Left = new Expression();
condition.Left.Exp = condition.ToString().Replace(SMVKeys.SELF, instance.Name);
}
condition.RelationalOperator = boolExp.RelationalOperator;
condition.Right = new Expression();
condition.Right.Exp = boolExp.Right.Exp;
}
else if (!boolExp.Left.Exp.Contains(instance.Name))
{
// if it is a shared variable (such as main's synch variable), then don't call with compartment name
if (boolExp.Left.Exp == CustomVariables.SYNCH)
{
// actually do nothing.
condition.Left = new Expression();
condition.Left.Exp = boolExp.Left.Exp;
}
else if (boolExp.Left is OperExp)
{
condition.Left = new Expression();
condition.Left.Exp = insertInstanceName2Expression(boolExp.Left, instance);
}
else
{
condition.Left = new Expression();
condition.Left.Exp = instance.Name + "." + boolExp.Left.Exp;
}
condition.RelationalOperator = boolExp.RelationalOperator;
condition.Right = new Expression();
condition.Right.Exp = boolExp.Right.Exp;
}
else
{
condition = boolExp;
}
return(condition);
}
else if (left is BoolVariable)
{
BoolVariable boolGuard = (BoolVariable)left;
BoolVariable condition = new BoolVariable();
if (boolGuard.BoolGuard.Exp == SMVKeys.SELF)
{
(condition as BoolVariable).BoolGuard.Exp = boolGuard.BoolGuard.Exp.Replace(SMVKeys.SELF, instance.Name);
}
else
{
(condition as BoolVariable).BoolGuard.Exp = instance.Name + "." + boolGuard.BoolGuard.Exp;
}
return(condition);;
}
else if (left is NegatedBoolExpression)
{
NegatedBoolExpression negated = (NegatedBoolExpression)left;
NegatedBoolExpression condition = new NegatedBoolExpression();
BoolExp boolExp = (BoolExp)negated.BoolExpression;
if (boolExp.Left.Exp == SMVKeys.SELF)
{
((condition as NegatedBoolExpression).BoolExpression as BoolExp).Left.Exp = boolExp.Left.Exp.Replace(SMVKeys.SELF, instance.Name);
}
else
{
((condition as NegatedBoolExpression).BoolExpression as BoolExp).Left.Exp = instance.Name + "." + boolExp.Left.Exp;
}
return(condition);
}
else if (left is TruthValue)
{
return(left);
}
else
{
if (left != null)
{
CompoundBoolExpression comp = (CompoundBoolExpression)left;
CompoundBoolExpression compoundBoolExpr = new CompoundBoolExpression();
compoundBoolExpr.LeftCondition = insertInstanceName(comp.LeftCondition, instance);
compoundBoolExpr.BinaryOperator = comp.BinaryOperator;
compoundBoolExpr.RightCondition = insertInstanceName(comp.RightCondition, instance);
// condition = compoundBoolExpr;
return(compoundBoolExpr);
}
else
{
return(null);
}
}
}
