private TextBuffer WrapOperandString(Exprent expr, bool eq, int indent, BytecodeMappingTracer
tracer)
{
int myprec = GetPrecedence();
int exprprec = expr.GetPrecedence();
bool parentheses = exprprec > myprec;
if (!parentheses && eq)
{
parentheses = (exprprec == myprec);
if (parentheses)
{
if (expr.type == Exprent.Exprent_Function && ((FunctionExprent)expr).GetFuncType(
) == funcType)
{
parentheses = !Associativity.Contains(funcType);
}
}
}
TextBuffer res = expr.ToJava(indent, tracer);
if (parentheses)
{
res.Enclose("(", ")");
}
return(res);
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
tracer.AddMapping(bytecode);
if (monType == Monitor_Enter)
{
return(value.ToJava(indent, tracer).Enclose("synchronized(", ")"));
}
else
{
return(new TextBuffer());
}
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
tracer.AddMapping(bytecode);
if (exitType == Exit_Return)
{
TextBuffer buffer = new TextBuffer("return");
if (retType.type != ICodeConstants.Type_Void)
{
buffer.Append(' ');
ExprProcessor.GetCastedExprent(value, retType, buffer, indent, false, tracer);
}
return(buffer);
}
else
{
MethodWrapper method = (MethodWrapper)DecompilerContext.GetProperty(DecompilerContext
.Current_Method_Wrapper);
ClassesProcessor.ClassNode node = ((ClassesProcessor.ClassNode)DecompilerContext.
GetProperty(DecompilerContext.Current_Class_Node));
if (method != null && node != null)
{
StructExceptionsAttribute attr = method.methodStruct.GetAttribute(StructGeneralAttribute
.Attribute_Exceptions);
if (attr != null)
{
string classname = null;
for (int i = 0; i < attr.GetThrowsExceptions().Count; i++)
{
string exClassName = attr.GetExcClassname(i, node.classStruct.GetPool());
if ("java/lang/Throwable".Equals(exClassName))
{
classname = exClassName;
break;
}
else if ("java/lang/Exception".Equals(exClassName))
{
classname = exClassName;
}
}
if (classname != null)
{
VarType exType = new VarType(classname, true);
TextBuffer buffer = new TextBuffer("throw ");
ExprProcessor.GetCastedExprent(value, exType, buffer, indent, false, tracer);
return(buffer);
}
}
}
return(value.ToJava(indent, tracer).Prepend("throw "));
}
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
TextBuffer res = array.ToJava(indent, tracer);
if (array.GetPrecedence() > GetPrecedence())
{
// array precedence equals 0
res.Enclose("(", ")");
}
VarType arrType = array.GetExprType();
if (arrType.arrayDim == 0)
{
VarType objArr = VarType.Vartype_Object.ResizeArrayDim(1);
// type family does not change
res.Enclose("((" + ExprProcessor.GetCastTypeName(objArr) + ")", ")");
}
tracer.AddMapping(bytecode);
return(res.Append('[').Append(index.ToJava(indent, tracer)).Append(']'));
}
private static string GetQualifiedNewInstance(string classname, List <Exprent> lstParams
, int indent, BytecodeMappingTracer tracer)
{
ClassesProcessor.ClassNode node = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(classname);
if (node != null && node.type != ClassesProcessor.ClassNode.Class_Root && node.type
!= ClassesProcessor.ClassNode.Class_Local && (node.access & ICodeConstants.Acc_Static
) == 0)
{
if (!(lstParams.Count == 0))
{
Exprent enclosing = lstParams[0];
bool isQualifiedNew = false;
if (enclosing.type == Exprent.Exprent_Var)
{
VarExprent varEnclosing = (VarExprent)enclosing;
StructClass current_class = ((ClassesProcessor.ClassNode)DecompilerContext.GetProperty
(DecompilerContext.Current_Class_Node)).classStruct;
string this_classname = varEnclosing.GetProcessor().GetThisVars().GetOrNull(new VarVersionPair
(varEnclosing));
if (!current_class.qualifiedName.Equals(this_classname))
{
isQualifiedNew = true;
}
}
else
{
isQualifiedNew = true;
}
if (isQualifiedNew)
{
return(enclosing.ToJava(indent, tracer).ToString());
}
}
}
return(null);
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
tracer.AddMapping(bytecode);
return(value.ToJava(indent, tracer).Enclose("switch(", ")"));
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
VarType leftType = left.GetExprType();
VarType rightType = right.GetExprType();
bool fieldInClassInit = false;
bool hiddenField = false;
if (left.type == Exprent.Exprent_Field)
{
// first assignment to a final field. Field name without "this" in front of it
FieldExprent field = (FieldExprent)left;
ClassesProcessor.ClassNode node = ((ClassesProcessor.ClassNode)DecompilerContext.
GetProperty(DecompilerContext.Current_Class_Node));
if (node != null)
{
StructField fd = node.classStruct.GetField(field.GetName(), field.GetDescriptor()
.descriptorString);
if (fd != null)
{
if (field.IsStatic() && fd.HasModifier(ICodeConstants.Acc_Final))
{
fieldInClassInit = true;
}
if (node.GetWrapper() != null && node.GetWrapper().GetHiddenMembers().Contains(InterpreterUtil
.MakeUniqueKey(fd.GetName(), fd.GetDescriptor())))
{
hiddenField = true;
}
}
}
}
if (hiddenField)
{
return(new TextBuffer());
}
TextBuffer buffer = new TextBuffer();
if (fieldInClassInit)
{
buffer.Append(((FieldExprent)left).GetName());
}
else
{
buffer.Append(left.ToJava(indent, tracer));
}
if (right.type == Exprent_Const)
{
((ConstExprent)right).AdjustConstType(leftType);
}
TextBuffer res = right.ToJava(indent, tracer);
if (condType == Condition_None && !leftType.IsSuperset(rightType) && (rightType.Equals
(VarType.Vartype_Object) || leftType.type != ICodeConstants.Type_Object))
{
if (right.GetPrecedence() >= FunctionExprent.GetPrecedence(FunctionExprent.Function_Cast
))
{
res.Enclose("(", ")");
}
res.Prepend("(" + ExprProcessor.GetCastTypeName(leftType) + ")");
}
buffer.Append(condType == Condition_None ? " = " : Operators[condType]).Append(res
);
tracer.AddMapping(bytecode);
return(buffer);
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
TextBuffer buf = new TextBuffer();
string super_qualifier = null;
bool isInstanceThis = false;
tracer.AddMapping(bytecode);
if (instance is InvocationExprent)
{
((InvocationExprent)instance).MarkUsingBoxingResult();
}
if (isStatic__)
{
if (IsBoxingCall() && canIgnoreBoxing)
{
// process general "boxing" calls, e.g. 'Object[] data = { true }' or 'Byte b = 123'
// here 'byte' and 'short' values do not need an explicit narrowing type cast
ExprProcessor.GetCastedExprent(lstParameters[0], descriptor.@params[0], buf, indent
, false, false, false, false, tracer);
return(buf);
}
ClassesProcessor.ClassNode node = (ClassesProcessor.ClassNode)DecompilerContext.GetProperty
(DecompilerContext.Current_Class_Node);
if (node == null || !classname.Equals(node.classStruct.qualifiedName))
{
buf.Append(DecompilerContext.GetImportCollector().GetShortNameInClassContext(ExprProcessor
.BuildJavaClassName(classname)));
}
}
else
{
if (instance != null && instance.type == Exprent.Exprent_Var)
{
VarExprent instVar = (VarExprent)instance;
VarVersionPair varPair = new VarVersionPair(instVar);
VarProcessor varProc = instVar.GetProcessor();
if (varProc == null)
{
MethodWrapper currentMethod = (MethodWrapper)DecompilerContext.GetProperty(DecompilerContext
.Current_Method_Wrapper);
if (currentMethod != null)
{
varProc = currentMethod.varproc;
}
}
string this_classname = null;
if (varProc != null)
{
this_classname = varProc.GetThisVars().GetOrNull(varPair);
}
if (this_classname != null)
{
isInstanceThis = true;
if (invocationTyp == Invoke_Special)
{
if (!classname.Equals(this_classname))
{
// TODO: direct comparison to the super class?
StructClass cl = DecompilerContext.GetStructContext().GetClass(classname);
bool isInterface = cl != null && cl.HasModifier(ICodeConstants.Acc_Interface);
super_qualifier = !isInterface ? this_classname : classname;
}
}
}
}
if (functype == Typ_General)
{
if (super_qualifier != null)
{
TextUtil.WriteQualifiedSuper(buf, super_qualifier);
}
else if (instance != null)
{
TextBuffer res = instance.ToJava(indent, tracer);
if (IsUnboxingCall())
{
// we don't print the unboxing call - no need to bother with the instance wrapping / casting
buf.Append(res);
return(buf);
}
VarType rightType = instance.GetExprType();
VarType leftType = new VarType(ICodeConstants.Type_Object, 0, classname);
if (rightType.Equals(VarType.Vartype_Object) && !leftType.Equals(rightType))
{
buf.Append("((").Append(ExprProcessor.GetCastTypeName(leftType)).Append(")");
if (instance.GetPrecedence() >= FunctionExprent.GetPrecedence(FunctionExprent.Function_Cast
))
{
res.Enclose("(", ")");
}
buf.Append(res).Append(")");
}
else if (instance.GetPrecedence() > GetPrecedence())
{
buf.Append("(").Append(res).Append(")");
}
else
{
buf.Append(res);
}
}
}
}
switch (functype)
{
case Typ_General:
{
if (VarExprent.Var_Nameless_Enclosure.Equals(buf.ToString()))
{
buf = new TextBuffer();
}
if (buf.Length() > 0)
{
buf.Append(".");
}
buf.Append(name);
if (invocationTyp == Invoke_Dynamic)
{
buf.Append("<invokedynamic>");
}
buf.Append("(");
break;
}
case Typ_Clinit:
{
throw new Exception("Explicit invocation of " + ICodeConstants.Clinit_Name);
}
case Typ_Init:
{
if (super_qualifier != null)
{
buf.Append("super(");
}
else if (isInstanceThis)
{
buf.Append("this(");
}
else if (instance != null)
{
buf.Append(instance.ToJava(indent, tracer)).Append(".<init>(");
}
else
{
throw new Exception("Unrecognized invocation of " + ICodeConstants.Init_Name);
}
break;
}
}
List <VarVersionPair> mask = null;
bool isEnum = false;
if (functype == Typ_Init)
{
ClassesProcessor.ClassNode newNode = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(classname);
if (newNode != null)
{
mask = ExprUtil.GetSyntheticParametersMask(newNode, stringDescriptor, lstParameters
.Count);
isEnum = newNode.classStruct.HasModifier(ICodeConstants.Acc_Enum) && DecompilerContext
.GetOption(IFernflowerPreferences.Decompile_Enum);
}
}
BitSet setAmbiguousParameters = GetAmbiguousParameters();
// omit 'new Type[] {}' for the last parameter of a vararg method call
if (lstParameters.Count == [email protected] && IsVarArgCall())
{
Exprent lastParam = lstParameters[lstParameters.Count - 1];
if (lastParam.type == Exprent_New && lastParam.GetExprType().arrayDim >= 1)
{
((NewExprent)lastParam).SetVarArgParam(true);
}
}
bool firstParameter = true;
int start = isEnum ? 2 : 0;
for (int i = start; i < lstParameters.Count; i++)
{
if (mask == null || mask[i] == null)
{
TextBuffer buff = new TextBuffer();
bool ambiguous = setAmbiguousParameters.Get(i);
// 'byte' and 'short' literals need an explicit narrowing type cast when used as a parameter
ExprProcessor.GetCastedExprent(lstParameters[i], descriptor.@params[i], buff, indent
, true, ambiguous, true, true, tracer);
// the last "new Object[0]" in the vararg call is not printed
if (buff.Length() > 0)
{
if (!firstParameter)
{
buf.Append(", ");
}
buf.Append(buff);
}
firstParameter = false;
}
}
buf.Append(')');
return(buf);
}
public override TextBuffer ToJava(int indent, BytecodeMappingTracer tracer)
{
tracer.AddMapping(bytecode);
return(condition.ToJava(indent, tracer).Enclose("if (", ")"));
}
