/// <summary>
/// http://lua-users.org/wiki/ContinueProposal
/// </summary>
/// <param name="block"></param>
private static void EmitBeginContinue(AbstractEmitterBlock block)
{
block.WriteVar(true);
block.Write("continue");
block.WriteNewLine();
block.BeginBlock("repeat");
}
public static bool HasContinue(AbstractEmitterBlock block, AstNode node) {
var visitor = new ContinueSearchVisitor();
node.AcceptVisitor(visitor);
bool has = visitor.Found;
if(has) {
EmitBeginContinue(block);
}
return has;
}
public static void EmitYield(AbstractEmitterBlock block, IType returnType)
{
block.WriteReturn(true);
block.Write(LuaHelper.Root + ".yieldEnumerator");
block.WriteOpenParentheses();
block.WriteFunction();
block.WriteOpenCloseParentheses();
block.BeginFunctionBlock();
}
public static void EmitYield(AbstractEmitterBlock block, IType returnType)
{
block.WriteReturn(true);
block.Write(LuaHelper.Root + ".yieldEnumerator");
block.WriteOpenParentheses();
block.WriteFunction();
block.WriteOpenCloseParentheses();
block.BeginFunctionBlock();
}
public static void EmitEndContinue(AbstractEmitterBlock block)
{
block.Write("continue = true");
block.WriteNewLine();
block.Outdent();
block.Write("until 1");
block.WriteNewLine();
block.Write("if not continue then break end");
block.WriteNewLine();
}
public static string ReplaceInlineArgs(AbstractEmitterBlock block, string inline, Expression[] args)
{
var emitter = block.Emitter;
inline = _formatArg.Replace(inline, delegate(Match m)
{
int count = emitter.Writers.Count;
string separate = m.Groups[1].Value;
string key = m.Groups[3].Value;
string modifier = m.Groups[2].Success ? m.Groups[5].Value : null;
StringBuilder oldSb = emitter.Output;
emitter.Output = new StringBuilder();
Expression expr = null;
if (Regex.IsMatch(key, "^\\d+$"))
{
expr = args.Skip(int.Parse(key)).FirstOrDefault();
}
else
{
expr = args.FirstOrDefault(e => e.ToString() == key);
}
string s = "";
if (expr != null)
{
var writer = block.SaveWriter();
block.NewWriter();
expr.AcceptVisitor(emitter);
s = emitter.Output.ToString();
block.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
block.Write(block.WriteIndentToString(s));
if (emitter.Writers.Count != count)
{
block.PopWriter();
}
string replacement = emitter.Output.ToString();
emitter.Output = oldSb;
return(replacement);
});
return(inline);
}
public static void EmitYield(AbstractEmitterBlock block, IType returnType, MethodDeclaration methodDeclaration)
{
block.WriteReturn(true);
block.Write(LuaHelper.Root, ".yield", returnType.Name);
block.WriteOpenParentheses();
block.WriteFunction();
block.WriteOpenParentheses();
AbstractMethodBlock.EmitMethodParameters(block, methodDeclaration.Parameters, methodDeclaration);
block.WriteCloseParentheses();
block.BeginFunctionBlock();
}
public static string ReplaceInlineArgs(AbstractEmitterBlock block, string inline, Expression[] args)
{
var emitter = block.Emitter;
inline = _formatArg.Replace(inline, delegate(Match m)
{
int count = emitter.Writers.Count;
string key = m.Groups[2].Value;
string modifier = m.Groups[1].Success ? m.Groups[4].Value : null;
StringBuilder oldSb = emitter.Output;
emitter.Output = new StringBuilder();
Expression expr = null;
if (Regex.IsMatch(key, "^\\d+$"))
{
expr = args.Skip(int.Parse(key)).FirstOrDefault();
}
else
{
expr = args.FirstOrDefault(e => e.ToString() == key);
}
string s = "";
if (expr != null)
{
var writer = block.SaveWriter();
block.NewWriter();
expr.AcceptVisitor(emitter);
s = emitter.Output.ToString();
block.RestoreWriter(writer);
if (modifier == "raw")
{
s = s.Trim('"');
}
}
block.Write(block.WriteIndentToString(s));
if (emitter.Writers.Count != count)
{
block.PopWriter();
}
string replacement = emitter.Output.ToString();
emitter.Output = oldSb;
return replacement;
});
return inline;
}
public static bool HasContinue(AbstractEmitterBlock block, AstNode node)
{
var visitor = new ContinueSearchVisitor();
node.AcceptVisitor(visitor);
bool has = visitor.Found;
if (has)
{
EmitBeginContinue(block);
}
return(has);
}
public static void EmitYieldReturn(AbstractEmitterBlock block, IType returnType)
{
block.EndFunctionBlock();
block.WriteComma();
if (returnType.TypeArguments.Count > 0)
{
block.Write(BridgeTypes.ToJsName(returnType.TypeArguments[0], block.Emitter));
}
else
{
block.Write("System.Object");
}
block.WriteCloseParentheses();
block.WriteNewLine();
}
public static bool IsUserDefinedConversion(AbstractEmitterBlock block, Expression expression)
{
Conversion conversion = null;
try
{
var rr = block.Emitter.Resolver.ResolveNode(expression, null);
conversion = block.Emitter.Resolver.Resolver.GetConversion(expression);
if (conversion == null)
{
return(false);
}
return(conversion.IsUserDefined);
}
catch
{
}
return(false);
}
public static bool IsUserDefinedConversion(AbstractEmitterBlock block, Expression expression)
{
Conversion conversion = null;
try
{
var rr = block.Emitter.Resolver.ResolveNode(expression, null);
conversion = block.Emitter.Resolver.Resolver.GetConversion(expression);
if (conversion == null)
{
return false;
}
return conversion.IsUserDefined;
}
catch
{
}
return false;
}
public static void EmitMethodParameters(AbstractEmitterBlock block, IEnumerable <ParameterDeclaration> declarations, AstNode context)
{
bool needComma = false;
EntityDeclaration entityDeclaration = context as EntityDeclaration;
if (entityDeclaration != null)
{
if (!entityDeclaration.HasModifier(Modifiers.Static))
{
block.WriteThis();
if (declarations.Any())
{
block.WriteComma();
}
}
}
foreach (ParameterDeclaration p in declarations)
{
string name = p.Name;
name = name.Replace(Bridge.Translator.Emitter.FIX_ARGUMENT_NAME, "");
if (block.Emitter.LocalsNamesMap != null && block.Emitter.LocalsNamesMap.ContainsKey(name))
{
name = block.Emitter.LocalsNamesMap[name];
}
if (needComma)
{
block.WriteComma();
}
needComma = true;
block.Write(name);
}
}
protected virtual Dictionary <string, string> CombineOutputs()
{
Dictionary <string, string> result = new Dictionary <string, string>();
foreach (var outputPair in this.Outputs)
{
var fileName = outputPair.Key;
var output = outputPair.Value;
string extension = Path.GetExtension(fileName);
bool isJs = extension == ('.' + Bridge.Translator.AssemblyInfo.JAVASCRIPT_EXTENSION);
foreach (var moduleOutput in output.ModuleOutput)
{
WriteNewLine(output.NonModuletOutput, moduleOutput.Value.ToString());
}
var tmp = new StringBuilder(output.TopOutput.Length + output.BottomOutput.Length + output.NonModuletOutput.Length + 100);
if (output.TopOutput.Length > 0)
{
tmp.Append(output.TopOutput.ToString());
tmp.Append("\n");
}
if (isJs)
{
tmp.Append(this.GetOutputHeader(true, false));
tmp.Append("\n");
}
if (output.NonModuletOutput.Length > 0)
{
if (isJs)
{
tmp.Append("(function (globals) {");
tmp.Append("\n");
tmp.Append(" ");
tmp.Append(this.GetOutputHeader(false, true));
tmp.Append("\n");
}
var code = output.NonModuletOutput.ToString() + (isJs ? "\n\nBridge.init();" : "");
if (isJs)
{
code = " " + AbstractEmitterBlock.WriteIndentToString(code, 1);
}
tmp.Append(code);
if (isJs)
{
tmp.Append("\n");
tmp.Append("})(this);");
tmp.Append("\n");
}
}
if (output.BottomOutput.Length > 0)
{
tmp.Append("\n");
tmp.Append(output.BottomOutput.ToString());
}
result.Add(fileName, tmp.ToString());
}
return(result);
}
protected virtual void WrapToModules()
{
foreach (var outputPair in this.Outputs)
{
var output = outputPair.Value;
foreach (var moduleOutputPair in output.ModuleOutput)
{
var moduleName = moduleOutputPair.Key;
var moduleOutput = moduleOutputPair.Value;
AbstractEmitterBlock.RemovePenultimateEmptyLines(moduleOutput, true);
var str = moduleOutput.ToString();
moduleOutput.Length = 0;
moduleOutput.Append("define(");
if (moduleName != Bridge.Translator.AssemblyInfo.DEFAULT_FILENAME)
{
moduleOutput.Append(this.ToJavaScript(moduleName));
moduleOutput.Append(", ");
}
moduleOutput.Append("[\"bridge\",");
if (output.ModuleDependencies.ContainsKey(moduleName) && output.ModuleDependencies[moduleName].Count > 0)
{
output.ModuleDependencies[moduleName].Each(md =>
{
moduleOutput.Append(this.ToJavaScript(md.DependencyName));
moduleOutput.Append(",");
});
}
moduleOutput.Remove(moduleOutput.Length - 1, 1); // remove trailing comma
moduleOutput.Append("], ");
moduleOutput.Append("function (_");
if (output.ModuleDependencies.ContainsKey(moduleName) && output.ModuleDependencies[moduleName].Count > 0)
{
moduleOutput.Append(", ");
output.ModuleDependencies[moduleName].Each(md =>
{
moduleOutput.Append(md.VariableName.IsNotEmpty() ? md.VariableName : md.DependencyName);
moduleOutput.Append(",");
});
moduleOutput.Remove(moduleOutput.Length - 1, 1); // remove trailing comma
}
WriteNewLine(moduleOutput, ") {");
string indent = str.StartsWith(" ") ? "" : " ";
moduleOutput.Append(" ");
WriteNewLine(moduleOutput, "var exports = { };");
moduleOutput.Append(indent + str.Replace("\n", "\n" + indent));
if (!str.Trim().EndsWith("\n"))
{
WriteNewLine(moduleOutput);
}
WriteNewLine(moduleOutput, " return exports;");
WriteNewLine(moduleOutput, "});");
}
}
}
/// <summary>
/// http://lua-users.org/wiki/ContinueProposal
/// </summary>
/// <param name="block"></param>
private static void EmitBeginContinue(AbstractEmitterBlock block) {
block.WriteVar(true);
block.Write("continue");
block.WriteNewLine();
block.BeginBlock("repeat");
}
protected void VisitAsyncWhileStatement()
{
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var jumpStatements = this.Emitter.JumpStatements;
this.Emitter.JumpStatements = new List <IJumpInfo>();
IAsyncStep conditionStep = null;
var lastStep = this.Emitter.AsyncBlock.Steps.Last();
if (string.IsNullOrWhiteSpace(lastStep.Output.ToString()))
{
conditionStep = lastStep;
}
else
{
lastStep.JumpToStep = this.Emitter.AsyncBlock.Step;
conditionStep = this.Emitter.AsyncBlock.AddAsyncStep();
}
this.WriteAwaiters(this.WhileStatement.Condition);
this.Emitter.ReplaceAwaiterByVar = true;
this.WriteIf();
this.WriteOpenParentheses(true);
this.WhileStatement.Condition.AcceptVisitor(this.Emitter);
this.WriteCloseParentheses(true);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.WriteSpace();
this.BeginBlock();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
var writer = this.SaveWriter();
var bodyStep = this.Emitter.AsyncBlock.AddAsyncStep();
this.Emitter.IgnoreBlock = this.WhileStatement.EmbeddedStatement;
var startCount = this.Emitter.AsyncBlock.Steps.Count;
this.WhileStatement.EmbeddedStatement.AcceptVisitor(this.Emitter);
if (!AbstractEmitterBlock.IsJumpStatementLast(this.Emitter.Output.ToString()))
{
this.WriteNewLine();
this.Write("$step = " + conditionStep.Step + ";");
this.WriteNewLine();
this.Write("continue;");
}
this.RestoreWriter(writer);
this.WriteNewLine();
this.EndBlock();
this.WriteSpace();
if (!AbstractEmitterBlock.IsJumpStatementLast(this.Emitter.Output.ToString()))
{
this.WriteNewLine();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
}
var nextStep = this.Emitter.AsyncBlock.AddAsyncStep();
conditionStep.JumpToStep = nextStep.Step;
if (this.Emitter.JumpStatements.Count > 0)
{
this.Emitter.JumpStatements.Sort((j1, j2) => - j1.Position.CompareTo(j2.Position));
foreach (var jump in this.Emitter.JumpStatements)
{
jump.Output.Insert(jump.Position, jump.Break ? nextStep.Step : conditionStep.Step);
}
}
this.Emitter.JumpStatements = jumpStatements;
}
public static void EmitEndContinue(AbstractEmitterBlock block) {
block.Write("continue = true");
block.WriteNewLine();
block.Outdent();
block.Write("until 1");
block.WriteNewLine();
block.Write("if not continue then break end");
block.WriteNewLine();
}
public static void EmitYieldReturn(AbstractEmitterBlock block, IType returnType)
{
block.EndFunctionBlock();
block.WriteCloseParentheses();
block.WriteNewLine();
}
protected void VisitIfElseStatement()
{
IfElseStatement ifElseStatement = this.IfElseStatement;
this.WriteAwaiters(ifElseStatement.Condition);
this.WriteIf();
var oldValue = this.Emitter.ReplaceAwaiterByVar;
this.Emitter.ReplaceAwaiterByVar = true;
ifElseStatement.Condition.AcceptVisitor(this.Emitter);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.WriteSpace();
this.WriteThen();
int startCount = 0;
int elseCount = 0;
IAsyncStep trueStep = null;
IAsyncStep elseStep = null;
if (this.Emitter.IsAsync)
{
startCount = this.Emitter.AsyncBlock.Steps.Count;
this.EmittedAsyncSteps = this.Emitter.AsyncBlock.EmittedAsyncSteps;
this.Emitter.AsyncBlock.EmittedAsyncSteps = new List <IAsyncStep>();
this.Emitter.IgnoreBlock = ifElseStatement.TrueStatement;
this.WriteSpace();
this.BeginBlock();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
var writer = this.SaveWriter();
var bodyStep = this.Emitter.AsyncBlock.AddAsyncStep();
ifElseStatement.TrueStatement.AcceptVisitor(this.Emitter);
if (this.Emitter.AsyncBlock.Steps.Count > startCount)
{
trueStep = this.Emitter.AsyncBlock.Steps.Last();
}
if (this.RestoreWriter(writer) && !this.IsOnlyWhitespaceOnPenultimateLine(true))
{
this.WriteNewLine();
}
this.EndBlock();
this.WriteSpace();
elseCount = this.Emitter.AsyncBlock.Steps.Count;
}
else
{
this.WriteNewLine();
this.Indent();
ifElseStatement.TrueStatement.AcceptVisitor(this.Emitter);
this.Outdent();
}
if (ifElseStatement.FalseStatement != null && !ifElseStatement.FalseStatement.IsNull)
{
this.WriteElse();
if (this.Emitter.IsAsync)
{
this.Emitter.IgnoreBlock = ifElseStatement.FalseStatement;
this.WriteSpace();
this.BeginBlock();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
var writer = this.SaveWriter();
var bodyStep = this.Emitter.AsyncBlock.AddAsyncStep();
ifElseStatement.FalseStatement.AcceptVisitor(this.Emitter);
if (this.Emitter.AsyncBlock.Steps.Count > elseCount)
{
elseStep = this.Emitter.AsyncBlock.Steps.Last();
}
if (this.RestoreWriter(writer) && !this.IsOnlyWhitespaceOnPenultimateLine(true))
{
this.WriteNewLine();
}
this.EndBlock();
this.WriteSpace();
}
else
{
bool isNextIf = ifElseStatement.FalseStatement.FirstChild is IfElseStatement;
if (!isNextIf)
{
this.WriteNewLine();
this.Indent();
}
ifElseStatement.FalseStatement.AcceptVisitor(this.Emitter);
if (!isNextIf)
{
this.Outdent();
this.Write("end");
this.WriteNewLine();
}
}
}
else
{
this.Write("end");
this.WriteNewLine();
}
if (this.Emitter.IsAsync && this.Emitter.AsyncBlock.Steps.Count > startCount)
{
if (this.Emitter.AsyncBlock.Steps.Count <= elseCount && !AbstractEmitterBlock.IsJumpStatementLast(this.Emitter.Output.ToString()))
{
this.WriteNewLine();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
}
var nextStep = this.Emitter.AsyncBlock.AddAsyncStep();
if (trueStep != null)
{
trueStep.JumpToStep = nextStep.Step;
}
if (elseStep != null)
{
elseStep.JumpToStep = nextStep.Step;
}
}
else if (this.Emitter.IsAsync)
{
this.WriteNewLine();
}
if (this.Emitter.IsAsync)
{
this.Emitter.AsyncBlock.EmittedAsyncSteps = this.EmittedAsyncSteps;
}
}
protected void VisitAsyncForeachStatement()
{
ForeachStatement foreachStatement = this.ForeachStatement;
if (foreachStatement.EmbeddedStatement is EmptyStatement)
{
return;
}
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var jumpStatements = this.Emitter.JumpStatements;
this.Emitter.JumpStatements = new List <IJumpInfo>();
this.WriteAwaiters(foreachStatement.InExpression);
bool containsAwaits = false;
var awaiters = this.GetAwaiters(foreachStatement.EmbeddedStatement);
if (awaiters != null && awaiters.Length > 0)
{
containsAwaits = true;
}
this.Emitter.ReplaceAwaiterByVar = true;
if (!containsAwaits)
{
this.VisitForeachStatement(oldValue);
return;
}
//var iteratorName = this.GetNextIteratorName();
var iteratorName = this.AddLocal(this.GetTempVarName(), AstType.Null);
//this.WriteVar();
this.Write(iteratorName, " = ", Bridge.Translator.Emitter.ROOT);
this.WriteDot();
this.Write(Bridge.Translator.Emitter.ENUMERATOR);
this.WriteOpenParentheses();
foreachStatement.InExpression.AcceptVisitor(this.Emitter);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.WriteCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
this.WriteNewLine();
IAsyncStep conditionStep = this.Emitter.AsyncBlock.AddAsyncStep();
this.WriteIf();
this.WriteOpenParentheses();
this.Write(iteratorName);
this.WriteDot();
this.Write(Bridge.Translator.Emitter.MOVE_NEXT);
this.WriteOpenCloseParentheses();
this.WriteCloseParentheses();
this.WriteSpace();
this.BeginBlock();
this.PushLocals();
var varName = this.AddLocal(foreachStatement.VariableName, foreachStatement.VariableType);
this.WriteVar();
this.Write(varName, " = ", iteratorName);
this.WriteDot();
this.Write(Bridge.Translator.Emitter.GET_CURRENT);
this.WriteOpenCloseParentheses();
this.WriteSemiColon();
this.WriteNewLine();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
BlockStatement block = foreachStatement.EmbeddedStatement as BlockStatement;
var writer = this.SaveWriter();
var bodyStep = this.Emitter.AsyncBlock.AddAsyncStep();
this.Emitter.IgnoreBlock = foreachStatement.EmbeddedStatement;
var startCount = this.Emitter.AsyncBlock.Steps.Count;
if (block != null)
{
block.AcceptChildren(this.Emitter);
}
else
{
foreachStatement.EmbeddedStatement.AcceptVisitor(this.Emitter);
}
IAsyncStep loopStep = null;
if (this.Emitter.AsyncBlock.Steps.Count > startCount)
{
loopStep = this.Emitter.AsyncBlock.Steps.Last();
loopStep.JumpToStep = conditionStep.Step;
}
this.RestoreWriter(writer);
if (!AbstractEmitterBlock.IsJumpStatementLast(this.Emitter.Output.ToString()))
{
this.Write("$step = " + conditionStep.Step + ";");
this.WriteNewLine();
this.Write("continue;");
this.WriteNewLine();
}
this.PopLocals();
this.WriteNewLine();
this.EndBlock();
this.WriteNewLine();
var nextStep = this.Emitter.AsyncBlock.AddAsyncStep();
conditionStep.JumpToStep = nextStep.Step;
if (this.Emitter.JumpStatements.Count > 0)
{
this.Emitter.JumpStatements.Sort((j1, j2) => - j1.Position.CompareTo(j2.Position));
foreach (var jump in this.Emitter.JumpStatements)
{
jump.Output.Insert(jump.Position, jump.Break ? nextStep.Step : conditionStep.Step);
}
}
this.Emitter.JumpStatements = jumpStatements;
}
protected void InjectSteps()
{
foreach (var label in this.JumpLabels)
{
var tostep = this.Steps.First(s => s.Node == label.Node);
label.Output.Replace("${" + label.Node.GetHashCode() + "}", tostep.Step.ToString());
}
for (int i = 0; i < this.Steps.Count; i++)
{
var step = this.Steps[i];
if (i != 0)
{
this.WriteNewLine();
}
var output = step.Output.ToString();
if (string.IsNullOrWhiteSpace(output) && step.JumpToStep == (i + 1))
{
continue;
}
this.Write("case " + i + ": ");
this.BeginBlock();
bool addNewLine = false;
if (step.FromTaskNumber > -1)
{
var expression = this.AwaitExpressions[step.FromTaskNumber - 1];
if (this.IsTaskResult(expression))
{
this.Write(string.Format("$taskResult{0} = $task{0}.getResult();", step.FromTaskNumber));
}
else
{
this.Write(string.Format("$task{0}.getResult();", step.FromTaskNumber));
}
addNewLine = true;
}
if (!string.IsNullOrWhiteSpace(output))
{
if (addNewLine)
{
this.WriteNewLine();
}
this.Write(this.WriteIndentToString(output.TrimEnd()));
}
if (!this.IsOnlyWhitespaceOnPenultimateLine(false))
{
addNewLine = true;
}
if (step.JumpToStep > -1 && !AbstractEmitterBlock.IsJumpStatementLast(output))
{
if (addNewLine)
{
this.WriteNewLine();
}
this.Write("$step = " + step.JumpToStep + ";");
this.WriteNewLine();
this.Write("continue;");
}
else if (step.JumpToNode != null && !AbstractEmitterBlock.IsJumpStatementLast(output))
{
var tostep = this.Steps.First(s => s.Node == step.JumpToNode);
if (addNewLine)
{
this.WriteNewLine();
}
this.Write("$step = " + tostep.Step + ";");
this.WriteNewLine();
this.Write("continue;");
}
else if (i == (this.Steps.Count - 1) && !AbstractEmitterBlock.IsReturnLast(output))
{
if (addNewLine)
{
this.WriteNewLine();
}
if (this.IsTaskReturn)
{
this.Write("$returnTask.setResult(null);");
this.WriteNewLine();
}
this.Write("return;");
}
this.WriteNewLine();
this.EndBlock();
}
this.WriteNewLine();
this.Write("default: ");
this.BeginBlock();
if (this.IsTaskReturn)
{
this.Write("$returnTask.setResult(null);");
this.WriteNewLine();
}
this.Write("return;");
this.WriteNewLine();
this.EndBlock();
}
public int GetNumberOfEmptyLinesAtEnd()
{
return(AbstractEmitterBlock.GetNumberOfEmptyLinesAtEnd(this.Emitter.Output));
}
public bool IsOnlyWhitespaceOnPenultimateLine(bool lastTwoLines = true)
{
return(AbstractEmitterBlock.IsOnlyWhitespaceOnPenultimateLine(this.Emitter.Output, lastTwoLines));
}
protected void VisitAsyncForStatement()
{
ForStatement forStatement = this.ForStatement;
var oldValue = this.Emitter.ReplaceAwaiterByVar;
var jumpStatements = this.Emitter.JumpStatements;
this.Emitter.JumpStatements = new List <IJumpInfo>();
this.PushLocals();
bool newLine = false;
foreach (var item in forStatement.Initializers)
{
if (newLine)
{
this.WriteNewLine();
}
item.AcceptVisitor(this.Emitter);
newLine = true;
}
this.RemovePenultimateEmptyLines(true);
this.WriteNewLine();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
IAsyncStep conditionStep = this.Emitter.AsyncBlock.AddAsyncStep();
this.WriteAwaiters(forStatement.Condition);
this.Emitter.ReplaceAwaiterByVar = true;
var lastConditionStep = this.Emitter.AsyncBlock.Steps.Last();
this.WriteIf();
this.WriteOpenParentheses(true);
forStatement.Condition.AcceptVisitor(this.Emitter);
this.WriteCloseParentheses(true);
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.WriteSpace();
this.BeginBlock();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
this.EmittedAsyncSteps = this.Emitter.AsyncBlock.EmittedAsyncSteps;
this.Emitter.AsyncBlock.EmittedAsyncSteps = new List <IAsyncStep>();
var writer = this.SaveWriter();
var bodyStep = this.Emitter.AsyncBlock.AddAsyncStep();
this.Emitter.IgnoreBlock = forStatement.EmbeddedStatement;
var startCount = this.Emitter.AsyncBlock.Steps.Count;
forStatement.EmbeddedStatement.AcceptVisitor(this.Emitter);
IAsyncStep loopStep = null;
if (this.Emitter.AsyncBlock.Steps.Count > startCount)
{
loopStep = this.Emitter.AsyncBlock.Steps.Last();
}
this.RestoreWriter(writer);
if (!AbstractEmitterBlock.IsJumpStatementLast(this.Emitter.Output.ToString()))
{
this.WriteNewLine();
this.Write("$step = " + this.Emitter.AsyncBlock.Step + ";");
this.WriteNewLine();
this.Write("continue;");
this.WriteNewLine();
this.EndBlock();
this.WriteSpace();
}
else
{
this.WriteNewLine();
this.EndBlock();
this.WriteSpace();
}
if (this.Emitter.IsAsync)
{
this.Emitter.AsyncBlock.EmittedAsyncSteps = this.EmittedAsyncSteps;
}
IAsyncStep iteratorsStep = this.Emitter.AsyncBlock.AddAsyncStep();
var lastIteratorStep = this.Emitter.AsyncBlock.Steps.Last();
if (loopStep != null)
{
loopStep.JumpToStep = iteratorsStep.Step;
}
lastIteratorStep.JumpToStep = conditionStep.Step;
this.Emitter.ReplaceAwaiterByVar = true;
var beforeStepsCount = this.Emitter.AsyncBlock.Steps.Count;
foreach (var item in forStatement.Iterators)
{
item.AcceptVisitor(this.Emitter);
if (this.Emitter.Output.ToString().TrimEnd().Last() != ';')
{
this.WriteSemiColon();
}
this.WriteNewLine();
}
if (beforeStepsCount < this.Emitter.AsyncBlock.Steps.Count)
{
this.Emitter.AsyncBlock.Steps.Last().JumpToStep = conditionStep.Step;
}
this.Emitter.ReplaceAwaiterByVar = oldValue;
this.PopLocals();
var nextStep = this.Emitter.AsyncBlock.AddAsyncStep();
lastConditionStep.JumpToStep = nextStep.Step;
if (this.Emitter.JumpStatements.Count > 0)
{
this.Emitter.JumpStatements.Sort((j1, j2) => - j1.Position.CompareTo(j2.Position));
foreach (var jump in this.Emitter.JumpStatements)
{
jump.Output.Insert(jump.Position, jump.Break ? nextStep.Step : iteratorsStep.Step);
}
}
this.Emitter.JumpStatements = jumpStatements;
}
