ikvm-fork/ikvmstub/ikvmstub.cs

/*
  Copyright (C) 2002, 2004, 2005 Jeroen Frijters

  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.

  Jeroen Frijters
  jeroen@frijters.net
  
*/
using System;
using System.Reflection;
using System.IO;
using System.Text;
using System.Collections;
using ICSharpCode.SharpZipLib.Zip;
using IKVM.Attributes;
using IKVM.Internal;

public class NetExp
{
	private static ZipOutputStream zipFile;
	private static Hashtable privateClasses = new Hashtable();

	public static void Main(string[] args)
	{
		Tracer.EnableTraceForDebug();
		if(args.Length != 1)
		{
			Console.Error.WriteLine("usage: ikvmstub <assemblyNameOrPath>");
			return;
		}
		Assembly assembly = null;
		FileInfo file = null;
		try
		{
			file = new FileInfo(args[0]);
		}
		catch(System.Exception x)
		{
			Console.Error.WriteLine("Error: unable to load \"{0}\"\n  {1}", args[0], x.Message);
			return;
		}
		if(file != null && file.Exists)
		{
			try
			{
				// If the same assembly can be found in the "Load" context, we prefer to use that
				// http://blogs.gotdotnet.com/suzcook/permalink.aspx/d5c5e14a-3612-4af1-a9b7-0a144c8dbf16
				// We use AssemblyName.FullName, because otherwise the assembly will be loaded in the
				// "LoadFrom" context using the path inside the AssemblyName object.
				assembly = Assembly.Load(AssemblyName.GetAssemblyName(args[0]).FullName);
				Console.Error.WriteLine("Warning: Assembly loaded from {0} instead", assembly.Location);
			}
			catch
			{
			}
			if(assembly == null)
			{
				assembly = Assembly.LoadFrom(args[0]);
			}
		}
		else
		{
			assembly = Assembly.LoadWithPartialName(args[0]);
		}
		int rc = 0;
		if(assembly == null)
		{
			Console.Error.WriteLine("Error: Assembly \"{0}\" not found", args[0]);
		}
		else
		{
			zipFile = new ZipOutputStream(new FileStream(assembly.GetName().Name + ".jar", FileMode.Create));
			try
			{
				ProcessAssembly(assembly);
				ProcessPrivateClasses(assembly);
			}
			catch(System.Exception x)
			{
				java.lang.Throwable.instancehelper_printStackTrace(IKVM.Runtime.Util.MapException(x));
				rc = 1;
			}
			zipFile.Close();
		}
		// FXBUG if we run a static initializer that starts a thread, we would never end,
		// so we force an exit here
		Environment.Exit(rc);
	}

	private static void WriteClass(string name, ClassFileWriter c)
	{
		zipFile.PutNextEntry(new ZipEntry(name));
		c.Write(zipFile);
	}

	private static void ProcessAssembly(Assembly assembly)
	{
		foreach(Type t in assembly.GetTypes())
		{
			if(t.IsPublic)
			{
				java.lang.Class c;
				try
				{
					c = java.lang.Class.forName(t.AssemblyQualifiedName, false, null);
				}
				catch(java.lang.ClassNotFoundException)
				{
					// types that IKVM doesn't support don't show up
					continue;
				}
				ProcessClass(assembly.FullName, c, null);
			}
		}
	}

	// TODO private classes should also be done handled for interfaces, fields and method arguments/return type
	private static void ProcessPrivateClasses(Assembly assembly)
	{
		Hashtable done = new Hashtable();
		bool keepGoing;
		do
		{
			Hashtable todo = privateClasses;
			privateClasses = new Hashtable();
			keepGoing = false;
			foreach(java.lang.Class c in todo.Values)
			{
				if(!done.ContainsKey(c.getName()))
				{
					keepGoing = true;
					done.Add(c.getName(), null);
					ProcessClass(assembly.FullName, c, c.getDeclaringClass());
				}
			}
		} while(keepGoing);
	}

	private static void AddToExportList(java.lang.Class c)
	{
		while(c.isArray())
		{
			c = c.getComponentType();
		}
		privateClasses[c.getName()] = c;
	}

	private static bool IsGenericType(java.lang.Class c)
	{
		// HACK huge hack, we look for the backtick
		return c.getName().IndexOf("$$0060") > 0;
	}

