public void SetUp() { pureDataFacadeMock_ = Substitute.For <IPureDataFacade>(); controllerStateFactoryMock_ = Substitute.For <IControllerStateFactory>(); controllerStateFactoryMock_.CreateCarrierState(pureDataFacadeMock_).Returns(carrierStateMock_); controllerStateFactoryMock_.CreateModulatorState(pureDataFacadeMock_).Returns(modulatorStateMock_); stateAssigner_ = new StateAssigner(pureDataFacadeMock_, controllerStateFactoryMock_); }
/// <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); }