private void CompilePrimitive(InterType type)
{
if (Program.BoxType == BoxingType.Java)
{
return;
}
if (type.PrimitiveType == PrimitiveType.Void)
{
return; //Skip compiling void type. It's never will boxed
}
JavaPrimitiveType javaType = JavaHelpers.InterTypeToJavaPrimitive(type);
currentJavaClass = new Java.Class();
currentJavaClass.AccessFlag = Java.ClassAccessFlag.Public | Java.ClassAccessFlag.Super | ClassAccessFlag.Final;
currentJavaClass.ThisClass = TypeNameToJava(type.CILBoxType);
currentJavaClass.SuperClass = TypeNameToJava(ClassNames.JavaObject);
Field valueField = new Field();
valueField.AccessFlags = FieldAccessFlags.Private;
valueField.Name = "value";
valueField.Descriptor = GetFieldDescriptor(type);
currentJavaClass.Fields.Add(valueField);
FieldRef valueFieldRef = new FieldRef(currentJavaClass.ThisClass, valueField.Name, valueField.Descriptor);
Method ctorMethod = new Method();
ctorMethod.AccessFlags = MethodAccessFlags.Public;
ctorMethod.Name = ClassNames.JavaConstructorMethodName;
ctorMethod.Descriptor = "()V";
ctorMethod.Attributes.Add(new JavaBytecodeWriter()
.Add(OpCodes.aload_0)
.Add(OpCodes.invokespecial, ClassNames.JavaObjectCtorMethodRef)
.Add(OpCodes.aload_0)
.AddDefaultValue(javaType)
.Add(OpCodes.putfield, valueFieldRef)
.Add(OpCodes._return)
.End(currentJavaClass.ConstantPool));
currentJavaClass.Methods.Add(ctorMethod);
Method ctorValueMethod = new Method();
ctorValueMethod.AccessFlags = MethodAccessFlags.Public;
ctorValueMethod.Name = ClassNames.JavaConstructorMethodName;
ctorValueMethod.Descriptor = "(" + valueField.Descriptor + ")V";
ctorValueMethod.Attributes.Add(new JavaBytecodeWriter()
.Add(OpCodes.aload_0)
.Add(OpCodes.invokespecial, ClassNames.JavaObjectCtorMethodRef)
.Add(OpCodes.aload_0)
.AddLoad(javaType, 1)
.Add(OpCodes.putfield, valueFieldRef)
.Add(OpCodes._return)
.End(currentJavaClass.ConstantPool));
currentJavaClass.Methods.Add(ctorValueMethod);
MethodRef ctorValueMethodRef = new MethodRef(currentJavaClass.ThisClass, ctorValueMethod.Name, ctorValueMethod.Descriptor);
Method valueOfMethod = new Method();
valueOfMethod.AccessFlags = MethodAccessFlags.Public | MethodAccessFlags.Static;
valueOfMethod.Name = "valueOf";
valueOfMethod.Descriptor = "(" + valueField.Descriptor + ")L" + TypeNameToJava(type.CILBoxType) + ";";
valueOfMethod.Attributes.Add(new JavaBytecodeWriter()
.Add(OpCodes._new, new Java.Constants.Class(TypeNameToJava(type.CILBoxType)))
.Add(OpCodes.dup)
.AddLoad(javaType, 0)
.Add(OpCodes.invokespecial, ctorValueMethodRef)
.Add(OpCodes.areturn)
.End(currentJavaClass.ConstantPool));
currentJavaClass.Methods.Add(valueOfMethod);
Method getValueMethod = new Method();
getValueMethod.AccessFlags = MethodAccessFlags.Public;
getValueMethod.Name = Utils.GetJavaTypeName(type.PrimitiveType) + "Value";
getValueMethod.Descriptor = "()" + GetFieldDescriptor(type);
getValueMethod.Attributes.Add(new JavaBytecodeWriter()
.Add(OpCodes.aload_0)
.Add(OpCodes.getfield, valueFieldRef)
.AddReturn(JavaHelpers.InterTypeToJavaPrimitive(type))
.End(currentJavaClass.ConstantPool));
currentJavaClass.Methods.Add(getValueMethod);
currentJavaInnerClasses = new Java.Attributes.InnerClasses();
foreach (InterField field in type.Fields)
{
currentJavaClass.Fields.Add(CompileField(field));
}
foreach (InterMethod method in type.Methods)
{
currentJavaClass.Methods.Add(CompileMethod(method));
}
if (currentJavaInnerClasses.Classes.Count > 0)
{
currentJavaClass.Attributes.Add(currentJavaInnerClasses);
}
WriteClass(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);
}
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);
}
public static Attribute ReadAttribute(BinaryReader Reader, ConstantPool Pool)
{
string Name = ((Constants.Utf8)Pool[Reader.ReadUInt16BE()]).Value;
uint Length = Reader.ReadUInt32BE();
long Next = (long)Reader.BaseStream.Position - (long)(Length - 6);
Attribute Result = null;
if (Name == "AnnotationDefault")
{
Result = new Attributes.AnnotationDefault();
}
else if (Name == "Code")
{
Result = new Attributes.Code();
}
else if (Name == "ConstantValue")
{
Result = new Attributes.ConstantValue();
}
else if (Name == "Deprecated")
{
Result = new Attributes.Deprecated();
}
else if (Name == "Exceptions")
{
Result = new Attributes.Exceptions();
}
else if (Name == "InnerClasses")
{
Result = new Attributes.InnerClasses();
}
else if (Name == "LineNumberTable")
{
Result = new Attributes.LineNumberTable();
}
else if (Name == "LocalVariableTable")
{
Result = new Attributes.LocalVariableTable();
}
else if (Name == "RuntimeVisibleAnnotations")
{
Result = new Attributes.RuntimeVisibleAnnotations();
}
else if (Name == "RuntimeInvisibleAnnotations")
{
Result = new Attributes.RuntimeInvisibleAnnotations();
}
else if (Name == "RuntimeVisibleParameterAnnotations")
{
Result = new Attributes.RuntimeVisibleParameterAnnotations(Reader.ReadByte());
}
else if (Name == "RuntimeInvisibleParameterAnnotations")
{
Result = new Attributes.RuntimeInvisibleParameterAnnotations(Reader.ReadByte());
}
else if (Name == "Signature")
{
Result = new Attributes.Signature();
}
else if (Name == "SourceFile")
{
Result = new Attributes.SourceFile();
}
else if (Name == "Synthetic")
{
Result = new Attributes.Synthetic();
}
else
{
Result = new Attributes.RawAttribute();
Result.Name = Name;
}
Result.Read(Length, Reader, Pool);
return(Result);
}