public BasicBlockStatement(BasicBlock block)
{
// *****************************************************************************
// private fields
// *****************************************************************************
// *****************************************************************************
// constructors
// *****************************************************************************
type = Statement.Type_Basicblock;
this.block = block;
id = block.id;
CounterContainer coun = DecompilerContext.GetCounterContainer();
if (id >= coun.GetCounter(CounterContainer.Statement_Counter))
{
coun.SetCounter(CounterContainer.Statement_Counter, id + 1);
}
Instruction instr = block.GetLastInstruction();
if (instr != null)
{
if (instr.group == ICodeConstants.Group_Jump && instr.opcode != ICodeConstants.opc_goto)
{
lastBasicType = Lastbasictype_If;
}
else if (instr.group == ICodeConstants.Group_Switch)
{
lastBasicType = Lastbasictype_Switch;
}
}
// monitorenter and monitorexits
BuildMonitorFlags();
}
/// <summary>
/// Adds a value to counter, and returns result value.
/// </summary>
/// <param name="incrementValue">Value to be added.</param>
/// <returns></returns>
private static int Counter(int incrementValue)
{
CounterContainer counter = SuppressEventScopeCounter;
counter.Counter += incrementValue;
return(counter.Counter);
}
public MethodWrapper(RootStatement root, VarProcessor varproc, StructMethod methodStruct
, CounterContainer counter)
{
this.root = root;
this.varproc = varproc;
this.methodStruct = methodStruct;
this.counter = counter;
}
public DecompilerContext(Dictionary <string, object> properties, IFernflowerLogger
logger, StructContext structContext, ClassesProcessor classProcessor, PoolInterceptor
interceptor)
{
this.properties = properties;
this.logger = logger;
this.structContext = structContext;
this.classProcessor = classProcessor;
this.poolInterceptor = interceptor;
this.counterContainer = new CounterContainer();
}
public void DoTest()
{
_firstTestCounter = new CounterContainer();
_errorTestCounter = new CounterContainer();
var tt = new TestThreads(false, FirstTest, 1);
tt.RunParallel(100);
while (_firstTestCounter.Counter < 100)
{
Thread.Sleep(10);
}
Assert.AreEqual(100, _firstTestCounter.Counter);
tt.Terminate();
}
public void DoTestMultiWithPar()
{
_firstTestCounter = new CounterContainer();
_errorTestCounter = new CounterContainer();
var tt = new TestThreads(false, SecondTest, 10);
tt.RunParallel(1000, 2);
while (_firstTestCounter.Counter < 1000 && _errorTestCounter.Counter==0)
{
Thread.Sleep(10);
}
Assert.AreEqual(0, _errorTestCounter.Counter);
Assert.AreEqual(1000, _firstTestCounter.Counter);
tt.Terminate();
}
public void DoTestMulti()
{
const int iterations = 10000;
_firstTestCounter = new CounterContainer();
_errorTestCounter = new CounterContainer();
var tt = new TestThreads(false, FirstTest, 100);
tt.RunParallel(iterations);
while (_firstTestCounter.Counter < iterations)
{
Thread.Sleep(10);
}
Assert.AreEqual(iterations, _firstTestCounter.Counter);
tt.Terminate();
}
public void DoTestMultiWithParAndReadingThread()
{
const int iterations = 10000;
var lfq = new LockFreeQueue<int>();
_sendCounter = new CounterContainer();
_firstTestCounter = new CounterContainer();
_errorTestCounter = new CounterContainer();
var ttr = new TestThreads(false, ThirdTestReader, 5);
ttr.RunParallel(iterations, lfq, true);
var tts = new TestThreads(false, ThirdTestSender, 5);
tts.RunParallel(iterations, lfq);
while (_firstTestCounter.Counter < (iterations-1) && _errorTestCounter.Counter == 0)
{
Thread.Sleep(10);
}
Assert.AreEqual(0, _errorTestCounter.Counter);
Assert.AreEqual(iterations, _sendCounter.Counter);
Assert.AreEqual(iterations-1, _firstTestCounter.Counter);
tts.Terminate();
ttr.Terminate();
}
public virtual void Init()
{
DecompilerContext.SetProperty(DecompilerContext.Current_Class, classStruct);
DecompilerContext.SetProperty(DecompilerContext.Current_Class_Wrapper, this);
DecompilerContext.GetLogger().StartClass(classStruct.qualifiedName);
int maxSec = System.Convert.ToInt32(DecompilerContext.GetProperty(IFernflowerPreferences
.Max_Processing_Method).ToString());
bool testMode = DecompilerContext.GetOption(IFernflowerPreferences.Unit_Test_Mode
);
foreach (StructMethod mt in classStruct.GetMethods())
{
DecompilerContext.GetLogger().StartMethod(mt.GetName() + " " + mt.GetDescriptor()
);
MethodDescriptor md = MethodDescriptor.ParseDescriptor(mt.GetDescriptor());
VarProcessor varProc = new VarProcessor(mt, md);
DecompilerContext.StartMethod(varProc);
VarNamesCollector vc = varProc.GetVarNamesCollector();
CounterContainer counter = DecompilerContext.GetCounterContainer();
RootStatement root = null;
bool isError = false;
try
{
if (mt.ContainsCode())
{
if (maxSec == 0 || testMode)
{
root = MethodProcessorRunnable.CodeToJava(mt, md, varProc);
}
else
{
MethodProcessorRunnable mtProc = new MethodProcessorRunnable(mt, md, varProc, DecompilerContext
.GetCurrentContext());
Thread mtThread = new Thread(o => mtProc.Run())
{
Name = "Java decompiler"
};
long stopAt = Runtime.CurrentTimeMillis() + maxSec * 1000L;
mtThread.Start();
while (!mtProc.IsFinished())
{
try
{
lock (mtProc.Lock)
{
Thread.Sleep(200);
}
}
catch (Exception e)
{
KillThread(mtThread);
throw;
}
if (Runtime.CurrentTimeMillis() >= stopAt)
{
string message = "Processing time limit exceeded for method " + mt.GetName() + ", execution interrupted.";
DecompilerContext.GetLogger().WriteMessage(message, IFernflowerLogger.Severity.Error
);
KillThread(mtThread);
isError = true;
break;
}
}
if (!isError)
{
root = mtProc.GetResult();
}
}
}
else
{
bool thisVar = !mt.HasModifier(ICodeConstants.Acc_Static);
int paramCount = 0;
if (thisVar)
{
Sharpen.Collections.Put(varProc.GetThisVars(), new VarVersionPair(0, 0), classStruct
.qualifiedName);
paramCount = 1;
}
paramCount += [email protected];
int varIndex = 0;
for (int i = 0; i < paramCount; i++)
{
varProc.SetVarName(new VarVersionPair(varIndex, 0), vc.GetFreeName(varIndex));
if (thisVar)
{
if (i == 0)
{
varIndex++;
}
else
{
varIndex += md.@params[i - 1].stackSize;
}
}
else
{
varIndex += md.@params[i].stackSize;
}
}
}
}
catch (Exception t)
{
string message = "Method " + mt.GetName() + " " + mt.GetDescriptor() + " couldn't be decompiled.";
DecompilerContext.GetLogger().WriteMessage(message, IFernflowerLogger.Severity.Warn
, t);
isError = true;
}
MethodWrapper methodWrapper = new MethodWrapper(root, varProc, mt, counter);
methodWrapper.decompiledWithErrors = isError;
methods.AddWithKey(methodWrapper, InterpreterUtil.MakeUniqueKey(mt.GetName(), mt.
GetDescriptor()));
if (!isError)
{
// rename vars so that no one has the same name as a field
VarNamesCollector namesCollector = new VarNamesCollector();
classStruct.GetFields().ForEach((StructField f) => namesCollector.AddName(f.GetName
()));
varProc.RefreshVarNames(namesCollector);
// if debug information present and should be used
if (DecompilerContext.GetOption(IFernflowerPreferences.Use_Debug_Var_Names))
{
StructLocalVariableTableAttribute attr = mt.GetLocalVariableAttr();
if (attr != null)
{
// only param names here
varProc.SetDebugVarNames(attr.GetMapParamNames());
// the rest is here
methodWrapper.GetOrBuildGraph().IterateExprents((Exprent exprent) => {
List <Exprent> lst = exprent.GetAllExprents(true);
lst.Add(exprent);
lst.Where(e => e.type == Exprent.Exprent_Var).ToList().ForEach((Exprent
e) => {
VarExprent varExprent = (VarExprent)e;
string name = varExprent.GetDebugName(mt);
if (name != null)
{
varProc.SetVarName(varExprent.GetVarVersionPair(), name);
}
}
);
return(0);
}
);
}
}
}
DecompilerContext.GetLogger().EndMethod();
}
DecompilerContext.GetLogger().EndClass();
}
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;
}
}
