public PrtSpecMachine(StateImpl app) : base()
{
observes = new List <PrtEventValue>();
currentTemperature = StateTemperature.Warm;
stateImpl = app;
//Push the start state function on the funStack.
PrtPushState(StartState);
}
public PrtState(string name, PrtFun entryFun, PrtFun exitFun, bool hasNullTransition, StateTemperature temperature)
{
this.name = name;
this.entryFun = entryFun;
this.exitFun = exitFun;
this.transitions = new Dictionary <PrtValue, PrtTransition>();
this.dos = new Dictionary <PrtValue, PrtFun>();
this.hasNullTransition = hasNullTransition;
this.temperature = temperature;
}
public PrtSpecMachine(StateImpl app) : base()
{
observes = new List <PrtEventValue>();
currentTemperature = StateTemperature.Warm;
stateImpl = app;
//Push the start state function on the funStack.
PrtPushState(StartState);
//Execute the entry function
PrtEnqueueEvent(PrtValue.@null, PrtValue.@null, null);
}
public StateInfo(string ownerName, string entryActionName, string exitFunName, StateTemperature temperature, string printedName)
{
this.ownerName = ownerName;
this.entryActionName = entryActionName;
this.exitFunName = exitFunName;
this.hasNullTransition = false;
this.transitions = new Dictionary <string, TransitionInfo>();
this.dos = new Dictionary <string, string>();
this.deferredEvents = new List <string>();
this.temperature = temperature;
this.printedName = printedName;
}
public Main_Init_Class(string name, PrtFun entryFun, PrtFun exitFun, bool hasNullTransition, StateTemperature temperature) : base(name, entryFun, exitFun, hasNullTransition, temperature)
{
}
public override void PrtEnqueueEvent(PrtValue e, PrtValue arg, PrtMachine source, PrtMachineValue target = null)
{
int numOfStepsTaken = 0;
// set the currentTrigger and currentPayload fields
// so that we can reuse the common functions
currentPayload = arg.Clone();
currentTrigger = e;
PrtValue currEventValue;
PrtFun currAction;
bool hasMoreWork = false;
try
{
Start:
switch (nextSMOperation)
{
case PrtNextStatemachineOperation.ExecuteFunctionOperation:
goto DoExecuteFunction;
case PrtNextStatemachineOperation.HandleEventOperation:
goto DoHandleEvent;
}
DoExecuteFunction:
if (invertedFunStack.TopOfStack == null)
{
//Trace: entered state
PrtFun entryFun = CurrentState.entryFun;
if (entryFun.IsAnonFun)
{
PrtPushFunStackFrame(entryFun, entryFun.CreateLocals(currentPayload));
}
else
{
PrtPushFunStackFrame(entryFun, entryFun.CreateLocals());
}
}
//invoke the function
invertedFunStack.TopOfStack.fun.Execute(stateImpl, this);
goto CheckFunLastOperation;
DoAction:
currAction = PrtFindActionHandler(eventValue);
if (currAction == PrtFun.IgnoreFun)
{
//Trace: Performed ignore action for the event
currentTrigger = PrtValue.@null;
currentPayload = PrtValue.@null;
}
else
{
if (invertedFunStack.TopOfStack == null)
{
//Trace: executed the action handler for event
if (currAction.IsAnonFun)
{
PrtPushFunStackFrame(currAction, currAction.CreateLocals(currentPayload));
}
else
{
PrtPushFunStackFrame(currAction, currAction.CreateLocals());
}
}
//invoke the action handler
invertedFunStack.TopOfStack.fun.Execute(stateImpl, this);
}
goto CheckFunLastOperation;
CheckFunLastOperation:
switch (continuation.reason)
{
case PrtContinuationReason.Goto:
{
stateExitReason = PrtStateExitReason.OnGotoStatement;
nextSMOperation = PrtNextStatemachineOperation.ExecuteFunctionOperation;
PrtPushExitFunction();
goto DoExecuteFunction;
}
case PrtContinuationReason.Raise:
{
nextSMOperation = PrtNextStatemachineOperation.HandleEventOperation;
hasMoreWork = true;
goto Finish;
}
case PrtContinuationReason.Return:
{
switch (stateExitReason)
{
case PrtStateExitReason.NotExit:
{
nextSMOperation = PrtNextStatemachineOperation.HandleEventOperation;
hasMoreWork = false;
goto Finish;
}
case PrtStateExitReason.OnGotoStatement:
{
PrtChangeState(destOfGoto);
currentTemperature = destOfGoto.temperature;
nextSMOperation = PrtNextStatemachineOperation.ExecuteFunctionOperation;
stateExitReason = PrtStateExitReason.NotExit;
hasMoreWork = true;
goto Finish;
}
case PrtStateExitReason.OnUnhandledEvent:
{
hasMoreWork = !PrtPopState(false);
nextSMOperation = PrtNextStatemachineOperation.HandleEventOperation;
stateExitReason = PrtStateExitReason.NotExit;
goto Finish;
}
case PrtStateExitReason.OnTransition:
{
stateExitReason = PrtStateExitReason.OnTransitionAfterExit;
nextSMOperation = PrtNextStatemachineOperation.ExecuteFunctionOperation;
PrtPushTransitionFun(eventValue);
goto DoExecuteFunction;
}
case PrtStateExitReason.OnTransitionAfterExit:
{
// The parameter to an anonymous transition function is always passed as swap.
// Update currentPayload to the latest value of the parameter so that the correct
// value gets passed to the entry function of the target state.
PrtTransition transition = CurrentState.transitions[eventValue];
PrtFun transitionFun = transition.transitionFun;
if (transitionFun.IsAnonFun)
{
currentPayload = continuation.retLocals[0];
}
PrtChangeState(transition.gotoState);
currentTemperature = transition.gotoState.temperature;
hasMoreWork = true;
nextSMOperation = PrtNextStatemachineOperation.ExecuteFunctionOperation;
stateExitReason = PrtStateExitReason.NotExit;
goto Finish;
}
default:
{
Debug.Assert(false, "Unexpected value for exit reason");
goto Finish;
}
}
}
default:
{
Debug.Assert(false, "Unexpected value for continuation reason");
goto Finish;
}
}
DoHandleEvent:
if (!currentTrigger.Equals(PrtValue.@null))
{
currEventValue = currentTrigger;
currentTrigger = PrtValue.@null;
}
else
{
currEventValue = eventValue;
}
if (PrtIsTransitionPresent(currEventValue))
{
stateExitReason = PrtStateExitReason.OnTransition;
nextSMOperation = PrtNextStatemachineOperation.ExecuteFunctionOperation;
eventValue = currEventValue;
PrtPushExitFunction();
goto DoExecuteFunction;
}
else if (PrtIsActionInstalled(currEventValue))
{
eventValue = currEventValue;
goto DoAction;
}
else
{
stateExitReason = PrtStateExitReason.OnUnhandledEvent;
nextSMOperation = PrtNextStatemachineOperation.ExecuteFunctionOperation;
eventValue = currEventValue;
PrtPushExitFunction();
goto DoExecuteFunction;
}
Finish:
if (hasMoreWork)
{
if (numOfStepsTaken > 100000)
{
throw new PrtInfiniteRaiseLoop("Infinite loop in spec machine");
}
else
{
numOfStepsTaken++;
goto Start;
}
}
else
{
return;
}
}
catch (PrtException ex)
{
stateImpl.Exception = ex;
}
}
public PrtSpecMachine() : base()
{
observes = new List <PrtEventValue>();
currentTemperature = StateTemperature.Warm;
}
public Timer_WaitForCancel_Class(string name, PrtFun entryFun, PrtFun exitFun, bool hasNullTransition, StateTemperature temperature) : base(name, entryFun, exitFun, hasNullTransition, temperature)
{
}
public PONG_Pong_WaitPing_Class(string name, PrtFun entryFun, PrtFun exitFun, bool hasNullTransition, StateTemperature temperature) : base(name, entryFun, exitFun, hasNullTransition, temperature)
{
}
public UserMachine_S1_Class(string name, PrtFun entryFun, PrtFun exitFun, bool hasNullTransition, StateTemperature temperature) : base(name, entryFun, exitFun, hasNullTransition, temperature)
{
}
public StatementSyntax MkStateInstantiation(string stateName, string stateType, string entryFun, string exitFun,
bool hasNullTransition, StateTemperature temperature)
{
if (hasNullTransition)
{
if (temperature == StateTemperature.WARM)
{
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(stateName),
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(stateType))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("\"" + stateName + "\"")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(entryFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(exitFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.TrueLiteralExpression)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("StateTemperature"),
SyntaxFactory.IdentifierName("Warm")))
})))))
.NormalizeWhitespace());
}
else if (temperature == StateTemperature.HOT)
{
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(stateName),
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(stateType))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("\"" + stateName + "\"")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(entryFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(exitFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.TrueLiteralExpression)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("StateTemperature"),
SyntaxFactory.IdentifierName("Hot")))
})))))
.NormalizeWhitespace());
}
else
{
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(stateName),
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(stateType))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("\"" + stateName + "\"")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(entryFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(exitFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.TrueLiteralExpression)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("StateTemperature"),
SyntaxFactory.IdentifierName("Cold")))
})))))
.NormalizeWhitespace());
}
}
else
{
if (temperature == StateTemperature.WARM)
{
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(stateName),
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(stateType))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("\"" + stateName + "\"")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(entryFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(exitFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.FalseLiteralExpression)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("StateTemperature"),
SyntaxFactory.IdentifierName("Warm")))
})))))
.NormalizeWhitespace());
}
else if (temperature == StateTemperature.HOT)
{
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(stateName),
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(stateType))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("\"" + stateName + "\"")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(entryFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(exitFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.FalseLiteralExpression)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("StateTemperature"),
SyntaxFactory.IdentifierName("Hot")))
})))))
.NormalizeWhitespace());
}
else
{
return(SyntaxFactory.ExpressionStatement(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(stateName),
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName(stateType))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[] {
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName("\"" + stateName + "\"")),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(entryFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(exitFun)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.FalseLiteralExpression)),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("StateTemperature"),
SyntaxFactory.IdentifierName("Cold")))
})))))
.NormalizeWhitespace());
}
}
}
public POrbMachine_ReadMessagesAndPublish_Class(string name, PrtFun entryFun, PrtFun exitFun, bool hasNullTransition, StateTemperature temperature) : base(name, entryFun, exitFun, hasNullTransition, temperature)
{
}
