private static ArgumentListSyntax AddArgument(ArgumentListSyntax argumentList, string parameterName,
ArgumentSyntax argument, bool alreadyRemovedOne)
{
return(alreadyRemovedOne
? argumentList.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.NameColon(SyntaxFactory.IdentifierName(parameterName)),
argument.RefOrOutKeyword,
argument.Expression))
: argumentList.AddArguments(argument));
}
private void ProcessPrint()
{
ArgumentListSyntax argumentList = SyntaxFactory.ArgumentList();
ExpressionSyntax argument = PopVariable();
List <ArgumentSyntax> arguments = new List <ArgumentSyntax>
{
SyntaxFactory.Argument(argument)
};
argumentList = argumentList.AddArguments(arguments.ToArray());
ExpressionSyntax expressionSyntax = SyntaxFactory.IdentifierName("Print");
InvocationExpressionSyntax invocationExpression = SyntaxFactory.InvocationExpression(expressionSyntax, argumentList);
ExpressionStatementSyntax expressionStatement = SyntaxFactory.ExpressionStatement(invocationExpression, semi);
var statements = new SyntaxList <StatementSyntax>().Add(expressionStatement);
//add to the current block
BlockHelper.AddToCurrentBlock(expressionStatement);
//currentBlock = currentBlock.WithStatements(statements);
//GlobalStatementSyntax globalStatement = Syntax.GlobalStatement(expressionStatement);
}
private static ArgumentListSyntax AddParamsArguments(SemanticModel semanticModel,
ICollection <MethodParameterLookup.ArgumentParameterMapping> paramsArguments, ArgumentListSyntax argumentList)
{
var firstParamsMapping = paramsArguments.First();
var firstParamsArgument = firstParamsMapping.Argument;
var paramsParameter = firstParamsMapping.Parameter;
if (firstParamsArgument.NameColon != null)
{
return(argumentList.AddArguments(firstParamsArgument));
}
if (paramsArguments.Count == 1 &&
paramsParameter.Type.Equals(
semanticModel.GetTypeInfo(firstParamsArgument.Expression).Type))
{
return(argumentList.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.NameColon(
SyntaxFactory.IdentifierName(paramsParameter.Name)),
firstParamsArgument.RefOrOutKeyword,
firstParamsArgument.Expression)));
}
return(argumentList.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.NameColon(
SyntaxFactory.IdentifierName(paramsParameter.Name)),
SyntaxFactory.Token(SyntaxKind.None),
SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(
paramsArguments.Select(arg => arg.Argument.Expression))
)))));
}
private InvocationExpressionSyntax ConvertToInvocation(SimpleNameSyntax calledMethod, ExpressionSyntax literalExpected, ExpressionSyntax actual, ExpressionSyntax message)
{
bool isLiteralTrue = GetMethod(literalExpected);
if (calledMethod.ToString() == @"AreNotEqual")
{
isLiteralTrue = !isLiteralTrue;
}
string method = isLiteralTrue ? "IsTrue" : "IsFalse";
ArgumentListSyntax argumentListSyntax = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { SyntaxFactory.Argument(actual) }));
if (message != null)
{
argumentListSyntax = argumentListSyntax.AddArguments(SyntaxFactory.Argument(message));
}
return(SyntaxFactory.InvocationExpression(SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseTypeName("Assert"), SyntaxFactory.Token(SyntaxKind.DotToken), (SimpleNameSyntax)SyntaxFactory.ParseName(method)), argumentListSyntax));
}
private void ProcessFunction()
{
DataIndex function = (DataIndex)stack.Pop();
string functionName = FunctionTable.Functions[function.Value];
ExpressionSyntax expressionSyntax = SyntaxFactory.IdentifierName(functionName);
ArgumentListSyntax argumentList = SyntaxFactory.ArgumentList();
List <ArgumentSyntax> arguments = new List <ArgumentSyntax>();
//reverse the stacks
stack = new Stack <object>(stack);
while (stack.Count > 0)
{
ExpressionSyntax paramSyntax = PopVariable();
arguments.Add(SyntaxFactory.Argument(paramSyntax));
// IsCharacterDead only takes one parameter and we need to cope with bug
if (functionName == "IsCharacterDead" &&
stack.Count > 0)
{
// cope with bug
if (OpCodes[codePointer + 1].OpCode == OpCodeType.OP_EQUAL)
{
arguments.Clear();
ExpressionSyntax paramSyntax2 = PopVariable();
arguments.Add(SyntaxFactory.Argument(paramSyntax2));
stack.Push(paramSyntax);
}
break;
}
}
argumentList = argumentList.AddArguments(arguments.ToArray());
InvocationExpressionSyntax invocationExpression = SyntaxFactory.InvocationExpression(expressionSyntax, argumentList);
ExpressionStatementSyntax expressionStatement = SyntaxFactory.ExpressionStatement(invocationExpression, semi);
// are we assigning to an equal as a bug?
if (OpCodes[codePointer + 1].OpCode == OpCodeType.OP_EQUAL)
{
var variableIdentifier = PopVariable();
var binaryExpression = SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, variableIdentifier, invocationExpression);
expressionStatement = SyntaxFactory.ExpressionStatement(binaryExpression, semi);
//make sure we move past the OP_EQUAL
codePointer++;
}
{
//are we assigning to a variable?
if (OpCodes[codePointer + 1].OpCode == OpCodeType.OP_GETTOP)
{
var variableIdentifier = SyntaxFactory.IdentifierName(VariableSet.Variables[OpCodes[codePointer + 1].DataIndex.Value].Name);
var assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variableIdentifier, expressionStatement.Expression);
expressionStatement = SyntaxFactory.ExpressionStatement(assignment, semi);
//make sure we move past the OP_GETTOP
codePointer++;
}
if (OpCodes[codePointer + 1].OpCode == OpCodeType.OP_GETTOP)
{
//add to the current block
var variableIdentifier = SyntaxFactory.IdentifierName(VariableSet.Variables[OpCodes[codePointer + 1].DataIndex.Value].Name);
var assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variableIdentifier, expressionStatement.Expression);
expressionStatement = SyntaxFactory.ExpressionStatement(assignment, semi);
//make sure we move past the OP_GETTOP
codePointer++;
}
}
//add to the current block
BlockHelper.AddToCurrentBlock(expressionStatement);
}
private static ArgumentListSyntax AddParamsArguments(SemanticModel semanticModel,
ICollection<MethodParameterLookup.ArgumentParameterMapping> paramsArguments, ArgumentListSyntax argumentList)
{
var firstParamsMapping = paramsArguments.First();
var firstParamsArgument = firstParamsMapping.Argument;
var paramsParameter = firstParamsMapping.Parameter;
if (firstParamsArgument.NameColon != null)
{
return argumentList.AddArguments(firstParamsArgument);
}
if (paramsArguments.Count == 1 &&
paramsParameter.Type.Equals(
semanticModel.GetTypeInfo(firstParamsArgument.Expression).Type))
{
return argumentList.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.NameColon(
SyntaxFactory.IdentifierName(paramsParameter.Name)),
firstParamsArgument.RefOrOutKeyword,
firstParamsArgument.Expression));
}
return argumentList.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.NameColon(
SyntaxFactory.IdentifierName(paramsParameter.Name)),
SyntaxFactory.Token(SyntaxKind.None),
SyntaxFactory.ImplicitArrayCreationExpression(
SyntaxFactory.InitializerExpression(
SyntaxKind.ArrayInitializerExpression,
SyntaxFactory.SeparatedList(
paramsArguments.Select(arg => arg.Argument.Expression))
))));
}
private static ArgumentListSyntax AddArgument(ArgumentListSyntax argumentList, string parameterName,
ArgumentSyntax argument, bool alreadyRemovedOne)
{
return alreadyRemovedOne
? argumentList.AddArguments(
SyntaxFactory.Argument(
SyntaxFactory.NameColon(SyntaxFactory.IdentifierName(parameterName)),
argument.RefOrOutKeyword,
argument.Expression))
: argumentList.AddArguments(argument);
}
