private void FillVars(List <ILVariable> vars)
{
if (thisMethod.HasThis)
{
var2Index.Add(vars.Where(V => V.Name == "this").FirstOrDefault() ?? new ILVariable()
{
Name = "this"
},
nextVarIndex++);
}
for (int i = 0; i < thisMethod.Parameters.Count; i++)
{
InterParameter param = thisMethod.Parameters[i];
ILVariable var = vars.Where(V => ((V.IsParameter) && (V.OriginalParameter.Index == param.Index))).FirstOrDefault();
var2Index.Add(var, nextVarIndex++);
if (param.Type.IsPrimitive)
{
JavaPrimitiveType varType = JavaHelpers.PrimitiveTypeToJavaPrimitive(param.Type.PrimitiveType);
if ((varType == JavaPrimitiveType.Long) || (varType == JavaPrimitiveType.Double))
{
nextVarIndex++;
}
}
}
if (thisMethod.IsVarArg)
{
var2Index.Add(new ILVariable()
{
Name = ClassNames.VarArgParamName
}, nextVarIndex++);
}
}
private ExpectType GetExpectType(InterParameter param)
{
return(GetExpectType(param.Type));
}
public InterMethod(MethodReference methodRef, List <InterGenericArgument> genericArgs, IResolver resolver, Action <InterMethod> onFounded)
{
originalName = methodRef.Name;
genericArgs = genericArgs ?? InterGenericArgument.EmptyGenericArgsList;
MethodDefinition methodDef = methodRef.Resolve();
CustomAttribute methodMapCustomAttr = null;
if (methodDef != null)
{
methodMapCustomAttr = methodDef.CustomAttributes.Where(C => C.AttributeType.FullName == ClassNames.MethodMapAttribute).FirstOrDefault();
if ((methodMapCustomAttr == null) && (Program.BoxType == BoxingType.Java))
{
methodMapCustomAttr = methodDef.CustomAttributes.Where(C => C.AttributeType.FullName == ClassNames.JavaBoxMethodMapAttribute).FirstOrDefault();
}
}
declType = resolver.Resolve(methodRef.DeclaringType, genericArgs);
#region Mapping
if (methodMapCustomAttr != null)
{
TypeReference realDeclType = methodMapCustomAttr.ConstructorArguments[0].Value as TypeReference;
TypeDefinition realDeclTypeDef = realDeclType.Resolve();
string mappedName = (string)methodMapCustomAttr.ConstructorArguments[1].Value;
MethodDefinition md = null;
int paramsOffset = 0;
if ((methodMapCustomAttr.ConstructorArguments.Count > 2) && ((bool)methodMapCustomAttr.ConstructorArguments[2].Value))
{
paramsOffset = 1;
}
foreach (var method in realDeclTypeDef.Methods)
{
if (method.Name != mappedName)
{
continue;
}
if (method.HasGenericParameters != methodDef.HasGenericParameters)
{
continue;
}
if (method.HasGenericParameters && method.GenericParameters.Count != methodDef.GenericParameters.Count)
{
continue;
}
if (!Utils.AreSame(method.ReturnType, methodDef.ReturnType))
{
continue;
}
if (paramsOffset == 0)
{
if ((!method.HasParameters) && (methodDef.HasParameters))
{
md = method;
break;
}
}
else
{
if (!method.HasParameters)
{
continue;
}
if ((!methodRef.HasParameters) && (method.Parameters.Count == 1))
{
md = method;
break;
}
}
if (!Utils.AreSame(method.Parameters, methodDef.Parameters, paramsOffset))
{
continue;
}
md = method;
break;
}
if (md == null)
{
throw new Exception(); //TODO: mapping error
}
MethodReference newMethodRef = md;
if (methodRef is GenericInstanceMethod)
{
GenericInstanceMethod oldGIM = (GenericInstanceMethod)methodRef;
GenericInstanceMethod newGIM = new GenericInstanceMethod(newMethodRef);
oldGIM.GenericArguments.ForEach(T => newGIM.GenericArguments.Add(T));
newMethodRef = newGIM;
}
onFounded(resolver.Resolve(newMethodRef, genericArgs));
return;
}
else
#endregion
{ name = methodRef.Name; }
genericArgs.AddRange(declType.GenericArguments);
if ((methodDef ?? methodRef).HasGenericParameters)
{
GenericInstanceMethod gim = methodRef as GenericInstanceMethod;
for (int i = 0; i < (methodDef ?? methodRef).GenericParameters.Count; i++)
{
GenericParameter gp = (methodDef ?? methodRef).GenericParameters[i];
TypeReference genericArg = null;
if (gim != null)
{
genericArg = gim.GenericArguments[i];
}
if (genericArg is GenericParameter)
{
gp = (GenericParameter)genericArg;
genericArg = null;
}
InterType resolvedGenericArg = null;
if (genericArg == null)
{
var resolvedInterGenericArg = genericArgs.Where(G => G.Owner == Utils.CecilGenericOwnerToC2JGenericOwner(gp.Type) &&
G.Position == gp.Position);
if (resolvedInterGenericArg.Count() > 0)
{
resolvedGenericArg = resolvedInterGenericArg.First().Type;
}
}
if (resolvedGenericArg != null)
{
this.genericArgs.Add(new InterGenericArgument(GenericArgumentOwnerType.Method, i, resolvedGenericArg));
}
else if (genericArg != null)
{
this.genericArgs.Add(new InterGenericArgument(GenericArgumentOwnerType.Method, i, resolver.Resolve(genericArg, genericArgs)));
}
else
{
Messages.Message(MessageCode.CantResolveGenericParameter, gp.ToString(), methodRef.ToString());
this.genericArgs.Add(new InterGenericArgument(GenericArgumentOwnerType.Method, i, resolver.Resolve(ClassNames.ObjectTypeName)));
}
}
string genericsSufix = "<" + string.Join(",", this.genericArgs.Select(G => G.Type.Fullname)) + ">";
this.name = this.name + "_GIM_" + resolver.GetGenericsArgsIndex(genericsSufix).ToString();
}
if (methodDef != null)
{
CustomAttribute fromJavaCustomAttr = methodDef.CustomAttributes.Where(C => C.AttributeType.FullName == ClassNames.FromJavaAttribute).FirstOrDefault();
if (fromJavaCustomAttr != null)
{
FromJava = true;
if (fromJavaCustomAttr.ConstructorArguments.Count > 0)
{
name = fromJavaCustomAttr.ConstructorArguments[0].Value.ToString();
}
}
}
if (methodRef.HasThis)
{
thisParam = new InterParameter(0, declType, "this");
}
this.returnParam = new InterParameter(-1, resolver.Resolve(methodRef.ReturnType, this.FullGenericArguments), "return",
methodRef.MethodReturnType.CustomAttributes.Where(C => C.AttributeType.FullName == ClassNames.BoxedAttribute).Count() > 0,
methodRef.MethodReturnType.CustomAttributes.Where(C => C.AttributeType.FullName == ClassNames.JavaBoxedAttribute).Count() > 0);
foreach (ParameterDefinition paramDef in methodRef.Parameters)
{
if (paramDef.ParameterType.IsSentinel)
{
break;
}
parameters.Add(new InterParameter(paramDef, this.FullGenericArguments, resolver));
}
if (methodDef != null)
{
if (methodDef.HasBody)
{
body = methodDef.Body;
}
IsPublic = methodDef.IsPublic || methodDef.IsAssembly;
IsProtected = methodDef.IsFamily || methodDef.IsFamilyAndAssembly || methodDef.IsFamilyOrAssembly;
IsPrivate = methodDef.IsPrivate;
IsAbstract = methodDef.IsAbstract;
IsFinal = methodDef.IsFinal;
IsVirtual = methodDef.IsVirtual;
IsNewSlot = methodDef.IsNewSlot;
IsStatic = methodDef.IsStatic;
IsSynchronized = methodDef.IsSynchronized;
IsConstructor = methodDef.IsConstructor;
IsVarArg = methodDef.CallingConvention == MethodCallingConvention.VarArg;
HasThis = methodDef.HasThis;
HasBody = methodDef.HasBody;
foreach (MethodReference overridedMethod in methodDef.Overrides)
{
overrides.Add(resolver.Resolve(overridedMethod, this.FullGenericArguments));
}
}
else
{
IsPublic = true;
IsFinal = true;
HasThis = methodRef.HasThis;
IsStatic = !methodRef.HasThis;
}
if ((!IsConstructor) && (!declType.IsDelegate))
{
//TODO: change params in ctors
var changedParams = parameters.Where(P => ((P.Type.IsEnum) ||
((P.Type.IsPrimitive) && (Utils.IsUnsigned(P.Type.PrimitiveType)))));
if (changedParams.Count() > 0)
{
name += "$" + string.Join("_", changedParams.Select(P => P.Index + P.Type.Fullname));
}
}
InterMethod thisFromDecl = declType.Methods.Where(M => M.Equals(this)).FirstOrDefault();
if (thisFromDecl != null)
{
onFounded(thisFromDecl);
}
}
