private static void RegisterJVMField(GType type, Field field, bool register)
{
var modifiers = (ModifierFlags)field.getModifiers();
if ((modifiers & (ModifierFlags.Private | ModifierFlags.Synthetic)) != ModifierFlags.None)
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + field);
}
return;
}
var res = new GMethod();
res.Type = type;
res.IsField = true;
res.Name = field.getName();
res.JVMName = field.getName();
res.CLRName = res.JVMName;
res.IsJVMMethod = true;
ConvertJVMAttributes(type, res, field);
res.ReturnType = RegisterClass(field.getType());
res.LowerName = (field.getName());
if (register)
{
type.Methods.Add(res);
type.MethodsWithInterfaces.Add(res);
}
}
private static void ConvertJVMAttributes(GType type, GMethod res, Member member)
{
var modifiers = (ModifierFlags)member.getModifiers();
res.Attributes = 0;
if ((modifiers & (ModifierFlags.Public)) != ModifierFlags.None || type.IsInterface)
{
res.Attributes |= MemberAttributes.Public;
}
if ((modifiers & (ModifierFlags.Static)) != ModifierFlags.None)
{
res.Attributes |= MemberAttributes.Static;
res.IsStatic = true;
}
/*if ((modifiers & (ModifierFlags.Abstract)) != ModifierFlags.None && !type.IsInterface)
* {
* res.Attributes |= MemberAttributes.Abstract;
* }*/
if ((modifiers & (ModifierFlags.Final)) != ModifierFlags.None && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Final;
res.IsFinal = true;
}
if (!res.IsField && (modifiers & (ModifierFlags.Varargs)) != ModifierFlags.None)
{
var indexOfLastParameter = res.Parameters.Count - 1;
res.Parameters[indexOfLastParameter].IsOptional = true;
}
}
private static GMethod RegisterCLRCall(GType type, MethodBase method)
{
var res = new GMethod();
res.Type = type;
res.Name = method.Name;
res.CLRName = method.Name;
res.JVMName = method.Name;
res.IsCLRMethod = true;
foreach (ParameterInfo info in method.GetParameters())
{
Type parameterType = info.ParameterType;
if (TestCLRType(parameterType))
{
return(null);
}
// we ignore IsOut when IsIn is set as well, because they are probably just attributes
// see System.IO.TextReader.Read([In, Out] char[] buffer, int index, int count)
if (info.IsOut && !info.IsIn)
{
//this is trick how to store out as type
parameterType = parameterType.GetElementType().MakePointerType();
}
res.ParameterNames.Add(info.Name);
res.Parameters.Add(RegisterType(parameterType));
}
res.ReturnType = RegisterType(typeof(void));
ConvertCLRAttributes(type, res, method);
res.LowerName = (res.JVMName + res.GetSignatureLowerNoRet());
return(res);
}
private static void RegisterCLRConstructor(GType type, ConstructorInfo method, bool register)
{
GMethod res = RegisterCLRCall(type, method);
if (res == null)
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
// skip
return;
}
res.IsConstructor = true;
if (register)
{
string sig = type.Name + res.GetJVMSignatureNoRet();
if (type.AllMethods.ContainsKey(sig))
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
type.AllMethods.Add(sig, res);
type.Constructors.Add(res);
}
}
private static void ConvertCLRAttributes(GType type, GMethod res, MethodBase method)
{
res.Attributes = 0;
if (method.IsPublic || type.IsInterface)
{
res.Attributes |= MemberAttributes.Public;
}
else if (method.IsFamily && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Family;
}
else if (method.IsFamilyOrAssembly && !type.IsInterface)
{
res.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if (method.IsFamilyAndAssembly && !type.IsInterface)
{
res.Attributes |= MemberAttributes.FamilyAndAssembly;
}
if (method.IsAbstract && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Abstract;
}
else if (method.IsStatic && !type.IsInterface)
{
res.IsStatic = method.IsStatic;
res.Attributes |= MemberAttributes.Static;
}
else if (!method.IsVirtual && !method.IsAbstract && !type.IsInterface)
{
//TODO res.Attributes |= MemberAttributes.Final;
}
}
private CodeStatement GenerateCallStatementC2J(GMethod method, CodeExpression invokeExpression)
{
CodeStatement call;
if (method.IsConstructor || method.IsVoid)
{
call = new CodeExpressionStatement(invokeExpression);
}
else
{
if (method.ReturnType.IsPrimitive)
{
if (method.ReturnType.JVMSubst != null)
{
invokeExpression = new CodeCastExpression(method.ReturnType.CLRReference, invokeExpression);
}
call = new CodeMethodReturnStatement(invokeExpression);
}
else
{
CodeMethodInvokeExpression conversionExpression = CreateConversionExpressionJ2CParam(method.ReturnType,
invokeExpression);
call = new CodeMethodReturnStatement(conversionExpression);
}
}
return call;
}
private static void RegisterJVMMethod(GType type, Method method, bool register)
{
var modifiers = (ModifierFlags)method.getModifiers();
Annotation annotation = HasAnnotation(method, "net.sf.jni4net.attributes.ClrMethod");
if (annotation != null ||
(modifiers & (ModifierFlags.Private | ModifierFlags.Synthetic)) != ModifierFlags.None)
{
if (annotation == null)
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
}
return;
}
var res = new GMethod();
res.Type = type;
res.Name = method.getName();
res.JVMName = res.Name;
res.CLRName = res.JVMName;
res.IsJVMMethod = true;
var parameterTypes = method.getParameterTypes();
var parameterNames = GetParameterNames(method, parameterTypes.Length);
for (int i = 0; i < parameterTypes.Length; i++)
{
var paramType = parameterTypes[i];
var paramName = parameterNames[i];
res.ParameterNames.Add(paramName); //+ paramType.ShortName
res.Parameters.Add(RegisterClass(paramType));
}
ConvertJVMAttributes(type, res, method);
res.LowerName = res.Name + res.GetSignatureLowerNoRet();
res.ReturnType = RegisterClass(method.getReturnType());
if (register)
{
bool force = false;
if (UseMethodModifier(type, res, res.Name, res.GetJVMSignature(), ref force))
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
FinishRegistration(method.getName(), type, res, force, res.Name + res.GetCLRSignatureNoRet(), skipCLR);
}
}
/*private void GenerateMethods(CodeTypeDeclaration tgtType)
{
foreach (GMethod method in type.Methods)
{
CreateMethodSignature(tgtType, method, false);
}
}*/
private CodeMemberMethod CreateConstructorHelper(GMethod constructor, string uName)
{
var tgtMethod = new CodeMemberMethod();
tgtMethod.Name = uName;
tgtMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private | MemberAttributes.New;
Utils.AddAttribute(tgtMethod, "net.sf.jni4net.attributes.ClrMethod", constructor.CLRSignature);
// inject thiz parameter
var tgtParameter = new CodeParameterDeclarationExpression();
tgtParameter.Name = "thiz";
tgtParameter.Type = constructor.Type.CLRReference;
tgtMethod.Parameters.Add(tgtParameter);
GenerateParameters(constructor, tgtMethod);
return tgtMethod;
}
private void CreateConstructorBody(GMethod constructor, CodeConstructor con, string uName)
{
if (!type.IsRootType)
{
con.BaseConstructorArgs.Add(
new CodeCastExpression(TypeReference("net.sf.jni4net.inj.INJEnv"), new CodePrimitiveExpression(null)));
con.BaseConstructorArgs.Add(new CodePrimitiveExpression(0));
}
var parameters = new CodeExpression[constructor.Parameters.Count + 1];
for (int p = 0; p < constructor.Parameters.Count; p++)
{
parameters[p + 1] = new CodeVariableReferenceExpression(constructor.ParameterNames[p]);
}
parameters[0] = new CodeThisReferenceExpression();
con.Statements.Add(
new CodeMethodInvokeExpression(CurrentTypeEx, uName, parameters));
}
private static void RegisterJVMConstructor(GType type, Constructor ctor, bool register)
{
var modifiers = (ModifierFlags)ctor.getModifiers();
if ((modifiers & (ModifierFlags.Private | ModifierFlags.Synthetic)) != ModifierFlags.None)
{
return;
}
var res = new GMethod();
res.Type = type;
res.Name = "<init>";
res.JVMName = res.Name;
res.CLRName = "_ctor" + type.JVMType.getSimpleName();
res.ReturnType = voidType;
res.IsJVMMethod = true;
res.IsConstructor = true;
var parameterTypes = ctor.getParameterTypes();
var parameterNames = GetParameterNames(ctor, parameterTypes.Length);
for (int i = 0; i < parameterTypes.Length; i++)
{
var paramType = parameterTypes[i];
var paramName = parameterNames[i];
res.ParameterNames.Add(paramName); //+ paramType.ShortName
res.Parameters.Add(RegisterClass(paramType));
}
ConvertJVMAttributes(type, res, ctor);
res.LowerName = (res.Name + res.GetSignatureLowerNoRet());
if (register)
{
bool force = false;
if (UseMethodModifier(type, res, res.Name, res.GetJVMSignature(), ref force))
{
return;
}
type.Constructors.Add(res);
}
}
private static void FinishRegistration(string method, GType type, GMethod res, bool force, string sig, RegSkip skipSignatureBuilder)
{
if (!res.UseExplicitInterface && !force)
{
if (type.AllMethods.ContainsKey(sig))
{
type.SkippedMethods.Add(res);
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method + "<-" + type.AllMethods[sig].Type);
}
return;
}
type.AllMethods.Add(sig, res);
}
if (res.UseExplicitInterface)
{
if (type.AllMethods.ContainsKey(sig))
{
GMethod rem = type.AllMethods[sig];
type.AllMethods.Remove(sig);
type.MethodsWithInterfaces.Remove(rem);
}
foreach (GMethod skip in type.SkippedMethods)
{
string skipSig = skipSignatureBuilder(skip);
if (skipSig == sig)
{
type.Methods.Add(skip);
type.MethodsWithInterfaces.Add(skip);
type.AllMethods.Add(sig, skip);
type.SkippedMethods.Remove(skip);
break;
}
}
type.AllMethods.Add(res.DeclaringType.Name + "." + sig, res);
}
type.MethodsWithInterfaces.Add(res);
type.Methods.Add(res);
}
private static bool UseMethodModifier(GType type, GMethod res, string name, string signature, ref bool force)
{
bool fskip = false;
if (type.Registration != null)
{
MethodModifier modifier;
if (type.Registration.GetModifier(name, signature, out modifier))
{
if (modifier.Return != null)
{
res.ReturnType = knownNames[modifier.Return.ToLowerInvariant()];
}
if (modifier.Interface != null)
{
res.UseExplicitInterface = true;
res.DeclaringType = knownNames[modifier.Interface.ToLowerInvariant()];
}
if (modifier.RenameJVM != null)
{
res.JVMName = modifier.RenameJVM;
}
if (modifier.RenameCLR != null)
{
res.JVMName = modifier.RenameCLR;
}
if (modifier.Hide)
{
res.Attributes = (res.Attributes & (MemberAttributes.VTableMask | MemberAttributes.ScopeMask)) | MemberAttributes.Private;
}
if (modifier.Skip)
{
type.SkippedMethods.Add(res);
fskip = true;
}
force = type.Registration.TestForceMethod(name, signature);
}
}
return(fskip);
}
protected void CreateMethodC2J(GMethod method, CodeTypeDeclaration tgtType, string uName, bool isProxy)
{
if (method.IsCLRMethod && !type.IsInterface && !type.IsDelegate)
{
return;
}
if (isProxy || !type.IsInterface)
{
GenerateMethodIdFieldC2J(method, tgtType, uName);
GenerateMethodRegC2J(method, uName);
}
if (method.IsStatic && type.IsInterface && isProxy)
{
return;
}
CodeStatementCollection tgtStatements = CreateMethodSignature(tgtType, method, isProxy);
GenerateGetEnvC2J(method, tgtStatements);
CodeMethodInvokeExpression invokeExpression = GenerateInvokeExpressionC2J(method, uName);
CodeStatement call = GenerateCallStatementC2J(method, invokeExpression);
tgtStatements.Add(call);
GenerateEndFrameC2J(tgtStatements);
}
private static void ConvertJVMAttributes(GType type, GMethod res, Member member)
{
var modifiers = (ModifierFlags)member.getModifiers();
res.Attributes = 0;
if ((modifiers & (ModifierFlags.Public)) != ModifierFlags.None || type.IsInterface)
{
res.Attributes |= MemberAttributes.Public;
}
if ((modifiers & (ModifierFlags.Static)) != ModifierFlags.None)
{
res.Attributes |= MemberAttributes.Static;
res.IsStatic = true;
}
/*if ((modifiers & (ModifierFlags.Abstract)) != ModifierFlags.None && !type.IsInterface)
* {
* res.Attributes |= MemberAttributes.Abstract;
* }*/
if ((modifiers & (ModifierFlags.Final)) != ModifierFlags.None && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Final;
}
}
protected CodeMemberMethod CreateMethodSignature(GMethod method, bool skipSignature)
{
CodeMemberMethod tgtMethod;
if (method.IsConstructor)
{
tgtMethod = new CodeConstructor();
}
else
{
tgtMethod = new CodeMemberMethod();
tgtMethod.Name = method.JVMName;
tgtMethod.ReturnType = method.ReturnType.JVMReference;
}
if (!config.SkipSignatures && !skipSignature)
{
if (method.IsConstructor)
{
Utils.AddAttribute(tgtMethod, "net.sf.jni4net.attributes.ClrConstructor", method.CLRSignature);
}
else
{
Utils.AddAttribute(tgtMethod, "net.sf.jni4net.attributes.ClrMethod", method.CLRSignature);
}
}
tgtMethod.Attributes = method.Attributes;
GenerateParameters(method, tgtMethod);
return tgtMethod;
}
private static string skipCLR(GMethod skip)
{
return skip.Name + skip.GetCLRSignatureNoRet();
}
private string GetCallNameC2J(GMethod method)
{
var callName = new StringBuilder();
if (method.IsConstructor)
{
callName.Append("NewObject");
}
else
{
if (method.ReturnType != null && method.ReturnType.IsPrimitive)
{
callName.Append(method.ReturnType.JVMResolved);
callName[0] = Char.ToUpper(callName[0]);
}
else
{
callName.Append("Object");
}
if (method.IsStatic)
{
callName.Insert(0, "Static");
}
callName.Insert(0, method.IsField ? "Get" : "Call");
callName.Append(method.IsField ? "Field" : "Method");
if (method.ReturnType != null && !method.ReturnType.IsPrimitive)
{
callName.Append("Ptr");
}
}
return callName.ToString();
}
private void GenerateMethodIdFieldC2J(GMethod method, CodeTypeDeclaration tgtType, string uName)
{
CodeMemberField fieldId;
if (method.IsField)
{
fieldId = new CodeMemberField(TypeReference(typeof (FieldId)), uName);
}
else
{
fieldId = new CodeMemberField(TypeReference(typeof (MethodId)), uName);
}
fieldId.Attributes = MemberAttributes.Static | MemberAttributes.FamilyAndAssembly;
tgtType.Members.Add(fieldId);
}
private static GMethod RegisterCLRCall(GType type, MethodBase method)
{
var res = new GMethod();
res.Type = type;
res.Name = method.Name;
res.CLRName = method.Name;
res.JVMName = method.Name;
res.IsCLRMethod = true;
foreach (ParameterInfo info in method.GetParameters())
{
Type parameterType = info.ParameterType;
if (TestCLRType(parameterType))
{
return null;
}
// we ignore IsOut when IsIn is set as well, because they are probably just attributes
// see System.IO.TextReader.Read([In, Out] char[] buffer, int index, int count)
if (info.IsOut && !info.IsIn)
{
//this is trick how to store out as type
parameterType = parameterType.GetElementType().MakePointerType();
}
res.ParameterNames.Add(info.Name);
res.Parameters.Add(RegisterType(parameterType));
}
res.ReturnType = RegisterType(typeof (void));
ConvertCLRAttributes(type, res, method);
res.LowerName = (res.JVMName + res.GetSignatureLowerNoRet());
return res;
}
private List<CodeExpression> GenerateCallParamsJ2C(GMethod method)
{
var callParams = new List<CodeExpression>();
for (int p = 0; p < method.Parameters.Count; p++)
{
GType paramType = method.Parameters[p];
var invokeExpression = new CodeVariableReferenceExpression(method.ParameterNames[p]);
if (paramType.IsOut)
{
var outExpression = new CodeSnippetExpression("out __out_" + method.ParameterNames[p]);
callParams.Add(outExpression);
}
else if (paramType.IsRef)
{
var outExpression = new CodeSnippetExpression("ref __ref_" + method.ParameterNames[p]);
callParams.Add(outExpression);
}
else if (paramType.IsPrimitive)
{
callParams.Add(invokeExpression);
}
else
{
CodeMethodInvokeExpression conversionExpression = CreateConversionExpressionJ2CParam(paramType,
invokeExpression);
callParams.Add(conversionExpression);
}
}
return callParams;
}
private void GenerateCallJ2C(CodeMemberMethod tgtMethod, GMethod method)
{
List<CodeExpression> callParams = GenerateCallParamsJ2C(method);
if (method.IsConstructor)
{
tgtMethod.ReturnType = new CodeTypeReference(typeof (void));
var call = new CodeObjectCreateExpression(RealType, callParams.ToArray());
tgtMethod.Statements.Add(
new CodeVariableDeclarationStatement(RealType, realVariableName, call));
tgtMethod.Statements.Add(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(TypeReferenceEx(typeof (Convertor)),
"InitProxy"), envVariable, objVariable, realVariable));
}
else
{
CodeExpression targetObject;
if (method.IsStatic)
{
targetObject = RealTypeEx;
}
else
{
CodeExpression expression = CreateConversionExpressionJ2C(type, objVariable);
tgtMethod.Statements.Add(
new CodeVariableDeclarationStatement(RealType, realVariableName, expression));
if (method.DeclaringType != type)
{
targetObject = new CodeCastExpression(method.DeclaringType.CLRReference, realVariable);
}
else
{
targetObject = realVariable;
}
}
CodeExpression call;
CodeExpression value = null;
if (method.IsProperty)
{
if (method.IsVoid)
{
int last = callParams.Count - 1;
value = callParams[last];
callParams.RemoveAt(last);
}
if (method.CLRProperty.GetIndexParameters().Length > 0)
{
call = new CodeIndexerExpression(targetObject, callParams.ToArray());
}
else
{
call = new CodePropertyReferenceExpression(targetObject, method.CLRProperty.Name);
}
}
else if (method.IsEvent)
{
int last = callParams.Count - 1;
value = callParams[last];
if (method.IsCLRPropertyAdd)
{
call = new CodeEventReferenceExpression(targetObject, method.CLREvent.Name + "__event_add__");
}
else
{
call = new CodeEventReferenceExpression(targetObject, method.CLREvent.Name + "__event_remove__");
}
}
else
{
call = new CodeMethodInvokeExpression(targetObject, method.CLRName, callParams.ToArray());
}
CodeStatement callst;
if (method.IsVoid)
{
if (method.IsProperty || method.IsEvent)
{
callst = new CodeAssignStatement(call, value);
}
else
{
callst = new CodeExpressionStatement(call);
}
}
else
{
if (method.ReturnType.IsPrimitive)
{
if (method.ReturnType.JVMSubst != null)
{
call = new CodeCastExpression(method.ReturnType.CLRReference, call);
}
callst = new CodeAssignStatement(new CodeVariableReferenceExpression("__return"),call);
tgtMethod.ReturnType = method.ReturnType.CLRReference;
}
else
{
CodeMethodInvokeExpression conversionExpression =
CreateConversionExpressionC2J(method.ReturnType, call);
callst = new CodeAssignStatement(new CodeVariableReferenceExpression("__return"), conversionExpression);
tgtMethod.ReturnType = TypeReference(typeof(JniHandle));
}
}
tgtMethod.Statements.Add(callst);
}
}
private static void RegisterJVMField(GType type, Field field, bool register)
{
var modifiers = (ModifierFlags) field.getModifiers();
if ((modifiers & (ModifierFlags.Private | ModifierFlags.Synthetic)) != ModifierFlags.None)
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + field);
}
return;
}
var res = new GMethod();
res.Type = type;
res.IsField = true;
res.Name = field.getName();
res.JVMName = field.getName();
res.CLRName = res.JVMName;
res.IsJVMMethod = true;
ConvertJVMAttributes(type, res, field);
res.ReturnType = RegisterClass(field.getType());
res.LowerName = (field.getName());
if (register)
{
type.Methods.Add(res);
type.MethodsWithInterfaces.Add(res);
}
}
private static void RegisterJVMMethod(GType type, Method method, bool register)
{
var modifiers = (ModifierFlags)method.getModifiers();
Annotation annotation = HasAnnotation(method, "net.sf.jni4net.attributes.ClrMethod");
if (annotation != null ||
(modifiers & (ModifierFlags.Private | ModifierFlags.Synthetic)) != ModifierFlags.None)
{
if (annotation == null)
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
}
return;
}
var res = new GMethod();
res.Type = type;
res.Name = method.getName();
res.JVMName = res.Name;
res.CLRName = res.JVMName;
res.IsJVMMethod = true;
Class[] parameterTypes = method.getParameterTypes();
for (int i = 0; i < parameterTypes.Length; i++)
{
Class paramType = parameterTypes[i];
res.ParameterNames.Add("par" + i); //+ paramType.ShortName
res.Parameters.Add(RegisterClass(paramType));
}
ConvertJVMAttributes(type, res, method);
res.LowerName = res.Name + res.GetSignatureLowerNoRet();
res.ReturnType = RegisterClass(method.getReturnType());
if (register)
{
bool force = false;
if (UseMethodModifier(type, res, res.Name, res.GetJVMSignature(), ref force))
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
FinishRegistration(method.getName(), type, res, force, res.Name + res.GetCLRSignatureNoRet(), skipCLR);
}
}
protected void GenerateParameters(GMethod method, CodeMemberMethod tgtMethod)
{
for (int i = 0; i < method.Parameters.Count; i++)
{
var tgtParameter = new CodeParameterDeclarationExpression();
tgtParameter.Name = method.ParameterNames[i];
tgtParameter.Type = method.Parameters[i].JVMReference;
tgtMethod.Parameters.Add(tgtParameter);
}
}
private void GenerateMethodCallEpilogJ2C(CodeMemberMethod tgtMethod, GMethod method)
{
for (int p = 0; p < method.Parameters.Count; p++)
{
GType parameter = method.Parameters[p];
string name = method.ParameterNames[p];
if (parameter.IsOut)
{
var parExpression = new CodeVariableReferenceExpression(name);
var outExpression = new CodeVariableReferenceExpression("__out_" + name);
CodeMethodInvokeExpression invokeExpression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(typeof(Out)), "SetValue",
new[] { parameter.CLRReference }),
envVariable, parExpression, outExpression);
tgtMethod.Statements.Add(invokeExpression);
}
else if (parameter.IsRef)
{
var parExpression = new CodeVariableReferenceExpression(name);
var outExpression = new CodeVariableReferenceExpression("__ref_" + name);
CodeMethodInvokeExpression invokeExpression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(typeof(Ref)), "SetValue",
new[] { parameter.CLRReference }),
envVariable, parExpression, outExpression);
tgtMethod.Statements.Add(invokeExpression);
}
}
tgtMethod.Statements.Add(
new CodeSnippetStatement(
" }catch (global::System.Exception __ex){@" + envVariableName + ".ThrowExisting(__ex);}"
//}
));
if (!method.IsConstructor && !method.IsVoid)
{
tgtMethod.Statements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("__return")));
}
}
private static void ConvertCLRAttributes(GType type, GMethod res, MethodBase method)
{
res.Attributes = 0;
if (method.IsPublic || type.IsInterface)
{
res.Attributes |= MemberAttributes.Public;
}
else if (method.IsFamily && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Family;
}
else if (method.IsFamilyOrAssembly && !type.IsInterface)
{
res.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if (method.IsFamilyAndAssembly && !type.IsInterface)
{
res.Attributes |= MemberAttributes.FamilyAndAssembly;
}
if (method.IsAbstract && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Abstract;
}
else if (method.IsStatic && !type.IsInterface)
{
res.IsStatic = method.IsStatic;
res.Attributes |= MemberAttributes.Static;
}
else if (!method.IsVirtual && !method.IsAbstract && !type.IsInterface)
{
//TODO res.Attributes |= MemberAttributes.Final;
}
}
private void GenerateGetEnvC2J(GMethod method, CodeStatementCollection tgtStatements)
{
if (method.IsStatic || method.IsConstructor)
{
CodeStatement statement =
new CodeVariableDeclarationStatement(
new CodeTypeReference(typeof (JNIEnv), CodeTypeReferenceOptions.GlobalReference),
envVariableName,
new CodePropertyReferenceExpression(TypeReferenceEx(typeof (JNIEnv)), "ThreadEnv"));
tgtStatements.Add(statement);
}
else
{
CodeStatement statement =
new CodeVariableDeclarationStatement(
new CodeTypeReference(typeof (JNIEnv), CodeTypeReferenceOptions.GlobalReference),
envVariableName,
new CodePropertyReferenceExpression
(new CodeThisReferenceExpression
(), "Env"));
tgtStatements.Add(statement);
}
int framesize = (10+method.Parameters.Count*2);
tgtStatements.Add(new CodeSnippetStatement(" using(new global::net.sf.jni4net.jni.LocalFrame(@__env, "+framesize+")){"));
}
private static string skipJVM(GMethod skip)
{
return skip.Name + skip.GetJVMSignatureNoRet();
}
private static void RegisterJVMConstructor(GType type, Constructor ctor, bool register)
{
var modifiers = (ModifierFlags) ctor.getModifiers();
if ((modifiers & (ModifierFlags.Private | ModifierFlags.Synthetic)) != ModifierFlags.None)
{
return;
}
var res = new GMethod();
res.Type = type;
res.Name = "<init>";
res.JVMName = res.Name;
res.CLRName = "_ctor" + type.JVMType.getSimpleName();
res.ReturnType = voidType;
res.IsJVMMethod = true;
res.IsConstructor = true;
Class[] parameterTypes = ctor.getParameterTypes();
for (int i = 0; i < parameterTypes.Length; i++)
{
Class paramType = parameterTypes[i];
res.ParameterNames.Add("par" + i); //+ paramType.ShortName
res.Parameters.Add(RegisterClass(paramType));
}
ConvertJVMAttributes(type, res, ctor);
res.LowerName = (res.Name + res.GetSignatureLowerNoRet());
if (register)
{
bool force = false;
if (UseMethodModifier(type, res, res.Name, res.GetJVMSignature(), ref force))
{
return;
}
type.Constructors.Add(res);
}
}
private CodeMethodInvokeExpression GenerateInvokeExpressionC2J(GMethod method, string uName)
{
CodeExpression[] expressions = GetExpressionsC2J(method, uName);
string callName = GetCallNameC2J(method);
return new CodeMethodInvokeExpression(envVariable, callName, expressions);
}
private static bool UseMethodModifier(GType type, GMethod res, string name, string signature, ref bool force)
{
bool fskip = false;
if (type.Registration != null)
{
MethodModifier modifier;
if (type.Registration.GetModifier(name, signature, out modifier))
{
if (modifier.Return != null)
{
res.ReturnType = knownNames[modifier.Return.ToLowerInvariant()];
}
if (modifier.Interface != null)
{
res.UseExplicitInterface = true;
res.DeclaringType = knownNames[modifier.Interface.ToLowerInvariant()];
}
if (modifier.RenameJVM != null)
{
res.JVMName = modifier.RenameJVM;
}
if (modifier.RenameCLR != null)
{
res.JVMName = modifier.RenameCLR;
}
if (modifier.Hide)
{
res.Attributes = (res.Attributes & (MemberAttributes.VTableMask|MemberAttributes.ScopeMask)) | MemberAttributes.Private;
}
if (modifier.Skip)
{
type.SkippedMethods.Add(res);
fskip = true;
}
force = type.Registration.TestForceMethod(name, signature);
}
}
return fskip;
}
private void GenerateMethodRegC2J(GMethod method, string uName)
{
var claxs = new CodeFieldReferenceExpression(CurrentTypeEx, "staticClass");
string getmethodidthrow = method.IsField
? method.IsStatic ? "GetStaticFieldID" : "GetFieldID"
: method.IsStatic ? "GetStaticMethodID" : "GetMethodID";
var initBody =
new CodeAssignStatement(
new CodeFieldReferenceExpression(CurrentTypeEx, uName),
new CodeMethodInvokeExpression(
envVariable, getmethodidthrow,
claxs,
new CodePrimitiveExpression(method.JVMName),
new CodePrimitiveExpression(method.JVMSignature)));
InitStatements.Add(initBody);
}
private static void RegisterCLRMethod(GType type, MethodInfo method, bool register)
{
object attr = HasAttribute(method, javaMethodAttribute);
if (method.IsGenericMethod || !method.IsPublic || attr != null)
{
if (attr == null && config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
if (method.IsSpecialName)
{
string name = method.Name;
if (name.StartsWith("op_"))
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
}
GMethod res = RegisterCLRCall(type, method);
if (res == null || TestCLRType(method.ReturnType))
{
// skip
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
if (method.IsSpecialName)
{
res.CLRProperty = GetProperty(type, method);
if (res.CLRProperty == null)
{
res.CLREvent = GetEvent(type, method);
res.IsEvent = true;
if (method.Name.StartsWith("add_"))
{
res.IsCLRPropertyAdd = true;
res.CLRPropertyAdd = res;
foreach (GMethod m in type.Methods)
{
if (m.CLRProperty == res.CLRProperty)
{
m.CLRPropertyAdd = res;
}
}
}
if (method.Name.StartsWith("remove_"))
{
res.IsCLRPropertyRemove = true;
res.CLRPropertyRemove = res;
foreach (GMethod m in type.Methods)
{
if (m.CLRProperty == res.CLRProperty)
{
m.CLRPropertyRemove = res;
}
}
}
res.CLRName = res.CLREvent.Name;
res.JVMName = method.Name.Replace("_", "");
}
else
{
res.IsProperty = true;
if (res.CLRProperty.CanRead && method.Name.StartsWith("get_"))
{
res.IsCLRPropertyGetter = true;
res.CLRPropertyGetter = res;
foreach (GMethod m in type.Methods)
{
if (m.CLRProperty == res.CLRProperty)
{
m.CLRPropertyGetter = res;
}
}
}
if (res.CLRProperty.CanWrite && method.Name.StartsWith("set_"))
{
res.IsCLRPropertySetter = true;
res.CLRPropertySetter = res;
foreach (GMethod m in type.Methods)
{
if (m.CLRProperty == res.CLRProperty)
{
m.CLRPropertySetter = res;
}
}
}
res.CLRName = res.CLRProperty.Name;
res.JVMName = method.Name.Replace("_", "");
if (res.CLRProperty.PropertyType == typeof(bool) && res.JVMName.StartsWith("getIs"))
{
res.JVMName = "is" + res.JVMName.Substring(5);
}
}
res.Name = method.Name;
}
if (method.DeclaringType != type.CLRType)
{
res.DeclaringType = RegisterType(method.DeclaringType);
}
res.ReturnType = RegisterType(method.ReturnType);
if (register)
{
bool force = false;
if (UseMethodModifier(type, res, res.Name, res.GetCLRSignature(), ref force))
{
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method);
}
return;
}
FinishRegistration(method.Name, type, res, force, res.Name + res.GetJVMSignatureNoRet(), skipJVM);
}
}
private CodeExpression[] GetExpressionsC2J(GMethod method, string uName)
{
int offset = method.IsConstructor ? 3 : 2;
var expressions = new CodeExpression[method.Parameters.Count + offset];
if (method.IsStatic || method.IsConstructor)
{
expressions[0] = new CodeFieldReferenceExpression(ProxyTypeEx, "staticClass");
}
else
{
expressions[0] = new CodeThisReferenceExpression();
}
expressions[1] = new CodeFieldReferenceExpression(ProxyTypeEx, uName);
if (method.IsConstructor)
{
expressions[2] = new CodeThisReferenceExpression();
}
for (int i = 0; i < method.Parameters.Count; i++)
{
GType parameter = method.Parameters[i];
string paramName = method.ParameterNames[i];
CodeExpression invokeExpression = new CodeVariableReferenceExpression(paramName);
CodeMethodInvokeExpression conversionExpression = CreateConversionExpressionC2JParam(parameter,
invokeExpression);
expressions[i + offset] = conversionExpression;
}
return expressions;
}
protected CodeStatementCollection CreateMethodSignature(CodeTypeDeclaration tgtType, GMethod method,
bool isProxy)
{
bool add = true;
CodeStatementCollection tgtStatements;
CodeTypeMember tgtMember;
CodeMemberMethod tgtMethod = null;
CodeMemberPropertyEx tgtProperty;
CodeMemberPropertyEx tgtEvent;
if (method.IsConstructor)
{
var tgtConstructor = new CodeConstructor();
tgtMethod = tgtConstructor;
tgtMember = tgtMethod;
tgtStatements = tgtMethod.Statements;
if (!type.IsRootType)
{
tgtConstructor.BaseConstructorArgs.Add(
new CodeCastExpression(TypeReference("net.sf.jni4net.jni.JNIEnv"),
new CodePrimitiveExpression(null)));
}
}
else if (method.IsField)
{
var p = new CodeMemberProperty();
tgtMember = p;
tgtStatements = p.GetStatements;
p.Name = method.CLRName;
p.Type = method.ReturnType.CLRReference;
}
else if (method.IsEvent)
{
tgtEvent = new CodeMemberPropertyEx();
tgtEvent.Getter = method.CLRPropertyAdd;
tgtEvent.Setter = method.CLRPropertyRemove;
tgtEvent.Name = method.CLRName;
if (method.UseExplicitInterface)
{
tgtEvent.PrivateImplementationType = method.DeclaringType.CLRReference;
}
foreach (CodeTypeMember m in tgtType.Members)
{
var member = m as CodeMemberPropertyEx;
if (member != null)
if (member.Getter == method || member.Setter == method)
{
tgtEvent = member;
add = false;
break;
}
}
int count = method.Parameters.Count-1;
tgtEvent.Type = method.Parameters[count].CLRReference;
if (add)
{
for (int i = 0; i < count; i++)
{
var tgtParameter = new CodeParameterDeclarationExpression();
tgtParameter.Name = method.ParameterNames[i];
tgtParameter.Type = method.Parameters[i].CLRReference;
tgtEvent.Parameters.Add(tgtParameter);
}
tgtEvent.Comments.Add(new CodeCommentStatement("__event__"));
}
tgtMember = tgtEvent;
if (method.IsCLRPropertyAdd)
{
tgtEvent.GetStatements.Add(new CodeCommentStatement("__add__"));
tgtStatements = tgtEvent.GetStatements;
}
else
{
tgtEvent.SetStatements.Add(new CodeCommentStatement("__remove__"));
tgtStatements = tgtEvent.SetStatements;
}
}
else if (method.IsProperty)
{
tgtProperty = new CodeMemberPropertyEx();
tgtProperty.Setter = method.CLRPropertySetter;
tgtProperty.Getter = method.CLRPropertyGetter;
tgtProperty.Name = method.CLRName;
if (method.UseExplicitInterface)
{
tgtProperty.PrivateImplementationType = method.DeclaringType.CLRReference;
}
foreach (CodeTypeMember m in tgtType.Members)
{
var member = m as CodeMemberPropertyEx;
if (member != null)
if (member.Getter == method || member.Setter == method)
{
tgtProperty = member;
add = false;
break;
}
}
int count = method.Parameters.Count;
if (!method.IsCLRPropertyGetter)
{
count--;
}
if (add)
{
for (int i = 0; i < count; i++)
{
var tgtParameter = new CodeParameterDeclarationExpression();
tgtParameter.Name = method.ParameterNames[i];
tgtParameter.Type = method.Parameters[i].CLRReference;
tgtProperty.Parameters.Add(tgtParameter);
}
}
if (method.IsCLRPropertyGetter)
{
tgtProperty.Type = method.ReturnType.CLRReference;
tgtStatements = tgtProperty.GetStatements;
}
else
{
tgtProperty.Type = method.Parameters[count].CLRReference;
tgtStatements = tgtProperty.SetStatements;
}
tgtMember = tgtProperty;
}
else
{
tgtMethod = new CodeMemberMethod();
tgtMethod.Name = method.CLRName;
tgtMethod.ReturnType = method.ReturnType.CLRReference;
tgtMember = tgtMethod;
tgtStatements = tgtMethod.Statements;
if (method.UseExplicitInterface)
{
tgtMethod.PrivateImplementationType = method.DeclaringType.CLRReference;
}
}
if (!config.SkipSignatures && !isProxy)
{
Utils.AddAttribute(tgtMember, "net.sf.jni4net.attributes.JavaMethodAttribute", method.JVMSignature);
}
tgtMember.Attributes = method.Attributes;
if (isProxy)
{
tgtMember.Attributes |= MemberAttributes.Final;
}
if (tgtMethod != null)
{
GenerateParameters(method, tgtMethod);
}
if (add)
{
tgtType.Members.Add(tgtMember);
}
return tgtStatements;
}
private void GenerateMethodRegistrationJ2C(GMethod method, string uName)
{
string callbackName = method.IsConstructor ? uName : method.JVMName;
string callBackSignature = method.IsConstructor
? method.JVMSignature.Replace("(", "(Lnet/sf/jni4net/inj/IClrProxy;")
: method.JVMSignature;
var registation = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("methods"),
"Add",
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
TypeReferenceEx(typeof (JNINativeMethod)), "Create"),
new CodeVariableReferenceExpression(typeVariableName),
new CodePrimitiveExpression(callbackName),
new CodePrimitiveExpression(uName),
new CodePrimitiveExpression(callBackSignature)));
initMethod.Statements.Add(registation);
}
private static string skipJVM(GMethod skip)
{
return(skip.Name + skip.GetJVMSignatureNoRet());
}
private void GenerateMethodCallPrologJ2C(CodeMemberMethod tgtMethod, GMethod method)
{
if (!method.IsConstructor && !method.IsVoid)
{
if (method.ReturnType.IsPrimitive)
{
tgtMethod.Statements.Add(new CodeVariableDeclarationStatement(method.ReturnType.CLRReference, "__return", new CodeDefaultValueExpression(method.ReturnType.CLRReference)));
}
else
{
CodeTypeReference jnihandle = TypeReference(typeof(JniHandle));
tgtMethod.Statements.Add(new CodeVariableDeclarationStatement(jnihandle, "__return", new CodeDefaultValueExpression(jnihandle)));
}
}
tgtMethod.Statements.Add(
new CodeSnippetStatement(
//using (new global::net.sf.jni4net.jni.LocalFrame(env)) {
" try {"));
for (int p = 0; p < method.Parameters.Count; p++)
{
GType parameter = method.Parameters[p];
string name = method.ParameterNames[p];
if (parameter.IsOut)
{
tgtMethod.Statements.Add(new CodeVariableDeclarationStatement(parameter.CLRReference, "__out_" + name));
}
if (parameter.IsRef)
{
var parExpression = new CodeVariableReferenceExpression(name);
CodeMethodInvokeExpression conversionExpression = new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(typeof(Ref)), "GetValue",
new[] { parameter.CLRReference }), envVariable, parExpression);
CodeVariableDeclarationStatement varExpression = new CodeVariableDeclarationStatement(parameter.CLRReference, "__ref_" + name, conversionExpression);
tgtMethod.Statements.Add(varExpression);
}
}
}
private static void ConvertJVMAttributes(GType type, GMethod res, Member member)
{
var modifiers = (ModifierFlags) member.getModifiers();
res.Attributes = 0;
if ((modifiers & (ModifierFlags.Public)) != ModifierFlags.None || type.IsInterface)
{
res.Attributes |= MemberAttributes.Public;
}
if ((modifiers & (ModifierFlags.Static)) != ModifierFlags.None)
{
res.Attributes |= MemberAttributes.Static;
res.IsStatic = true;
}
/*if ((modifiers & (ModifierFlags.Abstract)) != ModifierFlags.None && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Abstract;
}*/
if ((modifiers & (ModifierFlags.Final)) != ModifierFlags.None && !type.IsInterface)
{
res.Attributes |= MemberAttributes.Final;
}
}
private static string skipCLR(GMethod skip)
{
return(skip.Name + skip.GetCLRSignatureNoRet());
}
private void GenerateMethodJ2C(GMethod method, CodeTypeDeclaration tgtType, string uName)
{
var tgtMethod = new CodeMemberMethod();
tgtMethod.Statements.Add(new CodeCommentStatement(method.JVMSignature));
tgtMethod.Statements.Add(new CodeCommentStatement(method.CLRSignature));
tgtMethod.Name = uName;
tgtMethod.Attributes = MemberAttributes.Static | MemberAttributes.Private;
GenerateMethodParamsJ2C(tgtMethod, method);
GenerateGetEnvJ2C(tgtMethod);
GenerateMethodCallPrologJ2C(tgtMethod, method);
GenerateCallJ2C(tgtMethod, method);
GenerateMethodCallEpilogJ2C(tgtMethod, method);
tgtType.Members.Add(tgtMethod);
}
private void GenerateMethodParamsJ2C(CodeMemberMethod tgtMethod, GMethod method)
{
var enviParam = new CodeParameterDeclarationExpression(
TypeReference(typeof (IntPtr)), envpVariableName);
tgtMethod.Parameters.Add(enviParam);
if (method.IsStatic || method.IsConstructor)
{
var classParam = new CodeParameterDeclarationExpression(
TypeReference(typeof (JniLocalHandle)), classVariableName);
tgtMethod.Parameters.Add(classParam);
}
if (!method.IsStatic || method.IsConstructor)
{
var classParam = new CodeParameterDeclarationExpression(
TypeReference(typeof(JniLocalHandle)), objVariableName);
tgtMethod.Parameters.Add(classParam);
}
for (int p = 0; p < method.Parameters.Count; p++)
{
GType paramType = method.Parameters[p];
CodeTypeReference parameter;
if (!paramType.IsPrimitive || paramType.IsOut || paramType.IsRef)
{
parameter = TypeReference(typeof(JniLocalHandle));
}
else
{
parameter = paramType.CLRReference;
}
string name = method.ParameterNames[p];
tgtMethod.Parameters.Add(new CodeParameterDeclarationExpression(parameter, name));
}
}
private static void FinishRegistration(string method, GType type, GMethod res, bool force, string sig, RegSkip skipSignatureBuilder)
{
if (!res.UseExplicitInterface && !force)
{
if (type.AllMethods.ContainsKey(sig))
{
type.SkippedMethods.Add(res);
if (config.Verbose)
{
Console.WriteLine("Skip " + type + "." + method + "<-" + type.AllMethods[sig].Type);
}
return;
}
type.AllMethods.Add(sig, res);
}
if (res.UseExplicitInterface)
{
if (type.AllMethods.ContainsKey(sig))
{
GMethod rem = type.AllMethods[sig];
type.AllMethods.Remove(sig);
type.MethodsWithInterfaces.Remove(rem);
}
foreach (GMethod skip in type.SkippedMethods)
{
string skipSig = skipSignatureBuilder(skip);
if (skipSig == sig)
{
type.Methods.Add(skip);
type.MethodsWithInterfaces.Add(skip);
type.AllMethods.Add(sig, skip);
type.SkippedMethods.Remove(skip);
break;
}
}
type.AllMethods.Add(res.DeclaringType.Name + "." + sig, res);
}
type.MethodsWithInterfaces.Add(res);
type.Methods.Add(res);
}
