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