private static bool IsAssertionField(Exprent exprent, string classname, string key
, bool throwInIf)
{
if (throwInIf)
{
if (exprent.type == Exprent.Exprent_Function)
{
FunctionExprent fparam = (FunctionExprent)exprent;
if (fparam.GetFuncType() == FunctionExprent.Function_Bool_Not && fparam.GetLstOperands
()[0].type == Exprent.Exprent_Field)
{
FieldExprent fdparam = (FieldExprent)fparam.GetLstOperands()[0];
return(classname.Equals(fdparam.GetClassname()) && key.Equals(InterpreterUtil.MakeUniqueKey
(fdparam.GetName(), fdparam.GetDescriptor().descriptorString)));
}
}
}
else if (exprent.type == Exprent.Exprent_Field)
{
FieldExprent fdparam = (FieldExprent)exprent;
return(classname.Equals(fdparam.GetClassname()) && key.Equals(InterpreterUtil.MakeUniqueKey
(fdparam.GetName(), fdparam.GetDescriptor().descriptorString)));
}
return(false);
}
private static void LiftConstructor(ClassWrapper wrapper)
{
foreach (MethodWrapper method in wrapper.GetMethods())
{
if (ICodeConstants.Init_Name.Equals(method.methodStruct.GetName()) && method.root
!= null)
{
Statement firstData = Statements.FindFirstData(method.root);
if (firstData == null)
{
return;
}
int index = 0;
List <Exprent> lstExprents = firstData.GetExprents();
foreach (Exprent exprent in lstExprents)
{
int action = 0;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent assignExpr = (AssignmentExprent)exprent;
if (assignExpr.GetLeft().type == Exprent.Exprent_Field && assignExpr.GetRight().type
== Exprent.Exprent_Var)
{
FieldExprent fExpr = (FieldExprent)assignExpr.GetLeft();
if (fExpr.GetClassname().Equals(wrapper.GetClassStruct().qualifiedName))
{
StructField structField = wrapper.GetClassStruct().GetField(fExpr.GetName(), fExpr
.GetDescriptor().descriptorString);
if (structField != null && structField.HasModifier(ICodeConstants.Acc_Final))
{
action = 1;
}
}
}
}
else if (index > 0 && exprent.type == Exprent.Exprent_Invocation && Statements.IsInvocationInitConstructor
((InvocationExprent)exprent, method, wrapper, true))
{
// this() or super()
lstExprents.Add(0, lstExprents.RemoveAtReturningValue(index));
action = 2;
}
if (action != 1)
{
break;
}
index++;
}
}
}
}
private static void ExtractStaticInitializers(ClassWrapper wrapper, MethodWrapper
method)
{
RootStatement root = method.root;
StructClass cl = wrapper.GetClassStruct();
Statement firstData = Statements.FindFirstData(root);
if (firstData != null)
{
bool inlineInitializers = cl.HasModifier(ICodeConstants.Acc_Interface) || cl.HasModifier
(ICodeConstants.Acc_Enum);
while (!(firstData.GetExprents().Count == 0))
{
Exprent exprent = firstData.GetExprents()[0];
bool found = false;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent assignExpr = (AssignmentExprent)exprent;
if (assignExpr.GetLeft().type == Exprent.Exprent_Field)
{
FieldExprent fExpr = (FieldExprent)assignExpr.GetLeft();
if (fExpr.IsStatic() && fExpr.GetClassname().Equals(cl.qualifiedName) && cl.HasField
(fExpr.GetName(), fExpr.GetDescriptor().descriptorString))
{
// interfaces fields should always be initialized inline
if (inlineInitializers || IsExprentIndependent(assignExpr.GetRight(), method))
{
string keyField = InterpreterUtil.MakeUniqueKey(fExpr.GetName(), fExpr.GetDescriptor
().descriptorString);
if (!wrapper.GetStaticFieldInitializers().ContainsKey(keyField))
{
wrapper.GetStaticFieldInitializers().AddWithKey(assignExpr.GetRight(), keyField);
firstData.GetExprents().RemoveAtReturningValue(0);
found = true;
}
}
}
}
}
if (!found)
{
break;
}
}
}
}
public static void Simplify(SwitchStatement switchStatement)
{
SwitchExprent switchExprent = (SwitchExprent)switchStatement.GetHeadexprent();
Exprent value = switchExprent.GetValue();
if (IsEnumArray(value))
{
List <List <Exprent> > caseValues = switchStatement.GetCaseValues();
Dictionary <Exprent, Exprent> mapping = new Dictionary <Exprent, Exprent>(caseValues
.Count);
ArrayExprent array = (ArrayExprent)value;
FieldExprent arrayField = (FieldExprent)array.GetArray();
ClassesProcessor.ClassNode classNode = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(arrayField.GetClassname());
if (classNode != null)
{
MethodWrapper wrapper = classNode.GetWrapper().GetMethodWrapper(ICodeConstants.Clinit_Name
, "()V");
if (wrapper != null && wrapper.root != null)
{
wrapper.GetOrBuildGraph().IterateExprents((Exprent exprent) => {
if (exprent is AssignmentExprent)
{
AssignmentExprent assignment = (AssignmentExprent)exprent;
Exprent left = assignment.GetLeft();
if (left.type == Exprent.Exprent_Array && ((ArrayExprent)left).GetArray().Equals(
arrayField))
{
Sharpen.Collections.Put(mapping, assignment.GetRight(), ((InvocationExprent)((ArrayExprent
)left).GetIndex()).GetInstance());
}
}
return(0);
}
);
}
}
List <List <Exprent> > realCaseValues = new List <List <Exprent> >(caseValues.Count);
foreach (List <Exprent> caseValue in caseValues)
{
List <Exprent> values = new List <Exprent>(caseValue.Count);
realCaseValues.Add(values);
foreach (Exprent exprent in caseValue)
{
if (exprent == null)
{
values.Add(null);
}
else
{
Exprent realConst = mapping.GetOrNull(exprent);
if (realConst == null)
{
DecompilerContext.GetLogger().WriteMessage("Unable to simplify switch on enum: "
+ exprent + " not found, available: " + mapping, IFernflowerLogger.Severity.Error
);
return;
}
values.Add(realConst.Copy());
}
}
}
caseValues.Clear();
Sharpen.Collections.AddAll(caseValues, realCaseValues);
switchExprent.ReplaceExprent(value, ((InvocationExprent)array.GetIndex()).GetInstance
().Copy());
}
}
private static string IsClass14Invocation(Exprent exprent, ClassWrapper wrapper,
MethodWrapper meth)
{
if (exprent.type == Exprent.Exprent_Function)
{
FunctionExprent fexpr = (FunctionExprent)exprent;
if (fexpr.GetFuncType() == FunctionExprent.Function_Iif)
{
if (fexpr.GetLstOperands()[0].type == Exprent.Exprent_Function)
{
FunctionExprent headexpr = (FunctionExprent)fexpr.GetLstOperands()[0];
if (headexpr.GetFuncType() == FunctionExprent.Function_Eq)
{
if (headexpr.GetLstOperands()[0].type == Exprent.Exprent_Field && headexpr.GetLstOperands
()[1].type == Exprent.Exprent_Const && ((ConstExprent)headexpr.GetLstOperands()[
1]).GetConstType().Equals(VarType.Vartype_Null))
{
FieldExprent field = (FieldExprent)headexpr.GetLstOperands()[0];
ClassesProcessor.ClassNode fieldnode = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(field.GetClassname());
if (fieldnode != null && fieldnode.classStruct.qualifiedName.Equals(wrapper.GetClassStruct
().qualifiedName))
{
// source class
StructField fd = wrapper.GetClassStruct().GetField(field.GetName(), field.GetDescriptor
().descriptorString);
// FIXME: can be null! why??
if (fd != null && fd.HasModifier(ICodeConstants.Acc_Static) && (fd.IsSynthetic() ||
DecompilerContext.GetOption(IFernflowerPreferences.Synthetic_Not_Set)))
{
if (fexpr.GetLstOperands()[1].type == Exprent.Exprent_Assignment && fexpr.GetLstOperands
()[2].Equals(field))
{
AssignmentExprent asexpr = (AssignmentExprent)fexpr.GetLstOperands()[1];
if (asexpr.GetLeft().Equals(field) && asexpr.GetRight().type == Exprent.Exprent_Invocation)
{
InvocationExprent invexpr = (InvocationExprent)asexpr.GetRight();
if (invexpr.GetClassname().Equals(wrapper.GetClassStruct().qualifiedName) && invexpr
.GetName().Equals(meth.methodStruct.GetName()) && invexpr.GetStringDescriptor().
Equals(meth.methodStruct.GetDescriptor()))
{
if (invexpr.GetLstParameters()[0].type == Exprent.Exprent_Const)
{
wrapper.GetHiddenMembers().Add(InterpreterUtil.MakeUniqueKey(fd.GetName(), fd.GetDescriptor
()));
// hide synthetic field
return(((ConstExprent)invexpr.GetLstParameters()[0]).GetValue().ToString());
}
}
}
}
}
}
}
}
}
}
}
return(null);
}
private static void ExtractDynamicInitializers(ClassWrapper wrapper)
{
StructClass cl = wrapper.GetClassStruct();
bool isAnonymous = DecompilerContext.GetClassProcessor().GetMapRootClasses().GetOrNull
(cl.qualifiedName).type == ClassesProcessor.ClassNode.Class_Anonymous;
List <List <Exprent> > lstFirst = new List <List <Exprent> >();
List <MethodWrapper> lstMethodWrappers = new List <MethodWrapper>();
foreach (MethodWrapper method in wrapper.GetMethods())
{
if (ICodeConstants.Init_Name.Equals(method.methodStruct.GetName()) && method.root
!= null)
{
// successfully decompiled constructor
Statement firstData = Statements.FindFirstData(method.root);
if (firstData == null || (firstData.GetExprents().Count == 0))
{
return;
}
lstFirst.Add(firstData.GetExprents());
lstMethodWrappers.Add(method);
Exprent exprent = firstData.GetExprents()[0];
if (!isAnonymous)
{
// FIXME: doesn't make sense
if (exprent.type != Exprent.Exprent_Invocation || !Statements.IsInvocationInitConstructor
((InvocationExprent)exprent, method, wrapper, false))
{
return;
}
}
}
}
if ((lstFirst.Count == 0))
{
return;
}
while (true)
{
string fieldWithDescr = null;
Exprent value = null;
for (int i = 0; i < lstFirst.Count; i++)
{
List <Exprent> lst = lstFirst[i];
if (lst.Count < (isAnonymous ? 1 : 2))
{
return;
}
Exprent exprent = lst[isAnonymous ? 0 : 1];
bool found = false;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent assignExpr = (AssignmentExprent)exprent;
if (assignExpr.GetLeft().type == Exprent.Exprent_Field)
{
FieldExprent fExpr = (FieldExprent)assignExpr.GetLeft();
if (!fExpr.IsStatic() && fExpr.GetClassname().Equals(cl.qualifiedName) && cl.HasField
(fExpr.GetName(), fExpr.GetDescriptor().descriptorString))
{
// check for the physical existence of the field. Could be defined in a superclass.
if (IsExprentIndependent(assignExpr.GetRight(), lstMethodWrappers[i]))
{
string fieldKey = InterpreterUtil.MakeUniqueKey(fExpr.GetName(), fExpr.GetDescriptor
().descriptorString);
if (fieldWithDescr == null)
{
fieldWithDescr = fieldKey;
value = assignExpr.GetRight();
}
else if (!fieldWithDescr.Equals(fieldKey) || !value.Equals(assignExpr.GetRight()))
{
return;
}
found = true;
}
}
}
}
if (!found)
{
return;
}
}
if (!wrapper.GetDynamicFieldInitializers().ContainsKey(fieldWithDescr))
{
wrapper.GetDynamicFieldInitializers().AddWithKey(value, fieldWithDescr);
foreach (List <Exprent> lst in lstFirst)
{
lst.RemoveAtReturningValue(isAnonymous ? 0 : 1);
}
}
else
{
return;
}
}
}
private void ComputeMethodType(ClassesProcessor.ClassNode node, MethodWrapper method
)
{
NestedMemberAccess.MethodAccess type = NestedMemberAccess.MethodAccess.Normal;
if (method.root != null)
{
DirectGraph graph = method.GetOrBuildGraph();
StructMethod mt = method.methodStruct;
if ((noSynthFlag || mt.IsSynthetic()) && mt.HasModifier(ICodeConstants.Acc_Static
))
{
if (graph.nodes.Count == 2)
{
// incl. dummy exit node
if (graph.first.exprents.Count == 1)
{
Exprent exprent = graph.first.exprents[0];
MethodDescriptor mtdesc = MethodDescriptor.ParseDescriptor(mt.GetDescriptor());
int parcount = [email protected];
Exprent exprCore = exprent;
if (exprent.type == Exprent.Exprent_Exit)
{
ExitExprent exexpr = (ExitExprent)exprent;
if (exexpr.GetExitType() == ExitExprent.Exit_Return && exexpr.GetValue() != null)
{
exprCore = exexpr.GetValue();
}
}
switch (exprCore.type)
{
case Exprent.Exprent_Field:
{
FieldExprent fexpr = (FieldExprent)exprCore;
if ((parcount == 1 && !fexpr.IsStatic()) || (parcount == 0 && fexpr.IsStatic()))
{
if (fexpr.GetClassname().Equals(node.classStruct.qualifiedName))
{
// FIXME: check for private flag of the field
if (fexpr.IsStatic() || (fexpr.GetInstance().type == Exprent.Exprent_Var && ((VarExprent
)fexpr.GetInstance()).GetIndex() == 0))
{
type = NestedMemberAccess.MethodAccess.Field_Get;
}
}
}
break;
}
case Exprent.Exprent_Var:
{
// qualified this
if (parcount == 1)
{
// this or final variable
if (((VarExprent)exprCore).GetIndex() != 0)
{
type = NestedMemberAccess.MethodAccess.Field_Get;
}
}
break;
}
case Exprent.Exprent_Function:
{
// for now detect only increment/decrement
FunctionExprent functionExprent = (FunctionExprent)exprCore;
if (functionExprent.GetFuncType() >= FunctionExprent.Function_Imm && functionExprent
.GetFuncType() <= FunctionExprent.Function_Ppi)
{
if (functionExprent.GetLstOperands()[0].type == Exprent.Exprent_Field)
{
type = NestedMemberAccess.MethodAccess.Function;
}
}
break;
}
case Exprent.Exprent_Invocation:
{
type = NestedMemberAccess.MethodAccess.Method;
break;
}
case Exprent.Exprent_Assignment:
{
AssignmentExprent asexpr = (AssignmentExprent)exprCore;
if (asexpr.GetLeft().type == Exprent.Exprent_Field && asexpr.GetRight().type == Exprent
.Exprent_Var)
{
FieldExprent fexpras = (FieldExprent)asexpr.GetLeft();
if ((parcount == 2 && !fexpras.IsStatic()) || (parcount == 1 && fexpras.IsStatic(
)))
{
if (fexpras.GetClassname().Equals(node.classStruct.qualifiedName))
{
// FIXME: check for private flag of the field
if (fexpras.IsStatic() || (fexpras.GetInstance().type == Exprent.Exprent_Var && (
(VarExprent)fexpras.GetInstance()).GetIndex() == 0))
{
if (((VarExprent)asexpr.GetRight()).GetIndex() == parcount - 1)
{
type = NestedMemberAccess.MethodAccess.Field_Set;
}
}
}
}
}
break;
}
}
if (type == NestedMemberAccess.MethodAccess.Method)
{
// FIXME: check for private flag of the method
type = NestedMemberAccess.MethodAccess.Normal;
InvocationExprent invexpr = (InvocationExprent)exprCore;
bool isStatic = invexpr.IsStatic();
if ((isStatic && invexpr.GetLstParameters().Count == parcount) || (!isStatic && invexpr
.GetInstance().type == Exprent.Exprent_Var && ((VarExprent)invexpr.GetInstance()
).GetIndex() == 0 && invexpr.GetLstParameters().Count == parcount - 1))
{
bool equalpars = true;
int index = isStatic ? 0 : 1;
for (int i = 0; i < invexpr.GetLstParameters().Count; i++)
{
Exprent parexpr = invexpr.GetLstParameters()[i];
if (parexpr.type != Exprent.Exprent_Var || ((VarExprent)parexpr).GetIndex() != index)
{
equalpars = false;
break;
}
index += mtdesc.@params[i + (isStatic ? 0 : 1)].stackSize;
}
if (equalpars)
{
type = NestedMemberAccess.MethodAccess.Method;
}
}
}
}
else if (graph.first.exprents.Count == 2)
{
Exprent exprentFirst = graph.first.exprents[0];
Exprent exprentSecond = graph.first.exprents[1];
if (exprentFirst.type == Exprent.Exprent_Assignment && exprentSecond.type == Exprent
.Exprent_Exit)
{
MethodDescriptor mtdesc = MethodDescriptor.ParseDescriptor(mt.GetDescriptor());
int parcount = [email protected];
AssignmentExprent asexpr = (AssignmentExprent)exprentFirst;
if (asexpr.GetLeft().type == Exprent.Exprent_Field && asexpr.GetRight().type == Exprent
.Exprent_Var)
{
FieldExprent fexpras = (FieldExprent)asexpr.GetLeft();
if ((parcount == 2 && !fexpras.IsStatic()) || (parcount == 1 && fexpras.IsStatic(
)))
{
if (fexpras.GetClassname().Equals(node.classStruct.qualifiedName))
{
// FIXME: check for private flag of the field
if (fexpras.IsStatic() || (fexpras.GetInstance().type == Exprent.Exprent_Var && (
(VarExprent)fexpras.GetInstance()).GetIndex() == 0))
{
if (((VarExprent)asexpr.GetRight()).GetIndex() == parcount - 1)
{
ExitExprent exexpr = (ExitExprent)exprentSecond;
if (exexpr.GetExitType() == ExitExprent.Exit_Return && exexpr.GetValue() != null)
{
if (exexpr.GetValue().type == Exprent.Exprent_Var && ((VarExprent)asexpr.GetRight
()).GetIndex() == parcount - 1)
{
type = NestedMemberAccess.MethodAccess.Field_Set;
}
}
}
}
}
}
}
}
}
}
}
}
if (type != NestedMemberAccess.MethodAccess.Normal)
{
Sharpen.Collections.Put(mapMethodType, method, type);
}
else
{
Sharpen.Collections.Remove(mapMethodType, method);
}
}