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 void ProcessAssign()
{
ExpressionSyntax variableExpression = PopVariable();
var variableIdentifier = SyntaxFactory.IdentifierName(VariableSet.Variables[OpCodes[codePointer].DataIndex.Value].Name);
AssignmentExpressionSyntax assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variableIdentifier, variableExpression);
//is this a bad comparison that is actually an assign?
if (OpCodes[codePointer + 1].OpCode == OpCodeType.OP_JMPF)
{
//push expression onto the stack
stack.Push(assignment);
}
else
{
////is this a double assign?
//if (OpCodes[codePointer + 1].OpCode == OpCodeType.OP_GETTOP)
//{
// var variableIdentifier2 = SyntaxFactory.IdentifierName(VariableSet.Variables[OpCodes[codePointer + 1].DataIndex.Value].Name);
// assignment = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, variableIdentifier2, assignment);
// codePointer++;
//}
var expressionStatement = SyntaxFactory.ExpressionStatement(assignment, semi);
//add to the current block
BlockHelper.AddToCurrentBlock(expressionStatement);
}
}
private void AddVariablesToBlock()
{
TypeSyntax intType = SyntaxFactory.ParseTypeName("int ");
TypeSyntax stringType = SyntaxFactory.ParseTypeName("String ");
TypeSyntax floatType = SyntaxFactory.ParseTypeName("Float ");
TypeSyntax pointType = SyntaxFactory.ParseTypeName("Point ");
TypeSyntax characterType = SyntaxFactory.ParseTypeName("Character ");
TypeSyntax quaternionType = SyntaxFactory.ParseTypeName("Quaternion ");
var q = from variable in VariableSet.Variables
where (variable.Value.Static == false ||
variable.Value.Used == false)
orderby variable.Key
select variable;
foreach (var variable in q)
{
//sourceBuilder.Insert(0, string.Format("{0} variable{1};\n", variable.Value, variable.Key));
// Build the field variable 1
VariableDeclaratorSyntax declarator = SyntaxFactory.VariableDeclarator(
identifier: SyntaxFactory.Identifier(variable.Value.Name)
);
TypeSyntax theType = null;
switch (variable.Value.DataType.ToLower())
{
case ("int"):
theType = intType;
break;
case ("string"):
theType = stringType;
break;
case ("point"):
theType = pointType;
break;
case ("character"):
theType = characterType;
break;
case ("float"):
theType = floatType;
break;
case ("quaternion"):
theType = quaternionType;
break;
}
VariableDeclarationSyntax variableDeclaration = SyntaxFactory.VariableDeclaration(type: theType, variables: SyntaxFactory.SeparatedList <VariableDeclaratorSyntax>().Add(declarator));
SyntaxTokenList modifiers = new SyntaxTokenList();
LocalDeclarationStatementSyntax localDeclaration = SyntaxFactory.LocalDeclarationStatement(modifiers, variableDeclaration, semi);
BlockHelper.AddToCurrentBlock(localDeclaration);
}
}
private void ProcessComparison(OpCodeType opCode)
{
SyntaxKind syntaxKind;
if (opCode == OpCodeType.OP_NOT_EQUAL)
{
syntaxKind = SyntaxKind.NotEqualsExpression;
}
else if (opCode == OpCodeType.OP_MORE_THAN)
{
syntaxKind = SyntaxKind.GreaterThanExpression;
}
else if (opCode == OpCodeType.OP_MORE_THAN_OR_EQUAL)
{
syntaxKind = SyntaxKind.GreaterThanOrEqualExpression;
}
else if (opCode == OpCodeType.OP_LESS_THAN)
{
syntaxKind = SyntaxKind.LessThanExpression;
}
else if (opCode == OpCodeType.OP_LESS_THAN_OR_EQUAL)
{
syntaxKind = SyntaxKind.LessThanOrEqualExpression;
}
else
{
syntaxKind = SyntaxKind.EqualsExpression;
}
if (stack.Count == 0)
{
return;
}
var rhsVariableExpression = PopVariable();
var lhsVariableExpression = PopVariable();
var binaryExpression = SyntaxFactory.BinaryExpression(syntaxKind, lhsVariableExpression, rhsVariableExpression);
//check for an OP_EQUAL followed by OP_DISCARD where == is used instead of =
if (syntaxKind == SyntaxKind.EqualsExpression &&
OpCodes[codePointer + 1].OpCode == OpCodeType.OP_DISCARD)
{
var expressionStatement = SyntaxFactory.ExpressionStatement(binaryExpression, semi);
//add to the current block
BlockHelper.AddToCurrentBlock(expressionStatement);
}
else
{
//push expression onto the stack
stack.Push(binaryExpression);
}
}
private void ProcessJumpF()
{
ExpressionSyntax expressionSyntax = PopVariable();
if (expressionSyntax == null)
{
return;
}
// start a new block for the if
BlockSyntax ifBlock = BlockHelper.CreateNewBlock("if");
//add the if to the current block
IfStatementSyntax ifStatement = SyntaxFactory.IfStatement(expressionSyntax, ifBlock);
BlockHelper.AddToCurrentBlock(ifStatement);
//current block is now the if
BlockHelper.SetBlockAsCurrent(ifBlock);
}
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);
}