public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
SwitchHelper.Simplify(this);
TextBuffer buf = new TextBuffer();
buf.Append(ExprProcessor.ListToJava(varDefinitions, indent, tracer));
buf.Append(first.ToJava(indent, tracer));
if (IsLabeled())
{
buf.AppendIndent(indent).Append("label").Append(this.id.ToString()).Append(":").AppendLineSeparator
();
tracer.IncrementCurrentSourceLine();
}
buf.AppendIndent(indent).Append(headexprent[0].ToJava(indent, tracer)).Append(" {"
).AppendLineSeparator();
tracer.IncrementCurrentSourceLine();
VarType switch_type = headexprent[0].GetExprType();
for (int i = 0; i < caseStatements.Count; i++)
{
Statement stat = caseStatements[i];
List <StatEdge> edges = caseEdges[i];
List <Exprent> values = caseValues[i];
for (int j = 0; j < edges.Count; j++)
{
if (edges[j] == default_edge)
{
buf.AppendIndent(indent).Append("default:").AppendLineSeparator();
}
else
{
buf.AppendIndent(indent).Append("case ");
Exprent value = values[j];
if (value is ConstExprent)
{
value = value.Copy();
((ConstExprent)value).SetConstType(switch_type);
}
if (value is FieldExprent && ((FieldExprent)value).IsStatic())
{
// enum values
buf.Append(((FieldExprent)value).GetName());
}
else
{
buf.Append(value.ToJava(indent, tracer));
}
buf.Append(":").AppendLineSeparator();
}
tracer.IncrementCurrentSourceLine();
}
buf.Append(ExprProcessor.JmpWrapper(stat, indent + 1, false, tracer));
}
buf.AppendIndent(indent).Append("}").AppendLineSeparator();
tracer.IncrementCurrentSourceLine();
return(buf);
}
private static object[] IterateChildExprent(Exprent exprent, Exprent parent, Exprent
next, Dictionary <VarVersionPair, Exprent> mapVarValues, SSAUConstructorSparseEx
ssau)
{
bool changed = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
var oldExpr = expr;
while (true)
{
object[] arr = IterateChildExprent(oldExpr, parent, next, mapVarValues, ssau);
Exprent retexpr = (Exprent)arr[0];
changed |= (bool)arr[1];
bool isReplaceable = (bool)arr[2];
if (retexpr != null)
{
if (isReplaceable)
{
ReplaceSingleVar(exprent, (VarExprent)oldExpr, retexpr, ssau);
oldExpr = retexpr;
}
else
{
exprent.ReplaceExprent(oldExpr, retexpr);
}
changed = true;
}
if (!isReplaceable)
{
break;
}
}
}
Exprent dest = IsReplaceableVar(exprent, mapVarValues);
if (dest != null)
{
return(new object[] { dest, true, true });
}
VarExprent left = null;
Exprent right = null;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent @as = (AssignmentExprent)exprent;
if (@as.GetLeft().type == Exprent.Exprent_Var)
{
left = (VarExprent)@as.GetLeft();
right = @as.GetRight();
}
}
if (left == null)
{
return(new object[] { null, changed, false });
}
bool isHeadSynchronized = false;
if (next == null && parent.type == Exprent.Exprent_Monitor)
{
MonitorExprent monexpr = (MonitorExprent)parent;
if (monexpr.GetMonType() == MonitorExprent.Monitor_Enter && exprent.Equals(monexpr
.GetValue()))
{
isHeadSynchronized = true;
}
}
// stack variable or synchronized head exprent
if (!left.IsStack() && !isHeadSynchronized)
{
return(new object[] { null, changed, false });
}
VarVersionPair leftpaar = new VarVersionPair(left);
List <VarVersionNode> usedVers = new List <VarVersionNode>();
bool notdom = GetUsedVersions(ssau, leftpaar, usedVers);
if (!notdom && (usedVers.Count == 0))
{
return(new object[] { right, changed, false });
}
// stack variables only
if (!left.IsStack())
{
return(new object[] { null, changed, false });
}
int useflags = right.GetExprentUse();
if ((useflags & Exprent.Both_Flags) != Exprent.Both_Flags)
{
return(new object[] { null, changed, false });
}
Dictionary <int, HashSet <VarVersionPair> > mapVars = GetAllVarVersions(leftpaar, right
, ssau);
if (mapVars.ContainsKey(leftpaar.var) && notdom)
{
return(new object[] { null, changed, false });
}
Sharpen.Collections.Remove(mapVars, leftpaar.var);
HashSet <VarVersionPair> setAllowedVars = GetAllVersions(parent);
if (next != null)
{
Sharpen.Collections.AddAll(setAllowedVars, GetAllVersions(next));
}
bool vernotreplaced = false;
HashSet <VarVersionPair> setTempUsedVers = new HashSet <VarVersionPair>();
foreach (VarVersionNode usedvar in usedVers)
{
VarVersionPair usedver = new VarVersionPair(usedvar.var, usedvar.version);
if (IsVersionToBeReplaced(usedver, mapVars, ssau, leftpaar) && (right.type == Exprent
.Exprent_Var || setAllowedVars.Contains(usedver)))
{
setTempUsedVers.Add(usedver);
}
else
{
vernotreplaced = true;
}
}
if (!notdom && !vernotreplaced)
{
foreach (VarVersionPair usedver in setTempUsedVers)
{
Exprent copy = right.Copy();
if (right.type == Exprent.Exprent_Field && ssau.GetMapFieldVars().ContainsKey(right
.id))
{
Sharpen.Collections.Put(ssau.GetMapFieldVars(), copy.id, ssau.GetMapFieldVars().GetOrNullable
(right.id));
}
Sharpen.Collections.Put(mapVarValues, usedver, copy);
}
// remove assignment
return(new object[] { right, changed, false });
}
return(new object[] { null, changed, false });
}
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 int[] IterateExprent(List <Exprent> lstExprents, int index, Exprent next,
Dictionary <VarVersionPair, Exprent> mapVarValues, SSAUConstructorSparseEx ssau)
{
Exprent exprent = lstExprents[index];
int changed = 0;
foreach (Exprent expr in exprent.GetAllExprents())
{
var oldExpr = expr;
while (true)
{
object[] arr = IterateChildExprent(oldExpr, exprent, next, mapVarValues, ssau);
Exprent retexpr = (Exprent)arr[0];
changed |= (bool)arr[1] ? 1 : 0;
bool isReplaceable = (bool)arr[2];
if (retexpr != null)
{
if (isReplaceable)
{
ReplaceSingleVar(exprent, (VarExprent)oldExpr, retexpr, ssau);
oldExpr = retexpr;
}
else
{
exprent.ReplaceExprent(oldExpr, retexpr);
}
changed = 1;
}
if (!isReplaceable)
{
break;
}
}
}
// no var on the highest level, so no replacing
VarExprent left = null;
Exprent right = null;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent @as = (AssignmentExprent)exprent;
if (@as.GetLeft().type == Exprent.Exprent_Var)
{
left = (VarExprent)@as.GetLeft();
right = @as.GetRight();
}
}
if (left == null)
{
return(new int[] { -1, changed });
}
VarVersionPair leftpaar = new VarVersionPair(left);
List <VarVersionNode> usedVers = new List <VarVersionNode>();
bool notdom = GetUsedVersions(ssau, leftpaar, usedVers);
if (!notdom && (usedVers.Count == 0))
{
if (left.IsStack() && (right.type == Exprent.Exprent_Invocation || right.type ==
Exprent.Exprent_Assignment || right.type == Exprent.Exprent_New))
{
if (right.type == Exprent.Exprent_New)
{
// new Object(); permitted
NewExprent nexpr = (NewExprent)right;
if (nexpr.IsAnonymous() || nexpr.GetNewType().arrayDim > 0 || nexpr.GetNewType().
type != ICodeConstants.Type_Object)
{
return(new int[] { -1, changed });
}
}
lstExprents[index] = right;
return(new int[] { index + 1, 1 });
}
else if (right.type == Exprent.Exprent_Var)
{
lstExprents.RemoveAtReturningValue(index);
return(new int[] { index, 1 });
}
else
{
return(new int[] { -1, changed });
}
}
int useflags = right.GetExprentUse();
// stack variables only
if (!left.IsStack() && (right.type != Exprent.Exprent_Var || ((VarExprent)right).
IsStack()))
{
// special case catch(... ex)
return(new int[] { -1, changed });
}
if ((useflags & Exprent.Multiple_Uses) == 0 && (notdom || usedVers.Count > 1))
{
return(new int[] { -1, changed });
}
Dictionary <int, HashSet <VarVersionPair> > mapVars = GetAllVarVersions(leftpaar, right
, ssau);
bool isSelfReference = mapVars.ContainsKey(leftpaar.var);
if (isSelfReference && notdom)
{
return(new int[] { -1, changed });
}
HashSet <VarVersionPair> setNextVars = next == null ? null : GetAllVersions(next);
// FIXME: fix the entire method!
if (right.type != Exprent.Exprent_Const && right.type != Exprent.Exprent_Var && setNextVars
!= null && mapVars.ContainsKey(leftpaar.var))
{
foreach (VarVersionNode usedvar in usedVers)
{
if (!setNextVars.Contains(new VarVersionPair(usedvar.var, usedvar.version)))
{
return(new int[] { -1, changed });
}
}
}
Sharpen.Collections.Remove(mapVars, leftpaar.var);
bool vernotreplaced = false;
bool verreplaced = false;
HashSet <VarVersionPair> setTempUsedVers = new HashSet <VarVersionPair>();
foreach (VarVersionNode usedvar in usedVers)
{
VarVersionPair usedver = new VarVersionPair(usedvar.var, usedvar.version);
if (IsVersionToBeReplaced(usedver, mapVars, ssau, leftpaar) && (right.type == Exprent
.Exprent_Const || right.type == Exprent.Exprent_Var || right.type == Exprent.Exprent_Field ||
setNextVars == null || setNextVars.Contains(usedver)))
{
setTempUsedVers.Add(usedver);
verreplaced = true;
}
else
{
vernotreplaced = true;
}
}
if (isSelfReference && vernotreplaced)
{
return(new int[] { -1, changed });
}
else
{
foreach (VarVersionPair usedver in setTempUsedVers)
{
Exprent copy = right.Copy();
if (right.type == Exprent.Exprent_Field && ssau.GetMapFieldVars().ContainsKey(right
.id))
{
Sharpen.Collections.Put(ssau.GetMapFieldVars(), copy.id, ssau.GetMapFieldVars().GetOrNullable
(right.id));
}
Sharpen.Collections.Put(mapVarValues, usedver, copy);
}
}
if (!notdom && !vernotreplaced)
{
// remove assignment
lstExprents.RemoveAtReturningValue(index);
return(new int[] { index, 1 });
}
else if (verreplaced)
{
return(new int[] { index + 1, changed });
}
else
{
return(new int[] { -1, changed });
}
}
private Exprent ReplaceAccessExprent(ClassesProcessor.ClassNode caller, MethodWrapper
methdest, InvocationExprent invexpr)
{
ClassesProcessor.ClassNode node = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(invexpr.GetClassname());
MethodWrapper methsource = null;
if (node != null && node.GetWrapper() != null)
{
methsource = node.GetWrapper().GetMethodWrapper(invexpr.GetName(), invexpr.GetStringDescriptor
());
}
if (methsource == null || !mapMethodType.ContainsKey(methsource))
{
return(null);
}
// if same method, return
if (node.classStruct.qualifiedName.Equals(caller.classStruct.qualifiedName) && methsource
.methodStruct.GetName().Equals(methdest.methodStruct.GetName()) && methsource.methodStruct
.GetDescriptor().Equals(methdest.methodStruct.GetDescriptor()))
{
// no recursive invocations permitted!
return(null);
}
NestedMemberAccess.MethodAccess type = mapMethodType.GetOrNull(methsource);
// // FIXME: impossible case. MethodAccess.NORMAL is not saved in the map
// if(type == MethodAccess.NORMAL) {
// return null;
// }
if (!SameTree(caller, node))
{
return(null);
}
DirectGraph graph = methsource.GetOrBuildGraph();
Exprent source = graph.first.exprents[0];
Exprent retexprent = null;
switch (type.ordinal())
{
case 1:
{
ExitExprent exsource = (ExitExprent)source;
if (exsource.GetValue().type == Exprent.Exprent_Var)
{
// qualified this
VarExprent var = (VarExprent)exsource.GetValue();
string varname = methsource.varproc.GetVarName(new VarVersionPair(var));
if (!methdest.setOuterVarNames.Contains(varname))
{
VarNamesCollector vnc = new VarNamesCollector();
vnc.AddName(varname);
methdest.varproc.RefreshVarNames(vnc);
methdest.setOuterVarNames.Add(varname);
}
int index = methdest.counter.GetCounterAndIncrement(CounterContainer.Var_Counter);
VarExprent ret = new VarExprent(index, var.GetVarType(), methdest.varproc);
methdest.varproc.SetVarName(new VarVersionPair(index, 0), varname);
retexprent = ret;
}
else
{
// field
FieldExprent ret = (FieldExprent)exsource.GetValue().Copy();
if (!ret.IsStatic())
{
ret.ReplaceExprent(ret.GetInstance(), invexpr.GetLstParameters()[0]);
}
retexprent = ret;
}
break;
}
case 2:
{
AssignmentExprent ret_1;
if (source.type == Exprent.Exprent_Exit)
{
ExitExprent extex = (ExitExprent)source;
ret_1 = (AssignmentExprent)extex.GetValue().Copy();
}
else
{
ret_1 = (AssignmentExprent)source.Copy();
}
FieldExprent fexpr = (FieldExprent)ret_1.GetLeft();
if (fexpr.IsStatic())
{
ret_1.ReplaceExprent(ret_1.GetRight(), invexpr.GetLstParameters()[0]);
}
else
{
ret_1.ReplaceExprent(ret_1.GetRight(), invexpr.GetLstParameters()[1]);
fexpr.ReplaceExprent(fexpr.GetInstance(), invexpr.GetLstParameters()[0]);
}
// do not use copied bytecodes
ret_1.GetLeft().bytecode = null;
ret_1.GetRight().bytecode = null;
retexprent = ret_1;
break;
}
case 4:
{
retexprent = ReplaceFunction(invexpr, source);
break;
}
case 3:
{
if (source.type == Exprent.Exprent_Exit)
{
source = ((ExitExprent)source).GetValue();
}
InvocationExprent invret = (InvocationExprent)source.Copy();
int index_1 = 0;
if (!invret.IsStatic())
{
invret.ReplaceExprent(invret.GetInstance(), invexpr.GetLstParameters()[0]);
index_1 = 1;
}
for (int i = 0; i < invret.GetLstParameters().Count; i++)
{
invret.ReplaceExprent(invret.GetLstParameters()[i], invexpr.GetLstParameters()[i
+ index_1]);
}
retexprent = invret;
break;
}
}
if (retexprent != null)
{
// preserve original bytecodes
retexprent.bytecode = null;
retexprent.AddBytecodeOffsets(invexpr.bytecode);
// hide synthetic access method
bool hide = true;
if (node.type == ClassesProcessor.ClassNode.Class_Root || (node.access & ICodeConstants
.Acc_Static) != 0)
{
StructMethod mt = methsource.methodStruct;
if (!mt.IsSynthetic())
{
hide = false;
}
}
if (hide)
{
node.GetWrapper().GetHiddenMembers().Add(InterpreterUtil.MakeUniqueKey(invexpr.GetName
(), invexpr.GetStringDescriptor()));
}
}
return(retexprent);
}
