private static void buildReWritingVariables(KPsystem kpSystem, KpCore.MType kpType, NuSMV.Module module, int strategyIndex, KpCore.Rule kpRule)
{
RewritingRule rwr = (RewritingRule)kpRule;
string varName = "";
VariableOrigin origin = VariableOrigin.Original;
bool isLeft = true;
foreach (var leftHRule in rwr.Lhs)
{
varName = leftHRule.Key;
origin = VariableOrigin.Original;
isLeft = true;
buildReWritingVariable(kpSystem, kpType, module, strategyIndex, kpRule, varName, origin, isLeft);
}
foreach (var rigthHRule in rwr.Rhs)
{
varName = rigthHRule.Key;
origin = VariableOrigin.Original;
isLeft = false;
//first generate original one, then its copy
if (!module.isVariableExist(varName))
{
buildReWritingVariable(kpSystem, kpType, module, strategyIndex, kpRule, varName, origin, isLeft);
}
string copyVarName = varName + SMVPreFix.COPY;
origin = VariableOrigin.Copy;
buildReWritingVariable(kpSystem, kpType, module, strategyIndex, kpRule, copyVarName, origin, isLeft);
}
}
public object VisitRuleRightHandSide(KpLinguaParser.RuleRightHandSideContext context)
{
var rule = default(ConsumerRule);
var ruleMultisetContexts = context.ruleMultiset();
var divisionContexts = context.division();
var dissolutionContext = context.dissolution();
var linkCreationContext = context.linkCreation();
var linkDestructionContext = context.linkDestruction();
if (ruleMultisetContexts != null)
{
var rewritingRule = default(RewritingRule);
if (ruleMultisetContexts.Any(rm => rm.targetedMultiset() != null))
{
var rewriteCommunicationRule = new RewriteCommunicationRule();
var targetedMultisets = ruleMultisetContexts.Where(rm => rm.targetedMultiset() != null).Select(rm => rm.targetedMultiset().Accept(this) as TargetedMultiset);
rewriteCommunicationRule.AddRhs(targetedMultisets.ToDictionary(tm => tm.Target));
rewritingRule = rewriteCommunicationRule;
}
else
{
rewritingRule = new RewritingRule();
}
var multisets = ruleMultisetContexts.Where(rm => rm.nonEmptyMultiset() != null).Select(rm => rm.nonEmptyMultiset().Accept(this) as Multiset);
foreach (var multiset in multisets)
{
rewritingRule.AddRhs(multiset);
}
rule = rewritingRule;
}
else if (divisionContexts != null)
{
var divisionRule = new DivisionRule();
foreach (var divisionContext in divisionContexts)
{
divisionRule.Rhs.Add(divisionContext.Accept(this) as InstanceBlueprint);
}
rule = divisionRule;
}
else if (dissolutionContext != null)
{
rule = dissolutionContext.Accept(this) as DissolutionRule;
}
else if (linkCreationContext != null)
{
}
else if (linkDestructionContext != null)
{
}
return(rule);
}
private static IExp resultOfReWritingRule(KpCore.Rule kpRule, Variable variable)
{
OperExp result = new OperExp();
int value = 0;//value of the variable
RewritingRule rwr = null;
if (kpRule.Type == RuleType.MULTISET_REWRITING)
{
rwr = (RewritingRule)kpRule;
}
else if (kpRule.Type == RuleType.REWRITE_COMMUNICATION)
{
rwr = (RewriteCommunicationRule)kpRule;
}
string orijinalVarName = variable.Name.Replace(SMVPreFix.COPY, "");
if (variable.Origin == VariableOrigin.Original || variable.Origin == VariableOrigin.OriginalCommVar)
{
result.Oper.Value = MathOper.SUB;
foreach (var leftHRule in rwr.Lhs)
{
if (leftHRule.Key.Equals(orijinalVarName))
{
value += leftHRule.Value;
}
}
}
else if (variable.Origin == VariableOrigin.Copy || variable.Origin == VariableOrigin.CopyOfCommVar)
{
result.Oper.Value = MathOper.ADD;
foreach (var rigthHRule in rwr.Rhs)
{
if (rigthHRule.Key.Equals(orijinalVarName))
{
value += rigthHRule.Value;
}
}
}
result.Exp = variable.Name;
result.Result = new Expression(value.ToString());
return(result);
}
private void writeRule(Rule rule)
{
owt.Write("{");
bool pItem = writePItem(rule);
if (!rule.IsEmpty())
{
if (pItem)
{
owt.Write(", ");
}
if (rule.IsGuarded)
{
owt.Write("\"guard\":");
writeGuard(rule.Guard);
owt.Write(", ");
}
if (rule.Type == RuleType.CONSUMER)
{
owt.Write("\"lhs\":");
writeMultiset((rule as ConsumerRule).Lhs);
}
else if (rule.Type == RuleType.MULTISET_REWRITING)
{
RewritingRule r = rule as RewritingRule;
owt.Write("\"lhs\":");
writeMultiset(r.Lhs);
owt.Write(", \"rhs\":");
writeMultiset(r.Rhs);
}
else if (rule.Type == RuleType.REWRITE_COMMUNICATION)
{
RewriteCommunicationRule r = rule as RewriteCommunicationRule;
owt.Write("\"lhs\":");
writeMultiset(r.Lhs);
owt.Write(", \"rhs\":");
writeMultiset(r.Rhs);
owt.Write(", \"targetRhs\":[");
int i = 1;
foreach (TargetedMultiset tm in r.TargetRhs.Values)
{
writeTargetedMultiset(tm);
if (i++ < r.TargetRhs.Count)
{
owt.Write(", ");
}
}
owt.Write("]");
}
else if (rule.Type == RuleType.MEMBRANE_DIVISION)
{
DivisionRule r = rule as DivisionRule;
owt.Write("\"lhs\":");
writeMultiset(r.Lhs);
owt.Write(", \"instances\":[");
int i = 1;
foreach (InstanceBlueprint ib in r.Rhs)
{
writeInstanceBlueprint(ib);
if (i++ < r.Rhs.Count)
{
owt.Write(", ");
}
}
owt.Write("]");
}
else if (rule.Type == RuleType.LINK_CREATION)
{
LinkRule r = rule as LinkRule;
owt.Write("\"lhs\":");
writeMultiset(r.Lhs);
owt.Write(",\"linkCreate\":");
writeInstanceIdentifier(r.Target);
}
else if (rule.Type == RuleType.LINK_DESTRUCTION)
{
LinkRule r = rule as LinkRule;
owt.Write("\"lhs\":");
writeMultiset(r.Lhs);
owt.Write(",\"linkDestroy\":");
writeInstanceIdentifier(r.Target);
}
else if (rule.Type == RuleType.MEMBRANE_DISSOLUTION)
{
DissolutionRule r = rule as DissolutionRule;
owt.Write("\"lhs\":");
writeMultiset(r.Lhs);
owt.Write(", \"dissolve\": true");
}
}
owt.Write("}");
}
private Rule readRule(XPathNavigator nav)
{
ConsumerRule rule = null;
XPathNavigator rhsNav = nav.SelectSingleNode("rhs");
if (rhsNav != null)
{
Multiset m = readMultiset(rhsNav);
XPathNodeIterator div;
if (m.IsEmpty())
{
//then we can have structure changing rules
div = rhsNav.SelectChildren("instance", String.Empty);
if (div.Count > 0)
{
DivisionRule r = new DivisionRule();
while (div.MoveNext())
{
string mtype = div.Current.GetAttribute("mtype", String.Empty);
InstanceBlueprint ib = null;
if (String.IsNullOrEmpty(mtype))
{
ib = new InstanceBlueprint(currentType);
}
else
{
ib = new InstanceBlueprint(kp[mtype]);
}
readMultiset(div.Current, ib.Multiset);
r.Rhs.Add(ib);
}
rule = r;
}
else
{
XPathNavigator v;
v = rhsNav.SelectSingleNode("linkCreate");
if (v == null)
{
v = rhsNav.SelectSingleNode("linkDestroy");
if (v == null)
{
v = rhsNav.SelectSingleNode("dissolve");
if (v != null)
{
rule = new DissolutionRule();
}
}
else
{
rule = LinkRule.LinkDestroy(readInstanceIdentifier(v));
}
}
else
{
rule = LinkRule.LinkCreate(readInstanceIdentifier(v));
}
}
}
if (rule == null)
{
div = rhsNav.SelectChildren("target", String.Empty);
if (div.Count > 0)
{
RewriteCommunicationRule rcr = new RewriteCommunicationRule();
rcr.Rhs.Add(m);
while (div.MoveNext())
{
TargetedMultiset tm = readTargetedMultiset(div.Current);
TargetedMultiset otm = null;
rcr.TargetRhs.TryGetValue(tm.Target, out otm);
if (otm == null)
{
rcr.TargetRhs.Add(tm.Target, tm);
}
else
{
otm.Multiset.Add(tm.Multiset);
}
}
rule = rcr;
}
else if (m != null)
{
rule = new RewritingRule();
(rule as RewritingRule).Rhs.Add(m);
}
}
}
if (rule == null)
{
rule = new ConsumerRule();
}
readPItem(nav, rule);
rule.Guard = readGuard(nav.SelectSingleNode("guard"));
readMultiset(nav.SelectSingleNode("lhs"), rule.Lhs);
return(rule);
}
/// <summary>
/// if variable has NOT been set by XML file then set max automatically
/// </summary>
/// <param name="kpSystem"></param>
/// <param name="myType"></param>
/// <param name="module"></param>
/// <param name="variable"></param>
/// <returns></returns>
private static int setMax(KPsystem kpSystem, MType myType, NuSMV.Module module, IVar variable)
{
int maxVal = 0;
foreach (var type in kpSystem.Types)
{
ExecutionStrategy eS = type.ExecutionStrategy;
while (eS != null)
{
//Inside this type
if (myType.Name.Equals(type.Name))
{
foreach (var rule in eS.Rules)
{
//Normal variable
if (rule.Type == RuleType.MULTISET_REWRITING)
{
RewritingRule rwr = (RewritingRule)rule;
foreach (var leftHRule in rwr.Lhs)
{
if (variable.Name.Equals(leftHRule.Key))
{
maxVal = Math.Max(maxVal, leftHRule.Value);
}
}
foreach (var rigthHRule in rwr.Rhs)
{
if (variable.Name.Equals(rigthHRule.Key))
{
maxVal = Math.Max(maxVal, rigthHRule.Value);
}
}
}
// Communication Var
else if (rule.Type == RuleType.REWRITE_COMMUNICATION)
{
RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule;
foreach (var leftHRule in rcr.Lhs)
{
if (variable.Name.Equals(leftHRule.Key))
{
maxVal = Math.Max(maxVal, leftHRule.Value);
}
}
}
else if (rule.Type == RuleType.MEMBRANE_DIVISION)
{
DivisionRule divisionRule = (DivisionRule)rule;
foreach (var leftHRule in divisionRule.Lhs)
{
if (variable.Name.Equals(leftHRule.Key))
{
maxVal = Math.Max(maxVal, leftHRule.Value);
}
}
foreach (InstanceBlueprint compartment in divisionRule.Rhs)
{
MType compType = compartment.Type;
if (myType.Name.Equals(compType.Name))
{
Multiset ms = compartment.Multiset;
foreach (var obj in ms.Objects)
{
if (variable.Name.Equals(obj))
{
maxVal = Math.Max(maxVal, ms[obj]);
}
}
}
}
}
else if (rule.Type == RuleType.MEMBRANE_DISSOLUTION)
{
DissolutionRule dissolutionRule = (DissolutionRule)rule;
foreach (var leftHRule in dissolutionRule.Lhs)
{
if (variable.Name.Equals(leftHRule.Key))
{
maxVal = Math.Max(maxVal, leftHRule.Value);
}
}
}
}
}
//Inside communication rule of other types
else
{
foreach (var rule in eS.Rules)
{
if (rule.Type == RuleType.REWRITE_COMMUNICATION)
{
RewriteCommunicationRule rcr = (RewriteCommunicationRule)rule;
foreach (var target in rcr.TargetRhs.Values)
{
TargetedMultiset tg = (TargetedMultiset)target;
InstanceIdentifier identifier = (InstanceIdentifier)tg.Target;
if (myType.Name.Equals(identifier.Value))
{
Multiset ms = tg.Multiset;
foreach (var rightVar in ms.Objects)
{
if (variable.Name.Equals(rightVar))
{
maxVal = Math.Max(maxVal, ms[rightVar]);
}
}
}
}
}
else if (rule.Type == RuleType.MEMBRANE_DIVISION)
{
DivisionRule divisionRule = (DivisionRule)rule;
foreach (InstanceBlueprint compartment in divisionRule.Rhs)
{
MType compType = compartment.Type;
if (myType.Name.Equals(compType.Name))
{
Multiset ms = compartment.Multiset;
foreach (var obj in ms.Objects)
{
if (variable.Name.Equals(obj))
{
maxVal = Math.Max(maxVal, ms[obj]);
}
}
}
}
}
}
}
eS = eS.Next;
}
//also compare parameter values
foreach (var instance in type.Instances)
{
foreach (var param in instance.Multiset.Objects)
{
if (variable.Name.Equals(param))
{
maxVal = Math.Max(maxVal, instance.Multiset[param]);
}
}
}
}
return(maxVal);
}
