/// <exception cref="System.IO.IOException"/>
public override void InitContent(DataInputFullStream data, ConstantPool pool)
{
int classIndex = data.ReadUnsignedShort();
int methodIndex = data.ReadUnsignedShort();
className = pool.GetPrimitiveConstant(classIndex).GetString();
if (methodIndex != 0)
{
LinkConstant lk = pool.GetLinkConstant(methodIndex);
methodName = lk.elementname;
methodDescriptor = lk.descriptor;
}
}
public InvocationExprent(int opcode, LinkConstant cn, List <PooledConstant> bootstrapArguments
, ListStack <Exprent> stack, HashSet <int> bytecodeOffsets)
: this()
{
name = cn.elementname;
classname = cn.classname;
this.bootstrapArguments = bootstrapArguments;
switch (opcode)
{
case ICodeConstants.opc_invokestatic:
{
invocationTyp = Invoke_Static;
break;
}
case ICodeConstants.opc_invokespecial:
{
invocationTyp = Invoke_Special;
break;
}
case ICodeConstants.opc_invokevirtual:
{
invocationTyp = Invoke_Virtual;
break;
}
case ICodeConstants.opc_invokeinterface:
{
invocationTyp = Invoke_Interface;
break;
}
case ICodeConstants.opc_invokedynamic:
{
invocationTyp = Invoke_Dynamic;
classname = "java/lang/Class";
// dummy class name
invokeDynamicClassSuffix = "##Lambda_" + cn.index1 + "_" + cn.index2;
break;
}
}
if (ICodeConstants.Init_Name.Equals(name))
{
functype = Typ_Init;
}
else if (ICodeConstants.Clinit_Name.Equals(name))
{
functype = Typ_Clinit;
}
stringDescriptor = cn.descriptor;
descriptor = MethodDescriptor.ParseDescriptor(cn.descriptor);
foreach (VarType ignored in descriptor.@params)
{
lstParameters.Add(0, stack.Pop());
}
if (opcode == ICodeConstants.opc_invokedynamic)
{
int dynamicInvocationType = -1;
if (bootstrapArguments != null)
{
if (bootstrapArguments.Count > 1)
{
// INVOKEDYNAMIC is used not only for lambdas
PooledConstant link = bootstrapArguments[1];
if (link is LinkConstant)
{
dynamicInvocationType = ((LinkConstant)link).index1;
}
}
}
if (dynamicInvocationType == ICodeConstants.CONSTANT_MethodHandle_REF_invokeStatic)
{
isStatic__ = true;
}
else if (!(lstParameters.Count == 0))
{
// FIXME: remove the first parameter completely from the list. It's the object type for a virtual lambda method.
instance = lstParameters[0];
}
}
else if (opcode == ICodeConstants.opc_invokestatic)
{
isStatic__ = true;
}
else
{
instance = stack.Pop();
}
AddBytecodeOffsets(bytecodeOffsets);
}
public FieldExprent(LinkConstant cn, Exprent instance, HashSet <int> bytecodeOffsets
)
: this(cn.elementname, cn.classname, instance == null, instance, FieldDescriptor.
ParseDescriptor(cn.descriptor), bytecodeOffsets)
{
}
/// <exception cref="IOException"/>
public virtual void ProcessClass(ClassesProcessor.ClassNode node)
{
foreach (ClassesProcessor.ClassNode child in node.nested)
{
ProcessClass(child);
}
ClassesProcessor clProcessor = DecompilerContext.GetClassProcessor();
StructClass cl = node.classStruct;
if (cl.GetBytecodeVersion() < ICodeConstants.Bytecode_Java_8)
{
// lambda beginning with Java 8
return;
}
StructBootstrapMethodsAttribute bootstrap = cl.GetAttribute(StructGeneralAttribute
.Attribute_Bootstrap_Methods);
if (bootstrap == null || bootstrap.GetMethodsNumber() == 0)
{
return;
}
// no bootstrap constants in pool
BitSet lambda_methods = new BitSet();
// find lambda bootstrap constants
for (int i = 0; i < bootstrap.GetMethodsNumber(); ++i)
{
LinkConstant method_ref = bootstrap.GetMethodReference(i);
// method handle
// FIXME: extend for Eclipse etc. at some point
if (Javac_Lambda_Class.Equals(method_ref.classname) && (Javac_Lambda_Method.Equals
(method_ref.elementname) || Javac_Lambda_Alt_Method.Equals(method_ref.elementname
)))
{
lambda_methods.Set(i);
}
}
if (lambda_methods.IsEmpty())
{
return;
}
// no lambda bootstrap constant found
Dictionary <string, string> mapMethodsLambda = new Dictionary <string, string>();
// iterate over code and find invocations of bootstrap methods. Replace them with anonymous classes.
foreach (StructMethod mt in cl.GetMethods())
{
mt.ExpandData();
InstructionSequence seq = mt.GetInstructionSequence();
if (seq != null && seq.Length() > 0)
{
int len = seq.Length();
for (int i = 0; i < len; ++i)
{
Instruction instr = seq.GetInstr(i);
if (instr.opcode == ICodeConstants.opc_invokedynamic)
{
LinkConstant invoke_dynamic = cl.GetPool().GetLinkConstant(instr.Operand(0));
if (lambda_methods.Get(invoke_dynamic.index1))
{
// lambda invocation found
List <PooledConstant> bootstrap_arguments = bootstrap.GetMethodArguments(invoke_dynamic
.index1);
MethodDescriptor md = MethodDescriptor.ParseDescriptor(invoke_dynamic.descriptor);
string lambda_class_name = md.ret.value;
string lambda_method_name = invoke_dynamic.elementname;
string lambda_method_descriptor = ((PrimitiveConstant)bootstrap_arguments[2]).GetString
();
// method type
LinkConstant content_method_handle = (LinkConstant)bootstrap_arguments[1];
ClassesProcessor.ClassNode node_lambda = new ClassesProcessor.ClassNode(content_method_handle
.classname, content_method_handle.elementname, content_method_handle.descriptor,
content_method_handle.index1, lambda_class_name, lambda_method_name, lambda_method_descriptor
, cl);
node_lambda.simpleName = cl.qualifiedName + "##Lambda_" + invoke_dynamic.index1 +
"_" + invoke_dynamic.index2;
node_lambda.enclosingMethod = InterpreterUtil.MakeUniqueKey(mt.GetName(), mt.GetDescriptor
());
node.nested.Add(node_lambda);
node_lambda.parent = node;
Sharpen.Collections.Put(clProcessor.GetMapRootClasses(), node_lambda.simpleName,
node_lambda);
if (!node_lambda.lambdaInformation.is_method_reference)
{
Sharpen.Collections.Put(mapMethodsLambda, node_lambda.lambdaInformation.content_method_key
, node_lambda.simpleName);
}
}
}
}
}
mt.ReleaseResources();
}
// build class hierarchy on lambda
foreach (ClassesProcessor.ClassNode nd in node.nested)
{
if (nd.type == ClassesProcessor.ClassNode.Class_Lambda)
{
string parent_class_name = mapMethodsLambda.GetOrNull(nd.enclosingMethod);
if (parent_class_name != null)
{
ClassesProcessor.ClassNode parent_class = clProcessor.GetMapRootClasses().GetOrNull
(parent_class_name);
parent_class.nested.Add(nd);
nd.parent = parent_class;
}
}
}
}
