45 files changed, 13371 insertions, 0 deletions

diff --git a/Prebuild/src/Core/Targets/.NAntTarget.cs.swp b/Prebuild/src/Core/Targets/.NAntTarget.cs.swp
new file mode 100644
index 0000000..afec61c
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.NAntTarget.cs.swp
diff --git a/Prebuild/src/Core/Targets/.svn/all-wcprops b/Prebuild/src/Core/Targets/.svn/all-wcprops
new file mode 100644
index 0000000..91d6694
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/all-wcprops
@@ -0,0 +1,101 @@
+K 25
+svn:wc:ra_dav:version-url
+V 58
+/svnroot/dnpb/!svn/ver/323/trunk/Prebuild/src/Core/Targets
+END
+MakefileTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 76
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/MakefileTarget.cs
+END
+SharpDevelop2Target.cs
+K 25
+svn:wc:ra_dav:version-url
+V 81
+/svnroot/dnpb/!svn/ver/295/trunk/Prebuild/src/Core/Targets/SharpDevelop2Target.cs
+END
+ToolInfo.cs
+K 25
+svn:wc:ra_dav:version-url
+V 70
+/svnroot/dnpb/!svn/ver/290/trunk/Prebuild/src/Core/Targets/ToolInfo.cs
+END
+VSGenericTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 77
+/svnroot/dnpb/!svn/ver/316/trunk/Prebuild/src/Core/Targets/VSGenericTarget.cs
+END
+DebugTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 73
+/svnroot/dnpb/!svn/ver/164/trunk/Prebuild/src/Core/Targets/DebugTarget.cs
+END
+VSVersion.cs
+K 25
+svn:wc:ra_dav:version-url
+V 71
+/svnroot/dnpb/!svn/ver/316/trunk/Prebuild/src/Core/Targets/VSVersion.cs
+END
+MonoDevelopTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 79
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/MonoDevelopTarget.cs
+END
+AutotoolsTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 77
+/svnroot/dnpb/!svn/ver/298/trunk/Prebuild/src/Core/Targets/AutotoolsTarget.cs
+END
+VS2010Target.cs
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svnroot/dnpb/!svn/ver/317/trunk/Prebuild/src/Core/Targets/VS2010Target.cs
+END
+VS2002Target.cs
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svnroot/dnpb/!svn/ver/295/trunk/Prebuild/src/Core/Targets/VS2002Target.cs
+END
+SharpDevelopTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 80
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/SharpDevelopTarget.cs
+END
+VS2003Target.cs
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/VS2003Target.cs
+END
+VS2005Target.cs
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/VS2005Target.cs
+END
+NAntTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 72
+/svnroot/dnpb/!svn/ver/323/trunk/Prebuild/src/Core/Targets/NAntTarget.cs
+END
+XcodeTarget.cs
+K 25
+svn:wc:ra_dav:version-url
+V 73
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/XcodeTarget.cs
+END
+VS2008Target.cs
+K 25
+svn:wc:ra_dav:version-url
+V 74
+/svnroot/dnpb/!svn/ver/307/trunk/Prebuild/src/Core/Targets/VS2008Target.cs
+END
diff --git a/Prebuild/src/Core/Targets/.svn/dir-prop-base b/Prebuild/src/Core/Targets/.svn/dir-prop-base
new file mode 100644
index 0000000..a1989a0
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/dir-prop-base
@@ -0,0 +1,5 @@
+K 10
+svn:ignore
+V 5
+*.swp
+END
diff --git a/Prebuild/src/Core/Targets/.svn/entries b/Prebuild/src/Core/Targets/.svn/entries
new file mode 100644
index 0000000..c6daa49
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/entries
@@ -0,0 +1,572 @@
+10
+
+dir
+323
+https://dnpb.svn.sourceforge.net/svnroot/dnpb/trunk/Prebuild/src/Core/Targets
+https://dnpb.svn.sourceforge.net/svnroot/dnpb
+
+
+
+2010-09-10T17:51:36.189738Z
+323
+jhurliman
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+3355ff64-970d-0410-bbe8-d0fbd18be4fb
+
+MakefileTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+9f1538adc7e579b57d104dc7f313946b
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+19043
+
+SharpDevelop2Target.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+f6e8e9d8f335a5a264babb4a8f05a2a5
+2009-02-19T06:47:52.218324Z
+295
+kunnis
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2442
+
+ToolInfo.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+20e6cf8e0ad0b0744b6189534bfd049a
+2009-02-18T05:47:43.979044Z
+290
+kunnis
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4315
+
+VSGenericTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+6956b93fe770e1f5786cc44872c31d06
+2010-05-08T05:43:01.449559Z
+316
+jhurliman
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+34542
+
+DebugTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+7346beba16e30e642f272e7bcf3924bb
+2006-09-20T07:42:51.680045Z
+164
+jendave
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2703
+
+VSVersion.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+78ab7ae5edbe12dfb34c9fbd3dba9c23
+2010-05-08T05:43:01.449559Z
+316
+jhurliman
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+1950
+
+MonoDevelopTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+d8b264553d4c2d66a19f9610be56f4b4
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+15976
+
+AutotoolsTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+bc5383cb56dd751ac946386a51852a77
+2009-02-20T02:15:45.530129Z
+298
+kunnis
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+41145
+
+VS2010Target.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+7d9c7f130f06ead33e747f0920b989c4
+2010-05-09T07:39:45.137959Z
+317
+jhurliman
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2745
+
+VS2002Target.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+912769a89b935429b3801db96c467de7
+2009-02-19T06:47:52.218324Z
+295
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2507
+
+SharpDevelopTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+f9017c8dd94137dee4b673bee40c8e6e
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+12773
+
+VS2003Target.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+c8e60070e9d7343d50c297d3dff12ac4
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+18912
+
+VS2005Target.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+812092c2b5b068e087806088d80fe635
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+4291
+
+NAntTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+b635fc47efdd3eed660017693b9073c4
+2010-09-10T17:51:36.189738Z
+323
+jhurliman
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+32065
+
+VS2008Target.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+154f10d6947ee7bf4d5caf10fad8c43d
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+2514
+
+XcodeTarget.cs
+file
+
+
+
+
+2010-09-10T22:51:44.000000Z
+7ec0bbdd62020f03a725d8f99258769d
+2009-04-15T01:28:16.827957Z
+307
+kunnis
+has-props
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+28408
+
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/DebugTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/DebugTarget.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/DebugTarget.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/MakefileTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/MakefileTarget.cs.svn-base
new file mode 100644
index 0000000..05f6c06
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/MakefileTarget.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 13
+svn:mime-type
+V 13
+text/x-csharp
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/MonoDevelopTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/MonoDevelopTarget.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/MonoDevelopTarget.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/NAntTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/NAntTarget.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/NAntTarget.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/SharpDevelopTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/SharpDevelopTarget.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/SharpDevelopTarget.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/VS2002Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/VS2002Target.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/VS2002Target.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/VS2003Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/VS2003Target.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/VS2003Target.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/VS2005Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/VS2005Target.cs.svn-base
new file mode 100644
index 0000000..7b57b30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/VS2005Target.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 12
+svn:keywords
+V 23
+Author Date Id Revision
+END
diff --git a/Prebuild/src/Core/Targets/.svn/prop-base/XcodeTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/prop-base/XcodeTarget.cs.svn-base
new file mode 100644
index 0000000..05f6c06
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/prop-base/XcodeTarget.cs.svn-base
@@ -0,0 +1,9 @@
+K 13
+svn:eol-style
+V 6
+native
+K 13
+svn:mime-type
+V 13
+text/x-csharp
+END
diff --git a/Prebuild/src/Core/Targets/.svn/text-base/AutotoolsTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/AutotoolsTarget.cs.svn-base
new file mode 100644
index 0000000..e46b5a5
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/AutotoolsTarget.cs.svn-base
@@ -0,0 +1,1070 @@
+#region BSD License

+/*

+

+Copyright (c) 2004 - 2008

+Matthew Holmes        (matthew@wildfiregames.com),

+Dan     Moorehead     (dan05a@gmail.com),

+Dave    Hudson        (jendave@yahoo.com),

+C.J.    Adams-Collier (cjac@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 MIT X11 license

+

+/*

+ Portions of this file authored by Lluis Sanchez Gual

+

+ Copyright (C) 2006 Novell, Inc (http://www.novell.com)

+

+ Permission is hereby granted, free of charge, to any person obtaining

+ a copy of this software and associated documentation files (the

+ "Software"), to deal in the Software without restriction, including

+ without limitation the rights to use, copy, modify, merge, publish,

+ distribute, sublicense, and/or sell copies of the Software, and to

+ permit persons to whom the Software is furnished to do so, subject to

+ the following conditions:

+ 

+ The above copyright notice and this permission notice shall be

+ included in all copies or substantial portions of the Software.

+ 

+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+#endregion

+using System;

+using System.Collections.Generic;

+using System.IO;

+using System.Reflection;

+using System.Text;

+using System.Text.RegularExpressions;

+using System.Xml;

+using System.Xml.Xsl;

+using System.Net;

+using System.Diagnostics;

+

+using Prebuild.Core.Attributes;

+using Prebuild.Core.Interfaces;

+using Prebuild.Core.Nodes;

+using Prebuild.Core.Utilities;

+

+namespace Prebuild.Core.Targets

+{

+    public enum ClrVersion

+    {

+        Default,

+        Net_1_1,

+        Net_2_0

+    }

+

+    public class SystemPackage

+    {

+        string name;

+        string version;

+        string description;

+        string[] assemblies;

+        bool isInternal;

+        ClrVersion targetVersion;

+

+        public void Initialize(string name,

+                               string version,

+                               string description,

+                               string[] assemblies,

+                               ClrVersion targetVersion,

+                               bool isInternal)

+        {

+            this.isInternal = isInternal;

+            this.name = name;

+            this.version = version;

+            this.assemblies = assemblies;

+            this.description = description;

+            this.targetVersion = targetVersion;

+        }

+

+        public string Name

+        {

+            get { return name; }

+        }

+

+        public string Version

+        {

+            get { return version; }

+        }

+

+        public string Description

+        {

+            get { return description; }

+        }

+

+        public ClrVersion TargetVersion

+        {

+            get { return targetVersion; }

+        }

+

+        // The package is part of the mono SDK

+        public bool IsCorePackage

+        {

+            get { return name == "mono"; }

+        }

+

+        // The package has been registered by an add-in, and is not installed

+        // in the system.

+        public bool IsInternalPackage

+        {

+            get { return isInternal; }

+        }

+

+        public string[] Assemblies

+        {

+            get { return assemblies; }

+        }

+

+    }

+

+

+    /// <summary>

+    /// 

+    /// </summary>

+    [Target("autotools")]

+    public class AutotoolsTarget : ITarget

+    {

+        #region Fields

+

+        Kernel m_Kernel;

+        XmlDocument autotoolsDoc;

+        XmlUrlResolver xr;

+        System.Security.Policy.Evidence e;

+        readonly Dictionary<string, SystemPackage> assemblyPathToPackage = new Dictionary<string, SystemPackage>();

+        readonly Dictionary<string, string> assemblyFullNameToPath = new Dictionary<string, string>();

+        readonly Dictionary<string, SystemPackage> packagesHash = new Dictionary<string, SystemPackage>();

+        readonly List<SystemPackage> packages = new List<SystemPackage>();

+

+        #endregion

+

+        #region Private Methods

+

+        private static void mkdirDashP(string dirName)

+        {

+            DirectoryInfo di = new DirectoryInfo(dirName);

+            if (di.Exists)

+                return;

+

+            string parentDirName = System.IO.Path.GetDirectoryName(dirName);

+            DirectoryInfo parentDi = new DirectoryInfo(parentDirName);

+            if (!parentDi.Exists)

+                mkdirDashP(parentDirName);

+

+            di.Create();

+        }

+

+        private static void chkMkDir(string dirName)

+        {

+            System.IO.DirectoryInfo di =

+                new System.IO.DirectoryInfo(dirName);

+

+            if (!di.Exists)

+                di.Create();

+        }

+

+        private void transformToFile(string filename, XsltArgumentList argList, string nodeName)

+        {

+            // Create an XslTransform for this file

+            XslTransform templateTransformer =

+                new XslTransform();

+

+            // Load up the template

+            XmlNode templateNode =

+                autotoolsDoc.SelectSingleNode(nodeName + "/*");

+            templateTransformer.Load(templateNode.CreateNavigator(), xr, e);

+

+            // Create a writer for the transformed template

+            XmlTextWriter templateWriter =

+                new XmlTextWriter(filename, null);

+

+            // Perform transformation, writing the file

+            templateTransformer.Transform

+                (m_Kernel.CurrentDoc, argList, templateWriter, xr);

+        }

+

+        static string NormalizeAsmName(string name)

+        {

+            int i = name.IndexOf(", PublicKeyToken=null");

+            if (i != -1)

+                return name.Substring(0, i).Trim();

+            return name;

+        }

+

+        private void AddAssembly(string assemblyfile, SystemPackage package)

+        {

+            if (!File.Exists(assemblyfile))

+                return;

+

+            try

+            {

+                System.Reflection.AssemblyName an = System.Reflection.AssemblyName.GetAssemblyName(assemblyfile);

+                assemblyFullNameToPath[NormalizeAsmName(an.FullName)] = assemblyfile;

+                assemblyPathToPackage[assemblyfile] = package;

+            }

+            catch

+            {

+            }

+        }

+

+        private static List<string> GetAssembliesWithLibInfo(string line, string file)

+        {

+            List<string> references = new List<string>();

+            List<string> libdirs = new List<string>();

+            List<string> retval = new List<string>();

+            foreach (string piece in line.Split(' '))

+            {

+                if (piece.ToLower().Trim().StartsWith("/r:") || piece.ToLower().Trim().StartsWith("-r:"))

+                {

+                    references.Add(ProcessPiece(piece.Substring(3).Trim(), file));

+                }

+                else if (piece.ToLower().Trim().StartsWith("/lib:") || piece.ToLower().Trim().StartsWith("-lib:"))

+                {

+                    libdirs.Add(ProcessPiece(piece.Substring(5).Trim(), file));

+                }

+            }

+

+            foreach (string refrnc in references)

+            {

+                foreach (string libdir in libdirs)

+                {

+                    if (File.Exists(libdir + Path.DirectorySeparatorChar + refrnc))

+                    {

+                        retval.Add(libdir + Path.DirectorySeparatorChar + refrnc);

+                    }

+                }

+            }

+

+            return retval;

+        }

+

+        private static List<string> GetAssembliesWithoutLibInfo(string line, string file)

+        {

+            List<string> references = new List<string>();

+            foreach (string reference in line.Split(' '))

+            {

+                if (reference.ToLower().Trim().StartsWith("/r:") || reference.ToLower().Trim().StartsWith("-r:"))

+                {

+                    string final_ref = reference.Substring(3).Trim();

+                    references.Add(ProcessPiece(final_ref, file));

+                }

+            }

+            return references;

+        }

+

+        private static string ProcessPiece(string piece, string pcfile)

+        {

+            int start = piece.IndexOf("${");

+            if (start == -1)

+                return piece;

+

+            int end = piece.IndexOf("}");

+            if (end == -1)

+                return piece;

+

+            string variable = piece.Substring(start + 2, end - start - 2);

+            string interp = GetVariableFromPkgConfig(variable, Path.GetFileNameWithoutExtension(pcfile));

+            return ProcessPiece(piece.Replace("${" + variable + "}", interp), pcfile);

+        }

+

+        private static string GetVariableFromPkgConfig(string var, string pcfile)

+        {

+            ProcessStartInfo psi = new ProcessStartInfo("pkg-config");

+            psi.RedirectStandardOutput = true;

+            psi.UseShellExecute = false;

+            psi.Arguments = String.Format("--variable={0} {1}", var, pcfile);

+            Process p = new Process();

+            p.StartInfo = psi;

+            p.Start();

+            string ret = p.StandardOutput.ReadToEnd().Trim();

+            p.WaitForExit();

+            if (String.IsNullOrEmpty(ret))

+                return String.Empty;

+            return ret;

+        }

+

+        private void ParsePCFile(string pcfile)

+        {

+            // Don't register the package twice

+            string pname = Path.GetFileNameWithoutExtension(pcfile);

+            if (packagesHash.ContainsKey(pname))

+                return;

+

+            List<string> fullassemblies = null;

+            string version = "";

+            string desc = "";

+

+            SystemPackage package = new SystemPackage();

+

+            using (StreamReader reader = new StreamReader(pcfile))

+            {

+                string line;

+                while ((line = reader.ReadLine()) != null)

+                {

+                    string lowerLine = line.ToLower();

+                    if (lowerLine.StartsWith("libs:") && lowerLine.IndexOf(".dll") != -1)

+                    {

+                        string choppedLine = line.Substring(5).Trim();

+                        if (choppedLine.IndexOf("-lib:") != -1 || choppedLine.IndexOf("/lib:") != -1)

+                        {

+                            fullassemblies = GetAssembliesWithLibInfo(choppedLine, pcfile);

+                        }

+                        else

+                        {

+                            fullassemblies = GetAssembliesWithoutLibInfo(choppedLine, pcfile);

+                        }

+                    }

+                    else if (lowerLine.StartsWith("version:"))

+                    {

+                        // "version:".Length == 8

+                        version = line.Substring(8).Trim();

+                    }

+                    else if (lowerLine.StartsWith("description:"))

+                    {

+                        // "description:".Length == 12

+                        desc = line.Substring(12).Trim();

+                    }

+                }

+            }

+

+            if (fullassemblies == null)

+                return;

+

+            foreach (string assembly in fullassemblies)

+            {

+                AddAssembly(assembly, package);

+            }

+

+            package.Initialize(pname,

+                               version,

+                               desc,

+                               fullassemblies.ToArray(),

+                               ClrVersion.Default,

+                               false);

+            packages.Add(package);

+            packagesHash[pname] = package;

+        }

+

+        void RegisterSystemAssemblies(string prefix, string version, ClrVersion ver)

+        {

+            SystemPackage package = new SystemPackage();

+            List<string> list = new List<string>();

+

+            string dir = Path.Combine(prefix, version);

+            if (!Directory.Exists(dir))

+            {

+                return;

+            }

+

+            foreach (string assembly in Directory.GetFiles(dir, "*.dll"))

+            {

+                AddAssembly(assembly, package);

+                list.Add(assembly);

+            }

+

+            package.Initialize("mono",

+                               version,

+                               "The Mono runtime",

+                               list.ToArray(),

+                               ver,

+                               false);

+            packages.Add(package);

+        }

+

+        void RunInitialization()

+        {

+            string versionDir;

+

+            if (Environment.Version.Major == 1)

+            {

+                versionDir = "1.0";

+            }

+            else

+            {

+                versionDir = "2.0";

+            }

+

+            //Pull up assemblies from the installed mono system.

+            string prefix = Path.GetDirectoryName(typeof(int).Assembly.Location);

+

+            if (prefix.IndexOf(Path.Combine("mono", versionDir)) == -1)

+                prefix = Path.Combine(prefix, "mono");

+            else

+                prefix = Path.GetDirectoryName(prefix);

+

+            RegisterSystemAssemblies(prefix, "1.0", ClrVersion.Net_1_1);

+            RegisterSystemAssemblies(prefix, "2.0", ClrVersion.Net_2_0);

+

+            string search_dirs = Environment.GetEnvironmentVariable("PKG_CONFIG_PATH");

+            string libpath = Environment.GetEnvironmentVariable("PKG_CONFIG_LIBPATH");

+

+            if (String.IsNullOrEmpty(libpath))

+            {

+                string path_dirs = Environment.GetEnvironmentVariable("PATH");

+                foreach (string pathdir in path_dirs.Split(Path.PathSeparator))

+                {

+                    if (pathdir == null)

+                        continue;

+                    if (File.Exists(pathdir + Path.DirectorySeparatorChar + "pkg-config"))

+                    {

+                        libpath = Path.Combine(pathdir, "..");

+                        libpath = Path.Combine(libpath, "lib");

+                        libpath = Path.Combine(libpath, "pkgconfig");

+                        break;

+                    }

+                }

+            }

+            search_dirs += Path.PathSeparator + libpath;

+            if (!string.IsNullOrEmpty(search_dirs))

+            {

+                List<string> scanDirs = new List<string>();

+                foreach (string potentialDir in search_dirs.Split(Path.PathSeparator))

+                {

+                    if (!scanDirs.Contains(potentialDir))

+                        scanDirs.Add(potentialDir);

+                }

+                foreach (string pcdir in scanDirs)

+                {

+                    if (pcdir == null)

+                        continue;

+

+                    if (Directory.Exists(pcdir))

+                    {

+                        foreach (string pcfile in Directory.GetFiles(pcdir, "*.pc"))

+                        {

+                            ParsePCFile(pcfile);

+                        }

+                    }

+                }

+            }

+        }

+

+        private void WriteCombine(SolutionNode solution)

+        {

+            #region "Create Solution directory if it doesn't exist"

+            string solutionDir = Path.Combine(solution.FullPath,

+                                              Path.Combine("autotools",

+                                                           solution.Name));

+            chkMkDir(solutionDir);

+            #endregion

+

+            #region "Write Solution-level files"

+            XsltArgumentList argList = new XsltArgumentList();

+            argList.AddParam("solutionName", "", solution.Name);

+            // $solutionDir is $rootDir/$solutionName/

+            transformToFile(Path.Combine(solutionDir, "configure.ac"),

+                            argList, "/Autotools/SolutionConfigureAc");

+            transformToFile(Path.Combine(solutionDir, "Makefile.am"),

+                            argList, "/Autotools/SolutionMakefileAm");

+            transformToFile(Path.Combine(solutionDir, "autogen.sh"),

+                            argList, "/Autotools/SolutionAutogenSh");

+            #endregion

+

+            foreach (ProjectNode project in solution.ProjectsTableOrder)

+            {

+              m_Kernel.Log.Write(String.Format("Writing project: {0}",

+                                               project.Name));

+              WriteProject(solution, project);

+            }

+        }

+

+        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 solutionDir = Path.Combine(solution.FullPath, Path.Combine("autotools", solution.Name));

+            string projectDir = Path.Combine(solutionDir, project.Name);

+            string projectVersion = project.Version;

+            bool hasAssemblyConfig = false;

+            chkMkDir(projectDir);

+

+            List<string>

+                compiledFiles = new List<string>(),

+                contentFiles = new List<string>(),

+                embeddedFiles = new List<string>(),

+

+                binaryLibs = new List<string>(),

+                pkgLibs = new List<string>(),

+                systemLibs = new List<string>(),

+                runtimeLibs = new List<string>(),

+

+                extraDistFiles = new List<string>(),

+                localCopyTargets = new List<string>();

+

+            // If there exists a .config file for this assembly, copy

+            // it to the project folder

+

+            // TODO: Support copying .config.osx files

+            // TODO: support processing the .config file for native library deps

+            string projectAssemblyName = project.Name;

+            if (project.AssemblyName != null)

+                projectAssemblyName = project.AssemblyName;

+

+            if (File.Exists(Path.Combine(project.FullPath, projectAssemblyName) + ".dll.config"))

+            {

+                hasAssemblyConfig = true;

+                System.IO.File.Copy(Path.Combine(project.FullPath, projectAssemblyName + ".dll.config"), Path.Combine(projectDir, projectAssemblyName + ".dll.config"), true);

+                extraDistFiles.Add(project.AssemblyName + ".dll.config");

+            }

+

+            foreach (ConfigurationNode conf in project.Configurations)

+            {

+                if (conf.Options.KeyFile != string.Empty)

+                {

+                    // Copy snk file into the project's directory

+                    // Use the snk from the project directory directly

+                    string source = Path.Combine(project.FullPath, conf.Options.KeyFile);

+                    string keyFile = conf.Options.KeyFile;

+                    Regex re = new Regex(".*/");

+                    keyFile = re.Replace(keyFile, "");

+

+                    string dest = Path.Combine(projectDir, keyFile);

+                    // Tell the user if there's a problem copying the file

+                    try

+                    {

+                        mkdirDashP(System.IO.Path.GetDirectoryName(dest));

+                        System.IO.File.Copy(source, dest, true);

+                    }

+                    catch (System.IO.IOException e)

+                    {

+                        Console.WriteLine(e.Message);

+                    }

+                }

+            }

+

+            // Copy compiled, embedded and content files into the project's directory

+            foreach (string filename in project.Files)

+            {

+                string source = Path.Combine(project.FullPath, filename);

+                string dest = Path.Combine(projectDir, filename);

+

+                if (filename.Contains("AssemblyInfo.cs"))

+                {

+                    // If we've got an AssemblyInfo.cs, pull the version number from it

+                    string[] sources = { source };

+                    string[] args = { "" };

+                    Microsoft.CSharp.CSharpCodeProvider cscp =

+                        new Microsoft.CSharp.CSharpCodeProvider();

+

+                    string tempAssemblyFile = Path.Combine(Path.GetTempPath(), project.Name + "-temp.dll");

+                    System.CodeDom.Compiler.CompilerParameters cparam =

+                        new System.CodeDom.Compiler.CompilerParameters(args, tempAssemblyFile);

+                    

+                    System.CodeDom.Compiler.CompilerResults cr =

+                        cscp.CompileAssemblyFromFile(cparam, sources);

+

+                    foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors)

+                        Console.WriteLine("Error! '{0}'", error.ErrorText);

+

+                    try {

+                      string projectFullName = cr.CompiledAssembly.FullName;

+                      Regex verRegex = new Regex("Version=([\\d\\.]+)");

+                      Match verMatch = verRegex.Match(projectFullName);

+                      if (verMatch.Success)

+                        projectVersion = verMatch.Groups[1].Value;

+                    }catch{

+                      Console.WriteLine("Couldn't compile AssemblyInfo.cs");

+                    }

+

+                    // Clean up the temp file

+                    try

+                    {

+                        if (File.Exists(tempAssemblyFile))

+                            File.Delete(tempAssemblyFile);

+                    }

+                    catch 

+                    {

+                        Console.WriteLine("Error! '{0}'", e);

+                    }

+                   

+                }

+

+                // Tell the user if there's a problem copying the file

+                try

+                {

+                    mkdirDashP(System.IO.Path.GetDirectoryName(dest));

+                    System.IO.File.Copy(source, dest, true);

+                }

+                catch (System.IO.IOException e)

+                {

+                    Console.WriteLine(e.Message);

+                }

+

+                switch (project.Files.GetBuildAction(filename))

+                {

+                    case BuildAction.Compile:

+                        compiledFiles.Add(filename);

+                        break;

+                    case BuildAction.Content:

+                        contentFiles.Add(filename);

+                        extraDistFiles.Add(filename);

+                        break;

+                    case BuildAction.EmbeddedResource:

+                        embeddedFiles.Add(filename);

+                        break;

+                }

+            }

+

+            // Set up references

+            for (int refNum = 0; refNum < project.References.Count; refNum++)

