From 3436961bb5c01d659d09be134368f4f69460cef9 Mon Sep 17 00:00:00 2001
From: MW
Date: Sat, 26 May 2007 13:40:19 +0000
Subject: Start of rewrite 5279!

---
 Prebuild/src/Core/Targets/AutotoolsTarget.cs     | 926 +++++++++++++++++++++++
 Prebuild/src/Core/Targets/DebugTarget.cs         | 102 +++
 Prebuild/src/Core/Targets/MonoDevelopTarget.cs   | 458 +++++++++++
 Prebuild/src/Core/Targets/NAntTarget.cs          | 621 +++++++++++++++
 Prebuild/src/Core/Targets/SharpDevelop2Target.cs |  90 +++
 Prebuild/src/Core/Targets/SharpDevelopTarget.cs  | 437 +++++++++++
 Prebuild/src/Core/Targets/VS2002Target.cs        |  96 +++
 Prebuild/src/Core/Targets/VS2003Target.cs        | 633 ++++++++++++++++
 Prebuild/src/Core/Targets/VS2005Target.cs        | 883 +++++++++++++++++++++
 9 files changed, 4246 insertions(+)
 create mode 100644 Prebuild/src/Core/Targets/AutotoolsTarget.cs
 create mode 100644 Prebuild/src/Core/Targets/DebugTarget.cs
 create mode 100644 Prebuild/src/Core/Targets/MonoDevelopTarget.cs
 create mode 100644 Prebuild/src/Core/Targets/NAntTarget.cs
 create mode 100644 Prebuild/src/Core/Targets/SharpDevelop2Target.cs
 create mode 100644 Prebuild/src/Core/Targets/SharpDevelopTarget.cs
 create mode 100644 Prebuild/src/Core/Targets/VS2002Target.cs
 create mode 100644 Prebuild/src/Core/Targets/VS2003Target.cs
 create mode 100644 Prebuild/src/Core/Targets/VS2005Target.cs

(limited to 'Prebuild/src/Core/Targets')