	private static void ProcessClass(string assemblyName, java.lang.Class c, java.lang.Class outer)
	{
		string name = c.getName().Replace('.', '/');
		string super = null;
		if(c.getSuperclass() != null)
		{
			super = c.getSuperclass().getName().Replace('.', '/');
			// if the base class isn't public, we still need to export it (!)
			if(!java.lang.reflect.Modifier.isPublic(c.getSuperclass().getModifiers()))
			{
				AddToExportList(c.getSuperclass());
			}
		}
		if(c.isInterface())
		{
			super = "java/lang/Object";
		}
		Modifiers classmods = (Modifiers)c.getModifiers();
		if(outer != null)
		{
			// protected inner classes are actually public and private inner classes are actually package
			if((classmods & Modifiers.Protected) != 0)
			{
				classmods |= Modifiers.Public;
			}
			classmods &= ~(Modifiers.Static | Modifiers.Private | Modifiers.Protected);
		}
#if GENERICS
		if(c.isAnnotation())
		{
			classmods |= Modifiers.Annotation;
		}
		if(c.isEnum())
		{
			classmods |= Modifiers.Enum;
		}
		if(c.isSynthetic())
		{
			classmods |= Modifiers.Synthetic;
		}
		ClassFileWriter f = new ClassFileWriter(classmods, name, super, 0, 49);
		string genericSignature = BuildGenericSignature(c);
		if(genericSignature != null)
		{
			f.AddStringAttribute("Signature", genericSignature);
		}
#else
		ClassFileWriter f = new ClassFileWriter(classmods, name, super, 3, 45);
#endif
		f.AddStringAttribute("IKVM.NET.Assembly", assemblyName);
		if(IKVM.Runtime.Util.IsClassDeprecated(c))
		{
			f.AddAttribute(new DeprecatedAttribute(f));
		}
		InnerClassesAttribute innerClassesAttribute = null;
		if(outer != null)
		{
			innerClassesAttribute = new InnerClassesAttribute(f);
			string innername = name;
			int idx = name.LastIndexOf('$');
			if(idx >= 0)
			{
				innername = innername.Substring(idx + 1);
			}
			innerClassesAttribute.Add(name, outer.getName().Replace('.', '/'), innername, (ushort)c.getModifiers());
		}
		java.lang.Class[] interfaces = c.getInterfaces();
		for(int i = 0; i < interfaces.Length; i++)
		{
			if(java.lang.reflect.Modifier.isPublic(interfaces[i].getModifiers()))
			{
				f.AddInterface(interfaces[i].getName().Replace('.', '/'));
				if(IsGenericType(interfaces[i]))
				{
					AddToExportList(interfaces[i]);
				}
			}
		}
		java.lang.Class[] innerClasses = c.getDeclaredClasses();
		for(int i = 0; i < innerClasses.Length; i++)
		{
			Modifiers mods = (Modifiers)innerClasses[i].getModifiers();
			if((mods & (Modifiers.Public | Modifiers.Protected)) != 0)
			{
				if(innerClassesAttribute == null)
				{
					innerClassesAttribute = new InnerClassesAttribute(f);
				}
				string namePart = innerClasses[i].getName();
				namePart = namePart.Substring(namePart.LastIndexOf('$') + 1);
				innerClassesAttribute.Add(innerClasses[i].getName().Replace('.', '/'), name, namePart, (ushort)innerClasses[i].getModifiers());
				ProcessClass(assemblyName, innerClasses[i], c);
			}
		}
		java.lang.reflect.Constructor[] constructors = c.getDeclaredConstructors();
		for(int i = 0; i < constructors.Length; i++)
		{
			Modifiers mods = (Modifiers)constructors[i].getModifiers();
			if((mods & (Modifiers.Public | Modifiers.Protected)) != 0)
			{
#if GENERICS
				if(constructors[i].isSynthetic())
				{
					mods |= Modifiers.Synthetic;
				}
				if(constructors[i].isVarArgs())
				{
					mods |= Modifiers.VarArgs;
				}
#endif
				// TODO what happens if one of the argument types is non-public?
				java.lang.Class[] args = constructors[i].getParameterTypes();
				foreach(java.lang.Class arg in args)
				{
					if(IsGenericType(arg))
					{
						AddToExportList(arg);
					}
				}
				FieldOrMethod m = f.AddMethod(mods, "<init>", MakeSig(args, java.lang.Void.TYPE));
				CodeAttribute code = new CodeAttribute(f);
				code.MaxLocals = (ushort)(args.Length * 2 + 1);
				code.MaxStack = 3;
				ushort index1 = f.AddClass("java/lang/UnsatisfiedLinkError");
				ushort index2 = f.AddString("ikvmstub generated stubs can only be used on IKVM.NET");
				ushort index3 = f.AddMethodRef("java/lang/UnsatisfiedLinkError", "<init>", "(Ljava/lang/String;)V");
				code.ByteCode = new byte[] {
					187, (byte)(index1 >> 8), (byte)index1,	// new java/lang/UnsatisfiedLinkError
					89,										// dup
				    19,	 (byte)(index2 >> 8), (byte)index2,	// ldc_w "..."
					183, (byte)(index3 >> 8), (byte)index3, // invokespecial java/lang/UnsatisfiedLinkError/init()V
					191										// athrow
				};
				m.AddAttribute(code);
				AddExceptions(f, m, constructors[i].getExceptionTypes());
				if(IKVM.Runtime.Util.IsConstructorDeprecated(constructors[i]))
				{
					m.AddAttribute(new DeprecatedAttribute(f));
				}
#if GENERICS
				string signature = BuildGenericSignature(constructors[i].getTypeParameters(),
					constructors[i].getGenericParameterTypes(), java.lang.Void.TYPE, constructors[i].getGenericExceptionTypes());
				if (signature != null)
				{
					m.AddAttribute(f.MakeStringAttribute("Signature", signature));
				}
#endif
			}
		}
		java.lang.reflect.Method[] methods = c.getDeclaredMethods();
		for(int i = 0; i < methods.Length; i++)
		{
			// FXBUG (?) .NET reflection on java.lang.Object returns toString() twice!
			// I didn't want to add the work around to CompiledTypeWrapper, so it's here.
			if((c.getName() == "java.lang.Object" || c.getName() == "java.lang.Throwable")
				&& methods[i].getName() == "toString")
			{
				bool found = false;
				for(int j = 0; j < i; j++)
				{
					if(methods[j].getName() == "toString")
					{
						found = true;
						break;
					}
				}
				if(found)
				{
					continue;
				}
			}
			Modifiers mods = (Modifiers)methods[i].getModifiers();
			if((mods & (Modifiers.Public | Modifiers.Protected)) != 0)
			{
				if((mods & Modifiers.Abstract) == 0)
				{
					mods |= Modifiers.Native;
				}
#if GENERICS
				if(methods[i].isBridge())
				{
					mods |= Modifiers.Bridge;
				}
				if(methods[i].isSynthetic())
				{
					mods |= Modifiers.Synthetic;
				}
				if(methods[i].isVarArgs())
				{
					mods |= Modifiers.VarArgs;
				}
#endif
				// TODO what happens if one of the argument types (or the return type) is non-public?
				java.lang.Class[] args = methods[i].getParameterTypes();
				foreach(java.lang.Class arg in args)
				{
					if(IsGenericType(arg))
					{
						AddToExportList(arg);
					}
				}
				java.lang.Class retType = methods[i].getReturnType();
				if(IsGenericType(retType))
				{
					AddToExportList(retType);
				}
				FieldOrMethod m = f.AddMethod(mods, methods[i].getName(), MakeSig(args, retType));
				AddExceptions(f, m, methods[i].getExceptionTypes());
				if(IKVM.Runtime.Util.IsMethodDeprecated(methods[i]))
				{
					m.AddAttribute(new DeprecatedAttribute(f));
				}
#if GENERICS
				string signature = BuildGenericSignature(methods[i].getTypeParameters(),
					methods[i].getGenericParameterTypes(), methods[i].getGenericReturnType(),
					methods[i].getGenericExceptionTypes());
				if (signature != null)
				{
					m.AddAttribute(f.MakeStringAttribute("Signature", signature));
				}
#endif
			}
		}
		java.lang.reflect.Field[] fields = c.getDeclaredFields();
		for(int i = 0; i < fields.Length; i++)
		{
			Modifiers mods = (Modifiers)fields[i].getModifiers();
			if((mods & (Modifiers.Public | Modifiers.Protected)) != 0 ||
				// Include serialVersionUID field, to make Japitools comparison more acurate
				((mods & (Modifiers.Static | Modifiers.Final)) == (Modifiers.Static | Modifiers.Final) &&
				fields[i].getName() == "serialVersionUID" && fields[i].getType() == java.lang.Long.TYPE))
			{
				// we use the IKVM runtime API to get constant value
				// NOTE we can't use Field.get() because that will run the static initializer and
				// also won't allow us to see the difference between constants and blank final fields.
				object constantValue = IKVM.Runtime.Util.GetFieldConstantValue(fields[i]);
				if(constantValue != null)
				{
					if(constantValue is java.lang.Boolean)
					{
						constantValue = ((java.lang.Boolean)constantValue).booleanValue();
					}
					else if(constantValue is java.lang.Byte)
					{
						constantValue = ((java.lang.Byte)constantValue).byteValue();
					}
					else if(constantValue is java.lang.Short)
					{
						constantValue = ((java.lang.Short)constantValue).shortValue();
					}
					else if(constantValue is java.lang.Character)
					{
						constantValue = ((java.lang.Character)constantValue).charValue();
					}
					else if(constantValue is java.lang.Integer)
					{
						constantValue = ((java.lang.Integer)constantValue).intValue();
					}
					else if(constantValue is java.lang.Long)
					{
						constantValue = ((java.lang.Long)constantValue).longValue();
					}
					else if(constantValue is java.lang.Float)
					{
						constantValue = ((java.lang.Float)constantValue).floatValue();
					}
					else if(constantValue is java.lang.Double)
					{
						constantValue = ((java.lang.Double)constantValue).doubleValue();
					}
					else if(constantValue is string)
					{
						// no conversion needed
					}
					else
					{
						throw new InvalidOperationException();
					}
				}
				// TODO what happens if the field type is non-public?
				java.lang.Class fieldType = fields[i].getType();
				if(IsGenericType(fieldType))
				{
					AddToExportList(fieldType);
				}
#if GENERICS
				if(fields[i].isEnumConstant())
				{
					mods |= Modifiers.Enum;
				}
				if(fields[i].isSynthetic())
				{
					mods |= Modifiers.Synthetic;
				}
#endif
				FieldOrMethod fld = f.AddField(mods, fields[i].getName(), ClassToSig(fieldType), constantValue);
				if(IKVM.Runtime.Util.IsFieldDeprecated(fields[i]))
				{
					fld.AddAttribute(new DeprecatedAttribute(f));
				}
#if GENERICS
				if(fields[i].getGenericType() != fieldType)
				{
					fld.AddAttribute(f.MakeStringAttribute("Signature", ToSigForm(fields[i].getGenericType())));
				}
#endif
			}
		}
		if(innerClassesAttribute != null)
		{
			f.AddAttribute(innerClassesAttribute);
		}
		WriteClass(name + ".class", f);
	}