+            {

+                ReferenceNode refr = project.References[refNum];

+                Assembly refAssembly = Assembly.LoadWithPartialName(refr.Name);

+

+                /* Determine which pkg-config (.pc) file refers to

+                   this assembly */

+

+                SystemPackage package = null;

+

+                if (packagesHash.ContainsKey(refr.Name))

+                {

+                  package = packagesHash[refr.Name];

+

+                }

+                else

+                {

+                    string assemblyFullName = string.Empty;

+                    if (refAssembly != null)

+                        assemblyFullName = refAssembly.FullName;

+

+                    string assemblyFileName = string.Empty;

+                    if (assemblyFullName != string.Empty &&

+                        assemblyFullNameToPath.ContainsKey(assemblyFullName)

+                        )

+                        assemblyFileName =

+                          assemblyFullNameToPath[assemblyFullName];

+

+                    if (assemblyFileName != string.Empty &&

+                        assemblyPathToPackage.ContainsKey(assemblyFileName)

+                        )

+                        package = assemblyPathToPackage[assemblyFileName];

+

+                }

+

+                /* If we know the .pc file and it is not "mono"

+                   (already in the path), add a -pkg: argument */

+

+                if (package != null &&

+                    package.Name != "mono" &&

+                    !pkgLibs.Contains(package.Name)

+                    )

+                    pkgLibs.Add(package.Name);

+

+                string fileRef =

+                  FindFileReference(refr.Name, (ProjectNode)refr.Parent);

+

+                if (refr.LocalCopy ||

+                    solution.ProjectsTable.ContainsKey(refr.Name) ||

+                    fileRef != null ||

+                    refr.Path != null

+                    )

+                {

+

+                    /* Attempt to copy the referenced lib to the

+                       project's directory */

+

+                    string filename = refr.Name + ".dll";

+                    string source = filename;

+                    if (refr.Path != null)

+                        source = Path.Combine(refr.Path, source);

+                    source = Path.Combine(project.FullPath, source);

+                    string dest = Path.Combine(projectDir, filename);

+

+                    /* Since we depend on this binary dll to build, we

+                     * will add a compile- time dependency on the

+                     * copied dll, and add the dll to the list of

+                     * files distributed with this package

+                     */

+

+                    binaryLibs.Add(refr.Name + ".dll");

+                    extraDistFiles.Add(refr.Name + ".dll");

+

+                    // TODO: Support copying .config.osx files

+                    // TODO: Support for determining native dependencies

+                    if (File.Exists(source + ".config"))

+                    {

+                        System.IO.File.Copy(source + ".config", Path.GetDirectoryName(dest), true);

+                        extraDistFiles.Add(refr.Name + ".dll.config");

+                    }

+

+                    try

+                    {

+                        System.IO.File.Copy(source, dest, true);

+                    }

+                    catch (System.IO.IOException)

+                    {

+                      if (solution.ProjectsTable.ContainsKey(refr.Name)){

+

+                        /* If an assembly is referenced, marked for

+                         * local copy, in the list of projects for

+                         * this solution, but does not exist, put a

+                         * target into the Makefile.am to build the

+                         * assembly and copy it to this project's

+                         * directory

+                         */

+

+                        ProjectNode sourcePrj =

+                          ((solution.ProjectsTable[refr.Name]));

+

+                        string target =

+                          String.Format("{0}:\n" +

+                                        "\t$(MAKE) -C ../{1}\n" +

+                                        "\tln ../{2}/$@ $@\n",

+                                        filename,

+                                        sourcePrj.Name,

+                                        sourcePrj.Name );

+

+                        localCopyTargets.Add(target);

+                      }

+                    }

+                }

+                else if( !pkgLibs.Contains(refr.Name) )

+                {

+                    // Else, let's assume it's in the GAC or the lib path

+                    string assemName = string.Empty;

+                    int index = refr.Name.IndexOf(",");

+

+                    if (index > 0)

+                        assemName = refr.Name.Substring(0, index);

+                    else

+                        assemName = refr.Name;

+

+                    m_Kernel.Log.Write(String.Format(

+                    "Warning: Couldn't find an appropriate assembly " +

+                    "for reference:\n'{0}'", refr.Name

+                                                     ));

+                    systemLibs.Add(assemName);

+                }

+            }

+

+            const string lineSep = " \\\n\t";

+            string compiledFilesString = string.Empty;

+            if (compiledFiles.Count > 0)

+                compiledFilesString =

+                    lineSep + string.Join(lineSep, compiledFiles.ToArray());

+

+            string embeddedFilesString = "";

+            if (embeddedFiles.Count > 0)

+                embeddedFilesString =

+                    lineSep + string.Join(lineSep, embeddedFiles.ToArray());

+

+            string contentFilesString = "";

+            if (contentFiles.Count > 0)

+                contentFilesString =

+                    lineSep + string.Join(lineSep, contentFiles.ToArray());

+

+            string extraDistFilesString = "";

+            if (extraDistFiles.Count > 0)

+                extraDistFilesString =

+                    lineSep + string.Join(lineSep, extraDistFiles.ToArray());

+

+            string pkgLibsString = "";

+            if (pkgLibs.Count > 0)

+                pkgLibsString =

+                    lineSep + string.Join(lineSep, pkgLibs.ToArray());

+

+            string binaryLibsString = "";

+            if (binaryLibs.Count > 0)

+                binaryLibsString =

+                    lineSep + string.Join(lineSep, binaryLibs.ToArray());

+

+            string systemLibsString = "";

+            if (systemLibs.Count > 0)

+                systemLibsString =

+                    lineSep + string.Join(lineSep, systemLibs.ToArray());

+

+            string localCopyTargetsString = "";

+            if (localCopyTargets.Count > 0)

+                localCopyTargetsString =

+                    string.Join("\n", localCopyTargets.ToArray());

+

+            string monoPath = "";

+            foreach (string runtimeLib in runtimeLibs)

+            {

+                monoPath += ":`pkg-config --variable=libdir " + runtimeLib + "`";

+            }

+

+            // Add the project name to the list of transformation

+            // parameters

+            XsltArgumentList argList = new XsltArgumentList();

+            argList.AddParam("projectName", "", project.Name);

+            argList.AddParam("solutionName", "", solution.Name);

+            argList.AddParam("assemblyName", "", projectAssemblyName);

+            argList.AddParam("compiledFiles", "", compiledFilesString);

+            argList.AddParam("embeddedFiles", "", embeddedFilesString);

+            argList.AddParam("contentFiles", "", contentFilesString);

+            argList.AddParam("extraDistFiles", "", extraDistFilesString);

+            argList.AddParam("pkgLibs", "", pkgLibsString);

+            argList.AddParam("binaryLibs", "", binaryLibsString);

+            argList.AddParam("systemLibs", "", systemLibsString);

+            argList.AddParam("monoPath", "", monoPath);

+            argList.AddParam("localCopyTargets", "", localCopyTargetsString);

+            argList.AddParam("projectVersion", "", projectVersion);

+            argList.AddParam("hasAssemblyConfig", "", hasAssemblyConfig ? "true" : "");

+

+            // Transform the templates

+            transformToFile(Path.Combine(projectDir, "configure.ac"), argList, "/Autotools/ProjectConfigureAc");

+            transformToFile(Path.Combine(projectDir, "Makefile.am"), argList, "/Autotools/ProjectMakefileAm");

+            transformToFile(Path.Combine(projectDir, "autogen.sh"), argList, "/Autotools/ProjectAutogenSh");

+

+            if (project.Type == Core.Nodes.ProjectType.Library)

+                transformToFile(Path.Combine(projectDir, project.Name + ".pc.in"), argList, "/Autotools/ProjectPcIn");

+            if (project.Type == Core.Nodes.ProjectType.Exe || project.Type == Core.Nodes.ProjectType.WinExe)

+                transformToFile(Path.Combine(projectDir, project.Name.ToLower() + ".in"), argList, "/Autotools/ProjectWrapperScriptIn");

+        }

+

+        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;

+            m_Kernel.Log.Write("Parsing system pkg-config files");

+            RunInitialization();

+

+            const string streamName = "autotools.xml";

+            string fqStreamName = String.Format("Prebuild.data.{0}",

+                                                streamName

+                                                );

+

+            // Retrieve stream for the autotools template XML

+            Stream autotoolsStream = Assembly.GetExecutingAssembly()

+                .GetManifestResourceStream(fqStreamName);

+

+            if(autotoolsStream == null) {

+

+              /* 

+               * try without the default namespace prepended, in

+               * case prebuild.exe assembly was compiled with

+               * something other than Visual Studio .NET

+               */

+

+              autotoolsStream = Assembly.GetExecutingAssembly()

+                .GetManifestResourceStream(streamName);

+              if(autotoolsStream == null){

+                string errStr =

+                  String.Format("Could not find embedded resource file:\n" +

+                                "'{0}' or '{1}'",

+                                streamName, fqStreamName

+                                );

+

+                m_Kernel.Log.Write(errStr);

+

+                throw new System.Reflection.TargetException(errStr);

+              }

+            }

+

+            // Create an XML URL Resolver with default credentials

+            xr = new System.Xml.XmlUrlResolver();

+            xr.Credentials = CredentialCache.DefaultCredentials;

+

+            // Create a default evidence - no need to limit access

+            e = new System.Security.Policy.Evidence();

+

+            // Load the autotools XML

+            autotoolsDoc = new XmlDocument();

+            autotoolsDoc.Load(autotoolsStream);

+

+            /* rootDir is the filesystem location where the Autotools

+             * build tree will be created - for now we'll make it

+             * $PWD/autotools

+             */

+

+            string pwd = Directory.GetCurrentDirectory();

+            //string pwd = System.Environment.GetEnvironmentVariable("PWD");

+            //if (pwd.Length != 0)

+            //{

+            string rootDir = Path.Combine(pwd, "autotools");

+            //}

+            //else

+            //{

+            //    pwd = Assembly.GetExecutingAssembly()

+            //}

+            chkMkDir(rootDir);

+

+            foreach (SolutionNode solution in kern.Solutions)