diff --git a/Prebuild/src/Core/Targets/AutotoolsTarget.cs b/Prebuild/src/Core/Targets/AutotoolsTarget.cs
new file mode 100644
index 0000000..2b4a678
--- /dev/null
+++ b/Prebuild/src/Core/Targets/AutotoolsTarget.cs
@@ -0,0 +1,926 @@
+#region BSD License
+/*
+
+Copyright (c) 2004 - 2006
+Matthew Holmes        (matthew@wildfiregames.com),
+Dan     Moorehead     (dan05a@gmail.com),
+Dave    Hudson        (jendave@yahoo.com),
+C.J.    Adams-Collier (cjcollier@colliertech.org),
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+* The name of the author may not be used to endorse or promote
+products derived from this software without specific prior written
+permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2006-07-28 22:43:24 -0700 (Fri, 28 Jul 2006) $
+ * $Revision: 136 $
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Parse;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("autotools")]
+	public class AutotoolsTarget : ITarget
+	{
+		#region Fields
+
+		private Kernel m_Kernel;
+
+		#endregion
+
+		#region Private Methods
+
+		private static string PrependPath(string path)
+		{
+			string tmpPath = Helper.NormalizePath(path, '/');
+			Regex regex = new Regex(@"(\w):/(\w+)");
+			Match match = regex.Match(tmpPath);
+			if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
+			{
+				tmpPath = Helper.NormalizePath(tmpPath);
+			}
+			else
+			{
+				tmpPath = Helper.NormalizePath("./" + tmpPath);
+			}
+
+			return tmpPath;
+		}
+
+		private static string BuildReference(SolutionNode solution, ReferenceNode refr)
+		{
+			string ret = "";
+			if(solution.ProjectsTable.ContainsKey(refr.Name))
+			{
+				ProjectNode project = (ProjectNode)solution.ProjectsTable[refr.Name];				
+				string fileRef = FindFileReference(refr.Name, project);
+				string finalPath = Helper.NormalizePath(Helper.MakeFilePath(project.FullPath + "/$(BUILD_DIR)/$(CONFIG)/", refr.Name, "dll"), '/');
+				ret += finalPath;
+				return ret;
+			}
+			else
+			{
+				ProjectNode project = (ProjectNode)refr.Parent;
+				string fileRef = FindFileReference(refr.Name, project);
+
+				if(refr.Path != null || fileRef != null)
+				{
+					string finalPath = (refr.Path != null) ? Helper.NormalizePath(refr.Path + "/" + refr.Name + ".dll", '/') : fileRef;
+					ret += Path.Combine(project.Path, finalPath);					
+					return ret;
+				}
+
+				try
+				{
+					//Assembly assem = Assembly.Load(refr.Name);
+                    //if (assem != null)
+                    //{
+                    //    int index = refr.Name.IndexOf(",");
+                    //    if ( index > 0)
+                    //    {
+                    //        ret += assem.Location;
+                    //        //Console.WriteLine("Location1: " + assem.Location);
+                    //    }
+                    //    else
+                    //    {
+                    //        ret += (refr.Name + ".dll");
+                    //        //Console.WriteLine("Location2: " + assem.Location);
+                    //    }
+                    //}
+                    //else
+                    //{
+						int index = refr.Name.IndexOf(",");
+						if ( index > 0)
+						{
+							ret += refr.Name.Substring(0, index) + ".dll";
+							//Console.WriteLine("Location3: " + assem.Location);
+						}
+						else
+						{
+							ret += (refr.Name + ".dll");
+							//Console.WriteLine("Location4: " + assem.Location);
+						}
+					//}
+				}
+				catch (System.NullReferenceException e)
+				{
+					e.ToString();
+					int index = refr.Name.IndexOf(",");
+					if ( index > 0)
+					{
+						ret += refr.Name.Substring(0, index) + ".dll";
+						//Console.WriteLine("Location5: " + assem.Location);
+					}
+					else
+					{
+						ret += (refr.Name + ".dll");
+						//Console.WriteLine("Location6: " + assem.Location);
+					}
+				}
+			}
+			return ret;
+		}
+
+		private static string BuildReferencePath(SolutionNode solution, ReferenceNode refr)
+		{
+			string ret = "";
+			if(solution.ProjectsTable.ContainsKey(refr.Name))
+			{
+				ProjectNode project = (ProjectNode)solution.ProjectsTable[refr.Name];	
+				string finalPath = Helper.NormalizePath(Helper.MakeReferencePath(project.FullPath + "/${build.dir}/"), '/');
+				ret += finalPath;
+				return ret;
+			}
+			else
+			{
+				ProjectNode project = (ProjectNode)refr.Parent;
+				string fileRef = FindFileReference(refr.Name, project);
+
+				
+				if(refr.Path != null || fileRef != null)
+				{
+					string finalPath = (refr.Path != null) ? Helper.NormalizePath(refr.Path, '/') : fileRef;
+					ret += finalPath;
+					return ret;
+				}
+
+				try
+				{
+					Assembly assem = Assembly.Load(refr.Name);
+					if (assem != null)
+					{
+						ret += "";
+					}
+					else
+					{
+						ret += "";
+					}
+				}
+				catch (System.NullReferenceException e)
+				{
+					e.ToString();
+					ret += "";
+				}
+			}
+			return ret;
+		}
+
+		private static string FindFileReference(string refName, ProjectNode project) 
+		{
+			foreach(ReferencePathNode refPath in project.ReferencePaths) 
+			{
+				string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
+
+				if(File.Exists(fullPath)) 
+				{
+					return fullPath;
+				}
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		/// Gets the XML doc file.
+		/// </summary>
+		/// <param name="project">The project.</param>
+		/// <param name="conf">The conf.</param>
+		/// <returns></returns>
+		public static string GetXmlDocFile(ProjectNode project, ConfigurationNode conf) 
+		{
+			if( conf == null )
+			{
+				throw new ArgumentNullException("conf");
+			}
+			if( project == null )
+			{
+				throw new ArgumentNullException("project");
+			}
+			string docFile = (string)conf.Options["XmlDocFile"];
+			//			if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
+			//			{
+			//				return Path.GetFileNameWithoutExtension(project.AssemblyName) + ".xml";
+			//			}
+			return docFile;
+		}
+
+		/// <summary>
+		/// Normalizes the path.
+		/// </summary>
+		/// <param name="path">The path.</param>
+		/// <returns></returns>
+		public static string NormalizePath(string path)
+		{
+			if(path == null)
+			{
+				return "";
+			}
+
+			StringBuilder tmpPath;
+
+			if (Core.Parse.Preprocessor.GetOS() == "Win32")
+			{
+				tmpPath = new StringBuilder(path.Replace('\\', '/'));
+				tmpPath.Replace("/", @"\\");
+			}
+			else
+			{
+				tmpPath = new StringBuilder(path.Replace('\\', '/'));
+				tmpPath = tmpPath.Replace('/', Path.DirectorySeparatorChar);
+			}
+			return tmpPath.ToString();
+		}
+
+		private void WriteProject(SolutionNode solution, ProjectNode project)
+		{
+			string projFile = Helper.MakeFilePath(project.FullPath, "Include", "am");
+			StreamWriter ss = new StreamWriter(projFile);
+			ss.NewLine = "\n";
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
+
+			using(ss)
+			{
+				ss.WriteLine(Helper.AssemblyFullName(project.AssemblyName, project.Type) + ":");
+				ss.WriteLine("\tmkdir -p " + Helper.MakePathRelativeTo(solution.FullPath, project.Path) + "/$(BUILD_DIR)/$(CONFIG)/");
+				foreach(string file in project.Files)
+				{
+					if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+					{
+						ss.Write("\tresgen ");
+						ss.Write(Helper.NormalizePath(Path.Combine(project.Path, file.Substring(0, file.LastIndexOf('.')) + ".resx "), '/'));
+						if (project.Files.GetResourceName(file) != "")
+						{
+							ss.WriteLine(Helper.NormalizePath(Path.Combine(project.Path, project.RootNamespace + "." + project.Files.GetResourceName(file) + ".resources"), '/'));
+						}
+						else
+						{
+							ss.WriteLine(Helper.NormalizePath(Path.Combine(project.Path, project.RootNamespace + "." + file.Substring(0, file.LastIndexOf('.')) + ".resources"), '/'));
+						}
+					}
+				}
+				ss.WriteLine("\t$(CSC)\t/out:" + Helper.MakePathRelativeTo(solution.FullPath, project.Path) + "/$(BUILD_DIR)/$(CONFIG)/" + Helper.AssemblyFullName(project.AssemblyName, project.Type) + " \\");
+				ss.WriteLine("\t\t/target:" + project.Type.ToString().ToLower() + " \\");
+				if (project.References.Count > 0)
+				{
+					ss.Write("\t\t/reference:");
+					bool firstref = true;
+					foreach(ReferenceNode refr in project.References)
+					{
+						if (firstref)
+						{
+							firstref = false;
+						}
+						else
+						{
+							ss.Write(",");
+						}
+						ss.Write("{0}", Helper.NormalizePath(Helper.MakePathRelativeTo(solution.FullPath, BuildReference(solution, refr)), '/'));
+					}
+					ss.WriteLine(" \\");
+				}
+				//ss.WriteLine("\t\tProperties/AssemblyInfo.cs \\");
+
+				foreach(string file in project.Files)
+				{
+					switch(project.Files.GetBuildAction(file))
+					{
+						case BuildAction.EmbeddedResource:
+							ss.Write("\t\t/resource:");
+							ss.WriteLine(Helper.NormalizePath(Path.Combine(project.Path, file), '/') + " \\");
+							break;
+						default:
+							if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+							{
+								ss.Write("\t\t/resource:");
+								if (project.Files.GetResourceName(file) != "")
+								{
+									ss.WriteLine(Helper.NormalizePath(Path.Combine(project.Path, project.RootNamespace + "." + project.Files.GetResourceName(file) + ".resources"), '/') + "," + project.RootNamespace + "." + project.Files.GetResourceName(file) + ".resources" + " \\");
+								}
+								else
+								{
+									ss.WriteLine(Helper.NormalizePath(Path.Combine(project.Path, project.RootNamespace + "." + file.Substring(0, file.LastIndexOf('.')) + ".resources"), '/') + "," + project.RootNamespace + "." + file.Substring(0, file.LastIndexOf('.')) + ".resources" + " \\");
+								}
+							}
+							break;
+					}
+				}
+				
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (conf.Options.KeyFile !="")
+					{
+						ss.WriteLine("\t\t/keyfile:" + Helper.NormalizePath(Path.Combine(project.Path, conf.Options.KeyFile), '/') + " \\");	
+						break;
+					}
+				}
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (conf.Options.AllowUnsafe)
+					{
+						ss.WriteLine("\t\t/unsafe \\");
+						break;
+					}
+				}
+				if (project.AppIcon != "")
+				{
+					ss.WriteLine("\t\t/win32icon:" + Helper.NormalizePath(Path.Combine(project.Path, project.AppIcon), '/') + " \\");
+				}
+
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ss.WriteLine("\t\t/define:{0}", conf.Options.CompilerDefines.Replace(';', ',') + " \\");
+					break;
+				}
+				
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (GetXmlDocFile(project, conf) !="")
+					{
+						ss.WriteLine("\t\t/doc:" + Helper.MakePathRelativeTo(solution.FullPath, project.Path) + "/$(BUILD_DIR)/$(CONFIG)/" + project.Name + ".xml \\");
+						break;
+					}
+				}
+				foreach(string file in project.Files)
+				{
+					switch(project.Files.GetBuildAction(file))
+					{
+						case BuildAction.Compile:
+							ss.WriteLine("\t\t\\");
+							ss.Write("\t\t" + NormalizePath(Path.Combine(Helper.MakePathRelativeTo(solution.FullPath, project.Path), file)));
+							break;
+						default:
+							break;
+					}
+				}
+				ss.WriteLine();
+				ss.WriteLine();
+
+				if (project.Type == ProjectType.Library)
+				{
+					ss.WriteLine("install-data-local:");
+					ss.WriteLine("	echo \"$(GACUTIL) /i bin/Release/" + project.Name + ".dll /f $(GACUTIL_FLAGS)\";  \\");
+					ss.WriteLine("	$(GACUTIL) /i bin/Release/" + project.Name + ".dll /f $(GACUTIL_FLAGS) || exit 1;");
+					ss.WriteLine();
+					ss.WriteLine("uninstall-local:");
+					ss.WriteLine("	echo \"$(GACUTIL) /u " + project.Name + " $(GACUTIL_FLAGS)\"; \\");
+					ss.WriteLine("	$(GACUTIL) /u " + project.Name + " $(GACUTIL_FLAGS) || exit 1;");
+					ss.WriteLine();
+				}
+				ss.WriteLine("CLEANFILES = $(BUILD_DIR)/$(CONFIG)/" + Helper.AssemblyFullName(project.AssemblyName, project.Type) + " $(BUILD_DIR)/$(CONFIG)/" + project.AssemblyName + ".mdb $(BUILD_DIR)/$(CONFIG)/" + project.AssemblyName + ".pdb " + project.AssemblyName + ".xml");
+				ss.WriteLine("EXTRA_DIST = \\");
+				ss.Write("	$(FILES)");
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (conf.Options.KeyFile != "")
+					{
+						ss.Write(" \\");
+						ss.WriteLine("\t" + conf.Options.KeyFile);
+					}
+					break;
+				}
+			}                
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+		bool hasLibrary = false;
+
+		private void WriteCombine(SolutionNode solution)
+		{
+		
+			/* TODO: These vars should be pulled from the prebuild.xml file */
+			string releaseVersion  = "2.0.0";
+			string assemblyVersion = "2.1.0.0";
+			string description     = 
+			  "Tao Framework " + solution.Name + " Binding For .NET";
+		
+			hasLibrary = false;
+			m_Kernel.Log.Write("Creating Autotools make files");
+			foreach(ProjectNode project in solution.Projects)
+			{
+				if(m_Kernel.AllowProject(project.FilterGroups)) 
+				{
+					m_Kernel.Log.Write("...Creating makefile: {0}", project.Name);
+					WriteProject(solution, project);
+				}
+			}
+
+			m_Kernel.Log.Write("");
+			string combFile = Helper.MakeFilePath(solution.FullPath, "Makefile", "am");
+			StreamWriter ss = new StreamWriter(combFile);
+			ss.NewLine = "\n";
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
+            
+			using(ss)
+			{
+				foreach(ProjectNode project in solution.ProjectsTableOrder)
+				{
+					if (project.Type == ProjectType.Library)
+					{
+						hasLibrary = true;
+						break;
+					}
+				}
+
+				if (hasLibrary)
+				{
+					ss.Write("pkgconfig_in_files = ");
+					foreach(ProjectNode project in solution.ProjectsTableOrder)
+					{
+						if (project.Type == ProjectType.Library)
+						{
+							string combFilepc = Helper.MakeFilePath(solution.FullPath, project.Name, "pc.in");
+							ss.Write(" " + project.Name + ".pc.in ");
+							StreamWriter sspc = new StreamWriter(combFilepc);
+							sspc.NewLine = "\n";
+							using(sspc)
+							{
+								sspc.WriteLine("prefix=@prefix@");
+								sspc.WriteLine("exec_prefix=${prefix}");
+								sspc.WriteLine("libdir=${exec_prefix}/lib");
+								sspc.WriteLine();
+								sspc.WriteLine("Name: @PACKAGE_NAME@");
+								sspc.WriteLine("Description: @DESCRIPTION@");
+								sspc.WriteLine("Version: @ASSEMBLY_VERSION@");
+								sspc.WriteLine("Libs:  -r:${libdir}/mono/gac/@PACKAGE_NAME@/@ASSEMBLY_VERSION@__@PUBKEY@/@PACKAGE_NAME@.dll");
+							}
+						}
+					}
+				
+					ss.WriteLine();
+					ss.WriteLine("pkgconfigdir=$(prefix)/lib/pkgconfig");
+					ss.WriteLine("pkgconfig_DATA=$(pkgconfig_in_files:.pc.in=.pc)");
+				}
+				ss.WriteLine();
+				foreach(ProjectNode project in solution.ProjectsTableOrder)
+				{
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.WriteLine("-include x {0}",
+						Helper.NormalizePath(Helper.MakeFilePath(path, "Include", "am"),'/'));
+				}
+				ss.WriteLine();
+				ss.WriteLine("all: \\");
+				ss.Write("\t");
+				foreach(ProjectNode project in solution.ProjectsTableOrder)
+				{
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.Write(Helper.AssemblyFullName(project.AssemblyName, project.Type) + " ");
+						
+				}
+				ss.WriteLine();
+				if (hasLibrary)
+				{
+					ss.WriteLine("EXTRA_DIST = \\");
+					ss.WriteLine("\t$(pkgconfig_in_files)");
+				}
+				else
+				{
+					ss.WriteLine("EXTRA_DIST = ");
+				}
+				ss.WriteLine();
+				ss.WriteLine("DISTCLEANFILES = \\");
+				ss.WriteLine("\tconfigure \\");
+				ss.WriteLine("\tMakefile.in  \\");
+				ss.WriteLine("\taclocal.m4");
+			}
+			combFile = Helper.MakeFilePath(solution.FullPath, "configure", "ac");
+			StreamWriter ts = new StreamWriter(combFile);
+			ts.NewLine = "\n";
+			using(ts)
+			{
+				if (this.hasLibrary)
+				{
+					foreach(ProjectNode project in solution.ProjectsTableOrder)
+					{
+						if (project.Type == ProjectType.Library)
+						{
+							ts.WriteLine("AC_INIT(" + project.Name + ".pc.in)");
+							break;
+						}
+					}
+				}
+				else
+				{
+					ts.WriteLine("AC_INIT(Makefile.am)");
+				}
+				ts.WriteLine("AC_PREREQ(2.53)");
+				ts.WriteLine("AC_CANONICAL_SYSTEM");
+				
+				ts.WriteLine("PACKAGE_NAME={0}", solution.Name);
+				ts.WriteLine("PACKAGE_VERSION={0}", releaseVersion);
+				ts.WriteLine("DESCRIPTION=\"{0}\"", description);
+				ts.WriteLine("AC_SUBST(DESCRIPTION)");
+				ts.WriteLine("AM_INIT_AUTOMAKE([$PACKAGE_NAME],[$PACKAGE_VERSION],[$DESCRIPTION])");
+				
+				ts.WriteLine("ASSEMBLY_VERSION={0}", assemblyVersion);
+				ts.WriteLine("AC_SUBST(ASSEMBLY_VERSION)");
+				
+				ts.WriteLine("PUBKEY=`sn -t $PACKAGE_NAME.snk | grep 'Public Key Token' | awk -F: '{print $2}' | sed -e 's/^ //'`");
+				ts.WriteLine("AC_SUBST(PUBKEY)");
+				
+				ts.WriteLine();
+				ts.WriteLine("AM_MAINTAINER_MODE");
+				ts.WriteLine();
+				ts.WriteLine("dnl AC_PROG_INTLTOOL([0.25])");
+				ts.WriteLine();
+				ts.WriteLine("AC_PROG_INSTALL");
+				ts.WriteLine();
+				ts.WriteLine("MONO_REQUIRED_VERSION=1.1");
+				ts.WriteLine();
+				ts.WriteLine("AC_MSG_CHECKING([whether we're compiling from CVS])");
+				ts.WriteLine("if test -f \"$srcdir/.cvs_version\" ; then");
+				ts.WriteLine("        from_cvs=yes");
+				ts.WriteLine("else");
+				ts.WriteLine("  if test -f \"$srcdir/.svn\" ; then");
+				ts.WriteLine("        from_cvs=yes");
+				ts.WriteLine("  else");
+				ts.WriteLine("        from_cvs=no");
+				ts.WriteLine("  fi");
+				ts.WriteLine("fi");
+				ts.WriteLine();
+				ts.WriteLine("AC_MSG_RESULT($from_cvs)");
+				ts.WriteLine();
+				ts.WriteLine("AC_PATH_PROG(MONO, mono)");
+				ts.WriteLine("AC_PATH_PROG(GMCS, gmcs)");
+				ts.WriteLine("AC_PATH_PROG(GACUTIL, gacutil)");
+				ts.WriteLine();
+				ts.WriteLine("AC_MSG_CHECKING([for mono])");
+				ts.WriteLine("dnl if test \"x$MONO\" = \"x\" ; then");
+				ts.WriteLine("dnl  AC_MSG_ERROR([Can't find \"mono\" in your PATH])");
+				ts.WriteLine("dnl else");
+				ts.WriteLine("  AC_MSG_RESULT([found])");
+				ts.WriteLine("dnl fi");
+				ts.WriteLine();
+				ts.WriteLine("AC_MSG_CHECKING([for gmcs])");
+				ts.WriteLine("dnl if test \"x$GMCS\" = \"x\" ; then");
+				ts.WriteLine("dnl  AC_MSG_ERROR([Can't find \"gmcs\" in your PATH])");
+				ts.WriteLine("dnl else");
+				ts.WriteLine("  AC_MSG_RESULT([found])");
+				ts.WriteLine("dnl fi");
+				ts.WriteLine();
+                //ts.WriteLine("AC_MSG_CHECKING([for gacutil])");
+                //ts.WriteLine("if test \"x$GACUTIL\" = \"x\" ; then");
+                //ts.WriteLine("  AC_MSG_ERROR([Can't find \"gacutil\" in your PATH])");
+                //ts.WriteLine("else");
+                //ts.WriteLine("  AC_MSG_RESULT([found])");
+                //ts.WriteLine("fi");
+				ts.WriteLine();
+				ts.WriteLine("AC_SUBST(PATH)");
+				ts.WriteLine("AC_SUBST(LD_LIBRARY_PATH)");
+				ts.WriteLine();
+				ts.WriteLine("dnl CSFLAGS=\"-debug -nowarn:1574\"");
+				ts.WriteLine("CSFLAGS=\"\"");
+				ts.WriteLine("AC_SUBST(CSFLAGS)");
+				ts.WriteLine();
+				//				ts.WriteLine("AC_MSG_CHECKING(--disable-sdl argument)");
+				//				ts.WriteLine("AC_ARG_ENABLE(sdl,");
+				//				ts.WriteLine("    [  --disable-sdl         Disable Sdl interface.],");
+				//				ts.WriteLine("    [disable_sdl=$disableval],");
+				//				ts.WriteLine("    [disable_sdl=\"no\"])");
+				//				ts.WriteLine("AC_MSG_RESULT($disable_sdl)");
+				//				ts.WriteLine("if test \"$disable_sdl\" = \"yes\"; then");
+				//				ts.WriteLine("  AC_DEFINE(FEAT_SDL)");
+				//				ts.WriteLine("fi");
+				ts.WriteLine();
+				ts.WriteLine("dnl Find pkg-config");
+				ts.WriteLine("AC_PATH_PROG(PKGCONFIG, pkg-config, no)");
+				ts.WriteLine("if test \"x$PKG_CONFIG\" = \"xno\"; then");
+				ts.WriteLine("        AC_MSG_ERROR([You need to install pkg-config])");
+				ts.WriteLine("fi");
+				ts.WriteLine();
+				ts.WriteLine("PKG_CHECK_MODULES(MONO_DEPENDENCY, mono >= $MONO_REQUIRED_VERSION, has_mono=true, has_mono=false)");
+				ts.WriteLine("BUILD_DIR=\"bin\"");
+				ts.WriteLine("AC_SUBST(BUILD_DIR)");
+				ts.WriteLine("CONFIG=\"Release\"");
+				ts.WriteLine("AC_SUBST(CONFIG)");
+				ts.WriteLine();
+				ts.WriteLine("if test \"x$has_mono\" = \"xtrue\"; then");
+				ts.WriteLine("  AC_PATH_PROG(RUNTIME, mono, no)");
+				ts.WriteLine("  AC_PATH_PROG(CSC, gmcs, no)");
+				ts.WriteLine("  if test `uname -s` = \"Darwin\"; then");
+				ts.WriteLine("        LIB_PREFIX=");
+				ts.WriteLine("        LIB_SUFFIX=.dylib");
+				ts.WriteLine("  else");
+				ts.WriteLine("        LIB_PREFIX=.so");
+				ts.WriteLine("        LIB_SUFFIX=");
+				ts.WriteLine("  fi");
+				ts.WriteLine("else");
+				ts.WriteLine("  AC_PATH_PROG(CSC, csc.exe, no)");
+				ts.WriteLine("  if test x$CSC = \"xno\"; then");
+				ts.WriteLine("        AC_MSG_ERROR([You need to install either mono or .Net])");
+				ts.WriteLine("  else");
+				ts.WriteLine("    RUNTIME=");
+				ts.WriteLine("    LIB_PREFIX=");
+				ts.WriteLine("    LIB_SUFFIX=.dylib");
+				ts.WriteLine("  fi");
+				ts.WriteLine("fi");
+				ts.WriteLine();
+				ts.WriteLine("AC_SUBST(LIB_PREFIX)");
+				ts.WriteLine("AC_SUBST(LIB_SUFFIX)");
+				ts.WriteLine();
+				ts.WriteLine("AC_SUBST(BASE_DEPENDENCIES_CFLAGS)");
+				ts.WriteLine("AC_SUBST(BASE_DEPENDENCIES_LIBS)");
+				ts.WriteLine();
+				ts.WriteLine("dnl Find monodoc");
+				ts.WriteLine("MONODOC_REQUIRED_VERSION=1.0");
+				ts.WriteLine("AC_SUBST(MONODOC_REQUIRED_VERSION)");
+				ts.WriteLine("PKG_CHECK_MODULES(MONODOC_DEPENDENCY, monodoc >= $MONODOC_REQUIRED_VERSION, enable_monodoc=yes, enable_monodoc=no)");
+				ts.WriteLine();
+				ts.WriteLine("if test \"x$enable_monodoc\" = \"xyes\"; then");
+				ts.WriteLine("        AC_PATH_PROG(MONODOC, monodoc, no)");
+				ts.WriteLine("        if test x$MONODOC = xno; then");
+				ts.WriteLine("           enable_monodoc=no");
+				ts.WriteLine("        fi");
+				ts.WriteLine("else");
+				ts.WriteLine("        MONODOC=");
+				ts.WriteLine("fi");
+				ts.WriteLine();
+				ts.WriteLine("AC_SUBST(MONODOC)");
+				ts.WriteLine("AM_CONDITIONAL(ENABLE_MONODOC, test \"x$enable_monodoc\" = \"xyes\")");
+				ts.WriteLine();
+				ts.WriteLine("AC_PATH_PROG(GACUTIL, gacutil, no)");
+				ts.WriteLine("if test \"x$GACUTIL\" = \"xno\" ; then");
+				ts.WriteLine("        AC_MSG_ERROR([No gacutil tool found])");
+				ts.WriteLine("fi");
+				ts.WriteLine();
+				//				foreach(ProjectNode project in solution.ProjectsTableOrder)
+				//				{
+				//					if (project.Type == ProjectType.Library)
+				//					{
+				//					}
+				//				}
+				ts.WriteLine("GACUTIL_FLAGS='/package $(PACKAGE_NAME) /gacdir $(DESTDIR)$(prefix)'");
+				ts.WriteLine("AC_SUBST(GACUTIL_FLAGS)");
+				ts.WriteLine();
+				ts.WriteLine("winbuild=no");
+				ts.WriteLine("case \"$host\" in");
+				ts.WriteLine("       *-*-mingw*|*-*-cygwin*)");
+				ts.WriteLine("               winbuild=yes");
+				ts.WriteLine("               ;;");
+				ts.WriteLine("esac");
+				ts.WriteLine("AM_CONDITIONAL(WINBUILD, test x$winbuild = xyes)");
+				ts.WriteLine();
+				//				ts.WriteLine("dnl Check for SDL");
+				//				ts.WriteLine();
+				//				ts.WriteLine("AC_PATH_PROG([SDL_CONFIG], [sdl-config])");
+				//				ts.WriteLine("have_sdl=no");
+				//				ts.WriteLine("if test -n \"${SDL_CONFIG}\"; then");
+				//				ts.WriteLine("    have_sdl=yes");
+				//				ts.WriteLine("    SDL_CFLAGS=`$SDL_CONFIG --cflags`");
+				//				ts.WriteLine("    SDL_LIBS=`$SDL_CONFIG --libs`");
+				//				ts.WriteLine("    #");
+				//				ts.WriteLine("    # sdl-config sometimes emits an rpath flag pointing at its library");
+				//				ts.WriteLine("    # installation directory.  We don't want this, as it prevents users from");
+				//				ts.WriteLine("    # linking sdl-viewer against, for example, a locally compiled libGL when a");
+				//				ts.WriteLine("    # version of the library also exists in SDL's library installation");
+				//				ts.WriteLine("    # directory, typically /usr/lib.");
+				//				ts.WriteLine("    #");
+				//				ts.WriteLine("    SDL_LIBS=`echo $SDL_LIBS | sed 's/-Wl,-rpath,[[^ ]]* //'`");
+				//				ts.WriteLine("fi");
+				//				ts.WriteLine("AC_SUBST([SDL_CFLAGS])");
+				//				ts.WriteLine("AC_SUBST([SDL_LIBS])");
+				ts.WriteLine();
+				ts.WriteLine("AC_OUTPUT([");
+				ts.WriteLine("Makefile");
+                // TODO: this does not work quite right.
+				//ts.WriteLine("Properties/AssemblyInfo.cs");
+				foreach(ProjectNode project in solution.ProjectsTableOrder)
+				{
+					if (project.Type == ProjectType.Library)
+					{
+						ts.WriteLine(project.Name + ".pc");
+					}
+					//					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					//					ts.WriteLine(Helper.NormalizePath(Helper.MakeFilePath(path, "Include"),'/'));
+				}
+				ts.WriteLine("])");
+				ts.WriteLine();
+				ts.WriteLine("#po/Makefile.in");
+				ts.WriteLine();
+				ts.WriteLine("echo \"---\"");
+				ts.WriteLine("echo \"Configuration summary\"");
+				ts.WriteLine("echo \"\"");
+				ts.WriteLine("echo \"   * Installation prefix: $prefix\"");
+				ts.WriteLine("echo \"   * compiler:            $CSC\"");
+				ts.WriteLine("echo \"   * Documentation:       $enable_monodoc ($MONODOC)\"");
+				ts.WriteLine("echo \"   * Package Name:        $PACKAGE_NAME\"");
+				ts.WriteLine("echo \"   * Version:             $PACKAGE_VERSION\"");
+				ts.WriteLine("echo \"   * Public Key:          $PUBKEY\"");
+				ts.WriteLine("echo \"\"");
+				ts.WriteLine("echo \"---\"");
+				ts.WriteLine();
+			}
+
+            ts.NewLine = "\n";
+            foreach (ProjectNode project in solution.ProjectsTableOrder)
+            {
+                if (project.GenerateAssemblyInfoFile)
+                {
+                    GenerateAssemblyInfoFile(solution, combFile);
+                }
+            }
+		}
+
+        private static void GenerateAssemblyInfoFile(SolutionNode solution, string combFile)
+        {
+            System.IO.Directory.CreateDirectory(Helper.MakePathRelativeTo(solution.FullPath, "Properties"));
+            combFile = Helper.MakeFilePath(solution.FullPath + "/Properties/", "AssemblyInfo.cs", "in");
+            StreamWriter ai = new StreamWriter(combFile);
+            
+            using (ai)
+            {
+                ai.WriteLine("#region License");
+                ai.WriteLine("/*");
+                ai.WriteLine("MIT License");
+                ai.WriteLine("Copyright (c)2003-2006 Tao Framework Team");
+                ai.WriteLine("http://www.taoframework.com");
+                ai.WriteLine("All rights reserved.");
+                ai.WriteLine("");
+                ai.WriteLine("Permission is hereby granted, free of charge, to any person obtaining a copy");
+                ai.WriteLine("of this software and associated documentation files (the \"Software\"), to deal");
+                ai.WriteLine("in the Software without restriction, including without limitation the rights");
+                ai.WriteLine("to use, copy, modify, merge, publish, distribute, sublicense, and/or sell");
+                ai.WriteLine("copies of the Software, and to permit persons to whom the Software is");
+                ai.WriteLine("furnished to do so, subject to the following conditions:");
+                ai.WriteLine("");
+                ai.WriteLine("The above copyright notice and this permission notice shall be included in all");
+                ai.WriteLine("copies or substantial portions of the Software.");
+                ai.WriteLine("");
+                ai.WriteLine("THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR");
+                ai.WriteLine("IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,");
+                ai.WriteLine("FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE");
+                ai.WriteLine("AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER");
+                ai.WriteLine("LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,");
+                ai.WriteLine("OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE");
+                ai.WriteLine("SOFTWARE.");
+                ai.WriteLine("*/");
+                ai.WriteLine("#endregion License");
+                ai.WriteLine("");
+                ai.WriteLine("using System;");
+                ai.WriteLine("using System.Reflection;");
+                ai.WriteLine("using System.Runtime.InteropServices;");
+                ai.WriteLine("using System.Security;");
+                ai.WriteLine("using System.Security.Permissions;");
+                ai.WriteLine("");
+                ai.WriteLine("[assembly: AllowPartiallyTrustedCallers]");
+                ai.WriteLine("[assembly: AssemblyCompany(\"Tao Framework -- http://www.taoframework.com\")]");
+                ai.WriteLine("[assembly: AssemblyConfiguration(\"Retail\")]");
+                ai.WriteLine("[assembly: AssemblyCopyright(\"Copyright (c)2003-2006 Tao Framework Team.  All rights reserved.\")]");
+                ai.WriteLine("[assembly: AssemblyCulture(\"\")]");
+                ai.WriteLine("[assembly: AssemblyDefaultAlias(\"@PACKAGE_NAME@\")]");
+                ai.WriteLine("[assembly: AssemblyDelaySign(false)]");
+                ai.WriteLine("[assembly: AssemblyDescription(\"@DESCRIPTION@\")]");
+                ai.WriteLine("[assembly: AssemblyFileVersion(\"@ASSEMBLY_VERSION@\")]");
+                ai.WriteLine("[assembly: AssemblyInformationalVersion(\"@ASSEMBLY_VERSION@\")]");
+                ai.WriteLine("[assembly: AssemblyKeyName(\"\")]");
+                ai.WriteLine("[assembly: AssemblyProduct(\"@PACKAGE_NAME@.dll\")]");
+                ai.WriteLine("[assembly: AssemblyTitle(\"@DESCRIPTION@\")]");
+                ai.WriteLine("[assembly: AssemblyTrademark(\"Tao Framework -- http://www.taoframework.com\")]");
+                ai.WriteLine("[assembly: AssemblyVersion(\"@ASSEMBLY_VERSION@\")]");
+                ai.WriteLine("[assembly: CLSCompliant(true)]");
+                ai.WriteLine("[assembly: ComVisible(false)]");
+                ai.WriteLine("[assembly: SecurityPermission(SecurityAction.RequestMinimum, Flags = SecurityPermissionFlag.Execution)]");
+                ai.WriteLine("[assembly: SecurityPermission(SecurityAction.RequestMinimum, Flags = SecurityPermissionFlag.SkipVerification)]");
+                ai.WriteLine("[assembly: SecurityPermission(SecurityAction.RequestMinimum, Flags = SecurityPermissionFlag.UnmanagedCode)]");
+
+            }
+            //return combFile;
+        }
+
+		private void CleanProject(ProjectNode project)
+		{
+			m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
+			string projectFile = Helper.MakeFilePath(project.FullPath, "Include", "am");
+			Helper.DeleteIfExists(projectFile);
+		}
+
+		private void CleanSolution(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Cleaning Autotools make files for", solution.Name);
+
+			string slnFile = Helper.MakeFilePath(solution.FullPath, "Makefile", "am");
+			Helper.DeleteIfExists(slnFile);
+
+			slnFile = Helper.MakeFilePath(solution.FullPath, "Makefile", "in");
+			Helper.DeleteIfExists(slnFile);
+
+			slnFile = Helper.MakeFilePath(solution.FullPath, "configure", "ac");
+			Helper.DeleteIfExists(slnFile);
+
+			slnFile = Helper.MakeFilePath(solution.FullPath, "configure");
+			Helper.DeleteIfExists(slnFile);
+
+			slnFile = Helper.MakeFilePath(solution.FullPath, "Makefile");
+			Helper.DeleteIfExists(slnFile);
+
+			foreach(ProjectNode project in solution.Projects)
+			{
+				CleanProject(project);
+			}
+            
+			m_Kernel.Log.Write("");
+		}
+
+		#endregion
+
+		#region ITarget Members
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public void Write(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode solution in kern.Solutions)
+			{
+				WriteCombine(solution);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public virtual void Clean(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode sol in kern.Solutions)
+			{
+				CleanSolution(sol);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public string Name
+		{
+			get
+			{
+				return "autotools";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/DebugTarget.cs b/Prebuild/src/Core/Targets/DebugTarget.cs
new file mode 100644
index 0000000..6baa623
--- /dev/null
+++ b/Prebuild/src/Core/Targets/DebugTarget.cs
@@ -0,0 +1,102 @@
+#region	BSD	License
+/*
+Copyright (c) 2004-2005	Matthew	Holmes (matthew@wildfiregames.com),	Dan	Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary	forms, with	or without modification, are permitted
+provided that the following	conditions are met:
+
+* Redistributions of source	code must retain the above copyright notice, this list of conditions 
+  and the following	disclaimer.	
+* Redistributions in binary	form must reproduce	the	above copyright	notice,	this list of conditions	
+  and the following	disclaimer in the documentation	and/or other materials provided	with the 
+  distribution.	
+* The name of the author may not be	used to	endorse	or promote products	derived	from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR	``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,	
+BUT	NOT	LIMITED	TO,	THE	IMPLIED	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A	PARTICULAR PURPOSE 
+ARE	DISCLAIMED.	IN NO EVENT	SHALL THE AUTHOR BE	LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL	DAMAGES	(INCLUDING,	BUT	NOT	LIMITED	TO,	PROCUREMENT	OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA,	OR PROFITS;	OR BUSINESS	INTERRUPTION) HOWEVER CAUSED AND ON	ANY	THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR	TORT (INCLUDING	NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,	EVEN IF	ADVISED	OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region	CVS	Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2006-09-20 09:42:51 +0200 (on, 20 sep 2006) $
+ * $Revision: 164 $
+ */
+#endregion
+
+using System;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+
+#if	(DEBUG && _DEBUG_TARGET)
+namespace Prebuild.Core.Targets
+{
+	[Target("debug")]
+	public class DebugTarget : ITarget
+	{
+#region	Fields
+
+		private	Kernel m_Kernel	= null;
+
+#endregion
+
+#region	ITarget	Members
+
+		public void	Write()
+		{
+			foreach(SolutionNode s in m_Kernel.Solutions)
+			{
+				Console.WriteLine("Solution	[ {0}, {1} ]", s.Name, s.Path);
+				foreach(string file	in s.Files)
+{
+					Console.WriteLine("\tFile [	{0}	]",	file);
+}
+
+				foreach(ProjectNode	proj in	s.Projects)
+				{
+					Console.WriteLine("\tProject [ {0},	{1}. {2} ]", proj.Name,	proj.Path, proj.Language);
+					foreach(string file	in proj.Files)
+						Console.WriteLine("\t\tFile	[ {0} ]", file);
+				}
+			}
+		}
+
+		public void	Clean()
+		{
+			Console.WriteLine("Not implemented");
+		}
+
+		public string Name
+		{
+			get
+			{
+				return "debug";
+			}
+		}
+
+		public Kernel Kernel
+		{
+			get
+			{
+				return m_Kernel;
+			}
+			set
+			{
+				m_Kernel = value;
+			}
+		}
+
+#endregion
+	}
+}
+#endif
diff --git a/Prebuild/src/Core/Targets/MonoDevelopTarget.cs b/Prebuild/src/Core/Targets/MonoDevelopTarget.cs
new file mode 100644
index 0000000..8620e4b
--- /dev/null
+++ b/Prebuild/src/Core/Targets/MonoDevelopTarget.cs
@@ -0,0 +1,458 @@
+#region BSD License
+/*
+Copyright (c) 2004 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2007-02-13 22:07:07 +0100 (ti, 13 feb 2007) $
+ * $Revision: 206 $
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("monodev")]
+	public class MonoDevelopTarget : ITarget
+	{
+		#region Fields
+
+		private Kernel m_Kernel;
+
+		#endregion
+
+		#region Private Methods
+
+		private static string PrependPath(string path)
+		{
+			string tmpPath = Helper.NormalizePath(path, '/');
+			Regex regex = new Regex(@"(\w):/(\w+)");
+			Match match = regex.Match(tmpPath);
+			if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
+			{
+				tmpPath = Helper.NormalizePath(tmpPath);
+			}
+			else
+			{
+				tmpPath = Helper.NormalizePath("./" + tmpPath);
+			}
+
+			return tmpPath;
+		}
+
+		private static string BuildReference(SolutionNode solution, ReferenceNode refr)
+		{
+			string ret = "<ProjectReference type=\"";
+			if(solution.ProjectsTable.ContainsKey(refr.Name))
+			{
+				ret += "Project\"";
+				ret += " localcopy=\"" + refr.LocalCopy.ToString() +  "\" refto=\"" + refr.Name + "\" />";
+			}
+			else
+			{
+				ProjectNode project = (ProjectNode)refr.Parent;
+				string fileRef = FindFileReference(refr.Name, project);
+
+				if(refr.Path != null || fileRef != null)
+				{
+					ret += "Assembly\" refto=\"";
+
+					string finalPath = (refr.Path != null) ? Helper.MakeFilePath(refr.Path, refr.Name, "dll") : fileRef;
+
+					ret += finalPath;
+					ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
+					return ret;
+				}
+
+				ret += "Gac\"";
+				ret += " localcopy=\"" + refr.LocalCopy.ToString() + "\"";
+				ret += " refto=\"";
+				try
+				{
+					//Assembly assem = Assembly.Load(refr.Name);
+					//ret += assem.FullName;
+                    ret += refr.Name;
+				}
+				catch (System.NullReferenceException e)
+				{
+					e.ToString();
+					ret += refr.Name;
+				}
+				ret += "\" />";
+			}
+
+			return ret;
+		}
+
+		private static string FindFileReference(string refName, ProjectNode project) 
+		{
+			foreach(ReferencePathNode refPath in project.ReferencePaths) 
+			{
+				string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
+
+				if(File.Exists(fullPath)) 
+				{
+					return fullPath;
+				}
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		/// Gets the XML doc file.
+		/// </summary>
+		/// <param name="project">The project.</param>
+		/// <param name="conf">The conf.</param>
+		/// <returns></returns>
+		public static string GenerateXmlDocFile(ProjectNode project, ConfigurationNode conf) 
+		{
+			if( conf == null )
+			{
+				throw new ArgumentNullException("conf");
+			}
+			if( project == null )
+			{
+				throw new ArgumentNullException("project");
+			}
+			string docFile = (string)conf.Options["XmlDocFile"];
+			if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
+			{
+				return "False";
+			}
+			return "True";
+		}
+
+		private void WriteProject(SolutionNode solution, ProjectNode project)
+		{
+			string csComp = "Mcs";
+			string netRuntime = "Mono";
+			if(project.Runtime == ClrRuntime.Microsoft)
+			{
+				csComp = "Csc";
+				netRuntime = "MsNet";
+			}
+
+			string projFile = Helper.MakeFilePath(project.FullPath, project.Name, "mdp");
+			StreamWriter ss = new StreamWriter(projFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
+
+			using(ss)
+			{
+				ss.WriteLine(
+					"<Project name=\"{0}\" description=\"\" standardNamespace=\"{1}\" newfilesearch=\"None\" enableviewstate=\"True\" fileversion=\"2.0\" language=\"C#\" clr-version=\"Net_2_0\" ctype=\"DotNetProject\">",
+					project.Name,
+					project.RootNamespace
+					);
+				
+								int count = 0;
+				
+				ss.WriteLine("  <Configurations active=\"{0}\">", solution.ActiveConfig);
+
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ss.WriteLine("    <Configuration name=\"{0}\" ctype=\"DotNetProjectConfiguration\">", conf.Name);
+					ss.Write("      <Output");
+					ss.Write(" directory=\"{0}\"", Helper.EndPath(Helper.NormalizePath(".\\" + conf.Options["OutputPath"].ToString())));
+					ss.Write(" assembly=\"{0}\"", project.AssemblyName);
+					ss.Write(" executeScript=\"{0}\"", conf.Options["RunScript"]);
+					//ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]);
+					//ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]);
+					if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0)
+					{
+						ss.Write(" executeBeforeBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString()));
+					}
+					else
+					{
+						ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]);
+					}
+					if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0)
+					{
+						ss.Write(" executeAfterBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString()));
+					}
+					else
+					{
+						ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]);
+					}
+					ss.Write(" executeBeforeBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
+					ss.Write(" executeAfterBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
+					ss.WriteLine(" />");
+					
+					ss.Write("      <Build");
+					ss.Write(" debugmode=\"True\"");
+					if (project.Type == ProjectType.WinExe)
+					{
+						ss.Write(" target=\"{0}\"", ProjectType.Exe.ToString());
+					}
+					else
+					{
+						ss.Write(" target=\"{0}\"", project.Type);
+					}
+					ss.WriteLine(" />");
+					
+					ss.Write("      <Execution");
+					ss.Write(" runwithwarnings=\"True\"");
+					ss.Write(" consolepause=\"True\"");
+					ss.Write(" runtime=\"{0}\"", netRuntime);
+                    ss.Write(" clr-version=\"Net_2_0\"");
+					ss.WriteLine(" />");
+					
+					ss.Write("      <CodeGeneration");
+					ss.Write(" compiler=\"{0}\"", csComp);
+					ss.Write(" warninglevel=\"{0}\"", conf.Options["WarningLevel"]);
+					ss.Write(" nowarn=\"{0}\"", conf.Options["SuppressWarnings"]);
+					ss.Write(" includedebuginformation=\"{0}\"", conf.Options["DebugInformation"]);
+					ss.Write(" optimize=\"{0}\"", conf.Options["OptimizeCode"]);
+					ss.Write(" unsafecodeallowed=\"{0}\"", conf.Options["AllowUnsafe"]);
+					ss.Write(" generateoverflowchecks=\"{0}\"", conf.Options["CheckUnderflowOverflow"]);
+					ss.Write(" mainclass=\"{0}\"", project.StartupObject);
+					ss.Write(" target=\"{0}\"", project.Type);
+					ss.Write(" definesymbols=\"{0}\"", conf.Options["CompilerDefines"]);
+					ss.Write(" generatexmldocumentation=\"{0}\"", GenerateXmlDocFile(project, conf));
+					ss.Write(" win32Icon=\"{0}\"", project.AppIcon);
+					ss.Write(" ctype=\"CSharpCompilerParameters\"");
+					ss.WriteLine(" />");
+					ss.WriteLine("    </Configuration>");
+
+					count++;
+				}                
+				ss.WriteLine("  </Configurations>");
+
+				ss.Write("  <DeploymentInformation");
+				ss.Write(" target=\"\"");
+				ss.Write(" script=\"\"");
+				ss.Write(" strategy=\"File\"");
+				ss.WriteLine(">");
+				ss.WriteLine("    <excludeFiles />");
+				ss.WriteLine("  </DeploymentInformation>");
+				
+				ss.WriteLine("  <Contents>");
+				foreach(string file in project.Files)
+				{
+					string buildAction = "Compile";
+					switch(project.Files.GetBuildAction(file))
+					{
+						case BuildAction.None:
+							buildAction = "Nothing";
+							break;
+
+						case BuildAction.Content:
+							buildAction = "Exclude";
+							break;
+
+						case BuildAction.EmbeddedResource:
+							buildAction = "EmbedAsResource";
+							break;
+
+						default:
+							buildAction = "Compile";
+							break;
+					}
+
+					// Sort of a hack, we try and resolve the path and make it relative, if we can.
+					string filePath = PrependPath(file);
+					ss.WriteLine("    <File name=\"{0}\" subtype=\"Code\" buildaction=\"{1}\" dependson=\"\" data=\"\" />", filePath, buildAction);
+				}
+				ss.WriteLine("  </Contents>");
+
+				ss.WriteLine("  <References>");
+				foreach(ReferenceNode refr in project.References)
+				{
+					ss.WriteLine("    {0}", BuildReference(solution, refr));
+				}
+				ss.WriteLine("  </References>");
+
+
+				ss.WriteLine("</Project>");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void WriteCombine(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Creating MonoDevelop combine and project files");
+			foreach(ProjectNode project in solution.Projects)
+			{
+				if(m_Kernel.AllowProject(project.FilterGroups)) 
+				{
+					m_Kernel.Log.Write("...Creating project: {0}", project.Name);
+					WriteProject(solution, project);
+				}
+			}
+
+			m_Kernel.Log.Write("");
+			string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "mds");
+			StreamWriter ss = new StreamWriter(combFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
+            
+            int count = 0;
+            
+			using(ss)
+			{
+				ss.WriteLine("<Combine name=\"{0}\" fileversion=\"2.0\" description=\"\">", solution.Name);
+
+				count = 0;
+				foreach(ConfigurationNode conf in solution.Configurations)
+				{
+					if(count == 0)
+					{
+						ss.WriteLine("  <Configurations active=\"{0}\">", conf.Name);
+					}
+
+					ss.WriteLine("    <Configuration name=\"{0}\" ctype=\"CombineConfiguration\">", conf.Name);
+					foreach(ProjectNode project in solution.Projects)
+					{
+						ss.WriteLine("      <Entry configuration=\"{1}\" build=\"True\" name=\"{0}\" />", project.Name, conf.Name);
+					}
+					ss.WriteLine("    </Configuration>");
+
+					count++;
+				}
+				ss.WriteLine("  </Configurations>");
+				
+				count = 0;
+				
+				foreach(ProjectNode project in solution.Projects)
+				{                    
+					if(count == 0)
+						ss.WriteLine("  <StartMode startupentry=\"{0}\" single=\"True\">", project.Name);
+
+					ss.WriteLine("    <Execute type=\"None\" entry=\"{0}\" />", project.Name);
+					count++;
+				}
+				ss.WriteLine("  </StartMode>");
+				
+				ss.WriteLine("  <Entries>");
+				foreach(ProjectNode project in solution.Projects)
+				{
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.WriteLine("    <Entry filename=\"{0}\" />",
+						Helper.MakeFilePath(path, project.Name, "mdp"));
+				}
+				ss.WriteLine("  </Entries>");
+				
+				ss.WriteLine("</Combine>");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void CleanProject(ProjectNode project)
+		{
+			m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
+			string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "mdp");
+			Helper.DeleteIfExists(projectFile);
+		}
+
+		private void CleanSolution(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Cleaning MonoDevelop combine and project files for", solution.Name);
+
+			string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "mds");
+			Helper.DeleteIfExists(slnFile);
+
+			foreach(ProjectNode project in solution.Projects)
+			{
+				CleanProject(project);
+			}
+            
+			m_Kernel.Log.Write("");
+		}
+
+		#endregion
+
+		#region ITarget Members
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public void Write(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode solution in kern.Solutions)
+			{
+				WriteCombine(solution);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public virtual void Clean(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode sol in kern.Solutions)
+			{
+				CleanSolution(sol);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public string Name
+		{
+			get
+			{
+				return "sharpdev";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/NAntTarget.cs b/Prebuild/src/Core/Targets/NAntTarget.cs
new file mode 100644
index 0000000..0f0deb2
--- /dev/null
+++ b/Prebuild/src/Core/Targets/NAntTarget.cs
@@ -0,0 +1,621 @@
+#region BSD License
+/*
+Copyright (c) 2004 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2007-02-13 21:58:03 +0100 (ti, 13 feb 2007) $
+ * $Revision: 205 $
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("nant")]
+	public class NAntTarget : ITarget
+	{
+		#region Fields
+
+		private Kernel m_Kernel;
+
+		#endregion
+
+		#region Private Methods
+
+		private static string PrependPath(string path)
+		{
+			string tmpPath = Helper.NormalizePath(path, '/');
+			Regex regex = new Regex(@"(\w):/(\w+)");
+			Match match = regex.Match(tmpPath);
+			//if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
+			//{
+				tmpPath = Helper.NormalizePath(tmpPath);
+			//}
+//			else
+//			{
+//				tmpPath = Helper.NormalizePath("./" + tmpPath);
+//			}
+
+			return tmpPath;
+		}
+
+		private static string BuildReference(SolutionNode solution, ProjectNode currentProject, ReferenceNode refr)
+		{
+			string ret = "";
+			if(solution.ProjectsTable.ContainsKey(refr.Name))
+			{
+				ProjectNode project = (ProjectNode)solution.ProjectsTable[refr.Name];
+
+                string finalPath = Helper.NormalizePath(((ReferencePathNode)currentProject.ReferencePaths[0]).Path + refr.Name + ".dll", '/');
+				
+				return finalPath;
+			}
+			else
+			{
+				ProjectNode project = (ProjectNode)refr.Parent;
+				string fileRef = FindFileReference(refr.Name, project);
+
+				if(refr.Path != null || fileRef != null)
+				{
+					string finalPath = (refr.Path != null) ? Helper.NormalizePath(refr.Path + "/" + refr.Name + ".dll", '/') : fileRef;
+					ret += finalPath;
+					return ret;
+				}
+
+				try
+				{
+                    //Assembly assem = Assembly.Load(refr.Name);
+                    //if (assem != null)
+                    //{
+						//ret += (refr.Name + ".dll");
+					//}
+					//else
+					//{
+						ret += (refr.Name + ".dll");
+					//}
+				}
+				catch (System.NullReferenceException e)
+				{
+					e.ToString();
+					ret += refr.Name + ".dll";
+				}
+			}
+			return ret;
+		}
+
+		private static string BuildReferencePath(SolutionNode solution, ReferenceNode refr)
+		{
+			string ret = "";
+			if(solution.ProjectsTable.ContainsKey(refr.Name))
+			{
+				ProjectNode project = (ProjectNode)solution.ProjectsTable[refr.Name];
+                string finalPath = Helper.NormalizePath(((ReferencePathNode)project.ReferencePaths[0]).Path, '/');
+
+                return finalPath;
+            }
+			else
+			{
+				ProjectNode project = (ProjectNode)refr.Parent;
+				string fileRef = FindFileReference(refr.Name, project);
+
+				if(refr.Path != null || fileRef != null)
+				{
+					string finalPath = (refr.Path != null) ? Helper.NormalizePath(refr.Path, '/') : fileRef;
+					ret += finalPath;
+					return ret;
+				}
+
+				try
+				{
+					Assembly assem = Assembly.Load(refr.Name);
+					if (assem != null)
+					{
+						ret += "";
+					}
+					else
+					{
+						ret += "";
+					}
+				}
+				catch (System.NullReferenceException e)
+				{
+					e.ToString();
+					ret += "";
+				}
+			}
+			return ret;
+		}
+
+		private static string FindFileReference(string refName, ProjectNode project) 
+		{
+			foreach(ReferencePathNode refPath in project.ReferencePaths) 
+			{
+				string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
+
+				if(File.Exists(fullPath)) 
+				{
+					return fullPath;
+				}
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		/// Gets the XML doc file.
+		/// </summary>
+		/// <param name="project">The project.</param>
+		/// <param name="conf">The conf.</param>
+		/// <returns></returns>
+		public static string GetXmlDocFile(ProjectNode project, ConfigurationNode conf) 
+		{
+			if( conf == null )
+			{
+				throw new ArgumentNullException("conf");
+			}
+			if( project == null )
+			{
+				throw new ArgumentNullException("project");
+			}
+			string docFile = (string)conf.Options["XmlDocFile"];
+			//			if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
+			//			{
+			//				return Path.GetFileNameWithoutExtension(project.AssemblyName) + ".xml";
+			//			}
+			return docFile;
+		}
+
+		private void WriteProject(SolutionNode solution, ProjectNode project)
+		{
+			string projFile = Helper.MakeFilePath(project.FullPath, project.Name + (project.Type == ProjectType.Library ? ".dll" : ".exe"), "build");
+			StreamWriter ss = new StreamWriter(projFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
+			bool hasDoc = false;
+
+			using(ss)
+			{
+				ss.WriteLine("<?xml version=\"1.0\" ?>");
+				ss.WriteLine("<project name=\"{0}\" default=\"build\">", project.Name);
+				ss.WriteLine("    <target name=\"{0}\">", "build");
+				ss.WriteLine("        <echo message=\"Build Directory is ${project::get-base-directory()}/${build.dir}\" />");
+				ss.WriteLine("        <mkdir dir=\"${project::get-base-directory()}/${build.dir}\" />");				
+				ss.WriteLine("        <copy todir=\"${project::get-base-directory()}/${build.dir}\">");
+				ss.WriteLine("            <fileset basedir=\"${project::get-base-directory()}\">");
+				foreach(ReferenceNode refr in project.References)
+				{
+					if (refr.LocalCopy)
+					{
+						ss.WriteLine("                <include name=\"{0}", Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr))+"\" />", '/'));
+					}
+				}
+				ss.WriteLine("            </fileset>");
+				ss.WriteLine("        </copy>");
+				ss.Write("        <csc");
+				ss.Write(" target=\"{0}\"", project.Type.ToString().ToLower());
+				ss.Write(" debug=\"{0}\"", "${build.debug}");
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (conf.Options.KeyFile !="")
+					{
+						ss.Write(" keyfile=\"{0}\"", conf.Options.KeyFile);
+						break;
+					}
+				}
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ss.Write(" unsafe=\"{0}\"", conf.Options.AllowUnsafe);
+					break;
+				}
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ss.Write(" define=\"{0}\"", conf.Options.CompilerDefines);
+					break;
+				}
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (GetXmlDocFile(project, conf) !="")
+					{
+						ss.Write(" doc=\"{0}\"", "${project::get-base-directory()}/${build.dir}/" + GetXmlDocFile(project, conf));
+						hasDoc = true;
+					}
+					break;
+				}
+				ss.Write(" output=\"{0}", "${project::get-base-directory()}/${build.dir}/${project::get-name()}");
+				if (project.Type == ProjectType.Library)
+				{
+					ss.Write(".dll\"");
+				}
+				else
+				{
+					ss.Write(".exe\"");
+				}
+				if(project.AppIcon != null && project.AppIcon.Length != 0)
+				{
+					ss.Write(" win32icon=\"{0}\"", Helper.NormalizePath(project.AppIcon,'/'));
+				}
+				ss.WriteLine(">");
+                ss.WriteLine("            <resources prefix=\"{0}\" dynamicprefix=\"true\" >", project.RootNamespace);
+                foreach (string file in project.Files)
+                {
+                    switch (project.Files.GetBuildAction(file))
+                    {
+                        case BuildAction.EmbeddedResource:
+                            ss.WriteLine("                {0}", "<include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
+                            break;
+                        default:
+                            if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+                            {
+                                ss.WriteLine("                <include name=\"{0}\" />", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+                            }
+                            break;
+                    }
+                }
+                //if (project.Files.GetSubType(file).ToString() != "Code")
+                //{
+                //	ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx");                 
+
+                ss.WriteLine("            </resources>");
+				ss.WriteLine("            <sources failonempty=\"true\">");
+				foreach(string file in project.Files)
+				{
+					switch(project.Files.GetBuildAction(file))
+					{
+						case BuildAction.Compile:
+							ss.WriteLine("                <include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
+							break;
+						default:
+							break;
+					}
+				}
+				ss.WriteLine("            </sources>");
+				ss.WriteLine("            <references basedir=\"${project::get-base-directory()}\">");
+				ss.WriteLine("                <lib>");
+				ss.WriteLine("                    <include name=\"${project::get-base-directory()}\" />");
+				ss.WriteLine("                    <include name=\"${project::get-base-directory()}/${build.dir}\" />");
+				ss.WriteLine("                </lib>");
+				foreach(ReferenceNode refr in project.References)
+				{
+				    string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr)), '/');
+					ss.WriteLine("                <include name=\""+ path + "\" />" );
+				}
+				ss.WriteLine("            </references>");
+                
+				ss.WriteLine("        </csc>");
+
+                foreach (ConfigurationNode conf in project.Configurations)
+                {
+                    if (!String.IsNullOrEmpty(conf.Options.OutputPath))
+                    {
+                        string targetDir = Helper.NormalizePath(conf.Options.OutputPath, '/');
+                        
+                        ss.WriteLine("        <echo message=\"Copying from [${project::get-base-directory()}/${build.dir}/] to [${project::get-base-directory()}/" + targetDir + "\" />");
+
+                        ss.WriteLine("        <mkdir dir=\"${project::get-base-directory()}/" + targetDir + "\"/>");
+
+                        ss.WriteLine("        <copy todir=\"${project::get-base-directory()}/" + targetDir + "\">");
+                        ss.WriteLine("            <fileset basedir=\"${project::get-base-directory()}/${build.dir}/\" >");
+                        ss.WriteLine("                <include name=\"*.dll\"/>");
+                        ss.WriteLine("                <include name=\"*.exe\"/>");
+                        ss.WriteLine("            </fileset>");
+                        ss.WriteLine("        </copy>");
+                        break;
+                    }
+                }
+			    
+				ss.WriteLine("    </target>");
+
+				ss.WriteLine("    <target name=\"clean\">");
+				ss.WriteLine("        <delete dir=\"${bin.dir}\" failonerror=\"false\" />");
+				ss.WriteLine("        <delete dir=\"${obj.dir}\" failonerror=\"false\" />");
+				ss.WriteLine("    </target>");
+
+				ss.WriteLine("    <target name=\"doc\" description=\"Creates documentation.\">");
+				if (hasDoc)
+				{
+					ss.WriteLine("        <property name=\"doc.target\" value=\"\" />");
+					ss.WriteLine("        <if test=\"${platform::is-unix()}\">");
+					ss.WriteLine("            <property name=\"doc.target\" value=\"Web\" />");
+					ss.WriteLine("        </if>");
+					ss.WriteLine("        <ndoc failonerror=\"false\" verbose=\"true\">");
+					ss.WriteLine("            <assemblies basedir=\"${project::get-base-directory()}\">");
+					ss.Write("                <include name=\"${build.dir}/${project::get-name()}");
+					if (project.Type == ProjectType.Library)
+					{
+						ss.WriteLine(".dll\" />");
+					}
+					else
+					{
+						ss.WriteLine(".exe\" />");
+					}
+
+					ss.WriteLine("            </assemblies>");
+					ss.WriteLine("            <summaries basedir=\"${project::get-base-directory()}\">");
+					ss.WriteLine("                <include name=\"${build.dir}/${project::get-name()}.xml\"/>");
+					ss.WriteLine("            </summaries>");
+					ss.WriteLine("            <referencepaths basedir=\"${project::get-base-directory()}\">");
+					ss.WriteLine("                <include name=\"${build.dir}\" />");
+					//					foreach(ReferenceNode refr in project.References)
+					//					{
+					//						string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReferencePath(solution, refr)), '/');
+					//						if (path != "")
+					//						{
+					//							ss.WriteLine("                <include name=\"{0}\" />", path);
+					//						}
+					//					}
+					ss.WriteLine("            </referencepaths>");
+					ss.WriteLine("            <documenters>");
+					ss.WriteLine("                <documenter name=\"MSDN\">");
+                    ss.WriteLine("                    <property name=\"OutputDirectory\" value=\"${project::get-base-directory()}/${build.dir}/doc/${project::get-name()}\" />");
+					ss.WriteLine("                    <property name=\"OutputTarget\" value=\"${doc.target}\" />");
+					ss.WriteLine("                    <property name=\"HtmlHelpName\" value=\"${project::get-name()}\" />");
+					ss.WriteLine("                    <property name=\"IncludeFavorites\" value=\"False\" />");
+					ss.WriteLine("                    <property name=\"Title\" value=\"${project::get-name()} SDK Documentation\" />");
+					ss.WriteLine("                    <property name=\"SplitTOCs\" value=\"False\" />");
+					ss.WriteLine("                    <property name=\"DefaulTOC\" value=\"\" />");
+					ss.WriteLine("                    <property name=\"ShowVisualBasic\" value=\"True\" />");
+					ss.WriteLine("                    <property name=\"AutoDocumentConstructors\" value=\"True\" />");
+					ss.WriteLine("                    <property name=\"ShowMissingSummaries\" value=\"${build.debug}\" />");
+					ss.WriteLine("                    <property name=\"ShowMissingRemarks\" value=\"${build.debug}\" />");
+					ss.WriteLine("                    <property name=\"ShowMissingParams\" value=\"${build.debug}\" />");
+					ss.WriteLine("                    <property name=\"ShowMissingReturns\" value=\"${build.debug}\" />");
+					ss.WriteLine("                    <property name=\"ShowMissingValues\" value=\"${build.debug}\" />");
+					ss.WriteLine("                    <property name=\"DocumentInternals\" value=\"False\" />");
+					ss.WriteLine("                    <property name=\"DocumentPrivates\" value=\"False\" />");
+					ss.WriteLine("                    <property name=\"DocumentProtected\" value=\"True\" />");
+					ss.WriteLine("                    <property name=\"DocumentEmptyNamespaces\" value=\"${build.debug}\" />");
+					ss.WriteLine("                    <property name=\"IncludeAssemblyVersion\" value=\"True\" />");
+					ss.WriteLine("                </documenter>");
+					ss.WriteLine("            </documenters>");
+					ss.WriteLine("        </ndoc>");
+				}
+				ss.WriteLine("    </target>");
+				ss.WriteLine("</project>");
+			}                
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void WriteCombine(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Creating NAnt build files");
+			foreach(ProjectNode project in solution.Projects)
+			{
+				if(m_Kernel.AllowProject(project.FilterGroups)) 
+				{
+					m_Kernel.Log.Write("...Creating project: {0}", project.Name);
+					WriteProject(solution, project);
+				}
+			}
+
+			m_Kernel.Log.Write("");
+			string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "build");
+			StreamWriter ss = new StreamWriter(combFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
+            
+			using(ss)
+			{
+				ss.WriteLine("<?xml version=\"1.0\" ?>");
+				ss.WriteLine("<project name=\"{0}\" default=\"build\">", solution.Name);
+				ss.WriteLine("    <echo message=\"Using '${nant.settings.currentframework}' Framework\"/>");
+				ss.WriteLine();
+
+				//ss.WriteLine("    <property name=\"dist.dir\" value=\"dist\" />");
+				//ss.WriteLine("    <property name=\"source.dir\" value=\"source\" />");
+				ss.WriteLine("    <property name=\"bin.dir\" value=\"bin\" />");
+				ss.WriteLine("    <property name=\"obj.dir\" value=\"obj\" />");
+				ss.WriteLine("    <property name=\"doc.dir\" value=\"doc\" />");
+				ss.WriteLine("    <property name=\"project.main.dir\" value=\"${project::get-base-directory()}\" />");
+
+				foreach(ConfigurationNode conf in solution.Configurations)
+				{
+					// Set the project.config to a non-debug configuration
+					if( conf.Options["DebugInformation"].ToString().ToLower() != "true" )
+					{
+						ss.WriteLine("    <property name=\"project.config\" value=\"{0}\" />", conf.Name);
+					}
+					ss.WriteLine();
+					ss.WriteLine("    <target name=\"{0}\" description=\"\">", conf.Name);
+					ss.WriteLine("        <property name=\"project.config\" value=\"{0}\" />", conf.Name);
+					ss.WriteLine("        <property name=\"build.debug\" value=\"{0}\" />", conf.Options["DebugInformation"].ToString().ToLower());
+					ss.WriteLine("    </target>");
+					ss.WriteLine();
+				}
+
+				ss.WriteLine("    <target name=\"net-1.1\" description=\"Sets framework to .NET 1.1\">");
+				ss.WriteLine("        <property name=\"nant.settings.currentframework\" value=\"net-1.1\" />");
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+    
+				ss.WriteLine("    <target name=\"net-2.0\" description=\"Sets framework to .NET 2.0\">");
+				ss.WriteLine("        <property name=\"nant.settings.currentframework\" value=\"net-2.0\" />");
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+
+				ss.WriteLine("    <target name=\"mono-2.0\" description=\"Sets framework to mono 2.0\">");
+				ss.WriteLine("        <property name=\"nant.settings.currentframework\" value=\"mono-2.0\" />");
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+
+				ss.WriteLine("    <target name=\"mono-1.0\" description=\"Sets framework to mono 1.0\">");
+				ss.WriteLine("        <property name=\"nant.settings.currentframework\" value=\"mono-1.0\" />");
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+
+				ss.WriteLine("    <target name=\"init\" description=\"\">");
+				ss.WriteLine("        <call target=\"${project.config}\" />");
+				ss.WriteLine("        <sysinfo />");
+				ss.WriteLine("        <echo message=\"Platform ${sys.os.platform}\" />");
+				ss.WriteLine("        <property name=\"build.dir\" value=\"${bin.dir}/${project.config}\" />");
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+				
+				ss.WriteLine("    <target name=\"clean\" description=\"\">");
+				ss.WriteLine("        <echo message=\"Deleting all builds from all configurations\" />");
+				//ss.WriteLine("        <delete dir=\"${dist.dir}\" failonerror=\"false\" />");
+				ss.WriteLine("        <delete dir=\"${bin.dir}\" failonerror=\"false\" />");
+				ss.WriteLine("        <delete dir=\"${obj.dir}\" failonerror=\"false\" />");
+				foreach(ProjectNode project in solution.Projects)
+				{
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.Write("        <nant buildfile=\"{0}\"",
+						Helper.NormalizePath(Helper.MakeFilePath(path, project.Name + (project.Type == ProjectType.Library ? ".dll" : ".exe"), "build"),'/'));
+					ss.WriteLine(" target=\"clean\" />");
+				}
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+
+				ss.WriteLine("    <target name=\"build\" depends=\"init\" description=\"\">");
+				
+				foreach(ProjectNode project in solution.ProjectsTableOrder)
+				{
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.Write("        <nant buildfile=\"{0}\"",
+						Helper.NormalizePath(Helper.MakeFilePath(path, project.Name + (project.Type == ProjectType.Library ? ".dll" : ".exe"), "build"),'/'));
+					ss.WriteLine(" target=\"build\" />");
+				}
+				ss.WriteLine("    </target>");
+				ss.WriteLine();
+
+				ss.WriteLine("    <target name=\"build-release\" depends=\"Release, init, build\" description=\"Builds in Release mode\" />");
+				ss.WriteLine();
+				ss.WriteLine("    <target name=\"build-debug\" depends=\"Debug, init, build\" description=\"Builds in Debug mode\" />");
+				ss.WriteLine();
+				//ss.WriteLine("    <target name=\"package\" depends=\"clean, doc, copyfiles, zip\" description=\"Builds in Release mode\" />");
+				ss.WriteLine("    <target name=\"package\" depends=\"clean, doc\" description=\"Builds all\" />");
+				ss.WriteLine();
+
+                ss.WriteLine("    <target name=\"doc\" depends=\"build-release\">");
+                ss.WriteLine("        <echo message=\"Generating all documentation from all builds\" />");
+                foreach (ProjectNode project in solution.Projects)
+                {
+                    string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+                    ss.Write("        <nant buildfile=\"{0}\"",
+                        Helper.NormalizePath(Helper.MakeFilePath(path, project.Name + (project.Type == ProjectType.Library ? ".dll" : ".exe"), "build"), '/'));
+                    ss.WriteLine(" target=\"doc\" />");
+                }
+				ss.WriteLine("    </target>");
+				ss.WriteLine();    
+				ss.WriteLine("</project>");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void CleanProject(ProjectNode project)
+		{
+			m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
+			string projectFile = Helper.MakeFilePath(project.FullPath, project.Name + (project.Type == ProjectType.Library ? ".dll" : ".exe"), "build");
+			Helper.DeleteIfExists(projectFile);
+		}
+
+		private void CleanSolution(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Cleaning NAnt build files for", solution.Name);
+
+			string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "build");
+			Helper.DeleteIfExists(slnFile);
+
+			foreach(ProjectNode project in solution.Projects)
+			{
+				CleanProject(project);
+			}
+            
+			m_Kernel.Log.Write("");
+		}
+
+		#endregion
+
+		#region ITarget Members
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public void Write(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode solution in kern.Solutions)
+			{
+				WriteCombine(solution);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public virtual void Clean(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode sol in kern.Solutions)
+			{
+				CleanSolution(sol);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public string Name
+		{
+			get
+			{
+				return "nant";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/SharpDevelop2Target.cs b/Prebuild/src/Core/Targets/SharpDevelop2Target.cs
new file mode 100644
index 0000000..bc84b96
--- /dev/null
+++ b/Prebuild/src/Core/Targets/SharpDevelop2Target.cs
@@ -0,0 +1,90 @@
+#region BSD License
+/*
+Copyright (c) 2004-2005 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2006-01-27 16:49:58 -0800 (Fri, 27 Jan 2006) $
+ * $Revision: 71 $
+ */
+#endregion
+
+using System;
+
+using Prebuild.Core.Attributes;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("sharpdev2")]
+	public class SharpDevelop2Target : VS2005Target
+	{
+		#region Private Methods
+		private void SetSharpDevelop2()
+		{
+			this.VersionName = "SharpDevelop2";
+		}
+		#endregion
+
+		#region Public Methods
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public override void Write(Kernel kern)
+		{
+			SetSharpDevelop2();
+			base.Write(kern);
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public override void Clean(Kernel kern)
+		{
+			SetSharpDevelop2();
+			base.Clean(kern);
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public override string Name
+		{
+			get
+			{
+				return "sharpdev2";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/SharpDevelopTarget.cs b/Prebuild/src/Core/Targets/SharpDevelopTarget.cs
new file mode 100644
index 0000000..c725730
--- /dev/null
+++ b/Prebuild/src/Core/Targets/SharpDevelopTarget.cs
@@ -0,0 +1,437 @@
+#region BSD License
+/*
+Copyright (c) 2004 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2007-02-13 21:58:03 +0100 (ti, 13 feb 2007) $
+ * $Revision: 205 $
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+using System.Text.RegularExpressions;
+using System.Reflection;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("sharpdev")]
+	public class SharpDevelopTarget : ITarget
+	{
+		#region Fields
+
+		private Kernel m_Kernel;
+
+		#endregion
+
+		#region Private Methods
+
+		private static string PrependPath(string path)
+		{
+			string tmpPath = Helper.NormalizePath(path, '/');
+			Regex regex = new Regex(@"(\w):/(\w+)");
+			Match match = regex.Match(tmpPath);
+			if(match.Success || tmpPath[0] == '.' || tmpPath[0] == '/')
+			{
+				tmpPath = Helper.NormalizePath(tmpPath);
+			}
+			else
+			{
+				tmpPath = Helper.NormalizePath("./" + tmpPath);
+			}
+
+			return tmpPath;
+		}
+
+		private static string BuildReference(SolutionNode solution, ReferenceNode refr)
+		{
+			string ret = "<Reference type=\"";
+			if(solution.ProjectsTable.ContainsKey(refr.Name))
+			{
+				ret += "Project\" refto=\"" + refr.Name;
+				ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
+			}
+			else
+			{
+				ProjectNode project = (ProjectNode)refr.Parent;
+				string fileRef = FindFileReference(refr.Name, project);
+
+				if(refr.Path != null || fileRef != null)
+				{
+					ret += "Assembly\" refto=\"";
+
+					string finalPath = (refr.Path != null) ? Helper.MakeFilePath(refr.Path, refr.Name, "dll") : fileRef;
+
+					ret += finalPath;
+					ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
+					return ret;
+				}
+
+				ret += "Gac\" refto=\"";
+				try
+				{
+					//Assembly assem = Assembly.Load(refr.Name);
+                    ret += refr.Name;// assem.FullName;
+				}
+				catch (System.NullReferenceException e)
+				{
+					e.ToString();
+					ret += refr.Name;
+				}
+				ret += "\" localcopy=\"" + refr.LocalCopy.ToString() + "\" />";
+			}
+
+			return ret;
+		}
+
+		private static string FindFileReference(string refName, ProjectNode project) 
+		{
+			foreach(ReferencePathNode refPath in project.ReferencePaths) 
+			{
+				string fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
+
+				if(File.Exists(fullPath)) 
+				{
+					return fullPath;
+				}
+			}
+
+			return null;
+		}
+
+		/// <summary>
+		/// Gets the XML doc file.
+		/// </summary>
+		/// <param name="project">The project.</param>
+		/// <param name="conf">The conf.</param>
+		/// <returns></returns>
+		public static string GenerateXmlDocFile(ProjectNode project, ConfigurationNode conf) 
+		{
+			if( conf == null )
+			{
+				throw new ArgumentNullException("conf");
+			}
+			if( project == null )
+			{
+				throw new ArgumentNullException("project");
+			}
+			string docFile = (string)conf.Options["XmlDocFile"];
+			if(docFile != null && docFile.Length == 0)//default to assembly name if not specified
+			{
+				return "False";
+			}
+			return "True";
+		}
+
+		private void WriteProject(SolutionNode solution, ProjectNode project)
+		{
+			string csComp = "Csc";
+			string netRuntime = "MsNet";
+			if(project.Runtime == ClrRuntime.Mono)
+			{
+				csComp = "Mcs";
+				netRuntime = "Mono";
+			}
+
+			string projFile = Helper.MakeFilePath(project.FullPath, project.Name, "prjx");
+			StreamWriter ss = new StreamWriter(projFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(projFile));
+
+			using(ss)
+			{
+				ss.WriteLine(
+					"<Project name=\"{0}\" standardNamespace=\"{1}\" description=\"\" newfilesearch=\"None\" enableviewstate=\"True\" version=\"1.1\" projecttype=\"C#\">",
+					project.Name,
+					project.RootNamespace
+					);
+
+				ss.WriteLine("  <Contents>");
+				foreach(string file in project.Files)
+				{
+					string buildAction = "Compile";
+					switch(project.Files.GetBuildAction(file))
+					{
+						case BuildAction.None:
+							buildAction = "Nothing";
+							break;
+
+						case BuildAction.Content:
+							buildAction = "Exclude";
+							break;
+
+						case BuildAction.EmbeddedResource:
+							buildAction = "EmbedAsResource";
+							break;
+
+						default:
+							buildAction = "Compile";
+							break;
+					}
+
+					// Sort of a hack, we try and resolve the path and make it relative, if we can.
+					string filePath = PrependPath(file);
+					ss.WriteLine("    <File name=\"{0}\" subtype=\"Code\" buildaction=\"{1}\" dependson=\"\" data=\"\" />", filePath, buildAction);
+				}
+				ss.WriteLine("  </Contents>");
+
+				ss.WriteLine("  <References>");
+				foreach(ReferenceNode refr in project.References)
+				{
+					ss.WriteLine("    {0}", BuildReference(solution, refr));
+				}
+				ss.WriteLine("  </References>");
+
+				ss.Write("  <DeploymentInformation");
+				ss.Write(" target=\"\"");
+				ss.Write(" script=\"\"");
+				ss.Write(" strategy=\"File\"");
+				ss.WriteLine(" />");
+
+				int count = 0;
+				
+				ss.WriteLine("  <Configurations active=\"{0}\">", solution.ActiveConfig);
+
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ss.Write("    <Configuration");
+					ss.Write(" runwithwarnings=\"True\"");
+					ss.Write(" name=\"{0}\"", conf.Name);
+					ss.WriteLine(">");
+					ss.Write("      <CodeGeneration");
+					ss.Write(" runtime=\"{0}\"", netRuntime);
+					ss.Write(" compiler=\"{0}\"", csComp);
+					ss.Write(" compilerversion=\"\"");
+					ss.Write(" warninglevel=\"{0}\"", conf.Options["WarningLevel"]);
+					ss.Write(" nowarn=\"{0}\"", conf.Options["SuppressWarnings"]);
+					ss.Write(" includedebuginformation=\"{0}\"", conf.Options["DebugInformation"]);
+					ss.Write(" optimize=\"{0}\"", conf.Options["OptimizeCode"]);
+					ss.Write(" unsafecodeallowed=\"{0}\"", conf.Options["AllowUnsafe"]);
+					ss.Write(" generateoverflowchecks=\"{0}\"", conf.Options["CheckUnderflowOverflow"]);
+					ss.Write(" mainclass=\"{0}\"", project.StartupObject);
+					ss.Write(" target=\"{0}\"", project.Type);
+					ss.Write(" definesymbols=\"{0}\"", conf.Options["CompilerDefines"]);
+					ss.Write(" generatexmldocumentation=\"{0}\"", GenerateXmlDocFile(project, conf));
+					ss.Write(" win32Icon=\"{0}\"", Helper.NormalizePath(".\\" + project.AppIcon));
+					ss.Write(" noconfig=\"{0}\"", "False");
+					ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]);
+					ss.WriteLine(" />");
+
+					ss.Write("      <Execution");
+					ss.Write(" commandlineparameters=\"\"");
+					ss.Write(" consolepause=\"True\"");
+					ss.WriteLine(" />");
+
+					ss.Write("      <Output");
+					ss.Write(" directory=\".\\{0}\"", Helper.NormalizePath(conf.Options["OutputPath"].ToString()));
+					ss.Write(" assembly=\"{0}\"", project.AssemblyName);
+					ss.Write(" executeScript=\"{0}\"", conf.Options["RunScript"]);
+					if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0)
+					{
+						ss.Write(" executeBeforeBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString()));
+					}
+					else
+					{
+						ss.Write(" executeBeforeBuild=\"{0}\"", conf.Options["PreBuildEvent"]);
+					}
+					if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0)
+					{
+						ss.Write(" executeAfterBuild=\"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString()));
+					}
+					else
+					{
+						ss.Write(" executeAfterBuild=\"{0}\"", conf.Options["PostBuildEvent"]);
+					}
+					ss.Write(" executeBeforeBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
+					ss.Write(" executeAfterBuildArguments=\"{0}\"", conf.Options["PreBuildEventArgs"]);
+					ss.WriteLine(" />");
+					ss.WriteLine("    </Configuration>");
+
+					count++;
+				}  
+				ss.WriteLine("  </Configurations>");
+				ss.WriteLine("</Project>");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void WriteCombine(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Creating SharpDevelop combine and project files");
+			foreach(ProjectNode project in solution.Projects)
+			{
+				if(m_Kernel.AllowProject(project.FilterGroups)) 
+				{
+					m_Kernel.Log.Write("...Creating project: {0}", project.Name);
+					WriteProject(solution, project);
+				}
+			}
+
+			m_Kernel.Log.Write("");
+			string combFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "cmbx");
+			StreamWriter ss = new StreamWriter(combFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(combFile));
+            
+			using(ss)
+			{
+				ss.WriteLine("<Combine fileversion=\"1.0\" name=\"{0}\" description=\"\">", solution.Name);
+                
+				int count = 0;
+				foreach(ProjectNode project in solution.Projects)
+				{                    
+					if(count == 0)
+						ss.WriteLine("  <StartMode startupentry=\"{0}\" single=\"True\">", project.Name);
+
+					ss.WriteLine("    <Execute entry=\"{0}\" type=\"None\" />", project.Name);
+					count++;
+				}
+				ss.WriteLine("  </StartMode>");
+                
+				ss.WriteLine("  <Entries>");
+				foreach(ProjectNode project in solution.Projects)
+				{
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.WriteLine("    <Entry filename=\"{0}\" />",
+						Helper.MakeFilePath(path, project.Name, "prjx"));
+				}
+				ss.WriteLine("  </Entries>");
+
+				count = 0;
+				foreach(ConfigurationNode conf in solution.Configurations)
+				{
+					if(count == 0)
+					{
+						ss.WriteLine("  <Configurations active=\"{0}\">", conf.Name);
+					}
+
+					ss.WriteLine("    <Configuration name=\"{0}\">", conf.Name);
+					foreach(ProjectNode project in solution.Projects)
+					{
+						ss.WriteLine("      <Entry name=\"{0}\" configurationname=\"{1}\" build=\"True\" />", project.Name, conf.Name);
+					}
+					ss.WriteLine("    </Configuration>");
+
+					count++;
+				}
+				ss.WriteLine("  </Configurations>");
+				ss.WriteLine("</Combine>");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void CleanProject(ProjectNode project)
+		{
+			m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
+			string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "prjx");
+			Helper.DeleteIfExists(projectFile);
+		}
+
+		private void CleanSolution(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Cleaning SharpDevelop combine and project files for", solution.Name);
+
+			string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "cmbx");
+			Helper.DeleteIfExists(slnFile);
+
+			foreach(ProjectNode project in solution.Projects)
+			{
+				CleanProject(project);
+			}
+            
+			m_Kernel.Log.Write("");
+		}
+
+		#endregion
+
+		#region ITarget Members
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public void Write(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode solution in kern.Solutions)
+			{
+				WriteCombine(solution);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public virtual void Clean(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode sol in kern.Solutions)
+			{
+				CleanSolution(sol);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public string Name
+		{
+			get
+			{
+				return "sharpdev";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/VS2002Target.cs b/Prebuild/src/Core/Targets/VS2002Target.cs
new file mode 100644
index 0000000..66216dc
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2002Target.cs
@@ -0,0 +1,96 @@
+#region BSD License
+/*
+Copyright (c) 2004-2005 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2006-01-28 01:49:58 +0100 (lö, 28 jan 2006) $
+ * $Revision: 71 $
+ */
+#endregion
+
+using System;
+
+using Prebuild.Core.Attributes;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("vs2002")]
+	public class VS2002Target : VS2003Target
+	{
+		#region Private Methods
+
+		private void SetVS2002()
+		{
+			this.SolutionVersion = "7.00";
+			this.ProductVersion = "7.0.9254";
+			this.SchemaVersion = "1.0";
+			this.VersionName = "2002";
+			this.Version = VSVersion.VS70;
+		}
+
+		#endregion
+
+		#region Public Methods
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public override void Write(Kernel kern)
+		{
+			SetVS2002();
+			base.Write(kern);
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public override void Clean(Kernel kern)
+		{
+			SetVS2002();
+			base.Clean(kern);
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public override string Name
+		{
+			get
+			{
+				return "vs2002";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/VS2003Target.cs b/Prebuild/src/Core/Targets/VS2003Target.cs
new file mode 100644
index 0000000..b3236a8
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2003Target.cs
@@ -0,0 +1,633 @@
+#region BSD License
+/*
+Copyright (c) 2004-2005 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: jendave $
+ * $Date: 2006-09-29 21:11:40 +0200 (fr, 29 sep 2006) $
+ * $Revision: 177 $
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	public enum VSVersion
+	{
+		/// <summary>
+		/// 
+		/// </summary>
+		VS70,
+		/// <summary>
+		/// 
+		/// </summary>
+		VS71,
+		/// <summary>
+		/// 
+		/// </summary>
+		VS80
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	[Target("vs2003")]
+	public class VS2003Target : ITarget
+	{
+
+		#region Fields
+
+		string solutionVersion = "8.00";
+		string productVersion = "7.10.3077";
+		string schemaVersion = "2.0";
+		string versionName = "2003";
+		VSVersion version = VSVersion.VS71;
+
+		Hashtable m_Tools;
+		Kernel m_Kernel;
+
+		/// <summary>
+		/// Gets or sets the solution version.
+		/// </summary>
+		/// <value>The solution version.</value>
+		protected string SolutionVersion
+		{
+			get
+			{
+				return this.solutionVersion;
+			}
+			set
+			{
+				this.solutionVersion = value;
+			}
+		}
+		/// <summary>
+		/// Gets or sets the product version.
+		/// </summary>
+		/// <value>The product version.</value>
+		protected string ProductVersion
+		{
+			get
+			{
+				return this.productVersion;
+			}
+			set
+			{
+				this.productVersion = value;
+			}
+		}
+		/// <summary>
+		/// Gets or sets the schema version.
+		/// </summary>
+		/// <value>The schema version.</value>
+		protected string SchemaVersion
+		{
+			get
+			{
+				return this.schemaVersion;
+			}
+			set
+			{
+				this.schemaVersion = value;
+			}
+		}
+		/// <summary>
+		/// Gets or sets the name of the version.
+		/// </summary>
+		/// <value>The name of the version.</value>
+		protected string VersionName
+		{
+			get
+			{
+				return this.versionName;
+			}
+			set
+			{
+				this.versionName = value;
+			}
+		}
+		/// <summary>
+		/// Gets or sets the version.
+		/// </summary>
+		/// <value>The version.</value>
+		protected VSVersion Version
+		{
+			get
+			{
+				return this.version;
+			}
+			set
+			{
+				this.version = value;
+			}
+		}
+
+		#endregion
+
+		#region Constructors
+
+		/// <summary>
+		/// Initializes a new instance of the <see cref="VS2003Target"/> class.
+		/// </summary>
+		public VS2003Target()
+		{
+			m_Tools = new Hashtable();
+
+			m_Tools["C#"] = new ToolInfo("C#", "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}", "csproj", "CSHARP");
+			m_Tools["VB.NET"] = new ToolInfo("VB.NET", "{F184B08F-C81C-45F6-A57F-5ABD9991F28F}", "vbproj", "VisualBasic");
+		}
+
+		#endregion
+
+		#region Private Methods
+
+		private string MakeRefPath(ProjectNode project)
+		{
+			string ret = "";
+			foreach(ReferencePathNode node in project.ReferencePaths)
+			{
+				try
+				{
+					string fullPath = Helper.ResolvePath(node.Path);
+					if(ret.Length < 1)
+					{
+						ret = fullPath;
+					}
+					else
+					{
+						ret += ";" + fullPath;
+					}
+				}
+				catch(ArgumentException)
+				{
+					m_Kernel.Log.Write(LogType.Warning, "Could not resolve reference path: {0}", node.Path);
+				}
+			}
+
+			return ret;
+		}
+
+		private void WriteProject(SolutionNode solution, ProjectNode project)
+		{
+			if(!m_Tools.ContainsKey(project.Language))
+			{
+				throw new UnknownLanguageException("Unknown .NET language: " + project.Language);
+			}
+
+			ToolInfo toolInfo = (ToolInfo)m_Tools[project.Language];
+			string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, toolInfo.FileExtension);
+			StreamWriter ps = new StreamWriter(projectFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(projectFile));
+
+			IEnumerator enumerator;
+			//ConfigurationNode scripts;
+
+			using(ps)
+			{
+				ps.WriteLine("<VisualStudioProject>");
+				ps.WriteLine("    <{0}", toolInfo.XmlTag);
+				ps.WriteLine("\t\t\t\tProjectType = \"Local\"");
+				ps.WriteLine("\t\t\t\tProductVersion = \"{0}\"", this.ProductVersion);
+				ps.WriteLine("\t\t\t\tSchemaVersion = \"{0}\"", this.SchemaVersion);
+				ps.WriteLine("\t\t\t\tProjectGuid = \"{{{0}}}\"", project.Guid.ToString().ToUpper());
+				ps.WriteLine("\t\t>");
+
+				ps.WriteLine("\t\t\t\t<Build>");
+				ps.WriteLine("            <Settings");
+				ps.WriteLine("\t\t\t\t  ApplicationIcon = \"{0}\"",project.AppIcon);
+				ps.WriteLine("\t\t\t\t  AssemblyKeyContainerName = \"\"");
+				ps.WriteLine("\t\t\t\t  AssemblyName = \"{0}\"", project.AssemblyName);
+				ps.WriteLine("\t\t\t\t  AssemblyOriginatorKeyFile = \"\"");
+				ps.WriteLine("\t\t\t\t  DefaultClientScript = \"JScript\"");
+				ps.WriteLine("\t\t\t\t  DefaultHTMLPageLayout = \"Grid\"");
+				ps.WriteLine("\t\t\t\t  DefaultTargetSchema = \"IE50\"");
+				ps.WriteLine("\t\t\t\t  DelaySign = \"false\"");
+
+				if(this.Version == VSVersion.VS70)
+				{
+					ps.WriteLine("\t\t\t\t  NoStandardLibraries = \"false\"");
+				}
+
+				ps.WriteLine("\t\t\t\t  OutputType = \"{0}\"", project.Type.ToString());
+
+				enumerator = project.Configurations.GetEnumerator();
+				enumerator.Reset();
+				enumerator.MoveNext();
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					if (conf.Options["PreBuildEvent"] != null && conf.Options["PreBuildEvent"].ToString().Length != 0)
+					{
+						ps.WriteLine("\t\t\t\t  PreBuildEvent = \"{0}\"", Helper.NormalizePath(conf.Options["PreBuildEvent"].ToString()));
+					}
+					else
+					{
+						ps.WriteLine("\t\t\t\t  PreBuildEvent = \"{0}\"", conf.Options["PreBuildEvent"]);
+					}
+					if (conf.Options["PostBuildEvent"] != null && conf.Options["PostBuildEvent"].ToString().Length != 0)
+					{
+						ps.WriteLine("\t\t\t\t  PostBuildEvent = \"{0}\"", Helper.NormalizePath(conf.Options["PostBuildEvent"].ToString()));
+					}
+					else
+					{
+						ps.WriteLine("\t\t\t\t  PostBuildEvent = \"{0}\"", conf.Options["PostBuildEvent"]);
+					}
+					if (conf.Options["RunPostBuildEvent"] == null)
+					{
+						ps.WriteLine("\t\t\t\t  RunPostBuildEvent = \"{0}\"", "OnBuildSuccess");
+					}
+					else
+					{
+						ps.WriteLine("\t\t\t\t  RunPostBuildEvent = \"{0}\"", conf.Options["RunPostBuildEvent"]);
+					}
+					break;
+				}
+				
+				ps.WriteLine("\t\t\t\t  RootNamespace = \"{0}\"", project.RootNamespace);
+				ps.WriteLine("\t\t\t\t  StartupObject = \"{0}\"", project.StartupObject);
+				ps.WriteLine("\t\t     >");
+
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ps.WriteLine("\t\t\t\t  <Config");
+					ps.WriteLine("\t\t\t\t      Name = \"{0}\"", conf.Name);
+					ps.WriteLine("\t\t\t\t      AllowUnsafeBlocks = \"{0}\"", conf.Options["AllowUnsafe"].ToString().ToLower());
+					ps.WriteLine("\t\t\t\t      BaseAddress = \"{0}\"", conf.Options["BaseAddress"]);
+					ps.WriteLine("\t\t\t\t      CheckForOverflowUnderflow = \"{0}\"", conf.Options["CheckUnderflowOverflow"].ToString().ToLower());
+					ps.WriteLine("\t\t\t\t      ConfigurationOverrideFile = \"\"");
+					ps.WriteLine("\t\t\t\t      DefineConstants = \"{0}\"", conf.Options["CompilerDefines"]);
+					ps.WriteLine("\t\t\t\t      DocumentationFile = \"{0}\"", GetXmlDocFile(project, conf));//default to the assembly name
+					ps.WriteLine("\t\t\t\t      DebugSymbols = \"{0}\"", conf.Options["DebugInformation"].ToString().ToLower());
+					ps.WriteLine("\t\t\t\t      FileAlignment = \"{0}\"", conf.Options["FileAlignment"]);
+					ps.WriteLine("\t\t\t\t      IncrementalBuild = \"{0}\"", conf.Options["IncrementalBuild"].ToString().ToLower());
+                    
+					if(this.Version == VSVersion.VS71)
+					{
+						ps.WriteLine("\t\t\t\t      NoStdLib = \"{0}\"", conf.Options["NoStdLib"].ToString().ToLower());
+						ps.WriteLine("\t\t\t\t      NoWarn = \"{0}\"", conf.Options["SuppressWarnings"].ToString().ToLower());
+					}
+
+					ps.WriteLine("\t\t\t\t      Optimize = \"{0}\"", conf.Options["OptimizeCode"].ToString().ToLower());       
+					ps.WriteLine("                    OutputPath = \"{0}\"", 
+						Helper.EndPath(Helper.NormalizePath(conf.Options["OutputPath"].ToString())));
+					ps.WriteLine("                    RegisterForComInterop = \"{0}\"", conf.Options["RegisterComInterop"].ToString().ToLower());
+					ps.WriteLine("                    RemoveIntegerChecks = \"{0}\"", conf.Options["RemoveIntegerChecks"].ToString().ToLower());
+					ps.WriteLine("                    TreatWarningsAsErrors = \"{0}\"", conf.Options["WarningsAsErrors"].ToString().ToLower());
+					ps.WriteLine("                    WarningLevel = \"{0}\"", conf.Options["WarningLevel"]);
+					ps.WriteLine("                />");
+				}
+
+				ps.WriteLine("            </Settings>");
+
+				ps.WriteLine("            <References>");
+				foreach(ReferenceNode refr in project.References)
+				{
+					ps.WriteLine("                <Reference");
+					ps.WriteLine("                    Name = \"{0}\"", refr.Name);
+					ps.WriteLine("                    AssemblyName = \"{0}\"", refr.Name);
+
+					if(solution.ProjectsTable.ContainsKey(refr.Name))
+					{
+						ProjectNode refProject = (ProjectNode)solution.ProjectsTable[refr.Name];
+						ps.WriteLine("                    Project = \"{{{0}}}\"", refProject.Guid.ToString().ToUpper());
+						ps.WriteLine("                    Package = \"{0}\"", toolInfo.Guid.ToString().ToUpper());
+					}
+					else
+					{
+						if(refr.Path != null)
+						{
+							ps.WriteLine("                    HintPath = \"{0}\"", Helper.MakeFilePath(refr.Path, refr.Name, "dll"));
+						}
+
+					}
+                    
+					if(refr.LocalCopySpecified)
+					{
+						ps.WriteLine("                    Private = \"{0}\"",refr.LocalCopy);
+					}
+
+					ps.WriteLine("                />");
+				}
+				ps.WriteLine("            </References>");
+
+				ps.WriteLine("        </Build>");
+				ps.WriteLine("        <Files>");
+                
+				ps.WriteLine("            <Include>");
+
+				foreach(string file in project.Files)
+				{
+					string fileName = file.Replace(".\\", "");
+					ps.WriteLine("                <File");
+					ps.WriteLine("                    RelPath = \"{0}\"", fileName);
+					ps.WriteLine("                    SubType = \"{0}\"", project.Files.GetSubType(file));
+					ps.WriteLine("                    BuildAction = \"{0}\"", project.Files.GetBuildAction(file));
+					ps.WriteLine("                />");
+
+					if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings)
+					{
+						ps.WriteLine("                <File");
+						ps.WriteLine("                    RelPath = \"{0}\"", fileName.Substring(0, fileName.LastIndexOf('.')) + ".resx");
+						int slash = fileName.LastIndexOf('\\');
+						if (slash == -1)
+						{
+							ps.WriteLine("                    DependentUpon = \"{0}\"", fileName);
+						}
+						else
+						{
+							ps.WriteLine("                    DependentUpon = \"{0}\"", fileName.Substring(slash + 1, fileName.Length - slash - 1));
+						}
+						ps.WriteLine("                    BuildAction = \"{0}\"", "EmbeddedResource");
+						ps.WriteLine("                />");
+
+					}
+				}
+				ps.WriteLine("            </Include>");
+                
+				ps.WriteLine("        </Files>");
+				ps.WriteLine("    </{0}>", toolInfo.XmlTag);
+				ps.WriteLine("</VisualStudioProject>");
+			}
+
+			ps = new StreamWriter(projectFile + ".user");
+			using(ps)
+			{
+				ps.WriteLine("<VisualStudioProject>");
+				ps.WriteLine("    <{0}>", toolInfo.XmlTag);
+				ps.WriteLine("        <Build>");
+
+				ps.WriteLine("            <Settings ReferencePath=\"{0}\">", MakeRefPath(project));
+				foreach(ConfigurationNode conf in project.Configurations)
+				{
+					ps.WriteLine("                <Config");
+					ps.WriteLine("                    Name = \"{0}\"", conf.Name);
+					ps.WriteLine("                />");
+				}
+				ps.WriteLine("            </Settings>");
+
+				ps.WriteLine("        </Build>");
+				ps.WriteLine("    </{0}>", toolInfo.XmlTag);
+				ps.WriteLine("</VisualStudioProject>");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		/// <summary>
+		/// Gets the XML doc file.
+		/// </summary>
+		/// <param name="project">The project.</param>
+		/// <param name="conf">The conf.</param>
+		/// <returns></returns>
+		public static string GetXmlDocFile(ProjectNode project, ConfigurationNode conf) 
+		{
+			if( conf == null )
+			{
+				throw new ArgumentNullException("conf");
+			}
+			if( project == null )
+			{
+				throw new ArgumentNullException("project");
+			}
+			//			if(!(bool)conf.Options["GenerateXmlDocFile"]) //default to none, if the generate option is false
+			//			{
+			//				return string.Empty;
+			//			}
+
+			//default to "AssemblyName.xml"
+			//string defaultValue = Path.GetFileNameWithoutExtension(project.AssemblyName) + ".xml";
+			//return (string)conf.Options["XmlDocFile", defaultValue];
+
+			//default to no XmlDocFile file
+			return (string)conf.Options["XmlDocFile", ""];
+		}
+
+		private void WriteSolution(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Creating Visual Studio {0} solution and project files", this.VersionName);
+
+			foreach(ProjectNode project in solution.Projects)
+			{
+				if(m_Kernel.AllowProject(project.FilterGroups)) 
+				{
+					m_Kernel.Log.Write("...Creating project: {0}", project.Name);
+					WriteProject(solution, project);
+				}
+			}
+
+			m_Kernel.Log.Write("");
+			string solutionFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "sln");
+			StreamWriter ss = new StreamWriter(solutionFile);
+
+			m_Kernel.CurrentWorkingDirectory.Push();
+			Helper.SetCurrentDir(Path.GetDirectoryName(solutionFile));
+            
+			using(ss)
+			{
+				ss.WriteLine("Microsoft Visual Studio Solution File, Format Version {0}", this.SolutionVersion);
+				foreach(ProjectNode project in solution.Projects)
+				{
+					if(!m_Tools.ContainsKey(project.Language))
+					{
+						throw new UnknownLanguageException("Unknown .NET language: " + project.Language);
+					}
+
+					ToolInfo toolInfo = (ToolInfo)m_Tools[project.Language];
+                
+					string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+					ss.WriteLine("Project(\"{0}\") = \"{1}\", \"{2}\", \"{{{3}}}\"",
+						toolInfo.Guid, project.Name, Helper.MakeFilePath(path, project.Name,
+						toolInfo.FileExtension), project.Guid.ToString().ToUpper());
+
+					ss.WriteLine("\tProjectSection(ProjectDependencies) = postProject");
+					ss.WriteLine("\tEndProjectSection");
+
+					ss.WriteLine("EndProject");
+				}
+
+				ss.WriteLine("Global");
+
+				ss.WriteLine("\tGlobalSection(SolutionConfiguration) = preSolution");
+				foreach(ConfigurationNode conf in solution.Configurations)
+				{
+					ss.WriteLine("\t\t{0} = {0}", conf.Name);
+				}
+				ss.WriteLine("\tEndGlobalSection");
+
+				ss.WriteLine("\tGlobalSection(ProjectDependencies) = postSolution");
+				foreach(ProjectNode project in solution.Projects)
+				{
+					for(int i = 0; i < project.References.Count; i++)
+					{
+						ReferenceNode refr = (ReferenceNode)project.References[i];
+						if(solution.ProjectsTable.ContainsKey(refr.Name))
+						{
+							ProjectNode refProject = (ProjectNode)solution.ProjectsTable[refr.Name];
+							ss.WriteLine("\t\t({{{0}}}).{1} = ({{{2}}})", 
+								project.Guid.ToString().ToUpper()
+								, i, 
+								refProject.Guid.ToString().ToUpper()
+								);
+						}
+					}
+				}
+				ss.WriteLine("\tEndGlobalSection");
+
+				ss.WriteLine("\tGlobalSection(ProjectConfiguration) = postSolution");
+				foreach(ProjectNode project in solution.Projects)
+				{
+					foreach(ConfigurationNode conf in solution.Configurations)
+					{
+						ss.WriteLine("\t\t{{{0}}}.{1}.ActiveCfg = {1}|.NET",
+							project.Guid.ToString().ToUpper(),
+							conf.Name);
+
+						ss.WriteLine("\t\t{{{0}}}.{1}.Build.0 = {1}|.NET",
+							project.Guid.ToString().ToUpper(),
+							conf.Name);
+					}
+				}
+				ss.WriteLine("\tEndGlobalSection");
+
+				if(solution.Files != null)
+				{
+					ss.WriteLine("\tGlobalSection(SolutionItems) = postSolution");
+					foreach(string file in solution.Files)
+					{
+						ss.WriteLine("\t\t{0} = {0}", file);
+					}
+					ss.WriteLine("\tEndGlobalSection");
+				}
+
+				ss.WriteLine("\tGlobalSection(ExtensibilityGlobals) = postSolution");
+				ss.WriteLine("\tEndGlobalSection");
+				ss.WriteLine("\tGlobalSection(ExtensibilityAddIns) = postSolution");
+				ss.WriteLine("\tEndGlobalSection");
+
+				ss.WriteLine("EndGlobal");
+			}
+
+			m_Kernel.CurrentWorkingDirectory.Pop();
+		}
+
+		private void CleanProject(ProjectNode project)
+		{
+			m_Kernel.Log.Write("...Cleaning project: {0}", project.Name);
+
+			ToolInfo toolInfo = (ToolInfo)m_Tools[project.Language];
+			string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, toolInfo.FileExtension);
+			string userFile = projectFile + ".user";
+            
+			Helper.DeleteIfExists(projectFile);
+			Helper.DeleteIfExists(userFile);
+		}
+
+		private void CleanSolution(SolutionNode solution)
+		{
+			m_Kernel.Log.Write("Cleaning Visual Studio {0} solution and project files", this.VersionName, solution.Name);
+
+			string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "sln");
+			string suoFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "suo");
+            
+			Helper.DeleteIfExists(slnFile);
+			Helper.DeleteIfExists(suoFile);
+
+			foreach(ProjectNode project in solution.Projects)
+			{
+				CleanProject(project);
+			}
+
+			m_Kernel.Log.Write("");
+		}
+
+		#endregion
+
+		#region ITarget Members
+
+		/// <summary>
+		/// Writes the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public virtual void Write(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode sol in m_Kernel.Solutions)
+			{
+				WriteSolution(sol);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Cleans the specified kern.
+		/// </summary>
+		/// <param name="kern">The kern.</param>
+		public virtual void Clean(Kernel kern)
+		{
+			if( kern == null )
+			{
+				throw new ArgumentNullException("kern");
+			}
+			m_Kernel = kern;
+			foreach(SolutionNode sol in m_Kernel.Solutions)
+			{
+				CleanSolution(sol);
+			}
+			m_Kernel = null;
+		}
+
+		/// <summary>
+		/// Gets the name.
+		/// </summary>
+		/// <value>The name.</value>
+		public virtual string Name
+		{
+			get
+			{
+				return "vs2003";
+			}
+		}
+
+		#endregion
+	}
+}
diff --git a/Prebuild/src/Core/Targets/VS2005Target.cs b/Prebuild/src/Core/Targets/VS2005Target.cs
new file mode 100644
index 0000000..23b6116
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2005Target.cs
@@ -0,0 +1,883 @@
+#region BSD License
+/*
+Copyright (c) 2004 Matthew Holmes (matthew@wildfiregames.com)
+
+Redistribution and use in source and binary forms, with or without modification, are permitted
+provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions 
+  and the following disclaimer. 
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions 
+  and the following disclaimer in the documentation and/or other materials provided with the 
+  distribution. 
+* The name of the author may not be used to endorse or promote products derived from this software 
+  without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, 
+BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+#endregion
+
+#region CVS Information
+/*
+ * $Source$
+ * $Author: robloach $
+ * $Date: 2007-02-27 19:52:34 +0100 (ti, 27 feb 2007) $
+ * $Revision: 207 $
+ */
+#endregion
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+using System.IO;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public struct ToolInfo
+    {
+        string name;
+        string guid;
+        string fileExtension;
+        string xmlTag;
+        string importProject;
+
+        /// <summary>
+        /// Gets or sets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        public string Name
+        {
+            get
+            {
+                return name;
+            }
+            set
+            {
+                name = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the GUID.
+        /// </summary>
+        /// <value>The GUID.</value>
+        public string Guid
+        {
+            get
+            {
+                return guid;
+            }
+            set
+            {
+                guid = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the file extension.
+        /// </summary>
+        /// <value>The file extension.</value>
+        public string FileExtension
+        {
+            get
+            {
+                return fileExtension;
+            }
+            set
+            {
+                fileExtension = value;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the XML tag.
+        /// </summary>
+        /// <value>The XML tag.</value>
+        public string XmlTag
+        {
+            get
+            {
+                return xmlTag;
+            }
+            set
+            {
+                xmlTag = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the import project property.
+        /// </summary>
+        /// <value>The ImportProject tag.</value>
+        public string ImportProject
+        {
+            get
+            {
+                return importProject;
+            }
+            set
+            {
+                importProject = value;
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ToolInfo"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="guid">The GUID.</param>
+        /// <param name="fileExtension">The file extension.</param>
+        /// <param name="xml">The XML.</param>
+        /// <param name="importProject">The import project.</param>
+        public ToolInfo(string name, string guid, string fileExtension, string xml, string importProject)
+        {
+            this.name = name;
+            this.guid = guid;
+            this.fileExtension = fileExtension;
+            this.xmlTag = xml;
+            this.importProject = importProject;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ToolInfo"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="guid">The GUID.</param>
+        /// <param name="fileExtension">The file extension.</param>
+        /// <param name="xml">The XML.</param>
+        public ToolInfo(string name, string guid, string fileExtension, string xml)
+        {
+            this.name = name;
+            this.guid = guid;
+            this.fileExtension = fileExtension;
+            this.xmlTag = xml;
+            this.importProject = "$(MSBuildBinPath)\\Microsoft." + xml + ".Targets";
+        }
+
+        /// <summary>
+        /// Equals operator
+        /// </summary>
+        /// <param name="obj">ToolInfo to compare</param>
+        /// <returns>true if toolInfos are equal</returns>
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                throw new ArgumentNullException("obj");
+            }
+            if (obj.GetType() != typeof(ToolInfo))
+                return false;
+
+            ToolInfo c = (ToolInfo)obj;
+            return ((this.name == c.name) && (this.guid == c.guid) && (this.fileExtension == c.fileExtension) && (this.importProject == c.importProject));
+        }
+
+        /// <summary>
+        /// Equals operator
+        /// </summary>
+        /// <param name="c1">ToolInfo to compare</param>
+        /// <param name="c2">ToolInfo to compare</param>
+        /// <returns>True if toolInfos are equal</returns>
+        public static bool operator ==(ToolInfo c1, ToolInfo c2)
+        {
+            return ((c1.name == c2.name) && (c1.guid == c2.guid) && (c1.fileExtension == c2.fileExtension) && (c1.importProject == c2.importProject) && (c1.xmlTag == c2.xmlTag));
+        }
+
+        /// <summary>
+        /// Not equals operator
+        /// </summary>
+        /// <param name="c1">ToolInfo to compare</param>
+        /// <param name="c2">ToolInfo to compare</param>
+        /// <returns>True if toolInfos are not equal</returns>
+        public static bool operator !=(ToolInfo c1, ToolInfo c2)
+        {
+            return !(c1 == c2);
+        }
+
+        /// <summary>
+        /// Hash Code
+        /// </summary>
+        /// <returns>Hash code</returns>
+        public override int GetHashCode()
+        {
+            return name.GetHashCode() ^ guid.GetHashCode() ^ this.fileExtension.GetHashCode() ^ this.importProject.GetHashCode() ^ this.xmlTag.GetHashCode();
+
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    [Target("vs2005")]
+    public class VS2005Target : ITarget
+    {
+        #region Inner Classes
+
+        #endregion
+
+        #region Fields
+
+        string solutionVersion = "9.00";
+        string productVersion = "8.0.50727";
+        string schemaVersion = "2.0";
+        string versionName = "Visual C# 2005";
+        VSVersion version = VSVersion.VS80;
+
+        Hashtable tools;
+        Kernel kernel;
+
+        /// <summary>
+        /// Gets or sets the solution version.
+        /// </summary>
+        /// <value>The solution version.</value>
+        protected string SolutionVersion
+        {
+            get
+            {
+                return this.solutionVersion;
+            }
+            set
+            {
+                this.solutionVersion = value;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the product version.
+        /// </summary>
+        /// <value>The product version.</value>
+        protected string ProductVersion
+        {
+            get
+            {
+                return this.productVersion;
+            }
+            set
+            {
+                this.productVersion = value;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the schema version.
+        /// </summary>
+        /// <value>The schema version.</value>
+        protected string SchemaVersion
+        {
+            get
+            {
+                return this.schemaVersion;
+            }
+            set
+            {
+                this.schemaVersion = value;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the name of the version.
+        /// </summary>
+        /// <value>The name of the version.</value>
+        protected string VersionName
+        {
+            get
+            {
+                return this.versionName;
+            }
+            set
+            {
+                this.versionName = value;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the version.
+        /// </summary>
+        /// <value>The version.</value>
+        protected VSVersion Version
+        {
+            get
+            {
+                return this.version;
+            }
+            set
+            {
+                this.version = value;
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VS2005Target"/> class.
+        /// </summary>
+        public VS2005Target()
+        {
+            this.tools = new Hashtable();
+
+            this.tools["C#"] = new ToolInfo("C#", "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}", "csproj", "CSHARP", "$(MSBuildBinPath)\\Microsoft.CSHARP.Targets");
+            this.tools["Boo"] = new ToolInfo("Boo", "{45CEA7DC-C2ED-48A6-ACE0-E16144C02365}", "booproj", "Boo", "$(BooBinPath)\\Boo.Microsoft.Build.targets");
+            this.tools["VisualBasic"] = new ToolInfo("VisualBasic", "{F184B08F-C81C-45F6-A57F-5ABD9991F28F}", "vbproj", "VisualBasic", "$(MSBuildBinPath)\\Microsoft.VisualBasic.Targets");
+        }
+
+        #endregion
+
+        #region Private Methods
+
+        private string MakeRefPath(ProjectNode project)
+        {
+            string ret = "";
+            foreach (ReferencePathNode node in project.ReferencePaths)
+            {
+                try
+                {
+                    string fullPath = Helper.ResolvePath(node.Path);
+                    if (ret.Length < 1)
+                    {
+                        ret = fullPath;
+                    }
+                    else
+                    {
+                        ret += ";" + fullPath;
+                    }
+                }
+                catch (ArgumentException)
+                {
+                    this.kernel.Log.Write(LogType.Warning, "Could not resolve reference path: {0}", node.Path);
+                }
+            }
+
+            return ret;
+        }
+
+        private void WriteProject(SolutionNode solution, ProjectNode project)
+        {
+            if (!tools.ContainsKey(project.Language))
+            {
+                throw new UnknownLanguageException("Unknown .NET language: " + project.Language);
+            }
+
+            ToolInfo toolInfo = (ToolInfo)tools[project.Language];
+            string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, toolInfo.FileExtension);
+            StreamWriter ps = new StreamWriter(projectFile);
+
+            kernel.CurrentWorkingDirectory.Push();
+            Helper.SetCurrentDir(Path.GetDirectoryName(projectFile));
+
+            #region Project File
+            using (ps)
+            {
+                ps.WriteLine("<Project DefaultTargets=\"Build\" xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");
+                //ps.WriteLine("  <{0}", toolInfo.XMLTag);
+                ps.WriteLine("  <PropertyGroup>");
+                ps.WriteLine("    <ProjectType>Local</ProjectType>");
+                ps.WriteLine("    <ProductVersion>{0}</ProductVersion>", this.ProductVersion);
+                ps.WriteLine("    <SchemaVersion>{0}</SchemaVersion>", this.SchemaVersion);
+                ps.WriteLine("    <ProjectGuid>{{{0}}}</ProjectGuid>", project.Guid.ToString().ToUpper());
+
+                ps.WriteLine("    <Configuration Condition=\" '$(Configuration)' == '' \">Debug</Configuration>");
+                ps.WriteLine("    <Platform Condition=\" '$(Platform)' == '' \">AnyCPU</Platform>");
+                //ps.WriteLine("    <Build>");
+
+                //ps.WriteLine("      <Settings");
+                ps.WriteLine("    <ApplicationIcon>{0}</ApplicationIcon>", project.AppIcon);
+                ps.WriteLine("    <AssemblyKeyContainerName>");
+                ps.WriteLine("    </AssemblyKeyContainerName>");
+                ps.WriteLine("    <AssemblyName>{0}</AssemblyName>", project.AssemblyName);
+                foreach (ConfigurationNode conf in project.Configurations)
+                {
+                    if (conf.Options.KeyFile != "")
+                    {
+                        ps.WriteLine("    <AssemblyOriginatorKeyFile>{0}</AssemblyOriginatorKeyFile>", conf.Options.KeyFile);
+                        ps.WriteLine("    <SignAssembly>true</SignAssembly>");
+                        break;
+                    }
+                }
+                ps.WriteLine("    <DefaultClientScript>JScript</DefaultClientScript>");
+                ps.WriteLine("    <DefaultHTMLPageLayout>Grid</DefaultHTMLPageLayout>");
+                ps.WriteLine("    <DefaultTargetSchema>IE50</DefaultTargetSchema>");
+                ps.WriteLine("    <DelaySign>false</DelaySign>");
+
+                //if(m_Version == VSVersion.VS70)
+                //    ps.WriteLine("        NoStandardLibraries = \"false\"");
+
+                ps.WriteLine("    <OutputType>{0}</OutputType>", project.Type.ToString());
+                ps.WriteLine("    <AppDesignerFolder>{0}</AppDesignerFolder>", project.DesignerFolder);
+                ps.WriteLine("    <RootNamespace>{0}</RootNamespace>", project.RootNamespace);
+                ps.WriteLine("    <StartupObject>{0}</StartupObject>", project.StartupObject);
+                //ps.WriteLine("      >");
+                ps.WriteLine("    <FileUpgradeFlags>");
+                ps.WriteLine("    </FileUpgradeFlags>");
+
+                ps.WriteLine("  </PropertyGroup>");
+
+                foreach (ConfigurationNode conf in project.Configurations)
+                {
+                    ps.Write("  <PropertyGroup ");
+                    ps.WriteLine("Condition=\" '$(Configuration)|$(Platform)' == '{0}|AnyCPU' \">", conf.Name);
+                    ps.WriteLine("    <AllowUnsafeBlocks>{0}</AllowUnsafeBlocks>", conf.Options["AllowUnsafe"]);
+                    ps.WriteLine("    <BaseAddress>{0}</BaseAddress>", conf.Options["BaseAddress"]);
+                    ps.WriteLine("    <CheckForOverflowUnderflow>{0}</CheckForOverflowUnderflow>", conf.Options["CheckUnderflowOverflow"]);
+                    ps.WriteLine("    <ConfigurationOverrideFile>");
+                    ps.WriteLine("    </ConfigurationOverrideFile>");
+                    ps.WriteLine("    <DefineConstants>{0}</DefineConstants>", conf.Options["CompilerDefines"]);
+                    ps.WriteLine("    <DocumentationFile>{0}</DocumentationFile>", conf.Options["XmlDocFile"]);
+                    ps.WriteLine("    <DebugSymbols>{0}</DebugSymbols>", conf.Options["DebugInformation"]);
+                    ps.WriteLine("    <FileAlignment>{0}</FileAlignment>", conf.Options["FileAlignment"]);
+                    //                    ps.WriteLine("    <IncrementalBuild = \"{0}\"", conf.Options["IncrementalBuild"]);
+
+                    //                    if(m_Version == VSVersion.VS71)
+                    //                    {
+                    //                        ps.WriteLine("          NoStdLib = \"{0}\"", conf.Options["NoStdLib"]);
+                    //                        ps.WriteLine("          NoWarn = \"{0}\"", conf.Options["SuppressWarnings"]);
+                    //                    }
+
+                    ps.WriteLine("    <Optimize>{0}</Optimize>", conf.Options["OptimizeCode"]);
+                    ps.WriteLine("    <OutputPath>{0}</OutputPath>",
+                        Helper.EndPath(Helper.NormalizePath(conf.Options["OutputPath"].ToString())));
+                    ps.WriteLine("    <RegisterForComInterop>{0}</RegisterForComInterop>", conf.Options["RegisterComInterop"]);
+                    ps.WriteLine("    <RemoveIntegerChecks>{0}</RemoveIntegerChecks>", conf.Options["RemoveIntegerChecks"]);
+                    ps.WriteLine("    <TreatWarningsAsErrors>{0}</TreatWarningsAsErrors>", conf.Options["WarningsAsErrors"]);
+                    ps.WriteLine("    <WarningLevel>{0}</WarningLevel>", conf.Options["WarningLevel"]);
+                    ps.WriteLine("    <NoWarn>{0}</NoWarn>", conf.Options["SuppressWarnings"]);
+                    ps.WriteLine("  </PropertyGroup>");
+                }
+
+                //ps.WriteLine("      </Settings>");
+
+                // Assembly References
+                ps.WriteLine("  <ItemGroup>");
+                string refPath = ((ReferencePathNode) project.ReferencePaths[0]).Path;
+                
+                foreach (ReferenceNode refr in project.References)
+                {
+                    if (!solution.ProjectsTable.ContainsKey(refr.Name))
+                    {
+                        ps.Write("    <Reference");
+                        ps.Write(" Include=\"");
+                        ps.Write(refr.Name);
+
+                        ps.WriteLine("\" >");
+
+                        string path;
+                        
+                        if( refr.Name.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase ))
+                        {
+                            path = Helper.NormalizePath(Path.Combine( refPath, refr.Name), '\\');
+                        }
+                        else
+                        {
+                            path = refr.Name + ".dll";
+                        }
+                        
+                        // TODO: Allow reference to *.exe files
+                        ps.WriteLine("      <HintPath>{0}</HintPath>", path );
+                        ps.WriteLine("      <Private>{0}</Private>", refr.LocalCopy);
+                        ps.WriteLine("    </Reference>");
+                    }
+                }
+                ps.WriteLine("  </ItemGroup>");
+
+                //Project References
+                ps.WriteLine("  <ItemGroup>");
+                foreach (ReferenceNode refr in project.References)
+                {
+                    if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    {
+                        ProjectNode refProject = (ProjectNode)solution.ProjectsTable[refr.Name];
+                        // TODO: Allow reference to visual basic projects
+                        string path =
+                            Helper.MakePathRelativeTo(project.FullPath,
+                                                      Helper.MakeFilePath(refProject.FullPath, refProject.Name, "csproj"));
+                        ps.WriteLine("    <ProjectReference Include=\"{0}\">", path );
+                        //<ProjectReference Include="..\..\RealmForge\Utility\RealmForge.Utility.csproj">
+                        ps.WriteLine("      <Name>{0}</Name>", refProject.Name);
+                        //  <Name>RealmForge.Utility</Name>
+                        ps.WriteLine("      <Project>{{{0}}}</Project>", refProject.Guid.ToString().ToUpper());
+                        //  <Project>{6880D1D3-69EE-461B-B841-5319845B20D3}</Project>
+                        ps.WriteLine("      <Package>{0}</Package>", toolInfo.Guid.ToString().ToUpper());
+                        //  <Package>{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</Package>
+                        ps.WriteLine("\t\t\t<Private>{0}</Private>", refr.LocalCopy);
+                        ps.WriteLine("    </ProjectReference>");
+                        //</ProjectReference>
+                    }
+                    else
+                    {
+                    }
+                }
+                ps.WriteLine("  </ItemGroup>");
+
+                //                ps.WriteLine("    </Build>");
+                ps.WriteLine("  <ItemGroup>");
+
+                //                ps.WriteLine("      <Include>");
+                ArrayList list = new ArrayList();
+                foreach (string file in project.Files)
+                {
+                    //					if (file == "Properties\\Bind.Designer.cs")
+                    //					{
+                    //						Console.WriteLine("Wait a minute!");
+                    //						Console.WriteLine(project.Files.GetSubType(file).ToString());
+                    //					}
+
+                    if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) != SubType.Settings && project.Files.GetSubType(file) != SubType.Designer)
+                    {
+                        ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+
+                        int slash = file.LastIndexOf('\\');
+                        if (slash == -1)
+                        {
+                            ps.WriteLine("      <DependentUpon>{0}</DependentUpon>", file);
+                        }
+                        else
+                        {
+                            ps.WriteLine("      <DependentUpon>{0}</DependentUpon>", file.Substring(slash + 1, file.Length - slash - 1));
+                        }
+                        ps.WriteLine("      <SubType>Designer</SubType>");
+                        ps.WriteLine("    </EmbeddedResource>");
+                        //
+                    }
+                    
+                    if (project.Files.GetSubType(file) != SubType.Code && project.Files.GetSubType(file) == SubType.Designer)
+                    {
+                        ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx");
+                        ps.WriteLine("      <SubType>" + project.Files.GetSubType(file) + "</SubType>");
+                        ps.WriteLine("      <Generator>ResXFileCodeGenerator</Generator>");
+                        ps.WriteLine("      <LastGenOutput>Resources.Designer.cs</LastGenOutput>");
+                        ps.WriteLine("    </EmbeddedResource>");
+                        ps.WriteLine("    <Compile Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".Designer.cs");
+                        ps.WriteLine("      <AutoGen>True</AutoGen>");
+                        ps.WriteLine("      <DesignTime>True</DesignTime>");
+                        ps.WriteLine("      <DependentUpon>Resources.resx</DependentUpon>");
+                        ps.WriteLine("    </Compile>");
+                        list.Add(file.Substring(0, file.LastIndexOf('.')) + ".Designer.cs");
+                    }
+                    if (project.Files.GetSubType(file).ToString() == "Settings")
+                    {
+                        //Console.WriteLine("File: " + file);
+                        //Console.WriteLine("Last index: " + file.LastIndexOf('.'));
+                        //Console.WriteLine("Length: " + file.Length);
+                        ps.Write("    <{0} ", project.Files.GetBuildAction(file));
+                        ps.WriteLine("Include=\"{0}\">", file);
+                        int slash = file.LastIndexOf('\\');
+                        string fileName = file.Substring(slash + 1, file.Length - slash - 1);
+                        if (project.Files.GetBuildAction(file) == BuildAction.None)
+                        {
+                            ps.WriteLine("      <Generator>SettingsSingleFileGenerator</Generator>");
+
+                            //Console.WriteLine("FileName: " + fileName);
+                            //Console.WriteLine("FileNameMain: " + fileName.Substring(0, fileName.LastIndexOf('.')));
+                            //Console.WriteLine("FileNameExt: " + fileName.Substring(fileName.LastIndexOf('.'), fileName.Length - fileName.LastIndexOf('.')));
+                            if (slash == -1)
+                            {
+                                ps.WriteLine("      <LastGenOutput>{0}</LastGenOutput>", fileName.Substring(0, fileName.LastIndexOf('.')) + ".Designer.cs");
+                            }
+                            else
+                            {
+                                ps.WriteLine("      <LastGenOutput>{0}</LastGenOutput>", fileName.Substring(0, fileName.LastIndexOf('.')) + ".Designer.cs");
+                            }
+                        }
+                        else
+                        {
+                            ps.WriteLine("      <SubType>Code</SubType>");
+                            ps.WriteLine("      <AutoGen>True</AutoGen>");
+                            ps.WriteLine("      <DesignTimeSharedInput>True</DesignTimeSharedInput>");
+                            string fileNameShort = fileName.Substring(0, fileName.LastIndexOf('.'));
+                            string fileNameShorter = fileNameShort.Substring(0, fileNameShort.LastIndexOf('.'));
+                            ps.WriteLine("      <DependentUpon>{0}</DependentUpon>", fileNameShorter + ".settings");
+                        }
+                        ps.WriteLine("    </{0}>", project.Files.GetBuildAction(file));
+                    }
+                    else if (project.Files.GetSubType(file) != SubType.Designer)
+                    {
+                        if (!list.Contains(file))
+                        {
+                            ps.Write("    <{0} ", project.Files.GetBuildAction(file));
+                            ps.WriteLine("Include=\"{0}\">", file);
+
+
+                            if (file.Contains("Designer.cs"))
+                            {
+                                ps.WriteLine("      <DependentUpon>{0}</DependentUpon>", file.Substring(0, file.IndexOf(".Designer.cs")) + ".cs");
+                            }
+
+                            if (project.Files.GetIsLink(file))
+                            {
+                                ps.WriteLine("      <Link>{0}</Link>", Path.GetFileName(file));
+                            }
+                            else if (project.Files.GetBuildAction(file) != BuildAction.None)
+                            {
+                                if (project.Files.GetBuildAction(file) != BuildAction.EmbeddedResource)
+                                {
+                                    ps.WriteLine("      <SubType>{0}</SubType>", project.Files.GetSubType(file));
+                                }
+                            }
+                            if (project.Files.GetCopyToOutput(file) != CopyToOutput.Never)
+                            {
+                                ps.WriteLine("      <CopyToOutputDirectory>{0}</CopyToOutputDirectory>", project.Files.GetCopyToOutput(file));
+                            }
+
+                            ps.WriteLine("    </{0}>", project.Files.GetBuildAction(file));
+                        }
+                    }
+                }
+                //                ps.WriteLine("      </Include>");
+
+                ps.WriteLine("  </ItemGroup>");
+                ps.WriteLine("  <Import Project=\"" + toolInfo.ImportProject + "\" />");
+                ps.WriteLine("  <PropertyGroup>");
+                ps.WriteLine("    <PreBuildEvent>");
+                ps.WriteLine("    </PreBuildEvent>");
+                ps.WriteLine("    <PostBuildEvent>");
+                ps.WriteLine("    </PostBuildEvent>");
+                ps.WriteLine("  </PropertyGroup>");
+                //                ps.WriteLine("  </{0}>", toolInfo.XMLTag);
+                ps.WriteLine("</Project>");
+            }
+            #endregion
+
+            #region User File
+
+            ps = new StreamWriter(projectFile + ".user");
+            using (ps)
+            {
+                ps.WriteLine("<Project xmlns=\"http://schemas.microsoft.com/developer/msbuild/2003\">");
+                //ps.WriteLine( "<VisualStudioProject>" );
+                //ps.WriteLine("  <{0}>", toolInfo.XMLTag);
+                //ps.WriteLine("    <Build>");
+                ps.WriteLine("  <PropertyGroup>");
+                //ps.WriteLine("      <Settings ReferencePath=\"{0}\">", MakeRefPath(project));
+
+
+                ps.WriteLine("    <Configuration Condition=\" '$(Configuration)' == '' \">Debug</Configuration>");
+                ps.WriteLine("    <Platform Condition=\" '$(Platform)' == '' \">AnyCPU</Platform>");
+
+                if (projectFile.Contains( "OpenSim.csproj" ))
+                {
+                    ps.WriteLine("    <StartArguments>-loginserver -sandbox -accounts</StartArguments>");
+                }
+
+                ps.WriteLine("    <ReferencePath>{0}</ReferencePath>", MakeRefPath(project));
+                ps.WriteLine("    <LastOpenVersion>{0}</LastOpenVersion>", this.ProductVersion);
+                ps.WriteLine("    <ProjectView>ProjectFiles</ProjectView>");
+                ps.WriteLine("    <ProjectTrust>0</ProjectTrust>");
+                ps.WriteLine("  </PropertyGroup>");
+                foreach (ConfigurationNode conf in project.Configurations)
+                {
+                    ps.Write("  <PropertyGroup");
+                    ps.Write(" Condition = \" '$(Configuration)|$(Platform)' == '{0}|AnyCPU' \"", conf.Name);
+                    ps.WriteLine(" />");
+                }
+                
+                ps.WriteLine("</Project>");
+            }
+            #endregion
+
+            kernel.CurrentWorkingDirectory.Pop();
+        }
+
+        private void WriteSolution(SolutionNode solution)
+        {
+            kernel.Log.Write("Creating {0} solution and project files", this.VersionName);
+
+            foreach (ProjectNode project in solution.Projects)
+            {
+                kernel.Log.Write("...Creating project: {0}", project.Name);
+                WriteProject(solution, project);
+            }
+
+            kernel.Log.Write("");
+            string solutionFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "sln");
+            StreamWriter ss = new StreamWriter(solutionFile);
+
+            kernel.CurrentWorkingDirectory.Push();
+            Helper.SetCurrentDir(Path.GetDirectoryName(solutionFile));
+
+            using (ss)
+            {
+                ss.WriteLine("Microsoft Visual Studio Solution File, Format Version {0}", this.SolutionVersion);
+                ss.WriteLine("# Visual Studio 2005");
+                foreach (ProjectNode project in solution.Projects)
+                {
+                    if (!tools.ContainsKey(project.Language))
+                    {
+                        throw new UnknownLanguageException("Unknown .NET language: " + project.Language);
+                    }
+
+                    ToolInfo toolInfo = (ToolInfo)tools[project.Language];
+
+                    string path = Helper.MakePathRelativeTo(solution.FullPath, project.FullPath);
+                    ss.WriteLine("Project(\"{0}\") = \"{1}\", \"{2}\", \"{{{3}}}\"",
+                        toolInfo.Guid, project.Name, Helper.MakeFilePath(path, project.Name,
+                        toolInfo.FileExtension), project.Guid.ToString().ToUpper());
+
+                    //ss.WriteLine("  ProjectSection(ProjectDependencies) = postProject");
+                    //ss.WriteLine("  EndProjectSection");
+
+                    ss.WriteLine("EndProject");
+                }
+
+                if (solution.Files != null)
+                {
+                    ss.WriteLine("Project(\"{0}\") = \"Solution Items\", \"Solution Items\", \"{1}\"", "{2150E333-8FDC-42A3-9474-1A3956D46DE8}", "{468F1D07-AD17-4CC3-ABD0-2CA268E4E1A6}");
+                    ss.WriteLine("\tProjectSection(SolutionItems) = preProject");
+                    foreach (string file in solution.Files)
+                        ss.WriteLine("\t\t{0} = {0}", file);
+                    ss.WriteLine("\tEndProjectSection");
+                    ss.WriteLine("EndProject");
+                }
+
+                ss.WriteLine("Global");
+
+                ss.WriteLine("  GlobalSection(SolutionConfigurationPlatforms) = preSolution");
+                foreach (ConfigurationNode conf in solution.Configurations)
+                {
+                    ss.WriteLine("    {0}|Any CPU = {0}|Any CPU", conf.Name);
+                }
+                ss.WriteLine("  EndGlobalSection");
+
+                if (solution.Projects.Count > 1)
+                {
+                    ss.WriteLine("  GlobalSection(ProjectDependencies) = postSolution");
+                }
+                foreach (ProjectNode project in solution.Projects)
+                {
+                    for (int i = 0; i < project.References.Count; i++)
+                    {
+                        ReferenceNode refr = (ReferenceNode)project.References[i];
+                        if (solution.ProjectsTable.ContainsKey(refr.Name))
+                        {
+                            ProjectNode refProject = (ProjectNode)solution.ProjectsTable[refr.Name];
+                            ss.WriteLine("    ({{{0}}}).{1} = ({{{2}}})",
+                                project.Guid.ToString().ToUpper()
+                                , i,
+                                refProject.Guid.ToString().ToUpper()
+                                );
+                        }
+                    }
+                }
+                if (solution.Projects.Count > 1)
+                {
+                    ss.WriteLine("  EndGlobalSection");
+                }
+                ss.WriteLine("  GlobalSection(ProjectConfigurationPlatforms) = postSolution");
+                foreach (ProjectNode project in solution.Projects)
+                {
+                    foreach (ConfigurationNode conf in solution.Configurations)
+                    {
+                        ss.WriteLine("    {{{0}}}.{1}|Any CPU.ActiveCfg = {1}|Any CPU",
+                            project.Guid.ToString().ToUpper(),
+                            conf.Name);
+
+                        ss.WriteLine("    {{{0}}}.{1}|Any CPU.Build.0 = {1}|Any CPU",
+                            project.Guid.ToString().ToUpper(),
+                            conf.Name);
+                    }
+                }
+                ss.WriteLine("  EndGlobalSection");
+                ss.WriteLine("  GlobalSection(SolutionProperties) = preSolution");
+                ss.WriteLine("    HideSolutionNode = FALSE");
+                ss.WriteLine("  EndGlobalSection");
+
+                ss.WriteLine("EndGlobal");
+            }
+
+            kernel.CurrentWorkingDirectory.Pop();
+        }
+
+        private void CleanProject(ProjectNode project)
+        {
+            kernel.Log.Write("...Cleaning project: {0}", project.Name);
+
+            ToolInfo toolInfo = (ToolInfo)tools[project.Language];
+            string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, toolInfo.FileExtension);
+            string userFile = projectFile + ".user";
+
+            Helper.DeleteIfExists(projectFile);
+            Helper.DeleteIfExists(userFile);
+        }
+
+        private void CleanSolution(SolutionNode solution)
+        {
+            kernel.Log.Write("Cleaning {0} solution and project files", this.VersionName, solution.Name);
+
+            string slnFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "sln");
+            string suoFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "suo");
+
+            Helper.DeleteIfExists(slnFile);
+            Helper.DeleteIfExists(suoFile);
+
+            foreach (ProjectNode project in solution.Projects)
+            {
+                CleanProject(project);
+            }
+
+            kernel.Log.Write("");
+        }
+
+        #endregion
+
+        #region ITarget Members
+
+        /// <summary>
+        /// Writes the specified kern.
+        /// </summary>
+        /// <param name="kern">The kern.</param>
+        public virtual void Write(Kernel kern)
+        {
+            if (kern == null)
+            {
+                throw new ArgumentNullException("kern");
+            }
+            kernel = kern;
+            foreach (SolutionNode sol in kernel.Solutions)
+            {
+                WriteSolution(sol);
+            }
+            kernel = null;
+        }
+
+        /// <summary>
+        /// Cleans the specified kern.
+        /// </summary>
+        /// <param name="kern">The kern.</param>
+        public virtual void Clean(Kernel kern)
+        {
+            if (kern == null)
+            {
+                throw new ArgumentNullException("kern");
+            }
+            kernel = kern;
+            foreach (SolutionNode sol in kernel.Solutions)
+            {
+                CleanSolution(sol);
+            }
+            kernel = null;
+        }
+
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        public virtual string Name
+        {
+            get
+            {
+                return "vs2005";
+            }
+        }
+
+        #endregion
+    }
+}
-- 
cgit v1.1