	private static void AddExceptions(ClassFileWriter f, FieldOrMethod m, java.lang.Class[] exceptions)
	{
		if(exceptions.Length > 0)
		{
			ExceptionsAttribute attrib = new ExceptionsAttribute(f);
			foreach(java.lang.Class x in exceptions)
			{
				// TODO what happens if one of the exception types is non-public?
				attrib.Add(x.getName().Replace('.', '/'));
			}
			m.AddAttribute(attrib);
		}
	}

	private static string MakeSig(java.lang.Class[] args, java.lang.Class ret)
	{
		StringBuilder sb = new StringBuilder();
		sb.Append('(');
		for(int i = 0; i < args.Length; i++)
		{
			sb.Append(ClassToSig(args[i]));
		}
		sb.Append(')');
		sb.Append(ClassToSig(ret));
		return sb.ToString();
	}

	private static string ClassToSig(java.lang.Class c)
	{
		if(c.isPrimitive())
		{
			if(c == java.lang.Void.TYPE)
			{
				return "V";
			}
			else if(c == java.lang.Byte.TYPE)
			{
				return "B";
			}
			else if(c == java.lang.Boolean.TYPE)
			{
				return "Z";
			}
			else if(c == java.lang.Short.TYPE)
			{
				return "S";
			}
			else if(c == java.lang.Character.TYPE)
			{
				return "C";
			}
			else if(c == java.lang.Integer.TYPE)
			{
				return "I";
			}
			else if(c == java.lang.Long.TYPE)
			{
				return "J";
			}
			else if(c == java.lang.Float.TYPE)
			{
				return "F";
			}
			else if(c == java.lang.Double.TYPE)
			{
				return "D";
			}
			else
			{
				throw new InvalidOperationException();
			}
		}
		else if(c.isArray())
		{
			return "[" + ClassToSig(c.getComponentType());
		}
		else
		{
			return "L" + c.getName().Replace('.', '/') + ";";
		}
	}

#if GENERICS
	private static string BuildGenericSignature(java.lang.Class c)
	{
		bool isgeneric = false;
		StringBuilder sb = new StringBuilder();
		java.lang.reflect.TypeVariable[] vars = c.getTypeParameters();
		if(vars.Length > 0)
		{
			isgeneric = true;
			sb.Append('<');
			foreach(java.lang.reflect.TypeVariable t in vars)
			{
				sb.Append(t.getName());
				bool first = true;
				foreach(java.lang.reflect.Type bound in t.getBounds())
				{
					if(first)
					{
						first = false;
						if(bound is java.lang.Class)
						{
							// HACK I don't really understand what the proper criterion is to decide this
							if(((java.lang.Class)bound).isInterface())
							{
								sb.Append(':');
							}
						}
					}
					sb.Append(':').Append(ToSigForm(bound));
				}
			}
			sb.Append('>');
		}
		java.lang.reflect.Type superclass = c.getGenericSuperclass();
		if(superclass == null)
		{
			sb.Append("Ljava/lang/Object;");
		}
		else
		{
			isgeneric |= !(superclass is java.lang.Class);
			sb.Append(ToSigForm(superclass));
		}
        foreach(java.lang.reflect.Type t in c.getGenericInterfaces())
        {
			isgeneric |= !(t is java.lang.Class);
			sb.Append(ToSigForm(t));
        }
		if(isgeneric)
		{
			return sb.ToString();
		}
		return null;
	}