+            {

+              m_Kernel.Log.Write(String.Format("Writing solution: {0}",

+                                        solution.Name));

+              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/.svn/text-base/DebugTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/DebugTarget.cs.svn-base
new file mode 100644
index 0000000..3494c30
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/DebugTarget.cs.svn-base
@@ -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$
+ * $Date$
+ * $Revision$
+ */
+#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/.svn/text-base/MakefileTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/MakefileTarget.cs.svn-base
new file mode 100644
index 0000000..54046dd
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/MakefileTarget.cs.svn-base
@@ -0,0 +1,469 @@
+#region BSD License
+/*
+Copyright (c) 2004 Crestez Leonard (cleonard@go.ro)
+
+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
+
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+    [Target("makefile")]
+    public class MakefileTarget : ITarget
+    {
+        #region Fields
+
+        private Kernel m_Kernel = null;
+
+        #endregion
+
+        #region Private Methods
+
+        // This converts a path relative to the path of a project to
+        // a path relative to the solution path.
+        private string NicePath(ProjectNode proj, string path)
+        {
+            string res;
+            SolutionNode solution = (SolutionNode)proj.Parent;
+            res = Path.Combine(Helper.NormalizePath(proj.FullPath, '/'), Helper.NormalizePath(path, '/'));
+            res = Helper.NormalizePath(res, '/');
+            res = res.Replace("/./", "/");
+            while (res.IndexOf("/../") >= 0)
+            {
+                int a = res.IndexOf("/../");
+                int b = res.LastIndexOf("/", a - 1);
+                res = res.Remove(b, a - b + 3);
+            }
+            res = Helper.MakePathRelativeTo(solution.FullPath, res);
+            if (res.StartsWith("./"))
+                res = res.Substring(2, res.Length - 2);
+            res = Helper.NormalizePath(res, '/');
+            return res;
+        }
+
+        private void WriteProjectFiles(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            // Write list of source code files
+            f.WriteLine("SOURCES_{0} = \\", project.Name);
+            foreach (string file in project.Files)
+                if (project.Files.GetBuildAction(file) == BuildAction.Compile)
+                    f.WriteLine("\t{0} \\", NicePath(project, file));
+            f.WriteLine();
+
+            // Write list of resource files
+            f.WriteLine("RESOURCES_{0} = \\", project.Name);
+            foreach (string file in project.Files)
+                if (project.Files.GetBuildAction(file) == BuildAction.EmbeddedResource)
+                {
+                    string path = NicePath(project, file);
+                    f.WriteLine("\t-resource:{0},{1} \\", path, Path.GetFileName(path));
+                }
+            f.WriteLine();
+
+            // There's also Content and None in BuildAction.
+            // What am I supposed to do with that?
+        }
+
+        private string FindFileReference(string refName, ProjectNode project)
+        {
+            foreach (ReferencePathNode refPath in project.ReferencePaths)
+            {
+                string fullPath = NicePath(project, Helper.MakeFilePath(refPath.Path, refName, "dll"));
+                if (File.Exists(fullPath))
+                    return fullPath;
+            }
+            return null;
+        }
+
+        private void WriteProjectReferences(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            f.WriteLine("REFERENCES_{0} = \\", project.Name);
+            foreach (ReferenceNode refr in project.References)
+            {
+                string path;
+                // Project references change with configurations.
+                if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    continue;
+                path = FindFileReference(refr.Name, project);
+                if (path != null)
+                    f.WriteLine("\t-r:{0} \\", path);
+                else
+                    f.WriteLine("\t-r:{0} \\", refr.Name);
+            }
+            f.WriteLine();
+        }
+
+        private void WriteProjectDependencies(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            f.WriteLine("DEPENDENCIES_{0} = \\", project.Name);
+            f.WriteLine("\t$(SOURCES_{0}) \\", project.Name);
+            foreach (string file in project.Files)
+                if (project.Files.GetBuildAction(file) == BuildAction.EmbeddedResource)
+                    f.WriteLine("\t{0} \\", NicePath(project, file));
+            f.WriteLine();
+        }
+
+        private string ProjectTypeToExtension(ProjectType t)
+        {
+            if (t == ProjectType.Exe || t == ProjectType.WinExe)
+            {
+                return "exe";
+            }
+            else if (t == ProjectType.Library)
+            {
+                return "dll";
+            }
+            else
+            {
+                throw new FatalException("Bad ProjectType: {0}", t);
+            }
+        }
+
+        private string ProjectTypeToTarget(ProjectType t)
+        {
+            if (t == ProjectType.Exe)
+            {
+                return "exe";
+            }
+            else if (t == ProjectType.WinExe)
+            {
+                return "winexe";
+            }
+            else if (t == ProjectType.Library)
+            {
+                return "library";
+            }
+            else
+            {
+                throw new FatalException("Bad ProjectType: {0}", t);
+            }
+        }
+
+        private string ProjectOutput(ProjectNode project, ConfigurationNode config)
+        {
+            string filepath;
+            filepath = Helper.MakeFilePath((string)config.Options["OutputPath"],
+                    project.AssemblyName, ProjectTypeToExtension(project.Type));
+            return NicePath(project, filepath);
+        }
+
+        // Returns true if two configs in one project have the same output.
+        private bool ProjectClashes(ProjectNode project)
+        {
+            foreach (ConfigurationNode conf1 in project.Configurations)
+                foreach (ConfigurationNode conf2 in project.Configurations)
+                    if (ProjectOutput(project, conf1) == ProjectOutput(project, conf2) && conf1 != conf2)
+                    {
+                        m_Kernel.Log.Write("Warning: Configurations {0} and {1} for project {2} output the same file",
+                                conf1.Name, conf2.Name, project.Name);
+                        m_Kernel.Log.Write("Warning: I'm going to use some timestamps(extra empty files).");
+                        return true;
+                    }
+            return false;
+        }
+
+        private void WriteProject(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            f.WriteLine("# This is for project {0}", project.Name);
+            f.WriteLine();
+
+            WriteProjectFiles(f, solution, project);
+            WriteProjectReferences(f, solution, project);
+            WriteProjectDependencies(f, solution, project);
+
+            bool clash = ProjectClashes(project);
+
+            foreach (ConfigurationNode conf in project.Configurations)
+            {
+                string outpath = ProjectOutput(project, conf);
+                string filesToClean = outpath;
+
+                if (clash)
+                {
+                    f.WriteLine("{0}-{1}: .{0}-{1}-timestamp", project.Name, conf.Name);
+                    f.WriteLine();
+                    f.Write(".{0}-{1}-timestamp: $(DEPENDENCIES_{0})", project.Name, conf.Name);
+                }
+                else
+                {
+                    f.WriteLine("{0}-{1}: {2}", project.Name, conf.Name, outpath);
+                    f.WriteLine();
+                    f.Write("{2}: $(DEPENDENCIES_{0})", project.Name, conf.Name, outpath);
+                }
+                // Dependencies on other projects.
+                foreach (ReferenceNode refr in project.References)
+                    if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    {
+                        ProjectNode refProj = (ProjectNode)solution.ProjectsTable[refr.Name];
+                        if (ProjectClashes(refProj))
+                            f.Write(" .{0}-{1}-timestamp", refProj.Name, conf.Name);
+                        else
+                            f.Write(" {0}", ProjectOutput(refProj, conf));
+                    }
+                f.WriteLine();
+
+                // make directory for output.
+                if (Path.GetDirectoryName(outpath) != "")
+                {
+                    f.WriteLine("\tmkdir -p {0}", Path.GetDirectoryName(outpath));
+                }
+                // mcs command line.
+                f.Write("\tgmcs", project.Name);
+                f.Write(" -warn:{0}", conf.Options["WarningLevel"]);
+                if ((bool)conf.Options["DebugInformation"])
+                    f.Write(" -debug");
+                if ((bool)conf.Options["AllowUnsafe"])
+                    f.Write(" -unsafe");
+                if ((bool)conf.Options["CheckUnderflowOverflow"])
+                    f.Write(" -checked");
+                if (project.StartupObject != "")
+                    f.Write(" -main:{0}", project.StartupObject);
+                if ((string)conf.Options["CompilerDefines"] != "")
+                {
+                    f.Write(" -define:\"{0}\"", conf.Options["CompilerDefines"]);
+                }
+
+                f.Write(" -target:{0} -out:{1}", ProjectTypeToTarget(project.Type), outpath);
+
+                // Build references to other projects. Now that sux.
+                // We have to reference the other project in the same conf.
+                foreach (ReferenceNode refr in project.References)
+                    if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    {
+                        ProjectNode refProj;
+                        refProj = (ProjectNode)solution.ProjectsTable[refr.Name];
+                        f.Write(" -r:{0}", ProjectOutput(refProj, conf));
+                    }
+
+                f.Write(" $(REFERENCES_{0})", project.Name);
+                f.Write(" $(RESOURCES_{0})", project.Name);
+                f.Write(" $(SOURCES_{0})", project.Name);
+                f.WriteLine();
+
+                // Copy references with localcopy.
+                foreach (ReferenceNode refr in project.References)
+                    if (refr.LocalCopy)
+                    {
+                        string outPath, srcPath, destPath;
+                        outPath = Helper.NormalizePath((string)conf.Options["OutputPath"]);
+                        if (solution.ProjectsTable.ContainsKey(refr.Name))
+                        {
+                            ProjectNode refProj;
+                            refProj = (ProjectNode)solution.ProjectsTable[refr.Name];
+                            srcPath = ProjectOutput(refProj, conf);
+                            destPath = Path.Combine(outPath, Path.GetFileName(srcPath));
+                            destPath = NicePath(project, destPath);
+                            if (srcPath != destPath)
+                            {
+                                f.WriteLine("\tcp -f {0} {1}", srcPath, destPath);
+                                filesToClean += " " + destPath;
+                            }
+                            continue;
+                        }
+                        srcPath = FindFileReference(refr.Name, project);
+                        if (srcPath != null)
+                        {
+                            destPath = Path.Combine(outPath, Path.GetFileName(srcPath));
+                            destPath = NicePath(project, destPath);
+                            f.WriteLine("\tcp -f {0} {1}", srcPath, destPath);
+                            filesToClean += " " + destPath;
+                        }
+                    }
+
+                if (clash)
+                {
+                    filesToClean += String.Format(" .{0}-{1}-timestamp", project.Name, conf.Name);
+                    f.WriteLine("\ttouch .{0}-{1}-timestamp", project.Name, conf.Name);
+                    f.Write("\trm -rf");
+                    foreach (ConfigurationNode otherConf in project.Configurations)
+                        if (otherConf != conf)
+                            f.WriteLine(" .{0}-{1}-timestamp", project.Name, otherConf.Name);
+                    f.WriteLine();
+                }
+                f.WriteLine();
+                f.WriteLine("{0}-{1}-clean:", project.Name, conf.Name);
+                f.WriteLine("\trm -rf {0}", filesToClean);
+                f.WriteLine();
+            }
+        }
+
+        private void WriteIntro(StreamWriter f, SolutionNode solution)
+        {
+            f.WriteLine("# Makefile for {0} generated by Prebuild ( http://dnpb.sf.net )", solution.Name);
+            f.WriteLine("# Do not edit.");
+            f.WriteLine("#");
+
+            f.Write("# Configurations:");
+            foreach (ConfigurationNode conf in solution.Configurations)
+                f.Write(" {0}", conf.Name);
+            f.WriteLine();
+
+            f.WriteLine("# Projects:");
+            foreach (ProjectNode proj in solution.Projects)
+                f.WriteLine("#\t{0}", proj.Name);
+
+            f.WriteLine("#");
+            f.WriteLine("# Building:");
+            f.WriteLine("#\t\"make\" to build everything under the default(first) configuration");
+            f.WriteLine("#\t\"make CONF\" to build every project under configuration CONF");
+            f.WriteLine("#\t\"make PROJ\" to build project PROJ under the default(first) configuration");
+            f.WriteLine("#\t\"make PROJ-CONF\" to build project PROJ under configuration CONF");
+            f.WriteLine("#");
+            f.WriteLine("# Cleaning (removing results of build):");
+            f.WriteLine("#\t\"make clean\" to clean everything, that's what you probably want");
+            f.WriteLine("#\t\"make CONF\" to clean everything for a configuration");
+            f.WriteLine("#\t\"make PROJ\" to clean everything for a project");
+            f.WriteLine("#\t\"make PROJ-CONF\" to clea project PROJ under configuration CONF");
+            f.WriteLine();
+        }
+
+        private void WritePhony(StreamWriter f, SolutionNode solution)
+        {
+            string defconf = "";
+            foreach (ConfigurationNode conf in solution.Configurations)
+            {
+                defconf = conf.Name;
+                break;
+            }
+
+            f.Write(".PHONY: all");
+            foreach (ProjectNode proj in solution.Projects)
+                f.Write(" {0} {0}-clean", proj.Name);
+            foreach (ConfigurationNode conf in solution.Configurations)
+                f.Write(" {0} {0}-clean", conf.Name);
+            foreach (ProjectNode proj in solution.Projects)
+                foreach (ConfigurationNode conf in solution.Configurations)
+                    f.Write(" {0}-{1} {0}-{1}-clean", proj.Name, conf.Name);
+            f.WriteLine();
+            f.WriteLine();
+
+            f.WriteLine("all: {0}", defconf);
+            f.WriteLine();
+
+            f.Write("clean:");
+            foreach (ConfigurationNode conf in solution.Configurations)
+                f.Write(" {0}-clean", conf.Name);
+            f.WriteLine();
+            f.WriteLine();
+
+            foreach (ConfigurationNode conf in solution.Configurations)
+            {
+                f.Write("{0}: ", conf.Name);
+                foreach (ProjectNode proj in solution.Projects)
+                    f.Write(" {0}-{1}", proj.Name, conf.Name);
+                f.WriteLine();
+                f.WriteLine();
+
+                f.Write("{0}-clean: ", conf.Name);
+                foreach (ProjectNode proj in solution.Projects)
+                    f.Write(" {0}-{1}-clean", proj.Name, conf.Name);
+                f.WriteLine();
+                f.WriteLine();
+            }
+
+            foreach (ProjectNode proj in solution.Projects)
+            {
+                f.WriteLine("{0}: {0}-{1}", proj.Name, defconf);
+                f.WriteLine();
+
+                f.Write("{0}-clean:", proj.Name);
+                foreach (ConfigurationNode conf in proj.Configurations)
+                    f.Write(" {0}-{1}-clean", proj.Name, conf.Name);
+                f.WriteLine();
+                f.WriteLine();
+            }
+        }
+
+        private void WriteSolution(SolutionNode solution)
+        {
+            m_Kernel.Log.Write("Creating makefile for {0}", solution.Name);
+            m_Kernel.CurrentWorkingDirectory.Push();
+
+            string file = "Makefile";// Helper.MakeFilePath(solution.FullPath, solution.Name, "make");
+            StreamWriter f = new StreamWriter(file);
+
+            Helper.SetCurrentDir(Path.GetDirectoryName(file));
+
+            using (f)
+            {
+                WriteIntro(f, solution);
+                WritePhony(f, solution);
+
+                foreach (ProjectNode project in solution.Projects)
+                {
+                    m_Kernel.Log.Write("...Creating Project: {0}", project.Name);
+                    WriteProject(f, solution, project);
+                }
+            }
+
+            m_Kernel.Log.Write("");
+            m_Kernel.CurrentWorkingDirectory.Pop();
+        }
+
+        private void CleanSolution(SolutionNode solution)
+        {
+            m_Kernel.Log.Write("Cleaning makefile for {0}", solution.Name);
+
+            string file = Helper.MakeFilePath(solution.FullPath, solution.Name, "make");
+            Helper.DeleteIfExists(file);
+
+            m_Kernel.Log.Write("");
+        }
+
+        #endregion
+
+        #region ITarget Members
+
+        public void Write(Kernel kern)
+        {
+            m_Kernel = kern;
+            foreach (SolutionNode solution in kern.Solutions)
+                WriteSolution(solution);
+            m_Kernel = null;
+        }
+
+        public virtual void Clean(Kernel kern)
+        {
+            m_Kernel = kern;
+            foreach (SolutionNode sol in kern.Solutions)
+                CleanSolution(sol);
+            m_Kernel = null;
+        }
+
+        public string Name
+        {
+            get
+            {
+                return "makefile";
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/Prebuild/src/Core/Targets/.svn/text-base/MonoDevelopTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/MonoDevelopTarget.cs.svn-base
new file mode 100644
index 0000000..ea6d2c2
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/MonoDevelopTarget.cs.svn-base
@@ -0,0 +1,515 @@
+#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
+
+using System;
+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
+                                {
+                                        /*
+                                        Day changed to 28 Mar 2007
+                                        ...
+                                        08:09 < cj> is there anything that replaces Assembly.LoadFromPartialName() ?
+                                        08:09 < jonp> no
+                                        08:10 < jonp> in their infinite wisdom [sic], microsoft decided that the 
+                                                      ability to load any assembly version by-name was an inherently 
+                                                      bad idea
+                                        08:11 < cj> I'm thinking of a bunch of four-letter words right now...
+                                        08:11 < cj> security through making it difficult for the developer!!!
+                                        08:12 < jonp> just use the Obsolete API
+                                        08:12 < jonp> it should still work
+                                        08:12 < cj> alrighty.
+                                        08:12 < jonp> you just get warnings when using it
+                                        */
+                                        Assembly assem = Assembly.LoadWithPartialName(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=\"{0}\"", !conf.Options.WarningsAsErrors);
+                                        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;
+                                        string dependson = "";
+                                        string resource_id = "";
+                                        string copyToOutput = "";
+                                        
+                                        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;
+                                        }
+
+                    if (project.Files.GetCopyToOutput(file) != CopyToOutput.Never)
+                                                    buildAction = "FileCopy";
+
+                                        // Sort of a hack, we try and resolve the path and make it relative, if we can.
+                                        string extension = Path.GetExtension(file);
+                                        string designer_format = string.Format(".Designer{0}", extension);
+
+                                        if (file.EndsWith(designer_format))
+                                        {
+                                                string basename = file.Substring(0, file.LastIndexOf(designer_format));
+                                                string[] extensions = new string[] { ".cs", ".resx", ".settings" };
+
+                                                foreach(string ext in extensions)
+                                                {
+                                                        if (project.Files.Contains(basename + ext))
+                                                        {
+                                                                dependson = string.Format(" dependson=\"{0}{1}\"", basename, ext);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                        if (extension == ".resx")
+                                        {
+                                                buildAction = "EmbedAsResource";
+                                                string basename = file.Substring(0, file.LastIndexOf(".resx"));                                         
+                                                
+                                                // Visual Studio type resx + form dependency
+                                                if (project.Files.Contains(basename + ".cs"))
+                                                {
+                                                        dependson = string.Format(" dependson=\"{0}{1}\"", basename, ".cs");
+                                                }
+
+                                                // We need to specify a resources file name to avoid MissingManifestResourceExceptions
+                                                // in libraries that are built.
+                                                resource_id = string.Format(" resource_id=\"{0}.{1}.resources\"",
+                                                                project.AssemblyName, basename.Replace("/", "."));
+                                        }
+
+                                        switch(project.Files.GetCopyToOutput(file))
+                                        {
+                                                case CopyToOutput.Always:
+                                                        copyToOutput = string.Format(" copyToOutputDirectory=\"Always\"");
+                                                        break;
+                                                case CopyToOutput.PreserveNewest:
+                                                        copyToOutput = string.Format(" copyToOutputDirectory=\"PreserveNewest\"");
+                                                        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}\"{2}{3}{4} />", 
+                                                     filePath, buildAction, dependson, resource_id, copyToOutput);
+                                }
+                                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/.svn/text-base/NAntTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/NAntTarget.cs.svn-base
new file mode 100644
index 0000000..1efc16d
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/NAntTarget.cs.svn-base
@@ -0,0 +1,776 @@
+#region BSD License
+/*
+Copyright (c) 2004 - 2008
+Matthew Holmes            (matthew@wildfiregames.com),
+Dan             Moorehead         (dan05a@gmail.com),
+C.J.    Adams-Collier (cjac@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
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+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)
+        {
+
+            if (!String.IsNullOrEmpty(refr.Path))
+            {
+                return refr.Path;
+            }
+            
+            if (solution.ProjectsTable.ContainsKey(refr.Name))
+            {
+                ProjectNode projectRef = (ProjectNode) solution.ProjectsTable[refr.Name];
+                string finalPath =
+                    Helper.NormalizePath(refr.Name + GetProjectExtension(projectRef), '/');
+                return finalPath;
+            }
+
+            ProjectNode project = (ProjectNode) refr.Parent;
+
+            // Do we have an explicit file reference?
+            string fileRef = FindFileReference(refr.Name, project);
+            if (fileRef != null)
+            {
+                return fileRef;
+            }
+
+            // Is there an explicit path in the project ref?
+            if (refr.Path != null)
+            {
+                return Helper.NormalizePath(refr.Path + "/" + refr.Name + GetProjectExtension(project), '/');
+            }
+
+            // No, it's an extensionless GAC ref, but nant needs the .dll extension anyway
+            return refr.Name + ".dll";
+        }
+
+            public static string GetRefFileName(string refName)
+        {
+            if (ExtensionSpecified(refName))
+            {
+                return refName;
+            }
+            else
+            {
+                return refName + ".dll";
+            }
+        }
+
+        private static bool ExtensionSpecified(string refName)
+        {
+            return refName.EndsWith(".dll") || refName.EndsWith(".exe");
+        }
+
+        private static string GetProjectExtension(ProjectNode project)
+        {
+            string extension = ".dll";
+            if (project.Type == ProjectType.Exe || project.Type == ProjectType.WinExe)
+            {
+                extension = ".exe";
+            }
+            return extension;
+        }
+
+                private static string FindFileReference(string refName, ProjectNode project)
+                {
+                        foreach (ReferencePathNode refPath in project.ReferencePaths)
+                        {
+                            string fullPath = Helper.MakeFilePath(refPath.Path, refName);
+
+                if (File.Exists(fullPath))
+                {
+                    return fullPath;
+                }
+
+                fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
+
+                                if (File.Exists(fullPath))
+                                {
+                                        return fullPath;
+                                }
+
+                fullPath = Helper.MakeFilePath(refPath.Path, refName, "exe");
+
+                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 + GetProjectExtension(project), "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}\" flatten=\"true\">");
+                                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>");
+                                if (project.ConfigFile != null && project.ConfigFile.Length!=0)
+                                {
+                                        ss.Write("                <copy file=\"" + project.ConfigFile + "\" tofile=\"${project::get-base-directory()}/${build.dir}/${project::get-name()}");
+
+                                        if (project.Type == ProjectType.Library)
+                                        {
+                                                ss.Write(".dll.config\"");
+                                        }
+                                        else
+                                        {
+                                                ss.Write(".exe.config\"");
+                                        }
+                                        ss.WriteLine(" />");
+                                }
+
+                                // Add the content files to just be copied
+                                ss.WriteLine("            {0}", "<copy todir=\"${project::get-base-directory()}/${build.dir}\">");
+                                ss.WriteLine("                    {0}", "<fileset basedir=\".\">");
+                                
+                                foreach (string file in project.Files)
+                                {
+                                        // Ignore if we aren't content
+                                        if (project.Files.GetBuildAction(file) != BuildAction.Content)
+                                                        continue;
+
+                                        // Create a include tag
+                                        ss.WriteLine("                            {0}", "<include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
+                                }
+
+                                ss.WriteLine("                    {0}", "</fileset>");
+                                ss.WriteLine("            {0}", "</copy>");
+
+                                ss.Write("                <csc ");
+                                ss.Write(" target=\"{0}\"", project.Type.ToString().ToLower());
+                                ss.Write(" debug=\"{0}\"", "${build.debug}");
+                                ss.Write(" platform=\"${build.platform}\"");
+
+
+                                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(" warnaserror=\"{0}\"", conf.Options.WarningsAsErrors);
+                                        break;
+                                }
+                                foreach (ConfigurationNode conf in project.Configurations)
+                                {
+                                        ss.Write(" define=\"{0}\"", conf.Options.CompilerDefines);
+                                        break;
+                                }
+                                foreach (ConfigurationNode conf in project.Configurations)
+                                {
+                                        ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]);
+                                        break;
+                                }
+
+                                ss.Write(" main=\"{0}\"", project.StartupObject);
+
+                                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, '/'));
+                                }
+                // This disables a very different behavior between VS and NAnt.  With Nant,
+                //    If you have using System.Xml;  it will ensure System.Xml.dll is referenced,
+                //    but not in VS.  This will force the behaviors to match, so when it works
+                //    in nant, it will work in VS.
+                ss.Write(" noconfig=\"true\"");
+                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()}\" />");
+                foreach(ReferencePathNode refPath in project.ReferencePaths)
+                {
+                    ss.WriteLine("                                        <include name=\"${project::get-base-directory()}/" + refPath.Path.TrimEnd('/', '\\') + "\" />");
+                }
+                                ss.WriteLine("                            </lib>");
+                                foreach (ReferenceNode refr in project.References)
+                                {
+                                        string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr)), '/');
+                    if (refr.Path != null) {
+                        if (ExtensionSpecified(refr.Name))
+                        {
+                            ss.WriteLine ("                <include name=\"" + path + refr.Name + "\"/>");
+                        }
+                        else
+                        {
+                            ss.WriteLine ("                <include name=\"" + path + refr.Name + ".dll\"/>");
+                        }
+                    }
+                    else
+                    {
+                        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("                <include name=\"*.mdb\" if='${build.debug}'/>");
+                        ss.WriteLine("                <include name=\"*.pdb\" if='${build.debug}'/>");
+                        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()}\" />");
+
+                                // Use the active configuration, which is the first configuration name in the prebuild file.
+                                Dictionary<string,string> emittedConfigurations = new Dictionary<string, string>();
+
+                                ss.WriteLine("    <property name=\"project.config\" value=\"{0}\" />", solution.ActiveConfig);
+                                ss.WriteLine();
+
+                                foreach (ConfigurationNode conf in solution.Configurations)
+                                {
+                                        // If the name isn't in the emitted configurations, we give a high level target to the 
+                                        // platform specific on. This lets "Debug" point to "Debug-AnyCPU".
+                                        if (!emittedConfigurations.ContainsKey(conf.Name))
+                                        {
+                                                // Add it to the dictionary so we only emit one.
+                                                emittedConfigurations.Add(conf.Name, conf.Platform);
+
+                                                // Write out the target block.
+                                                ss.WriteLine("    <target name=\"{0}\" description=\"{0}|{1}\" depends=\"{0}-{1}\">", conf.Name, conf.Platform);
+                                                ss.WriteLine("    </target>");
+                                                ss.WriteLine();
+                                        }
+
+                                        // Write out the target for the configuration.
+                                        ss.WriteLine("    <target name=\"{0}-{1}\" description=\"{0}|{1}\">", conf.Name, conf.Platform);
+                                        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("\t\t  <property name=\"build.platform\" value=\"{0}\" />", conf.Platform);
+                                        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=\"net-3.5\" description=\"Sets framework to .NET 3.5\">");
+                                ss.WriteLine("            <property name=\"nant.settings.currentframework\" value=\"net-3.5\" />");
+                                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=\"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-3.5\" description=\"Sets framework to mono 3.5\">");
+                                ss.WriteLine("        <property name=\"nant.settings.currentframework\" value=\"mono-3.5\" />");
+                                ss.WriteLine("    </target>");
+                                ss.WriteLine();
+
+                ss.WriteLine("    <target name=\"init\" description=\"\">");
+                ss.WriteLine("        <call target=\"${project.config}\" />");
+                ss.WriteLine("        <property name=\"sys.os.platform\"");
+                ss.WriteLine("                  value=\"${platform::get-name()}\"");
+                ss.WriteLine("                  />");
+                ss.WriteLine("        <echo message=\"Platform ${sys.os.platform}\" />");
+                ss.WriteLine("        <property name=\"build.dir\" value=\"${bin.dir}/${project.config}\" />");
+                ss.WriteLine("    </target>");
+                ss.WriteLine();
+
+
+                // sdague - ok, this is an ugly hack, but what it lets
+                // us do is native include of files into the nant
+                // created files from all .nant/*include files.  This
+                // lets us keep using prebuild, but allows for
+                // extended nant targets to do build and the like.
+
+                try
+                {
+                    Regex re = new Regex(".include$");
+                    DirectoryInfo nantdir = new DirectoryInfo(".nant");
+                    foreach (FileSystemInfo item in nantdir.GetFileSystemInfos())
+                    {
+                        if (item is DirectoryInfo) { }
+                        else if (item is FileInfo)
+                        {
+                            if (re.Match(item.FullName) !=
+                                System.Text.RegularExpressions.Match.Empty)
+                            {
+                                Console.WriteLine("Including file: " + item.FullName);
+
+                                using (FileStream fs = new FileStream(item.FullName,
+                                                                      FileMode.Open,
+                                                                      FileAccess.Read,
+                                                                      FileShare.None))
+                                {
+                                    using (StreamReader sr = new StreamReader(fs))
+                                    {
+                                        ss.WriteLine("<!-- included from {0} -->", (item).FullName);
+                                        while (sr.Peek() != -1)
+                                        {
+                                            ss.WriteLine(sr.ReadLine());
+                                        }
+                                        ss.WriteLine();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch { }
+                // ss.WriteLine("   <include buildfile=\".nant/local.include\" />");
+                //                 ss.WriteLine("    <target name=\"zip\" description=\"\">");
+                //                 ss.WriteLine("       <zip zipfile=\"{0}-{1}.zip\">", solution.Name, solution.Version);
+                //                 ss.WriteLine("       <fileset basedir=\"${project::get-base-directory()}\">");
+
+                //                 ss.WriteLine("       <include name=\"${project::get-base-directory()}/**/*.cs\" />");
+                //                 // ss.WriteLine("       <include name=\"${project.main.dir}/**/*\" />");
+                //                 ss.WriteLine("       </fileset>");
+                //                 ss.WriteLine("       </zip>");
+                //                 ss.WriteLine("        <echo message=\"Building zip target\" />");
+                //                 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\" />");
+                if (solution.Cleanup != null && solution.Cleanup.CleanFiles.Count > 0)
+                {
+                    foreach (CleanFilesNode cleanFile in solution.Cleanup.CleanFiles)
+                    {
+                        ss.WriteLine("        <delete failonerror=\"false\">");
+                        ss.WriteLine("            <fileset basedir=\"${project::get-base-directory()}\">");
+                        ss.WriteLine("                <include name=\"{0}/*\"/>", cleanFile.Pattern);
+                        ss.WriteLine("                <include name=\"{0}\"/>", cleanFile.Pattern);
+                        ss.WriteLine("            </fileset>");
+                        ss.WriteLine("        </delete>");
+                    }
+                }
+                            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 + GetProjectExtension(project), "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 + GetProjectExtension(project), "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 + GetProjectExtension(project), "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 + GetProjectExtension(project), "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/.svn/text-base/SharpDevelop2Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/SharpDevelop2Target.cs.svn-base
new file mode 100644
index 0000000..66dd1bc
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/SharpDevelop2Target.cs.svn-base
@@ -0,0 +1,82 @@
+#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
+
+using System;
+
+using Prebuild.Core.Attributes;
+
+namespace Prebuild.Core.Targets
+{
+        /// <summary>
+        /// 
+        /// </summary>
+        [Target("sharpdev2")]
+        public class SharpDevelop2Target : VS2005Target
+    {
+        #region Properties
+        public override string VersionName
+        {
+            get
+            {
+                return "SharpDevelop2";
+            }
+        }
+        #endregion
+
+                #region Public Methods
+
+                /// <summary>
+                /// Writes the specified kern.
+                /// </summary>
+                /// <param name="kern">The kern.</param>
+                public override void Write(Kernel kern)
+                {
+                        base.Write(kern);
+                }
+
+                /// <summary>
+                /// Cleans the specified kern.
+                /// </summary>
+                /// <param name="kern">The kern.</param>
+                public override void Clean(Kernel kern)
+                {
+                        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/.svn/text-base/SharpDevelopTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/SharpDevelopTarget.cs.svn-base
new file mode 100644
index 0000000..8e32050
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/SharpDevelopTarget.cs.svn-base
@@ -0,0 +1,425 @@
+#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
+
+using System;
+using System.IO;
+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("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/.svn/text-base/ToolInfo.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/ToolInfo.cs.svn-base
new file mode 100644
index 0000000..935c674
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/ToolInfo.cs.svn-base
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+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;
+                        }
+                }
+                public string LanguageExtension
+                {
+                        get
+                        {
+                                switch (this.Name)
+                                {
+                                        case "C#":
+                                                return ".cs";
+                                        case "VisualBasic":
+                                                return ".vb";
+                                        case "Boo":
+                                                return ".boo";
+                                        default:
+                                                return ".cs";
+                                }
+                        }
+                }
+                /// <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();
+
+                }
+        }
+}
diff --git a/Prebuild/src/Core/Targets/.svn/text-base/VS2002Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VS2002Target.cs.svn-base
new file mode 100644
index 0000000..2292624
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VS2002Target.cs.svn-base
@@ -0,0 +1,87 @@
+#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
+
+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/.svn/text-base/VS2003Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VS2003Target.cs.svn-base
new file mode 100644
index 0000000..10e2dc4
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VS2003Target.cs.svn-base
@@ -0,0 +1,593 @@
+#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
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+        [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;
+
+            readonly Dictionary<string, ToolInfo> m_Tools = new Dictionary<string, ToolInfo>();
+                Kernel m_Kernel;
+
+                /// <summary>
+                /// Gets or sets the solution version.
+                /// </summary>
+                /// <value>The solution version.</value>
+                protected string SolutionVersion
+                {
+                        get
+                        {
+                                return solutionVersion;
+                        }
+                        set
+                        {
+                                solutionVersion = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the product version.
+                /// </summary>
+                /// <value>The product version.</value>
+                protected string ProductVersion
+                {
+                        get
+                        {
+                                return productVersion;
+                        }
+                        set
+                        {
+                                productVersion = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the schema version.
+                /// </summary>
+                /// <value>The schema version.</value>
+                protected string SchemaVersion
+                {
+                        get
+                        {
+                                return schemaVersion;
+                        }
+                        set
+                        {
+                                schemaVersion = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the name of the version.
+                /// </summary>
+                /// <value>The name of the version.</value>
+                protected string VersionName
+                {
+                        get
+                        {
+                                return versionName;
+                        }
+                        set
+                        {
+                                versionName = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the version.
+                /// </summary>
+                /// <value>The version.</value>
+                protected VSVersion Version
+                {
+                        get
+                        {
+                                return version;
+                        }
+                        set
+                        {
+                                version = value;
+                        }
+                }
+
+                #endregion
+
+                #region Constructors
+
+                /// <summary>
+                /// Initializes a new instance of the <see cref="VS2003Target"/> class.
+                /// </summary>
+                public VS2003Target()
+                {
+                        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 = 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));
+
+                        using(ps)
+                        {
+                                ps.WriteLine("<VisualStudioProject>");
+                                ps.WriteLine("    <{0}", toolInfo.XmlTag);
+                                ps.WriteLine("\t\t\t\tProjectType = \"Local\"");
+                                ps.WriteLine("\t\t\t\tProductVersion = \"{0}\"", ProductVersion);
+                                ps.WriteLine("\t\t\t\tSchemaVersion = \"{0}\"", 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(Version == VSVersion.VS70)
+                                {
+                                        ps.WriteLine("\t\t\t\t  NoStandardLibraries = \"false\"");
+                                }
+
+                                ps.WriteLine("\t\t\t\t  OutputType = \"{0}\"", project.Type);
+
+                                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(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 = solution.ProjectsTable[refr.Name];
+                                                ps.WriteLine("                    Project = \"{{{0}}}\"", refProject.Guid.ToString().ToUpper());
+                                                ps.WriteLine("                    Package = \"{0}\"", toolInfo.Guid.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", 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}", SolutionVersion);
+                                foreach(ProjectNode project in solution.Projects)
+                                {
+                                        if(!m_Tools.ContainsKey(project.Language))
+                                        {
+                                                throw new UnknownLanguageException("Unknown .NET language: " + project.Language);
+                                        }
+
+                                        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 = project.References[i];
+                                                if(solution.ProjectsTable.ContainsKey(refr.Name))
+                                                {
+                                                        ProjectNode refProject = 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 = 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", 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/.svn/text-base/VS2005Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VS2005Target.cs.svn-base
new file mode 100644
index 0000000..9c70e26
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VS2005Target.cs.svn-base
@@ -0,0 +1,147 @@
+#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
+
+using System;
+using System.IO;
+using System.Text;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [Target("vs2005")]
+    public class VS2005Target : VSGenericTarget
+    {
+        #region Inner Classes
+
+        #endregion
+
+        #region Fields
+
+        string solutionVersion = "9.00";
+        string productVersion = "8.0.50727";
+        string schemaVersion = "2.0";
+        string versionName = "Visual C# 2005";
+        string name = "vs2005";
+
+        VSVersion version = VSVersion.VS80;
+
+        public override string SolutionTag
+        {
+            get { return "# Visual Studio 2005"; }
+        }
+
+        protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
+        {
+            return string.Empty;
+        }
+        /// <summary>
+        /// Gets or sets the solution version.
+        /// </summary>
+        /// <value>The solution version.</value>
+        public override string SolutionVersion
+        {
+            get
+            {
+                return solutionVersion;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the product version.
+        /// </summary>
+        /// <value>The product version.</value>
+        public override string ProductVersion
+        {
+            get
+            {
+                return productVersion;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the schema version.
+        /// </summary>
+        /// <value>The schema version.</value>
+        public override string SchemaVersion
+        {
+            get
+            {
+                return schemaVersion;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the name of the version.
+        /// </summary>
+        /// <value>The name of the version.</value>
+        public override string VersionName
+        {
+            get
+            {
+                return versionName;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the version.
+        /// </summary>
+        /// <value>The version.</value>
+        public override VSVersion Version
+        {
+            get
+            {
+                return version;
+            }
+        }
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        public override string Name
+        {
+            get
+            {
+                return name;
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VS2005Target"/> class.
+        /// </summary>
+        public VS2005Target() 
+            : base()
+        {          
+        }
+
+        #endregion
+    }
+}
diff --git a/Prebuild/src/Core/Targets/.svn/text-base/VS2008Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VS2008Target.cs.svn-base
new file mode 100644
index 0000000..fee4f7f
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VS2008Target.cs.svn-base
@@ -0,0 +1,127 @@
+using System;
+using System.IO;
+using System.Text;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+using System.CodeDom.Compiler;
+
+namespace Prebuild.Core.Targets
+{
+
+        /// <summary>
+        /// 
+        /// </summary>
+        [Target("vs2008")]
+        public class VS2008Target : VSGenericTarget
+        {
+                #region Fields
+                string solutionVersion = "10.00";
+                string productVersion = "9.0.21022";
+                string schemaVersion = "2.0";
+                string versionName = "Visual Studio 2008";
+                string name = "vs2008";
+                VSVersion version = VSVersion.VS90;
+
+                /// <summary>
+                /// Gets or sets the solution version.
+                /// </summary>
+                /// <value>The solution version.</value>
+                public override string SolutionVersion
+                {
+                        get
+                        {
+                                return solutionVersion;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the product version.
+                /// </summary>
+                /// <value>The product version.</value>
+                public override string ProductVersion
+                {
+                        get
+                        {
+                                return productVersion;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the schema version.
+                /// </summary>
+                /// <value>The schema version.</value>
+                public override string SchemaVersion
+                {
+                        get
+                        {
+                                return schemaVersion;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the name of the version.
+                /// </summary>
+                /// <value>The name of the version.</value>
+                public override string VersionName
+                {
+                        get
+                        {
+                                return versionName;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the version.
+                /// </summary>
+                /// <value>The version.</value>
+                public override VSVersion Version
+                {
+                        get
+                        {
+                                return version;
+                        }
+                }
+                /// <summary>
+                /// Gets the name.
+                /// </summary>
+                /// <value>The name.</value>
+                public override string Name
+                {
+                        get
+                        {
+                                return name;
+                        }
+                }
+
+        protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
+        {
+            switch (frameworkVersion)
+            {
+                case FrameworkVersion.v3_5:
+                    return "ToolsVersion=\"3.5\"";
+                case FrameworkVersion.v3_0:
+                    return "ToolsVersion=\"3.0\"";
+                default:
+                    return "ToolsVersion=\"2.0\"";
+            }
+        }
+
+        public override string SolutionTag
+        {
+            get { return "# Visual Studio 2008"; }
+        }
+
+            #endregion
+
+                #region Constructors
+
+                /// <summary>
+                /// Initializes a new instance of the <see cref="VS2005Target"/> class.
+                /// </summary>
+                public VS2008Target()
+                        : base()
+                {
+                }
+
+                #endregion
+        }
+}
diff --git a/Prebuild/src/Core/Targets/.svn/text-base/VS2010Target.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VS2010Target.cs.svn-base
new file mode 100644
index 0000000..ea9f736
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VS2010Target.cs.svn-base
@@ -0,0 +1,138 @@
+using System;

+using System.IO;

+using System.Text;

+

+using Prebuild.Core.Attributes;

+using Prebuild.Core.Interfaces;

+using Prebuild.Core.Nodes;

+using Prebuild.Core.Utilities;

+using System.CodeDom.Compiler;

+

+namespace Prebuild.Core.Targets

+{

+

+        /// <summary>

+        /// 

+        /// </summary>

+        [Target("vs2010")]

+        public class VS2010Target : VSGenericTarget

+        {

+                #region Fields

+                

+                string solutionVersion = "11.00";

+                string productVersion = "9.0.30729";

+                string schemaVersion = "2.0";

+                string versionName = "Visual Studio 2010";

+                string name = "vs2010";

+                VSVersion version = VSVersion.VS10;

+

+                #endregion

+                

+                #region Properties

+                

+                /// <summary>

+                /// Gets or sets the solution version.

+                /// </summary>

+                /// <value>The solution version.</value>

+                public override string SolutionVersion

+                {

+                        get

+                        {

+                                return solutionVersion;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the product version.

+                /// </summary>

+                /// <value>The product version.</value>

+                public override string ProductVersion

+                {

+                        get

+                        {

+                                return productVersion;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the schema version.

+                /// </summary>

+                /// <value>The schema version.</value>

+                public override string SchemaVersion

+                {

+                        get

+                        {

+                                return schemaVersion;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the name of the version.

+                /// </summary>

+                /// <value>The name of the version.</value>

+                public override string VersionName

+                {

+                        get

+                        {

+                                return versionName;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the version.

+                /// </summary>

+                /// <value>The version.</value>

+                public override VSVersion Version

+                {

+                        get

+                        {

+                                return version;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets the name.

+                /// </summary>

+                /// <value>The name.</value>

+                public override string Name

+                {

+                        get

+                        {

+                                return name;

+                        }

+                }

+

+        protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)

+        {

+            switch (frameworkVersion)

+            {

+                case FrameworkVersion.v4_0:

+                case FrameworkVersion.v3_5:

+                        return "ToolsVersion=\"4.0\"";

+                case FrameworkVersion.v3_0:

+                    return "ToolsVersion=\"3.0\"";

+                default:

+                    return "ToolsVersion=\"2.0\"";

+            }

+        }

+

+        public override string SolutionTag

+        {

+            get { return "# Visual Studio 2010"; }

+        }

+

+            #endregion

+

+                #region Constructors

+

+                /// <summary>

+                /// Initializes a new instance of the <see cref="VS2005Target"/> class.

+                /// </summary>

+                public VS2010Target()

+                        : base()

+                {

+                }

+

+                #endregion

+        }

+}

diff --git a/Prebuild/src/Core/Targets/.svn/text-base/VSGenericTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VSGenericTarget.cs.svn-base
new file mode 100644
index 0000000..6969dd7
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VSGenericTarget.cs.svn-base
@@ -0,0 +1,922 @@
+#region BSD License

+/*

+Copyright (c) 2008 Matthew Holmes (matthew@wildfiregames.com), John Anderson (sontek@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

+

+using System;

+using System.Collections.Generic;

+using System.IO;

+using Prebuild.Core.Interfaces;

+using Prebuild.Core.Nodes;

+using Prebuild.Core.Utilities;

+using System.CodeDom.Compiler;

+

+namespace Prebuild.Core.Targets

+{

+

+        /// <summary>

+        /// 

+        /// </summary>

+        public abstract class VSGenericTarget : ITarget

+        {

+                #region Fields

+

+                readonly Dictionary<string, ToolInfo> tools = new Dictionary<string, ToolInfo>();

+                Kernel kernel;

+                #endregion

+

+                #region Properties

+                /// <summary>

+                /// Gets or sets the solution version.

+                /// </summary>

+                /// <value>The solution version.</value>

+                public abstract string SolutionVersion { get; }

+                /// <summary>

+                /// Gets or sets the product version.

+                /// </summary>

+                /// <value>The product version.</value>

+                public abstract string ProductVersion { get; }

+                /// <summary>

+                /// Gets or sets the schema version.

+                /// </summary>

+                /// <value>The schema version.</value>

+                public abstract string SchemaVersion { get; }

+                /// <summary>

+                /// Gets or sets the name of the version.

+                /// </summary>

+                /// <value>The name of the version.</value>

+                public abstract string VersionName { get; }

+                /// <summary>

+                /// Gets or sets the version.

+                /// </summary>

+                /// <value>The version.</value>

+                public abstract VSVersion Version { get; }

+                /// <summary>

+                /// Gets the name.

+                /// </summary>

+                /// <value>The name.</value>

+                public abstract string Name { get; }

+

+                protected abstract string GetToolsVersionXml(FrameworkVersion version);

+                public abstract string SolutionTag { get; }

+

+                #endregion

+

+                #region Constructors

+

+                /// <summary>

+                /// Initializes a new instance of the <see cref="VSGenericTarget"/> class.

+                /// </summary>

+                protected VSGenericTarget()

+                {

+                        tools["C#"] = new ToolInfo("C#", "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}", "csproj", "CSHARP", "$(MSBuildBinPath)\\Microsoft.CSHARP.Targets");

+                        tools["Database"] = new ToolInfo("Database", "{4F174C21-8C12-11D0-8340-0000F80270F8}", "dbp", "UNKNOWN");

+                        tools["Boo"] = new ToolInfo("Boo", "{45CEA7DC-C2ED-48A6-ACE0-E16144C02365}", "booproj", "Boo", "$(BooBinPath)\\Boo.Microsoft.Build.targets");

+                        tools["VisualBasic"] = new ToolInfo("VisualBasic", "{F184B08F-C81C-45F6-A57F-5ABD9991F28F}", "vbproj", "VisualBasic", "$(MSBuildBinPath)\\Microsoft.VisualBasic.Targets");

+                        tools["Folder"] = new ToolInfo("Folder", "{2150E333-8FDC-42A3-9474-1A3956D46DE8}", null, null);

+                }

+

+                #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)

+                                {

+                                        kernel.Log.Write(LogType.Warning, "Could not resolve reference path: {0}", node.Path);

+                                }

+                        }

+

+                        return ret;

+                }

+

+                private static ProjectNode FindProjectInSolution(string name, SolutionNode solution)

+                {

+                        SolutionNode node = solution;

+

+                        while (node.Parent is SolutionNode)

+                                node = node.Parent as SolutionNode;

+

+                        return FindProjectInSolutionRecursively(name, node);

+                }

+

+                private static ProjectNode FindProjectInSolutionRecursively(string name, SolutionNode solution)

+                {

+                        if (solution.ProjectsTable.ContainsKey(name))

+                                return solution.ProjectsTable[name];

+

+                        foreach (SolutionNode child in solution.Solutions)

+                        {

+                                ProjectNode node = FindProjectInSolutionRecursively(name, child);

+                                if (node != null)

+                                        return node;

+                        }

+

+                        return null;

+                }

+

+                private void WriteProject(SolutionNode solution, ProjectNode project)

+                {

+                        if (!tools.ContainsKey(project.Language))

+                        {

+                                throw new UnknownLanguageException("Unknown .NET language: " + project.Language);

+                        }

+

+                        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\" {0}>", GetToolsVersionXml(project.FrameworkVersion));

+                                ps.WriteLine("  <PropertyGroup>");

+                                ps.WriteLine("    <ProjectType>Local</ProjectType>");

+                                ps.WriteLine("    <ProductVersion>{0}</ProductVersion>", ProductVersion);

+                                ps.WriteLine("    <SchemaVersion>{0}</SchemaVersion>", SchemaVersion);

+                                ps.WriteLine("    <ProjectGuid>{{{0}}}</ProjectGuid>", project.Guid.ToString().ToUpper());

+

+                                // Visual Studio has a hard coded guid for the project type

+                                if (project.Type == ProjectType.Web)

+                                        ps.WriteLine("    <ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>");

+                                ps.WriteLine("    <Configuration Condition=\" '$(Configuration)' == '' \">Debug</Configuration>");

+                                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>");

+                                ps.WriteLine("    <TargetFrameworkVersion>{0}</TargetFrameworkVersion>", project.FrameworkVersion.ToString().Replace("_", "."));

+

+                                ps.WriteLine("    <OutputType>{0}</OutputType>", project.Type == ProjectType.Web ? ProjectType.Library.ToString() : project.Type.ToString());

+                                ps.WriteLine("    <AppDesignerFolder>{0}</AppDesignerFolder>", project.DesignerFolder);

+                                ps.WriteLine("    <RootNamespace>{0}</RootNamespace>", project.RootNamespace);

+                                ps.WriteLine("    <StartupObject>{0}</StartupObject>", project.StartupObject);

+                                if (string.IsNullOrEmpty(project.DebugStartParameters))

+                                {

+                                        ps.WriteLine("    <StartArguments>{0}</StartArguments>", project.DebugStartParameters);

+                                }

+                                ps.WriteLine("    <FileUpgradeFlags>");

+                                ps.WriteLine("    </FileUpgradeFlags>");

+

+                                ps.WriteLine("  </PropertyGroup>");

+

+                                foreach (ConfigurationNode conf in project.Configurations)

+                                {

+                                        ps.Write("      <PropertyGroup ");

+                                        ps.WriteLine("Condition=\" '$(Configuration)|$(Platform)' == '{0}|{1}' \">", conf.Name, conf.Platform);

+                                        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>", Helper.NormalizePath(conf.Options["XmlDocFile"].ToString()));

+                                        ps.WriteLine("    <DebugSymbols>{0}</DebugSymbols>", conf.Options["DebugInformation"]);

+                                        ps.WriteLine("    <FileAlignment>{0}</FileAlignment>", conf.Options["FileAlignment"]);

+                                        ps.WriteLine("    <Optimize>{0}</Optimize>", conf.Options["OptimizeCode"]);

+                                        if (project.Type != ProjectType.Web)

+                                                ps.WriteLine("    <OutputPath>{0}</OutputPath>",

+                                                             Helper.EndPath(Helper.NormalizePath(conf.Options["OutputPath"].ToString())));

+                                        else

+                                                ps.WriteLine("    <OutputPath>{0}</OutputPath>",

+                                                             Helper.EndPath(Helper.NormalizePath("bin\\")));

+

+                                        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("    <NoStdLib>{0}</NoStdLib>", conf.Options["NoStdLib"]);

+                                        ps.WriteLine("    <NoWarn>{0}</NoWarn>", conf.Options["SuppressWarnings"]);

+                                        ps.WriteLine("    <PlatformTarget>{0}</PlatformTarget>", conf.Platform);

+                                        ps.WriteLine("  </PropertyGroup>");

+                                }

+

+                                //ps.WriteLine("          </Settings>");

+

+                                Dictionary<ReferenceNode, ProjectNode> projectReferences = new Dictionary<ReferenceNode, ProjectNode>();

+                                List<ReferenceNode> otherReferences = new List<ReferenceNode>();

+

+                                foreach (ReferenceNode refr in project.References)

+                                {

+                                        ProjectNode projectNode = FindProjectInSolution(refr.Name, solution);

+

+                                        if (projectNode == null)

+                                                otherReferences.Add(refr);

+                                        else

+                                                projectReferences.Add(refr, projectNode);

+                                }

+                                // Assembly References

+                                ps.WriteLine("  <ItemGroup>");

+

+                                foreach (ReferenceNode refr in otherReferences)

+                                {

+                                        ps.Write("        <Reference");

+                                        ps.Write(" Include=\"");

+                                        ps.Write(refr.Name);

+                                        ps.WriteLine("\" >");

+                                        ps.Write("                <Name>");

+                                        ps.Write(refr.Name);

+                                        ps.WriteLine("</Name>");

+                                                                                

+                                        if(!String.IsNullOrEmpty(refr.Path))

+                                        {

+                                                // Use absolute path to assembly (for determining assembly type)

+                                                string absolutePath = Path.Combine(project.FullPath, refr.Path);

+                                                if(File.Exists(Helper.MakeFilePath(absolutePath, refr.Name, "exe"))) {

+                                                        // Assembly is an executable (exe)

+                                                        ps.WriteLine("          <HintPath>{0}</HintPath>", Helper.MakeFilePath(refr.Path, refr.Name, "exe"));

+                                                } else if(File.Exists(Helper.MakeFilePath(absolutePath, refr.Name, "dll"))) {

+                                                        // Assembly is an library (dll)                                                 

+                                                        ps.WriteLine("          <HintPath>{0}</HintPath>", Helper.MakeFilePath(refr.Path, refr.Name, "dll"));

+                                                } else {

+                                                        string referencePath = Helper.MakeFilePath(refr.Path, refr.Name, "dll");

+                                                        kernel.Log.Write(LogType.Warning, "Reference \"{0}\": The specified file doesn't exist.", referencePath);

+                                                        ps.WriteLine("          <HintPath>{0}</HintPath>", Helper.MakeFilePath(refr.Path, refr.Name, "dll"));

+                                                }

+                                        }

+                                        

+                                        ps.WriteLine("          <Private>{0}</Private>", refr.LocalCopy);

+                                        ps.WriteLine("    </Reference>");

+                                }

+                                ps.WriteLine("  </ItemGroup>");

+

+                                //Project References

+                                ps.WriteLine("  <ItemGroup>");

+                                foreach (KeyValuePair<ReferenceNode, ProjectNode> pair in projectReferences)

+                                {

+                                        ToolInfo tool = tools[pair.Value.Language];

+                                        if (tools == null)

+                                                throw new UnknownLanguageException();

+

+                                        string path =

+                                                Helper.MakePathRelativeTo(project.FullPath,

+                                                                          Helper.MakeFilePath(pair.Value.FullPath, pair.Value.Name, tool.FileExtension));

+                                        ps.WriteLine("    <ProjectReference Include=\"{0}\">", path);

+

+                                        // TODO: Allow reference to visual basic projects

+                                        ps.WriteLine("          <Name>{0}</Name>", pair.Value.Name);

+                                        ps.WriteLine("          <Project>{0}</Project>", pair.Value.Guid.ToString("B").ToUpper());

+                                        ps.WriteLine("          <Package>{0}</Package>", tool.Guid.ToUpper());

+

+                                        //This is the Copy Local flag in VS

+                                        ps.WriteLine("          <Private>{0}</Private>", pair.Key.LocalCopy);

+

+                                        ps.WriteLine("    </ProjectReference>");

+                                }

+                                ps.WriteLine("  </ItemGroup>");

+

+                                //                                ps.WriteLine("        </Build>");

+                                ps.WriteLine("  <ItemGroup>");

+

+                                //                                ps.WriteLine("          <Include>");

+                                List<string> list = new List<string>();

+

+                                foreach (string path in project.Files)

+                                {

+                                        string lower = path.ToLower();

+                                        if (lower.EndsWith(".resx"))

+                                        {

+                                                string codebehind = String.Format("{0}.Designer{1}", path.Substring(0, path.LastIndexOf('.')), toolInfo.LanguageExtension);

+                                                if (!list.Contains(codebehind))

+                                                        list.Add(codebehind);

+                                        }

+

+                                }

+                                

+                                foreach (string filePath in project.Files)

+                                {

+                                        //                                      if (file == "Properties\\Bind.Designer.cs")

+                                        //                                      {

+                                        //                                              Console.WriteLine("Wait a minute!");

+                                        //                                              Console.WriteLine(project.Files.GetSubType(file).ToString());

+                                        //                                      }

+                                        SubType subType = project.Files.GetSubType(filePath);

+                                        

+                                        // Visual Studio chokes on file names if forward slash is used as a path separator

+                                        // instead of backslash.  So we must make sure that all file paths written to the

+                                        // project file use \ as a path separator.

+                                        string file = filePath.Replace(@"/", @"\");

+

+                                        if (subType != SubType.Code && subType != SubType.Settings && subType != SubType.Designer

+                                            && subType != SubType.CodeBehind)

+                                        {

+                                                ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx");

+                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file));

+                                                ps.WriteLine("          <SubType>Designer</SubType>");

+                                                ps.WriteLine("    </EmbeddedResource>");

+                                                //

+                                        }

+

+                                        if (subType == SubType.Designer)

+                                        {

+                                                ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file);

+                                                

+                                                string autogen_name = file.Substring(0, file.LastIndexOf('.')) + ".Designer.cs";

+                                                string dependent_name = filePath.Substring(0, file.LastIndexOf('.')) + ".cs";

+

+                                                // Check for a parent .cs file with the same name as this designer file

+                                                if (File.Exists(Helper.NormalizePath(dependent_name)))

+                                                {

+                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(dependent_name));

+                                                }

+                                                else

+                                                {

+                                                        ps.WriteLine("          <Generator>ResXFileCodeGenerator</Generator>");

+                                                        ps.WriteLine("          <LastGenOutput>{0}</LastGenOutput>", Path.GetFileName(autogen_name));

+                                                        ps.WriteLine("          <SubType>" + subType + "</SubType>");

+                                                }

+                                                

+                                                ps.WriteLine("    </EmbeddedResource>");

+                                                if (File.Exists(Helper.NormalizePath(autogen_name)))

+                                                {

+                                                        ps.WriteLine("    <Compile Include=\"{0}\">", autogen_name);

+                                                        //ps.WriteLine("          <DesignTime>True</DesignTime>");

+

+                                                        // If a parent .cs file exists, link this autogen file to it. Otherwise link

+                                                        // to the designer file

+                                                        if (File.Exists(dependent_name))

+                                                        {

+                                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(dependent_name));

+                                                        }

+                                                        else

+                                                        {

+                                                                ps.WriteLine("          <AutoGen>True</AutoGen>");

+                                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(filePath));

+                                                        }

+                                                        

+                                                        ps.WriteLine("    </Compile>");

+                                                }

+                                                list.Add(autogen_name);

+                                        }

+                                        if (subType == SubType.Settings)

+                                        {

+                                                ps.Write("        <{0} ", project.Files.GetBuildAction(filePath));

+                                                ps.WriteLine("Include=\"{0}\">", file);

+                                                string fileName = Path.GetFileName(filePath);

+                                                if (project.Files.GetBuildAction(filePath) == BuildAction.None)

+                                                {

+                                                        ps.WriteLine("          <Generator>SettingsSingleFileGenerator</Generator>");

+                                                        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>", Path.GetFileName(fileNameShorter + ".settings"));

+                                                }

+                                                ps.WriteLine("    </{0}>", project.Files.GetBuildAction(filePath));

+                                        }

+                                        else if (subType != SubType.Designer)

+                                        {

+                                                string path = Helper.NormalizePath(file);

+                                                string path_lower = path.ToLower();

+

+                                                if (!list.Contains(filePath))

+                                                {

+                                                        ps.Write("        <{0} ", project.Files.GetBuildAction(filePath));

+

+                                                        int startPos = 0;

+                                                        if (project.Files.GetPreservePath(filePath))

+                                                        {

+                                                                while ((@"./\").IndexOf(file.Substring(startPos, 1)) != -1)

+                                                                        startPos++;

+

+                                                        }

+                                                        else

+                                                        {

+                                                                startPos = file.LastIndexOf(Path.GetFileName(path));

+                                                        }

+                                                        

+                                                        // be sure to write out the path with backslashes so VS recognizes

+                                                        // the file properly.

+                                                        ps.WriteLine("Include=\"{0}\">", file);

+

+                                                        int last_period_index = file.LastIndexOf('.');

+                                                        string short_file_name = file.Substring(0, last_period_index);

+                                                        string extension = Path.GetExtension(path);

+                                                        // make this upper case, so that when File.Exists tests for the

+                                                        // existence of a designer file on a case-sensitive platform,

+                                                        // it is correctly identified.

+                                                        string designer_format = string.Format(".Designer{0}", extension);

+

+                                                        if (path_lower.EndsWith(designer_format.ToLowerInvariant()))

+                                                        {

+                                                                int designer_index = path.IndexOf(designer_format);

+                                                                string file_name = path.Substring(0, designer_index);

+

+                                                                // There are two corrections to the next lines:

+                                                                // 1. Fix the connection between a designer file and a form

+                                                                //        or usercontrol that don't have an associated resx file.

+                                                                // 2. Connect settings files to associated designer files.

+                                                                if (File.Exists(file_name + extension))

+                                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file_name + extension));

+                                                                else if (File.Exists(file_name + ".resx"))

+                                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file_name + ".resx"));

+                                                                else if (File.Exists(file_name + ".settings"))

+                                                                {

+                                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file_name + ".settings"));

+                                                                        ps.WriteLine("          <AutoGen>True</AutoGen>");

+                                                                        ps.WriteLine("          <DesignTimeSharedInput>True</DesignTimeSharedInput>");

+                                                                }

+                                                        }

+                                                        else if (subType == SubType.CodeBehind)

+                                                        {

+                                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(short_file_name));

+                                                        }

+                                                        if (project.Files.GetIsLink(filePath))

+                                                        {

+                                                                string alias = project.Files.GetLinkPath(filePath);

+                                                                alias += file.Substring(startPos);

+                                                                alias = Helper.NormalizePath(alias);

+                                                                ps.WriteLine("          <Link>{0}</Link>", alias);

+                                                        }

+                                                        else if (project.Files.GetBuildAction(filePath) != BuildAction.None)

+                                                        {

+                                                                if (project.Files.GetBuildAction(filePath) != BuildAction.EmbeddedResource)

+                                                                {

+                                                                        ps.WriteLine("          <SubType>{0}</SubType>", subType);

+                                                                }

+                                                        }

+

+                                                        if (project.Files.GetCopyToOutput(filePath) != CopyToOutput.Never)

+                                                        {

+                                                                ps.WriteLine("          <CopyToOutputDirectory>{0}</CopyToOutputDirectory>", project.Files.GetCopyToOutput(filePath));

+                                                        }

+

+                                                        ps.WriteLine("    </{0}>", project.Files.GetBuildAction(filePath));

+                                                }

+                                        }

+                                }

+

+                                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("</Project>");

+                        }

+                        #endregion

+

+                        #region User File

+

+                        ps = new StreamWriter(projectFile + ".user");

+                        using (ps)

+                        {

+                                // Get the first configuration from the project.

+                                ConfigurationNode firstConfiguration = null;

+

+                                if (project.Configurations.Count > 0)

+                                {

+                                        firstConfiguration = project.Configurations[0];

+                                }

+

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

+

+                                if (firstConfiguration != null)

+                                {

+                                        ps.WriteLine("    <Configuration Condition=\" '$(Configuration)' == '' \">{0}</Configuration>", firstConfiguration.Name);

+                                        ps.WriteLine("    <Platform Condition=\" '$(Platform)' == '' \">{0}</Platform>", firstConfiguration.Platform);

+                                }

+

+                                ps.WriteLine("    <ReferencePath>{0}</ReferencePath>", MakeRefPath(project));

+                                ps.WriteLine("    <LastOpenVersion>{0}</LastOpenVersion>", 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}|{1}' \"", conf.Name, conf.Platform);

+                                        ps.WriteLine(" />");

+                                }

+                                ps.WriteLine("</Project>");

+                        }

+                        #endregion

+

+                        kernel.CurrentWorkingDirectory.Pop();

+                }

+

+                private void WriteSolution(SolutionNode solution, bool writeSolutionToDisk)

+                {

+                        kernel.Log.Write("Creating {0} solution and project files", VersionName);

+

+                        foreach (SolutionNode child in solution.Solutions)

+                        {

+                                kernel.Log.Write("...Creating folder: {0}", child.Name);

+                                WriteSolution(child, false);

+                        }

+

+                        foreach (ProjectNode project in solution.Projects)

+                        {

+                                kernel.Log.Write("...Creating project: {0}", project.Name);

+                                WriteProject(solution, project);

+                        }

+

+                        foreach (DatabaseProjectNode project in solution.DatabaseProjects)

+                        {

+                                kernel.Log.Write("...Creating database project: {0}", project.Name);

+                                WriteDatabaseProject(solution, project);

+                        }

+

+                        if (writeSolutionToDisk) // only write main solution

+                        {

+                                kernel.Log.Write("");

+                                string solutionFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "sln");

+                                

+                                using (StreamWriter ss = new StreamWriter(solutionFile))

+                                {

+                                        kernel.CurrentWorkingDirectory.Push();

+                                        Helper.SetCurrentDir(Path.GetDirectoryName(solutionFile));

+

+                                        ss.WriteLine("Microsoft Visual Studio Solution File, Format Version {0}", SolutionVersion);

+                                        ss.WriteLine(SolutionTag);

+

+                                        WriteProjectDeclarations(ss, solution, solution);

+

+                                        ss.WriteLine("Global");

+

+                                        ss.WriteLine("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution");

+                                        foreach (ConfigurationNode conf in solution.Configurations)

+                                        {

+                                                ss.WriteLine("\t\t{0} = {0}", conf.NameAndPlatform);

+                                        }

+                                        ss.WriteLine("\tEndGlobalSection");

+

+                                        ss.WriteLine("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution");

+                                        WriteConfigurationLines(solution.Configurations, solution, ss);

+                                        ss.WriteLine("\tEndGlobalSection");

+

+                                        if (solution.Solutions.Count > 0)

+                                        {

+                                                ss.WriteLine("\tGlobalSection(NestedProjects) = preSolution");

+                                                foreach (SolutionNode embeddedSolution in solution.Solutions)

+                                                {

+                                                        WriteNestedProjectMap(ss, embeddedSolution);

+                                                }

+                                                ss.WriteLine("\tEndGlobalSection");

+                                        }

+

+                                        ss.WriteLine("EndGlobal");

+                                }

+

+                                kernel.CurrentWorkingDirectory.Pop();

+                        }

+                }

+

+                private void WriteProjectDeclarations(TextWriter writer, SolutionNode actualSolution, SolutionNode embeddedSolution)

+                {

+                        foreach (SolutionNode childSolution in embeddedSolution.Solutions)

+                        {

+                                WriteEmbeddedSolution(writer, childSolution);

+                                WriteProjectDeclarations(writer, actualSolution, childSolution);

+                        }

+

+                        foreach (ProjectNode project in embeddedSolution.Projects)

+                        {

+                                WriteProject(actualSolution, writer, project);

+                        }

+

+                        foreach (DatabaseProjectNode dbProject in embeddedSolution.DatabaseProjects)

+                        {

+                                WriteProject(actualSolution, writer, dbProject);

+                        }

+

+                        if (actualSolution.Guid == embeddedSolution.Guid)

+                        {

+                                WriteSolutionFiles(actualSolution, writer);

+                        }

+                }

+

+                private static void WriteNestedProjectMap(TextWriter writer, SolutionNode embeddedSolution)

+                {

+                        foreach (ProjectNode project in embeddedSolution.Projects)

+                        {

+                                WriteNestedProject(writer, embeddedSolution, project.Guid);

+                        }

+

+                        foreach (DatabaseProjectNode dbProject in embeddedSolution.DatabaseProjects)

+                        {

+                                WriteNestedProject(writer, embeddedSolution, dbProject.Guid);

+                        }

+

+                        foreach (SolutionNode child in embeddedSolution.Solutions)

+                        {

+                                WriteNestedProject(writer, embeddedSolution, child.Guid);

+                                WriteNestedProjectMap(writer, child);

+                        }

+                }

+

+                private static void WriteNestedProject(TextWriter writer, SolutionNode solution, Guid projectGuid)

+                {

+                        WriteNestedFolder(writer, solution.Guid, projectGuid);

+                }

+

+                private static void WriteNestedFolder(TextWriter writer, Guid parentGuid, Guid childGuid)

+                {

+                        writer.WriteLine("\t\t{0} = {1}",

+                                         childGuid.ToString("B").ToUpper(),

+                                         parentGuid.ToString("B").ToUpper());

+                }

+

+                private static void WriteConfigurationLines(IEnumerable<ConfigurationNode> configurations, SolutionNode solution, TextWriter ss)

+                {

+                        foreach (ProjectNode project in solution.Projects)

+                        {

+                                foreach (ConfigurationNode conf in configurations)

+                                {

+                                        ss.WriteLine("\t\t{0}.{1}.ActiveCfg = {1}",

+                                                     project.Guid.ToString("B").ToUpper(),

+                                                     conf.NameAndPlatform);

+

+                                        ss.WriteLine("\t\t{0}.{1}.Build.0 = {1}",

+                                                     project.Guid.ToString("B").ToUpper(),

+                                                     conf.NameAndPlatform);

+                                }

+                        }

+

+                        foreach (SolutionNode child in solution.Solutions)

+                        {

+                                WriteConfigurationLines(configurations, child, ss);

+                        }

+                }

+

+                private void WriteSolutionFiles(SolutionNode solution, TextWriter ss)

+                {

+                        if(solution.Files != null && solution.Files.Count > 0)

+                                WriteProject(ss, "Folder", solution.Guid, "Solution Files", "Solution Files", solution.Files);

+                }

+

+                private void WriteEmbeddedSolution(TextWriter writer, SolutionNode embeddedSolution)

+                {

+                        WriteProject(writer, "Folder", embeddedSolution.Guid, embeddedSolution.Name, embeddedSolution.Name, embeddedSolution.Files);

+                }

+

+                private void WriteProject(SolutionNode solution, TextWriter ss, ProjectNode project)

+                {

+                        WriteProject(ss, solution, project.Language, project.Guid, project.Name, project.FullPath);

+                }

+

+                private void WriteProject(SolutionNode solution, TextWriter ss, DatabaseProjectNode dbProject)

+                {

+                        if (solution.Files != null && solution.Files.Count > 0)

+                                WriteProject(ss, solution, "Database", dbProject.Guid, dbProject.Name, dbProject.FullPath);

+                }

+

+                const string ProjectDeclarationBeginFormat = "Project(\"{0}\") = \"{1}\", \"{2}\", \"{3}\"";

+                const string ProjectDeclarationEndFormat = "EndProject";

+

+                private void WriteProject(TextWriter ss, SolutionNode solution, string language, Guid guid, string name, string projectFullPath)

+                {

+                        if (!tools.ContainsKey(language))

+                                throw new UnknownLanguageException("Unknown .NET language: " + language);

+

+                        ToolInfo toolInfo = tools[language];

+

+                        string path = Helper.MakePathRelativeTo(solution.FullPath, projectFullPath);

+

+                        path = Helper.MakeFilePath(path, name, toolInfo.FileExtension);

+

+                        WriteProject(ss, language, guid, name, path);

+                }

+

+                private void WriteProject(TextWriter writer, string language, Guid projectGuid, string name, string location)

+                {

+                        WriteProject(writer, language, projectGuid, name, location, null);

+                }

+

+                private void WriteProject(TextWriter writer, string language, Guid projectGuid, string name, string location, FilesNode files)

+                {

+                        if (!tools.ContainsKey(language))

+                                throw new UnknownLanguageException("Unknown .NET language: " + language);

+

+                        ToolInfo toolInfo = tools[language];

+

+                        writer.WriteLine(ProjectDeclarationBeginFormat,

+                                         toolInfo.Guid,

+                                         name,

+                                         location,

+                                         projectGuid.ToString("B").ToUpper());

+

+                        if (files != null)

+                        {

+                                writer.WriteLine("\tProjectSection(SolutionItems) = preProject");

+

+                                foreach (string file in files)

+                                        writer.WriteLine("\t\t{0} = {0}", file);

+

+                                writer.WriteLine("\tEndProjectSection");

+                        }

+

+                        writer.WriteLine(ProjectDeclarationEndFormat);

+                }

+

+                private void WriteDatabaseProject(SolutionNode solution, DatabaseProjectNode project)

+                {

+                        string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "dbp");

+                        IndentedTextWriter ps = new IndentedTextWriter(new StreamWriter(projectFile), "   ");

+

+                        kernel.CurrentWorkingDirectory.Push();

+

+                        Helper.SetCurrentDir(Path.GetDirectoryName(projectFile));

+

+                        using (ps)

+                        {

+                                ps.WriteLine("# Microsoft Developer Studio Project File - Database Project");

+                                ps.WriteLine("Begin DataProject = \"{0}\"", project.Name);

+                                ps.Indent++;

+                                ps.WriteLine("MSDTVersion = \"80\"");

+                                // TODO: Use the project.Files property

+                                if (ContainsSqlFiles(Path.GetDirectoryName(projectFile)))

+                                        WriteDatabaseFoldersAndFiles(ps, Path.GetDirectoryName(projectFile));

+

+                                ps.WriteLine("Begin DBRefFolder = \"Database References\"");

+                                ps.Indent++;

+                                foreach (DatabaseReferenceNode reference in project.References)

+                                {

+                                        ps.WriteLine("Begin DBRefNode = \"{0}\"", reference.Name);

+                                        ps.Indent++;

+                                        ps.WriteLine("ConnectStr = \"{0}\"", reference.ConnectionString);

+                                        ps.WriteLine("Provider = \"{0}\"", reference.ProviderId.ToString("B").ToUpper());

+                                        //ps.WriteLine("Colorizer = 5");

+                                        ps.Indent--;

+                                        ps.WriteLine("End");

+                                }

+                                ps.Indent--;

+                                ps.WriteLine("End");

+                                ps.Indent--;

+                                ps.WriteLine("End");

+

+                                ps.Flush();

+                        }

+

+                        kernel.CurrentWorkingDirectory.Pop();

+                }

+

+                private static bool ContainsSqlFiles(string folder)

+                {

+                        if(Directory.GetFiles(folder, "*.sql").Length > 0)

+                                return true; // if the folder contains 1 .sql file, that's good enough

+

+                        foreach (string child in Directory.GetDirectories(folder))

+                        {

+                                if (ContainsSqlFiles(child))

+                                        return true; // if 1 child folder contains a .sql file, still good enough

+                        }

+

+                        return false;

+                }

+

+                private static void WriteDatabaseFoldersAndFiles(IndentedTextWriter writer, string folder)

+                {

+                        foreach (string child in Directory.GetDirectories(folder))

+                        {

+                                if (ContainsSqlFiles(child))

+                                {

+                                        writer.WriteLine("Begin Folder = \"{0}\"", Path.GetFileName(child));

+                                        writer.Indent++;

+                                        WriteDatabaseFoldersAndFiles(writer, child);

+                                        writer.Indent--;

+                                        writer.WriteLine("End");

+                                }

+                        }

+                        foreach (string file in Directory.GetFiles(folder, "*.sql"))

+                        {

+                                writer.WriteLine("Script = \"{0}\"", Path.GetFileName(file));

+                        }

+                }

+

+                private void CleanProject(ProjectNode project)

+                {

+                        kernel.Log.Write("...Cleaning project: {0}", project.Name);

+

+                        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", 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, true);

+                        }

+                        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;

+                }

+

+                #endregion

+        }

+}

diff --git a/Prebuild/src/Core/Targets/.svn/text-base/VSVersion.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/VSVersion.cs.svn-base
new file mode 100644
index 0000000..699b5ca
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/VSVersion.cs.svn-base
@@ -0,0 +1,54 @@
+#region BSD License
+/*
+Copyright (c) 2008-2009 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com), John Anderson (sontek@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
+
+namespace Prebuild.Core.Targets
+{
+        /// <summary>
+        /// 
+        /// </summary>
+        public enum VSVersion
+        {
+                /// <summary>
+                /// Visual Studio 2002 
+                /// </summary>
+                VS70,
+                /// <summary>
+                /// Visual Studio 2003 
+                /// </summary>
+                VS71,
+                /// <summary>
+                /// Visual Studio 2005 
+                /// </summary>
+                VS80,
+                /// <summary>
+                /// Visual Studio 2008 
+                /// </summary>
+                VS90,
+                /// <summary>
+                /// Visual Studio 2010 
+                /// </summary>
+                VS10
+        }
+}
diff --git a/Prebuild/src/Core/Targets/.svn/text-base/XcodeTarget.cs.svn-base b/Prebuild/src/Core/Targets/.svn/text-base/XcodeTarget.cs.svn-base
new file mode 100644
index 0000000..5393cec
--- /dev/null
+++ b/Prebuild/src/Core/Targets/.svn/text-base/XcodeTarget.cs.svn-base
@@ -0,0 +1,594 @@
+#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
+
+using System;
+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("xcode")]
+    public class XcodeTarget : 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}/", 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 += 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 fileRef = FindFileReference(refr.Name, project);
+                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;
+        }
+
+        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, 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)
+                {
+                    ss.WriteLine("                <include name=\"{0}", Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, refr)) + "\" />", '/'));
+                }
+                ss.WriteLine("            </references>");
+
+                ss.WriteLine("        </csc>");
+                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 Xcode 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("");
+            DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(solution.FullPath, solution.Name + ".xcodeproj"));
+            if (!directoryInfo.Exists)
+            {
+                directoryInfo.Create();
+            }
+            string combFile = Helper.MakeFilePath(Path.Combine(solution.FullPath, solution.Name + ".xcodeproj"), "project", "pbxproj");
+            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 Xcode 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 "xcode";
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/Prebuild/src/Core/Targets/AutotoolsTarget.cs b/Prebuild/src/Core/Targets/AutotoolsTarget.cs
new file mode 100644
index 0000000..e46b5a5
--- /dev/null
+++ b/Prebuild/src/Core/Targets/AutotoolsTarget.cs
@@ -0,0 +1,1070 @@
+#region BSD License

+/*

+

+Copyright (c) 2004 - 2008

+Matthew Holmes        (matthew@wildfiregames.com),

+Dan     Moorehead     (dan05a@gmail.com),

+Dave    Hudson        (jendave@yahoo.com),

+C.J.    Adams-Collier (cjac@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 MIT X11 license

+

+/*

+ Portions of this file authored by Lluis Sanchez Gual

+

+ Copyright (C) 2006 Novell, Inc (http://www.novell.com)

+

+ Permission is hereby granted, free of charge, to any person obtaining

+ a copy of this software and associated documentation files (the

+ "Software"), to deal in the Software without restriction, including

+ without limitation the rights to use, copy, modify, merge, publish,

+ distribute, sublicense, and/or sell copies of the Software, and to

+ permit persons to whom the Software is furnished to do so, subject to

+ the following conditions:

+ 

+ The above copyright notice and this permission notice shall be

+ included in all copies or substantial portions of the Software.

+ 

+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ */

+

+#endregion

+using System;

+using System.Collections.Generic;

+using System.IO;

+using System.Reflection;

+using System.Text;

+using System.Text.RegularExpressions;

+using System.Xml;

+using System.Xml.Xsl;

+using System.Net;

+using System.Diagnostics;

+

+using Prebuild.Core.Attributes;

+using Prebuild.Core.Interfaces;

+using Prebuild.Core.Nodes;

+using Prebuild.Core.Utilities;

+

+namespace Prebuild.Core.Targets

+{

+    public enum ClrVersion

+    {

+        Default,

+        Net_1_1,

+        Net_2_0

+    }

+

+    public class SystemPackage

+    {

+        string name;

+        string version;

+        string description;

+        string[] assemblies;

+        bool isInternal;

+        ClrVersion targetVersion;

+

+        public void Initialize(string name,

+                               string version,

+                               string description,

+                               string[] assemblies,

+                               ClrVersion targetVersion,

+                               bool isInternal)

+        {

+            this.isInternal = isInternal;

+            this.name = name;

+            this.version = version;

+            this.assemblies = assemblies;

+            this.description = description;

+            this.targetVersion = targetVersion;

+        }

+

+        public string Name

+        {

+            get { return name; }

+        }

+

+        public string Version

+        {

+            get { return version; }

+        }

+

+        public string Description

+        {

+            get { return description; }

+        }

+

+        public ClrVersion TargetVersion

+        {

+            get { return targetVersion; }

+        }

+

+        // The package is part of the mono SDK

+        public bool IsCorePackage

+        {

+            get { return name == "mono"; }

+        }

+

+        // The package has been registered by an add-in, and is not installed

+        // in the system.

+        public bool IsInternalPackage

+        {

+            get { return isInternal; }

+        }

+

+        public string[] Assemblies

+        {

+            get { return assemblies; }

+        }

+

+    }

+

+

+    /// <summary>

+    /// 

+    /// </summary>

+    [Target("autotools")]

+    public class AutotoolsTarget : ITarget

+    {

+        #region Fields

+

+        Kernel m_Kernel;

+        XmlDocument autotoolsDoc;

+        XmlUrlResolver xr;

+        System.Security.Policy.Evidence e;

+        readonly Dictionary<string, SystemPackage> assemblyPathToPackage = new Dictionary<string, SystemPackage>();

+        readonly Dictionary<string, string> assemblyFullNameToPath = new Dictionary<string, string>();

+        readonly Dictionary<string, SystemPackage> packagesHash = new Dictionary<string, SystemPackage>();

+        readonly List<SystemPackage> packages = new List<SystemPackage>();

+

+        #endregion

+

+        #region Private Methods

+

+        private static void mkdirDashP(string dirName)

+        {

+            DirectoryInfo di = new DirectoryInfo(dirName);

+            if (di.Exists)

+                return;

+

+            string parentDirName = System.IO.Path.GetDirectoryName(dirName);

+            DirectoryInfo parentDi = new DirectoryInfo(parentDirName);

+            if (!parentDi.Exists)

+                mkdirDashP(parentDirName);

+

+            di.Create();

+        }

+

+        private static void chkMkDir(string dirName)

+        {

+            System.IO.DirectoryInfo di =

+                new System.IO.DirectoryInfo(dirName);

+

+            if (!di.Exists)

+                di.Create();

+        }

+

+        private void transformToFile(string filename, XsltArgumentList argList, string nodeName)

+        {

+            // Create an XslTransform for this file

+            XslTransform templateTransformer =

+                new XslTransform();

+

+            // Load up the template

+            XmlNode templateNode =

+                autotoolsDoc.SelectSingleNode(nodeName + "/*");

+            templateTransformer.Load(templateNode.CreateNavigator(), xr, e);

+

+            // Create a writer for the transformed template

+            XmlTextWriter templateWriter =

+                new XmlTextWriter(filename, null);

+

+            // Perform transformation, writing the file

+            templateTransformer.Transform

+                (m_Kernel.CurrentDoc, argList, templateWriter, xr);

+        }

+

+        static string NormalizeAsmName(string name)

+        {

+            int i = name.IndexOf(", PublicKeyToken=null");

+            if (i != -1)

+                return name.Substring(0, i).Trim();

+            return name;

+        }

+

+        private void AddAssembly(string assemblyfile, SystemPackage package)

+        {

+            if (!File.Exists(assemblyfile))

+                return;

+

+            try

+            {

+                System.Reflection.AssemblyName an = System.Reflection.AssemblyName.GetAssemblyName(assemblyfile);

+                assemblyFullNameToPath[NormalizeAsmName(an.FullName)] = assemblyfile;

+                assemblyPathToPackage[assemblyfile] = package;

+            }

+            catch

+            {

+            }

+        }

+

+        private static List<string> GetAssembliesWithLibInfo(string line, string file)

+        {

+            List<string> references = new List<string>();

+            List<string> libdirs = new List<string>();

+            List<string> retval = new List<string>();

+            foreach (string piece in line.Split(' '))

+            {

+                if (piece.ToLower().Trim().StartsWith("/r:") || piece.ToLower().Trim().StartsWith("-r:"))

+                {

+                    references.Add(ProcessPiece(piece.Substring(3).Trim(), file));

+                }

+                else if (piece.ToLower().Trim().StartsWith("/lib:") || piece.ToLower().Trim().StartsWith("-lib:"))

+                {

+                    libdirs.Add(ProcessPiece(piece.Substring(5).Trim(), file));

+                }

+            }

+

+            foreach (string refrnc in references)

+            {

+                foreach (string libdir in libdirs)

+                {

+                    if (File.Exists(libdir + Path.DirectorySeparatorChar + refrnc))

+                    {

+                        retval.Add(libdir + Path.DirectorySeparatorChar + refrnc);

+                    }

+                }

+            }

+

+            return retval;

+        }

+

+        private static List<string> GetAssembliesWithoutLibInfo(string line, string file)

+        {

+            List<string> references = new List<string>();

+            foreach (string reference in line.Split(' '))

+            {

+                if (reference.ToLower().Trim().StartsWith("/r:") || reference.ToLower().Trim().StartsWith("-r:"))

+                {

+                    string final_ref = reference.Substring(3).Trim();

+                    references.Add(ProcessPiece(final_ref, file));

+                }

+            }

+            return references;

+        }

+

+        private static string ProcessPiece(string piece, string pcfile)

+        {

+            int start = piece.IndexOf("${");

+            if (start == -1)

+                return piece;

+

+            int end = piece.IndexOf("}");

+            if (end == -1)

+                return piece;

+

+            string variable = piece.Substring(start + 2, end - start - 2);

+            string interp = GetVariableFromPkgConfig(variable, Path.GetFileNameWithoutExtension(pcfile));

+            return ProcessPiece(piece.Replace("${" + variable + "}", interp), pcfile);

+        }

+

+        private static string GetVariableFromPkgConfig(string var, string pcfile)

+        {

+            ProcessStartInfo psi = new ProcessStartInfo("pkg-config");

+            psi.RedirectStandardOutput = true;

+            psi.UseShellExecute = false;

+            psi.Arguments = String.Format("--variable={0} {1}", var, pcfile);

+            Process p = new Process();

+            p.StartInfo = psi;

+            p.Start();

+            string ret = p.StandardOutput.ReadToEnd().Trim();

+            p.WaitForExit();

+            if (String.IsNullOrEmpty(ret))

+                return String.Empty;

+            return ret;

+        }

+

+        private void ParsePCFile(string pcfile)

+        {

+            // Don't register the package twice

+            string pname = Path.GetFileNameWithoutExtension(pcfile);

+            if (packagesHash.ContainsKey(pname))

+                return;

+

+            List<string> fullassemblies = null;

+            string version = "";

+            string desc = "";

+

+            SystemPackage package = new SystemPackage();

+

+            using (StreamReader reader = new StreamReader(pcfile))

+            {

+                string line;

+                while ((line = reader.ReadLine()) != null)

+                {

+                    string lowerLine = line.ToLower();

+                    if (lowerLine.StartsWith("libs:") && lowerLine.IndexOf(".dll") != -1)

+                    {

+                        string choppedLine = line.Substring(5).Trim();

+                        if (choppedLine.IndexOf("-lib:") != -1 || choppedLine.IndexOf("/lib:") != -1)

+                        {

+                            fullassemblies = GetAssembliesWithLibInfo(choppedLine, pcfile);

+                        }

+                        else

+                        {

+                            fullassemblies = GetAssembliesWithoutLibInfo(choppedLine, pcfile);

+                        }

+                    }

+                    else if (lowerLine.StartsWith("version:"))

+                    {

+                        // "version:".Length == 8

+                        version = line.Substring(8).Trim();

+                    }

+                    else if (lowerLine.StartsWith("description:"))

+                    {

+                        // "description:".Length == 12

+                        desc = line.Substring(12).Trim();

+                    }

+                }

+            }

+

+            if (fullassemblies == null)

+                return;

+

+            foreach (string assembly in fullassemblies)

+            {

+                AddAssembly(assembly, package);

+            }

+

+            package.Initialize(pname,

+                               version,

+                               desc,

+                               fullassemblies.ToArray(),

+                               ClrVersion.Default,

+                               false);

+            packages.Add(package);

+            packagesHash[pname] = package;

+        }

+

+        void RegisterSystemAssemblies(string prefix, string version, ClrVersion ver)

+        {

+            SystemPackage package = new SystemPackage();

+            List<string> list = new List<string>();

+

+            string dir = Path.Combine(prefix, version);

+            if (!Directory.Exists(dir))

+            {

+                return;

+            }

+

+            foreach (string assembly in Directory.GetFiles(dir, "*.dll"))

+            {

+                AddAssembly(assembly, package);

+                list.Add(assembly);

+            }

+

+            package.Initialize("mono",

+                               version,

+                               "The Mono runtime",

+                               list.ToArray(),

+                               ver,

+                               false);

+            packages.Add(package);

+        }

+

+        void RunInitialization()

+        {

+            string versionDir;

+

+            if (Environment.Version.Major == 1)

+            {

+                versionDir = "1.0";

+            }

+            else

+            {

+                versionDir = "2.0";

+            }

+

+            //Pull up assemblies from the installed mono system.

+            string prefix = Path.GetDirectoryName(typeof(int).Assembly.Location);

+

+            if (prefix.IndexOf(Path.Combine("mono", versionDir)) == -1)

+                prefix = Path.Combine(prefix, "mono");

+            else

+                prefix = Path.GetDirectoryName(prefix);

+

+            RegisterSystemAssemblies(prefix, "1.0", ClrVersion.Net_1_1);

+            RegisterSystemAssemblies(prefix, "2.0", ClrVersion.Net_2_0);

+

+            string search_dirs = Environment.GetEnvironmentVariable("PKG_CONFIG_PATH");

+            string libpath = Environment.GetEnvironmentVariable("PKG_CONFIG_LIBPATH");

+

+            if (String.IsNullOrEmpty(libpath))

+            {

+                string path_dirs = Environment.GetEnvironmentVariable("PATH");

+                foreach (string pathdir in path_dirs.Split(Path.PathSeparator))

+                {

+                    if (pathdir == null)

+                        continue;

+                    if (File.Exists(pathdir + Path.DirectorySeparatorChar + "pkg-config"))

+                    {

+                        libpath = Path.Combine(pathdir, "..");

+                        libpath = Path.Combine(libpath, "lib");

+                        libpath = Path.Combine(libpath, "pkgconfig");

+                        break;

+                    }

+                }

+            }

+            search_dirs += Path.PathSeparator + libpath;

+            if (!string.IsNullOrEmpty(search_dirs))

+            {

+                List<string> scanDirs = new List<string>();

+                foreach (string potentialDir in search_dirs.Split(Path.PathSeparator))

+                {

+                    if (!scanDirs.Contains(potentialDir))

+                        scanDirs.Add(potentialDir);

+                }

+                foreach (string pcdir in scanDirs)

+                {

+                    if (pcdir == null)

+                        continue;

+

+                    if (Directory.Exists(pcdir))

+                    {

+                        foreach (string pcfile in Directory.GetFiles(pcdir, "*.pc"))

+                        {

+                            ParsePCFile(pcfile);

+                        }

+                    }

+                }

+            }

+        }

+

+        private void WriteCombine(SolutionNode solution)

+        {

+            #region "Create Solution directory if it doesn't exist"

+            string solutionDir = Path.Combine(solution.FullPath,

+                                              Path.Combine("autotools",

+                                                           solution.Name));

+            chkMkDir(solutionDir);

+            #endregion

+

+            #region "Write Solution-level files"

+            XsltArgumentList argList = new XsltArgumentList();

+            argList.AddParam("solutionName", "", solution.Name);

+            // $solutionDir is $rootDir/$solutionName/

+            transformToFile(Path.Combine(solutionDir, "configure.ac"),

+                            argList, "/Autotools/SolutionConfigureAc");

+            transformToFile(Path.Combine(solutionDir, "Makefile.am"),

+                            argList, "/Autotools/SolutionMakefileAm");

+            transformToFile(Path.Combine(solutionDir, "autogen.sh"),

+                            argList, "/Autotools/SolutionAutogenSh");

+            #endregion

+

+            foreach (ProjectNode project in solution.ProjectsTableOrder)

+            {

+              m_Kernel.Log.Write(String.Format("Writing project: {0}",

+                                               project.Name));

+              WriteProject(solution, project);

+            }

+        }

+

+        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 solutionDir = Path.Combine(solution.FullPath, Path.Combine("autotools", solution.Name));

+            string projectDir = Path.Combine(solutionDir, project.Name);

+            string projectVersion = project.Version;

+            bool hasAssemblyConfig = false;

+            chkMkDir(projectDir);

+

+            List<string>

+                compiledFiles = new List<string>(),

+                contentFiles = new List<string>(),

+                embeddedFiles = new List<string>(),

+

+                binaryLibs = new List<string>(),

+                pkgLibs = new List<string>(),

+                systemLibs = new List<string>(),

+                runtimeLibs = new List<string>(),

+

+                extraDistFiles = new List<string>(),

+                localCopyTargets = new List<string>();

+

+            // If there exists a .config file for this assembly, copy

+            // it to the project folder

+

+            // TODO: Support copying .config.osx files

+            // TODO: support processing the .config file for native library deps

+            string projectAssemblyName = project.Name;

+            if (project.AssemblyName != null)

+                projectAssemblyName = project.AssemblyName;

+

+            if (File.Exists(Path.Combine(project.FullPath, projectAssemblyName) + ".dll.config"))

+            {

+                hasAssemblyConfig = true;

+                System.IO.File.Copy(Path.Combine(project.FullPath, projectAssemblyName + ".dll.config"), Path.Combine(projectDir, projectAssemblyName + ".dll.config"), true);

+                extraDistFiles.Add(project.AssemblyName + ".dll.config");

+            }

+

+            foreach (ConfigurationNode conf in project.Configurations)

+            {

+                if (conf.Options.KeyFile != string.Empty)

+                {

+                    // Copy snk file into the project's directory

+                    // Use the snk from the project directory directly

+                    string source = Path.Combine(project.FullPath, conf.Options.KeyFile);

+                    string keyFile = conf.Options.KeyFile;

+                    Regex re = new Regex(".*/");

+                    keyFile = re.Replace(keyFile, "");

+

+                    string dest = Path.Combine(projectDir, keyFile);

+                    // Tell the user if there's a problem copying the file

+                    try

+                    {

+                        mkdirDashP(System.IO.Path.GetDirectoryName(dest));

+                        System.IO.File.Copy(source, dest, true);

+                    }

+                    catch (System.IO.IOException e)

+                    {

+                        Console.WriteLine(e.Message);

+                    }

+                }

+            }

+

+            // Copy compiled, embedded and content files into the project's directory

+            foreach (string filename in project.Files)

+            {

+                string source = Path.Combine(project.FullPath, filename);

+                string dest = Path.Combine(projectDir, filename);

+

+                if (filename.Contains("AssemblyInfo.cs"))

+                {

+                    // If we've got an AssemblyInfo.cs, pull the version number from it

+                    string[] sources = { source };

+                    string[] args = { "" };

+                    Microsoft.CSharp.CSharpCodeProvider cscp =

+                        new Microsoft.CSharp.CSharpCodeProvider();

+

+                    string tempAssemblyFile = Path.Combine(Path.GetTempPath(), project.Name + "-temp.dll");

+                    System.CodeDom.Compiler.CompilerParameters cparam =

+                        new System.CodeDom.Compiler.CompilerParameters(args, tempAssemblyFile);

+                    

+                    System.CodeDom.Compiler.CompilerResults cr =

+                        cscp.CompileAssemblyFromFile(cparam, sources);

+

+                    foreach (System.CodeDom.Compiler.CompilerError error in cr.Errors)

+                        Console.WriteLine("Error! '{0}'", error.ErrorText);

+

+                    try {

+                      string projectFullName = cr.CompiledAssembly.FullName;

+                      Regex verRegex = new Regex("Version=([\\d\\.]+)");

+                      Match verMatch = verRegex.Match(projectFullName);

+                      if (verMatch.Success)

+                        projectVersion = verMatch.Groups[1].Value;

+                    }catch{

+                      Console.WriteLine("Couldn't compile AssemblyInfo.cs");

+                    }

+

+                    // Clean up the temp file

+                    try

+                    {

+                        if (File.Exists(tempAssemblyFile))

+                            File.Delete(tempAssemblyFile);

+                    }

+                    catch 

+                    {

+                        Console.WriteLine("Error! '{0}'", e);

+                    }

+                   

+                }

+

+                // Tell the user if there's a problem copying the file

+                try

+                {

+                    mkdirDashP(System.IO.Path.GetDirectoryName(dest));

+                    System.IO.File.Copy(source, dest, true);

+                }

+                catch (System.IO.IOException e)

+                {

+                    Console.WriteLine(e.Message);

+                }

+

+                switch (project.Files.GetBuildAction(filename))

+                {

+                    case BuildAction.Compile:

+                        compiledFiles.Add(filename);

+                        break;

+                    case BuildAction.Content:

+                        contentFiles.Add(filename);

+                        extraDistFiles.Add(filename);

+                        break;

+                    case BuildAction.EmbeddedResource:

+                        embeddedFiles.Add(filename);

+                        break;

+                }

+            }

+

+            // Set up references

+            for (int refNum = 0; refNum < project.References.Count; refNum++)

+            {

+                ReferenceNode refr = project.References[refNum];

+                Assembly refAssembly = Assembly.LoadWithPartialName(refr.Name);

+

+                /* Determine which pkg-config (.pc) file refers to

+                   this assembly */

+

+                SystemPackage package = null;

+

+                if (packagesHash.ContainsKey(refr.Name))

+                {

+                  package = packagesHash[refr.Name];

+

+                }

+                else

+                {

+                    string assemblyFullName = string.Empty;

+                    if (refAssembly != null)

+                        assemblyFullName = refAssembly.FullName;

+

+                    string assemblyFileName = string.Empty;

+                    if (assemblyFullName != string.Empty &&

+                        assemblyFullNameToPath.ContainsKey(assemblyFullName)

+                        )

+                        assemblyFileName =

+                          assemblyFullNameToPath[assemblyFullName];

+

+                    if (assemblyFileName != string.Empty &&

+                        assemblyPathToPackage.ContainsKey(assemblyFileName)

+                        )

+                        package = assemblyPathToPackage[assemblyFileName];

+

+                }

+

+                /* If we know the .pc file and it is not "mono"

+                   (already in the path), add a -pkg: argument */

+

+                if (package != null &&

+                    package.Name != "mono" &&

+                    !pkgLibs.Contains(package.Name)

+                    )

+                    pkgLibs.Add(package.Name);

+

+                string fileRef =

+                  FindFileReference(refr.Name, (ProjectNode)refr.Parent);

+

+                if (refr.LocalCopy ||

+                    solution.ProjectsTable.ContainsKey(refr.Name) ||

+                    fileRef != null ||

+                    refr.Path != null

+                    )

+                {

+

+                    /* Attempt to copy the referenced lib to the

+                       project's directory */

+

+                    string filename = refr.Name + ".dll";

+                    string source = filename;

+                    if (refr.Path != null)

+                        source = Path.Combine(refr.Path, source);

+                    source = Path.Combine(project.FullPath, source);

+                    string dest = Path.Combine(projectDir, filename);

+

+                    /* Since we depend on this binary dll to build, we

+                     * will add a compile- time dependency on the

+                     * copied dll, and add the dll to the list of

+                     * files distributed with this package

+                     */

+

+                    binaryLibs.Add(refr.Name + ".dll");

+                    extraDistFiles.Add(refr.Name + ".dll");

+

+                    // TODO: Support copying .config.osx files

+                    // TODO: Support for determining native dependencies

+                    if (File.Exists(source + ".config"))

+                    {

+                        System.IO.File.Copy(source + ".config", Path.GetDirectoryName(dest), true);

+                        extraDistFiles.Add(refr.Name + ".dll.config");

+                    }

+

+                    try

+                    {

+                        System.IO.File.Copy(source, dest, true);

+                    }

+                    catch (System.IO.IOException)

+                    {

+                      if (solution.ProjectsTable.ContainsKey(refr.Name)){

+

+                        /* If an assembly is referenced, marked for

+                         * local copy, in the list of projects for

+                         * this solution, but does not exist, put a

+                         * target into the Makefile.am to build the

+                         * assembly and copy it to this project's

+                         * directory

+                         */

+

+                        ProjectNode sourcePrj =

+                          ((solution.ProjectsTable[refr.Name]));

+

+                        string target =

+                          String.Format("{0}:\n" +

+                                        "\t$(MAKE) -C ../{1}\n" +

+                                        "\tln ../{2}/$@ $@\n",

+                                        filename,

+                                        sourcePrj.Name,

+                                        sourcePrj.Name );

+

+                        localCopyTargets.Add(target);

+                      }

+                    }

+                }

+                else if( !pkgLibs.Contains(refr.Name) )

+                {

+                    // Else, let's assume it's in the GAC or the lib path

+                    string assemName = string.Empty;

+                    int index = refr.Name.IndexOf(",");

+

+                    if (index > 0)

+                        assemName = refr.Name.Substring(0, index);

+                    else

+                        assemName = refr.Name;

+

+                    m_Kernel.Log.Write(String.Format(

+                    "Warning: Couldn't find an appropriate assembly " +

+                    "for reference:\n'{0}'", refr.Name

+                                                     ));

+                    systemLibs.Add(assemName);

+                }

+            }

+

+            const string lineSep = " \\\n\t";

+            string compiledFilesString = string.Empty;

+            if (compiledFiles.Count > 0)

+                compiledFilesString =

+                    lineSep + string.Join(lineSep, compiledFiles.ToArray());

+

+            string embeddedFilesString = "";

+            if (embeddedFiles.Count > 0)

+                embeddedFilesString =

+                    lineSep + string.Join(lineSep, embeddedFiles.ToArray());

+

+            string contentFilesString = "";

+            if (contentFiles.Count > 0)

+                contentFilesString =

+                    lineSep + string.Join(lineSep, contentFiles.ToArray());

+

+            string extraDistFilesString = "";

+            if (extraDistFiles.Count > 0)

+                extraDistFilesString =

+                    lineSep + string.Join(lineSep, extraDistFiles.ToArray());

+

+            string pkgLibsString = "";

+            if (pkgLibs.Count > 0)

+                pkgLibsString =

+                    lineSep + string.Join(lineSep, pkgLibs.ToArray());

+

+            string binaryLibsString = "";

+            if (binaryLibs.Count > 0)

+                binaryLibsString =

+                    lineSep + string.Join(lineSep, binaryLibs.ToArray());

+

+            string systemLibsString = "";

+            if (systemLibs.Count > 0)

+                systemLibsString =

+                    lineSep + string.Join(lineSep, systemLibs.ToArray());

+

+            string localCopyTargetsString = "";

+            if (localCopyTargets.Count > 0)

+                localCopyTargetsString =

+                    string.Join("\n", localCopyTargets.ToArray());

+

+            string monoPath = "";

+            foreach (string runtimeLib in runtimeLibs)

+            {

+                monoPath += ":`pkg-config --variable=libdir " + runtimeLib + "`";

+            }

+

+            // Add the project name to the list of transformation

+            // parameters

+            XsltArgumentList argList = new XsltArgumentList();

+            argList.AddParam("projectName", "", project.Name);

+            argList.AddParam("solutionName", "", solution.Name);

+            argList.AddParam("assemblyName", "", projectAssemblyName);

+            argList.AddParam("compiledFiles", "", compiledFilesString);

+            argList.AddParam("embeddedFiles", "", embeddedFilesString);

+            argList.AddParam("contentFiles", "", contentFilesString);

+            argList.AddParam("extraDistFiles", "", extraDistFilesString);

+            argList.AddParam("pkgLibs", "", pkgLibsString);

+            argList.AddParam("binaryLibs", "", binaryLibsString);

+            argList.AddParam("systemLibs", "", systemLibsString);

+            argList.AddParam("monoPath", "", monoPath);

+            argList.AddParam("localCopyTargets", "", localCopyTargetsString);

+            argList.AddParam("projectVersion", "", projectVersion);

+            argList.AddParam("hasAssemblyConfig", "", hasAssemblyConfig ? "true" : "");

+

+            // Transform the templates

+            transformToFile(Path.Combine(projectDir, "configure.ac"), argList, "/Autotools/ProjectConfigureAc");

+            transformToFile(Path.Combine(projectDir, "Makefile.am"), argList, "/Autotools/ProjectMakefileAm");

+            transformToFile(Path.Combine(projectDir, "autogen.sh"), argList, "/Autotools/ProjectAutogenSh");

+

+            if (project.Type == Core.Nodes.ProjectType.Library)

+                transformToFile(Path.Combine(projectDir, project.Name + ".pc.in"), argList, "/Autotools/ProjectPcIn");

+            if (project.Type == Core.Nodes.ProjectType.Exe || project.Type == Core.Nodes.ProjectType.WinExe)

+                transformToFile(Path.Combine(projectDir, project.Name.ToLower() + ".in"), argList, "/Autotools/ProjectWrapperScriptIn");

+        }

+

+        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;

+            m_Kernel.Log.Write("Parsing system pkg-config files");

+            RunInitialization();

+

+            const string streamName = "autotools.xml";

+            string fqStreamName = String.Format("Prebuild.data.{0}",

+                                                streamName

+                                                );

+

+            // Retrieve stream for the autotools template XML

+            Stream autotoolsStream = Assembly.GetExecutingAssembly()

+                .GetManifestResourceStream(fqStreamName);

+

+            if(autotoolsStream == null) {

+

+              /* 

+               * try without the default namespace prepended, in

+               * case prebuild.exe assembly was compiled with

+               * something other than Visual Studio .NET

+               */

+

+              autotoolsStream = Assembly.GetExecutingAssembly()

+                .GetManifestResourceStream(streamName);

+              if(autotoolsStream == null){

+                string errStr =

+                  String.Format("Could not find embedded resource file:\n" +

+                                "'{0}' or '{1}'",

+                                streamName, fqStreamName

+                                );

+

+                m_Kernel.Log.Write(errStr);

+

+                throw new System.Reflection.TargetException(errStr);

+              }

+            }

+

+            // Create an XML URL Resolver with default credentials

+            xr = new System.Xml.XmlUrlResolver();

+            xr.Credentials = CredentialCache.DefaultCredentials;

+

+            // Create a default evidence - no need to limit access

+            e = new System.Security.Policy.Evidence();

+

+            // Load the autotools XML

+            autotoolsDoc = new XmlDocument();

+            autotoolsDoc.Load(autotoolsStream);

+

+            /* rootDir is the filesystem location where the Autotools

+             * build tree will be created - for now we'll make it

+             * $PWD/autotools

+             */

+

+            string pwd = Directory.GetCurrentDirectory();

+            //string pwd = System.Environment.GetEnvironmentVariable("PWD");

+            //if (pwd.Length != 0)

+            //{

+            string rootDir = Path.Combine(pwd, "autotools");

+            //}

+            //else

+            //{

+            //    pwd = Assembly.GetExecutingAssembly()

+            //}

+            chkMkDir(rootDir);

+

+            foreach (SolutionNode solution in kern.Solutions)

+            {

+              m_Kernel.Log.Write(String.Format("Writing solution: {0}",

+                                        solution.Name));

+              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..650007e
--- /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 08:42:51 +0100 (Wed, 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/MakefileTarget.cs b/Prebuild/src/Core/Targets/MakefileTarget.cs
new file mode 100644
index 0000000..54046dd
--- /dev/null
+++ b/Prebuild/src/Core/Targets/MakefileTarget.cs
@@ -0,0 +1,469 @@
+#region BSD License
+/*
+Copyright (c) 2004 Crestez Leonard (cleonard@go.ro)
+
+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
+
+using System;
+using System.IO;
+using System.Text.RegularExpressions;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+    [Target("makefile")]
+    public class MakefileTarget : ITarget
+    {
+        #region Fields
+
+        private Kernel m_Kernel = null;
+
+        #endregion
+
+        #region Private Methods
+
+        // This converts a path relative to the path of a project to
+        // a path relative to the solution path.
+        private string NicePath(ProjectNode proj, string path)
+        {
+            string res;
+            SolutionNode solution = (SolutionNode)proj.Parent;
+            res = Path.Combine(Helper.NormalizePath(proj.FullPath, '/'), Helper.NormalizePath(path, '/'));
+            res = Helper.NormalizePath(res, '/');
+            res = res.Replace("/./", "/");
+            while (res.IndexOf("/../") >= 0)
+            {
+                int a = res.IndexOf("/../");
+                int b = res.LastIndexOf("/", a - 1);
+                res = res.Remove(b, a - b + 3);
+            }
+            res = Helper.MakePathRelativeTo(solution.FullPath, res);
+            if (res.StartsWith("./"))
+                res = res.Substring(2, res.Length - 2);
+            res = Helper.NormalizePath(res, '/');
+            return res;
+        }
+
+        private void WriteProjectFiles(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            // Write list of source code files
+            f.WriteLine("SOURCES_{0} = \\", project.Name);
+            foreach (string file in project.Files)
+                if (project.Files.GetBuildAction(file) == BuildAction.Compile)
+                    f.WriteLine("\t{0} \\", NicePath(project, file));
+            f.WriteLine();
+
+            // Write list of resource files
+            f.WriteLine("RESOURCES_{0} = \\", project.Name);
+            foreach (string file in project.Files)
+                if (project.Files.GetBuildAction(file) == BuildAction.EmbeddedResource)
+                {
+                    string path = NicePath(project, file);
+                    f.WriteLine("\t-resource:{0},{1} \\", path, Path.GetFileName(path));
+                }
+            f.WriteLine();
+
+            // There's also Content and None in BuildAction.
+            // What am I supposed to do with that?
+        }
+
+        private string FindFileReference(string refName, ProjectNode project)
+        {
+            foreach (ReferencePathNode refPath in project.ReferencePaths)
+            {
+                string fullPath = NicePath(project, Helper.MakeFilePath(refPath.Path, refName, "dll"));
+                if (File.Exists(fullPath))
+                    return fullPath;
+            }
+            return null;
+        }
+
+        private void WriteProjectReferences(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            f.WriteLine("REFERENCES_{0} = \\", project.Name);
+            foreach (ReferenceNode refr in project.References)
+            {
+                string path;
+                // Project references change with configurations.
+                if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    continue;
+                path = FindFileReference(refr.Name, project);
+                if (path != null)
+                    f.WriteLine("\t-r:{0} \\", path);
+                else
+                    f.WriteLine("\t-r:{0} \\", refr.Name);
+            }
+            f.WriteLine();
+        }
+
+        private void WriteProjectDependencies(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            f.WriteLine("DEPENDENCIES_{0} = \\", project.Name);
+            f.WriteLine("\t$(SOURCES_{0}) \\", project.Name);
+            foreach (string file in project.Files)
+                if (project.Files.GetBuildAction(file) == BuildAction.EmbeddedResource)
+                    f.WriteLine("\t{0} \\", NicePath(project, file));
+            f.WriteLine();
+        }
+
+        private string ProjectTypeToExtension(ProjectType t)
+        {
+            if (t == ProjectType.Exe || t == ProjectType.WinExe)
+            {
+                return "exe";
+            }
+            else if (t == ProjectType.Library)
+            {
+                return "dll";
+            }
+            else
+            {
+                throw new FatalException("Bad ProjectType: {0}", t);
+            }
+        }
+
+        private string ProjectTypeToTarget(ProjectType t)
+        {
+            if (t == ProjectType.Exe)
+            {
+                return "exe";
+            }
+            else if (t == ProjectType.WinExe)
+            {
+                return "winexe";
+            }
+            else if (t == ProjectType.Library)
+            {
+                return "library";
+            }
+            else
+            {
+                throw new FatalException("Bad ProjectType: {0}", t);
+            }
+        }
+
+        private string ProjectOutput(ProjectNode project, ConfigurationNode config)
+        {
+            string filepath;
+            filepath = Helper.MakeFilePath((string)config.Options["OutputPath"],
+                    project.AssemblyName, ProjectTypeToExtension(project.Type));
+            return NicePath(project, filepath);
+        }
+
+        // Returns true if two configs in one project have the same output.
+        private bool ProjectClashes(ProjectNode project)
+        {
+            foreach (ConfigurationNode conf1 in project.Configurations)
+                foreach (ConfigurationNode conf2 in project.Configurations)
+                    if (ProjectOutput(project, conf1) == ProjectOutput(project, conf2) && conf1 != conf2)
+                    {
+                        m_Kernel.Log.Write("Warning: Configurations {0} and {1} for project {2} output the same file",
+                                conf1.Name, conf2.Name, project.Name);
+                        m_Kernel.Log.Write("Warning: I'm going to use some timestamps(extra empty files).");
+                        return true;
+                    }
+            return false;
+        }
+
+        private void WriteProject(StreamWriter f, SolutionNode solution, ProjectNode project)
+        {
+            f.WriteLine("# This is for project {0}", project.Name);
+            f.WriteLine();
+
+            WriteProjectFiles(f, solution, project);
+            WriteProjectReferences(f, solution, project);
+            WriteProjectDependencies(f, solution, project);
+
+            bool clash = ProjectClashes(project);
+
+            foreach (ConfigurationNode conf in project.Configurations)
+            {
+                string outpath = ProjectOutput(project, conf);
+                string filesToClean = outpath;
+
+                if (clash)
+                {
+                    f.WriteLine("{0}-{1}: .{0}-{1}-timestamp", project.Name, conf.Name);
+                    f.WriteLine();
+                    f.Write(".{0}-{1}-timestamp: $(DEPENDENCIES_{0})", project.Name, conf.Name);
+                }
+                else
+                {
+                    f.WriteLine("{0}-{1}: {2}", project.Name, conf.Name, outpath);
+                    f.WriteLine();
+                    f.Write("{2}: $(DEPENDENCIES_{0})", project.Name, conf.Name, outpath);
+                }
+                // Dependencies on other projects.
+                foreach (ReferenceNode refr in project.References)
+                    if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    {
+                        ProjectNode refProj = (ProjectNode)solution.ProjectsTable[refr.Name];
+                        if (ProjectClashes(refProj))
+                            f.Write(" .{0}-{1}-timestamp", refProj.Name, conf.Name);
+                        else
+                            f.Write(" {0}", ProjectOutput(refProj, conf));
+                    }
+                f.WriteLine();
+
+                // make directory for output.
+                if (Path.GetDirectoryName(outpath) != "")
+                {
+                    f.WriteLine("\tmkdir -p {0}", Path.GetDirectoryName(outpath));
+                }
+                // mcs command line.
+                f.Write("\tgmcs", project.Name);
+                f.Write(" -warn:{0}", conf.Options["WarningLevel"]);
+                if ((bool)conf.Options["DebugInformation"])
+                    f.Write(" -debug");
+                if ((bool)conf.Options["AllowUnsafe"])
+                    f.Write(" -unsafe");
+                if ((bool)conf.Options["CheckUnderflowOverflow"])
+                    f.Write(" -checked");
+                if (project.StartupObject != "")
+                    f.Write(" -main:{0}", project.StartupObject);
+                if ((string)conf.Options["CompilerDefines"] != "")
+                {
+                    f.Write(" -define:\"{0}\"", conf.Options["CompilerDefines"]);
+                }
+
+                f.Write(" -target:{0} -out:{1}", ProjectTypeToTarget(project.Type), outpath);
+
+                // Build references to other projects. Now that sux.
+                // We have to reference the other project in the same conf.
+                foreach (ReferenceNode refr in project.References)
+                    if (solution.ProjectsTable.ContainsKey(refr.Name))
+                    {
+                        ProjectNode refProj;
+                        refProj = (ProjectNode)solution.ProjectsTable[refr.Name];
+                        f.Write(" -r:{0}", ProjectOutput(refProj, conf));
+                    }
+
+                f.Write(" $(REFERENCES_{0})", project.Name);
+                f.Write(" $(RESOURCES_{0})", project.Name);
+                f.Write(" $(SOURCES_{0})", project.Name);
+                f.WriteLine();
+
+                // Copy references with localcopy.
+                foreach (ReferenceNode refr in project.References)
+                    if (refr.LocalCopy)
+                    {
+                        string outPath, srcPath, destPath;
+                        outPath = Helper.NormalizePath((string)conf.Options["OutputPath"]);
+                        if (solution.ProjectsTable.ContainsKey(refr.Name))
+                        {
+                            ProjectNode refProj;
+                            refProj = (ProjectNode)solution.ProjectsTable[refr.Name];
+                            srcPath = ProjectOutput(refProj, conf);
+                            destPath = Path.Combine(outPath, Path.GetFileName(srcPath));
+                            destPath = NicePath(project, destPath);
+                            if (srcPath != destPath)
+                            {
+                                f.WriteLine("\tcp -f {0} {1}", srcPath, destPath);
+                                filesToClean += " " + destPath;
+                            }
+                            continue;
+                        }
+                        srcPath = FindFileReference(refr.Name, project);
+                        if (srcPath != null)
+                        {
+                            destPath = Path.Combine(outPath, Path.GetFileName(srcPath));
+                            destPath = NicePath(project, destPath);
+                            f.WriteLine("\tcp -f {0} {1}", srcPath, destPath);
+                            filesToClean += " " + destPath;
+                        }
+                    }
+
+                if (clash)
+                {
+                    filesToClean += String.Format(" .{0}-{1}-timestamp", project.Name, conf.Name);
+                    f.WriteLine("\ttouch .{0}-{1}-timestamp", project.Name, conf.Name);
+                    f.Write("\trm -rf");
+                    foreach (ConfigurationNode otherConf in project.Configurations)
+                        if (otherConf != conf)
+                            f.WriteLine(" .{0}-{1}-timestamp", project.Name, otherConf.Name);
+                    f.WriteLine();
+                }
+                f.WriteLine();
+                f.WriteLine("{0}-{1}-clean:", project.Name, conf.Name);
+                f.WriteLine("\trm -rf {0}", filesToClean);
+                f.WriteLine();
+            }
+        }
+
+        private void WriteIntro(StreamWriter f, SolutionNode solution)
+        {
+            f.WriteLine("# Makefile for {0} generated by Prebuild ( http://dnpb.sf.net )", solution.Name);
+            f.WriteLine("# Do not edit.");
+            f.WriteLine("#");
+
+            f.Write("# Configurations:");
+            foreach (ConfigurationNode conf in solution.Configurations)
+                f.Write(" {0}", conf.Name);
+            f.WriteLine();
+
+            f.WriteLine("# Projects:");
+            foreach (ProjectNode proj in solution.Projects)
+                f.WriteLine("#\t{0}", proj.Name);
+
+            f.WriteLine("#");
+            f.WriteLine("# Building:");
+            f.WriteLine("#\t\"make\" to build everything under the default(first) configuration");
+            f.WriteLine("#\t\"make CONF\" to build every project under configuration CONF");
+            f.WriteLine("#\t\"make PROJ\" to build project PROJ under the default(first) configuration");
+            f.WriteLine("#\t\"make PROJ-CONF\" to build project PROJ under configuration CONF");
+            f.WriteLine("#");
+            f.WriteLine("# Cleaning (removing results of build):");
+            f.WriteLine("#\t\"make clean\" to clean everything, that's what you probably want");
+            f.WriteLine("#\t\"make CONF\" to clean everything for a configuration");
+            f.WriteLine("#\t\"make PROJ\" to clean everything for a project");
+            f.WriteLine("#\t\"make PROJ-CONF\" to clea project PROJ under configuration CONF");
+            f.WriteLine();
+        }
+
+        private void WritePhony(StreamWriter f, SolutionNode solution)
+        {
+            string defconf = "";
+            foreach (ConfigurationNode conf in solution.Configurations)
+            {
+                defconf = conf.Name;
+                break;
+            }
+
+            f.Write(".PHONY: all");
+            foreach (ProjectNode proj in solution.Projects)
+                f.Write(" {0} {0}-clean", proj.Name);
+            foreach (ConfigurationNode conf in solution.Configurations)
+                f.Write(" {0} {0}-clean", conf.Name);
+            foreach (ProjectNode proj in solution.Projects)
+                foreach (ConfigurationNode conf in solution.Configurations)
+                    f.Write(" {0}-{1} {0}-{1}-clean", proj.Name, conf.Name);
+            f.WriteLine();
+            f.WriteLine();
+
+            f.WriteLine("all: {0}", defconf);
+            f.WriteLine();
+
+            f.Write("clean:");
+            foreach (ConfigurationNode conf in solution.Configurations)
+                f.Write(" {0}-clean", conf.Name);
+            f.WriteLine();
+            f.WriteLine();
+
+            foreach (ConfigurationNode conf in solution.Configurations)
+            {
+                f.Write("{0}: ", conf.Name);
+                foreach (ProjectNode proj in solution.Projects)
+                    f.Write(" {0}-{1}", proj.Name, conf.Name);
+                f.WriteLine();
+                f.WriteLine();
+
+                f.Write("{0}-clean: ", conf.Name);
+                foreach (ProjectNode proj in solution.Projects)
+                    f.Write(" {0}-{1}-clean", proj.Name, conf.Name);
+                f.WriteLine();
+                f.WriteLine();
+            }
+
+            foreach (ProjectNode proj in solution.Projects)
+            {
+                f.WriteLine("{0}: {0}-{1}", proj.Name, defconf);
+                f.WriteLine();
+
+                f.Write("{0}-clean:", proj.Name);
+                foreach (ConfigurationNode conf in proj.Configurations)
+                    f.Write(" {0}-{1}-clean", proj.Name, conf.Name);
+                f.WriteLine();
+                f.WriteLine();
+            }
+        }
+
+        private void WriteSolution(SolutionNode solution)
+        {
+            m_Kernel.Log.Write("Creating makefile for {0}", solution.Name);
+            m_Kernel.CurrentWorkingDirectory.Push();
+
+            string file = "Makefile";// Helper.MakeFilePath(solution.FullPath, solution.Name, "make");
+            StreamWriter f = new StreamWriter(file);
+
+            Helper.SetCurrentDir(Path.GetDirectoryName(file));
+
+            using (f)
+            {
+                WriteIntro(f, solution);
+                WritePhony(f, solution);
+
+                foreach (ProjectNode project in solution.Projects)
+                {
+                    m_Kernel.Log.Write("...Creating Project: {0}", project.Name);
+                    WriteProject(f, solution, project);
+                }
+            }
+
+            m_Kernel.Log.Write("");
+            m_Kernel.CurrentWorkingDirectory.Pop();
+        }
+
+        private void CleanSolution(SolutionNode solution)
+        {
+            m_Kernel.Log.Write("Cleaning makefile for {0}", solution.Name);
+
+            string file = Helper.MakeFilePath(solution.FullPath, solution.Name, "make");
+            Helper.DeleteIfExists(file);
+
+            m_Kernel.Log.Write("");
+        }
+
+        #endregion
+
+        #region ITarget Members
+
+        public void Write(Kernel kern)
+        {
+            m_Kernel = kern;
+            foreach (SolutionNode solution in kern.Solutions)
+                WriteSolution(solution);
+            m_Kernel = null;
+        }
+
+        public virtual void Clean(Kernel kern)
+        {
+            m_Kernel = kern;
+            foreach (SolutionNode sol in kern.Solutions)
+                CleanSolution(sol);
+            m_Kernel = null;
+        }
+
+        public string Name
+        {
+            get
+            {
+                return "makefile";
+            }
+        }
+
+        #endregion
+    }
+}
diff --git a/Prebuild/src/Core/Targets/MonoDevelopTarget.cs b/Prebuild/src/Core/Targets/MonoDevelopTarget.cs
new file mode 100644
index 0000000..ea6d2c2
--- /dev/null
+++ b/Prebuild/src/Core/Targets/MonoDevelopTarget.cs
@@ -0,0 +1,515 @@
+#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
+
+using System;
+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
+                                {
+                                        /*
+                                        Day changed to 28 Mar 2007
+                                        ...
+                                        08:09 < cj> is there anything that replaces Assembly.LoadFromPartialName() ?
+                                        08:09 < jonp> no
+                                        08:10 < jonp> in their infinite wisdom [sic], microsoft decided that the 
+                                                      ability to load any assembly version by-name was an inherently 
+                                                      bad idea
+                                        08:11 < cj> I'm thinking of a bunch of four-letter words right now...
+                                        08:11 < cj> security through making it difficult for the developer!!!
+                                        08:12 < jonp> just use the Obsolete API
+                                        08:12 < jonp> it should still work
+                                        08:12 < cj> alrighty.
+                                        08:12 < jonp> you just get warnings when using it
+                                        */
+                                        Assembly assem = Assembly.LoadWithPartialName(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=\"{0}\"", !conf.Options.WarningsAsErrors);
+                                        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;
+                                        string dependson = "";
+                                        string resource_id = "";
+                                        string copyToOutput = "";
+                                        
+                                        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;
+                                        }
+
+                    if (project.Files.GetCopyToOutput(file) != CopyToOutput.Never)
+                                                    buildAction = "FileCopy";
+
+                                        // Sort of a hack, we try and resolve the path and make it relative, if we can.
+                                        string extension = Path.GetExtension(file);
+                                        string designer_format = string.Format(".Designer{0}", extension);
+
+                                        if (file.EndsWith(designer_format))
+                                        {
+                                                string basename = file.Substring(0, file.LastIndexOf(designer_format));
+                                                string[] extensions = new string[] { ".cs", ".resx", ".settings" };
+
+                                                foreach(string ext in extensions)
+                                                {
+                                                        if (project.Files.Contains(basename + ext))
+                                                        {
+                                                                dependson = string.Format(" dependson=\"{0}{1}\"", basename, ext);
+                                                                break;
+                                                        }
+                                                }
+                                        }
+                                        if (extension == ".resx")
+                                        {
+                                                buildAction = "EmbedAsResource";
+                                                string basename = file.Substring(0, file.LastIndexOf(".resx"));                                         
+                                                
+                                                // Visual Studio type resx + form dependency
+                                                if (project.Files.Contains(basename + ".cs"))
+                                                {
+                                                        dependson = string.Format(" dependson=\"{0}{1}\"", basename, ".cs");
+                                                }
+
+                                                // We need to specify a resources file name to avoid MissingManifestResourceExceptions
+                                                // in libraries that are built.
+                                                resource_id = string.Format(" resource_id=\"{0}.{1}.resources\"",
+                                                                project.AssemblyName, basename.Replace("/", "."));
+                                        }
+
+                                        switch(project.Files.GetCopyToOutput(file))
+                                        {
+                                                case CopyToOutput.Always:
+                                                        copyToOutput = string.Format(" copyToOutputDirectory=\"Always\"");
+                                                        break;
+                                                case CopyToOutput.PreserveNewest:
+                                                        copyToOutput = string.Format(" copyToOutputDirectory=\"PreserveNewest\"");
+                                                        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}\"{2}{3}{4} />", 
+                                                     filePath, buildAction, dependson, resource_id, copyToOutput);
+                                }
+                                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..d4a33f8
--- /dev/null
+++ b/Prebuild/src/Core/Targets/NAntTarget.cs
@@ -0,0 +1,792 @@
+#region BSD License
+/*
+Copyright (c) 2004 - 2008
+Matthew Holmes            (matthew@wildfiregames.com),
+Dan             Moorehead         (dan05a@gmail.com),
+C.J.    Adams-Collier (cjac@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
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+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)
+        {
+
+            if (!String.IsNullOrEmpty(refr.Path))
+            {
+                return refr.Path;
+            }
+            
+            if (solution.ProjectsTable.ContainsKey(refr.Name))
+            {
+                ProjectNode projectRef = (ProjectNode) solution.ProjectsTable[refr.Name];
+                string finalPath =
+                    Helper.NormalizePath(refr.Name + GetProjectExtension(projectRef), '/');
+                return finalPath;
+            }
+
+            ProjectNode project = (ProjectNode) refr.Parent;
+
+            // Do we have an explicit file reference?
+            string fileRef = FindFileReference(refr.Name, project);
+            if (fileRef != null)
+            {
+                return fileRef;
+            }
+
+            // Is there an explicit path in the project ref?
+            if (refr.Path != null)
+            {
+                return Helper.NormalizePath(refr.Path + "/" + refr.Name + GetProjectExtension(project), '/');
+            }
+
+            // No, it's an extensionless GAC ref, but nant needs the .dll extension anyway
+            return refr.Name + ".dll";
+        }
+
+            public static string GetRefFileName(string refName)
+        {
+            if (ExtensionSpecified(refName))
+            {
+                return refName;
+            }
+            else
+            {
+                return refName + ".dll";
+            }
+        }
+
+        private static bool ExtensionSpecified(string refName)
+        {
+            return refName.EndsWith(".dll") || refName.EndsWith(".exe");
+        }
+
+        private static string GetProjectExtension(ProjectNode project)
+        {
+            string extension = ".dll";
+            if (project.Type == ProjectType.Exe || project.Type == ProjectType.WinExe)
+            {
+                extension = ".exe";
+            }
+            return extension;
+        }
+
+                private static string FindFileReference(string refName, ProjectNode project)
+                {
+                        foreach (ReferencePathNode refPath in project.ReferencePaths)
+                        {
+                            string fullPath = Helper.MakeFilePath(refPath.Path, refName);
+
+                if (File.Exists(fullPath))
+                {
+                    return fullPath;
+                }
+
+                fullPath = Helper.MakeFilePath(refPath.Path, refName, "dll");
+
+                                if (File.Exists(fullPath))
+                                {
+                                        return fullPath;
+                                }
+
+                fullPath = Helper.MakeFilePath(refPath.Path, refName, "exe");
+
+                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 + GetProjectExtension(project), "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}\" flatten=\"true\">");
+                                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>");
+                                if (project.ConfigFile != null && project.ConfigFile.Length!=0)
+                                {
+                                        ss.Write("                <copy file=\"" + project.ConfigFile + "\" tofile=\"${project::get-base-directory()}/${build.dir}/${project::get-name()}");
+
+                                        if (project.Type == ProjectType.Library)
+                                        {
+                                                ss.Write(".dll.config\"");
+                                        }
+                                        else
+                                        {
+                                                ss.Write(".exe.config\"");
+                                        }
+                                        ss.WriteLine(" />");
+                                }
+
+                                // Add the content files to just be copied
+                                ss.WriteLine("            {0}", "<copy todir=\"${project::get-base-directory()}/${build.dir}\">");
+                                ss.WriteLine("                    {0}", "<fileset basedir=\".\">");
+                                
+                                foreach (string file in project.Files)
+                                {
+                                        // Ignore if we aren't content
+                                        if (project.Files.GetBuildAction(file) != BuildAction.Content)
+                                                        continue;
+
+                                        // Create a include tag
+                                        ss.WriteLine("                            {0}", "<include name=\"" + Helper.NormalizePath(PrependPath(file), '/') + "\" />");
+                                }
+
+                                ss.WriteLine("                    {0}", "</fileset>");
+                                ss.WriteLine("            {0}", "</copy>");
+
+                                ss.Write("                <csc ");
+                                ss.Write(" target=\"{0}\"", project.Type.ToString().ToLower());
+                                ss.Write(" debug=\"{0}\"", "${build.debug}");
+                                ss.Write(" platform=\"${build.platform}\"");
+
+
+                                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(" warnaserror=\"{0}\"", conf.Options.WarningsAsErrors);
+                                        break;
+                                }
+                                foreach (ConfigurationNode conf in project.Configurations)
+                                {
+                                        ss.Write(" define=\"{0}\"", conf.Options.CompilerDefines);
+                                        break;
+                                }
+                                foreach (ConfigurationNode conf in project.Configurations)
+                                {
+                                        ss.Write(" nostdlib=\"{0}\"", conf.Options["NoStdLib"]);
+                                        break;
+                                }
+
+                                ss.Write(" main=\"{0}\"", project.StartupObject);
+
+                                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, '/'));
+                                }
+                // This disables a very different behavior between VS and NAnt.  With Nant,
+                //    If you have using System.Xml;  it will ensure System.Xml.dll is referenced,
+                //    but not in VS.  This will force the behaviors to match, so when it works
+                //    in nant, it will work in VS.
+                ss.Write(" noconfig=\"true\"");
+                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()}\" />");
+                foreach(ReferencePathNode refPath in project.ReferencePaths)
+                {
+                    ss.WriteLine("                                        <include name=\"${project::get-base-directory()}/" + refPath.Path.TrimEnd('/', '\\') + "\" />");
+                }
+                                ss.WriteLine("                            </lib>");
+                                foreach (ReferenceNode refr in project.References)
+                                {
+                                        string path = Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, project, refr)), '/');
+                    if (refr.Path != null) {
+                        if (ExtensionSpecified(refr.Name))
+                        {
+                            ss.WriteLine ("                <include name=\"" + path + refr.Name + "\"/>");
+                        }
+                        else
+                        {
+                            ss.WriteLine ("                <include name=\"" + path + refr.Name + ".dll\"/>");
+                        }
+                    }
+                    else
+                    {
+                        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("                <include name=\"*.mdb\" if='${build.debug}'/>");
+                        ss.WriteLine("                <include name=\"*.pdb\" if='${build.debug}'/>");
+                        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()}\" />");
+
+                                // Use the active configuration, which is the first configuration name in the prebuild file.
+                                Dictionary<string,string> emittedConfigurations = new Dictionary<string, string>();
+
+                                ss.WriteLine("    <property name=\"project.config\" value=\"{0}\" />", solution.ActiveConfig);
+                                ss.WriteLine();
+
+                                foreach (ConfigurationNode conf in solution.Configurations)
+                                {
+                                        // If the name isn't in the emitted configurations, we give a high level target to the 
+                                        // platform specific on. This lets "Debug" point to "Debug-AnyCPU".
+                                        if (!emittedConfigurations.ContainsKey(conf.Name))
+                                        {
+                                                // Add it to the dictionary so we only emit one.
+                                                emittedConfigurations.Add(conf.Name, conf.Platform);
+
+                                                // Write out the target block.
+                                                ss.WriteLine("    <target name=\"{0}\" description=\"{0}|{1}\" depends=\"{0}-{1}\">", conf.Name, conf.Platform);
+                                                ss.WriteLine("    </target>");
+                                                ss.WriteLine();
+                                        }
+
+                                        // Write out the target for the configuration.
+                                        ss.WriteLine("    <target name=\"{0}-{1}\" description=\"{0}|{1}\">", conf.Name, conf.Platform);
+                                        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("\t\t  <property name=\"build.platform\" value=\"{0}\" />", conf.Platform);
+                                        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=\"net-3.5\" description=\"Sets framework to .NET 3.5\">");
+                                ss.WriteLine("            <property name=\"nant.settings.currentframework\" value=\"net-3.5\" />");
+                                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=\"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-3.5\" description=\"Sets framework to mono 3.5\">");
+                                ss.WriteLine("        <property name=\"nant.settings.currentframework\" value=\"mono-3.5\" />");
+                                ss.WriteLine("    </target>");
+                                ss.WriteLine();
+
+                ss.WriteLine("    <target name=\"init\" description=\"\">");
+                ss.WriteLine("        <call target=\"${project.config}\" />");
+                ss.WriteLine("        <property name=\"sys.os.platform\"");
+                ss.WriteLine("                  value=\"${platform::get-name()}\"");
+                ss.WriteLine("                  />");
+                ss.WriteLine("        <echo message=\"Platform ${sys.os.platform}\" />");
+                ss.WriteLine("        <property name=\"build.dir\" value=\"${bin.dir}/${project.config}\" />");
+                ss.WriteLine("    </target>");
+                ss.WriteLine();
+
+
+                // sdague - ok, this is an ugly hack, but what it lets
+                // us do is native include of files into the nant
+                // created files from all .nant/*include files.  This
+                // lets us keep using prebuild, but allows for
+                // extended nant targets to do build and the like.
+
+                try
+                {
+                    Regex re = new Regex(".include$");
+                    DirectoryInfo nantdir = new DirectoryInfo(".nant");
+                    foreach (FileSystemInfo item in nantdir.GetFileSystemInfos())
+                    {
+                        if (item is DirectoryInfo) { }
+                        else if (item is FileInfo)
+                        {
+                            if (re.Match(item.FullName) !=
+                                System.Text.RegularExpressions.Match.Empty)
+                            {
+                                Console.WriteLine("Including file: " + item.FullName);
+
+                                using (FileStream fs = new FileStream(item.FullName,
+                                                                      FileMode.Open,
+                                                                      FileAccess.Read,
+                                                                      FileShare.None))
+                                {
+                                    using (StreamReader sr = new StreamReader(fs))
+                                    {
+                                        ss.WriteLine("<!-- included from {0} -->", (item).FullName);
+                                        while (sr.Peek() != -1)
+                                        {
+                                            ss.WriteLine(sr.ReadLine());
+                                        }
+                                        ss.WriteLine();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch { }
+                // ss.WriteLine("   <include buildfile=\".nant/local.include\" />");
+                //                 ss.WriteLine("    <target name=\"zip\" description=\"\">");
+                //                 ss.WriteLine("       <zip zipfile=\"{0}-{1}.zip\">", solution.Name, solution.Version);
+                //                 ss.WriteLine("       <fileset basedir=\"${project::get-base-directory()}\">");
+
+                //                 ss.WriteLine("       <include name=\"${project::get-base-directory()}/**/*.cs\" />");
+                //                 // ss.WriteLine("       <include name=\"${project.main.dir}/**/*\" />");
+                //                 ss.WriteLine("       </fileset>");
+                //                 ss.WriteLine("       </zip>");
+                //                 ss.WriteLine("        <echo message=\"Building zip target\" />");
+                //                 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\" />");
+
+                // justincc: FIXME FIXME FIXME - A temporary OpenSim hack to clean up files when "nant clean" is executed.
+                // Should be replaced with extreme prejudice once anybody finds out if the CleanFiles stuff works or there is
+                // another working mechanism for specifying this stuff
+                ss.WriteLine("        <delete failonerror=\"false\">");
+                ss.WriteLine("        <fileset basedir=\"${bin.dir}\">");
+                ss.WriteLine("            <include name=\"OpenSim*.dll\"/>");
+                ss.WriteLine("            <include name=\"OpenSim*.exe\"/>");
+                ss.WriteLine("            <include name=\"ScriptEngines/*\"/>");
+                ss.WriteLine("            <include name=\"Physics/*\"/>");
+                ss.WriteLine("            <exclude name=\"OpenSim.32BitLaunch.exe\"/>");
+                ss.WriteLine("            <exclude name=\"ScriptEngines/Default.lsl\"/>");
+                ss.WriteLine("        </fileset>");
+                ss.WriteLine("        </delete>");
+
+                if (solution.Cleanup != null && solution.Cleanup.CleanFiles.Count > 0)
+                {
+                    foreach (CleanFilesNode cleanFile in solution.Cleanup.CleanFiles)
+                    {
+                        ss.WriteLine("        <delete failonerror=\"false\">");
+                        ss.WriteLine("            <fileset basedir=\"${project::get-base-directory()}\">");
+                        ss.WriteLine("                <include name=\"{0}/*\"/>", cleanFile.Pattern);
+                        ss.WriteLine("                <include name=\"{0}\"/>", cleanFile.Pattern);
+                        ss.WriteLine("            </fileset>");
+                        ss.WriteLine("        </delete>");
+                    }
+                }
+
+                            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 + GetProjectExtension(project), "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 + GetProjectExtension(project), "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 + GetProjectExtension(project), "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 + GetProjectExtension(project), "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..66dd1bc
--- /dev/null
+++ b/Prebuild/src/Core/Targets/SharpDevelop2Target.cs
@@ -0,0 +1,82 @@
+#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
+
+using System;
+
+using Prebuild.Core.Attributes;
+
+namespace Prebuild.Core.Targets
+{
+        /// <summary>
+        /// 
+        /// </summary>
+        [Target("sharpdev2")]
+        public class SharpDevelop2Target : VS2005Target
+    {
+        #region Properties
+        public override string VersionName
+        {
+            get
+            {
+                return "SharpDevelop2";
+            }
+        }
+        #endregion
+
+                #region Public Methods
+
+                /// <summary>
+                /// Writes the specified kern.
+                /// </summary>
+                /// <param name="kern">The kern.</param>
+                public override void Write(Kernel kern)
+                {
+                        base.Write(kern);
+                }
+
+                /// <summary>
+                /// Cleans the specified kern.
+                /// </summary>
+                /// <param name="kern">The kern.</param>
+                public override void Clean(Kernel kern)
+                {
+                        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..8e32050
--- /dev/null
+++ b/Prebuild/src/Core/Targets/SharpDevelopTarget.cs
@@ -0,0 +1,425 @@
+#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
+
+using System;
+using System.IO;
+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("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/ToolInfo.cs b/Prebuild/src/Core/Targets/ToolInfo.cs
new file mode 100644
index 0000000..935c674
--- /dev/null
+++ b/Prebuild/src/Core/Targets/ToolInfo.cs
@@ -0,0 +1,197 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+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;
+                        }
+                }
+                public string LanguageExtension
+                {
+                        get
+                        {
+                                switch (this.Name)
+                                {
+                                        case "C#":
+                                                return ".cs";
+                                        case "VisualBasic":
+                                                return ".vb";
+                                        case "Boo":
+                                                return ".boo";
+                                        default:
+                                                return ".cs";
+                                }
+                        }
+                }
+                /// <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();
+
+                }
+        }
+}
diff --git a/Prebuild/src/Core/Targets/VS2002Target.cs b/Prebuild/src/Core/Targets/VS2002Target.cs
new file mode 100644
index 0000000..2292624
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2002Target.cs
@@ -0,0 +1,87 @@
+#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
+
+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..10e2dc4
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2003Target.cs
@@ -0,0 +1,593 @@
+#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
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+        [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;
+
+            readonly Dictionary<string, ToolInfo> m_Tools = new Dictionary<string, ToolInfo>();
+                Kernel m_Kernel;
+
+                /// <summary>
+                /// Gets or sets the solution version.
+                /// </summary>
+                /// <value>The solution version.</value>
+                protected string SolutionVersion
+                {
+                        get
+                        {
+                                return solutionVersion;
+                        }
+                        set
+                        {
+                                solutionVersion = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the product version.
+                /// </summary>
+                /// <value>The product version.</value>
+                protected string ProductVersion
+                {
+                        get
+                        {
+                                return productVersion;
+                        }
+                        set
+                        {
+                                productVersion = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the schema version.
+                /// </summary>
+                /// <value>The schema version.</value>
+                protected string SchemaVersion
+                {
+                        get
+                        {
+                                return schemaVersion;
+                        }
+                        set
+                        {
+                                schemaVersion = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the name of the version.
+                /// </summary>
+                /// <value>The name of the version.</value>
+                protected string VersionName
+                {
+                        get
+                        {
+                                return versionName;
+                        }
+                        set
+                        {
+                                versionName = value;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the version.
+                /// </summary>
+                /// <value>The version.</value>
+                protected VSVersion Version
+                {
+                        get
+                        {
+                                return version;
+                        }
+                        set
+                        {
+                                version = value;
+                        }
+                }
+
+                #endregion
+
+                #region Constructors
+
+                /// <summary>
+                /// Initializes a new instance of the <see cref="VS2003Target"/> class.
+                /// </summary>
+                public VS2003Target()
+                {
+                        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 = 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));
+
+                        using(ps)
+                        {
+                                ps.WriteLine("<VisualStudioProject>");
+                                ps.WriteLine("    <{0}", toolInfo.XmlTag);
+                                ps.WriteLine("\t\t\t\tProjectType = \"Local\"");
+                                ps.WriteLine("\t\t\t\tProductVersion = \"{0}\"", ProductVersion);
+                                ps.WriteLine("\t\t\t\tSchemaVersion = \"{0}\"", 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(Version == VSVersion.VS70)
+                                {
+                                        ps.WriteLine("\t\t\t\t  NoStandardLibraries = \"false\"");
+                                }
+
+                                ps.WriteLine("\t\t\t\t  OutputType = \"{0}\"", project.Type);
+
+                                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(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 = solution.ProjectsTable[refr.Name];
+                                                ps.WriteLine("                    Project = \"{{{0}}}\"", refProject.Guid.ToString().ToUpper());
+                                                ps.WriteLine("                    Package = \"{0}\"", toolInfo.Guid.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", 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}", SolutionVersion);
+                                foreach(ProjectNode project in solution.Projects)
+                                {
+                                        if(!m_Tools.ContainsKey(project.Language))
+                                        {
+                                                throw new UnknownLanguageException("Unknown .NET language: " + project.Language);
+                                        }
+
+                                        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 = project.References[i];
+                                                if(solution.ProjectsTable.ContainsKey(refr.Name))
+                                                {
+                                                        ProjectNode refProject = 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 = 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", 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..9c70e26
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2005Target.cs
@@ -0,0 +1,147 @@
+#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
+
+using System;
+using System.IO;
+using System.Text;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+
+namespace Prebuild.Core.Targets
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    [Target("vs2005")]
+    public class VS2005Target : VSGenericTarget
+    {
+        #region Inner Classes
+
+        #endregion
+
+        #region Fields
+
+        string solutionVersion = "9.00";
+        string productVersion = "8.0.50727";
+        string schemaVersion = "2.0";
+        string versionName = "Visual C# 2005";
+        string name = "vs2005";
+
+        VSVersion version = VSVersion.VS80;
+
+        public override string SolutionTag
+        {
+            get { return "# Visual Studio 2005"; }
+        }
+
+        protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
+        {
+            return string.Empty;
+        }
+        /// <summary>
+        /// Gets or sets the solution version.
+        /// </summary>
+        /// <value>The solution version.</value>
+        public override string SolutionVersion
+        {
+            get
+            {
+                return solutionVersion;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the product version.
+        /// </summary>
+        /// <value>The product version.</value>
+        public override string ProductVersion
+        {
+            get
+            {
+                return productVersion;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the schema version.
+        /// </summary>
+        /// <value>The schema version.</value>
+        public override string SchemaVersion
+        {
+            get
+            {
+                return schemaVersion;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the name of the version.
+        /// </summary>
+        /// <value>The name of the version.</value>
+        public override string VersionName
+        {
+            get
+            {
+                return versionName;
+            }
+        }
+        /// <summary>
+        /// Gets or sets the version.
+        /// </summary>
+        /// <value>The version.</value>
+        public override VSVersion Version
+        {
+            get
+            {
+                return version;
+            }
+        }
+        /// <summary>
+        /// Gets the name.
+        /// </summary>
+        /// <value>The name.</value>
+        public override string Name
+        {
+            get
+            {
+                return name;
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VS2005Target"/> class.
+        /// </summary>
+        public VS2005Target() 
+            : base()
+        {          
+        }
+
+        #endregion
+    }
+}
diff --git a/Prebuild/src/Core/Targets/VS2008Target.cs b/Prebuild/src/Core/Targets/VS2008Target.cs
new file mode 100644
index 0000000..fee4f7f
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2008Target.cs
@@ -0,0 +1,127 @@
+using System;
+using System.IO;
+using System.Text;
+
+using Prebuild.Core.Attributes;
+using Prebuild.Core.Interfaces;
+using Prebuild.Core.Nodes;
+using Prebuild.Core.Utilities;
+using System.CodeDom.Compiler;
+
+namespace Prebuild.Core.Targets
+{
+
+        /// <summary>
+        /// 
+        /// </summary>
+        [Target("vs2008")]
+        public class VS2008Target : VSGenericTarget
+        {
+                #region Fields
+                string solutionVersion = "10.00";
+                string productVersion = "9.0.21022";
+                string schemaVersion = "2.0";
+                string versionName = "Visual Studio 2008";
+                string name = "vs2008";
+                VSVersion version = VSVersion.VS90;
+
+                /// <summary>
+                /// Gets or sets the solution version.
+                /// </summary>
+                /// <value>The solution version.</value>
+                public override string SolutionVersion
+                {
+                        get
+                        {
+                                return solutionVersion;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the product version.
+                /// </summary>
+                /// <value>The product version.</value>
+                public override string ProductVersion
+                {
+                        get
+                        {
+                                return productVersion;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the schema version.
+                /// </summary>
+                /// <value>The schema version.</value>
+                public override string SchemaVersion
+                {
+                        get
+                        {
+                                return schemaVersion;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the name of the version.
+                /// </summary>
+                /// <value>The name of the version.</value>
+                public override string VersionName
+                {
+                        get
+                        {
+                                return versionName;
+                        }
+                }
+                /// <summary>
+                /// Gets or sets the version.
+                /// </summary>
+                /// <value>The version.</value>
+                public override VSVersion Version
+                {
+                        get
+                        {
+                                return version;
+                        }
+                }
+                /// <summary>
+                /// Gets the name.
+                /// </summary>
+                /// <value>The name.</value>
+                public override string Name
+                {
+                        get
+                        {
+                                return name;
+                        }
+                }
+
+        protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)
+        {
+            switch (frameworkVersion)
+            {
+                case FrameworkVersion.v3_5:
+                    return "ToolsVersion=\"3.5\"";
+                case FrameworkVersion.v3_0:
+                    return "ToolsVersion=\"3.0\"";
+                default:
+                    return "ToolsVersion=\"2.0\"";
+            }
+        }
+
+        public override string SolutionTag
+        {
+            get { return "# Visual Studio 2008"; }
+        }
+
+            #endregion
+
+                #region Constructors
+
+                /// <summary>
+                /// Initializes a new instance of the <see cref="VS2005Target"/> class.
+                /// </summary>
+                public VS2008Target()
+                        : base()
+                {
+                }
+
+                #endregion
+        }
+}
diff --git a/Prebuild/src/Core/Targets/VS2010Target.cs b/Prebuild/src/Core/Targets/VS2010Target.cs
new file mode 100644
index 0000000..ea9f736
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VS2010Target.cs
@@ -0,0 +1,138 @@
+using System;

+using System.IO;

+using System.Text;

+

+using Prebuild.Core.Attributes;

+using Prebuild.Core.Interfaces;

+using Prebuild.Core.Nodes;

+using Prebuild.Core.Utilities;

+using System.CodeDom.Compiler;

+

+namespace Prebuild.Core.Targets

+{

+

+        /// <summary>

+        /// 

+        /// </summary>

+        [Target("vs2010")]

+        public class VS2010Target : VSGenericTarget

+        {

+                #region Fields

+                

+                string solutionVersion = "11.00";

+                string productVersion = "9.0.30729";

+                string schemaVersion = "2.0";

+                string versionName = "Visual Studio 2010";

+                string name = "vs2010";

+                VSVersion version = VSVersion.VS10;

+

+                #endregion

+                

+                #region Properties

+                

+                /// <summary>

+                /// Gets or sets the solution version.

+                /// </summary>

+                /// <value>The solution version.</value>

+                public override string SolutionVersion

+                {

+                        get

+                        {

+                                return solutionVersion;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the product version.

+                /// </summary>

+                /// <value>The product version.</value>

+                public override string ProductVersion

+                {

+                        get

+                        {

+                                return productVersion;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the schema version.

+                /// </summary>

+                /// <value>The schema version.</value>

+                public override string SchemaVersion

+                {

+                        get

+                        {

+                                return schemaVersion;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the name of the version.

+                /// </summary>

+                /// <value>The name of the version.</value>

+                public override string VersionName

+                {

+                        get

+                        {

+                                return versionName;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets or sets the version.

+                /// </summary>

+                /// <value>The version.</value>

+                public override VSVersion Version

+                {

+                        get

+                        {

+                                return version;

+                        }

+                }

+                

+                /// <summary>

+                /// Gets the name.

+                /// </summary>

+                /// <value>The name.</value>

+                public override string Name

+                {

+                        get

+                        {

+                                return name;

+                        }

+                }

+

+        protected override string GetToolsVersionXml(FrameworkVersion frameworkVersion)

+        {

+            switch (frameworkVersion)

+            {

+                case FrameworkVersion.v4_0:

+                case FrameworkVersion.v3_5:

+                        return "ToolsVersion=\"4.0\"";

+                case FrameworkVersion.v3_0:

+                    return "ToolsVersion=\"3.0\"";

+                default:

+                    return "ToolsVersion=\"2.0\"";

+            }

+        }

+

+        public override string SolutionTag

+        {

+            get { return "# Visual Studio 2010"; }

+        }

+

+            #endregion

+

+                #region Constructors

+

+                /// <summary>

+                /// Initializes a new instance of the <see cref="VS2005Target"/> class.

+                /// </summary>

+                public VS2010Target()

+                        : base()

+                {

+                }

+

+                #endregion

+        }

+}

diff --git a/Prebuild/src/Core/Targets/VSGenericTarget.cs b/Prebuild/src/Core/Targets/VSGenericTarget.cs
new file mode 100644
index 0000000..6969dd7
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VSGenericTarget.cs
@@ -0,0 +1,922 @@
+#region BSD License

+/*

+Copyright (c) 2008 Matthew Holmes (matthew@wildfiregames.com), John Anderson (sontek@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

+

+using System;

+using System.Collections.Generic;

+using System.IO;

+using Prebuild.Core.Interfaces;

+using Prebuild.Core.Nodes;

+using Prebuild.Core.Utilities;

+using System.CodeDom.Compiler;

+

+namespace Prebuild.Core.Targets

+{

+

+        /// <summary>

+        /// 

+        /// </summary>

+        public abstract class VSGenericTarget : ITarget

+        {

+                #region Fields

+

+                readonly Dictionary<string, ToolInfo> tools = new Dictionary<string, ToolInfo>();

+                Kernel kernel;

+                #endregion

+

+                #region Properties

+                /// <summary>

+                /// Gets or sets the solution version.

+                /// </summary>

+                /// <value>The solution version.</value>

+                public abstract string SolutionVersion { get; }

+                /// <summary>

+                /// Gets or sets the product version.

+                /// </summary>

+                /// <value>The product version.</value>

+                public abstract string ProductVersion { get; }

+                /// <summary>

+                /// Gets or sets the schema version.

+                /// </summary>

+                /// <value>The schema version.</value>

+                public abstract string SchemaVersion { get; }

+                /// <summary>

+                /// Gets or sets the name of the version.

+                /// </summary>

+                /// <value>The name of the version.</value>

+                public abstract string VersionName { get; }

+                /// <summary>

+                /// Gets or sets the version.

+                /// </summary>

+                /// <value>The version.</value>

+                public abstract VSVersion Version { get; }

+                /// <summary>

+                /// Gets the name.

+                /// </summary>

+                /// <value>The name.</value>

+                public abstract string Name { get; }

+

+                protected abstract string GetToolsVersionXml(FrameworkVersion version);

+                public abstract string SolutionTag { get; }

+

+                #endregion

+

+                #region Constructors

+

+                /// <summary>

+                /// Initializes a new instance of the <see cref="VSGenericTarget"/> class.

+                /// </summary>

+                protected VSGenericTarget()

+                {

+                        tools["C#"] = new ToolInfo("C#", "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}", "csproj", "CSHARP", "$(MSBuildBinPath)\\Microsoft.CSHARP.Targets");

+                        tools["Database"] = new ToolInfo("Database", "{4F174C21-8C12-11D0-8340-0000F80270F8}", "dbp", "UNKNOWN");

+                        tools["Boo"] = new ToolInfo("Boo", "{45CEA7DC-C2ED-48A6-ACE0-E16144C02365}", "booproj", "Boo", "$(BooBinPath)\\Boo.Microsoft.Build.targets");

+                        tools["VisualBasic"] = new ToolInfo("VisualBasic", "{F184B08F-C81C-45F6-A57F-5ABD9991F28F}", "vbproj", "VisualBasic", "$(MSBuildBinPath)\\Microsoft.VisualBasic.Targets");

+                        tools["Folder"] = new ToolInfo("Folder", "{2150E333-8FDC-42A3-9474-1A3956D46DE8}", null, null);

+                }

+

+                #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)

+                                {

+                                        kernel.Log.Write(LogType.Warning, "Could not resolve reference path: {0}", node.Path);

+                                }

+                        }

+

+                        return ret;

+                }

+

+                private static ProjectNode FindProjectInSolution(string name, SolutionNode solution)

+                {

+                        SolutionNode node = solution;

+

+                        while (node.Parent is SolutionNode)

+                                node = node.Parent as SolutionNode;

+

+                        return FindProjectInSolutionRecursively(name, node);

+                }

+

+                private static ProjectNode FindProjectInSolutionRecursively(string name, SolutionNode solution)

+                {

+                        if (solution.ProjectsTable.ContainsKey(name))

+                                return solution.ProjectsTable[name];

+

+                        foreach (SolutionNode child in solution.Solutions)

+                        {

+                                ProjectNode node = FindProjectInSolutionRecursively(name, child);

+                                if (node != null)

+                                        return node;

+                        }

+

+                        return null;

+                }

+

+                private void WriteProject(SolutionNode solution, ProjectNode project)

+                {

+                        if (!tools.ContainsKey(project.Language))

+                        {

+                                throw new UnknownLanguageException("Unknown .NET language: " + project.Language);

+                        }

+

+                        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\" {0}>", GetToolsVersionXml(project.FrameworkVersion));

+                                ps.WriteLine("  <PropertyGroup>");

+                                ps.WriteLine("    <ProjectType>Local</ProjectType>");

+                                ps.WriteLine("    <ProductVersion>{0}</ProductVersion>", ProductVersion);

+                                ps.WriteLine("    <SchemaVersion>{0}</SchemaVersion>", SchemaVersion);

+                                ps.WriteLine("    <ProjectGuid>{{{0}}}</ProjectGuid>", project.Guid.ToString().ToUpper());

+

+                                // Visual Studio has a hard coded guid for the project type

+                                if (project.Type == ProjectType.Web)

+                                        ps.WriteLine("    <ProjectTypeGuids>{349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc}</ProjectTypeGuids>");

+                                ps.WriteLine("    <Configuration Condition=\" '$(Configuration)' == '' \">Debug</Configuration>");

+                                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>");

+                                ps.WriteLine("    <TargetFrameworkVersion>{0}</TargetFrameworkVersion>", project.FrameworkVersion.ToString().Replace("_", "."));

+

+                                ps.WriteLine("    <OutputType>{0}</OutputType>", project.Type == ProjectType.Web ? ProjectType.Library.ToString() : project.Type.ToString());

+                                ps.WriteLine("    <AppDesignerFolder>{0}</AppDesignerFolder>", project.DesignerFolder);

+                                ps.WriteLine("    <RootNamespace>{0}</RootNamespace>", project.RootNamespace);

+                                ps.WriteLine("    <StartupObject>{0}</StartupObject>", project.StartupObject);

+                                if (string.IsNullOrEmpty(project.DebugStartParameters))

+                                {

+                                        ps.WriteLine("    <StartArguments>{0}</StartArguments>", project.DebugStartParameters);

+                                }

+                                ps.WriteLine("    <FileUpgradeFlags>");

+                                ps.WriteLine("    </FileUpgradeFlags>");

+

+                                ps.WriteLine("  </PropertyGroup>");

+

+                                foreach (ConfigurationNode conf in project.Configurations)

+                                {

+                                        ps.Write("      <PropertyGroup ");

+                                        ps.WriteLine("Condition=\" '$(Configuration)|$(Platform)' == '{0}|{1}' \">", conf.Name, conf.Platform);

+                                        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>", Helper.NormalizePath(conf.Options["XmlDocFile"].ToString()));

+                                        ps.WriteLine("    <DebugSymbols>{0}</DebugSymbols>", conf.Options["DebugInformation"]);

+                                        ps.WriteLine("    <FileAlignment>{0}</FileAlignment>", conf.Options["FileAlignment"]);

+                                        ps.WriteLine("    <Optimize>{0}</Optimize>", conf.Options["OptimizeCode"]);

+                                        if (project.Type != ProjectType.Web)

+                                                ps.WriteLine("    <OutputPath>{0}</OutputPath>",

+                                                             Helper.EndPath(Helper.NormalizePath(conf.Options["OutputPath"].ToString())));

+                                        else

+                                                ps.WriteLine("    <OutputPath>{0}</OutputPath>",

+                                                             Helper.EndPath(Helper.NormalizePath("bin\\")));

+

+                                        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("    <NoStdLib>{0}</NoStdLib>", conf.Options["NoStdLib"]);

+                                        ps.WriteLine("    <NoWarn>{0}</NoWarn>", conf.Options["SuppressWarnings"]);

+                                        ps.WriteLine("    <PlatformTarget>{0}</PlatformTarget>", conf.Platform);

+                                        ps.WriteLine("  </PropertyGroup>");

+                                }

+

+                                //ps.WriteLine("          </Settings>");

+

+                                Dictionary<ReferenceNode, ProjectNode> projectReferences = new Dictionary<ReferenceNode, ProjectNode>();

+                                List<ReferenceNode> otherReferences = new List<ReferenceNode>();

+

+                                foreach (ReferenceNode refr in project.References)

+                                {

+                                        ProjectNode projectNode = FindProjectInSolution(refr.Name, solution);

+

+                                        if (projectNode == null)

+                                                otherReferences.Add(refr);

+                                        else

+                                                projectReferences.Add(refr, projectNode);

+                                }

+                                // Assembly References

+                                ps.WriteLine("  <ItemGroup>");

+

+                                foreach (ReferenceNode refr in otherReferences)

+                                {

+                                        ps.Write("        <Reference");

+                                        ps.Write(" Include=\"");

+                                        ps.Write(refr.Name);

+                                        ps.WriteLine("\" >");

+                                        ps.Write("                <Name>");

+                                        ps.Write(refr.Name);

+                                        ps.WriteLine("</Name>");

+                                                                                

+                                        if(!String.IsNullOrEmpty(refr.Path))

+                                        {

+                                                // Use absolute path to assembly (for determining assembly type)

+                                                string absolutePath = Path.Combine(project.FullPath, refr.Path);

+                                                if(File.Exists(Helper.MakeFilePath(absolutePath, refr.Name, "exe"))) {

+                                                        // Assembly is an executable (exe)

+                                                        ps.WriteLine("          <HintPath>{0}</HintPath>", Helper.MakeFilePath(refr.Path, refr.Name, "exe"));

+                                                } else if(File.Exists(Helper.MakeFilePath(absolutePath, refr.Name, "dll"))) {

+                                                        // Assembly is an library (dll)                                                 

+                                                        ps.WriteLine("          <HintPath>{0}</HintPath>", Helper.MakeFilePath(refr.Path, refr.Name, "dll"));

+                                                } else {

+                                                        string referencePath = Helper.MakeFilePath(refr.Path, refr.Name, "dll");

+                                                        kernel.Log.Write(LogType.Warning, "Reference \"{0}\": The specified file doesn't exist.", referencePath);

+                                                        ps.WriteLine("          <HintPath>{0}</HintPath>", Helper.MakeFilePath(refr.Path, refr.Name, "dll"));

+                                                }

+                                        }

+                                        

+                                        ps.WriteLine("          <Private>{0}</Private>", refr.LocalCopy);

+                                        ps.WriteLine("    </Reference>");

+                                }

+                                ps.WriteLine("  </ItemGroup>");

+

+                                //Project References

+                                ps.WriteLine("  <ItemGroup>");

+                                foreach (KeyValuePair<ReferenceNode, ProjectNode> pair in projectReferences)

+                                {

+                                        ToolInfo tool = tools[pair.Value.Language];

+                                        if (tools == null)

+                                                throw new UnknownLanguageException();

+

+                                        string path =

+                                                Helper.MakePathRelativeTo(project.FullPath,

+                                                                          Helper.MakeFilePath(pair.Value.FullPath, pair.Value.Name, tool.FileExtension));

+                                        ps.WriteLine("    <ProjectReference Include=\"{0}\">", path);

+

+                                        // TODO: Allow reference to visual basic projects

+                                        ps.WriteLine("          <Name>{0}</Name>", pair.Value.Name);

+                                        ps.WriteLine("          <Project>{0}</Project>", pair.Value.Guid.ToString("B").ToUpper());

+                                        ps.WriteLine("          <Package>{0}</Package>", tool.Guid.ToUpper());

+

+                                        //This is the Copy Local flag in VS

+                                        ps.WriteLine("          <Private>{0}</Private>", pair.Key.LocalCopy);

+

+                                        ps.WriteLine("    </ProjectReference>");

+                                }

+                                ps.WriteLine("  </ItemGroup>");

+

+                                //                                ps.WriteLine("        </Build>");

+                                ps.WriteLine("  <ItemGroup>");

+

+                                //                                ps.WriteLine("          <Include>");

+                                List<string> list = new List<string>();

+

+                                foreach (string path in project.Files)

+                                {

+                                        string lower = path.ToLower();

+                                        if (lower.EndsWith(".resx"))

+                                        {

+                                                string codebehind = String.Format("{0}.Designer{1}", path.Substring(0, path.LastIndexOf('.')), toolInfo.LanguageExtension);

+                                                if (!list.Contains(codebehind))

+                                                        list.Add(codebehind);

+                                        }

+

+                                }

+                                

+                                foreach (string filePath in project.Files)

+                                {

+                                        //                                      if (file == "Properties\\Bind.Designer.cs")

+                                        //                                      {

+                                        //                                              Console.WriteLine("Wait a minute!");

+                                        //                                              Console.WriteLine(project.Files.GetSubType(file).ToString());

+                                        //                                      }

+                                        SubType subType = project.Files.GetSubType(filePath);

+                                        

+                                        // Visual Studio chokes on file names if forward slash is used as a path separator

+                                        // instead of backslash.  So we must make sure that all file paths written to the

+                                        // project file use \ as a path separator.

+                                        string file = filePath.Replace(@"/", @"\");

+

+                                        if (subType != SubType.Code && subType != SubType.Settings && subType != SubType.Designer

+                                            && subType != SubType.CodeBehind)

+                                        {

+                                                ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file.Substring(0, file.LastIndexOf('.')) + ".resx");

+                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file));

+                                                ps.WriteLine("          <SubType>Designer</SubType>");

+                                                ps.WriteLine("    </EmbeddedResource>");

+                                                //

+                                        }

+

+                                        if (subType == SubType.Designer)

+                                        {

+                                                ps.WriteLine("    <EmbeddedResource Include=\"{0}\">", file);

+                                                

+                                                string autogen_name = file.Substring(0, file.LastIndexOf('.')) + ".Designer.cs";

+                                                string dependent_name = filePath.Substring(0, file.LastIndexOf('.')) + ".cs";

+

+                                                // Check for a parent .cs file with the same name as this designer file

+                                                if (File.Exists(Helper.NormalizePath(dependent_name)))

+                                                {

+                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(dependent_name));

+                                                }

+                                                else

+                                                {

+                                                        ps.WriteLine("          <Generator>ResXFileCodeGenerator</Generator>");

+                                                        ps.WriteLine("          <LastGenOutput>{0}</LastGenOutput>", Path.GetFileName(autogen_name));

+                                                        ps.WriteLine("          <SubType>" + subType + "</SubType>");

+                                                }

+                                                

+                                                ps.WriteLine("    </EmbeddedResource>");

+                                                if (File.Exists(Helper.NormalizePath(autogen_name)))

+                                                {

+                                                        ps.WriteLine("    <Compile Include=\"{0}\">", autogen_name);

+                                                        //ps.WriteLine("          <DesignTime>True</DesignTime>");

+

+                                                        // If a parent .cs file exists, link this autogen file to it. Otherwise link

+                                                        // to the designer file

+                                                        if (File.Exists(dependent_name))

+                                                        {

+                                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(dependent_name));

+                                                        }

+                                                        else

+                                                        {

+                                                                ps.WriteLine("          <AutoGen>True</AutoGen>");

+                                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(filePath));

+                                                        }

+                                                        

+                                                        ps.WriteLine("    </Compile>");

+                                                }

+                                                list.Add(autogen_name);

+                                        }

+                                        if (subType == SubType.Settings)

+                                        {

+                                                ps.Write("        <{0} ", project.Files.GetBuildAction(filePath));

+                                                ps.WriteLine("Include=\"{0}\">", file);

+                                                string fileName = Path.GetFileName(filePath);

+                                                if (project.Files.GetBuildAction(filePath) == BuildAction.None)

+                                                {

+                                                        ps.WriteLine("          <Generator>SettingsSingleFileGenerator</Generator>");

+                                                        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>", Path.GetFileName(fileNameShorter + ".settings"));

+                                                }

+                                                ps.WriteLine("    </{0}>", project.Files.GetBuildAction(filePath));

+                                        }

+                                        else if (subType != SubType.Designer)

+                                        {

+                                                string path = Helper.NormalizePath(file);

+                                                string path_lower = path.ToLower();

+

+                                                if (!list.Contains(filePath))

+                                                {

+                                                        ps.Write("        <{0} ", project.Files.GetBuildAction(filePath));

+

+                                                        int startPos = 0;

+                                                        if (project.Files.GetPreservePath(filePath))

+                                                        {

+                                                                while ((@"./\").IndexOf(file.Substring(startPos, 1)) != -1)

+                                                                        startPos++;

+

+                                                        }

+                                                        else

+                                                        {

+                                                                startPos = file.LastIndexOf(Path.GetFileName(path));

+                                                        }

+                                                        

+                                                        // be sure to write out the path with backslashes so VS recognizes

+                                                        // the file properly.

+                                                        ps.WriteLine("Include=\"{0}\">", file);

+

+                                                        int last_period_index = file.LastIndexOf('.');

+                                                        string short_file_name = file.Substring(0, last_period_index);

+                                                        string extension = Path.GetExtension(path);

+                                                        // make this upper case, so that when File.Exists tests for the

+                                                        // existence of a designer file on a case-sensitive platform,

+                                                        // it is correctly identified.

+                                                        string designer_format = string.Format(".Designer{0}", extension);

+

+                                                        if (path_lower.EndsWith(designer_format.ToLowerInvariant()))

+                                                        {

+                                                                int designer_index = path.IndexOf(designer_format);

+                                                                string file_name = path.Substring(0, designer_index);

+

+                                                                // There are two corrections to the next lines:

+                                                                // 1. Fix the connection between a designer file and a form

+                                                                //        or usercontrol that don't have an associated resx file.

+                                                                // 2. Connect settings files to associated designer files.

+                                                                if (File.Exists(file_name + extension))

+                                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file_name + extension));

+                                                                else if (File.Exists(file_name + ".resx"))

+                                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file_name + ".resx"));

+                                                                else if (File.Exists(file_name + ".settings"))

+                                                                {

+                                                                        ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(file_name + ".settings"));

+                                                                        ps.WriteLine("          <AutoGen>True</AutoGen>");

+                                                                        ps.WriteLine("          <DesignTimeSharedInput>True</DesignTimeSharedInput>");

+                                                                }

+                                                        }

+                                                        else if (subType == SubType.CodeBehind)

+                                                        {

+                                                                ps.WriteLine("          <DependentUpon>{0}</DependentUpon>", Path.GetFileName(short_file_name));

+                                                        }

+                                                        if (project.Files.GetIsLink(filePath))

+                                                        {

+                                                                string alias = project.Files.GetLinkPath(filePath);

+                                                                alias += file.Substring(startPos);

+                                                                alias = Helper.NormalizePath(alias);

+                                                                ps.WriteLine("          <Link>{0}</Link>", alias);

+                                                        }

+                                                        else if (project.Files.GetBuildAction(filePath) != BuildAction.None)

+                                                        {

+                                                                if (project.Files.GetBuildAction(filePath) != BuildAction.EmbeddedResource)

+                                                                {

+                                                                        ps.WriteLine("          <SubType>{0}</SubType>", subType);

+                                                                }

+                                                        }

+

+                                                        if (project.Files.GetCopyToOutput(filePath) != CopyToOutput.Never)

+                                                        {

+                                                                ps.WriteLine("          <CopyToOutputDirectory>{0}</CopyToOutputDirectory>", project.Files.GetCopyToOutput(filePath));

+                                                        }

+

+                                                        ps.WriteLine("    </{0}>", project.Files.GetBuildAction(filePath));

+                                                }

+                                        }

+                                }

+

+                                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("</Project>");

+                        }

+                        #endregion

+

+                        #region User File

+

+                        ps = new StreamWriter(projectFile + ".user");

+                        using (ps)

+                        {

+                                // Get the first configuration from the project.

+                                ConfigurationNode firstConfiguration = null;

+

+                                if (project.Configurations.Count > 0)

+                                {

+                                        firstConfiguration = project.Configurations[0];

+                                }

+

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

+

+                                if (firstConfiguration != null)

+                                {

+                                        ps.WriteLine("    <Configuration Condition=\" '$(Configuration)' == '' \">{0}</Configuration>", firstConfiguration.Name);

+                                        ps.WriteLine("    <Platform Condition=\" '$(Platform)' == '' \">{0}</Platform>", firstConfiguration.Platform);

+                                }

+

+                                ps.WriteLine("    <ReferencePath>{0}</ReferencePath>", MakeRefPath(project));

+                                ps.WriteLine("    <LastOpenVersion>{0}</LastOpenVersion>", 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}|{1}' \"", conf.Name, conf.Platform);

+                                        ps.WriteLine(" />");

+                                }

+                                ps.WriteLine("</Project>");

+                        }

+                        #endregion

+

+                        kernel.CurrentWorkingDirectory.Pop();

+                }

+

+                private void WriteSolution(SolutionNode solution, bool writeSolutionToDisk)

+                {

+                        kernel.Log.Write("Creating {0} solution and project files", VersionName);

+

+                        foreach (SolutionNode child in solution.Solutions)

+                        {

+                                kernel.Log.Write("...Creating folder: {0}", child.Name);

+                                WriteSolution(child, false);

+                        }

+

+                        foreach (ProjectNode project in solution.Projects)

+                        {

+                                kernel.Log.Write("...Creating project: {0}", project.Name);

+                                WriteProject(solution, project);

+                        }

+

+                        foreach (DatabaseProjectNode project in solution.DatabaseProjects)

+                        {

+                                kernel.Log.Write("...Creating database project: {0}", project.Name);

+                                WriteDatabaseProject(solution, project);

+                        }

+

+                        if (writeSolutionToDisk) // only write main solution

+                        {

+                                kernel.Log.Write("");

+                                string solutionFile = Helper.MakeFilePath(solution.FullPath, solution.Name, "sln");

+                                

+                                using (StreamWriter ss = new StreamWriter(solutionFile))

+                                {

+                                        kernel.CurrentWorkingDirectory.Push();

+                                        Helper.SetCurrentDir(Path.GetDirectoryName(solutionFile));

+

+                                        ss.WriteLine("Microsoft Visual Studio Solution File, Format Version {0}", SolutionVersion);

+                                        ss.WriteLine(SolutionTag);

+

+                                        WriteProjectDeclarations(ss, solution, solution);

+

+                                        ss.WriteLine("Global");

+

+                                        ss.WriteLine("\tGlobalSection(SolutionConfigurationPlatforms) = preSolution");

+                                        foreach (ConfigurationNode conf in solution.Configurations)

+                                        {

+                                                ss.WriteLine("\t\t{0} = {0}", conf.NameAndPlatform);

+                                        }

+                                        ss.WriteLine("\tEndGlobalSection");

+

+                                        ss.WriteLine("\tGlobalSection(ProjectConfigurationPlatforms) = postSolution");

+                                        WriteConfigurationLines(solution.Configurations, solution, ss);

+                                        ss.WriteLine("\tEndGlobalSection");

+

+                                        if (solution.Solutions.Count > 0)

+                                        {

+                                                ss.WriteLine("\tGlobalSection(NestedProjects) = preSolution");

+                                                foreach (SolutionNode embeddedSolution in solution.Solutions)

+                                                {

+                                                        WriteNestedProjectMap(ss, embeddedSolution);

+                                                }

+                                                ss.WriteLine("\tEndGlobalSection");

+                                        }

+

+                                        ss.WriteLine("EndGlobal");

+                                }

+

+                                kernel.CurrentWorkingDirectory.Pop();

+                        }

+                }

+

+                private void WriteProjectDeclarations(TextWriter writer, SolutionNode actualSolution, SolutionNode embeddedSolution)

+                {

+                        foreach (SolutionNode childSolution in embeddedSolution.Solutions)

+                        {

+                                WriteEmbeddedSolution(writer, childSolution);

+                                WriteProjectDeclarations(writer, actualSolution, childSolution);

+                        }

+

+                        foreach (ProjectNode project in embeddedSolution.Projects)

+                        {

+                                WriteProject(actualSolution, writer, project);

+                        }

+

+                        foreach (DatabaseProjectNode dbProject in embeddedSolution.DatabaseProjects)

+                        {

+                                WriteProject(actualSolution, writer, dbProject);

+                        }

+

+                        if (actualSolution.Guid == embeddedSolution.Guid)

+                        {

+                                WriteSolutionFiles(actualSolution, writer);

+                        }

+                }

+

+                private static void WriteNestedProjectMap(TextWriter writer, SolutionNode embeddedSolution)

+                {

+                        foreach (ProjectNode project in embeddedSolution.Projects)

+                        {

+                                WriteNestedProject(writer, embeddedSolution, project.Guid);

+                        }

+

+                        foreach (DatabaseProjectNode dbProject in embeddedSolution.DatabaseProjects)

+                        {

+                                WriteNestedProject(writer, embeddedSolution, dbProject.Guid);

+                        }

+

+                        foreach (SolutionNode child in embeddedSolution.Solutions)

+                        {

+                                WriteNestedProject(writer, embeddedSolution, child.Guid);

+                                WriteNestedProjectMap(writer, child);

+                        }

+                }

+

+                private static void WriteNestedProject(TextWriter writer, SolutionNode solution, Guid projectGuid)

+                {

+                        WriteNestedFolder(writer, solution.Guid, projectGuid);

+                }

+

+                private static void WriteNestedFolder(TextWriter writer, Guid parentGuid, Guid childGuid)

+                {

+                        writer.WriteLine("\t\t{0} = {1}",

+                                         childGuid.ToString("B").ToUpper(),

+                                         parentGuid.ToString("B").ToUpper());

+                }

+

+                private static void WriteConfigurationLines(IEnumerable<ConfigurationNode> configurations, SolutionNode solution, TextWriter ss)

+                {

+                        foreach (ProjectNode project in solution.Projects)

+                        {

+                                foreach (ConfigurationNode conf in configurations)

+                                {

+                                        ss.WriteLine("\t\t{0}.{1}.ActiveCfg = {1}",

+                                                     project.Guid.ToString("B").ToUpper(),

+                                                     conf.NameAndPlatform);

+

+                                        ss.WriteLine("\t\t{0}.{1}.Build.0 = {1}",

+                                                     project.Guid.ToString("B").ToUpper(),

+                                                     conf.NameAndPlatform);

+                                }

+                        }

+

+                        foreach (SolutionNode child in solution.Solutions)

+                        {

+                                WriteConfigurationLines(configurations, child, ss);

+                        }

+                }

+

+                private void WriteSolutionFiles(SolutionNode solution, TextWriter ss)

+                {

+                        if(solution.Files != null && solution.Files.Count > 0)

+                                WriteProject(ss, "Folder", solution.Guid, "Solution Files", "Solution Files", solution.Files);

+                }

+

+                private void WriteEmbeddedSolution(TextWriter writer, SolutionNode embeddedSolution)

+                {

+                        WriteProject(writer, "Folder", embeddedSolution.Guid, embeddedSolution.Name, embeddedSolution.Name, embeddedSolution.Files);

+                }

+

+                private void WriteProject(SolutionNode solution, TextWriter ss, ProjectNode project)

+                {

+                        WriteProject(ss, solution, project.Language, project.Guid, project.Name, project.FullPath);

+                }

+

+                private void WriteProject(SolutionNode solution, TextWriter ss, DatabaseProjectNode dbProject)

+                {

+                        if (solution.Files != null && solution.Files.Count > 0)

+                                WriteProject(ss, solution, "Database", dbProject.Guid, dbProject.Name, dbProject.FullPath);

+                }

+

+                const string ProjectDeclarationBeginFormat = "Project(\"{0}\") = \"{1}\", \"{2}\", \"{3}\"";

+                const string ProjectDeclarationEndFormat = "EndProject";

+

+                private void WriteProject(TextWriter ss, SolutionNode solution, string language, Guid guid, string name, string projectFullPath)

+                {

+                        if (!tools.ContainsKey(language))

+                                throw new UnknownLanguageException("Unknown .NET language: " + language);

+

+                        ToolInfo toolInfo = tools[language];

+

+                        string path = Helper.MakePathRelativeTo(solution.FullPath, projectFullPath);

+

+                        path = Helper.MakeFilePath(path, name, toolInfo.FileExtension);

+

+                        WriteProject(ss, language, guid, name, path);

+                }

+

+                private void WriteProject(TextWriter writer, string language, Guid projectGuid, string name, string location)

+                {

+                        WriteProject(writer, language, projectGuid, name, location, null);

+                }

+

+                private void WriteProject(TextWriter writer, string language, Guid projectGuid, string name, string location, FilesNode files)

+                {

+                        if (!tools.ContainsKey(language))

+                                throw new UnknownLanguageException("Unknown .NET language: " + language);

+

+                        ToolInfo toolInfo = tools[language];

+

+                        writer.WriteLine(ProjectDeclarationBeginFormat,

+                                         toolInfo.Guid,

+                                         name,

+                                         location,

+                                         projectGuid.ToString("B").ToUpper());

+

+                        if (files != null)

+                        {

+                                writer.WriteLine("\tProjectSection(SolutionItems) = preProject");

+

+                                foreach (string file in files)

+                                        writer.WriteLine("\t\t{0} = {0}", file);

+

+                                writer.WriteLine("\tEndProjectSection");

+                        }

+

+                        writer.WriteLine(ProjectDeclarationEndFormat);

+                }

+

+                private void WriteDatabaseProject(SolutionNode solution, DatabaseProjectNode project)

+                {

+                        string projectFile = Helper.MakeFilePath(project.FullPath, project.Name, "dbp");

+                        IndentedTextWriter ps = new IndentedTextWriter(new StreamWriter(projectFile), "   ");

+

+                        kernel.CurrentWorkingDirectory.Push();

+

+                        Helper.SetCurrentDir(Path.GetDirectoryName(projectFile));

+

+                        using (ps)

+                        {

+                                ps.WriteLine("# Microsoft Developer Studio Project File - Database Project");

+                                ps.WriteLine("Begin DataProject = \"{0}\"", project.Name);

+                                ps.Indent++;

+                                ps.WriteLine("MSDTVersion = \"80\"");

+                                // TODO: Use the project.Files property

+                                if (ContainsSqlFiles(Path.GetDirectoryName(projectFile)))

+                                        WriteDatabaseFoldersAndFiles(ps, Path.GetDirectoryName(projectFile));

+

+                                ps.WriteLine("Begin DBRefFolder = \"Database References\"");

+                                ps.Indent++;

+                                foreach (DatabaseReferenceNode reference in project.References)

+                                {

+                                        ps.WriteLine("Begin DBRefNode = \"{0}\"", reference.Name);

+                                        ps.Indent++;

+                                        ps.WriteLine("ConnectStr = \"{0}\"", reference.ConnectionString);

+                                        ps.WriteLine("Provider = \"{0}\"", reference.ProviderId.ToString("B").ToUpper());

+                                        //ps.WriteLine("Colorizer = 5");

+                                        ps.Indent--;

+                                        ps.WriteLine("End");

+                                }

+                                ps.Indent--;

+                                ps.WriteLine("End");

+                                ps.Indent--;

+                                ps.WriteLine("End");

+

+                                ps.Flush();

+                        }

+

+                        kernel.CurrentWorkingDirectory.Pop();

+                }

+

+                private static bool ContainsSqlFiles(string folder)

+                {

+                        if(Directory.GetFiles(folder, "*.sql").Length > 0)

+                                return true; // if the folder contains 1 .sql file, that's good enough

+

+                        foreach (string child in Directory.GetDirectories(folder))

+                        {

+                                if (ContainsSqlFiles(child))

+                                        return true; // if 1 child folder contains a .sql file, still good enough

+                        }

+

+                        return false;

+                }

+

+                private static void WriteDatabaseFoldersAndFiles(IndentedTextWriter writer, string folder)

+                {

+                        foreach (string child in Directory.GetDirectories(folder))

+                        {

+                                if (ContainsSqlFiles(child))

+                                {

+                                        writer.WriteLine("Begin Folder = \"{0}\"", Path.GetFileName(child));

+                                        writer.Indent++;

+                                        WriteDatabaseFoldersAndFiles(writer, child);

+                                        writer.Indent--;

+                                        writer.WriteLine("End");

+                                }

+                        }

+                        foreach (string file in Directory.GetFiles(folder, "*.sql"))

+                        {

+                                writer.WriteLine("Script = \"{0}\"", Path.GetFileName(file));

+                        }

+                }

+

+                private void CleanProject(ProjectNode project)

+                {

+                        kernel.Log.Write("...Cleaning project: {0}", project.Name);

+

+                        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", 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, true);

+                        }

+                        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;

+                }

+

+                #endregion

+        }

+}

diff --git a/Prebuild/src/Core/Targets/VSVersion.cs b/Prebuild/src/Core/Targets/VSVersion.cs
new file mode 100644
index 0000000..699b5ca
--- /dev/null
+++ b/Prebuild/src/Core/Targets/VSVersion.cs
@@ -0,0 +1,54 @@
+#region BSD License
+/*
+Copyright (c) 2008-2009 Matthew Holmes (matthew@wildfiregames.com), Dan Moorehead (dan05a@gmail.com), John Anderson (sontek@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
+
+namespace Prebuild.Core.Targets
+{
+        /// <summary>
+        /// 
+        /// </summary>
+        public enum VSVersion
+        {
+                /// <summary>
+                /// Visual Studio 2002 
+                /// </summary>
+                VS70,
+                /// <summary>
+                /// Visual Studio 2003 
+                /// </summary>
+                VS71,
+                /// <summary>
+                /// Visual Studio 2005 
+                /// </summary>
+                VS80,
+                /// <summary>
+                /// Visual Studio 2008 
+                /// </summary>
+                VS90,
+                /// <summary>
+                /// Visual Studio 2010 
+                /// </summary>
+                VS10
+        }
+}
diff --git a/Prebuild/src/Core/Targets/XcodeTarget.cs b/Prebuild/src/Core/Targets/XcodeTarget.cs
new file mode 100644
index 0000000..5393cec
--- /dev/null
+++ b/Prebuild/src/Core/Targets/XcodeTarget.cs
@@ -0,0 +1,594 @@
+#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
+
+using System;
+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("xcode")]
+    public class XcodeTarget : 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}/", 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 += 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 fileRef = FindFileReference(refr.Name, project);
+                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;
+        }
+
+        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, 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)
+                {
+                    ss.WriteLine("                <include name=\"{0}", Helper.NormalizePath(Helper.MakePathRelativeTo(project.FullPath, BuildReference(solution, refr)) + "\" />", '/'));
+                }
+                ss.WriteLine("            </references>");
+
+                ss.WriteLine("        </csc>");
+                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 Xcode 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("");
+            DirectoryInfo directoryInfo = new DirectoryInfo(Path.Combine(solution.FullPath, solution.Name + ".xcodeproj"));
+            if (!directoryInfo.Exists)
+            {
+                directoryInfo.Create();
+            }
+            string combFile = Helper.MakeFilePath(Path.Combine(solution.FullPath, solution.Name + ".xcodeproj"), "project", "pbxproj");
+            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 Xcode 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 "xcode";
+            }
+        }
+
+        #endregion
+    }
+}