|
public static AddAttribute ( |
||
| tgtMethodCLR | ||
| attr | string | |
| return | ||
/// <summary>
/// Create proxy for interface
/// </summary>
protected void GenerateProxy(CodeNamespace nameSpace)
{
var tgtType = new CodeTypeDeclaration("__" + type.Name);
SetCurrentType(type.CLRNamespaceExt + ".__" + type.Name, type.CLRNamespace + "." + type.Name,
type.CLRNamespaceExt + ".__" + type.Name, type.CLRNamespaceExt + "." + type.Name + "_");
AddTypeCLR(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = TypeAttributes.NotPublic | TypeAttributes.Sealed;
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.JavaProxyAttribute", RealType, StaticType);
tgtType.BaseTypes.Add(Repository.javaLangObject.CLRReference);
if (type.IsInterface)
{
tgtType.BaseTypes.Add(type.CLRReference);
}
tgtType.IsPartial = true;
GenerateTypeOfInit(tgtType, true);
GenerateWrapperInitJ2C();
if (type.Registration == null || !type.Registration.NoMethods)
{
if (type.IsInterface || type.IsDelegate)
{
GenerateProxyMethodsC2J(tgtType);
}
GenerateWrapperMethodsJ2C(tgtType);
}
GenerateConstructionHelper(tgtType);
CreateEnvConstructor(tgtType, "net.sf.jni4net.jni.JNIEnv", false, false, true);
tgtType.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, cdc));
tgtType.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, cdc));
}
private void GenerateInterface(CodeNamespace nameSpace)
{
var tgtType = new CodeTypeDeclaration(type.Name);
SetCurrentType(type.JVMNamespace + "." + type.Name);
AddTypeCLR(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = TypeAttributes.Public;
tgtType.IsInterface = true;
tgtType.IsPartial = true;
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.JavaInterfaceAttribute", type.JVMFullName);
foreach (GType ifc in type.Interfaces)
{
if (ifc.IsCLRGenerate || ifc.IsCLRType)
{
tgtType.BaseTypes.Add(ifc.CLRReference);
}
}
if (type.Registration == null || !type.Registration.NoMethods)
{
// dump java side methods
// CLR methods should be in partial file
foreach (GMethod method in type.Methods)
{
if (method.IsJVMMethod && !method.IsField)
{
CreateMethodSignature(tgtType, method, false);
}
}
}
tgtType.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, cdc));
tgtType.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, cdc));
}
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);
}
/// <summary>
/// Create proxy for interface
/// </summary>
protected void GenerateProxy(CodeNamespace nameSpace)
{
var tgtType = new CodeTypeDeclaration("__" + type.Name);
SetCurrentType(type.JVMNamespaceExt + ".__" + type.Name, type.JVMNamespace + "." + type.Name,
type.JVMNamespaceExt + ".__" + type.Name, type.CLRNamespaceExt + "." + type.Name + "_");
AddTypeJVM(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = TypeAttributes.NotPublic;
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.ClrProxy");
if (!type.IsDelegate)
{
tgtType.BaseTypes.Add(Repository.systemObject.JVMReference);
}
tgtType.BaseTypes.Add(type.JVMReference);
CreateEnvConstructor(tgtType, "net.sf.jni4net.inj.INJEnv", false, true, false);
if (type.Registration == null || !type.Registration.NoMethods)
{
foreach (GMethod method in type.MethodsWithInterfaces)
{
if (!method.IsStatic || !type.IsInterface)
{
CodeMemberMethod tgtMethod = CreateMethodSignature(method, false);
ChangeNativeAttributes(tgtMethod);
tgtType.Members.Add(tgtMethod);
}
}
}
tgtType.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, sMagicProxy));
tgtType.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, eMagicProxy));
}
protected void GenerateWrapperMethodsJ2C(CodeTypeDeclaration tgtType)
{
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.ClrWrapperAttribute", RealType, StaticType);
tgtType.Members.Add(initMethod);
int m = 0;
foreach (GMethod method in type.MethodsWithInterfaces)
{
string uName = (method.CLRName + m);
if (!method.IsStatic || !type.IsInterface)
{
GenerateMethodJ2C(method, tgtType, uName);
GenerateMethodRegistrationJ2C(method, uName);
}
m++;
}
m = 0;
foreach (GMethod method in type.Constructors)
{
string uName = "__ctor" + type.Name + m;
GenerateMethodJ2C(method, tgtType, uName);
GenerateMethodRegistrationJ2C(method, uName);
m++;
}
initMethod.Statements.Add(
new CodeMethodReturnStatement(new CodeVariableReferenceExpression("methods")));
}
private void GenerateClass(CodeNamespace nameSpace)
{
var tgtType = new CodeTypeDeclaration(type.Name);
SetCurrentType(type.CLRNamespace + "." + type.Name);
AddTypeCLR(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = type.Attributes & TypeAttributes.VisibilityMask;
tgtType.IsPartial = true;
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.JavaClassAttribute");
tgtType.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, cdc));
tgtType.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, cdc));
if (type.Base != null)
{
tgtType.BaseTypes.Add(type.Base.CLRReference);
}
foreach (GType ifc in type.Interfaces)
{
if (ifc.IsCLRGenerate || ifc.IsCLRType)
{
tgtType.BaseTypes.Add(ifc.CLRReference);
}
}
// fields with type information
GenerateStaticFields(tgtType);
GenerateTypeOfInit(tgtType, false);
GenerateMethodsC2J(tgtType);
GenerateConstructionHelper(tgtType);
CreateEnvConstructor(tgtType, "net.sf.jni4net.jni.JNIEnv",
type == Repository.javaLangClass || type == Repository.javaLangString, false, false);
if (type.IsException)
{
if (type.IsRootType)
{
return;
}
Utils.AddAttribute(tgtType, "System.SerializableAttribute");
var sc = new CodeConstructor();
sc.Attributes = MemberAttributes.Family;
sc.Parameters.Add(new CodeParameterDeclarationExpression(TypeReference(typeof(SerializationInfo)), "info"));
sc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("info"));
sc.Parameters.Add(new CodeParameterDeclarationExpression(TypeReference(typeof(StreamingContext)), "context"));
sc.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("context"));
tgtType.Members.Add(sc);
}
}
private void GenerateStatic(CodeNamespace nameSpace)
{
// static helper type
var tgtType = new CodeTypeDeclaration(type.Name + "_");
SetCurrentType(type.JVMNamespaceExt + "." + type.Name + "_", type.JVMNamespace + "." + type.Name,
type.JVMNamespaceExt + ".__" + type.Name, type.JVMNamespaceExt + "." + type.Name + "_");
AddTypeJVM(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.ClrTypeInfo");
// fields with type information
GenerateTypeOfInit(tgtType);
WrapMethodsMagic(tgtType, sMagicStatic, eMagicStatic);
}
/*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);
}
protected override void Generate(CodeNamespace nameSpace)
{
var tgtType = new CodeTypeDeclaration(type.Name);
SetCurrentType(type.JVMNamespace + "." + type.Name);
AddTypeJVM(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = type.Attributes & TypeAttributes.VisibilityMask;
/*if (type.IsAbstract)
* {
* tgtType.TypeAttributes |= TypeAttributes.Abstract;
* }*/
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.ClrType");
if (type.Base != null)
{
tgtType.BaseTypes.Add(type.Base.JVMReference);
}
foreach (GType ifc in type.Interfaces)
{
if (ifc.IsJVMGenerate || ifc.IsJVMType)
{
tgtType.BaseTypes.Add(ifc.JVMReference);
}
}
// fields with type information
CreateEnvConstructor(tgtType, "net.sf.jni4net.inj.INJEnv", false, true, false);
GenerateConstructors(tgtType);
GenerateMethods(tgtType);
GenerateTypeOfInit(tgtType);
WrapMethodsMagic(tgtType, sMagicProxy, eMagicProxy);
if (type.IsDelegate)
{
tgtType.TypeAttributes |= TypeAttributes.Abstract;
GenerateProxy(nameSpace);
}
}
private void GenerateInterface(CodeNamespace nameSpace)
{
var tgtType = new CodeTypeDeclaration(type.Name);
SetCurrentType(type.JVMNamespace + "." + type.Name);
AddTypeJVM(CurrentType.BaseType);
nameSpace.Types.Add(tgtType);
tgtType.TypeAttributes = TypeAttributes.Public;
tgtType.IsInterface = true;
Utils.AddAttribute(tgtType, "net.sf.jni4net.attributes.ClrInterface");
foreach (GType ifc in type.Interfaces)
{
if (ifc.IsJVMGenerate || ifc.IsJVMType)
{
tgtType.BaseTypes.Add(ifc.JVMReference);
}
}
CodeMemberMethod first = null;
CodeMemberMethod last = null;
if (type.Registration == null || !type.Registration.NoMethods)
{
// dump java side methods first, they will be replaced by oldFile eventually
foreach (GMethod method in type.Methods)
{
if (method.IsJVMMethod)
{
last = CreateMethodSignature(method, true);
tgtType.Members.Add(last);
}
}
// now dump methods which are found on CLR side
foreach (GMethod method in type.Methods)
{
if (method.IsCLRMethod)
{
last = CreateMethodSignature(method, false);
tgtType.Members.Add(last);
if (first == null)
{
first = last;
}
}
}
}
// if there is at leat one, put magic block around
if (first != null)
{
first.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, sMagicIface));
last.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, eMagicIface));
}
else if (last != null)
{
last.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, sMagicIface));
last.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, eMagicIface));
}
}
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);
}
