public VarVersionPair getVarVersionPair() { return new VarVersionPair(index, version); }
VarVersionPair varpaar = new VarVersionPair((VarExprent)((AssignmentExprent)lstExprents.get(firstcode == 2 ? 1 : 0)).getLeft()); if (expr.type == Exprent.EXPRENT_VAR && new VarVersionPair((VarExprent)expr).equals(varpaar)) { found = true; break; AssignmentExprent assexpr = (AssignmentExprent)exprent; if (assexpr.getRight().type == Exprent.EXPRENT_VAR && new VarVersionPair((VarExprent)assexpr.getRight()).equals(varpaar)) {
@Override public int hashCode() { return fieldKey.hashCode() + varPair.hashCode(); } }
@Override public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof VarFieldPair)) return false; VarFieldPair pair = (VarFieldPair)o; return fieldKey.equals(pair.fieldKey) && varPair.equals(pair.varPair); }
@Override public boolean equals(Object o) { if (o == this) return true; if (o == null || !(o instanceof VarFieldPair)) return false; VarFieldPair pair = (VarFieldPair)o; return fieldKey.equals(pair.fieldKey) && varPair.equals(pair.varPair); }
private static Exprent isReplaceableVar(Exprent exprent, Map<VarVersionPair, Exprent> mapVarValues) { Exprent dest = null; if (exprent.type == Exprent.EXPRENT_VAR) { VarExprent var = (VarExprent)exprent; dest = mapVarValues.get(new VarVersionPair(var)); } return dest; }
VarVersionPair varpaar = new VarVersionPair((VarExprent)((AssignmentExprent)lstExprents.get(firstcode == 2 ? 1 : 0)).getLeft()); if (expr.type == Exprent.EXPRENT_VAR && new VarVersionPair((VarExprent)expr).equals(varpaar)) { found = true; break; AssignmentExprent assexpr = (AssignmentExprent)exprent; if (assexpr.getRight().type == Exprent.EXPRENT_VAR && new VarVersionPair((VarExprent)assexpr.getRight()).equals(varpaar)) {
@Override public int hashCode() { return fieldKey.hashCode() + varPair.hashCode(); } }
public Set<VarVersionPair> getAllVariables() { List<Exprent> lstAllExprents = getAllExprents(true); lstAllExprents.add(this); Set<VarVersionPair> set = new HashSet<>(); for (Exprent expr : lstAllExprents) { if (expr.type == EXPRENT_VAR) { set.add(new VarVersionPair((VarExprent)expr)); } } return set; }
private static Set<VarVersionPair> getAllVersions(Exprent exprent) { Set<VarVersionPair> res = new HashSet<>(); List<Exprent> listTemp = new ArrayList<>(exprent.getAllExprents(true)); listTemp.add(exprent); for (Exprent expr : listTemp) { if (expr.type == Exprent.EXPRENT_VAR) { VarExprent var = (VarExprent)expr; res.add(new VarVersionPair(var)); } } return res; }
private Integer getNextFreeVersion(Integer var, Statement stat) { Integer nextver = lastversion.get(var); if (nextver == null) { nextver = 1; } else { nextver++; } lastversion.put(var, nextver); // save the first protected range, containing current statement if (stat != null) { // null iff phantom version Integer firstRangeId = getFirstProtectedRange(stat); if (firstRangeId != null) { mapVersionFirstRange.put(new VarVersionPair(var, nextver), firstRangeId); } } return nextver; }
set.add(ent.getKey()); for (Integer version : ent.getValue()) { set.add(new VarVersionPair(ent.getKey().var, version.intValue())); phiVersions.put(new VarVersionPair(paar.var, paar.version), min);
private static boolean isExprentIndependent(Exprent exprent, MethodWrapper method) { List<Exprent> lst = exprent.getAllExprents(true); lst.add(exprent); for (Exprent expr : lst) { switch (expr.type) { case Exprent.EXPRENT_VAR: VarVersionPair varPair = new VarVersionPair((VarExprent)expr); if (!method.varproc.getExternalVars().contains(varPair)) { String varName = method.varproc.getVarName(varPair); if (!varName.equals("this") && !varName.endsWith(".this")) { // FIXME: remove direct comparison with strings return false; } } break; case Exprent.EXPRENT_FIELD: return false; } } return true; } }
public static List<VarVersionPair> getSyntheticParametersMask(ClassNode node, String descriptor, int parameters) { List<VarVersionPair> mask = null; ClassWrapper wrapper = node.getWrapper(); if (wrapper != null) { // own class MethodWrapper methodWrapper = wrapper.getMethodWrapper(CodeConstants.INIT_NAME, descriptor); if (methodWrapper == null) { if (DecompilerContext.getOption(IFernflowerPreferences.IGNORE_INVALID_BYTECODE)) { return null; } throw new RuntimeException("Constructor " + node.classStruct.qualifiedName + "." + CodeConstants.INIT_NAME + descriptor + " not found"); } mask = methodWrapper.synthParameters; } else if (parameters > 0 && node.type == ClassNode.CLASS_MEMBER && (node.access & CodeConstants.ACC_STATIC) == 0) { // non-static member class mask = new ArrayList<>(Collections.nCopies(parameters, null)); mask.set(0, new VarVersionPair(-1, 0)); } return mask; } }
private static void updateVersions(DirectGraph graph, final Map<VarVersionPair, Integer> versions) { graph.iterateExprents(exprent -> { List<Exprent> lst = exprent.getAllExprents(true); lst.add(exprent); for (Exprent expr : lst) { if (expr.type == Exprent.EXPRENT_VAR) { VarExprent var = (VarExprent)expr; Integer version = versions.get(new VarVersionPair(var)); if (version != null) { var.setVersion(version); } } } return 0; }); }
StructClass cl = (StructClass)DecompilerContext.getProperty(DecompilerContext.CURRENT_CLASS); VarType clType = new VarType(CodeConstants.TYPE_OBJECT, 0, cl.qualifiedName); mapExprentMinTypes.put(new VarVersionPair(0, 1), clType); mapExprentMaxTypes.put(new VarVersionPair(0, 1), clType); mapExprentMinTypes.put(new VarVersionPair(varIndex + (thisVar ? 1 : 0), 1), md.params[i]); mapExprentMaxTypes.put(new VarVersionPair(varIndex + (thisVar ? 1 : 0), 1), md.params[i]); varIndex += md.params[i].stackSize; mapExprentMinTypes.put(new VarVersionPair(var.getIndex(), 1), var.getVarType()); mapExprentMaxTypes.put(new VarVersionPair(var.getIndex(), 1), var.getVarType());
VarVersionPair firstPair = new VarVersionPair(ent.getKey(), lstVersions.get(i)); VarType firstType = mapExprentMinTypes.get(firstPair); VarVersionPair secondPair = new VarVersionPair(ent.getKey(), lstVersions.get(j)); VarType secondType = mapExprentMinTypes.get(secondPair);
Set<VarVersionPair> verset = new HashSet<>(); for (Integer vers : mapLiveVars.get(varindex)) { verset.add(new VarVersionPair(varindex, vers.intValue())); Set<VarVersionPair> verset = new HashSet<>(); for (Integer vers : mapLiveVars.get(varindex)) { verset.add(new VarVersionPair(varindex, vers.intValue()));
public static boolean isInvocationInitConstructor(InvocationExprent inv, MethodWrapper method, ClassWrapper wrapper, boolean withThis) { if (inv.getFunctype() == InvocationExprent.TYP_INIT && inv.getInstance().type == Exprent.EXPRENT_VAR) { VarExprent instVar = (VarExprent)inv.getInstance(); VarVersionPair varPair = new VarVersionPair(instVar); String className = method.varproc.getThisVars().get(varPair); if (className != null) { // any this instance. TODO: Restrict to current class? return withThis || !wrapper.getClassStruct().qualifiedName.equals(inv.getClassname()); } } return false; } }
int newIndex = pair.version == 1 ? pair.var : counters.getCounterAndIncrement(CounterContainer.VAR_COUNTER); VarVersionPair newVar = new VarVersionPair(newIndex, 0); if (expr.type == Exprent.EXPRENT_VAR) { VarExprent newVar = (VarExprent)expr; Integer newVarIndex = mapVarPaar.get(new VarVersionPair(newVar)); if (newVarIndex != null) { newVar.setIndex(newVarIndex); VarType maxType = mapExprentMaxTypes.get(new VarVersionPair(expr.id, -1)); if (maxType != null && maxType.equals(VarType.VARTYPE_CHAR)) { ((ConstExprent)expr).setConstType(maxType);