public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
bool bRet = false;
if (_list != null)
{
ActionBranch p = previousAction;
ActionBranch n;
_list.ResetBeforeCompile();
for (int i = 0, j = 1; i < _list.Count; i++, j++) //ActionBranch a in _list)
{
if (j < _list.Count)
{
n = _list[j];
}
else
{
n = nextAction;
}
if (!_list[i].IsCompiled)
{
bRet = _list[i].ExportCode(p, n, compiler, method, statements);
}
p = _list[i];
}
}
return(bRet);
}
public override void OnExportClientServerCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements,
StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
if (_actionList != null)
{
int last = _actionList.Count - 1;
for (int k = 0; k < _actionList.Count; k++)
{
if (_actionList[k].Action != null)
{
ActionBranch nt = null;
if (k == last)
{
nt = nextAction;
if (nt != null && nt.UseInput)
{
nt.InputName = this.OutputCodeName;
nt.InputType = this.OutputType;
nt.SetInputName(OutputCodeName, OutputType);
}
}
_actionList[k].Action.ExportJavaScriptCode(this, nt, jsCode, methodCode, data);
}
}
}
}
public override void VisitBranch(ActionBranch output)
{
var branchMethod = new CodeMemberMethod()
{
ReturnType = !DebugSystem.IsDebugMode ? new CodeTypeReference(typeof(void)) : new CodeTypeReference(typeof(IEnumerator)),
Name = output.VariableName
};
_.PushStatements(branchMethod.Statements);
var actionNode = output.Node as ActionNode;
if (actionNode != null)
{
actionNode.WriteActionOutputs(_);
}
base.VisitBranch(output);
if (DebugSystem.IsDebugMode)
{
_._("yield break");
}
_.PopStatements();
_.CurrentDeclaration.Members.Add(branchMethod);
}
public override bool OnExportPhpScriptCode(ActionBranch previousAction, ActionBranch nextAction, StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
bool bRet = false;
if (_actionList != null)
{
int last = _actionList.Count - 1;
for (int k = 0; k < _actionList.Count; k++)
{
if (_actionList[k].Action != null)
{
bRet = _actionList[k].Action.IsMethodReturn;
ActionBranch nt = null;
if (k == last)
{
nt = nextAction;
if (nt != null && nt.UseInput)
{
nt.InputName = this.OutputCodeName;
nt.InputType = this.OutputType;
nt.SetInputName(OutputCodeName, OutputType);
}
}
_actionList[k].Action.ExportPhpScriptCode(this, nt, jsCode, methodCode, data);
}
}
}
return(bRet);
}
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
bool bRet = false;
if (_actionList != null)
{
int last = _actionList.Count - 1;
for (int k = 0; k < _actionList.Count; k++)
{
if (_actionList[k].Action != null)
{
bRet = _actionList[k].Action.IsMethodReturn;
ActionBranch nt = null;
if (k == last)
{
nt = nextAction;
if (nt != null && nt.UseInput)
{
nt.InputName = this.OutputCodeName;
nt.InputType = this.OutputType;
nt.SetInputName(OutputCodeName, OutputType);
}
}
_actionList[k].Action.ExportCode(this, nt, compiler, this.Method, method, statements, compiler.Debug);
}
}
}
return(bRet);
}
public override ActionBranch SearchBranchById(UInt32 branchId)
{
ActionBranch ab = base.SearchBranchById(branchId);
if (ab != null)
{
return(ab);
}
if (_ifActions != null)
{
ab = _ifActions.SearchBranchById(branchId);
if (ab != null)
{
return(ab);
}
}
if (_elseActions != null)
{
ab = _elseActions.SearchBranchById(branchId);
if (ab != null)
{
return(ab);
}
}
return(null);
}
public override bool OnExportPhpScriptCode(ActionBranch previousAction, ActionBranch nextAction, StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
bool bRet = false;
if (_list != null)
{
ActionBranch p = previousAction;
ActionBranch n;
_list.ResetBeforeCompile();
for (int i = 0, j = 1; i < _list.Count; i++, j++) //ActionBranch a in _list)
{
if (j < _list.Count)
{
n = _list[j];
}
else
{
n = nextAction;
}
if (!_list[i].IsCompiled)
{
bRet = _list[i].ExportPhpScriptCode(p, n, jsCode, methodCode, data);
}
p = _list[i];
}
}
return(bRet);
}
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
ClassPointer list = compiler.ActionEventList;
if (list != null)
{
if (_actionData == null)
{
_actionData = _actId.LoadActionInstance(this.ActionsHolder);
}
}
if (_actionData != null)
{
//link both actions
if (nextAction != null)
{
if (!string.IsNullOrEmpty(OutputCodeName) && OutputType != null && !OutputType.IsVoid)
{
nextAction.InputName = OutputCodeName;
nextAction.InputType = OutputType;
nextAction.SetInputName(OutputCodeName, OutputType);
}
}
if (_actionData.ActionMethod != null && _actionData.ActionMethod.IsValid)
{
_actionData.ExportCode(this, nextAction, compiler, this.Method, method, statements, compiler.Debug);
}
if (_actionData.IsMethodReturn)
{
return(true);
}
return(this.IsMethodReturn);
}
return(false);
}
public override void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, System.CodeDom.CodeMemberMethod method, System.CodeDom.CodeStatementCollection statements, bool debug)
{
IMathExpression mathExp = MathExp;
if (mathExp != null)
{
CodeExpression ceCondition = null;
if (Condition != null)
{
ceCondition = Condition.ExportCode(methodToCompile);
if (ceCondition != null)
{
ceCondition = CompilerUtil.ConvertToBool(Condition.DataType, ceCondition);
}
}
CodeExpression ce = mathExp.ReturnCodeExpression(methodToCompile);
if (ce != null)
{
if (ceCondition == null)
{
statements.Add(new CodeMethodReturnStatement(ce));
}
else
{
CodeConditionStatement cd = new CodeConditionStatement();
cd.Condition = ceCondition;
cd.TrueStatements.Add(new CodeMethodReturnStatement(ce));
statements.Add(cd);
}
}
}
}
public override bool OnExportPhpScriptCode(ActionBranch currentAction, ActionBranch nextAction, StringCollection jsCode, StringCollection methodToCompile, JsMethodCompiler data)
{
ClassPointer list = data.ActionEventList;
if (list != null && _actId != null)
{
_actionData = _actId.LoadActionInstance(this.ActionsHolder);
}
if (_actionData != null)
{
//link both actions
if (nextAction != null)
{
if (!string.IsNullOrEmpty(OutputCodeName) && OutputType != null && !OutputType.IsVoid)
{
nextAction.InputName = OutputCodeName;
nextAction.InputType = OutputType;
nextAction.SetInputName(OutputCodeName, OutputType);
}
}
if (_actionData.ActionMethod != null && _actionData.ActionMethod.IsValid)
{
_actionData.ExportPhpScriptCode(this, nextAction, jsCode, methodToCompile, data);
}
if (_actionData.IsMethodReturn)
{
return(true);
}
return(this.IsMethodReturn);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="previousAction"></param>
/// <param name="nextAction"></param>
/// <param name="compiler"></param>
/// <param name="method"></param>
/// <param name="statements"></param>
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
string indexName = RepeatIndex.CodeName;
CodeExpression c = new CodeBinaryOperatorExpression(new CodeVariableReferenceExpression(indexName), CodeBinaryOperatorType.LessThan, RepeatCount.GetReferenceCode(Method, statements, true));
CodeIterationStatement cis = new CodeIterationStatement();
cis.TestExpression = c;
cis.InitStatement = new CodeVariableDeclarationStatement(typeof(int), indexName, new CodePrimitiveExpression(0));
cis.IncrementStatement = new CodeSnippetStatement(indexName + "++");
statements.Add(cis);
if (_iconList != null)
{
foreach (ComponentIcon ci in _iconList)
{
ComponentIconLocal cil = ci as ComponentIconLocal;
if (cil != null && cil.ScopeGroupId == this.BranchId)
{
cil.LocalPointer.AddVariableDeclaration(cis.Statements);
}
}
}
SetWithinLoop();
Method.SubMethod.Push(this);
CompilerUtil.AddSubMethod(method, this);
bool bRet = base.OnExportCode(previousAction, nextAction, compiler, method, cis.Statements);
Method.SubMethod.Pop();
bRet = CompilerUtil.FinishSubMethod(method, this, cis.Statements, bRet);
return(bRet);
}
public void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, bool debug)
{
if (IsValid)
{
CodeExpression ceCondition = null;
if (_condition != null)
{
ceCondition = _condition.ExportCode(methodToCompile);
if (ceCondition != null)
{
ceCondition = CompilerUtil.ConvertToBool(_condition.DataType, ceCondition);
}
}
CodeStatementCollection sts = statements;
if (ceCondition != null)
{
CodeConditionStatement cs = new CodeConditionStatement();
cs.Condition = ceCondition;
statements.Add(cs);
sts = cs.TrueStatements;
}
CodeExpression right;
if (_valType.ValueType == EnumValueType.ConstantValue)
{
right = _val.GetReferenceCode(methodToCompile, sts, true);
}
else
{
List <CodeExpression> ps = new List <CodeExpression>();
ps.Add(_valType.GetReferenceCode(methodToCompile, sts, true));
if (_val.ConstantValue != null)
{
CodeExpression[] pp = _val.ConstantValue.GetConstructorParameters(methodToCompile, sts);
if (pp != null)
{
ps.AddRange(pp);
}
}
right = new CodeCastExpression(_var.BaseClassType,
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Activator)),
"CreateInstance",
ps.ToArray())
);
}
CodeExpression left = _var.GetReferenceCode(methodToCompile, sts, false);
CodeVariableReferenceExpression cvre = left as CodeVariableReferenceExpression;
CodeSnippetExpression cse = right as CodeSnippetExpression;
if (cvre != null && cse != null && string.CompareOrdinal(cse.Value, string.Format(CultureInfo.InvariantCulture, "{0}++", cvre.VariableName)) == 0)
{
CodeExpressionStatement ces = new CodeExpressionStatement(right);
sts.Add(ces);
}
else
{
CodeAssignStatement cas = new CodeAssignStatement(left, right);
sts.Add(cas);
}
}
}
/// <summary>
/// generate code:
/// if( {event name} != null)
/// {
/// {event name}(parameters);
/// }
/// </summary>
/// <param name="compiler"></param>
/// <param name="methodToCompile"></param>
/// <param name="method"></param>
/// <param name="statements"></param>
/// <param name="debug"></param>
public void Compile(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, CodeExpressionCollection parameters, IObjectPointer returnReceiver, bool debug)
{
CodeConditionStatement cs = new CodeConditionStatement();
cs.Condition = new CodeBinaryOperatorExpression(
_event.GetReferenceCode(methodToCompile, statements, true), CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null));
CodeMethodInvokeExpression cme = new CodeMethodInvokeExpression();
if (_event.IsStatic || (_event.Declarer != null && _event.Declarer.IsStatic))
{
if (parameters != null && parameters.Count > 0)
{
CodeTypeReferenceExpression sender = parameters[0] as CodeTypeReferenceExpression;
if (sender != null)
{
if (string.CompareOrdinal(sender.Type.BaseType, _event.Owner.TypeString) == 0)
{
parameters[0] = new CodeTypeOfExpression(sender.Type.BaseType);
}
}
}
cme.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(_event.Owner.TypeString), _event.Name);
}
else
{
cme.Method = new CodeMethodReferenceExpression(_event.Owner.GetReferenceCode(methodToCompile, statements, false), _event.Name);
}
if (parameters != null)
{
cme.Parameters.AddRange(parameters);
}
cs.TrueStatements.Add(cme);
statements.Add(cs);
}
public override void InitializeBranches(BranchList branches)
{
if (_ifJumpToId != 0)
{
if (_ifActions == null)
{
_ifActions = branches.GetJumpToActionBranch(_ifJumpToId);
if (_ifActions == null)
{
throw new DesignerException("Action for True branch not found (id={0})", _ifJumpToId);
}
}
}
else
{
_ifActions = null;
}
if (_elseJumpToId != 0)
{
if (_elseActions == null)
{
_elseActions = branches.GetJumpToActionBranch(_elseJumpToId);
if (_elseActions == null)
{
throw new DesignerException("Action for False branch not found (id={0})", _elseJumpToId);
}
}
}
else
{
_elseActions = null;
}
}
public void Compile(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, bool debug)
{
CodeAssignStatement cas = new CodeAssignStatement();
cas.Left = SetProperty.GetReferenceCode(methodToCompile);
if (cas.Left == null)
{
compiler.AddError("Error: CustomSetter missing property");
}
else
{
CodeExpression rt = Value.GetReferenceCode(methodToCompile);
CodeMethodReferenceExpression cmr = rt as CodeMethodReferenceExpression;
if (cmr != null)
{
rt = new CodeMethodInvokeExpression(cmr);
}
if (nextAction != null && nextAction.UseInput)
{
CodeVariableDeclarationStatement output = new CodeVariableDeclarationStatement(
currentAction.OutputType.TypeString, currentAction.OutputCodeName, rt);
statements.Add(output);
rt = new CodeVariableReferenceExpression(currentAction.OutputCodeName);
}
cas.Right = rt;
statements.Add(cas);
}
}
public ActionBranchParameter(Type type, string name, ActionBranch branch)
: base(type, name, branch.Method)
{
_actionBranch = branch;
this.ParameterID = branch.BranchId;
AllowTypeChange = false;
}
/// <summary>
/// before executing an action in a method.
/// it can be called from different threads
/// </summary>
/// <param name="objectKey">ObjectKey of the owner of the method</param>
/// <param name="methodWholeId">method id</param>
/// <param name="branchId">action branch id of the action to be executed</param>
/// <param name="executer">object instance executing the method</param>
public void BeforeExecuteAction(string objectKey, UInt64 methodWholeId, UInt32 branchId, object executer)
{
if (_ComponentDebugger.Stopping)
{
return;
}
int threadId = System.Threading.Thread.CurrentThread.ManagedThreadId;
_ComponentDebugger.IncrementStackLevel(threadId);
//check if it is at a break point
MethodClass mc = _ComponentDebugger.GetMethod(methodWholeId);
if (mc != null)
{
//MethodClass mc = mc0.Clone() as MethodClass;
IActionGroup g = mc;
ActionBranch branch = mc.GetBranchByIdInGroup(branchId, ref g);
if (branch != null)
{
if (_ComponentDebugger.ShouldBreak(threadId) || branch.BreakBeforeExecute)
{
_ComponentDebugger.SetSelectedObject(executer);
_ComponentDebugger.SetAtBreak(threadId, true);
_debugUI.ShowBreakPoint(_ComponentDebugger);
branch.AtBreak = EnumActionBreakStatus.Before;
_ComponentDebugger.ShowBreakPointInMethod(threadId, mc, g, branch);
waitForBreakPoint(threadId);
}
}
}
}
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
if (_decisionTable != null)
{
CodeConditionStatement ccs = null;
for (int i = 0; i < _decisionTable.ConditionCount; i++)
{
_decisionTable[i].Condition.PrepareForCompile(this.Method);
CodeExpression c = _decisionTable[i].Condition.ExportCode(this.Method);
if (ccs == null)
{
ccs = new CodeConditionStatement();
statements.Add(ccs);
}
else
{
CodeConditionStatement ccs2 = new CodeConditionStatement();
ccs.FalseStatements.Add(ccs2);
ccs = ccs2;
}
ccs.Condition = c;
if (_decisionTable[i].Actions != null)
{
for (int k = 0; k < _decisionTable[i].Actions.Count; k++)
{
verifyActionObj(k, i);
_decisionTable[i].Actions[k].Action.ExportCode(this, nextAction, compiler, this.Method, method, ccs.TrueStatements, compiler.Debug);
}
}
}
}
return(false);
}
protected override void OnVerifyJump(BranchList branch)
{
if (_jumpToId == 0)
{
List <ActionPortOut> aos = OutPortList;
if (aos != null && aos.Count > 0)
{
if (aos[0].LinkedInPort != null)
{
ActionBranch ab = aos[0].LinkedInPort.PortOwner as ActionBranch;
if (ab != null)
{
_jumpToId = ab.BranchId;
_jumpToActionBranch = ab;
}
}
}
}
else
{
if (_jumpToId == FirstActionId)
{
_jumpToId = 0;
}
}
}
protected override void OnVerifyJump(BranchList branch)
{
if (_ifJumpToId == 0)
{
if (OutPortList[0].LinkedInPort != null)
{
ActionBranch ab = OutPortList[0].LinkedInPort.PortOwner as ActionBranch;
if (ab != null)
{
_ifJumpToId = ab.BranchId;
_ifActions = ab;
}
}
}
if (_elseJumpToId == 0)
{
if (OutPortList[1].LinkedInPort != null)
{
ActionBranch ab = OutPortList[1].LinkedInPort.PortOwner as ActionBranch;
if (ab != null)
{
_elseJumpToId = ab.BranchId;
_elseActions = ab;
}
}
}
}
public override void ExportJavaScriptCode(ActionBranch currentAction, ActionBranch nextAction, StringCollection jsCode, StringCollection methodToCompile, JsMethodCompiler data)
{
IMathExpression mathExp = MathExp;
if (mathExp != null)
{
string ce = mathExp.ReturnJavaScriptCodeExpression(methodToCompile);
if (!string.IsNullOrEmpty(ce))
{
string target = null;
string output = null;
if (nextAction != null)
{
if (nextAction.UseInput)
{
methodToCompile.Add("var ");
methodToCompile.Add(currentAction.OutputCodeName);
methodToCompile.Add("=");
methodToCompile.Add(ce);
methodToCompile.Add(";\r\n");
output = currentAction.OutputCodeName;
}
}
IVariable v = mathExp.OutputVariable;
if (v != null)
{
string ceCondition = null;
if (Condition != null)
{
ceCondition = Condition.CreateJavaScriptCode(methodToCompile);
}
target = v.ExportJavaScriptCode(methodToCompile);
string jsLine;
if (output != null)
{
jsLine = string.Format(System.Globalization.CultureInfo.InvariantCulture,
"{0}={1};\r\n", target, currentAction.OutputCodeName);
}
else
{
jsLine = string.Format(System.Globalization.CultureInfo.InvariantCulture,
"{0}={1};\r\n", target, ce);
}
if (string.IsNullOrEmpty(ceCondition))
{
methodToCompile.Add(jsLine);
}
else
{
methodToCompile.Add("if(");
methodToCompile.Add(ceCondition);
methodToCompile.Add(")\r\n{\r\n");
methodToCompile.Add(jsLine);
methodToCompile.Add("\r\n}\r\n");
}
}
}
}
}
public override bool OnExportCode(ActionBranch previousAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, CodeMemberMethod method, CodeStatementCollection statements)
{
if (_eventAction != null)
{
_eventAction.AttachCodeDomAction(this.Method, statements, false);
}
return(false);
}
public override bool OnExportJavaScriptCode(ActionBranch previousAction, ActionBranch nextAction, StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
if (_eventAction != null)
{
_eventAction.AttachJavascriptAction(this.BranchId, methodCode, Indentation.GetIndent());
}
return(false);
}
public override bool OnExportJavaScriptCode(ActionBranch previousAction, ActionBranch nextAction, StringCollection jsCode, StringCollection methodCode, JsMethodCompiler data)
{
if (_nextAction != null && _nextAction.FirstActionBranch != null && _nextAction.FirstActionBranch.InPortCount < 2)
{
return(_nextAction.OnExportJavaScriptCode(previousAction, nextAction, jsCode, methodCode, data));
}
return(false);
}
public virtual void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, bool debug)
{
loadEventAction();
if (_eventAction != null)
{
_eventAction.AttachCodeDomAction(methodToCompile, statements, debug);
}
}
public override void MakePortLinkForSingleThread(List <UInt32> used, BranchList branch)
{
ActionBranch ai = FirstAction;
if (ai != null)
{
ai.MakePortLinkForSingleThread(used, branch);
}
}
public override void ExportCode(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, bool debug)
{
IMathExpression mathExp = MathExp;
if (mathExp != null)
{
CodeExpression ceCondition = null;
if (Condition != null)
{
ceCondition = Condition.ExportCode(methodToCompile);
if (ceCondition != null)
{
ceCondition = CompilerUtil.ConvertToBool(Condition.DataType, ceCondition);
}
}
CodeExpression ce = mathExp.ReturnCodeExpression(methodToCompile);
if (ce != null)
{
CodeExpression target = null;
CodeVariableDeclarationStatement output = null;
if (nextAction != null)
{
if (nextAction.UseInput)
{
output = new CodeVariableDeclarationStatement(currentAction.OutputType.TypeString, currentAction.OutputCodeName, ce);
statements.Add(output);
}
}
IVariable v = mathExp.OutputVariable;
if (v != null)
{
CodeStatement cs;
target = v.ExportCode(methodToCompile);
if (output != null)
{
cs = new CodeAssignStatement(target, new CodeVariableReferenceExpression(currentAction.OutputCodeName));
}
else
{
cs = new CodeAssignStatement(target, ce);
}
if (ceCondition == null)
{
statements.Add(cs);
}
else
{
CodeConditionStatement cd = new CodeConditionStatement();
cd.Condition = ceCondition;
cd.TrueStatements.Add(cs);
statements.Add(cd);
}
}
}
}
}
public override ActionPortIn GetActionInport(List <UInt32> used, UInt32 portId, UInt32 portInstanceId)
{
ActionBranch ai = FirstAction;
if (ai != null)
{
return(ai.GetActionInport(used, portId, portInstanceId));
}
return(null);
}
public static bool FinishActionGroup(CodeMemberMethod method, CodeStatementCollection statements, UInt32 groupId, bool completed)
{
if (method.UserData.Contains(GOTOBRANCHES_Group))
{
Dictionary <UInt32, Dictionary <UInt32, MethodSegment> > groups = (Dictionary <UInt32, Dictionary <UInt32, MethodSegment> >)method.UserData[GOTOBRANCHES_Group];
if (groups != null)
{
Dictionary <UInt32, MethodSegment> gotoBranches;
if (groups.TryGetValue(groupId, out gotoBranches))
{
if (gotoBranches != null && gotoBranches.Count > 0)
{
string lb = "L_" + Guid.NewGuid().GetHashCode().ToString("x");
bool bUseLabel = false;
if (!completed)
{
//if the last method code is not a return then add a default method return
//if at least one of the branches in the method (not including goBranches) is not ended (method return or go to)
//addDefaultMethodReturn(mc, mm.Statements);
bUseLabel = true;
statements.Add(new CodeGotoStatement(lb));
}
foreach (KeyValuePair <UInt32, MethodSegment> kv in gotoBranches)
{
//if the last statement for this gotoBranch is not a method return then add a default one
if (!kv.Value.Completed)
{
bUseLabel = true;
kv.Value.Statements.Add(new CodeGotoStatement(lb));
}
//append the label to the end of method code
statements.Add(new CodeLabeledStatement(ActionBranch.IdToLabel(kv.Key)));
if (kv.Value.Statements.Count == 0)
{
statements.Add(new CodeSnippetStatement(";"));
}
//append the staments belonging to this gotoBranch to the end of the method
for (int i = 0; i < kv.Value.Statements.Count; i++)
{
statements.Add(kv.Value.Statements[i]);
}
}
if (bUseLabel)
{
statements.Add(new CodeLabeledStatement(lb));
statements.Add(new CodeSnippetStatement(";"));
}
}
}
}
}
return(completed);
}
public void Compile(ActionBranch currentAction, ActionBranch nextAction, ILimnorCodeCompiler compiler, IMethodCompile methodToCompile, CodeMemberMethod method, CodeStatementCollection statements, CodeExpressionCollection parameters, IObjectPointer returnReceiver, bool debug)
{
if (_dataTransfers != null)
{
foreach (KeyValuePair <IProperty, ParameterValue> kv in _dataTransfers)
{
if (kv.Value != null && kv.Key != null)
{
MethodDataTransfer.Compile(kv.Key, kv.Value.GetReferenceCode(methodToCompile, statements, true), currentAction, nextAction, compiler, methodToCompile, method, statements, parameters, returnReceiver, debug);
}
}
}
}
public override void VisitBranch(ActionBranch output)
{
var branchMethod = new CodeMemberMethod()
{
ReturnType = !DebugSystem.IsDebugMode ? new CodeTypeReference(typeof(void)) : new CodeTypeReference(typeof(IEnumerator)),
Name = output.VariableName
};
_.PushStatements(branchMethod.Statements);
var actionNode = output.Node as ActionNode;
if (actionNode != null)
{
actionNode.WriteActionOutputs(_);
}
base.VisitBranch(output);
if (DebugSystem.IsDebugMode)
_._("yield break");
_.PopStatements();
_.CurrentDeclaration.Members.Add(branchMethod);
}
public override void VisitBranch(ActionBranch output)
{
var branchMethod = new CodeMemberMethod()
{
ReturnType = !DebugSystem.IsDebugMode ? new CodeTypeReference(typeof(void)) : new CodeTypeReference(typeof(IEnumerator)),
Name = output.VariableName
};
_.PushStatements(branchMethod.Statements);
var actionNode = output.Node as ActionNode;
if (actionNode != null)
{
actionNode.WriteActionOutputs(_);
}
if (output.ActionFieldInfo != null && output.ActionFieldInfo.IsBranch)
{
foreach (var item in output.ActionFieldInfo.DelegateMembers)
{
branchMethod.Parameters.Add(new CodeParameterDeclarationExpression(item.MemberType.FullName, item.MemberName));
if (actionNode != null)
_._("{0}_{1} = {1}", actionNode.VariableName, item.MemberName);
}
}
base.VisitBranch(output);
if (DebugSystem.IsDebugMode)
_._("yield break");
var branchesChildItem = output.OutputTo<BranchesChildItem>();
if (branchesChildItem != null)
{
_._("{0}()", branchesChildItem.Name);
}
_.PopStatements();
_.CurrentDeclaration.Members.Add(branchMethod);
}
public virtual void VisitBranch(ActionBranch output)
{
var item = output.OutputTo<SequenceItemNode>();
if (item != null)
{
Visit(item);
}
}
public virtual void AfterVisitBranch(ActionBranch actionBranch)
{
}
public virtual void BeforeVisitBranch(ActionBranch actionBranch)
{
}
