public virtual VarVersionNode CreateNode(VarVersionPair ver)
{
VarVersionNode node;
nodes.AddWithKey(node = new VarVersionNode(ver.var, ver.version), ver);
return(node);
}
public override bool Equals(object o)
{
if (o == this)
{
return(true);
}
if (!(o is VarVersionPair))
{
return(false);
}
VarVersionPair paar = (VarVersionPair)o;
return(var == paar.var && version == paar.version);
}
private bool CheckTypeExprent(Exprent exprent)
{
foreach (Exprent expr in exprent.GetAllExprents())
{
if (!CheckTypeExprent(expr))
{
return(false);
}
}
if (exprent.type == Exprent.Exprent_Const)
{
ConstExprent constExpr = (ConstExprent)exprent;
if (constExpr.GetConstType().typeFamily <= ICodeConstants.Type_Family_Integer)
{
// boolean or integer
VarVersionPair pair = new VarVersionPair(constExpr.id, -1);
if (!mapExprentMinTypes.ContainsKey(pair))
{
Sharpen.Collections.Put(mapExprentMinTypes, pair, constExpr.GetConstType());
}
}
}
CheckTypesResult result = exprent.CheckExprTypeBounds();
bool res = true;
if (result != null)
{
foreach (CheckTypesResult.ExprentTypePair entry in result.GetLstMaxTypeExprents())
{
if (entry.type.typeFamily != ICodeConstants.Type_Family_Object)
{
ChangeExprentType(entry.exprent, entry.type, 1);
}
}
foreach (CheckTypesResult.ExprentTypePair entry in result.GetLstMinTypeExprents())
{
res &= ChangeExprentType(entry.exprent, entry.type, 0);
}
}
return(res);
}
public virtual void SetVarName(VarVersionPair pair, string name)
{
Sharpen.Collections.Put(mapVarNames, pair, name);
}
public virtual string GetVarName(VarVersionPair pair)
{
return(mapVarNames == null ? null : mapVarNames.GetOrNull(pair));
}
public virtual void SetVarType(VarVersionPair pair, VarType type)
{
varVersions.SetVarType(pair, type);
}
public virtual VarType GetVarType(VarVersionPair pair)
{
return(varVersions == null ? null : varVersions.GetVarType(pair));
}
private bool ChangeExprentType(Exprent exprent, VarType newType, int minMax)
{
bool res = true;
switch (exprent.type)
{
case Exprent.Exprent_Const:
{
ConstExprent constExpr = (ConstExprent)exprent;
VarType constType = constExpr.GetConstType();
if (newType.typeFamily > ICodeConstants.Type_Family_Integer || constType.typeFamily
> ICodeConstants.Type_Family_Integer)
{
return(true);
}
else if (newType.typeFamily == ICodeConstants.Type_Family_Integer)
{
VarType minInteger = new ConstExprent((int)constExpr.GetValue(), false, null).GetConstType
();
if (minInteger.IsStrictSuperset(newType))
{
newType = minInteger;
}
}
goto case Exprent.Exprent_Var;
}
case Exprent.Exprent_Var:
{
VarVersionPair pair = null;
if (exprent.type == Exprent.Exprent_Const)
{
pair = new VarVersionPair(((ConstExprent)exprent).id, -1);
}
else if (exprent.type == Exprent.Exprent_Var)
{
pair = new VarVersionPair((VarExprent)exprent);
}
if (minMax == 0)
{
// min
VarType currentMinType = mapExprentMinTypes.GetOrNull(pair);
VarType newMinType;
if (currentMinType == null || newType.typeFamily > currentMinType.typeFamily)
{
newMinType = newType;
}
else if (newType.typeFamily < currentMinType.typeFamily)
{
return(true);
}
else
{
newMinType = VarType.GetCommonSupertype(currentMinType, newType);
}
Sharpen.Collections.Put(mapExprentMinTypes, pair, newMinType);
if (exprent.type == Exprent.Exprent_Const)
{
((ConstExprent)exprent).SetConstType(newMinType);
}
if (currentMinType != null && (newMinType.typeFamily > currentMinType.typeFamily ||
newMinType.IsStrictSuperset(currentMinType)))
{
return(false);
}
}
else
{
// max
VarType currentMaxType = mapExprentMaxTypes.GetOrNull(pair);
VarType newMaxType;
if (currentMaxType == null || newType.typeFamily < currentMaxType.typeFamily)
{
newMaxType = newType;
}
else if (newType.typeFamily > currentMaxType.typeFamily)
{
return(true);
}
else
{
newMaxType = VarType.GetCommonMinType(currentMaxType, newType);
}
Sharpen.Collections.Put(mapExprentMaxTypes, pair, newMaxType);
}
break;
}
case Exprent.Exprent_Assignment:
{
return(ChangeExprentType(((AssignmentExprent)exprent).GetRight(), newType, minMax
));
}
case Exprent.Exprent_Function:
{
FunctionExprent func = (FunctionExprent)exprent;
switch (func.GetFuncType())
{
case FunctionExprent.Function_Iif:
{
// FIXME:
res = ChangeExprentType(func.GetLstOperands()[1], newType, minMax) & ChangeExprentType
(func.GetLstOperands()[2], newType, minMax);
break;
}
case FunctionExprent.Function_And:
case FunctionExprent.Function_Or:
case FunctionExprent.Function_Xor:
{
res = ChangeExprentType(func.GetLstOperands()[0], newType, minMax) & ChangeExprentType
(func.GetLstOperands()[1], newType, minMax);
break;
}
}
break;
}
}
return(res);
}
public virtual int GetVarFinal(VarVersionPair pair)
{
int?fin = typeProcessor.GetMapFinalVars().GetOrNullable(pair);
return(fin == null ? VarTypeProcessor.Var_Final : fin.Value);
}
public virtual void SetVarType(VarVersionPair pair, VarType type)
{
typeProcessor.SetVarType(pair, type);
}
public virtual VarType GetVarType(VarVersionPair pair)
{
return(typeProcessor.GetVarType(pair));
}
private void SetNewVarIndices(VarTypeProcessor typeProcessor, DirectGraph graph,
VarVersionsProcessor previousVersionsProcessor)
{
Dictionary <VarVersionPair, VarType> mapExprentMaxTypes = typeProcessor.GetMapExprentMaxTypes
();
Dictionary <VarVersionPair, VarType> mapExprentMinTypes = typeProcessor.GetMapExprentMinTypes
();
Dictionary <VarVersionPair, int> mapFinalVars = typeProcessor.GetMapFinalVars();
CounterContainer counters = DecompilerContext.GetCounterContainer();
Dictionary <VarVersionPair, int> mapVarPaar = new Dictionary <VarVersionPair, int>
();
Dictionary <int, int> mapOriginalVarIndices = new Dictionary <int, int>();
// map var-version pairs on new var indexes
foreach (VarVersionPair pair in new List <VarVersionPair>(mapExprentMinTypes.Keys))
{
if (pair.version >= 0)
{
int newIndex = pair.version == 1 ? pair.var : counters.GetCounterAndIncrement(CounterContainer
.Var_Counter);
VarVersionPair newVar = new VarVersionPair(newIndex, 0);
Sharpen.Collections.Put(mapExprentMinTypes, newVar, mapExprentMinTypes.GetOrNull(
pair));
Sharpen.Collections.Put(mapExprentMaxTypes, newVar, mapExprentMaxTypes.GetOrNull(
pair));
if (mapFinalVars.ContainsKey(pair))
{
Sharpen.Collections.Put(mapFinalVars, newVar, Sharpen.Collections.Remove(mapFinalVars
, pair));
}
Sharpen.Collections.Put(mapVarPaar, pair, newIndex);
Sharpen.Collections.Put(mapOriginalVarIndices, newIndex, pair.var);
}
}
// set new vars
graph.IterateExprents((Exprent exprent) => {
List <Exprent> lst = exprent.GetAllExprents(true);
lst.Add(exprent);
foreach (Exprent expr in lst)
{
if (expr.type == Exprent.Exprent_Var)
{
VarExprent newVar = (VarExprent)expr;
int?newVarIndex = mapVarPaar.GetOrNullable(new VarVersionPair(newVar));
if (newVarIndex != null)
{
newVar.SetIndex(newVarIndex.Value);
newVar.SetVersion(0);
}
}
else if (expr.type == Exprent.Exprent_Const)
{
VarType maxType = mapExprentMaxTypes.GetOrNull(new VarVersionPair(expr.id, -1));
if (maxType != null && maxType.Equals(VarType.Vartype_Char))
{
((ConstExprent)expr).SetConstType(maxType);
}
}
}
return(0);
}
);
if (previousVersionsProcessor != null)
{
Dictionary <int, int> oldIndices = previousVersionsProcessor.GetMapOriginalVarIndices
();
this.mapOriginalVarIndices = new Dictionary <int, int>(mapOriginalVarIndices.Count
);
foreach (KeyValuePair <int, int> entry in mapOriginalVarIndices)
{
int value = entry.Value;
int?oldValue = oldIndices.GetOrNullable(value);
value = oldValue != null ? oldValue.Value : value;
Sharpen.Collections.Put(this.mapOriginalVarIndices, entry.Key, value);
}
}
else
{
this.mapOriginalVarIndices = mapOriginalVarIndices;
}
}
private static void SimpleMerge(VarTypeProcessor typeProcessor, DirectGraph graph
, StructMethod mt)
{
Dictionary <VarVersionPair, VarType> mapExprentMaxTypes = typeProcessor.GetMapExprentMaxTypes
();
Dictionary <VarVersionPair, VarType> mapExprentMinTypes = typeProcessor.GetMapExprentMinTypes
();
Dictionary <int, HashSet <int> > mapVarVersions = new Dictionary <int, HashSet <int> >
();
foreach (VarVersionPair pair in mapExprentMinTypes.Keys)
{
if (pair.version >= 0)
{
// don't merge constants
mapVarVersions.ComputeIfAbsent(pair.var, (int k) => new HashSet <int>()).Add(pair.
version);
}
}
bool is_method_static = mt.HasModifier(ICodeConstants.Acc_Static);
Dictionary <VarVersionPair, int> mapMergedVersions = new Dictionary <VarVersionPair
, int>();
foreach (KeyValuePair <int, HashSet <int> > ent in mapVarVersions)
{
if (ent.Value.Count > 1)
{
List <int> lstVersions = new List <int>(ent.Value);
lstVersions.Sort();
for (int i = 0; i < lstVersions.Count; i++)
{
VarVersionPair firstPair = new VarVersionPair(ent.Key, lstVersions[i]);
VarType firstType = mapExprentMinTypes.GetOrNull(firstPair);
if (firstPair.var == 0 && firstPair.version == 1 && !is_method_static)
{
continue;
}
// don't merge 'this' variable
for (int j = i + 1; j < lstVersions.Count; j++)
{
VarVersionPair secondPair = new VarVersionPair(ent.Key, lstVersions[j]);
VarType secondType = mapExprentMinTypes.GetOrNull(secondPair);
if (firstType.Equals(secondType) || (firstType.Equals(VarType.Vartype_Null) && secondType
.type == ICodeConstants.Type_Object) || (secondType.Equals(VarType.Vartype_Null) &&
firstType.type == ICodeConstants.Type_Object))
{
VarType firstMaxType = mapExprentMaxTypes.GetOrNull(firstPair);
VarType secondMaxType = mapExprentMaxTypes.GetOrNull(secondPair);
VarType type = firstMaxType == null ? secondMaxType : secondMaxType == null ? firstMaxType
: VarType.GetCommonMinType(firstMaxType, secondMaxType);
Sharpen.Collections.Put(mapExprentMaxTypes, firstPair, type);
Sharpen.Collections.Put(mapMergedVersions, secondPair, firstPair.version);
Sharpen.Collections.Remove(mapExprentMaxTypes, secondPair);
Sharpen.Collections.Remove(mapExprentMinTypes, secondPair);
if (firstType.Equals(VarType.Vartype_Null))
{
Sharpen.Collections.Put(mapExprentMinTypes, firstPair, secondType);
firstType = secondType;
}
Sharpen.Collections.Put(typeProcessor.GetMapFinalVars(), firstPair, VarTypeProcessor
.Var_Non_Final);
lstVersions.RemoveAtReturningValue(j);
//noinspection AssignmentToForLoopParameter
j--;
}
}
}
}
}
if (!(mapMergedVersions.Count == 0))
{
UpdateVersions(graph, mapMergedVersions);
}
}
public virtual VarType GetVarType(VarVersionPair pair)
{
return(mapExprentMinTypes.GetOrNull(pair));
}
public virtual void SetVarType(VarVersionPair pair, VarType type)
{
Sharpen.Collections.Put(mapExprentMinTypes, pair, type);
}
public virtual int GetVarFinal(VarVersionPair pair)
{
return(varVersions == null ? VarTypeProcessor.Var_Final : varVersions.GetVarFinal
(pair));
}
public virtual void SetVarFinal(VarVersionPair pair, int finalType)
{
varVersions.SetVarFinal(pair, finalType);
}
public virtual void SetVarFinal(VarVersionPair pair, int finalType)
{
Sharpen.Collections.Put(typeProcessor.GetMapFinalVars(), pair, finalType);
}
