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 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)); } }