/// <summary>
/// Decompiles the method to an explicit state machine representation
/// </summary>
/// <returns>decopmiled method</returns>
public IDecompilationResult DecompileToFSM()
{
InitializeCFGs();
int numILStates = _stateCFGs.Length;
var design = _code.GetDesign();
var owner = _code.Owner as ComponentDescriptor;
var myps = _code as ProcessDescriptor;
// Decompile state handlers
_stateInfos = new Dictionary<StateInfo, StateInfo>();
var decomp = new MSILDecompiler(_code, _stateCFGs[1], _fsmInstance);
_curTempl = decomp.Template;
_curTempl.AddAttribute(this);
_curTempl.DisallowReturnStatements = true;
_curTempl.DisallowConditionals = true;
_curTempl.DisallowLoops = true;
var lvState = _curTempl.ExportLocalVariableState();
var startSI = new StateInfo(0);
foreach (var kvp in _locFields)
startSI.LVState[kvp.Key] = kvp.Value.Type.GetSampleInstance(ETypeCreationOptions.ForceCreation);
_stateInfos[startSI] = startSI;
_curSI = startSI;
var stateList = new List<StateInfo>();
stateList.Add(startSI);
_stateQ = new Queue<StateInfo>();
startSI.Result = decomp.Decompile();
while (_stateQ.Any())
{
var nextSI = _stateQ.Dequeue();
_curSI = nextSI.Fork(nextSI.ILState);
decomp = new MSILDecompiler(_code, _stateCFGs[nextSI.ILState + 1], _fsmInstance);
_curTempl = decomp.Template;
_curTempl.AddAttribute(this);
_curTempl.DisallowReturnStatements = true;
_curTempl.DisallowConditionals = true;
_curTempl.DisallowLoops = true;
_curSI.Result = decomp.Decompile();
stateList.Add(_curSI);
_stateInfos[_curSI] = _curSI;
}
// Create enumeration type for state
string prefix = _code.Name;
string enumName = "t_" + prefix + "_state";
var stateNames = new List<string>();
for (int i = 0; i < stateList.Count; i++)
{
string name;
if (stateList[i].HasWaitState)
{
name = enumName + "_await_" + i;
stateNames.Add(name);
}
name = enumName + "_" + i;
stateNames.Add(name);
}
int numStates = stateNames.Count;
Statement[] states;
SignalDescriptor stateSignal = null;
if (numStates > 1)
{
var enumType = design.CreateEnum(enumName, stateNames);
_stateValues = enumType.CILType.GetEnumValues();
var enumDefault = _stateValues.GetValue(0);
int j = 0;
for (int i = 0; i < stateList.Count; i++)
{
if (stateList[i].HasWaitState)
stateList[i].WaitStateValue = _stateValues.GetValue(j++);
stateList[i].StateValue = _stateValues.GetValue(j++);
}
// Create signals for state
string stateSignalName = prefix + "_state";
stateSignal = owner.CreateSignalInstance(stateSignalName, enumDefault);
_nextStateSignal = stateSignal;
// Implement state joins
states = new Statement[numStates];
j = 0;
for (int i = 0; i < stateList.Count; i++)
{
if (stateList[i].HasWaitState)
{
var wsb = new DefaultAlgorithmBuilder();
ImplementJoin(stateList[i].JP, wsb, stateList[i]);
var join = wsb.Complete();
states[j++] = join.Body;
}
states[j++] = stateList[i].Result.Decompiled.Body;
}
// Replace ProceedWithState calls with actual states
for (j = 0; j < states.Length; j++)
{
var orgBody = states[j];
var xform = new StateAssigner(this, orgBody);
var state = xform.GetAlgorithm();
states[j] = state.Body;
}
}
else
{
// Implement state joins
states = new Statement[1];
// Replace ProceedWithState calls with actual states
var xform = new StateAssigner(this, stateList[0].Result.Decompiled.Body, true);
var state = xform.GetAlgorithm();
states[0] = state.Body;
}
var calledMethods = stateList
.SelectMany(b => b.Result.CalledMethods)
.Distinct()
.ToList();
var calledSyncMethods = calledMethods
.Where(mci => !mci.Method.IsAsync())
.ToList();
var referencedFields = stateList
.SelectMany(b => b.Result.ReferencedFields)
.Distinct()
.ToList();
var referencedLocals = stateList
.SelectMany(b => b.Result.Decompiled.LocalVariables)
.Distinct();
_coFSMs = DecompileCoFSMs(calledMethods);
// Extract clock edge
var predFunc = _context.CurrentProcess.Predicate;
var predInstRef = LiteralReference.CreateConstant(predFunc.Target);
var arg = new StackElement(predInstRef, predFunc.Target, EVariability.ExternVariable);
var edge = _curTempl.GetCallExpression(predFunc.Method, arg).Expr;
// Synchronous process
var alg = new DefaultAlgorithmBuilder();
foreach (var v in referencedLocals)
{
alg.DeclareLocal(v);
}
alg.If(edge);
// Co state machines
foreach (var cofsm in _coFSMs.Order)
{
foreach (var argv in cofsm.Arguments)
alg.DeclareLocal(argv);
alg.DeclareLocal(cofsm.DoneVar);
if (cofsm.ResultVar != null)
alg.DeclareLocal(cofsm.ResultVar);
_curCoFSM = cofsm;
var weaver = new StateWeaver(this, cofsm.HandlerBody);
alg.InlineCall(weaver.GetAlgorithm().Body);
}
// Main state machine switch statement
if (numStates > 1)
{
var switchStmt = alg.Switch(
SignalRef.Create(stateSignal, SignalRef.EReferencedProperty.Cur));
{
for (int i = 0; i < states.Length; i++)
{
var stateValue = _stateValues.GetValue(i);
alg.Case(LiteralReference.CreateConstant(stateValue));
var weaver = new StateWeaver(this, states[i]);
alg.InlineCall(weaver.GetAlgorithm().Body);
alg.Break(switchStmt);
alg.EndCase();
}
}
alg.EndSwitch();
}
else
{
var weaver = new StateWeaver(this, states[0]);
alg.InlineCall(weaver.GetAlgorithm().Body);
}
alg.EndIf();
var syncPS = alg.Complete();
syncPS.Name = prefix + "$sync";
myps.Kind = Process.EProcessKind.Triggered;
myps.Sensitivity = new ISignalOrPortDescriptor[] { ((SignalBase)predFunc.Target).Descriptor };
return new Result(syncPS, calledSyncMethods, referencedFields);
}
