private AssertionBase createReachability(AssertionExpr assertion)
{
Spec.ExecProcessDatabase.TryGetValue(assertion.Target, out DefinitionRef execProc);
ADLAssertionReachability assertionCSP = new ADLAssertionReachability(execProc, assertion.Expression);
//Spec.DeclarationDatabase.Add(assertion.Expression, new Expression());
// TODO: need to revise this to work
return(assertionCSP);
}
public override object VisitAssertion([NotNull] AssertionContext context)
{
Console.WriteLine("visit asssertion " + context.verification().ID());
AssertionExpr assert = new AssertionExpr(context.verification().ID().GetText());
if (context.verification().DEADLOCKFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.deadlockfree;
}
else if (context.verification().CIRCULARFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.circularfree;
}
else if (context.verification().BOTTLENECKFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.bottleneckfree;
}
else if (context.verification().AMBIGUOUSINTERFACEFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.ambiguousinterface;
}
else if (context.verification().LAVAFLOWFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.lavaflow;
}
else if (context.verification().DECOMPOSITIONFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.decomposition;
}
else if (context.verification().POLTERGEISTSFREE() != null)
{
assert.Type = AssertionExpr.AssertionType.poltergeists;
}
else if (context.verification().reachexpr() != null)
{
assert.Type = AssertionExpr.AssertionType.reachability;
assert.Expression = context.verification().reachexpr().ID().GetText().Trim();
}
else if (context.verification().ltlexpr() != null)
{
String ltlexpr = context.verification().ltlexpr().GetText();
foreach (var token in context.verification().ltlexpr().children)
{
Console.WriteLine(" LTL=== " + token.GetText());
}
assert.Expression = ltlexpr.Substring(ltlexpr.IndexOf("|=") + 2);
assert.ExpressionContext = context.verification().ltlexpr();
assert.Type = AssertionExpr.AssertionType.LTL;
}
return(assert);
}
public void AddAssertion(AssertionExpr assertion, string options)
{
if (assertion.Type == AssertionExpr.AssertionType.deadlockfree)
{
AssertionBase asrt = createDeadlockAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-deadlockfree", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.circularfree)
{
AssertionBase asrt = createCircularAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-circularfree", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.bottleneckfree)
{
AssertionBase asrt = createBottleneckAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-bottleneckfree", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.ambiguousinterface)
{
AssertionBase asrt = createAmbiguousInterfaceAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-ambiguousinterface", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.lavaflow)
{
AssertionBase asrt = createLavaFlowAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-lavaflow", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.decomposition)
{
AssertionBase asrt = createDecompositionAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-decomposition", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.poltergeists)
{
AssertionBase asrt = createPoltergeistAssertion(assertion);
Spec.AssertionDatabase.Add(assertion.Target + "-poltergeist", asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.LTL)
{
AssertionBase asrt = createLTLAssertion(assertion, options);
Spec.AssertionDatabase.Add(assertion.Target + " " + assertion.Expression, asrt);
}
else if (assertion.Type == AssertionExpr.AssertionType.reachability)
{
AssertionBase asrt = createReachability(assertion);
Spec.AssertionDatabase.Add(assertion.Target + " reaches " + assertion.Expression, asrt);
}
}
private AssertionBase createCircularAssertion(AssertionExpr assertion)
{
Spec.ExecProcessDatabase.TryGetValue(assertion.Target, out DefinitionRef execProc);
// insert assertion
ADLAssertionCircular assertionCSP = null;
if (execProc != null)
{
assertionCSP = new ADLAssertionCircular(execProc);
}
else
{
throw new Exception("Unknown target process for assertion");
}
return(assertionCSP);
}
private AssertionBase createPoltergeistAssertion(AssertionExpr assertion)
{
Spec.ExecProcessDatabase.TryGetValue(assertion.Target, out DefinitionRef execProc);
// insert assertion
ADLAssertionPoltergeist assertionCSP = null;
if (execProc != null)
{
assertionCSP = new ADLAssertionPoltergeist(execProc);
assertionCSP.ComponentDatabase = Spec.ComponentDatabase;
}
else
{
throw new Exception("Unknown target process for assertion");
}
return(assertionCSP);
}
private AssertionBase createLTLAssertion(AssertionExpr assertion, string options)
{
Spec.ExecProcessDatabase.TryGetValue(assertion.Target, out DefinitionRef execProc);
ADLAssertionLTL assertLTL = null;
if (execProc != null)
{
String ltl = assertion.Expression.Trim();
// Update LTL state
if (ltl.IndexOf(".") != -1)
{
ltl = ltl.Replace('.', '_');
}
// create ADLAssertionLTL
assertLTL = new ADLAssertionLTL(execProc, ltl);
BuchiAutomata PositiveBA = LTL2BA.FormulaToBA(ltl, options, null);
// default to false for x operator U X V T F R NOT SUPPORTED for now
bool hasXoperator = false;
PositiveBA.HasXOperator = hasXoperator;
if (!LivenessChecking.isLiveness(PositiveBA))
{
assertLTL.SeteBAs(null, PositiveBA);
}
else
{
BuchiAutomata BA = LTL2BA.FormulaToBA("!(" + ltl + ")", options, null); //.Replace(".", Ultility.Ultility.DOT_PREFIX)
BA.HasXOperator = hasXoperator;
assertLTL.SeteBAs(BA, PositiveBA);
}
}
else
{
throw new Exception("Unknown target process for assertion");
}
return(assertLTL);
}
/// <summary>
/// Parse the specification from string input into objects
/// </summary>
/// <param name="spec">string input of the model</param>
/// <param name="option">option for LTL parsing, usually it is an empty string</param>
protected virtual void ParseSpec(string spec, string options)
{
System.Diagnostics.Debug.WriteLine("parsing spec... ");
IsParsing = true;
if (GlobalConstantDatabase == null)
{
GlobalConstantDatabase = new Dictionary <string, Expression>();
}
// Start parsing ADL
AntlrInputStream inputStream = new AntlrInputStream(spec);
ADLLexer speakLexer = new ADLLexer(inputStream);
Antlr4.Runtime.CommonTokenStream commonTokenStream = new Antlr4.Runtime.CommonTokenStream(speakLexer);
ADL_Parser.ADLParser parser = new ADL_Parser.ADLParser(commonTokenStream);
ADLVisitor visitor = new ADLVisitor();
Object element;
StatementContext statement;
CSPGenerator generator = new CSPGenerator(this);
while (true)
{
statement = parser.statement();
// parsing architecture elements
if ((element = statement.archelement()) != null)
{
element = visitor.Visit((ArchelementContext)element);
if (element is Component)
{
Component comp = (Component)element;
Console.WriteLine(comp.ToString());
ComponentDatabase.Add(comp.Name, comp);
}
else if (element is Connector)
{
Connector conn = ((Connector)element);
Console.WriteLine(conn.ToString());
ConnectorDatabase.Add(conn.Name, conn);
}
else if (element is SystemConfig)
{
Console.WriteLine(((SystemConfig)element).ToString());
// Console.WriteLine("system:"+((SystemConfig)element).ToString());
generator.parse((SystemConfig)element);
}
// parsing assetion
}
else if ((element = statement.assertion()) != null)
{
AssertionExpr assertion = (AssertionExpr)visitor.VisitAssertion((AssertionContext)element);
Console.WriteLine(assertion.ToString());
generator.AddAssertion(assertion, options);
}
else
{
break;
}
}
// End parsing ADL
StaticAnalysis();
CheckingConflictingEventsAndVariables();
foreach (KeyValuePair <string, Definition> pair in DefinitionDatabase)
{
List <string> gVar = pair.Value.GlobalVars;
int i = 0;
while (i < gVar.Count)
{
//Console.WriteLine("parsed " + gVar[i]);
if (SpecValuation.Variables != null && !SpecValuation.Variables.ContainsKey(gVar[i]))
{
gVar.RemoveAt(i);
}
else
{
i++;
}
}
}
//get the relevant channels;
if (ChannelDatabase.Count > 0)
{
SyncrhonousChannelNames = new List <string>(0);
Dictionary <string, ChannelQueue> newChannelDatabase = new Dictionary <string, ChannelQueue>();
foreach (KeyValuePair <string, ChannelQueue> pair in ChannelDatabase)
{
if (pair.Value.Size == 0)
{
SyncrhonousChannelNames.Add(pair.Key);
}
else
{
newChannelDatabase.Add(pair.Key, pair.Value);
}
}
SpecValuation.Channels = newChannelDatabase;
HasSyncrhonousChannel = SyncrhonousChannelNames.Count > 0;
}
foreach (KeyValuePair <string, AssertionBase> entry in AssertionDatabase)
{
entry.Value.Initialize(this);
}
CheckVariableRange();
// Console.WriteLine("Finish parsing spec....................");
Console.WriteLine(this.GetSpecification());
}
