public override void CaseAVoidReturnStm(AVoidReturnStm node)
{
if (!neededWhile)
{
node.Parent().RemoveChild(node);
return;
}
/*
* return;
* ->
* hasMethodReturnedVar = true;
* break;
*/
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(hasMethodReturnedVar.GetName().Text));
data.LvalueTypes[lvalue] = hasMethodReturnedVar.GetType();
data.LocalLinks[lvalue] = hasMethodReturnedVar;
PExp exp = new ABooleanConstExp(new ATrueBool());
data.ExpTypes[exp] = new ANamedType(new TIdentifier("bool"), null);
exp = new AAssignmentExp(new TAssign("="), lvalue, exp);
data.ExpTypes[exp] = hasMethodReturnedVar.GetType();
PStm stm = new AExpStm(new TSemicolon(";"), exp);
AABlock block = new AABlock();
block.GetStatements().Add(stm);
block.GetStatements().Add(new ABreakStm(new TBreak("break")));
node.ReplaceBy(new ABlockStm(new TLBrace("{"), block));
}
public override void CaseALocalDeclStm(ALocalDeclStm node)
{
AMethodDecl pMethod = Util.GetAncestor <AMethodDecl>(node);
AALocalDecl decl = (AALocalDecl)node.GetLocalDecl();
if (decl.GetInit() == null)
{
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(decl.GetName().Text));
data.LocalLinks[lvalue] = decl;
data.LvalueTypes[lvalue] = decl.GetType();
List <PStm> statements = AssignDefault(lvalue);
AABlock pBlock = (AABlock)node.Parent();
foreach (PStm statement in statements)
{
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node), statement);
}
pBlock.RemoveChild(node);
}
else
{
//Make an assignment expression before moving
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(decl.GetName().Text));
data.LvalueTypes[lvalue] = decl.GetType();
AAssignmentExp exp = new AAssignmentExp(new TAssign("="), lvalue, decl.GetInit());
AExpStm expStm = new AExpStm(new TSemicolon(";"), exp);
node.ReplaceBy(expStm);
data.LvalueTypes[lvalue] = decl.GetType();
data.ExpTypes[exp] = decl.GetType();
data.LocalLinks[lvalue] = decl;
}
AABlock block = (AABlock)pMethod.GetBlock();
block.GetStatements().Insert(0, node);
}
public override void CaseAValueReturnStm(AValueReturnStm node)
{
/*
* return <exp>;
* ->
* methodReturnerVar = <exp>;
* hasMethodReturnedVar = true;
* break;
*/
ALocalLvalue lvalue = new ALocalLvalue(new TIdentifier(methodReturnerVar.GetName().Text));
data.LvalueTypes[lvalue] = methodReturnerVar.GetType();
data.LocalLinks[lvalue] = methodReturnerVar;
AAssignmentExp exp = new AAssignmentExp(new TAssign("="), lvalue, node.GetExp());
data.ExpTypes[exp] = methodReturnerVar.GetType();
PStm stm = new AExpStm(new TSemicolon(";"), exp);
AABlock block = new AABlock();
block.GetStatements().Add(stm);
block.GetStatements().Add(new AVoidReturnStm(node.GetToken()));
node.ReplaceBy(new ABlockStm(new TLBrace("{"), block));
block.Apply(this);
}
public static bool Parse(ControlFlowGraph cfg, SharedData data, out bool redoLivenessAnalysis)
{
bool changed = false;
redoLivenessAnalysis = false;
Dictionary <ControlFlowGraph.Node, List <ASimpleInvokeExp> > Modifications = new Dictionary <ControlFlowGraph.Node, List <ASimpleInvokeExp> >();
foreach (ControlFlowGraph.Node node in cfg.Nodes)
{
if (node.Expression is AAssignmentExp)
{
AAssignmentExp exp = (AAssignmentExp)node.Expression;
if (exp.GetLvalue() is ALocalLvalue)
{
AALocalDecl decl = data.LocalLinks[(ALocalLvalue)exp.GetLvalue()];
//If the variable is not live at any successors, remove this assignment
bool inUse = false;
foreach (ControlFlowGraph.Node successor in node.Successors)
{
if (successor.LiveVariables.Contains(decl))
{
inUse = true;
break;
}
}
if (!inUse)
{
//Move method invokes out
GetMethodInvokes getter = new GetMethodInvokes();
exp.GetExp().Apply(getter);
//Might also have to redo because we removed a reference to a variable in the right side
//if (getter.Invokes.Count > 0)
redoLivenessAnalysis = true;
Modifications[node] = getter.Invokes;
changed = true;
}
}
}
}
foreach (KeyValuePair <ControlFlowGraph.Node, List <ASimpleInvokeExp> > pair in Modifications)
{
ControlFlowGraph.Node node = pair.Key;
foreach (ASimpleInvokeExp invoke in pair.Value)
{
AExpStm stm = new AExpStm(new TSemicolon(";"), invoke);
AABlock pBlock = (AABlock)node.Statement.Parent();
pBlock.GetStatements().Insert(pBlock.GetStatements().IndexOf(node.Statement), stm);
cfg.Insert(node, stm);
}
cfg.Remove(node);
node.Statement.Parent().RemoveChild(node.Statement);
}
return(changed);
}
public override void CaseAAssignmentExp(AAssignmentExp node)
{
if (!(node.Parent() is AExpStm))
{
PStm parentStm = Util.GetAncestor <PStm>(node);
MoveMethodDeclsOut mover = new MoveMethodDeclsOut("multipleAssignmentsVar", finalTrans.data);
node.GetLvalue().Apply(mover);
PLvalue lvalue = Util.MakeClone(node.GetLvalue(), finalTrans.data);
ALvalueExp exp = new ALvalueExp(lvalue);
finalTrans.data.ExpTypes[exp] = finalTrans.data.LvalueTypes[lvalue];
node.ReplaceBy(exp);
AExpStm stm = new AExpStm(new TSemicolon(";"), node);
AABlock block = (AABlock)parentStm.Parent();
//block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), localDeclStm);
block.GetStatements().Insert(block.GetStatements().IndexOf(parentStm), stm);
//localDeclStm.Apply(this);
stm.Apply(this);
if (parentStm is AWhileStm && Util.IsAncestor(exp, ((AWhileStm)parentStm).GetCondition()))
{
AWhileStm aStm = (AWhileStm)parentStm;
//Copy assignment before continues
//Before each continue in the while, and at the end.
//Add continue statement, if not present
block = (AABlock)((ABlockStm)aStm.GetBody()).GetBlock();
if (block.GetStatements().Count == 0 || !(block.GetStatements()[block.GetStatements().Count - 1] is AContinueStm))
{
block.GetStatements().Add(new AContinueStm(new TContinue("continue")));
}
//Get all continue statements in the while
ContinueFinder finder = new ContinueFinder();
block.Apply(finder);
foreach (AContinueStm continueStm in finder.Continues)
{
stm = new AExpStm(new TSemicolon(";"), Util.MakeClone(node, finalTrans.data));
block.GetStatements().Insert(block.GetStatements().IndexOf(continueStm), stm);
stm.Apply(this);
}
}
return;
}
base.CaseAAssignmentExp(node);
}
public Node Insert(Node node, AExpStm newStm)
{
//Node must be a node for an AExpStm
Node newNode = new Node(newStm);
foreach (Node successor in node.Successors)
{
newNode.AddSucc(successor);
}
foreach (Node successor in newNode.Successors)
{
node.RemoveSucc(successor);
}
node.AddSucc(newNode);
Nodes.Insert(Nodes.IndexOf(node) + 1, newNode);
return(newNode);
}
public override void OutAShadySAssignmentExp(AShadySAssignmentExp node)
{
if (node.GetLocalDeclRight().Count == 1 &&
((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetName() == null)
{
//Assignment expression
//an assignment can't be const);
//An assignment must have a right side
if (((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetInit() == null ||
((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetAssignop() == null)
{
node.Parent().RemoveChild(node);
return;
}
ASAssignmentExp exp = new ASAssignmentExp(
((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetAssignop(), node.GetLvalue(),
((AALocalDeclRight)node.GetLocalDeclRight()[0]).GetInit());
node.ReplaceBy(exp);
exp.Apply(this);
}
else
{
//Local decl
AMultiLocalDecl localDecl = new AMultiLocalDecl(node.GetConst(), LvalueToType(node.GetLvalue(), node.GetPostPointers(), node.GetGenericToken(), node.GetGenericTypes()),
new ArrayList());
while (node.GetLocalDeclRight().Count > 0)
{
localDecl.GetLocalDeclRight().Add(node.GetLocalDeclRight()[0]);
}
AExpStm expStm = Util.GetAncestor <AExpStm>(node);
ALocalDeclStm localDeclStm = new ALocalDeclStm(expStm.GetToken(), localDecl);
expStm.ReplaceBy(localDeclStm);
localDeclStm.Apply(this);
}
}
public override void CaseAExpStm(AExpStm node)
{
}
public override void OutAAProgram(AAProgram node)
{
if (!processStructs)
{
if (!processFieldsOnly)
{
unusedMethods.RemoveAll(method => method.GetTrigger() != null);
if (finalTrans.mainEntry != null)
{
unusedMethods.Remove(finalTrans.mainEntry);
}
if (finalTrans.data.DeobfuscateMethod != null)
{
unusedMethods.Remove(finalTrans.data.DeobfuscateMethod);
}
foreach (AMethodDecl unusedMethod in unusedMethods)
{
if (firstMethodRun && finalTrans.data.UserMethods.Contains(unusedMethod))
{
children.Add(new ErrorCollection.Error(unusedMethod.GetName(),
Util.GetAncestor <AASourceFile>(unusedMethod),
LocRM.GetString("ErrorText219") + unusedMethod.GetName().Text, true));
}
if (Options.Compiler.RemoveUnusedMethods)
{
unusedMethod.Parent().RemoveChild(unusedMethod);
}
}
firstMethodRun = false;
if (Options.Compiler.RemoveUnusedMethods)
{
finalTrans.data.Methods.RemoveAll(declItem => unusedMethods.Contains(declItem.Decl));
if (unusedMethods.Count > 0)
{
//We removed a method. this may cause other methods to be unused
processMethodsOnly = true;
unusedMethods.Clear();
unusedMethods.AddRange(finalTrans.data.Methods.Select((declItem) => declItem.Decl));
base.CaseAAProgram(node);
return;
}
}
unusedMethods.Clear();
processMethodsOnly = false;
}
if (!processFieldsOnly)
{
fieldsWithMethodCalls.Clear();
usedFields.Clear();
processFieldsOnly = true;
base.CaseAAProgram(node);
return;
}
usedFields.AddRange(finalTrans.data.ObfuscationFields);
List <SharedData.DeclItem <AFieldDecl> > removedFields = new List <SharedData.DeclItem <AFieldDecl> >();
foreach (SharedData.DeclItem <AFieldDecl> declItem in finalTrans.data.Fields)
{
AFieldDecl fieldDecl = declItem.Decl;
if (fieldDecl.GetConst() == null && !usedFields.Contains(fieldDecl))
{
if (!reportedFields.Contains(declItem.Decl))
{
if (firstFieldRun && finalTrans.data.UserFields.Contains(fieldDecl))
{
children.Add(new ErrorCollection.Error(fieldDecl.GetName(),
Util.GetAncestor <AASourceFile>(fieldDecl),
LocRM.GetString("ErrorText65") + fieldDecl.GetName().Text, true));
}
reportedFields.Add(declItem.Decl);
}
if (Options.Compiler.RemoveUnusedFields || (fieldDecl.GetType() is AArrayTempType && ((AArrayTempType)fieldDecl.GetType()).GetIntDim().Text == "0"))
{
//We cannot remove it if there is a method call in it
if (fieldsWithMethodCalls.Contains(fieldDecl))
{
continue;
}
//Remove assignments to the field
foreach (AAssignmentExp assignmentExp in assignedToFields[fieldDecl])
{
if (assignmentExp.Parent() is AExpStm)
{
AExpStm stm = (AExpStm)assignmentExp.Parent();
RemoveVariableStatement(stm, assignmentExp.GetExp(), stm.GetToken().Line,
stm.GetToken().Pos);
continue;
}
PExp exp = assignmentExp.GetExp();
assignmentExp.ReplaceBy(exp);
}
removedFields.Add(declItem);
fieldDecl.Parent().RemoveChild(fieldDecl);
}
}
}
firstFieldRun = false;
foreach (var removedField in removedFields)
{
finalTrans.data.Fields.Remove(removedField);
}
/* if (Options.Compiler.RemoveUnusedFields)
* finalTrans.data.Fields.RemoveAll(
* declItem =>
* (!usedFields.Contains(declItem.Decl)) && (!fieldsWithMethodCalls.Contains(declItem.Decl)));*/
if (removedFields.Count > 0)
{
//Other fields may have become unused
fieldsWithMethodCalls.Clear();
usedFields.Clear();
processFieldsOnly = true;
base.CaseAAProgram(node);
return;
}
//Remove empty arrays from struct fields
foreach (var pair in finalTrans.data.StructFields)
{
for (int i = 0; i < pair.Value.Count; i++)
{
AALocalDecl field = pair.Value[i];
if (field.GetType() is AArrayTempType && ((AArrayTempType)field.GetType()).GetIntDim().Text == "0")
{
field.Parent().RemoveChild(field);
pair.Value.RemoveAt(i);
--i;
}
}
}
}
//Remove unused structs
processFieldsOnly = false;
if (!processStructs)
{
processStructs = true;
base.CaseAAProgram(node);
return;
}
foreach (SharedData.DeclItem <AStructDecl> declItem in finalTrans.data.Structs)
{
if (!usedStructs.Contains(declItem.Decl))
{
if (firstStructRun)
{
children.Add(new ErrorCollection.Error(declItem.Decl.GetName(),
Util.GetAncestor <AASourceFile>(declItem.Decl),
LocRM.GetString("ErrorText64") + declItem.Decl.GetName().Text, true));
}
if (Options.Compiler.RemoveUnusedStructs)
{
if (declItem.Decl != null && declItem.Decl.Parent() != null)
{
declItem.Decl.Parent().RemoveChild(declItem.Decl);
}
}
}
}
if (Options.Compiler.RemoveUnusedStructs)
{
finalTrans.data.Structs.RemoveAll(declItem => !usedStructs.Contains(declItem.Decl));
}
if (children.Count > 0)
{
finalTrans.errors.Add(new ErrorCollection.Error(children[0], LocRM.GetString("ErrorText66"), children.ToArray()));
}
}
public override void CaseAMethodDecl(AMethodDecl node)
{
if (processStructs || processFieldsOnly || processMethodsOnly)
{
base.CaseAMethodDecl(node);
return;
}
bool removed = true;
List <AALocalDecl> couldntRemove = new List <AALocalDecl>();
while (removed)
{
removed = false;
definedLocals.Clear();
usedLocals.Clear();
assignedToLocals.Clear();
base.CaseAMethodDecl(node);
usedLocals.AddRange(finalTrans.data.GeneratedVariables);
foreach (AALocalDecl definedLocal in definedLocals)
{
if (!usedLocals.Contains(definedLocal) && !couldntRemove.Contains(definedLocal))
{
if ((Util.GetAncestor <AABlock>(definedLocal) != null || node.GetTrigger() == null) &&
finalTrans.data.UserLocals.Contains(definedLocal))
{
children.Add(new ErrorCollection.Error(definedLocal.GetName(),
Util.GetAncestor <AASourceFile>(node),
LocRM.GetString("ErrorText67") + definedLocal.GetName().Text, true));
}
removed = true;
//Remove decl);
if (definedLocal.Parent() is ALocalDeclStm)
{
ALocalDeclStm localDeclStm = (ALocalDeclStm)definedLocal.Parent();
RemoveVariableStatement(localDeclStm, definedLocal.GetInit(), localDeclStm.GetToken().Line, localDeclStm.GetToken().Pos);
}
//Dont remove parameters
else
{
couldntRemove.Add(definedLocal);
}
//Remove assignments);
foreach (AAssignmentExp assignmentExp in assignedToLocals[definedLocal])
{
if (assignmentExp.Parent() is AExpStm)
{
AExpStm stm = (AExpStm)assignmentExp.Parent();
RemoveVariableStatement(stm, assignmentExp.GetExp(), stm.GetToken().Line, stm.GetToken().Pos);
continue;
}
PExp exp = assignmentExp.GetExp();
assignmentExp.ReplaceBy(exp);
}
}
}
}
}
public override void CaseAExpStm(AExpStm node)
{
//Create node
GetNode(node);
}
public override void CaseAExpStm(AExpStm node)
{
node.GetExp().Apply(this);
Write(";\n");
}
