void INamesController.WriteAnonumousClass(Java.Class javaClass)
{
WriteClass(javaClass);
Java.Attributes.InnerClasses.InnerClass descr = new Java.Attributes.InnerClasses.InnerClass();
descr.AccessFlags = Java.Attributes.InnerClasses.InnerClassAccessFlags.Public;
descr.InnerClassInfo = javaClass.ThisClass;
descr.OuterClassInfo = currentJavaClass.ThisClass;
descr.InnerName = javaClass.ThisClass.Substring(javaClass.ThisClass.LastIndexOf('$') + 1);
currentJavaInnerClasses.Classes.Add(descr);
}
private Java.Class ComplileType(InterType type)
{
sourceFileNameCounter = new Counter <string>();
Messages.Verbose(" Compiling type {0}...", type.ToString());
currentType = type;
currentJavaClass = new Java.Class();
currentJavaClass.AccessFlag = (Java.ClassAccessFlag)GetClassAccessFlags(type, false);
currentJavaClass.ThisClass = TypeNameToJava(type.Fullname);
if (type.BaseType == null)
{
currentJavaClass.SuperClass = TypeNameToJava(ClassNames.JavaObject);
}
else
{
currentJavaClass.SuperClass = TypeNameToJava(type.BaseType.Fullname);
}
foreach (InterType i in type.Interfaces)
{
currentJavaClass.Interfaces.Add(TypeNameToJava(i.Fullname));
}
if (type.IsValueType)
{
CompileValueType(type);
}
if (type.IsEnum)
{
CompileEnum(type);
}
currentJavaInnerClasses = new Java.Attributes.InnerClasses();
if (type.DeclaringType != null)
{
Java.Attributes.InnerClasses.InnerClass innerClass = new Java.Attributes.InnerClasses.InnerClass();
innerClass.AccessFlags = (Java.Attributes.InnerClasses.InnerClassAccessFlags)GetClassAccessFlags(type, true);
innerClass.InnerClassInfo = TypeNameToJava(type.Fullname);
innerClass.InnerName = TypeNameToJava(type.Name);
innerClass.OuterClassInfo = TypeNameToJava(type.DeclaringType.Fullname);
currentJavaInnerClasses.Classes.Add(innerClass);
}
foreach (InterType nestedClass in type.NestedClasses)
{
Java.Attributes.InnerClasses.InnerClass innerClass = new Java.Attributes.InnerClasses.InnerClass();
innerClass.AccessFlags = (Java.Attributes.InnerClasses.InnerClassAccessFlags)GetClassAccessFlags(nestedClass, true);
innerClass.InnerClassInfo = TypeNameToJava(nestedClass.Fullname);
innerClass.InnerName = TypeNameToJava(nestedClass.Name);
innerClass.OuterClassInfo = TypeNameToJava(type.Fullname);
currentJavaInnerClasses.Classes.Add(innerClass);
}
if (type.IsDelegate)
{
CompileDelegate(type);
}
else
{
foreach (InterField field in type.Fields)
{
currentJavaClass.Fields.Add(CompileField(field));
}
foreach (InterMethod method in type.Methods)
{
currentJavaClass.Methods.Add(CompileMethod(method));
}
if (type.BaseType != null)
{
CompileOverridedMethods(type, type.BaseType);
}
foreach (InterType iface in type.Interfaces)
{
CompileOverridedMethods(type, iface);
}
GenerateFieldAccessors(type);
}
bool hasStaticCtor = type.Methods.Where(M => ((M.IsConstructor) && (M.IsStatic))).Count() > 0;
bool needStaticCtor = type.Fields.Where(F => ((F.FieldType.IsValueType) && (F.IsStatic))).Count() > 0;
needStaticCtor |= type.Fields.Where(F => F.IsStatic && F.IsThreadLocal).Count() > 0;
if ((needStaticCtor) && (!hasStaticCtor))
{
GenerateStaticCtor(type);
}
if (currentJavaInnerClasses.Classes.Count > 0)
{
currentJavaClass.Attributes.Add(currentJavaInnerClasses);
}
if ((Program.Debug) && (sourceFileNameCounter != null) && (sourceFileNameCounter.IsStarted))
{
string fileName = sourceFileNameCounter.MostUsed;
if (!Program.FullPathInSourceFileName)
{
fileName = System.IO.Path.GetFileName(fileName);
}
currentJavaClass.Attributes.Add(new Java.Attributes.SourceFile(fileName));
}
return(currentJavaClass);
}
private void GenerateDelegateRunner(InterType type)
{
Java.Class runner = new Java.Class();
runner.AccessFlag = ClassAccessFlag.Final;
runner.ThisClass = currentJavaClass.ThisClass + "$" + ClassNames.DelegateRunnerClassName;
runner.SuperClass = TypeNameToJava(ClassNames.CIL2JavaDelegateRunner.ClassName);
Java.Attributes.InnerClasses.InnerClass inner = new Java.Attributes.InnerClasses.InnerClass()
{
AccessFlags = Java.Attributes.InnerClasses.InnerClassAccessFlags.Final | Java.Attributes.InnerClasses.InnerClassAccessFlags.Private,
InnerClassInfo = runner.ThisClass,
InnerName = ClassNames.DelegateRunnerClassName,
OuterClassInfo = currentJavaClass.ThisClass
};
Java.Attributes.InnerClasses innerAttr = new Java.Attributes.InnerClasses();
innerAttr.Classes.Add(inner);
runner.Attributes.Add(innerAttr);
currentJavaInnerClasses.Classes.Add(inner);
InterMethod invokeMethod = type.Methods.Where(M => M.Name == ClassNames.DelegateInvokeMethodName).FirstOrDefault();
Field selfField = new Field();
selfField.AccessFlags = FieldAccessFlags.Private | FieldAccessFlags.Final;
selfField.Name = ClassNames.DelegateRunnerSelfFieldName;
selfField.Descriptor = GetFieldDescriptor(type);
runner.Fields.Add(selfField);
FieldRef selfFieldRef = new FieldRef(runner.ThisClass, selfField.Name, selfField.Descriptor);
JavaBytecodeWriter ctorCodeWriter = new JavaBytecodeWriter();
JavaBytecodeWriter runCodeWriter = new JavaBytecodeWriter();
ctorCodeWriter
//super()
.Add(OpCodes.aload_0)
.Add(OpCodes.invokespecial, ClassNames.CIL2JavaDelegateRunner.CtorMethodRef)
//this.self = self;
.Add(OpCodes.aload_0)
.Add(OpCodes.aload_1)
.Add(OpCodes.putfield, selfFieldRef);
if (invokeMethod.ReturnParameter.Type.PrimitiveType != PrimitiveType.Void)
{
runCodeWriter.Add(OpCodes.aload_0);
}
runCodeWriter
.Add(OpCodes.aload_0)
.Add(OpCodes.getfield, selfFieldRef);
for (int i = 0; i < invokeMethod.Parameters.Count; i++)
{
InterType paramType = invokeMethod.Parameters[i].Type;
JavaPrimitiveType jp = JavaHelpers.InterTypeToJavaPrimitive(paramType);
Field paramField = new Field();
paramField.AccessFlags = FieldAccessFlags.Final | FieldAccessFlags.Private;
paramField.Name = ClassNames.DelegateRunnerParamFieldNamePrefix + i.ToString();;
paramField.Descriptor = GetFieldDescriptor(paramType);
runner.Fields.Add(paramField);
FieldRef paramFieldRef = new FieldRef(runner.ThisClass, paramField.Name, paramField.Descriptor);
ctorCodeWriter
.Add(OpCodes.aload_0)
.AddLoad(jp, i + 2)
.Add(OpCodes.putfield, paramFieldRef);
runCodeWriter
.Add(OpCodes.aload_0)
.Add(OpCodes.getfield, paramFieldRef);
}
if (invokeMethod.ReturnParameter.Type.PrimitiveType != PrimitiveType.Void)
{
Field resultField = new Field();
resultField.AccessFlags = FieldAccessFlags.Private;
resultField.Name = ClassNames.DelegateRunnerResultFieldName;
resultField.Descriptor = GetFieldDescriptor(invokeMethod.ReturnParameter.Type);
runner.Fields.Add(resultField);
runCodeWriter.Add(OpCodes.putfield, new FieldRef(runner.ThisClass, resultField.Name, resultField.Descriptor));
}
runCodeWriter
.Add(OpCodes.invokevirtual, new MethodRef(TypeNameToJava(type.Fullname), ClassNames.DelegateInvokeMethodName,
GetMethodDescriptor(invokeMethod)))
.Add(OpCodes.aload_0)
.Add(OpCodes.getfield, ClassNames.CIL2JavaDelegateRunner.OnEndedFieldRef)
.Add(OpCodes.dup)
.Add(OpCodes.ifnull, "noOnEnd")
.Add(OpCodes.aload_0)
.Add(OpCodes.getfield, ClassNames.CIL2JavaDelegateRunner.AsyncResultFieldResult)
.Add(OpCodes.invokevirtual, ClassNames.SystemAsyncCallback.InvokeMethodRef)
.Add(OpCodes._goto, "exit")
.Label("noOnEnd")
.Add(OpCodes.pop)
.Label("exit");
ctorCodeWriter.Add(OpCodes._return);
runCodeWriter.Add(OpCodes._return);
string paramsDescriptor = GetMethodDescriptor(invokeMethod);
paramsDescriptor = paramsDescriptor.Substring(1, paramsDescriptor.LastIndexOf(')') - 1);
Method ctorMethod = new Method();
ctorMethod.AccessFlags = MethodAccessFlags.Public;
ctorMethod.Name = ClassNames.JavaConstructorMethodName;
ctorMethod.Descriptor = "(" + GetFieldDescriptor(type) + paramsDescriptor + ")V";
ctorMethod.Attributes.Add(ctorCodeWriter.End(runner.ConstantPool));
runner.Methods.Add(ctorMethod);
Method runMethod = new Method();
runMethod.AccessFlags = MethodAccessFlags.Public;
runMethod.Name = ClassNames.CIL2JavaDelegateRunner.RunMethodName;
runMethod.Descriptor = "()V";
runMethod.Attributes.Add(runCodeWriter.End(runner.ConstantPool));
runner.Methods.Add(runMethod);
WriteClass(runner);
}
