I installed Debian 3.0r1 in VMware to work on getting IKVM.NET to build on Mono.

I put together a new snapshot, this time including a GNU Classpath snapshot, because of the compromise of the FSF CVS server my Classpath sources differ from what's available in CVS.

Here are the steps required to build IKVM.NET on Mono on Debian:

• Download and extract Mono 0.29 runtime and C# compiler
• Comment out the line
  [assembly: AssemblyKeyFile("..\\..\\bytefx.snk")]
  in mcs-0.29/class/ByteFX.Data/AssemblyInfo.cs.
• Make the HasShutdownStarted property in mcs-0.29/class/corlib/System/Environment.cs static and change it to return false instead of throw a NotImplementedException.
• cd mono-0.29
• ./configure && make && make install
• cd ../mcs-0.29
• make && make install
• Download and extract Jikes 1.18
• cd jikes-1.18
• ./configure && make && make install
• Download NAnt 0.84-rc1
• mkdir nant-0.84
• cd nant-0.84
• unzip ../nant-0.84.zip
• Comment out the class constructor (static CompilerBase() { ... }) in src/NAnt.DotNet/Tasks/CompilerBase.cs.
• make clean && make
• Create a nant shell script in /usr/local/bin that contains:
  #!/bin/sh
/usr/local/bin/mono /usr/local/src/nant-0.84/bin/NAnt.exe "$@"
• Create a dummy peverify shell script, that contains:
  #!/bin/sh
• Download and unzip classpath.zip (don't run any of the scripts)
• Download and unzip ikvm.zip
• cd ikvm
• nant clean
• nant

Note: I have not yet integrated Zoltan Varga's JNI provider for Mono and the (broken) Windows Forms based AWT is not built on Mono.

Here is what's new since the last snapshot:

• Changed build process to work on Mono/Linux.
• Added flag to bytecode metadata table to see if an instruction can throw an exception. The compiler can use this optimize away useless exception blocks.
• Changed constant pool constant handling to stop boxing the values and use type based accessors instead.
• Fixed handling of ConstantValue attribute (now works for static fields regardless of whether they are final are not).
• Exception remapping is now defined in map.xml. This allows more efficient exception handlers, because the compiler now understand the exception hierarchy (including the constraints imposed by the remapping).
• Changed handling of netexp exported classes to be more robust in the face of errors (on Mono some of the mscorlib.jar classes are not (yet) present in mscorlib.dll).
• Fixed emitting of DebuggableAttribute (the attribute was attached to the module, but it should be attached to the assembly).
• Moved most of ExceptionHelper.cs to ExceptionHelper.java and changed the runtime to generate the exception mapping method from map.xml.
• Fixed some ghost related bugs.
• Added a test to supress the type initializer bug warning (during netexp) on runtimes that are not broken.
• Moved common conversion emit operations to TypeWrapper (EmitConvStackToParameterType & EmitConvParameterToStackType).
• Added test in JavaTypeImpl.Finish to make sure that we are not in "phase 1" of static compilation. During phase 1, classes are being loaded and no compilation should occur, if it does get triggered it is because of a bug in the compiler or a compilation error during compilation of the bootstrap classes.
• Changed loading of java.lang.Throwable$VirtualMethods so that the ClassNotFound warning doesn't occur any more.
• Added (partial) support for private interface method implementations to reflection. This fixes a bug in netexp, that caused classes that use private interface implementation to be unusable from Java (because they appear abstract, because of the missing method).
• Removed WeakHashtable.cs. Exception mapping code is now written in Java and uses java.util.WeakHashMap.
• Removed StackTraceElement class from classpath.cs. Exception mapping code is now written in Java and uses the GNU Classpath StackTraceElement.java.
• Moved java.lang.Runtime native methods to Java (except for getVersion and nativeLoad). This is based on a new split of java.lang.Runtime and java.lang.VMRuntime that hasn't been checked into Classpath yet.
• Many changes to the bytecode compiler to emit more efficient (actually less inefficient) code for exception handlers.
• Added workaround to bytecode compiler to Improve debugging line number information.
• Various bug fixes and some clean up of bytecode compiler.
• Made ikvmc more user-friendly. It now guesses all options based on the input. You can now do "ikvmc HelloWorld.class" and it will generate HelloWorld.exe (if HelloWorld.class has a main method, if not it will generate HelloWorld.dll).
• Fixed DotNetProcess (that implement Runtime.exec) to handle environment variable duplicates properly.
• Removed support for throwing arbitrary exceptions using Thread.stop(Throwable). You can now only throw arbitrary exceptions on the current thread or ThreadDeath exceptions on other threads.
• Implemented shutdown hooks.
• Changed ikvm.exe to use a more compatible way of finding the main method and to always run the static initializer of the main class (even if the main method is missing).
• The ikvm -Xsave option is now implemented using a shutdown hook. This allows it to work even if the application terminates with System.exit().

New snapshots: just the binaries, source plus binaries and GNU Classpath.