	private static string BuildGenericSignature(java.lang.reflect.TypeVariable[] typeParameters,
		java.lang.reflect.Type[] parameterTypes, java.lang.reflect.Type returnType,
		java.lang.reflect.Type[] exceptionTypes)
	{
		StringBuilder sb = new StringBuilder();
		if(typeParameters.Length > 0)
		{
			sb.Append('<');
			foreach(java.lang.reflect.TypeVariable t in typeParameters)
			{
				sb.Append(t.getName());
				foreach(java.lang.reflect.Type bound in t.getBounds())
				{
					sb.Append(':').Append(ToSigForm(bound));
				}
			}
			sb.Append('>');
		}
		sb.Append('(');
		foreach(java.lang.reflect.Type t in parameterTypes)
		{
			sb.Append(ToSigForm(t));
		}
		sb.Append(')');
		sb.Append(ToSigForm(returnType));
		foreach(java.lang.reflect.Type t in exceptionTypes)
		{
			sb.Append('^').Append(ToSigForm(t));
		}
		return sb.ToString();
	}

	private static string ToSigForm(java.lang.reflect.Type t)
	{
		if(t is java.lang.reflect.ParameterizedType)
		{
			java.lang.reflect.ParameterizedType p = (java.lang.reflect.ParameterizedType)t;
			if(p.getOwnerType() != null)
			{
				// TODO
				throw new NotImplementedException();
			}
			StringBuilder sb = new StringBuilder();
			sb.Append('L').Append(((java.lang.Class)p.getRawType()).getName().Replace('.', '/'));
			sb.Append('<');
			foreach(java.lang.reflect.Type arg in p.getActualTypeArguments())
			{
				sb.Append(ToSigForm(arg));
			}
			sb.Append(">;");
			return sb.ToString();
		}
		else if(t is java.lang.reflect.TypeVariable)
		{
			return "T" + ((java.lang.reflect.TypeVariable)t).getName() + ";";
		}
		else if(t is java.lang.reflect.WildcardType)
		{
			java.lang.reflect.WildcardType w = (java.lang.reflect.WildcardType)t;
			java.lang.reflect.Type[] lower = w.getLowerBounds();
			java.lang.reflect.Type[] upper = w.getUpperBounds();
			if (lower.Length == 0 && upper.Length == 0)
			{
				return "*";
			}
			if (lower.Length == 1)
			{
				return "-" + ToSigForm(lower[0]);
			}
			if (upper.Length == 1)
			{
				return "+" + ToSigForm(upper[0]);
			}
			throw new NotImplementedException();
		}
		else if(t is java.lang.reflect.GenericArrayType)
		{
			java.lang.reflect.GenericArrayType a = (java.lang.reflect.GenericArrayType)t;
			return "[" + ToSigForm(a.getGenericComponentType());
		}
		else if(t is java.lang.Class)
		{
			return ClassToSig((java.lang.Class)t);
		}
		else
		{
			throw new NotImplementedException(t.GetType().FullName);
		}
	}
#endif
}