public static string ComponentEventOutputs(IEnumerable <Connection> connections, bool useProcesses)
{
string outputsString = "-- ComponentEventOutputs\n";
if (useProcesses)
{
foreach (string output in _getInternalEventOutputStrings(connections))
{
outputsString += String.Format(Smv.NextVarAssignment, output, Smv.False);
}
}
else
{
foreach (string output in _getInternalEventOutputs(connections))
{
string[] outpSplit = Smv.SplitConnectionVariableName(output);
bool alreadyChecked;
string varName = Smv.ConvertConnectionVariableName(output, Smv.ModuleParameters.Event, out alreadyChecked);
string setRule = String.Format("\t{0}.{1}_set : {2};\n", outpSplit[0], Smv.ModuleParameters.Event(outpSplit[1]), Smv.True);
string resetRule = String.Format("\t{0} : {1};\n", Smv.True, Smv.False);
outputsString += String.Format(Smv.EmptyNextCaseBlock, varName, setRule + resetRule);
}
}
return(outputsString);
}
public static string EcActionsCounterChangeBlock(IEnumerable <ECState> states)
{
string rules = "\t" + Smv.OsmStateVar + "=" + Smv.Osm.S1 + ": 1;\n";
string rformat = "\t" + Smv.OsmStateVar + "=" + Smv.Osm.S2 + " & " + Smv.AlgStepsCounterVar +
"=0 & ({0}): ";
const string modFormatSuffix = "({1}) mod {2};\n";
const string normalFormatSuffix = "{1};\n";
string rule1 = "";
string rule2 = "";
foreach (ECState state in states)
{
string add = "(";
add += Smv.EccStateVar + "=" + Smv.EccState(state.Name);
add += " & ";
add += Smv.EcActionsCounterVar + " {0} " + (state.ActionsCount > 0 ? state.ActionsCount : 1);
add += ") | ";
rule1 += String.Format(add, "<");
rule2 += String.Format(add, "=");
}
rules += String.Format(rformat + modFormatSuffix, rule1.TrimEnd(Smv.OrTrimChars), Smv.EcActionsCounterVar + " + 1", states.Max(state => state.ActionsCount) + 1);
rules += String.Format(rformat + normalFormatSuffix, rule2.TrimEnd(Smv.OrTrimChars), " 0 ");
return(String.Format(Smv.NextCaseBlock, Smv.EcActionsCounterVar, rules));
}
public static string InternalEventConnections(IEnumerable <Connection> internalBuffers, bool useProcesses)
{
string eventConnections = "-- _internalEventConnections\n";
MultiMap <string> eventConnectionsMap = _getEventConnectionsMap(internalBuffers);
List <string> definesList = new List <string>();
foreach (string dst in eventConnectionsMap.Keys)
{
bool dstComponent;
string dstSmvVar = Smv.ConvertConnectionVariableName(dst, Smv.ModuleParameters.Event, out dstComponent);
string srcString = "\t("; //+ srcSmvVar + " : " + Smv.True + ";\n";
foreach (string src in eventConnectionsMap[dst])
{
bool srcComponent;
string srcSmvVar = Smv.ConvertConnectionVariableName(src, Smv.ModuleParameters.Event, out srcComponent);
if (srcComponent)
{
srcString += srcSmvVar + " | ";
}
else
{
srcString += String.Format("({0} & {1}) | ", srcSmvVar, Smv.Alpha);
}
}
srcString = srcString.TrimEnd(Smv.OrTrimChars) + ")";
if (useProcesses)
{
srcString += " : " + Smv.True + ";\n";
eventConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString);
}
else
{
string reset_string;
if (dstComponent)
{
string[] connectionDst = Smv.SplitConnectionVariableName(dst);
reset_string = String.Format("\t({0}.{1}_reset) : {2};\n", connectionDst[0], Smv.ModuleParameters.Event(connectionDst[1]), Smv.False);
srcString += " : " + Smv.True + ";\n";
eventConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString + reset_string);
}
else
{
//reset_string = String.Format("\t{0} : {1};\n", Smv.True, Smv.False);
//srcString = srcString.TrimEnd(Smv.OrTrimChars) + ") : " + Smv.True + ";\n";
//eventConnections += String.Format(Smv.EmptyNextCaseBlock + "\n", dstSmvVar, srcString + reset_string);
dstSmvVar += "_set";
definesList.Add(String.Format(Smv.DefineBlock, dstSmvVar, srcString));
}
}
}
foreach (string def in definesList)
{
eventConnections += def;
}
return(eventConnections);
}
private static Variable _findVariable(string connectionPoint, IEnumerable <Variable> allVariables, IEnumerable <FBInstance> instances)
{
string[] nameSplit = Smv.SplitConnectionVariableName(connectionPoint);
FBInstance fbInst = instances.FirstOrDefault(inst => inst.Name == nameSplit[0]);
Variable foundVar = allVariables.FirstOrDefault(v => v.FBType == fbInst.InstanceType && v.Name == nameSplit[1]);
return(foundVar);
}
public static string EccStatesDeclaration(IEnumerable <ECState> states)
{
string eccStates = "";
foreach (var ecState in states)
{
eccStates += Smv.EccState(ecState.Name) + Smv.ModuleParameters.Splitter;
}
return(String.Format("VAR {0} : {{{1}}};\n", Smv.EccStateVar,
eccStates.TrimEnd(Smv.ModuleParameters.Splitter.ToCharArray())));
}
public static string BasicModuleDefines(IEnumerable <ECState> states, IEnumerable <Event> events, IEnumerable <ECTransition> transitions, bool showUnconditionalTransitions)
{
string ecTran = "";
foreach (ECState state in states)
{
IEnumerable <ECTransition> stateTrans = transitions.Where(t => t.Source == state.Name);
if (!stateTrans.Any())
{
continue;
}
ecTran += "(";
ecTran += Smv.EccStateVar + "=" + Smv.EccState(state.Name);
string transitionRules = "";
foreach (var transition in stateTrans)
{
transitionRules += "(";
if (transition.Condition == null || transition.Condition == "1")
{
if (!showUnconditionalTransitions)
{
transitionRules = null;
break;
}
else
{
transitionRules += "1";
}
}
else
{
transitionRules += _translateEventNames(Smv.ClearConditionExpr(transition.Condition), events);
}
transitionRules += ") | ";
}
if (transitionRules != null)
{
ecTran += " & (" + transitionRules.TrimEnd(Smv.OrTrimChars) + ")";
}
ecTran += ") | ";
}
string existsEnabledECTran = String.Format("DEFINE {0}:= {1};\n", Smv.ExistsEnabledEcTran, ecTran.Trim(Smv.OrTrimChars));
string absentsEnabledECTran = "\n";
//string alphabeta = "--alpha/beta\nDEFINE alpha_beta := ( (alpha & S_smv=s0_osm & !ExistsInputEvent | S_smv=s1_osm & (!ExistsEnabledECTran)) );\n";
return(FbSmvCommon.DefineExistsInputEvent(events) + existsEnabledECTran + absentsEnabledECTran); // + alphabeta;
}
private static void _addCounterRules(ref string rule1, ref string rule2, ECState state, int algsCount, ECAction action)
{
string add = "(";
add += Smv.EccStateVar + "=" + Smv.EccState(state.Name);
add += " & ";
add += Smv.EcActionsCounterVar + " = " + (action.Number);
//(state.ActionsCount > 0 ? state.ActionsCount : 1);
add += " & ";
add += Smv.AlgStepsCounterVar + " {0} " + (algsCount > 0 ? algsCount : 1);
add += ") | ";
rule1 += String.Format(add, "<");
rule2 += String.Format(add, "=");
}
public static string ModuleFooter(Settings settings)
{
if (settings.UseProcesses)
{
return("\n" + Smv.Fairness(Smv.Running));
}
else
{
string ret = "";
ret += Smv.Fairness(Smv.Alpha);
ret += Smv.Fairness(Smv.Beta);
return(ret + "\n");
}
}
public static string AlgStepsCounterChangeBlock(IEnumerable <ECState> states, IEnumerable <ECAction> actions, IEnumerable <TranslatedAlg> algorithms)
{
//if (!algorithms.Any()) return "";
string rules = "\t" + Smv.OsmStateVar + "=" + Smv.Osm.S1 + ": 1;\n";
string rformat = "\t" + Smv.OsmStateVar + "=" + Smv.Osm.S2 + " & ({0}):";
const string modFormatSuffix = "({1}) mod {2};\n";
const string normalFormatSuffix = "{1};\n";
string rule1 = "";
string rule2 = "";
foreach (ECState state in states)
{
string stateName = state.Name;
if (state.ActionsCount == 0)
{
string add = "(";
add += Smv.EccStateVar + "=" + Smv.EccState(state.Name);
add += " & ";
add += Smv.EcActionsCounterVar + " = 1";
add += " & ";
add += Smv.AlgStepsCounterVar + " {0} 1";
add += ") | ";
rule1 += String.Format(add, "<");
rule2 += String.Format(add, "=");
}
else
{
foreach (ECAction action in actions.Where(act => act.ECState == stateName))
{
int algsCount = 0;
if (action.Algorithm != null)
{
var actionAlg = algorithms.FirstOrDefault(alg => alg.Name == action.Algorithm);
if (actionAlg != null)
{
algsCount = actionAlg.Lines.Count;
}
}
_addCounterRules(ref rule1, ref rule2, state, algsCount, action);
}
}
}
int maxAlgStepsCount = algorithms.Any() ? algorithms.Max(alg => alg.Lines.Max(line => line.NI)) : 1;
rules += String.Format(rformat + modFormatSuffix, rule1.TrimEnd(Smv.OrTrimChars), Smv.AlgStepsCounterVar + " + 1", maxAlgStepsCount + 1);
rules += String.Format(rformat + normalFormatSuffix, rule2.TrimEnd(Smv.OrTrimChars), " 0 ");
return(String.Format(Smv.NextCaseBlock, Smv.AlgStepsCounterVar, rules));
}
private static bool _isInputFromComponent(FBInterface instanceParameter, IEnumerable <Connection> connections, string instanceName, out Connection inputConnection)
{
inputConnection = null;
bool srcComponent = false;
if (instanceParameter.Direction == Direction.Input)
{
inputConnection = connections.FirstOrDefault(conn => conn.Destination == instanceName + "." + instanceParameter.Name);
if (inputConnection != null)
{
Smv.ConvertConnectionVariableName(inputConnection.Source, Smv.ModuleParameters.Event, out srcComponent);
}
}
return(srcComponent);
}
private static string _getVarChangingRules(Variable variable, IEnumerable <AlgorithmLine> currrentVarLines, IEnumerable <ECAction> actions, Settings settings)
{
string rules = "";
foreach (AlgorithmLine line in currrentVarLines)
{
foreach (ECAction action in _findActionsByAlgorithmName(actions, line.AlgorithmName))
{
string rule = "\t" + Smv.OsmStateVar + "=" + Smv.Osm.S2;
rule += " & ";
rule += Smv.EccStateVar + "=" + Smv.EccState(action.ECState);
rule += " & ";
rule += Smv.EcActionsCounterVar + "=" + action.Number;
rule += " & ";
rule += Smv.AlgStepsCounterVar + "=" + line.NI;
if (line.Condition != "1")
{
rule += " & ";
rule += "(" + Smv.ClearConditionExpr(line.Condition) + ")";
}
//string val = line.Value;
string val = Smv.ClearConditionExpr(line.Value);
if (String.Compare(val, "false", StringComparison.InvariantCultureIgnoreCase) == 0)
{
val = Smv.False;
}
if (String.Compare(val, "true", StringComparison.InvariantCultureIgnoreCase) == 0)
{
val = Smv.True;
}
if (variable.SmvType.GetType() != typeof(Smv.DataTypes.BoolSmvType) && settings.ModularArithmetics)
{
//string rangeStr = variable.SmvType.Split()
Smv.DataTypes.RangeSmvType varType = (Smv.DataTypes.RangeSmvType)variable.SmvType;
rule += " : (" + _modulo_range(val, varType.RangeBegin, varType.RangeEnd) + ");\n";;
}
else
{
rule += " : (" + val + ");\n";
}
rules += rule;
}
}
return(rules);
}
public static string SetOutputVarBuffers(IEnumerable <Variable> variables, IEnumerable <Event> events, IEnumerable <ECAction> actions, IEnumerable <WithConnection> withConnections, ShowMessageDelegate showMessage)
{
string outVarsChangeString = "";
foreach (Variable variable in variables.Where(v => v.Direction == Direction.Output))
{
string rule = Smv.OsmStateVar + "=" + Smv.Osm.S2 + " & " + Smv.AlgStepsCounterVar + "=0" +
" & ({0}) : {1};\n";
string outCond = "";
List <ECAction> ac = new List <ECAction>();
foreach (WithConnection connection in withConnections.Where(conn => conn.Var == variable.Name))
{
var outputEventsActions = actions.Where(act => act.Output == connection.Event);
if (outputEventsActions.Count() == 0)
{
showMessage(String.Format("Warning! Event {0} associated with output {1} never fires.", connection.Event, variable.Name));
}
foreach (ECAction action in outputEventsActions)
{
if (!ac.Contains(action))
{
ac.Add(action);
}
}
}
foreach (ECAction action in ac)
{
outCond += "(" + Smv.EccStateVar + "=" + Smv.EccState(action.ECState) + " & " +
Smv.EcActionsCounterVar + "=" + action.Number + ") | ";
}
if (outCond != "")
{
rule = String.Format(rule, outCond.TrimEnd(Smv.OrTrimChars), variable.Name);
outVarsChangeString += String.Format(Smv.NextCaseBlock, Smv.ModuleParameters.Variable(variable.Name), rule);
}
else
{
showMessage(String.Format("Warning! No active events associated with output {0}.", variable.Name));
}
}
return(outVarsChangeString);
}
private static IEnumerable <string> _getInternalEventOutputs(IEnumerable <Connection> internalBuffers)
{
HashSet <string> internalEventOutputs = new HashSet <string>();
foreach (Connection connection in internalBuffers.Where(conn => conn.Type == ConnectionType.Event))
{
bool srcComponent;
Smv.ConvertConnectionVariableName(connection.Source, Smv.ModuleParameters.Event, out srcComponent);
if (!internalEventOutputs.Contains(connection.Source))
{
if (srcComponent)
{
internalEventOutputs.Add(connection.Source);
}
}
}
return(internalEventOutputs);
}
public static string OutputEventsSettingRules(IEnumerable <Event> events, IEnumerable <ECAction> actions, bool useProcesses)
{
string eventChangeString = "";
foreach (Event ev in events.Where(ev => ev.Direction == Direction.Output))
{
string rule = "\t" + Smv.OsmStateVar + "=" + Smv.Osm.S2 + " & " + Smv.AlgStepsCounterVar + "=0" + " & ({0})";
const string setValue = " : {0};\n";
string outCond = "";
bool eventSignalSet = false;
foreach (ECAction action in actions.Where(act => act.Output == ev.Name))
{
outCond += "(" + Smv.EccStateVar + "=" + Smv.EccState(action.ECState) + " & " + Smv.EcActionsCounterVar + "=" + action.Number + ") | ";
eventSignalSet = true;
}
if (eventSignalSet)
{
rule = String.Format(rule, outCond.TrimEnd(Smv.OrTrimChars));
if (useProcesses)
{
eventChangeString += String.Format(Smv.NextCaseBlock, Smv.ModuleParameters.Event(ev.Name), rule + String.Format(setValue, Smv.True));
}
else
{
eventChangeString += String.Format(Smv.DefineBlock, Smv.ModuleParameters.Event(ev.Name) + "_set", rule);
}
}
else
{
if (useProcesses)
{
eventChangeString += String.Format(Smv.NextCaseBlock, Smv.ModuleParameters.Event(ev.Name), "");
}
else
{
eventChangeString += String.Format(Smv.DefineBlock, Smv.ModuleParameters.Event(ev.Name) + "_set", Smv.False);
}
}
}
return(eventChangeString);
}
public static string EcStateChangeBlock(IEnumerable <ECTransition> transitions, IEnumerable <Event> events)
{
string ecTransitionsSmv = "";
foreach (var transition in transitions)
{
ecTransitionsSmv += "\t";
ecTransitionsSmv += Smv.EccStateVar + "=" + Smv.EccState(transition.Source);
ecTransitionsSmv += " & ";
ecTransitionsSmv += Smv.OsmStateVar + "=" + Smv.Osm.S1;
if (transition.Condition != null && transition.Condition != "1")
{
ecTransitionsSmv += " & " + _translateEventNames(Smv.ClearConditionExpr(transition.Condition), events);
}
ecTransitionsSmv += " : ";
ecTransitionsSmv += Smv.EccState(transition.Destination);
ecTransitionsSmv += ";\n";
}
return(String.Format("\n" + Smv.NextCaseBlock + "\n", Smv.EccStateVar, ecTransitionsSmv));
}
public static string InternalDataConnections(IEnumerable <Connection> internalBuffers, IEnumerable <WithConnection> withConnections, IEnumerable <Variable> allVariables, IEnumerable <FBInstance> instances)
{
string dataConnections = "-- _internalDataConnections\n";
foreach (Connection connection in internalBuffers.Where(conn => conn.Type == ConnectionType.Data))
{
bool srcComponent;
bool dstComponent;
string dstSmvVar = Smv.ConvertConnectionVariableName(connection.Destination, Smv.ModuleParameters.Variable, out dstComponent);
string srcSmvVar = Smv.ConvertConnectionVariableName(connection.Source, Smv.ModuleParameters.Variable, out srcComponent);
string srcString = "";
/*if (srcComponent && dstComponent)
* {
* //srcString = "\t" + srcSmvVar + " : " + Smv.True + ";\n"; //TODO: make direct connections without double-buffering
* var srcVar = _findVariable(connection.Source, allVariables, instances);
*
* if (srcVar.ArraySize == 0)
* dataConnections += String.Format(Smv.NextVarAssignment + "\n", dstSmvVar, srcSmvVar);
* else
* {
* for (int i = 0; i < srcVar.ArraySize; i++)
* {
* dataConnections += String.Format(Smv.NextVarAssignment + "\n", dstSmvVar + Smv.ArrayIndex(i), srcSmvVar + Smv.ArrayIndex(i));
* }
* }
* }
* else */
if (!srcComponent && dstComponent)
{
var dstVar = _findVariable(connection.Destination, allVariables, instances);
if (dstVar.ArraySize == 0)
{
srcString = FbSmvCommon.VarSamplingRule(connection.Source, withConnections, false);
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString);
}
else
{
for (int i = 0; i < dstVar.ArraySize; i++)
{
srcString = FbSmvCommon.VarSamplingRule(connection.Source, withConnections, false, i);
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar + Smv.ArrayIndex(i), srcString);
}
}
}
else if (srcComponent && !dstComponent)
{
IEnumerable <string> samplingEvents = _getSamplingEventNamesForVariable(connection.Destination, withConnections);
MultiMap <string> eventConnectionsMap = _getEventConnectionsMap(internalBuffers);
string eventSeed = "";
foreach (string ev in samplingEvents)
{
string src = "";
foreach (string parentEvent in eventConnectionsMap[ev])
{
bool dontCare;
src += Smv.ConvertConnectionVariableName(parentEvent, Smv.ModuleParameters.Event, out dontCare) + Smv.Or;
}
eventSeed += String.Format("({0}){1}", src.TrimEnd(Smv.OrTrimChars), Smv.Or);
}
var srcVar = _findVariable(connection.Source, allVariables, instances);
if (srcVar.ArraySize == 0)
{
srcString = String.Format("\t{0} : {1};\n", eventSeed.TrimEnd(Smv.OrTrimChars), srcSmvVar);
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar, srcString);
}
else
{
for (int i = 0; i < srcVar.ArraySize; i++)
{
srcString = String.Format("\t{0} : {1};\n", eventSeed.TrimEnd(Smv.OrTrimChars), srcSmvVar + Smv.ArrayIndex(i));
dataConnections += String.Format(Smv.NextCaseBlock + "\n", dstSmvVar + Smv.ArrayIndex(i), srcString);
}
}
}
}
return(dataConnections);
}
public static string NonConnectedInputs(IEnumerable <Connection> connections, IEnumerable <Variable> allVariables, IEnumerable <FBInstance> instances)
{
string ret = "";
foreach (FBInstance instance in instances)
{
var instanceVariables = allVariables.Where(v => v.FBType == instance.InstanceType && v.Direction == Direction.Input && !v.IsConstant);
foreach (Variable variable in instanceVariables)
{
if (_nonInitializableVar(variable))
{
continue; // do not add "next" statement for FB_DELAY and E_CYCLE data IOs
}
string connectionNodeName = instance.Name + "." + variable.Name;
Connection connection = connections.FirstOrDefault(conn => conn.Destination == connectionNodeName);
if (connection != null)
{
continue;
}
if (variable.ArraySize == 0)
{
ret += String.Format(Smv.NextVarAssignment, instance.Name + "_" + variable.Name, instance.Name + "_" + variable.Name);
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
ret += String.Format(Smv.NextVarAssignment, instance.Name + "_" + variable.Name + Smv.ArrayIndex(i), instance.Name + "_" + variable.Name + Smv.ArrayIndex(i));
}
}
}
}
return(ret);
}
public static string OutputVariablesChangingRules(IEnumerable <Variable> variables, IEnumerable <ECAction> actions, IEnumerable <AlgorithmLine> lines, Settings settings)
{
string varChangeBlocks = "";
foreach (Variable variable in variables.Where(v => v.Direction == Direction.Output || v.Direction == Direction.Internal))
{
if (variable.ArraySize == 0)
{
IEnumerable <AlgorithmLine> currrentVarLines = lines.Where(line => line.Variable == variable.Name);
string rules = _getVarChangingRules(variable, currrentVarLines, actions, settings);
varChangeBlocks += String.Format(Smv.NextCaseBlock, variable.Name, rules);
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
string arrayElementVar = String.Format("{0}[{1}]", variable.Name, i);
IEnumerable <AlgorithmLine> currrentVarLines = lines.Where(line => line.Variable == arrayElementVar);
string rules = _getVarChangingRules(variable, currrentVarLines, actions, settings);
varChangeBlocks += String.Format(Smv.NextCaseBlock, variable.Name + Smv.ArrayIndex(i), rules);
}
}
}
return(varChangeBlocks);
}
public static string ModuleVariablesInitBlock(IEnumerable <Variable> variables)
{
string varsInit = "-- _moduleVariablesInitBlock\n";
foreach (var variable in variables)
{
if (!variable.IsConstant)
{
if (variable.ArraySize == 0)
{
varsInit += String.Format(Smv.VarInitializationBlock, variable.Name, Smv.InitialValue(variable));
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
varsInit += String.Format(Smv.VarInitializationBlock, variable.Name + Smv.ArrayIndex(i), Smv.InitialValue(variable));
}
}
}
}
return(varsInit);
}
public static string InputVariablesSampleBasic(IEnumerable <Variable> variables, IEnumerable <WithConnection> withConnections)
{
string varChangeBlocks = "";
foreach (Variable variable in variables.Where(v => v.Direction == Direction.Input))
{
if (!variable.IsConstant)
{
if (variable.ArraySize == 0)
{
varChangeBlocks += String.Format(Smv.NextCaseBlock, variable.Name, FbSmvCommon.VarSamplingRule(variable.Name, withConnections, true));
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
varChangeBlocks += String.Format(Smv.NextCaseBlock, variable.Name + Smv.ArrayIndex(i), FbSmvCommon.VarSamplingRule(variable.Name, withConnections, true, i));
}
}
}
}
return(varChangeBlocks);
}
public static string ModuleHeader(IEnumerable <Event> events, IEnumerable <Variable> variables, string fbTypeName)
{
string outp = "";
outp += FbSmvCommon.SmvModuleDeclaration(events, variables, fbTypeName);
foreach (var variable in variables)
{
if (variable.ArraySize == 0)
{
if (variable.IsConstant)
{
outp += String.Format(Smv.DefineBlock, variable.Name, variable.InitialValue);
}
else
{
outp += String.Format(Smv.VarDeclarationBlock, variable.Name, variable.SmvType);
}
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
if (variable.IsConstant)
{
outp += String.Format(Smv.VarDeclarationBlock, variable.Name + Smv.ArrayIndex(i), variable.InitialValue); //TODO: parse initial values for arrays
}
else
{
outp += String.Format(Smv.VarDeclarationBlock, variable.Name + Smv.ArrayIndex(i), variable.SmvType);
}
}
}
}
return(outp);
}
public static string InternalBuffersDeclaration(IEnumerable <FBInstance> instances, IEnumerable <Connection> connections, IEnumerable <Event> nonFilteredEvents, IEnumerable <Variable> nonFilteredVariables)
{
string buffers = "";
foreach (FBInstance instance in instances)
{
var instanceVariables = nonFilteredVariables.Where(v => v.FBType == instance.InstanceType && v.Direction != Direction.Internal && !v.IsConstant);
var instanceEvents = nonFilteredEvents.Where(ev => ev.FBType == instance.InstanceType && ev.Direction != Direction.Internal);
foreach (Event ev in instanceEvents)
{
//Connection inputConnection;
//if (! _isInputFromComponent(ev, connections, instance.Name, out inputConnection))
//{
buffers += String.Format(Smv.VarDeclarationBlock, instance.Name + "_" + ev.Name, Smv.DataTypes.BoolType);
//}
}
foreach (Variable variable in instanceVariables)
{
Connection inputConnection;
if (!_isInputFromComponent(variable, connections, instance.Name, out inputConnection))
{
if (variable.ArraySize == 0)
{
buffers += String.Format(Smv.VarDeclarationBlock, instance.Name + "_" + variable.Name, variable.SmvType);
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
buffers += String.Format(Smv.VarDeclarationBlock, instance.Name + "_" + variable.Name + Smv.ArrayIndex(i), variable.SmvType);
}
}
}
}
buffers += String.Format(Smv.VarDeclarationBlock, instance.Name + "_" + Smv.Alpha, Smv.DataTypes.BoolType);
buffers += String.Format(Smv.VarDeclarationBlock, instance.Name + "_" + Smv.Beta, Smv.DataTypes.BoolType);
buffers += "\n";
}
return(buffers);
}
public static string InternalBuffersInitialization(IEnumerable <FBInstance> instances, IEnumerable <Connection> connections, IEnumerable <Event> nonFilteredEvents, IEnumerable <Variable> nonFilteredVariables, IEnumerable <InstanceParameter> instanceParameters, bool mainModule = false)
{
string buffersInit = "";
foreach (FBInstance instance in instances)
{
var instanceVariables = nonFilteredVariables.Where(v => v.FBType == instance.InstanceType && v.Direction != Direction.Internal && !v.IsConstant);
var instanceEvents = nonFilteredEvents.Where(ev => ev.FBType == instance.InstanceType && ev.Direction != Direction.Internal);
foreach (Event ev in instanceEvents)
{
//Connection inputConnection;
//if (!_isInputFromComponent(ev, connections, instance.Name, out inputConnection))
//{
buffersInit += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + ev.Name, Smv.False);
//}
}
foreach (Variable variable in instanceVariables)
{
Connection inputConnection;
if (_nonInitializableVar(variable))
{
continue; // do not initialize SMV variables for FB_DELAY and E_CYCLE data IOs
}
if (_isInputFromComponent(variable, connections, instance.Name, out inputConnection))
{
continue;
}
// if(! _isInputFromComponent)
InstanceParameter instanceParameter = instanceParameters.FirstOrDefault(p => p.InstanceName == instance.Name && p.Name == variable.Name);
if (variable.ArraySize == 0)
{
string value = instanceParameter == null?Smv.InitialValue(variable) : Smv.ClearInitialValue(instanceParameter.Value, variable);
buffersInit += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + variable.Name, value);
}
else
{
string[] values;
if (instanceParameter == null)
{
values = new string[variable.ArraySize];
for (int i = 0; i < variable.ArraySize; i++)
{
values[i] = Smv.InitialValue(variable);
}
}
else
{
char[] trimChars = { '[', ']' };
values = instanceParameter.Value.Trim(trimChars).Split(',');
if (values.Count() != variable.ArraySize)
{
throw new Exception("Invalid array value " + instanceParameter.Value);
}
}
for (int i = 0; i < variable.ArraySize; i++)
{
buffersInit += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + variable.Name + Smv.ArrayIndex(i), Smv.ClearInitialValue(values[i], variable));
}
}
}
if (!mainModule)
{
buffersInit += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + Smv.Alpha, Smv.False);
buffersInit += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + Smv.Beta, Smv.False);
}
buffersInit += "\n";
}
return(buffersInit);
}
public string TranslateBasicFB(FBType fbType, bool eventSignalResetSolve = true, bool showUnconditionalTransitions = false)
{
string smvModule = "";
ExecutionModel executionModel = _executionModels.FirstOrDefault(em => em.FBTypeName == fbType.Name);
var events = _storage.Events.Where(ev => ev.FBType == fbType.Name);
var variables = _storage.Variables.Where(ev => ev.FBType == fbType.Name);
var states = _storage.EcStates.Where(ev => ev.FBType == fbType.Name);
var algorithms = _storage.Algorithms.Where(alg => alg.FBType == fbType.Name && alg.Language == AlgorithmLanguages.ST);
var smvAlgs = _translateAlgorithms(algorithms);
var actions = _storage.EcActions.Where(act => act.FBType == fbType.Name);
var withConnections = _storage.WithConnections.Where(conn => conn.FBType == fbType.Name);
var transitions = _storage.EcTransitions.Where(tr => tr.FBType == fbType.Name);
smvModule += BasicFbSmv.ModuleHeader(events, variables, fbType.Name);
smvModule += BasicFbSmv.OsmStatesDeclaration();
smvModule += BasicFbSmv.EccStatesDeclaration(states) + "\n";
smvModule += BasicFbSmv.EcActionsCounterDeclaration(states);
smvModule += BasicFbSmv.AlgStepsCounterDeclaration(smvAlgs);
smvModule += Smv.Assign;
smvModule += String.Format(Smv.VarInitializationBlock, Smv.EccStateVar, Smv.EccState(states.First(s => true).Name));
smvModule += String.Format(Smv.VarInitializationBlock, Smv.OsmStateVar, Smv.Osm.S0);
smvModule += BasicFbSmv.ModuleVariablesInitBlock(variables) + "\n";
smvModule += String.Format(Smv.VarInitializationBlock, Smv.EcActionsCounterVar, "0");
smvModule += String.Format(Smv.VarInitializationBlock, Smv.AlgStepsCounterVar, "0");
smvModule += BasicFbSmv.EcStateChangeBlock(transitions, events);
smvModule += Smv.OsmStateChangeBlock + "\n";
smvModule += BasicFbSmv.EcActionsCounterChangeBlock(states) + "\n";
smvModule += BasicFbSmv.AlgStepsCounterChangeBlock(states, actions, smvAlgs) + "\n";
smvModule += BasicFbSmv.InputVariablesSampleBasic(variables, withConnections) + "\n";
smvModule += BasicFbSmv.OutputVariablesChangingRules(variables, actions, _storage.AlgorithmLines.Where(line => line.FBType == fbType.Name), _settings) + "\n";
smvModule += BasicFbSmv.SetOutputVarBuffers(variables, events, actions, withConnections, _showMessage) + "\n";
smvModule += BasicFbSmv.SetServiceSignals(_settings.UseProcesses) + "\n";
smvModule += BasicFbSmv.EventInputsResetRules(events, executionModel, eventSignalResetSolve, _settings.UseProcesses) + "\n";
smvModule += BasicFbSmv.OutputEventsSettingRules(events, actions, _settings.UseProcesses) + "\n";
smvModule += BasicFbSmv.BasicModuleDefines(states, events, transitions, showUnconditionalTransitions) + "\n";
smvModule += FbSmvCommon.ModuleFooter(_settings) + "\n";
return(smvModule);
}
public string GenerateMain()
{
string mainModule = "";
FBType topLevelFbType = _storage.Types.FirstOrDefault(fbType => fbType.IsRoot);
if (topLevelFbType == null)
{
throw new ArgumentNullException("Can't find root FB type");
}
List <FBInstance> instanceList = new List <FBInstance>();
List <Connection> connections = new List <Connection>();
List <InstanceParameter> instanceParameters = new List <InstanceParameter>();
FBInstance instance = new FBInstance(topLevelFbType.Name + "_inst", topLevelFbType.Name, "Top-level FB instance", "main");
instanceList.Add(instance);
mainModule += String.Format(Smv.ModuleDef, "main", "");
mainModule += CompositeFbSmv.FbInstances(instanceList, _storage.Events, _storage.Variables, connections, _settings) + "\n";
mainModule += CompositeFbSmv.InternalBuffersDeclaration(instanceList, connections, _storage.Events, _storage.Variables) + "\n";
if (_settings.GenerateDummyProperty)
{
mainModule += String.Format(Smv.VarDeclarationBlock, "false_var", Smv.DataTypes.BoolType);
}
mainModule += Smv.Assign;
if (_settings.GenerateDummyProperty)
{
mainModule += String.Format(Smv.VarInitializationBlock, "false_var", Smv.False);
mainModule += String.Format(Smv.NextVarAssignment, "false_var", Smv.False);
}
mainModule += CompositeFbSmv.InternalBuffersInitialization(instanceList, connections, _storage.Events, _storage.Variables, instanceParameters, true) + "\n";
mainModule += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + Smv.Alpha, Smv.True);
mainModule += String.Format(Smv.VarInitializationBlock, instance.Name + "_" + Smv.Beta, Smv.False);
//Main module next blocks
//**********************
foreach (Variable variable in _storage.Variables.Where(v => v.FBType == topLevelFbType.Name && v.Direction == Direction.Input && !v.IsConstant))
{
string smvVariable = instance.Name + "_" + variable.Name;
if (variable.ArraySize == 0)
{
mainModule += String.Format(Smv.NextVarAssignment, smvVariable, smvVariable);
}
else
{
for (int i = 0; i < variable.ArraySize; i++)
{
mainModule += String.Format(Smv.NextVarAssignment, smvVariable + Smv.ArrayIndex(i), smvVariable + Smv.ArrayIndex(i));
}
}
}
foreach (Event ev in _storage.Events.Where(ev => ev.FBType == topLevelFbType.Name))
{
string smvVariable = instance.Name + "_" + ev.Name;
string nextRule = "";
if (ev.Direction == Direction.Output)
{
nextRule = instance.Name + "." + "event_" + ev.Name + "_set : " + Smv.True + ";\n";
}
else
{
nextRule = instance.Name + "." + "event_" + ev.Name + "_reset : " + Smv.False + ";\n";
}
mainModule += String.Format(Smv.NextCaseBlock, smvVariable, nextRule);
}
string alphaRule = "\t" + instance.Name + "_" + Smv.Beta + " : " + Smv.True + ";\n" +
"\t" + instance.Name + ".alpha_reset : " + Smv.False + ";\n";
string betaRule = "\t" + instance.Name + "_" + Smv.Beta + " : " + Smv.False + ";\n" +
"\t" + instance.Name + ".beta_set : " + Smv.True + ";\n";
mainModule += String.Format(Smv.NextCaseBlock, instance.Name + "_" + Smv.Alpha, alphaRule);
mainModule += String.Format(Smv.NextCaseBlock, instance.Name + "_" + Smv.Beta, betaRule);
//**********************
//mainModule += FbSmvCommon.ModuleFooter(_settings) + "\n";
if (_settings.GenerateDummyProperty)
{
mainModule += "\nLTLSPEC F false_var=TRUE";
}
return(mainModule);
}
